gtk2_ardour/keyboard.cc

   1 /*
   2     Copyright (C) 2001 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "ardour_ui.h"
  21
  22 #include <algorithm>
  23 #include <fstream>
  24
  25 #include <ctype.h>
  26
  27 #include <gdk/gdkkeysyms.h>
  28 #include <pbd/error.h>
  29
  30 #include "keyboard.h"
  31 #include "gui_thread.h"
  32
  33 #include "i18n.h"
  34
  35 using namespace PBD;
  36
  37 #define KBD_DEBUG 1
  38 bool debug_keyboard = false;
  39
  40 guint Keyboard::edit_but = 3;
  41 guint Keyboard::edit_mod = GDK_CONTROL_MASK;
  42 guint Keyboard::delete_but = 3;
  43 guint Keyboard::delete_mod = GDK_SHIFT_MASK;
  44 guint Keyboard::snap_mod = GDK_MOD3_MASK;
  45
  46 #ifdef GTKOSX
  47 guint Keyboard::PrimaryModifier = GDK_MOD1_MASK;   // Command
  48 guint Keyboard::SecondaryModifier = GDK_MOD5_MASK; // Alt/Option
  49 guint Keyboard::TertiaryModifier = GDK_SHIFT_MASK; // Shift
  50 guint Keyboard::CopyModifier = GDK_MOD5_MASK;      // Alt/Option
  51 guint Keyboard::RangeSelectModifier = GDK_SHIFT_MASK;
  52 #else
  53 guint Keyboard::PrimaryModifier = GDK_CONTROL_MASK; // Control
  54 guint Keyboard::SecondaryModifier = GDK_MOD1_MASK;  // Alt/Option
  55 guint Keyboard::TertiaryModifier = GDK_SHIFT_MASK;  // Shift
  56 guint Keyboard::CopyModifier = GDK_CONTROL_MASK;
  57 guint Keyboard::RangeSelectModifier = GDK_SHIFT_MASK;
  58 #endif
  59
  60 Keyboard*    Keyboard::_the_keyboard = 0;
  61 Gtk::Window* Keyboard::current_window = 0;
  62 bool         Keyboard::_some_magic_widget_has_focus = false;
  63
  64 /* set this to initially contain the modifiers we care about, then track changes in ::set_edit_modifier() etc. */
  65
  66 GdkModifierType Keyboard::RelevantModifierKeyMask;
  67
  68 void
  69 Keyboard::magic_widget_grab_focus ()
  70 {
  71         _some_magic_widget_has_focus = true;
  72 }
  73
  74 void
  75 Keyboard::magic_widget_drop_focus ()
  76 {
  77         _some_magic_widget_has_focus = false;
  78 }
  79
  80 bool
  81 Keyboard::some_magic_widget_has_focus ()
  82 {
  83         return _some_magic_widget_has_focus;
  84 }
  85
  86 Keyboard::Keyboard ()
  87 {
  88         if (_the_keyboard == 0) {
  89                 _the_keyboard = this;
  90         }
  91
  92         RelevantModifierKeyMask = (GdkModifierType) gtk_accelerator_get_default_mod_mask ();
  93
  94         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | PrimaryModifier);
  95         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | SecondaryModifier);
  96         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | TertiaryModifier);
  97         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | CopyModifier);
  98         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | RangeSelectModifier);
  99
 100         snooper_id = gtk_key_snooper_install (_snooper, (gpointer) this);
 101
 102         XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
 103         set_state (*node);
 104 }
 105
 106 Keyboard::~Keyboard ()
 107 {
 108         gtk_key_snooper_remove (snooper_id);
 109 }
 110
 111 XMLNode&
 112 Keyboard::get_state (void)
 113 {
 114         XMLNode* node = new XMLNode ("Keyboard");
 115         char buf[32];
 116
 117         snprintf (buf, sizeof (buf), "%d", edit_but);
 118         node->add_property ("edit-button", buf);
 119         snprintf (buf, sizeof (buf), "%d", edit_mod);
 120         node->add_property ("edit-modifier", buf);
 121         snprintf (buf, sizeof (buf), "%d", delete_but);
 122         node->add_property ("delete-button", buf);
 123         snprintf (buf, sizeof (buf), "%d", delete_mod);
 124         node->add_property ("delete-modifier", buf);
 125         snprintf (buf, sizeof (buf), "%d", snap_mod);
 126         node->add_property ("snap-modifier", buf);
 127
 128         return *node;
 129 }
 130
 131 int
 132 Keyboard::set_state (const XMLNode& node)
 133 {
 134         const XMLProperty* prop;
 135
 136         if ((prop = node.property ("edit-button")) != 0) {
 137                 sscanf (prop->value().c_str(), "%d", &edit_but);
 138         }
 139
 140         if ((prop = node.property ("edit-modifier")) != 0) {
 141                 sscanf (prop->value().c_str(), "%d", &edit_mod);
 142         }
 143
 144         if ((prop = node.property ("delete-button")) != 0) {
 145                 sscanf (prop->value().c_str(), "%d", &delete_but);
 146         }
 147
 148         if ((prop = node.property ("delete-modifier")) != 0) {
 149                 sscanf (prop->value().c_str(), "%d", &delete_mod);
 150         }
 151
 152         if ((prop = node.property ("snap-modifier")) != 0) {
 153                 sscanf (prop->value().c_str(), "%d", &snap_mod);
 154         }
 155
 156         return 0;
 157 }
 158
 159 gint
 160 Keyboard::_snooper (GtkWidget *widget, GdkEventKey *event, gpointer data)
 161 {
 162         return ((Keyboard *) data)->snooper (widget, event);
 163 }
 164
 165 gint
 166 Keyboard::snooper (GtkWidget *widget, GdkEventKey *event)
 167 {
 168         uint32_t keyval;
 169
 170 #if 0
 171         cerr << "snoop widget " << widget << " key " << event->keyval << " type: " << event->type
 172              << " state " << std::hex << event->state << std::dec
 173              << endl;
 174 #endif
 175
 176 #if KBD_DEBUG
 177         if (debug_keyboard) {
 178                 cerr << "snoop widget " << widget << " key " << event->keyval << " type: " << event->type
 179                      << endl;
 180         }
 181 #endif
 182
 183         if (event->keyval == GDK_Shift_R) {
 184                 keyval = GDK_Shift_L;
 185
 186         } else  if (event->keyval == GDK_Control_R) {
 187                 keyval = GDK_Control_L;
 188
 189         } else {
 190                 keyval = event->keyval;
 191         }
 192
 193         if (event->type == GDK_KEY_PRESS) {
 194
 195                 if (find (state.begin(), state.end(), keyval) == state.end()) {
 196                         state.push_back (keyval);
 197                         sort (state.begin(), state.end());
 198                 }
 199
 200         } else if (event->type == GDK_KEY_RELEASE) {
 201
 202                 State::iterator i;
 203
 204                 if ((i = find (state.begin(), state.end(), keyval)) != state.end()) {
 205                         state.erase (i);
 206                         sort (state.begin(), state.end());
 207                 }
 208
 209         }
 210
 211         if (event->type == GDK_KEY_RELEASE && event->keyval == GDK_w && modifier_state_equals (event->state, PrimaryModifier)) {
 212                 if (current_window) {
 213                         current_window->hide ();
 214                         current_window = 0;
 215                 }
 216         }
 217
 218         return false;
 219 }
 220
 221 bool
 222 Keyboard::key_is_down (uint32_t keyval)
 223 {
 224         return find (state.begin(), state.end(), keyval) != state.end();
 225 }
 226
 227 bool
 228 Keyboard::enter_window (GdkEventCrossing *ev, Gtk::Window* win)
 229 {
 230         current_window = win;
 231         return false;
 232 }
 233
 234 bool
 235 Keyboard::leave_window (GdkEventCrossing *ev, Gtk::Window* win)
 236 {
 237         switch (ev->detail) {
 238         case GDK_NOTIFY_INFERIOR:
 239                 if (debug_keyboard) {
 240                         cerr << "INFERIOR crossing ... out\n";
 241                 }
 242                 break;
 243
 244         case GDK_NOTIFY_VIRTUAL:
 245                 if (debug_keyboard) {
 246                         cerr << "VIRTUAL crossing ... out\n";
 247                 }
 248                 /* fallthru */
 249
 250         default:
 251                 if (debug_keyboard) {
 252                         cerr << "REAL CROSSING ... out\n";
 253                         cerr << "clearing current target\n";
 254                 }
 255                 state.clear ();
 256                 current_window = 0;
 257         }
 258
 259         return false;
 260 }
 261
 262 void
 263 Keyboard::set_edit_button (guint but)
 264 {
 265         edit_but = but;
 266 }
 267
 268 void
 269 Keyboard::set_edit_modifier (guint mod)
 270 {
 271         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask & ~edit_mod);
 272         edit_mod = mod;
 273         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | edit_mod);
 274 }
 275
 276 void
 277 Keyboard::set_delete_button (guint but)
 278 {
 279         delete_but = but;
 280 }
 281
 282 void
 283 Keyboard::set_delete_modifier (guint mod)
 284 {
 285         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask & ~delete_mod);
 286         delete_mod = mod;
 287         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | delete_mod);
 288 }
 289
 290 void
 291 Keyboard::set_modifier (uint32_t newval, uint32_t& var)
 292 {
 293         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask & ~var);
 294         var = newval;
 295         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | var);
 296 }
 297
 298 void
 299 Keyboard::set_snap_modifier (guint mod)
 300 {
 301         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask & ~snap_mod);
 302         snap_mod = mod;
 303         RelevantModifierKeyMask = GdkModifierType (RelevantModifierKeyMask | snap_mod);
 304 }
 305
 306 bool
 307 Keyboard::is_edit_event (GdkEventButton *ev)
 308 {
 309
 310         return (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_BUTTON_RELEASE) &&
 311                 (ev->button == Keyboard::edit_button()) &&
 312                 ((ev->state & RelevantModifierKeyMask) == Keyboard::edit_modifier());
 313 }
 314
 315 bool
 316 Keyboard::is_delete_event (GdkEventButton *ev)
 317 {
 318         return (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_BUTTON_RELEASE) &&
 319                 (ev->button == Keyboard::delete_button()) &&
 320                 ((ev->state & RelevantModifierKeyMask) == Keyboard::delete_modifier());
 321 }
 322
 323 bool
 324 Keyboard::is_context_menu_event (GdkEventButton *ev)
 325 {
 326         return (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_BUTTON_RELEASE) &&
 327                 (ev->button == 3) &&
 328                 ((ev->state & RelevantModifierKeyMask) == 0);
 329 }
 330
 331 bool
 332 Keyboard::no_modifiers_active (guint state)
 333 {
 334         return (state & RelevantModifierKeyMask) == 0;
 335 }
 336
 337 bool
 338 Keyboard::modifier_state_contains (guint state, ModifierMask mask)
 339 {
 340         return (state & mask) == (guint) mask;
 341 }
 342
 343 bool
 344 Keyboard::modifier_state_equals (guint state, ModifierMask mask)
 345 {
 346         return (state & RelevantModifierKeyMask) == (guint) mask;
 347 }
 348
 349 Selection::Operation
 350 Keyboard::selection_type (guint state)
 351 {
 352         /* note that there is no modifier for "Add" */
 353
 354         if (modifier_state_equals (state, RangeSelectModifier)) {
 355                 return Selection::Extend;
 356         } else if (modifier_state_equals (state, PrimaryModifier)) {
 357                 return Selection::Toggle;
 358         } else {
 359                 return Selection::Set;
 360         }
 361 }