2005-09-25 14:42:24 -04:00
|
|
|
/*
|
|
|
|
Copyright (C) 2001 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 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.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
#include <vector>
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/ardour.h"
|
2008-02-16 17:43:18 -05:00
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
#include "ardour_ui.h"
|
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include <fstream>
|
2008-02-16 17:43:18 -05:00
|
|
|
#include <iostream>
|
2005-09-25 14:42:24 -04:00
|
|
|
|
|
|
|
#include <ctype.h>
|
|
|
|
|
2008-02-16 17:43:18 -05:00
|
|
|
#include <gtkmm/accelmap.h>
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
#include <gdk/gdkkeysyms.h>
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/error.h"
|
|
|
|
#include "pbd/file_utils.h"
|
2008-02-16 17:43:18 -05:00
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/filesystem_paths.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
|
|
|
|
#include "keyboard.h"
|
|
|
|
#include "gui_thread.h"
|
2008-02-16 17:43:18 -05:00
|
|
|
#include "opts.h"
|
2008-09-10 11:03:30 -04:00
|
|
|
#include "actions.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
|
|
|
|
#include "i18n.h"
|
|
|
|
|
2006-06-21 19:01:03 -04:00
|
|
|
using namespace PBD;
|
2008-02-16 17:43:18 -05:00
|
|
|
using namespace ARDOUR;
|
2008-09-10 11:03:30 -04:00
|
|
|
using namespace Gtk;
|
|
|
|
using namespace std;
|
2006-06-21 19:01:03 -04:00
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
#define KBD_DEBUG 1
|
|
|
|
bool debug_keyboard = false;
|
|
|
|
|
|
|
|
guint Keyboard::edit_but = 3;
|
|
|
|
guint Keyboard::edit_mod = GDK_CONTROL_MASK;
|
|
|
|
guint Keyboard::delete_but = 3;
|
|
|
|
guint Keyboard::delete_mod = GDK_SHIFT_MASK;
|
|
|
|
guint Keyboard::snap_mod = GDK_MOD3_MASK;
|
|
|
|
|
2008-01-10 16:20:59 -05:00
|
|
|
#ifdef GTKOSX
|
2008-02-16 17:43:18 -05:00
|
|
|
guint Keyboard::PrimaryModifier = GDK_META_MASK; // Command
|
|
|
|
guint Keyboard::SecondaryModifier = GDK_MOD1_MASK; // Alt/Option
|
2008-01-10 16:20:59 -05:00
|
|
|
guint Keyboard::TertiaryModifier = GDK_SHIFT_MASK; // Shift
|
2008-03-17 16:54:03 -04:00
|
|
|
guint Keyboard::Level4Modifier = GDK_CONTROL_MASK; // Control
|
2008-02-16 17:43:18 -05:00
|
|
|
guint Keyboard::CopyModifier = GDK_MOD1_MASK; // Alt/Option
|
2008-01-10 16:20:59 -05:00
|
|
|
guint Keyboard::RangeSelectModifier = GDK_SHIFT_MASK;
|
2008-12-12 09:43:24 -05:00
|
|
|
guint Keyboard::button2_modifiers = Keyboard::SecondaryModifier|Keyboard::Level4Modifier;
|
2008-01-10 16:20:59 -05:00
|
|
|
#else
|
|
|
|
guint Keyboard::PrimaryModifier = GDK_CONTROL_MASK; // Control
|
|
|
|
guint Keyboard::SecondaryModifier = GDK_MOD1_MASK; // Alt/Option
|
|
|
|
guint Keyboard::TertiaryModifier = GDK_SHIFT_MASK; // Shift
|
2008-03-17 16:54:03 -04:00
|
|
|
guint Keyboard::Level4Modifier = GDK_MOD4_MASK; // Mod4/Windows
|
2008-01-10 16:20:59 -05:00
|
|
|
guint Keyboard::CopyModifier = GDK_CONTROL_MASK;
|
|
|
|
guint Keyboard::RangeSelectModifier = GDK_SHIFT_MASK;
|
2008-12-12 09:43:24 -05:00
|
|
|
guint Keyboard::button2_modifiers = 0; /* not used */
|
2008-01-10 16:20:59 -05:00
|
|
|
#endif
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
Keyboard* Keyboard::_the_keyboard = 0;
|
|
|
|
Gtk::Window* Keyboard::current_window = 0;
|
|
|
|
bool Keyboard::_some_magic_widget_has_focus = false;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2008-02-16 17:43:18 -05:00
|
|
|
std::string Keyboard::user_keybindings_path;
|
|
|
|
bool Keyboard::can_save_keybindings = false;
|
2008-09-10 11:03:30 -04:00
|
|
|
bool Keyboard::bindings_changed_after_save_became_legal = false;
|
2008-02-16 17:43:18 -05:00
|
|
|
map<string,string> Keyboard::binding_files;
|
2008-09-10 11:03:30 -04:00
|
|
|
string Keyboard::_current_binding_name = _("Unknown");
|
|
|
|
map<AccelKey,pair<string,string>,Keyboard::AccelKeyLess> Keyboard::release_keys;
|
2008-02-16 17:43:18 -05:00
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
/* set this to initially contain the modifiers we care about, then track changes in ::set_edit_modifier() etc. */
|
|
|
|
|
2007-02-08 22:36:00 -05:00
|
|
|
GdkModifierType Keyboard::RelevantModifierKeyMask;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2007-05-22 20:06:16 -04:00
|
|
|
void
|
|
|
|
Keyboard::magic_widget_grab_focus ()
|
|
|
|
{
|
|
|
|
_some_magic_widget_has_focus = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::magic_widget_drop_focus ()
|
|
|
|
{
|
|
|
|
_some_magic_widget_has_focus = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
Keyboard::some_magic_widget_has_focus ()
|
|
|
|
{
|
|
|
|
return _some_magic_widget_has_focus;
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
|
|
|
Keyboard::Keyboard ()
|
|
|
|
{
|
|
|
|
if (_the_keyboard == 0) {
|
|
|
|
_the_keyboard = this;
|
|
|
|
}
|
|
|
|
|
2007-02-08 22:36:00 -05:00
|
|
|
RelevantModifierKeyMask = (GdkModifierType) gtk_accelerator_get_default_mod_mask ();
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2008-01-10 16:20:59 -05:00
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | PrimaryModifier);
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | SecondaryModifier);
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | TertiaryModifier);
|
2008-03-17 16:54:03 -04:00
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | Level4Modifier);
|
2008-01-10 16:20:59 -05:00
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | CopyModifier);
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | RangeSelectModifier);
|
2007-02-08 22:36:00 -05:00
|
|
|
|
2008-03-17 16:54:03 -04:00
|
|
|
gtk_accelerator_set_default_mod_mask (RelevantModifierKeyMask);
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
snooper_id = gtk_key_snooper_install (_snooper, (gpointer) this);
|
|
|
|
|
|
|
|
XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
|
|
|
|
set_state (*node);
|
|
|
|
}
|
|
|
|
|
|
|
|
Keyboard::~Keyboard ()
|
|
|
|
{
|
|
|
|
gtk_key_snooper_remove (snooper_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLNode&
|
|
|
|
Keyboard::get_state (void)
|
|
|
|
{
|
|
|
|
XMLNode* node = new XMLNode ("Keyboard");
|
|
|
|
char buf[32];
|
|
|
|
|
|
|
|
snprintf (buf, sizeof (buf), "%d", edit_but);
|
|
|
|
node->add_property ("edit-button", buf);
|
|
|
|
snprintf (buf, sizeof (buf), "%d", edit_mod);
|
|
|
|
node->add_property ("edit-modifier", buf);
|
|
|
|
snprintf (buf, sizeof (buf), "%d", delete_but);
|
|
|
|
node->add_property ("delete-button", buf);
|
|
|
|
snprintf (buf, sizeof (buf), "%d", delete_mod);
|
|
|
|
node->add_property ("delete-modifier", buf);
|
|
|
|
snprintf (buf, sizeof (buf), "%d", snap_mod);
|
|
|
|
node->add_property ("snap-modifier", buf);
|
|
|
|
|
|
|
|
return *node;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
Keyboard::set_state (const XMLNode& node)
|
|
|
|
{
|
|
|
|
const XMLProperty* prop;
|
|
|
|
|
|
|
|
if ((prop = node.property ("edit-button")) != 0) {
|
|
|
|
sscanf (prop->value().c_str(), "%d", &edit_but);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((prop = node.property ("edit-modifier")) != 0) {
|
|
|
|
sscanf (prop->value().c_str(), "%d", &edit_mod);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((prop = node.property ("delete-button")) != 0) {
|
|
|
|
sscanf (prop->value().c_str(), "%d", &delete_but);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((prop = node.property ("delete-modifier")) != 0) {
|
|
|
|
sscanf (prop->value().c_str(), "%d", &delete_mod);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((prop = node.property ("snap-modifier")) != 0) {
|
|
|
|
sscanf (prop->value().c_str(), "%d", &snap_mod);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
|
|
|
Keyboard::_snooper (GtkWidget *widget, GdkEventKey *event, gpointer data)
|
|
|
|
{
|
|
|
|
return ((Keyboard *) data)->snooper (widget, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
|
|
|
Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
|
|
|
|
{
|
|
|
|
uint32_t keyval;
|
2008-09-10 11:03:30 -04:00
|
|
|
bool ret = false;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2008-01-10 16:20:59 -05:00
|
|
|
#if 0
|
|
|
|
cerr << "snoop widget " << widget << " key " << event->keyval << " type: " << event->type
|
|
|
|
<< " state " << std::hex << event->state << std::dec
|
|
|
|
<< endl;
|
|
|
|
#endif
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
#if KBD_DEBUG
|
|
|
|
if (debug_keyboard) {
|
|
|
|
cerr << "snoop widget " << widget << " key " << event->keyval << " type: " << event->type
|
|
|
|
<< endl;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (event->keyval == GDK_Shift_R) {
|
|
|
|
keyval = GDK_Shift_L;
|
|
|
|
|
|
|
|
} else if (event->keyval == GDK_Control_R) {
|
|
|
|
keyval = GDK_Control_L;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
keyval = event->keyval;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (event->type == GDK_KEY_PRESS) {
|
|
|
|
|
|
|
|
if (find (state.begin(), state.end(), keyval) == state.end()) {
|
|
|
|
state.push_back (keyval);
|
|
|
|
sort (state.begin(), state.end());
|
2008-09-10 11:03:30 -04:00
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* key is already down. if its also used for release,
|
|
|
|
prevent auto-repeat events.
|
|
|
|
*/
|
|
|
|
|
|
|
|
for (map<AccelKey,two_strings,AccelKeyLess>::iterator k = release_keys.begin(); k != release_keys.end(); ++k) {
|
|
|
|
|
|
|
|
const AccelKey& ak (k->first);
|
|
|
|
|
|
|
|
if (keyval == ak.get_key() && (Gdk::ModifierType)(event->state | Gdk::RELEASE_MASK) == ak.get_mod()) {
|
2009-08-26 23:09:30 -04:00
|
|
|
cerr << "Suppress auto repeat\n";
|
2008-09-10 11:03:30 -04:00
|
|
|
ret = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
|
|
|
} else if (event->type == GDK_KEY_RELEASE) {
|
|
|
|
|
|
|
|
State::iterator i;
|
|
|
|
|
|
|
|
if ((i = find (state.begin(), state.end(), keyval)) != state.end()) {
|
|
|
|
state.erase (i);
|
|
|
|
sort (state.begin(), state.end());
|
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
for (map<AccelKey,two_strings,AccelKeyLess>::iterator k = release_keys.begin(); k != release_keys.end(); ++k) {
|
|
|
|
|
|
|
|
const AccelKey& ak (k->first);
|
|
|
|
two_strings ts (k->second);
|
|
|
|
|
|
|
|
if (keyval == ak.get_key() && (Gdk::ModifierType)(event->state | Gdk::RELEASE_MASK) == ak.get_mod()) {
|
|
|
|
Glib::RefPtr<Gtk::Action> act = ActionManager::get_action (ts.first.c_str(), ts.second.c_str());
|
|
|
|
if (act) {
|
|
|
|
act->activate();
|
2009-08-26 23:09:30 -04:00
|
|
|
cerr << "use repeat, suppress other\n";
|
2008-09-10 11:03:30 -04:00
|
|
|
ret = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
/* Special keys that we want to handle in
|
|
|
|
any dialog, no matter whether it uses
|
|
|
|
the regular set of accelerators or not
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (event->type == GDK_KEY_RELEASE && modifier_state_equals (event->state, PrimaryModifier)) {
|
|
|
|
switch (event->keyval) {
|
|
|
|
case GDK_w:
|
|
|
|
if (current_window) {
|
|
|
|
current_window->hide ();
|
|
|
|
current_window = 0;
|
|
|
|
ret = true;
|
|
|
|
}
|
|
|
|
break;
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
return ret;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
Keyboard::key_is_down (uint32_t keyval)
|
|
|
|
{
|
|
|
|
return find (state.begin(), state.end(), keyval) != state.end();
|
|
|
|
}
|
|
|
|
|
2005-11-22 23:13:32 -05:00
|
|
|
bool
|
2009-07-21 11:55:17 -04:00
|
|
|
Keyboard::enter_window (GdkEventCrossing *, Gtk::Window* win)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2007-10-11 18:07:47 -04:00
|
|
|
current_window = win;
|
2007-02-08 22:36:00 -05:00
|
|
|
return false;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2005-11-22 23:13:32 -05:00
|
|
|
bool
|
2009-07-21 11:55:17 -04:00
|
|
|
Keyboard::leave_window (GdkEventCrossing *ev, Gtk::Window* /*win*/)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2008-12-12 09:43:24 -05:00
|
|
|
if (ev) {
|
|
|
|
switch (ev->detail) {
|
|
|
|
case GDK_NOTIFY_INFERIOR:
|
|
|
|
if (debug_keyboard) {
|
|
|
|
cerr << "INFERIOR crossing ... out\n";
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDK_NOTIFY_VIRTUAL:
|
|
|
|
if (debug_keyboard) {
|
|
|
|
cerr << "VIRTUAL crossing ... out\n";
|
|
|
|
}
|
|
|
|
/* fallthru */
|
|
|
|
|
|
|
|
default:
|
|
|
|
if (debug_keyboard) {
|
|
|
|
cerr << "REAL CROSSING ... out\n";
|
|
|
|
cerr << "clearing current target\n";
|
|
|
|
}
|
|
|
|
state.clear ();
|
|
|
|
current_window = 0;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2008-12-12 09:43:24 -05:00
|
|
|
} else {
|
2007-10-11 18:07:47 -04:00
|
|
|
current_window = 0;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2007-02-08 22:36:00 -05:00
|
|
|
return false;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::set_edit_button (guint but)
|
|
|
|
{
|
|
|
|
edit_but = but;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::set_edit_modifier (guint mod)
|
|
|
|
{
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask & ~edit_mod);
|
|
|
|
edit_mod = mod;
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | edit_mod);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::set_delete_button (guint but)
|
|
|
|
{
|
|
|
|
delete_but = but;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::set_delete_modifier (guint mod)
|
|
|
|
{
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask & ~delete_mod);
|
|
|
|
delete_mod = mod;
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | delete_mod);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-01-10 16:20:59 -05:00
|
|
|
Keyboard::set_modifier (uint32_t newval, uint32_t& var)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2008-01-10 16:20:59 -05:00
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask & ~var);
|
|
|
|
var = newval;
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | var);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::set_snap_modifier (guint mod)
|
|
|
|
{
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask & ~snap_mod);
|
|
|
|
snap_mod = mod;
|
|
|
|
RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | snap_mod);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
Keyboard::is_edit_event (GdkEventButton *ev)
|
|
|
|
{
|
|
|
|
return (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_BUTTON_RELEASE) &&
|
|
|
|
(ev->button == Keyboard::edit_button()) &&
|
|
|
|
((ev->state & RelevantModifierKeyMask) == Keyboard::edit_modifier());
|
|
|
|
}
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
bool
|
|
|
|
Keyboard::is_button2_event (GdkEventButton* ev)
|
|
|
|
{
|
|
|
|
#ifdef GTKOSX
|
|
|
|
return (ev->button == 2) ||
|
|
|
|
((ev->button == 1) &&
|
|
|
|
((ev->state & Keyboard::button2_modifiers) == Keyboard::button2_modifiers));
|
|
|
|
#else
|
|
|
|
return ev->button == 2;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
bool
|
|
|
|
Keyboard::is_delete_event (GdkEventButton *ev)
|
|
|
|
{
|
|
|
|
return (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_BUTTON_RELEASE) &&
|
|
|
|
(ev->button == Keyboard::delete_button()) &&
|
|
|
|
((ev->state & RelevantModifierKeyMask) == Keyboard::delete_modifier());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
Keyboard::is_context_menu_event (GdkEventButton *ev)
|
|
|
|
{
|
|
|
|
return (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_BUTTON_RELEASE) &&
|
|
|
|
(ev->button == 3) &&
|
|
|
|
((ev->state & RelevantModifierKeyMask) == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
Keyboard::no_modifiers_active (guint state)
|
|
|
|
{
|
|
|
|
return (state & RelevantModifierKeyMask) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
Keyboard::modifier_state_contains (guint state, ModifierMask mask)
|
|
|
|
{
|
|
|
|
return (state & mask) == (guint) mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
Keyboard::modifier_state_equals (guint state, ModifierMask mask)
|
|
|
|
{
|
|
|
|
return (state & RelevantModifierKeyMask) == (guint) mask;
|
|
|
|
}
|
|
|
|
|
2006-03-05 14:39:16 -05:00
|
|
|
Selection::Operation
|
|
|
|
Keyboard::selection_type (guint state)
|
|
|
|
{
|
2006-11-09 15:38:39 -05:00
|
|
|
/* note that there is no modifier for "Add" */
|
|
|
|
|
2008-01-10 16:20:59 -05:00
|
|
|
if (modifier_state_equals (state, RangeSelectModifier)) {
|
2006-03-05 14:39:16 -05:00
|
|
|
return Selection::Extend;
|
2008-01-10 16:20:59 -05:00
|
|
|
} else if (modifier_state_equals (state, PrimaryModifier)) {
|
2006-03-05 14:39:16 -05:00
|
|
|
return Selection::Toggle;
|
|
|
|
} else {
|
|
|
|
return Selection::Set;
|
|
|
|
}
|
|
|
|
}
|
2008-02-16 17:43:18 -05:00
|
|
|
|
|
|
|
|
|
|
|
static void
|
2009-07-21 11:55:17 -04:00
|
|
|
accel_map_changed (GtkAccelMap* /*map*/,
|
|
|
|
gchar* /*path*/,
|
|
|
|
guint /*key*/,
|
|
|
|
GdkModifierType /*mod*/,
|
|
|
|
gpointer /*arg*/)
|
2008-02-16 17:43:18 -05:00
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
Keyboard::keybindings_changed ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::keybindings_changed ()
|
|
|
|
{
|
|
|
|
if (Keyboard::can_save_keybindings) {
|
|
|
|
Keyboard::bindings_changed_after_save_became_legal = true;
|
|
|
|
}
|
|
|
|
|
2008-02-16 17:43:18 -05:00
|
|
|
Keyboard::save_keybindings ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::set_can_save_keybindings (bool yn)
|
|
|
|
{
|
|
|
|
can_save_keybindings = yn;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::save_keybindings ()
|
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
if (can_save_keybindings && bindings_changed_after_save_became_legal) {
|
2008-02-16 17:43:18 -05:00
|
|
|
Gtk::AccelMap::save (user_keybindings_path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Keyboard::setup_keybindings ()
|
|
|
|
{
|
|
|
|
using namespace ARDOUR_COMMAND_LINE;
|
|
|
|
std::string default_bindings = "mnemonic-us.bindings";
|
|
|
|
vector<string> strs;
|
|
|
|
|
|
|
|
binding_files.clear ();
|
|
|
|
|
|
|
|
ARDOUR::find_bindings_files (binding_files);
|
|
|
|
|
|
|
|
/* set up the per-user bindings path */
|
|
|
|
|
|
|
|
strs.push_back (Glib::get_home_dir());
|
2008-02-21 14:30:01 -05:00
|
|
|
strs.push_back (".ardour3");
|
2008-02-16 17:43:18 -05:00
|
|
|
strs.push_back ("ardour.bindings");
|
|
|
|
|
|
|
|
user_keybindings_path = Glib::build_filename (strs);
|
|
|
|
|
|
|
|
if (Glib::file_test (user_keybindings_path, Glib::FILE_TEST_EXISTS)) {
|
|
|
|
std::pair<string,string> newpair;
|
|
|
|
newpair.first = _("your own");
|
|
|
|
newpair.second = user_keybindings_path;
|
|
|
|
binding_files.insert (newpair);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check to see if they gave a style name ("SAE", "ergonomic") or
|
|
|
|
an actual filename (*.bindings)
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!keybindings_path.empty() && keybindings_path.find (".bindings") == string::npos) {
|
|
|
|
|
|
|
|
// just a style name - allow user to
|
|
|
|
// specify the layout type.
|
|
|
|
|
|
|
|
char* layout;
|
|
|
|
|
|
|
|
if ((layout = getenv ("ARDOUR_KEYBOARD_LAYOUT")) != 0 && layout[0] != '\0') {
|
|
|
|
|
|
|
|
/* user-specified keyboard layout */
|
|
|
|
|
|
|
|
keybindings_path += '-';
|
|
|
|
keybindings_path += layout;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* default to US/ANSI - we have to pick something */
|
|
|
|
|
|
|
|
keybindings_path += "-us";
|
|
|
|
}
|
|
|
|
|
|
|
|
keybindings_path += ".bindings";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (keybindings_path.empty()) {
|
|
|
|
|
|
|
|
/* no path or binding name given: check the user one first */
|
|
|
|
|
|
|
|
if (!Glib::file_test (user_keybindings_path, Glib::FILE_TEST_EXISTS)) {
|
|
|
|
|
|
|
|
keybindings_path = "";
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
keybindings_path = user_keybindings_path;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if we still don't have a path at this point, use the default */
|
|
|
|
|
|
|
|
if (keybindings_path.empty()) {
|
|
|
|
keybindings_path = default_bindings;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
|
|
|
|
if (!Glib::path_is_absolute (keybindings_path)) {
|
|
|
|
|
|
|
|
/* not absolute - look in the usual places */
|
|
|
|
sys::path keybindings_file;
|
|
|
|
|
|
|
|
SearchPath spath = ardour_search_path() + user_config_directory() + system_config_search_path();
|
|
|
|
|
2008-02-21 14:30:01 -05:00
|
|
|
if ( ! find_file_in_search_path (spath, keybindings_path, keybindings_file)) {
|
2008-02-16 17:43:18 -05:00
|
|
|
|
|
|
|
if (keybindings_path == default_bindings) {
|
|
|
|
error << _("Default keybindings not found - Ardour will be hard to use!") << endmsg;
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
warning << string_compose (_("Key bindings file \"%1\" not found. Default bindings used instead"),
|
|
|
|
keybindings_path)
|
|
|
|
<< endmsg;
|
|
|
|
keybindings_path = default_bindings;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* use it */
|
|
|
|
|
2008-02-21 14:30:01 -05:00
|
|
|
keybindings_path = keybindings_file.to_string();
|
2008-02-16 17:43:18 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* path is absolute already */
|
|
|
|
|
|
|
|
if (!Glib::file_test (keybindings_path, Glib::FILE_TEST_EXISTS)) {
|
|
|
|
if (keybindings_path == default_bindings) {
|
|
|
|
error << _("Default keybindings not found - Ardour will be hard to use!") << endmsg;
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
warning << string_compose (_("Key bindings file \"%1\" not found. Default bindings used instead"),
|
|
|
|
keybindings_path)
|
|
|
|
<< endmsg;
|
|
|
|
keybindings_path = default_bindings;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
load_keybindings (keybindings_path);
|
|
|
|
|
|
|
|
/* catch changes */
|
|
|
|
|
|
|
|
GtkAccelMap* accelmap = gtk_accel_map_get();
|
|
|
|
g_signal_connect (accelmap, "changed", (GCallback) accel_map_changed, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
Keyboard::load_keybindings (string path)
|
|
|
|
{
|
|
|
|
try {
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
cerr << "Loading bindings from " << path << endl;
|
2008-02-16 17:43:18 -05:00
|
|
|
|
|
|
|
Gtk::AccelMap::load (path);
|
|
|
|
|
|
|
|
_current_binding_name = _("Unknown");
|
|
|
|
|
|
|
|
for (map<string,string>::iterator x = binding_files.begin(); x != binding_files.end(); ++x) {
|
|
|
|
if (path == x->second) {
|
|
|
|
_current_binding_name = x->first;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} catch (...) {
|
|
|
|
error << string_compose (_("Ardour key bindings file not found at \"%1\" or contains errors."), path)
|
|
|
|
<< endmsg;
|
|
|
|
return false;
|
|
|
|
}
|
2008-09-10 11:03:30 -04:00
|
|
|
|
|
|
|
/* now find all release-driven bindings */
|
|
|
|
|
|
|
|
vector<string> groups;
|
|
|
|
vector<string> names;
|
|
|
|
vector<AccelKey> bindings;
|
|
|
|
|
|
|
|
ActionManager::get_all_actions (groups, names, bindings);
|
|
|
|
|
|
|
|
vector<string>::iterator g;
|
|
|
|
vector<AccelKey>::iterator b;
|
|
|
|
vector<string>::iterator n;
|
|
|
|
|
|
|
|
release_keys.clear ();
|
|
|
|
|
2009-04-15 14:04:23 -04:00
|
|
|
bool show_bindings = (getenv ("ARDOUR_SHOW_BINDINGS") != 0);
|
|
|
|
|
|
|
|
for (n = names.begin(), b = bindings.begin(), g = groups.begin(); n != names.end(); ++n, ++b, ++g) {
|
|
|
|
|
|
|
|
if (show_bindings) {
|
|
|
|
|
|
|
|
cerr << "Action: " << (*n) << " Group: " << (*g) << " binding = ";
|
|
|
|
|
|
|
|
if ((*b).get_key() != GDK_VoidSymbol) {
|
|
|
|
cerr << (*b).get_key() << " w/mod = " << hex << (*b).get_mod() << dec << " = " << (*b).get_abbrev();
|
|
|
|
} else {
|
|
|
|
cerr << "unbound";
|
|
|
|
}
|
|
|
|
|
|
|
|
cerr << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
for (n = names.begin(), b = bindings.begin(), g = groups.begin(); n != names.end(); ++n, ++b, ++g) {
|
|
|
|
if ((*b).get_mod() & Gdk::RELEASE_MASK) {
|
|
|
|
release_keys.insert (pair<AccelKey,two_strings> (*b, two_strings (*g, *n)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2008-02-16 17:43:18 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|