/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "pbd/convert.h"
#include "pbd/debug.h"
#include "pbd/error.h"
+#include "pbd/replace_all.h"
#include "pbd/xml++.h"
#include "gtkmm2ext/actions.h"
#include "gtkmm2ext/keyboard.h"
#include "gtkmm2ext/utils.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace Glib;
using namespace Gtkmm2ext;
using namespace PBD;
-ActionMap Gtkmm2ext::Actions; /* global. Gulp */
list<Bindings*> Bindings::bindings; /* global. Gulp */
-uint32_t Bindings::_ignored_state = 0;
+PBD::Signal1<void,Bindings*> Bindings::BindingsChanged;
+
+template <typename IteratorValueType>
+struct ActionNameRegistered
+{
+ ActionNameRegistered(std::string const& name)
+ : action_name(name)
+ {}
+
+ bool operator()(IteratorValueType elem) const {
+ return elem.second.action_name == action_name;
+ }
+ std::string const& action_name;
+};
MouseButton::MouseButton (uint32_t state, uint32_t keycode)
{
- uint32_t ignore = Bindings::ignored_state();
+ uint32_t ignore = ~Keyboard::RelevantModifierKeyMask;
- if (gdk_keyval_is_upper (keycode) && gdk_keyval_is_lower (keycode)) {
- /* key is not subject to case, so ignore SHIFT
- */
- ignore |= GDK_SHIFT_MASK;
- }
+ /* this is a slightly wierd test that relies on
+ * gdk_keyval_is_{upper,lower}() returning true for keys that have no
+ * case-sensitivity. This covers mostly non-alphanumeric keys.
+ */
+
+ if (gdk_keyval_is_upper (keycode) && gdk_keyval_is_lower (keycode)) {
+ /* key is not subject to case, so ignore SHIFT
+ */
+ ignore |= GDK_SHIFT_MASK;
+ }
- _val = (state & ~ignore);
- _val <<= 32;
- _val |= keycode;
+ _val = (state & ~ignore);
+ _val <<= 32;
+ _val |= keycode;
};
bool
MouseButton::make_button (const string& str, MouseButton& b)
{
- int s = 0;
+ int s = 0;
- if (str.find ("Primary") != string::npos) {
- s |= Keyboard::PrimaryModifier;
- }
+ if (str.find ("Primary") != string::npos) {
+ s |= Keyboard::PrimaryModifier;
+ }
- if (str.find ("Secondary") != string::npos) {
- s |= Keyboard::SecondaryModifier;
- }
+ if (str.find ("Secondary") != string::npos) {
+ s |= Keyboard::SecondaryModifier;
+ }
- if (str.find ("Tertiary") != string::npos) {
- s |= Keyboard::TertiaryModifier;
- }
+ if (str.find ("Tertiary") != string::npos) {
+ s |= Keyboard::TertiaryModifier;
+ }
- if (str.find ("Level4") != string::npos) {
- s |= Keyboard::Level4Modifier;
- }
+ if (str.find ("Level4") != string::npos) {
+ s |= Keyboard::Level4Modifier;
+ }
- string::size_type lastmod = str.find_last_of ('-');
- uint32_t button_number;
+ string::size_type lastmod = str.find_last_of ('-');
+ uint32_t button_number;
- if (lastmod == string::npos) {
- button_number = PBD::atoi (str);
- } else {
- button_number = PBD::atoi (str.substr (lastmod+1));
- }
+ if (lastmod == string::npos) {
+ button_number = PBD::atoi (str);
+ } else {
+ button_number = PBD::atoi (str.substr (lastmod+1));
+ }
- b = MouseButton (s, button_number);
- return true;
+ b = MouseButton (s, button_number);
+ return true;
}
string
MouseButton::name () const
{
- int s = state();
-
- string str;
-
- if (s & Keyboard::PrimaryModifier) {
- str += "Primary";
- }
- if (s & Keyboard::SecondaryModifier) {
- if (!str.empty()) {
- str += '-';
- }
- str += "Secondary";
- }
- if (s & Keyboard::TertiaryModifier) {
- if (!str.empty()) {
- str += '-';
- }
- str += "Tertiary";
- }
- if (s & Keyboard::Level4Modifier) {
- if (!str.empty()) {
- str += '-';
- }
- str += "Level4";
- }
-
- if (!str.empty()) {
- str += '-';
- }
-
- char buf[16];
- snprintf (buf, sizeof (buf), "%u", button());
- str += buf;
-
- return str;
+ int s = state();
+
+ string str;
+
+ if (s & Keyboard::PrimaryModifier) {
+ str += "Primary";
+ }
+ if (s & Keyboard::SecondaryModifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += "Secondary";
+ }
+ if (s & Keyboard::TertiaryModifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += "Tertiary";
+ }
+ if (s & Keyboard::Level4Modifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += "Level4";
+ }
+
+ if (!str.empty()) {
+ str += '-';
+ }
+
+ char buf[16];
+ snprintf (buf, sizeof (buf), "%u", button());
+ str += buf;
+
+ return str;
}
+/*================================ KeyboardKey ================================*/
KeyboardKey::KeyboardKey (uint32_t state, uint32_t keycode)
{
- uint32_t ignore = Bindings::ignored_state();
+ uint32_t ignore = ~Keyboard::RelevantModifierKeyMask;
- _val = (state & ~ignore);
- _val <<= 32;
- _val |= keycode;
-};
+ _val = (state & ~ignore);
+ _val <<= 32;
+ _val |= keycode;
+}
+string
+KeyboardKey::display_label () const
+{
+ if (key() == 0) {
+ return string();
+ }
+
+ /* This magically returns a string that will display the right thing
+ * on all platforms, notably the command key on OS X.
+ */
+
+ uint32_t mod = state();
+
+ return gtk_accelerator_get_label (key(), (GdkModifierType) mod);
+}
string
KeyboardKey::name () const
{
- int s = state();
-
- string str;
-
- if (s & Keyboard::PrimaryModifier) {
- str += "Primary";
- }
- if (s & Keyboard::SecondaryModifier) {
- if (!str.empty()) {
- str += '-';
- }
- str += "Secondary";
- }
- if (s & Keyboard::TertiaryModifier) {
- if (!str.empty()) {
- str += '-';
- }
- str += "Tertiary";
- }
- if (s & Keyboard::Level4Modifier) {
- if (!str.empty()) {
- str += '-';
- }
- str += "Level4";
- }
-
- if (!str.empty()) {
- str += '-';
- }
-
- char const *gdk_name = gdk_keyval_name (key());
-
- if (gdk_name) {
- str += gdk_name;
- } else {
- /* fail! */
- return string();
- }
-
- return str;
+ int s = state();
+
+ string str;
+
+ if (s & Keyboard::PrimaryModifier) {
+ str += "Primary";
+ }
+ if (s & Keyboard::SecondaryModifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += "Secondary";
+ }
+ if (s & Keyboard::TertiaryModifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += "Tertiary";
+ }
+ if (s & Keyboard::Level4Modifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += "Level4";
+ }
+
+ if (!str.empty()) {
+ str += '-';
+ }
+
+ char const *gdk_name = gdk_keyval_name (key());
+
+ if (gdk_name) {
+ str += gdk_name;
+ } else {
+ /* fail! */
+ return string();
+ }
+
+ return str;
+}
+
+string
+KeyboardKey::native_name () const
+{
+ int s = state();
+
+ string str;
+
+ if (s & Keyboard::PrimaryModifier) {
+ str += Keyboard::primary_modifier_name ();
+ }
+ if (s & Keyboard::SecondaryModifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += Keyboard::secondary_modifier_name ();
+ }
+ if (s & Keyboard::TertiaryModifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += Keyboard::tertiary_modifier_name ();
+ }
+ if (s & Keyboard::Level4Modifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += Keyboard::level4_modifier_name ();
+ }
+
+ if (!str.empty()) {
+ str += '-';
+ }
+
+ char const *gdk_name = gdk_keyval_name (key());
+
+ if (gdk_name) {
+ str += gdk_name;
+ } else {
+ /* fail! */
+ return string();
+ }
+
+ return str;
+}
+
+string
+KeyboardKey::native_short_name () const
+{
+ int s = state();
+
+ string str;
+
+ if (s & Keyboard::PrimaryModifier) {
+ str += Keyboard::primary_modifier_short_name ();
+ }
+ if (s & Keyboard::SecondaryModifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += Keyboard::secondary_modifier_short_name ();
+ }
+ if (s & Keyboard::TertiaryModifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += Keyboard::tertiary_modifier_short_name ();
+ }
+ if (s & Keyboard::Level4Modifier) {
+ if (!str.empty()) {
+ str += '-';
+ }
+ str += Keyboard::level4_modifier_short_name ();
+ }
+
+ if (!str.empty()) {
+ str += '-';
+ }
+
+ char const *gdk_name = gdk_keyval_name (key());
+
+ if (gdk_name) {
+ str += gdk_name;
+ } else {
+ /* fail! */
+ return string();
+ }
+
+ return str;
}
bool
KeyboardKey::make_key (const string& str, KeyboardKey& k)
{
- int s = 0;
+ int s = 0;
- if (str.find ("Primary") != string::npos) {
- s |= Keyboard::PrimaryModifier;
- }
+ if (str.find ("Primary") != string::npos) {
+ s |= Keyboard::PrimaryModifier;
+ }
- if (str.find ("Secondary") != string::npos) {
- s |= Keyboard::SecondaryModifier;
- }
+ if (str.find ("Secondary") != string::npos) {
+ s |= Keyboard::SecondaryModifier;
+ }
- if (str.find ("Tertiary") != string::npos) {
- s |= Keyboard::TertiaryModifier;
- }
+ if (str.find ("Tertiary") != string::npos) {
+ s |= Keyboard::TertiaryModifier;
+ }
- if (str.find ("Level4") != string::npos) {
- s |= Keyboard::Level4Modifier;
- }
+ if (str.find ("Level4") != string::npos) {
+ s |= Keyboard::Level4Modifier;
+ }
- string::size_type lastmod = str.find_last_of ('-');
- guint keyval;
-
- if (lastmod == string::npos) {
- keyval = gdk_keyval_from_name (str.c_str());
- } else {
- keyval = gdk_keyval_from_name (str.substr (lastmod+1).c_str());
- }
+ /* since all SINGLE key events keycodes are changed to lower case
+ * before looking them up, make sure we only store lower case here. The
+ * Shift part will be stored in the modifier part of the KeyboardKey.
+ *
+ * And yes Mildred, this doesn't cover CapsLock cases. Oh well.
+ */
+
+ string actual;
+
+ string::size_type lastmod = str.find_last_of ('-');
+
+ if (lastmod != string::npos) {
+ actual = str.substr (lastmod+1);
+ }
+ else {
+ actual = str;
+ }
+
+ if (actual.size() == 1) {
+ actual = PBD::downcase (actual);
+ }
+
+ guint keyval;
+ keyval = gdk_keyval_from_name (actual.c_str());
- if (keyval == GDK_VoidSymbol || keyval == 0) {
- return false;
- }
+ if (keyval == GDK_VoidSymbol || keyval == 0) {
+ return false;
+ }
- k = KeyboardKey (s, keyval);
+ k = KeyboardKey (s, keyval);
- return true;
+ return true;
}
+/*================================= Bindings =================================*/
Bindings::Bindings (std::string const& name)
: _name (name)
- , _action_map (Actions)
{
bindings.push_back (this);
}
bindings.remove (this);
}
+string
+Bindings::ardour_action_name (RefPtr<Action> action)
+{
+ /* Skip "<Actions>/" */
+ return action->get_accel_path ().substr (10);
+}
+
+KeyboardKey
+Bindings::get_binding_for_action (RefPtr<Action> action, Operation& op)
+{
+ const string action_name = ardour_action_name (action);
+
+ for (KeybindingMap::iterator k = press_bindings.begin(); k != press_bindings.end(); ++k) {
+
+ /* option one: action has already been associated with the
+ * binding
+ */
+
+ if (k->second.action == action) {
+ return k->first;
+ }
+
+ /* option two: action name matches, so lookup the action,
+ * setup the association while we're here, and return the binding.
+ */
+
+ if (k->second.action_name == action_name) {
+ k->second.action = ActionManager::get_action (action_name, false);
+ return k->first;
+ }
+
+ }
+
+ for (KeybindingMap::iterator k = release_bindings.begin(); k != release_bindings.end(); ++k) {
+
+ /* option one: action has already been associated with the
+ * binding
+ */
+
+ if (k->second.action == action) {
+ return k->first;
+ }
+
+ /* option two: action name matches, so lookup the action,
+ * setup the association while we're here, and return the binding.
+ */
+
+ if (k->second.action_name == action_name) {
+ k->second.action = ActionManager::get_action (action_name, false);
+ return k->first;
+ }
+
+ }
+
+ return KeyboardKey::null_key();
+}
+
void
-Bindings::set_action_map (ActionMap& actions)
+Bindings::reassociate ()
{
- _action_map = actions;
dissociate ();
associate ();
}
bool
Bindings::activate (KeyboardKey kb, Operation op)
{
- KeybindingMap* kbm = 0;
+ KeybindingMap& kbm = get_keymap (op);
- switch (op) {
- case Press:
- kbm = &press_bindings;
- break;
- case Release:
- kbm = &release_bindings;
- break;
- }
-
- KeybindingMap::iterator k = kbm->find (kb);
+ /* if shift was pressed, GDK will send us (e.g) 'E' rather than 'e'.
+ Our bindings all use the lower case character/keyname, so switch
+ to the lower case before doing the lookup.
+ */
- if (k == kbm->end()) {
- /* no entry for this key in the state map */
- DEBUG_TRACE (DEBUG::Bindings, string_compose ("no binding for %1\n", kb));
- return false;
- }
+ KeyboardKey unshifted (kb.state(), gdk_keyval_to_lower (kb.key()));
- RefPtr<Action> action;
-
- if (!k->second.action) {
- action = _action_map.find_action (k->second.action_name);
- }
+ KeybindingMap::iterator k = kbm.find (unshifted);
- if (action) {
- /* lets do it ... */
- DEBUG_TRACE (DEBUG::Bindings, string_compose ("binding for %1: %2\n", kb, k->second.action_name));
- action->activate ();
- }
+ if (k == kbm.end()) {
+ /* no entry for this key in the state map */
+ DEBUG_TRACE (DEBUG::Bindings, string_compose ("no binding for %1\n", unshifted));
+ return false;
+ }
+
+ RefPtr<Action> action;
- /* return true even if the action could not be found */
+ if (k->second.action) {
+ action = k->second.action;
+ } else {
+ action = ActionManager::get_action (k->second.action_name, false);
+ }
+
+ if (action) {
+ /* lets do it ... */
+ DEBUG_TRACE (DEBUG::Bindings, string_compose ("binding for %1: %2\n", unshifted, k->second.action_name));
+ action->activate ();
+ }
- return true;
+ /* return true even if the action could not be found */
+
+ return true;
}
void
KeybindingMap::iterator k;
for (k = press_bindings.begin(); k != press_bindings.end(); ++k) {
- k->second.action = _action_map.find_action (k->second.action_name);
+ k->second.action = ActionManager::get_action (k->second.action_name, false);
if (k->second.action) {
push_to_gtk (k->first, k->second.action);
+ } else {
+ cerr << _name << " didn't find " << k->second.action_name << endl;
}
}
for (k = release_bindings.begin(); k != release_bindings.end(); ++k) {
- k->second.action = _action_map.find_action (k->second.action_name);
+ k->second.action = ActionManager::get_action (k->second.action_name, false);
/* no working support in GTK for release bindings */
}
MouseButtonBindingMap::iterator b;
-
+
for (b = button_press_bindings.begin(); b != button_press_bindings.end(); ++b) {
- b->second.action = _action_map.find_action (b->second.action_name);
+ b->second.action = ActionManager::get_action (b->second.action_name, false);
}
for (b = button_release_bindings.begin(); b != button_release_bindings.end(); ++b) {
- b->second.action = _action_map.find_action (b->second.action_name);
+ b->second.action = ActionManager::get_action (b->second.action_name, false);
}
}
void
Bindings::push_to_gtk (KeyboardKey kb, RefPtr<Action> what)
{
- /* GTK has the useful feature of showing key bindings for actions in
- * menus. As of August 2015, we have no interest in trying to
- * reimplement this functionality, so we will use it even though we no
- * longer use GTK accelerators for handling key events. To do this, we
- * need to make sure that there is a fully populated GTK AccelMap set
- * up with all bindings/actions.
- */
-
- Gtk::AccelKey gtk_key;
-
- /* tweak the modifier used in the binding so that GTK will accept it
- * and display something acceptable. The actual keyval should display
- * correctly even if it involves a key that GTK would not allow
- * as an accelerator.
- */
-
- uint32_t gtk_legal_keyval = kb.key();
- possibly_translate_keyval_to_make_legal_accelerator (gtk_legal_keyval);
- KeyboardKey gtk_binding (kb.state(), gtk_legal_keyval);
-
-
- bool entry_exists = Gtk::AccelMap::lookup_entry (what->get_accel_path(), gtk_key);
-
- if (!entry_exists || gtk_key.get_key() == 0) {
-
- /* there is a trick happening here. It turns out that
- * gtk_accel_map_add_entry() performs no validation checks on
- * the accelerator keyval. This means we can use it to define
- * ANY accelerator, even if they violate GTK's rules
- * (e.g. about not using navigation keys). This works ONLY when
- * the entry in the GTK accelerator map has not already been
- * added. The entries will be added by the GTK UIManager when
- * building menus, so this code must be called before that
- * happens.
- */
-
- Gtk::AccelMap::add_entry (what->get_accel_path(),
- gtk_binding.key(),
- (Gdk::ModifierType) gtk_binding.state());
- } else {
- warning << string_compose (_("There is more than one key binding defined for %1. Both will work, but only the first will be visible in menus"), what->get_accel_path()) << endmsg;
- }
-
- if (!Gtk::AccelMap::lookup_entry (what->get_accel_path(), gtk_key) || gtk_key.get_key() == 0) {
- cerr << "GTK binding using " << gtk_binding << " failed for " << what->get_accel_path() << " existing = " << gtk_key.get_key() << " + " << gtk_key.get_mod() << endl;
- }
-}
-
-bool
-Bindings::replace (KeyboardKey kb, Operation op, string const & action_name, bool can_save)
-{
- /* We have to search the existing binding map by both action and
- * keybinding, because the following are possible:
- *
- * - key is already used for a different action
- * - action has a different binding
- * - key is not used
- * - action is not bound
+ /* GTK has the useful feature of showing key bindings for actions in
+ * menus. As of August 2015, we have no interest in trying to
+ * reimplement this functionality, so we will use it even though we no
+ * longer use GTK accelerators for handling key events. To do this, we
+ * need to make sure that there is a fully populated GTK AccelMap set
+ * up with all bindings/actions.
*/
-
- RefPtr<Action> action = Actions.find_action (action_name);
- if (!action) {
- return false;
- }
+ Gtk::AccelKey gtk_key;
+ bool entry_exists = Gtk::AccelMap::lookup_entry (what->get_accel_path(), gtk_key);
- KeybindingMap* kbm = 0;
+ if (!entry_exists) {
- switch (op) {
- case Press:
- kbm = &press_bindings;
- break;
- case Release:
- kbm = &release_bindings;
- break;
- }
+ /* there is a trick happening here. It turns out that
+ * gtk_accel_map_add_entry() performs no validation checks on
+ * the accelerator keyval. This means we can use it to define
+ * ANY accelerator, even if they violate GTK's rules
+ * (e.g. about not using navigation keys). This works ONLY when
+ * the entry in the GTK accelerator map has not already been
+ * added. The entries will be added by the GTK UIManager when
+ * building menus, so this code must be called before that
+ * happens.
+ */
- KeybindingMap::iterator k = kbm->find (kb);
- if (k != kbm->end()) {
- kbm->erase (k);
- }
+ int mod = kb.state();
- /* now linear search by action */
-
- for (k = kbm->begin(); k != kbm->end(); ++k) {
- if (k->second.action_name == action_name) {
- kbm->erase (k);
- break;
- }
- }
-
- add (kb, op, action_name, can_save);
-
- /* for now, this never fails */
-
- return true;
+ Gtk::AccelMap::add_entry (what->get_accel_path(), kb.key(), (Gdk::ModifierType) mod);
+ }
}
-void
-Bindings::add (KeyboardKey kb, Operation op, string const& action_name, bool can_save)
+bool
+Bindings::replace (KeyboardKey kb, Operation op, string const & action_name, bool can_save)
{
- KeybindingMap* kbm = 0;
-
- switch (op) {
- case Press:
- kbm = &press_bindings;
- break;
- case Release:
- kbm = &release_bindings;
- break;
- }
-
- KeybindingMap::iterator k = kbm->find (kb);
+ if (is_registered(op, action_name)) {
+ remove (op, action_name, can_save);
+ }
- if (k != kbm->end()) {
- kbm->erase (k);
- }
- KeybindingMap::value_type new_pair (kb, ActionInfo (action_name));
-
- kbm->insert (new_pair).first;
+ /* XXX need a way to get the old group name */
+ add (kb, op, action_name, 0, can_save);
- if (can_save) {
- Keyboard::keybindings_changed ();
- }
+ return true;
}
-void
-Bindings::remove (KeyboardKey kb, Operation op, bool can_save)
+bool
+Bindings::add (KeyboardKey kb, Operation op, string const& action_name, XMLProperty const* group, bool can_save)
{
- KeybindingMap* kbm = 0;
+ if (is_registered (op, action_name)) {
+ return false;
+ }
- switch (op) {
- case Press:
- kbm = &press_bindings;
- break;
- case Release:
- kbm = &release_bindings;
- break;
- }
+ KeybindingMap& kbm = get_keymap (op);
+ if (group) {
+ KeybindingMap::value_type new_pair = make_pair (kb, ActionInfo (action_name, group->value()));
+ (void) kbm.insert (new_pair).first;
+ } else {
+ KeybindingMap::value_type new_pair = make_pair (kb, ActionInfo (action_name));
+ (void) kbm.insert (new_pair).first;
+ }
- KeybindingMap::iterator k = kbm->find (kb);
+ DEBUG_TRACE (DEBUG::Bindings, string_compose ("add binding between %1 and %2, group [%3]\n",
+ kb, action_name, (group ? group->value() : string())));
- if (k != kbm->end()) {
- kbm->erase (k);
- }
+ if (can_save) {
+ Keyboard::keybindings_changed ();
+ }
- if (can_save) {
- Keyboard::keybindings_changed ();
- }
+ BindingsChanged (this); /* EMIT SIGNAL */
+ return true;
}
-void
-Bindings::remove (RefPtr<Action> action, Operation op, bool can_save)
+bool
+Bindings::remove (Operation op, std::string const& action_name, bool can_save)
{
- KeybindingMap* kbm = 0;
+ bool erased_action = false;
+ KeybindingMap& kbm = get_keymap (op);
+ for (KeybindingMap::iterator k = kbm.begin(); k != kbm.end(); ++k) {
+ if (k->second.action_name == action_name) {
+ kbm.erase (k);
+ erased_action = true;
+ break;
+ }
+ }
- switch (op) {
- case Press:
- kbm = &press_bindings;
- break;
- case Release:
- kbm = &release_bindings;
- break;
- }
+ if (!erased_action) {
+ return erased_action;
+ }
- for (KeybindingMap::iterator k = kbm->begin(); k != kbm->end(); ++k) {
- if (k->second.action == action) {
- kbm->erase (k);
- break;
- }
- }
+ if (can_save) {
+ Keyboard::keybindings_changed ();
+ }
- if (can_save) {
- Keyboard::keybindings_changed ();
- }
+ BindingsChanged (this); /* EMIT SIGNAL */
+ return erased_action;
}
+
bool
Bindings::activate (MouseButton bb, Operation op)
{
- MouseButtonBindingMap* bbm = 0;
+ MouseButtonBindingMap& bbm = get_mousemap(op);
- switch (op) {
- case Press:
- bbm = &button_press_bindings;
- break;
- case Release:
- bbm = &button_release_bindings;
- break;
- }
+ MouseButtonBindingMap::iterator b = bbm.find (bb);
- MouseButtonBindingMap::iterator b = bbm->find (bb);
+ if (b == bbm.end()) {
+ /* no entry for this key in the state map */
+ return false;
+ }
- if (b == bbm->end()) {
- /* no entry for this key in the state map */
- return false;
- }
+ RefPtr<Action> action;
- RefPtr<Action> action;
-
- if (!b->second.action) {
- action = _action_map.find_action (b->second.action_name);
- }
+ if (b->second.action) {
+ action = b->second.action;
+ } else {
+ action = ActionManager::get_action (b->second.action_name, false);
+ }
+
+ if (action) {
+ /* lets do it ... */
+ DEBUG_TRACE (DEBUG::Bindings, string_compose ("activating action %1\n", ardour_action_name (action)));
+ action->activate ();
+ }
- if (action) {
- /* lets do it ... */
- action->activate ();
- }
+ /* return true even if the action could not be found */
- /* return true even if the action could not be found */
-
- return true;
+ return true;
}
void
-Bindings::add (MouseButton bb, Operation op, string const& action_name)
+Bindings::add (MouseButton bb, Operation op, string const& action_name, XMLProperty const* /*group*/)
{
- MouseButtonBindingMap* bbm = 0;
+ MouseButtonBindingMap& bbm = get_mousemap(op);
- switch (op) {
- case Press:
- bbm = &button_press_bindings;
- break;
- case Release:
- bbm = &button_release_bindings;
- break;
- }
-
- MouseButtonBindingMap::value_type newpair (bb, ActionInfo (action_name));
- bbm->insert (newpair);
+ MouseButtonBindingMap::value_type newpair (bb, ActionInfo (action_name));
+ bbm.insert (newpair);
}
void
Bindings::remove (MouseButton bb, Operation op)
{
- MouseButtonBindingMap* bbm = 0;
-
- switch (op) {
- case Press:
- bbm = &button_press_bindings;
- break;
- case Release:
- bbm = &button_release_bindings;
- break;
- }
+ MouseButtonBindingMap& bbm = get_mousemap(op);
+ MouseButtonBindingMap::iterator b = bbm.find (bb);
- MouseButtonBindingMap::iterator b = bbm->find (bb);
-
- if (b != bbm->end()) {
- bbm->erase (b);
- }
+ if (b != bbm.end()) {
+ bbm.erase (b);
+ }
}
void
Bindings::save (XMLNode& root)
{
- XMLNode* presses = new XMLNode (X_("Press"));
+ XMLNode* presses = new XMLNode (X_("Press"));
- for (KeybindingMap::iterator k = press_bindings.begin(); k != press_bindings.end(); ++k) {
- XMLNode* child;
+ for (KeybindingMap::iterator k = press_bindings.begin(); k != press_bindings.end(); ++k) {
+ XMLNode* child;
- if (k->first.name().empty()) {
- continue;
- }
+ if (k->first.name().empty()) {
+ continue;
+ }
- child = new XMLNode (X_("Binding"));
- child->add_property (X_("key"), k->first.name());
- child->add_property (X_("action"), k->second.action_name);
- presses->add_child_nocopy (*child);
- }
+ child = new XMLNode (X_("Binding"));
+ child->set_property (X_("key"), k->first.name());
+ child->set_property (X_("action"), k->second.action_name);
+ presses->add_child_nocopy (*child);
+ }
- for (MouseButtonBindingMap::iterator k = button_press_bindings.begin(); k != button_press_bindings.end(); ++k) {
- XMLNode* child;
- child = new XMLNode (X_("Binding"));
- child->add_property (X_("button"), k->first.name());
- child->add_property (X_("action"), k->second.action_name);
- presses->add_child_nocopy (*child);
- }
+ for (MouseButtonBindingMap::iterator k = button_press_bindings.begin(); k != button_press_bindings.end(); ++k) {
+ XMLNode* child;
+ child = new XMLNode (X_("Binding"));
+ child->set_property (X_("button"), k->first.name());
+ child->set_property (X_("action"), k->second.action_name);
+ presses->add_child_nocopy (*child);
+ }
- XMLNode* releases = new XMLNode (X_("Release"));
+ XMLNode* releases = new XMLNode (X_("Release"));
- for (KeybindingMap::iterator k = release_bindings.begin(); k != release_bindings.end(); ++k) {
- XMLNode* child;
+ for (KeybindingMap::iterator k = release_bindings.begin(); k != release_bindings.end(); ++k) {
+ XMLNode* child;
- if (k->first.name().empty()) {
- continue;
- }
+ if (k->first.name().empty()) {
+ continue;
+ }
- child = new XMLNode (X_("Binding"));
- child->add_property (X_("key"), k->first.name());
- child->add_property (X_("action"), k->second.action_name);
- releases->add_child_nocopy (*child);
- }
+ child = new XMLNode (X_("Binding"));
+ child->set_property (X_("key"), k->first.name());
+ child->set_property (X_("action"), k->second.action_name);
+ releases->add_child_nocopy (*child);
+ }
- for (MouseButtonBindingMap::iterator k = button_release_bindings.begin(); k != button_release_bindings.end(); ++k) {
- XMLNode* child;
- child = new XMLNode (X_("Binding"));
- child->add_property (X_("button"), k->first.name());
- child->add_property (X_("action"), k->second.action_name);
- releases->add_child_nocopy (*child);
- }
+ for (MouseButtonBindingMap::iterator k = button_release_bindings.begin(); k != button_release_bindings.end(); ++k) {
+ XMLNode* child;
+ child = new XMLNode (X_("Binding"));
+ child->set_property (X_("button"), k->first.name());
+ child->set_property (X_("action"), k->second.action_name);
+ releases->add_child_nocopy (*child);
+ }
- root.add_child_nocopy (*presses);
- root.add_child_nocopy (*releases);
+ root.add_child_nocopy (*presses);
+ root.add_child_nocopy (*releases);
}
-bool
-Bindings::load (XMLNode const& node)
+void
+Bindings::save_all_bindings_as_html (ostream& ostr)
{
- const XMLNodeList& children (node.children());
-
- press_bindings.clear ();
- release_bindings.clear ();
+ if (bindings.empty()) {
+ return;
+ }
+
- for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
- /* each node could be Press or Release */
- load_operation (**i);
- }
+ ostr << "<html>\n<head>\n<title>";
+ ostr << PROGRAM_NAME;
+ ostr << "</title>\n";
+ ostr << "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n";
- return true;
+ ostr << "</head>\n<body>\n";
+
+ ostr << "<table border=\"2\" cellpadding=\"6\"><tbody>\n\n";
+ ostr << "<tr>\n\n";
+
+ /* first column: separate by group */
+ ostr << "<td>\n\n";
+ for (list<Bindings*>::const_iterator b = bindings.begin(); b != bindings.end(); ++b) {
+ (*b)->save_as_html (ostr, true);
+ }
+ ostr << "</td>\n\n";
+
+ //second column
+ ostr << "<td style=\"vertical-align:top\">\n\n";
+ for (list<Bindings*>::const_iterator b = bindings.begin(); b != bindings.end(); ++b) {
+ (*b)->save_as_html (ostr, false);
+ }
+ ostr << "</td>\n\n";
+
+
+ ostr << "</tr>\n\n";
+ ostr << "</tbody></table>\n\n";
+
+ ostr << "</br></br>\n\n";
+ ostr << "<table border=\"2\" cellpadding=\"6\"><tbody>\n\n";
+ ostr << "<tr>\n\n";
+ ostr << "<td>\n\n";
+ ostr << "<h2><u> Partial List of Available Actions { => with current shortcut, where applicable } </u></h2>\n\n";
+ {
+ vector<string> paths;
+ vector<string> labels;
+ vector<string> tooltips;
+ vector<string> keys;
+ vector<Glib::RefPtr<Gtk::Action> > actions;
+
+ ActionManager::get_all_actions (paths, labels, tooltips, keys, actions);
+
+ vector<string>::iterator k;
+ vector<string>::iterator p;
+ vector<string>::iterator l;
+
+ for (p = paths.begin(), k = keys.begin(), l = labels.begin(); p != paths.end(); ++k, ++p, ++l) {
+
+ string print_path = *p;
+ /* strip <Actions>/ from the start */
+ print_path = print_path.substr (10);
+
+ if ((*k).empty()) {
+ ostr << print_path << " ( " << *l << " ) " << "</br>" << endl;
+ } else {
+ ostr << print_path << " ( " << *l << " ) " << " => " << *k << "</br>" << endl;
+ }
+ }
+ }
+ ostr << "</td>\n\n";
+ ostr << "</tr>\n\n";
+ ostr << "</tbody></table>\n\n";
+
+ ostr << "</body>\n";
+ ostr << "</html>\n";
}
void
-Bindings::load_operation (XMLNode const& node)
+Bindings::save_as_html (ostream& ostr, bool categorize) const
{
- if (node.name() == X_("Press") || node.name() == X_("Release")) {
- Operation op;
+ if (!press_bindings.empty()) {
+
+ ostr << "<h2><u>";
+ if (categorize)
+ ostr << _("Window") << ": " << name() << _(" (Categorized)");
+ else
+ ostr << _("Window") << ": " << name() << _(" (Alphabetical)");
+ ostr << "</u></h2>\n\n";
+
+ typedef std::map<std::string, std::vector<KeybindingMap::const_iterator> > GroupMap;
+ GroupMap group_map;
+
+ for (KeybindingMap::const_iterator k = press_bindings.begin(); k != press_bindings.end(); ++k) {
+
+ if (k->first.name().empty()) {
+ continue;
+ }
+
+ string group_name;
+ if (categorize && !k->second.group_name.empty()) {
+ group_name = k->second.group_name;
+ } else {
+ group_name = _("Uncategorized");
+ }
+
+ GroupMap::iterator gm = group_map.find (group_name);
+ if (gm == group_map.end()) {
+ std::vector<KeybindingMap::const_iterator> li;
+ li.push_back (k);
+ group_map.insert (make_pair (group_name,li));
+ } else {
+ gm->second.push_back (k);
+ }
+ }
+
- if (node.name() == X_("Press")) {
- op = Press;
- } else {
- op = Release;
- }
+ for (GroupMap::const_iterator gm = group_map.begin(); gm != group_map.end(); ++gm) {
- const XMLNodeList& children (node.children());
+ if (categorize) {
+ ostr << "<h3>" << gm->first << "</h3>\n";
+ }
- for (XMLNodeList::const_iterator p = children.begin(); p != children.end(); ++p) {
+ for (vector<KeybindingMap::const_iterator>::const_iterator k = gm->second.begin(); k != gm->second.end(); ++k) {
- XMLProperty* ap;
- XMLProperty* kp;
- XMLProperty* bp;
+ if ((*k)->first.name().empty()) {
+ continue;
+ }
- ap = (*p)->property ("action");
- kp = (*p)->property ("key");
- bp = (*p)->property ("button");
+ RefPtr<Action> action;
- if (!ap || (!kp && !bp)) {
- continue;
- }
+ if ((*k)->second.action) {
+ action = (*k)->second.action;
+ } else {
+ action = ActionManager::get_action ((*k)->second.action_name, false);
+ }
- if (kp) {
- KeyboardKey k;
- if (!KeyboardKey::make_key (kp->value(), k)) {
- continue;
- }
- add (k, op, ap->value());
- } else {
- MouseButton b;
- if (!MouseButton::make_button (bp->value(), b)) {
- continue;
- }
- add (b, op, ap->value());
- }
- }
- }
+ if (!action) {
+ continue;
+ }
+
+ string key_name = (*k)->first.native_short_name ();
+ replace_all (key_name, X_("KP_"), X_("Numpad "));
+ replace_all (key_name, X_("nabla"), X_("Tab"));
+
+ string::size_type pos;
+
+ char const *targets[] = { X_("Separator"), X_("Add"), X_("Subtract"), X_("Decimal"), X_("Divide"),
+ X_("grave"), X_("comma"), X_("period"), X_("asterisk"), X_("backslash"),
+ X_("apostrophe"), X_("minus"), X_("plus"), X_("slash"), X_("semicolon"),
+ X_("colon"), X_("equal"), X_("bracketleft"), X_("bracketright"),
+ X_("ampersand"), X_("numbersign"), X_("parenleft"), X_("parenright"),
+ X_("quoteright"), X_("quoteleft"), X_("exclam"), X_("quotedbl"),
+ 0
+ };
+
+ char const *replacements[] = { X_("-"), X_("+"), X_("-"), X_("."), X_("/"),
+ X_("`"), X_(","), X_("."), X_("*"), X_("\\"),
+ X_("'"), X_("-"), X_("+"), X_("/"), X_(";"),
+ X_(":"), X_("="), X_("{"), X_("{"),
+ X_("&"), X_("#"), X_("("), X_(")"),
+ X_("`"), X_("'"), X_("!"), X_("\""),
+ };
+
+ for (size_t n = 0; targets[n]; ++n) {
+ if ((pos = key_name.find (targets[n])) != string::npos) {
+ key_name.replace (pos, strlen (targets[n]), replacements[n]);
+ }
+ }
+
+ key_name.append(" ");
+
+ while (key_name.length()<28)
+ key_name.append("-");
+
+ ostr << "<span style=\"font-family:monospace;\">" << key_name;
+ ostr << "<i>" << action->get_label() << "</i></span></br>\n";
+ }
+ ostr << "\n\n";
+
+ }
+
+ ostr << "\n";
+ }
}
-void
-Bindings::get_all_actions (std::vector<std::string>& paths,
- std::vector<std::string>& labels,
- std::vector<std::string>& tooltips,
- std::vector<std::string>& keys,
- std::vector<RefPtr<Action> >& actions)
+bool
+Bindings::load (XMLNode const& node)
{
- /* build a reverse map from actions to bindings */
+ const XMLNodeList& children (node.children());
- typedef map<Glib::RefPtr<Gtk::Action>,KeyboardKey> ReverseMap;
- ReverseMap rmap;
+ press_bindings.clear ();
+ release_bindings.clear ();
- for (KeybindingMap::const_iterator k = press_bindings.begin(); k != press_bindings.end(); ++k) {
- rmap.insert (make_pair (k->second.action, k->first));
+ for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
+ /* each node could be Press or Release */
+ load_operation (**i);
}
- /* get a list of all actions */
-
- ActionMap::Actions all_actions;
- _action_map.get_actions (all_actions);
-
- for (ActionMap::Actions::const_iterator act = all_actions.begin(); act != all_actions.end(); ++act) {
+ return true;
+}
- paths.push_back ((*act)->get_accel_path());
- labels.push_back ((*act)->get_label());
- tooltips.push_back ((*act)->get_tooltip());
+void
+Bindings::load_operation (XMLNode const& node)
+{
+ if (node.name() == X_("Press") || node.name() == X_("Release")) {
- ReverseMap::iterator r = rmap.find (*act);
+ Operation op;
- if (r != rmap.end()) {
- keys.push_back (gtk_accelerator_get_label (r->second.key(), (GdkModifierType) r->second.state()));
+ if (node.name() == X_("Press")) {
+ op = Press;
} else {
- keys.push_back (string());
+ op = Release;
}
- actions.push_back (*act);
+ const XMLNodeList& children (node.children());
+
+ for (XMLNodeList::const_iterator p = children.begin(); p != children.end(); ++p) {
+
+ XMLProperty const * ap;
+ XMLProperty const * kp;
+ XMLProperty const * bp;
+ XMLProperty const * gp;
+ XMLNode const * child = *p;
+
+ ap = child->property ("action");
+ kp = child->property ("key");
+ bp = child->property ("button");
+ gp = child->property ("group");
+
+ if (!ap || (!kp && !bp)) {
+ continue;
+ }
+
+ if (kp) {
+ KeyboardKey k;
+ if (!KeyboardKey::make_key (kp->value(), k)) {
+ continue;
+ }
+ add (k, op, ap->value(), gp);
+ } else {
+ MouseButton b;
+ if (!MouseButton::make_button (bp->value(), b)) {
+ continue;
+ }
+ add (b, op, ap->value(), gp);
+ }
+ }
}
}
void
-Bindings::get_all_actions (std::vector<std::string>& names,
- std::vector<std::string>& paths,
- std::vector<std::string>& keys)
+Bindings::get_all_actions (std::vector<std::string>& paths,
+ std::vector<std::string>& labels,
+ std::vector<std::string>& tooltips,
+ std::vector<std::string>& keys,
+ std::vector<RefPtr<Action> >& actions)
{
/* build a reverse map from actions to bindings */
rmap.insert (make_pair (k->second.action, k->first));
}
- /* get a list of all actions */
+#if 0
+
+ /* get a list of all actions XXX relevant for these bindings */
ActionMap::Actions all_actions;
- _action_map.get_actions (all_actions);
-
+ ActionManager::get_actions (all_actions);
+
for (ActionMap::Actions::const_iterator act = all_actions.begin(); act != all_actions.end(); ++act) {
-
- names.push_back ((*act)->get_name());
+
paths.push_back ((*act)->get_accel_path());
+ labels.push_back ((*act)->get_label());
+ tooltips.push_back ((*act)->get_tooltip());
ReverseMap::iterator r = rmap.find (*act);
+
if (r != rmap.end()) {
- keys.push_back (gtk_accelerator_get_label (r->second.key(), (GdkModifierType) r->second.state()));
+ keys.push_back (r->second.display_label());
} else {
keys.push_back (string());
}
+
+ actions.push_back (*act);
}
+#endif
}
Bindings*
}
}
-/*==========================================ACTION MAP =========================================*/
-
-void
-ActionMap::get_actions (ActionMap::Actions& acts)
-{
- for (_ActionMap::iterator a = _actions.begin(); a != _actions.end(); ++a) {
- acts.push_back (a->second);
- }
-}
-
-RefPtr<Action>
-ActionMap::find_action (const string& name)
+bool
+Bindings::is_bound (KeyboardKey const& kb, Operation op) const
{
- _ActionMap::iterator a = _actions.find (name);
-
- if (a != _actions.end()) {
- return a->second;
- }
-
- return RefPtr<Action>();
+ const KeybindingMap& km = get_keymap(op);
+ return km.find(kb) != km.end();
}
-RefPtr<ActionGroup>
-ActionMap::create_action_group (const string& name)
+std::string
+Bindings::bound_name (KeyboardKey const& kb, Operation op) const
{
- RefPtr<ActionGroup> g = ActionGroup::create (name);
-
- /* this is one of the places where our own Action management code
- has to touch the GTK one, because we want the GtkUIManager to
- be able to create widgets (particularly Menus) from our actions.
-
- This is a a necessary step for that to happen.
- */
-
- if (g) {
- ActionManager::ui_manager->insert_action_group (g);
+ const KeybindingMap& km = get_keymap(op);
+ KeybindingMap::const_iterator b = km.find(kb);
+ if (b == km.end()) {
+ return "";
}
-
- return g;
+ return b->second.action_name;
}
-RefPtr<Action>
-ActionMap::register_action (RefPtr<ActionGroup> group, const char* name, const char* label)
+bool
+Bindings::is_registered (Operation op, std::string const& action_name) const
{
- string fullpath;
-
- RefPtr<Action> act = Action::create (name, label);
-
- fullpath = group->get_name();
- fullpath += '/';
- fullpath += name;
-
- if (_actions.insert (_ActionMap::value_type (fullpath, act)).second) {
- group->add (act);
- return act;
- }
-
- /* already registered */
- return RefPtr<Action> ();
+ const KeybindingMap& km = get_keymap(op);
+ return std::find_if(km.begin(), km.end(), ActionNameRegistered<KeybindingMap::const_iterator::value_type>(action_name)) != km.end();
}
-RefPtr<Action>
-ActionMap::register_action (RefPtr<ActionGroup> group,
- const char* name, const char* label, sigc::slot<void> sl)
+Bindings::KeybindingMap&
+Bindings::get_keymap (Operation op)
{
- string fullpath;
-
- RefPtr<Action> act = Action::create (name, label);
-
- fullpath = group->get_name();
- fullpath += '/';
- fullpath += name;
-
- if (_actions.insert (_ActionMap::value_type (fullpath, act)).second) {
- group->add (act, sl);
- return act;
- }
-
- /* already registered */
- return RefPtr<Action>();
-}
-
-RefPtr<Action>
-ActionMap::register_radio_action (RefPtr<ActionGroup> group,
- Gtk::RadioAction::Group& rgroup,
- const char* name, const char* label,
- sigc::slot<void> sl)
-{
- string fullpath;
-
- RefPtr<Action> act = RadioAction::create (rgroup, name, label);
- RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
-
- fullpath = group->get_name();
- fullpath += '/';
- fullpath += name;
-
- if (_actions.insert (_ActionMap::value_type (fullpath, act)).second) {
- group->add (act, sl);
- return act;
- }
-
- /* already registered */
- return RefPtr<Action>();
+ switch (op) {
+ case Press:
+ return press_bindings;
+ case Release:
+ default:
+ return release_bindings;
+ }
}
-RefPtr<Action>
-ActionMap::register_radio_action (RefPtr<ActionGroup> group,
- Gtk::RadioAction::Group& rgroup,
- const char* name, const char* label,
- sigc::slot<void,GtkAction*> sl,
- int value)
+const Bindings::KeybindingMap&
+Bindings::get_keymap (Operation op) const
{
- string fullpath;
-
- RefPtr<Action> act = RadioAction::create (rgroup, name, label);
- RefPtr<RadioAction> ract = RefPtr<RadioAction>::cast_dynamic(act);
- ract->property_value() = value;
-
- fullpath = group->get_name();
- fullpath += '/';
- fullpath += name;
-
- if (_actions.insert (_ActionMap::value_type (fullpath, act)).second) {
- group->add (act, sigc::bind (sl, act->gobj()));
- return act;
- }
-
- /* already registered */
-
- return RefPtr<Action>();
+ switch (op) {
+ case Press:
+ return press_bindings;
+ case Release:
+ default:
+ return release_bindings;
+ }
}
-RefPtr<Action>
-ActionMap::register_toggle_action (RefPtr<ActionGroup> group,
- const char* name, const char* label, sigc::slot<void> sl)
+Bindings::MouseButtonBindingMap&
+Bindings::get_mousemap (Operation op)
{
- string fullpath;
-
- fullpath = group->get_name();
- fullpath += '/';
- fullpath += name;
-
- RefPtr<Action> act = ToggleAction::create (name, label);
-
- if (_actions.insert (_ActionMap::value_type (fullpath, act)).second) {
- group->add (act, sl);
- return act;
- }
-
- /* already registered */
- return RefPtr<Action>();
+ switch (op) {
+ case Press:
+ return button_press_bindings;
+ case Release:
+ default:
+ return button_release_bindings;
+ }
}
std::ostream& operator<<(std::ostream& out, Gtkmm2ext::KeyboardKey const & k) {
char const *gdk_name = gdk_keyval_name (k.key());
- return out << "Key " << k.key() << " (" << (gdk_name ? gdk_name : "no-key") << ") state " << k.state();
+ return out << "Key " << k.key() << " (" << (gdk_name ? gdk_name : "no-key") << ") state "
+ << hex << k.state() << dec << ' ' << show_gdk_event_state (k.state());
}
-