libs/surfaces/push2/buttons.cc

   1 /*
   2   Copyright (C) 2016 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 #include <algorithm>
  20
  21 #include "ardour/debug.h"
  22 #include "ardour/mute_control.h"
  23 #include "ardour/session.h"
  24 #include "ardour/solo_control.h"
  25
  26 #include "layout.h"
  27 #include "push2.h"
  28 #include "track_mix.h"
  29
  30 using namespace ArdourSurface;
  31 using namespace ARDOUR;
  32 using namespace PBD;
  33 using std::cerr;
  34
  35 void
  36 Push2::build_maps ()
  37 {
  38         /* Pads */
  39
  40         Pad* pad;
  41
  42 #define MAKE_PAD(x,y,nn) \
  43         pad = new Pad ((x), (y), (nn)); \
  44         nn_pad_map.insert (std::make_pair (pad->extra(), pad));
  45
  46         MAKE_PAD (0, 0, 92);
  47         MAKE_PAD (0, 1, 93);
  48         MAKE_PAD (0, 2, 94);
  49         MAKE_PAD (0, 3, 95);
  50         MAKE_PAD (0, 4, 96);
  51         MAKE_PAD (0, 5, 97);
  52         MAKE_PAD (0, 6, 98);
  53         MAKE_PAD (0, 7, 99);
  54         MAKE_PAD (1, 0, 84);
  55         MAKE_PAD (1, 1, 85);
  56         MAKE_PAD (1, 2, 86);
  57         MAKE_PAD (1, 3, 87);
  58         MAKE_PAD (1, 4, 88);
  59         MAKE_PAD (1, 5, 89);
  60         MAKE_PAD (1, 6, 90);
  61         MAKE_PAD (1, 7, 91);
  62         MAKE_PAD (2, 0, 76);
  63         MAKE_PAD (2, 1, 77);
  64         MAKE_PAD (2, 2, 78);
  65         MAKE_PAD (2, 3, 79);
  66         MAKE_PAD (2, 4, 80);
  67         MAKE_PAD (2, 5, 81);
  68         MAKE_PAD (2, 6, 82);
  69         MAKE_PAD (2, 7, 83);
  70         MAKE_PAD (3, 0, 68);
  71         MAKE_PAD (3, 1, 69);
  72         MAKE_PAD (3, 2, 70);
  73         MAKE_PAD (3, 3, 71);
  74         MAKE_PAD (3, 4, 72);
  75         MAKE_PAD (3, 5, 73);
  76         MAKE_PAD (3, 6, 74);
  77         MAKE_PAD (3, 7, 75);
  78         MAKE_PAD (4, 0, 60);
  79         MAKE_PAD (4, 1, 61);
  80         MAKE_PAD (4, 2, 62);
  81         MAKE_PAD (4, 3, 63);
  82         MAKE_PAD (4, 4, 64);
  83         MAKE_PAD (4, 5, 65);
  84         MAKE_PAD (4, 6, 66);
  85         MAKE_PAD (4, 7, 67);
  86         MAKE_PAD (5, 0, 52);
  87         MAKE_PAD (5, 1, 53);
  88         MAKE_PAD (5, 2, 54);
  89         MAKE_PAD (5, 3, 55);
  90         MAKE_PAD (5, 4, 56);
  91         MAKE_PAD (5, 5, 57);
  92         MAKE_PAD (5, 6, 58);
  93         MAKE_PAD (5, 7, 59);
  94         MAKE_PAD (6, 0, 44);
  95         MAKE_PAD (6, 1, 45);
  96         MAKE_PAD (6, 2, 46);
  97         MAKE_PAD (6, 3, 47);
  98         MAKE_PAD (6, 4, 48);
  99         MAKE_PAD (6, 5, 49);
 100         MAKE_PAD (6, 6, 50);
 101         MAKE_PAD (6, 7, 51);
 102         MAKE_PAD (7, 0, 36);
 103         MAKE_PAD (7, 1, 37);
 104         MAKE_PAD (7, 2, 38);
 105         MAKE_PAD (7, 3, 39);
 106         MAKE_PAD (7, 4, 40);
 107         MAKE_PAD (7, 5, 41);
 108         MAKE_PAD (7, 6, 42);
 109         MAKE_PAD (7, 7, 43);
 110
 111         /* Now color buttons */
 112
 113         Button *button;
 114
 115 #define MAKE_COLOR_BUTTON(i,cc) \
 116         button = new ColorButton ((i), (cc)); \
 117         cc_button_map.insert (std::make_pair (button->controller_number(), button)); \
 118         id_button_map.insert (std::make_pair (button->id, button));
 119 #define MAKE_COLOR_BUTTON_PRESS(i,cc,p)\
 120         button = new ColorButton ((i), (cc), (p)); \
 121         cc_button_map.insert (std::make_pair (button->controller_number(), button)); \
 122         id_button_map.insert (std::make_pair (button->id, button))
 123 #define MAKE_COLOR_BUTTON_PRESS_RELEASE_LONG(i,cc,p,r,l)                      \
 124         button = new ColorButton ((i), (cc), (p), (r), (l)); \
 125         cc_button_map.insert (std::make_pair (button->controller_number(), button)); \
 126         id_button_map.insert (std::make_pair (button->id, button))
 127
 128         MAKE_COLOR_BUTTON_PRESS (Upper1, 102, &Push2::button_upper_1);
 129         MAKE_COLOR_BUTTON_PRESS (Upper2, 103, &Push2::button_upper_2);
 130         MAKE_COLOR_BUTTON_PRESS (Upper3, 104, &Push2::button_upper_3);
 131         MAKE_COLOR_BUTTON_PRESS (Upper4, 105, &Push2::button_upper_4);
 132         MAKE_COLOR_BUTTON_PRESS (Upper5, 106, &Push2::button_upper_5);
 133         MAKE_COLOR_BUTTON_PRESS (Upper6, 107, &Push2::button_upper_6);
 134         MAKE_COLOR_BUTTON_PRESS (Upper7, 108, &Push2::button_upper_7);
 135         MAKE_COLOR_BUTTON_PRESS (Upper8, 109, &Push2::button_upper_8);
 136         MAKE_COLOR_BUTTON_PRESS (Lower1, 20, &Push2::button_lower_1);
 137         MAKE_COLOR_BUTTON_PRESS (Lower2, 21, &Push2::button_lower_2);
 138         MAKE_COLOR_BUTTON_PRESS (Lower3, 22, &Push2::button_lower_3);
 139         MAKE_COLOR_BUTTON_PRESS (Lower4, 23, &Push2::button_lower_4);
 140         MAKE_COLOR_BUTTON_PRESS (Lower5, 24, &Push2::button_lower_5);
 141         MAKE_COLOR_BUTTON_PRESS (Lower6, 25, &Push2::button_lower_6);
 142         MAKE_COLOR_BUTTON_PRESS (Lower7, 26, &Push2::button_lower_7);
 143         MAKE_COLOR_BUTTON_PRESS (Lower8, 27, &Push2::button_lower_8);
 144         MAKE_COLOR_BUTTON_PRESS (Master, 28, &Push2::button_master);
 145         MAKE_COLOR_BUTTON_PRESS (Mute, 60, &Push2::button_mute);
 146         MAKE_COLOR_BUTTON_PRESS_RELEASE_LONG (Solo, 61, &Push2::relax, &Push2::button_solo, &Push2::button_solo_long_press);
 147         MAKE_COLOR_BUTTON_PRESS (Stop, 29, &Push2::button_stop);
 148         MAKE_COLOR_BUTTON_PRESS (Fwd32ndT, 43, &Push2::button_fwd32t);
 149         MAKE_COLOR_BUTTON_PRESS (Fwd32nd,42 , &Push2::button_fwd32);
 150         MAKE_COLOR_BUTTON_PRESS (Fwd16thT, 41, &Push2::button_fwd16t);
 151         MAKE_COLOR_BUTTON_PRESS (Fwd16th, 40, &Push2::button_fwd16);
 152         MAKE_COLOR_BUTTON_PRESS (Fwd8thT, 39 , &Push2::button_fwd8t);
 153         MAKE_COLOR_BUTTON_PRESS (Fwd8th, 38, &Push2::button_fwd8);
 154         MAKE_COLOR_BUTTON_PRESS (Fwd4trT, 37, &Push2::button_fwd4t);
 155         MAKE_COLOR_BUTTON_PRESS (Fwd4tr, 36, &Push2::button_fwd4);
 156         MAKE_COLOR_BUTTON (Automate, 89);
 157         MAKE_COLOR_BUTTON_PRESS (RecordEnable, 86, &Push2::button_recenable);
 158         MAKE_COLOR_BUTTON_PRESS (Play, 85, &Push2::button_play);
 159
 160 #define MAKE_WHITE_BUTTON(i,cc)\
 161         button = new WhiteButton ((i), (cc)); \
 162         cc_button_map.insert (std::make_pair (button->controller_number(), button)); \
 163         id_button_map.insert (std::make_pair (button->id, button))
 164 #define MAKE_WHITE_BUTTON_PRESS(i,cc,p)\
 165         button = new WhiteButton ((i), (cc), (p)); \
 166         cc_button_map.insert (std::make_pair (button->controller_number(), button)); \
 167         id_button_map.insert (std::make_pair (button->id, button))
 168 #define MAKE_WHITE_BUTTON_PRESS_RELEASE(i,cc,p,r)                                \
 169         button = new WhiteButton ((i), (cc), (p), (r)); \
 170         cc_button_map.insert (std::make_pair (button->controller_number(), button)); \
 171         id_button_map.insert (std::make_pair (button->id, button))
 172 #define MAKE_WHITE_BUTTON_PRESS_RELEASE_LONG(i,cc,p,r,l)                      \
 173         button = new WhiteButton ((i), (cc), (p), (r), (l)); \
 174         cc_button_map.insert (std::make_pair (button->controller_number(), button)); \
 175         id_button_map.insert (std::make_pair (button->id, button))
 176
 177         MAKE_WHITE_BUTTON (TapTempo, 3);
 178         MAKE_WHITE_BUTTON_PRESS (Metronome, 9, &Push2::button_metronome);
 179         MAKE_WHITE_BUTTON (Setup, 30);
 180         MAKE_WHITE_BUTTON (User, 59);
 181         MAKE_WHITE_BUTTON (Delete, 118);
 182         MAKE_WHITE_BUTTON (AddDevice, 52);
 183         MAKE_WHITE_BUTTON (Device, 110);
 184         MAKE_WHITE_BUTTON_PRESS (Mix, 112, &Push2::button_mix_press);
 185         MAKE_WHITE_BUTTON_PRESS (Undo, 119, &Push2::button_undo);
 186         MAKE_WHITE_BUTTON_PRESS (AddTrack, 53, &Push2::button_add_track);
 187         MAKE_WHITE_BUTTON_PRESS (Browse, 111, &Push2::button_browse);
 188         MAKE_WHITE_BUTTON_PRESS (Clip, 113, &Push2::button_clip);
 189         MAKE_WHITE_BUTTON (Convert, 35);
 190         MAKE_WHITE_BUTTON (DoubleLoop, 117);
 191         MAKE_WHITE_BUTTON_PRESS (Quantize, 116, &Push2::button_quantize);
 192         MAKE_WHITE_BUTTON_PRESS (Duplicate, 88, &Push2::button_duplicate);
 193         MAKE_WHITE_BUTTON_PRESS (New, 87, &Push2::button_new);
 194         MAKE_WHITE_BUTTON_PRESS (FixedLength, 90, &Push2::button_fixed_length);
 195         MAKE_WHITE_BUTTON_PRESS (Up, 46, &Push2::button_up);
 196         MAKE_WHITE_BUTTON_PRESS (Right, 45, &Push2::button_right);
 197         MAKE_WHITE_BUTTON_PRESS (Down, 47, &Push2::button_down);
 198         MAKE_WHITE_BUTTON_PRESS (Left, 44, &Push2::button_left);
 199         MAKE_WHITE_BUTTON_PRESS (Repeat, 56, &Push2::button_repeat);
 200         MAKE_WHITE_BUTTON (Accent, 57);
 201         MAKE_WHITE_BUTTON_PRESS (Scale, 58, &Push2::button_scale_press);
 202         MAKE_WHITE_BUTTON_PRESS (Layout, 31, &Push2::button_layout_press);
 203         MAKE_WHITE_BUTTON (Note, 50);
 204         MAKE_WHITE_BUTTON (Session, 51);
 205         MAKE_WHITE_BUTTON (Layout, 31);
 206         MAKE_WHITE_BUTTON_PRESS (OctaveUp, 55, &Push2::button_octave_up);
 207         MAKE_WHITE_BUTTON_PRESS (PageRight, 63, &Push2::button_page_right);
 208         MAKE_WHITE_BUTTON_PRESS (OctaveDown, 54, &Push2::button_octave_down);
 209         MAKE_WHITE_BUTTON_PRESS (PageLeft, 62, &Push2::button_page_left);
 210         MAKE_WHITE_BUTTON_PRESS_RELEASE_LONG (Shift, 49, &Push2::button_shift_press, &Push2::button_shift_release, &Push2::button_shift_long_press);
 211         MAKE_WHITE_BUTTON_PRESS_RELEASE_LONG (Select, 48, &Push2::button_select_press, &Push2::button_select_release, &Push2::button_select_long_press);
 212 }
 213
 214 std::string
 215 Push2::button_name_by_id (ButtonID id)
 216 {
 217         switch (id) {
 218         case TapTempo:
 219                 return "TapTempo";
 220         case Metronome:
 221                 return "Metronome";
 222         case Upper1:
 223                 return "Upper1";
 224         case Upper2:
 225                 return "Upper2";
 226         case Upper3:
 227                 return "Upper3";
 228         case Upper4:
 229                 return "Upper4";
 230         case Upper5:
 231                 return "Upper5";
 232         case Upper6:
 233                 return "Upper6";
 234         case Upper7:
 235                 return "Upper7";
 236         case Upper8:
 237                 return "Upper8";
 238         case Setup:
 239                 return "Setup";
 240         case User:
 241                 return "User";
 242         case Delete:
 243                 return "Delete";
 244         case AddDevice:
 245                 return "AddDevice";
 246         case Device:
 247                 return "Device";
 248         case Mix:
 249                 return "Mix";
 250         case Undo:
 251                 return "Undo";
 252         case AddTrack:
 253                 return "AddTrack";
 254         case Browse:
 255                 return "Browse";
 256         case Clip:
 257                 return "Clip";
 258         case Mute:
 259                 return "Mute";
 260         case Solo:
 261                 return "Solo";
 262         case Stop:
 263                 return "Stop";
 264         case Lower1:
 265                 return "Lower1";
 266         case Lower2:
 267                 return "Lower2";
 268         case Lower3:
 269                 return "Lower3";
 270         case Lower4:
 271                 return "Lower4";
 272         case Lower5:
 273                 return "Lower5";
 274         case Lower6:
 275                 return "Lower6";
 276         case Lower7:
 277                 return "Lower7";
 278         case Lower8:
 279                 return "Lower8";
 280         case Master:
 281                 return "Master";
 282         case Convert:
 283                 return "Convert";
 284         case DoubleLoop:
 285                 return "DoubleLoop";
 286         case Quantize:
 287                 return "Quantize";
 288         case Duplicate:
 289                 return "Duplicate";
 290         case New:
 291                 return "New";
 292         case FixedLength:
 293                 return "FixedLength";
 294         case Automate:
 295                 return "Automate";
 296         case RecordEnable:
 297                 return "RecordEnable";
 298         case Play:
 299                 return "Play";
 300         case Fwd32ndT:
 301                 return "Fwd32ndT";
 302         case Fwd32nd:
 303                 return "Fwd32nd";
 304         case Fwd16thT:
 305                 return "Fwd16thT";
 306         case Fwd16th:
 307                 return "Fwd16th";
 308         case Fwd8thT:
 309                 return "Fwd8thT";
 310         case Fwd8th:
 311                 return "Fwd8th";
 312         case Fwd4trT:
 313                 return "Fwd4trT";
 314         case Fwd4tr:
 315                 return "Fwd4tr";
 316         case Up:
 317                 return "Up";
 318         case Right:
 319                 return "Right";
 320         case Down:
 321                 return "Down";
 322         case Left:
 323                 return "Left";
 324         case Repeat:
 325                 return "Repeat";
 326         case Accent:
 327                 return "Accent";
 328         case Scale:
 329                 return "Scale";
 330         case Layout:
 331                 return "Layout";
 332         case Note:
 333                 return "Note";
 334         case Session:
 335                 return "Session";
 336         case OctaveUp:
 337                 return "OctaveUp";
 338         case PageRight:
 339                 return "PageRight";
 340         case OctaveDown:
 341                 return "OctaveDown";
 342         case PageLeft:
 343                 return "PageLeft";
 344         case Shift:
 345                 return "Shift";
 346         case Select:
 347                 return "Select";
 348         default:
 349                 break;
 350         }
 351
 352         return "???";
 353 }
 354
 355 void
 356 Push2::button_play ()
 357 {
 358         if (!session) {
 359                 return;
 360         }
 361
 362         if (_modifier_state & ModShift) {
 363                 goto_start (session->transport_rolling());
 364                 return;
 365         }
 366
 367         if (session->transport_rolling ()) {
 368                 transport_stop ();
 369         } else {
 370                 transport_play ();
 371         }
 372 }
 373
 374 void
 375 Push2::button_recenable ()
 376 {
 377         rec_enable_toggle ();
 378 }
 379
 380 void
 381 Push2::button_up ()
 382 {
 383         _current_layout->button_up ();
 384 }
 385
 386 void
 387 Push2::button_down ()
 388 {
 389         _current_layout->button_down ();
 390 }
 391
 392 void
 393 Push2::button_page_right ()
 394 {
 395         ScrollTimeline (0.75);
 396 }
 397
 398 void
 399 Push2::button_page_left ()
 400 {
 401         ScrollTimeline (-0.75);
 402 }
 403
 404 void
 405 Push2::button_right ()
 406 {
 407         _current_layout->button_right ();
 408 }
 409
 410 void
 411 Push2::button_left ()
 412 {
 413         _current_layout->button_left ();
 414 }
 415
 416 void
 417 Push2::button_repeat ()
 418 {
 419         loop_toggle ();
 420 }
 421
 422 void
 423 Push2::button_metronome ()
 424 {
 425         toggle_click ();
 426 }
 427
 428 void
 429 Push2::button_solo_long_press ()
 430 {
 431         cancel_all_solo ();
 432 }
 433
 434 void
 435 Push2::button_mute ()
 436 {
 437         if (_current_layout) {
 438                 _current_layout->button_mute ();
 439         }
 440 }
 441
 442 void
 443 Push2::button_solo ()
 444 {
 445         if (_current_layout) {
 446                 _current_layout->button_solo ();
 447         }
 448 }
 449
 450 void
 451 Push2::button_new ()
 452 {
 453         access_action ("Editor/start-range-from-playhead");
 454
 455         id_button_map[New]->set_color (LED::White);
 456         id_button_map[New]->set_state (LED::NoTransition);
 457         write (id_button_map[New]->state_msg());
 458
 459         /* blink the button for the other half of this operation */
 460
 461         id_button_map[FixedLength]->set_color (LED::White);
 462         id_button_map[FixedLength]->set_state (LED::Blinking4th);
 463         write (id_button_map[FixedLength]->state_msg());
 464 }
 465
 466
 467 void
 468 Push2::button_fixed_length ()
 469 {
 470         access_action ("Editor/finish-range-from-playhead");
 471
 472         /* turn off both buttons for this operation */
 473
 474         id_button_map[New]->set_color (LED::Black);
 475         id_button_map[New]->set_state (LED::NoTransition);
 476         write (id_button_map[New]->state_msg());
 477         id_button_map[FixedLength]->set_color (LED::Black);
 478         id_button_map[FixedLength]->set_state (LED::NoTransition);
 479         write (id_button_map[FixedLength]->state_msg());
 480 }
 481
 482 void
 483 Push2::button_browse ()
 484 {
 485         access_action ("Editor/addExistingAudioFiles");
 486 }
 487
 488 void
 489 Push2::button_clip ()
 490 {
 491 }
 492
 493 void
 494 Push2::button_upper (uint32_t n)
 495 {
 496         _current_layout->button_upper (n);
 497 }
 498
 499 void
 500 Push2::button_lower (uint32_t n)
 501 {
 502         _current_layout->button_lower (n);
 503 }
 504
 505 void
 506 Push2::button_undo ()
 507 {
 508         if (_modifier_state & ModShift) {
 509                 ControlProtocol::Redo ();
 510         } else {
 511                 ControlProtocol::Undo ();
 512         }
 513 }
 514
 515 void
 516 Push2::button_fwd32t ()
 517 {
 518         const int n = (_modifier_state & ModShift) ? 8 : 0;
 519         goto_nth_marker (0+n);
 520 }
 521
 522 void
 523 Push2::button_fwd32 ()
 524 {
 525         const int n = (_modifier_state & ModShift) ? 8 : 0;
 526         goto_nth_marker (1+n);
 527 }
 528
 529 void
 530 Push2::button_fwd16t ()
 531 {
 532         const int n = (_modifier_state & ModShift) ? 8 : 0;
 533         goto_nth_marker (2+n);
 534 }
 535
 536 void
 537 Push2::button_fwd16 ()
 538 {
 539         const int n = (_modifier_state & ModShift) ? 8 : 0;
 540         goto_nth_marker (3+n);
 541 }
 542
 543 void
 544 Push2::button_fwd8t ()
 545 {
 546         const int n = (_modifier_state & ModShift) ? 8 : 0;
 547         goto_nth_marker (4+n);
 548 }
 549
 550 void
 551 Push2::button_fwd8 ()
 552 {
 553         const int n = (_modifier_state & ModShift) ? 8 : 0;
 554         goto_nth_marker (5+n);
 555 }
 556
 557 void
 558 Push2::button_fwd4t ()
 559 {
 560         const int n = (_modifier_state & ModShift) ? 8 : 0;
 561         goto_nth_marker (6+n);
 562 }
 563
 564 void
 565 Push2::button_fwd4 ()
 566 {
 567         const int n = (_modifier_state & ModShift) ? 8 : 0;
 568         goto_nth_marker (7+n);
 569 }
 570
 571 void
 572 Push2::button_add_track ()
 573 {
 574         access_action ("Main/AddTrackBus");
 575 }
 576
 577 void
 578 Push2::button_stop ()
 579 {
 580         /* close current window */
 581         access_action ("Main/close-current-dialog");
 582 }
 583
 584 void
 585 Push2::button_shift_press ()
 586 {
 587         start_shift ();
 588 }
 589
 590 void
 591 Push2::button_shift_release ()
 592 {
 593         end_shift ();
 594 }
 595
 596 void
 597 Push2::button_shift_long_press ()
 598 {
 599         access_action ("Main/close-current-dialog");
 600 }
 601
 602 void
 603 Push2::button_select_press ()
 604 {
 605         cerr << "start select\n";
 606         _modifier_state = ModifierState (_modifier_state | ModSelect);
 607         Button* b = id_button_map[Select];
 608         b->set_color (Push2::LED::White);
 609         b->set_state (Push2::LED::Blinking16th);
 610         write (b->state_msg());
 611
 612         _current_layout->button_select_press ();
 613 }
 614
 615 void
 616 Push2::button_select_release ()
 617 {
 618         if (_modifier_state & ModSelect) {
 619                 cerr << "end select\n";
 620                 _modifier_state = ModifierState (_modifier_state & ~(ModSelect));
 621                 Button* b = id_button_map[Select];
 622                 b->timeout_connection.disconnect ();
 623                 b->set_color (Push2::LED::White);
 624                 b->set_state (Push2::LED::OneShot24th);
 625                 write (b->state_msg());
 626         }
 627
 628         _current_layout->button_select_release ();
 629 }
 630
 631 void
 632 Push2::button_select_long_press ()
 633 {
 634         access_action ("Main/Escape");
 635 }
 636
 637 bool
 638 Push2::button_long_press_timeout (ButtonID id)
 639 {
 640         if (buttons_down.find (id) != buttons_down.end()) {
 641                 DEBUG_TRACE (DEBUG::Push2, string_compose ("long press timeout for %1, invoking method\n", id));
 642                 Button* button = id_button_map[id];
 643                 (this->*button->long_press_method) ();
 644         } else {
 645                 DEBUG_TRACE (DEBUG::Push2, string_compose ("long press timeout for %1, expired/cancelled\n", id));
 646                 /* release happened and somehow we were not cancelled */
 647         }
 648
 649         /* whichever button this was, we've used it ... don't invoke the
 650            release action.
 651         */
 652         consumed.insert (id);
 653
 654         return false; /* don't get called again */
 655 }
 656
 657 void
 658 Push2::start_press_timeout (Button& button, ButtonID id)
 659 {
 660         Glib::RefPtr<Glib::TimeoutSource> timeout = Glib::TimeoutSource::create (500); // milliseconds
 661         button.timeout_connection = timeout->connect (sigc::bind (sigc::mem_fun (*this, &Push2::button_long_press_timeout), id));
 662         timeout->attach (main_loop()->get_context());
 663 }
 664
 665 void
 666 Push2::button_octave_down ()
 667 {
 668         if (_modifier_state & ModShift) {
 669                 octave_shift = 0;
 670                 return;
 671         }
 672
 673         int os = (max (-4, octave_shift - 1));
 674         if (os != octave_shift) {
 675                 octave_shift = os;
 676         }
 677 }
 678
 679 void
 680 Push2::button_octave_up ()
 681 {
 682         if (_modifier_state & ModShift) {
 683                 octave_shift = 0;
 684                 return;
 685         }
 686
 687         int os = (min (4, octave_shift + 1));
 688         if (os != octave_shift) {
 689                 octave_shift = os;
 690         }
 691 }
 692
 693 void
 694 Push2::button_layout_press ()
 695 {
 696         if (percussion) {
 697                 set_percussive_mode (false);
 698         } else {
 699                 set_percussive_mode (true);
 700         }
 701 }
 702
 703 void
 704 Push2::button_scale_press ()
 705 {
 706         if (_current_layout != scale_layout) {
 707                 set_current_layout (scale_layout);
 708         } else {
 709                 if (ControlProtocol::first_selected_stripable()) {
 710                         set_current_layout (mix_layout);
 711                 }
 712         }
 713 }
 714
 715 void
 716 Push2::button_mix_press ()
 717 {
 718         if (_current_layout == track_mix_layout) {
 719                 set_current_layout (mix_layout);
 720         } else {
 721                 if (ControlProtocol::first_selected_stripable()) {
 722                         set_current_layout (track_mix_layout);
 723                 }
 724         }
 725 }
 726
 727 void
 728 Push2::button_master ()
 729 {
 730         boost::shared_ptr<Stripable> master = session->master_out();
 731
 732         if (!master) {
 733                 return;
 734         }
 735
 736         ControlProtocol::SetStripableSelection (master);
 737
 738         if (_current_layout != track_mix_layout) {
 739                 set_current_layout (track_mix_layout);
 740         }
 741 }
 742
 743 void
 744 Push2::button_quantize ()
 745 {
 746         access_action ("Editor/quantize");
 747 }
 748
 749 void
 750 Push2::button_duplicate ()
 751 {
 752         access_action ("Editor/duplicate-range");
 753 }