gtk2_ardour/midi_region_view.cc

   1 /*
   2     Copyright (C) 2001-2011 Paul Davis
   3     Author: David Robillard
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <cmath>
  21 #include <algorithm>
  22 #include <ostream>
  23
  24 #include <gtkmm.h>
  25
  26 #include "gtkmm2ext/gtk_ui.h"
  27
  28 #include <sigc++/signal.h>
  29
  30 #include "pbd/memento_command.h"
  31 #include "pbd/stateful_diff_command.h"
  32
  33 #include "ardour/midi_model.h"
  34 #include "ardour/midi_patch_manager.h"
  35 #include "ardour/midi_region.h"
  36 #include "ardour/midi_source.h"
  37 #include "ardour/midi_track.h"
  38 #include "ardour/operations.h"
  39 #include "ardour/session.h"
  40
  41 #include "evoral/Parameter.hpp"
  42 #include "evoral/MIDIEvent.hpp"
  43 #include "evoral/Control.hpp"
  44 #include "evoral/midi_util.h"
  45
  46 #include "canvas/debug.h"
  47 #include "canvas/text.h"
  48
  49 #include "automation_region_view.h"
  50 #include "automation_time_axis.h"
  51 #include "control_point.h"
  52 #include "debug.h"
  53 #include "editor.h"
  54 #include "editor_drag.h"
  55 #include "ghostregion.h"
  56 #include "gui_thread.h"
  57 #include "item_counts.h"
  58 #include "keyboard.h"
  59 #include "midi_channel_dialog.h"
  60 #include "midi_cut_buffer.h"
  61 #include "midi_list_editor.h"
  62 #include "midi_region_view.h"
  63 #include "midi_streamview.h"
  64 #include "midi_time_axis.h"
  65 #include "midi_util.h"
  66 #include "midi_velocity_dialog.h"
  67 #include "mouse_cursors.h"
  68 #include "note_player.h"
  69 #include "paste_context.h"
  70 #include "public_editor.h"
  71 #include "route_time_axis.h"
  72 #include "rgb_macros.h"
  73 #include "selection.h"
  74 #include "streamview.h"
  75 #include "patch_change_dialog.h"
  76 #include "verbose_cursor.h"
  77 #include "ardour_ui.h"
  78 #include "note.h"
  79 #include "hit.h"
  80 #include "patch_change.h"
  81 #include "sys_ex.h"
  82
  83 #include "i18n.h"
  84
  85 using namespace ARDOUR;
  86 using namespace PBD;
  87 using namespace Editing;
  88 using namespace std;
  89 using Gtkmm2ext::Keyboard;
  90
  91 PBD::Signal1<void, MidiRegionView *> MidiRegionView::SelectionCleared;
  92
  93 #define MIDI_BP_ZERO ((Config->get_first_midi_bank_is_zero())?0:1)
  94
  95 MidiRegionView::MidiRegionView (ArdourCanvas::Container*      parent,
  96                                 RouteTimeAxisView&            tv,
  97                                 boost::shared_ptr<MidiRegion> r,
  98                                 double                        spu,
  99                                 uint32_t                      basic_color)
 100         : RegionView (parent, tv, r, spu, basic_color)
 101         , _current_range_min(0)
 102         , _current_range_max(0)
 103         , _region_relative_time_converter(r->session().tempo_map(), r->position())
 104         , _source_relative_time_converter(r->session().tempo_map(), r->position() - r->start())
 105         , _active_notes(0)
 106         , _note_group (new ArdourCanvas::Container (group))
 107         , _note_diff_command (0)
 108         , _ghost_note(0)
 109         , _step_edit_cursor (0)
 110         , _step_edit_cursor_width (1.0)
 111         , _step_edit_cursor_position (0.0)
 112         , _channel_selection_scoped_note (0)
 113         , _temporary_note_group (0)
 114         , _mouse_state(None)
 115         , _pressed_button(0)
 116         , _sort_needed (true)
 117         , _optimization_iterator (_events.end())
 118         , _list_editor (0)
 119         , _no_sound_notes (false)
 120         , _last_event_x (0)
 121         , _last_event_y (0)
 122         , _grabbed_keyboard (false)
 123         , _entered (false)
 124         , pre_enter_cursor (0)
 125         , pre_press_cursor (0)
 126         , pre_note_enter_cursor (0)
 127         , _note_player (0)
 128 {
 129         CANVAS_DEBUG_NAME (_note_group, string_compose ("note group for %1", get_item_name()));
 130         _note_group->raise_to_top();
 131         PublicEditor::DropDownKeys.connect (sigc::mem_fun (*this, &MidiRegionView::drop_down_keys));
 132
 133         Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&MidiRegionView::parameter_changed, this, _1), gui_context());
 134         connect_to_diskstream ();
 135
 136         SelectionCleared.connect (_selection_cleared_connection, invalidator (*this), boost::bind (&MidiRegionView::selection_cleared, this, _1), gui_context ());
 137 }
 138
 139 MidiRegionView::MidiRegionView (ArdourCanvas::Container*      parent,
 140                                 RouteTimeAxisView&            tv,
 141                                 boost::shared_ptr<MidiRegion> r,
 142                                 double                        spu,
 143                                 uint32_t                      basic_color,
 144                                 TimeAxisViewItem::Visibility  visibility)
 145         : RegionView (parent, tv, r, spu, basic_color, false, visibility)
 146         , _current_range_min(0)
 147         , _current_range_max(0)
 148         , _region_relative_time_converter(r->session().tempo_map(), r->position())
 149         , _source_relative_time_converter(r->session().tempo_map(), r->position() - r->start())
 150         , _active_notes(0)
 151         , _note_group (new ArdourCanvas::Container (parent))
 152         , _note_diff_command (0)
 153         , _ghost_note(0)
 154         , _step_edit_cursor (0)
 155         , _step_edit_cursor_width (1.0)
 156         , _step_edit_cursor_position (0.0)
 157         , _channel_selection_scoped_note (0)
 158         , _temporary_note_group (0)
 159         , _mouse_state(None)
 160         , _pressed_button(0)
 161         , _sort_needed (true)
 162         , _optimization_iterator (_events.end())
 163         , _list_editor (0)
 164         , _no_sound_notes (false)
 165         , _last_event_x (0)
 166         , _last_event_y (0)
 167         , _grabbed_keyboard (false)
 168         , _entered (false)
 169         , pre_enter_cursor (0)
 170         , pre_press_cursor (0)
 171         , pre_note_enter_cursor (0)
 172         , _note_player (0)
 173 {
 174         CANVAS_DEBUG_NAME (_note_group, string_compose ("note group for %1", get_item_name()));
 175         _note_group->raise_to_top();
 176
 177         PublicEditor::DropDownKeys.connect (sigc::mem_fun (*this, &MidiRegionView::drop_down_keys));
 178
 179         connect_to_diskstream ();
 180
 181         SelectionCleared.connect (_selection_cleared_connection, invalidator (*this), boost::bind (&MidiRegionView::selection_cleared, this, _1), gui_context ());
 182 }
 183
 184 void
 185 MidiRegionView::parameter_changed (std::string const & p)
 186 {
 187         if (p == "display-first-midi-bank-as-zero") {
 188                 if (_enable_display) {
 189                         redisplay_model();
 190                 }
 191         }
 192 }
 193
 194 MidiRegionView::MidiRegionView (const MidiRegionView& other)
 195         : sigc::trackable(other)
 196         , RegionView (other)
 197         , _current_range_min(0)
 198         , _current_range_max(0)
 199         , _region_relative_time_converter(other.region_relative_time_converter())
 200         , _source_relative_time_converter(other.source_relative_time_converter())
 201         , _active_notes(0)
 202         , _note_group (new ArdourCanvas::Container (get_canvas_group()))
 203         , _note_diff_command (0)
 204         , _ghost_note(0)
 205         , _step_edit_cursor (0)
 206         , _step_edit_cursor_width (1.0)
 207         , _step_edit_cursor_position (0.0)
 208         , _channel_selection_scoped_note (0)
 209         , _temporary_note_group (0)
 210         , _mouse_state(None)
 211         , _pressed_button(0)
 212         , _sort_needed (true)
 213         , _optimization_iterator (_events.end())
 214         , _list_editor (0)
 215         , _no_sound_notes (false)
 216         , _last_event_x (0)
 217         , _last_event_y (0)
 218         , _grabbed_keyboard (false)
 219         , _entered (false)
 220         , pre_enter_cursor (0)
 221         , pre_press_cursor (0)
 222         , pre_note_enter_cursor (0)
 223         , _note_player (0)
 224 {
 225         init (false);
 226 }
 227
 228 MidiRegionView::MidiRegionView (const MidiRegionView& other, boost::shared_ptr<MidiRegion> region)
 229         : RegionView (other, boost::shared_ptr<Region> (region))
 230         , _current_range_min(0)
 231         , _current_range_max(0)
 232         , _region_relative_time_converter(other.region_relative_time_converter())
 233         , _source_relative_time_converter(other.source_relative_time_converter())
 234         , _active_notes(0)
 235         , _note_group (new ArdourCanvas::Container (get_canvas_group()))
 236         , _note_diff_command (0)
 237         , _ghost_note(0)
 238         , _step_edit_cursor (0)
 239         , _step_edit_cursor_width (1.0)
 240         , _step_edit_cursor_position (0.0)
 241         , _channel_selection_scoped_note (0)
 242         , _temporary_note_group (0)
 243         , _mouse_state(None)
 244         , _pressed_button(0)
 245         , _sort_needed (true)
 246         , _optimization_iterator (_events.end())
 247         , _list_editor (0)
 248         , _no_sound_notes (false)
 249         , _last_event_x (0)
 250         , _last_event_y (0)
 251         , _grabbed_keyboard (false)
 252         , _entered (false)
 253         , pre_enter_cursor (0)
 254         , pre_press_cursor (0)
 255         , pre_note_enter_cursor (0)
 256         , _note_player (0)
 257 {
 258         init (true);
 259 }
 260
 261 void
 262 MidiRegionView::init (bool wfd)
 263 {
 264         PublicEditor::DropDownKeys.connect (sigc::mem_fun (*this, &MidiRegionView::drop_down_keys));
 265
 266         NoteBase::NoteBaseDeleted.connect (note_delete_connection, MISSING_INVALIDATOR,
 267                                            boost::bind (&MidiRegionView::maybe_remove_deleted_note_from_selection, this, _1),
 268                                            gui_context());
 269
 270         if (wfd) {
 271                 midi_region()->midi_source(0)->load_model();
 272         }
 273
 274         _model = midi_region()->midi_source(0)->model();
 275         _enable_display = false;
 276
 277         RegionView::init (false);
 278
 279         set_height (trackview.current_height());
 280
 281         region_muted ();
 282         region_sync_changed ();
 283         region_resized (ARDOUR::bounds_change);
 284         region_locked ();
 285
 286         set_colors ();
 287
 288         _enable_display = true;
 289         if (_model) {
 290                 if (wfd) {
 291                         display_model (_model);
 292                 }
 293         }
 294
 295         reset_width_dependent_items (_pixel_width);
 296
 297         group->raise_to_top();
 298
 299         midi_view()->midi_track()->PlaybackChannelModeChanged.connect (_channel_mode_changed_connection, invalidator (*this),
 300                                                                        boost::bind (&MidiRegionView::midi_channel_mode_changed, this),
 301                                                                        gui_context ());
 302
 303         instrument_info().Changed.connect (_instrument_changed_connection, invalidator (*this),
 304                                            boost::bind (&MidiRegionView::instrument_settings_changed, this), gui_context());
 305
 306         trackview.editor().SnapChanged.connect(snap_changed_connection, invalidator(*this),
 307                                                boost::bind (&MidiRegionView::snap_changed, this),
 308                                                gui_context());
 309
 310         Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&MidiRegionView::parameter_changed, this, _1), gui_context());
 311         connect_to_diskstream ();
 312
 313         SelectionCleared.connect (_selection_cleared_connection, invalidator (*this), boost::bind (&MidiRegionView::selection_cleared, this, _1), gui_context ());
 314 }
 315
 316 InstrumentInfo&
 317 MidiRegionView::instrument_info () const
 318 {
 319         RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
 320         return route_ui->route()->instrument_info();
 321 }
 322
 323 const boost::shared_ptr<ARDOUR::MidiRegion>
 324 MidiRegionView::midi_region() const
 325 {
 326         return boost::dynamic_pointer_cast<ARDOUR::MidiRegion>(_region);
 327 }
 328
 329 void
 330 MidiRegionView::connect_to_diskstream ()
 331 {
 332         midi_view()->midi_track()->DataRecorded.connect(
 333                 *this, invalidator(*this),
 334                 boost::bind (&MidiRegionView::data_recorded, this, _1),
 335                 gui_context());
 336 }
 337
 338 bool
 339 MidiRegionView::canvas_group_event(GdkEvent* ev)
 340 {
 341         if (in_destructor) {
 342                 return false;
 343         }
 344
 345         if (!trackview.editor().internal_editing()) {
 346                 // not in internal edit mode, so just act like a normal region
 347                 return RegionView::canvas_group_event (ev);
 348         }
 349
 350         const MouseMode m = trackview.editor().current_mouse_mode();
 351         bool r;
 352
 353         switch (ev->type) {
 354         case GDK_ENTER_NOTIFY:
 355                 _last_event_x = ev->crossing.x;
 356                 _last_event_y = ev->crossing.y;
 357                 enter_notify(&ev->crossing);
 358                 // set entered_regionview (among other things)
 359                 return RegionView::canvas_group_event (ev);
 360
 361         case GDK_LEAVE_NOTIFY:
 362                 _last_event_x = ev->crossing.x;
 363                 _last_event_y = ev->crossing.y;
 364                 leave_notify(&ev->crossing);
 365                 // reset entered_regionview (among other things)
 366                 return RegionView::canvas_group_event (ev);
 367
 368         case GDK_2BUTTON_PRESS:
 369                 // cannot use double-click to exit internal mode if single-click is being used
 370                 if ((m != MouseDraw) &&
 371                     (m != MouseObject ||
 372                      !Keyboard::modifier_state_contains (ev->button.state, Keyboard::insert_note_modifier()))) {
 373                         return trackview.editor().toggle_internal_editing_from_double_click (ev);
 374                 }
 375                 break;
 376
 377         case GDK_SCROLL:
 378                 if (scroll (&ev->scroll)) {
 379                         return true;
 380                 }
 381                 break;
 382
 383         case GDK_KEY_PRESS:
 384                 return key_press (&ev->key);
 385
 386         case GDK_KEY_RELEASE:
 387                 return key_release (&ev->key);
 388
 389         case GDK_BUTTON_PRESS:
 390                 return button_press (&ev->button);
 391
 392         case GDK_BUTTON_RELEASE:
 393                 r = button_release (&ev->button);
 394                 delete _note_player;
 395                 _note_player = 0;
 396                 return r;
 397
 398         case GDK_MOTION_NOTIFY:
 399                 _last_event_x = ev->motion.x;
 400                 _last_event_y = ev->motion.y;
 401                 return motion (&ev->motion);
 402
 403         default:
 404                 break;
 405         }
 406
 407         return RegionView::canvas_group_event (ev);
 408 }
 409
 410 bool
 411 MidiRegionView::enter_notify (GdkEventCrossing* ev)
 412 {
 413         trackview.editor().MouseModeChanged.connect (
 414                 _mouse_mode_connection, invalidator (*this), boost::bind (&MidiRegionView::mouse_mode_changed, this), gui_context ()
 415                 );
 416
 417         enter_internal();
 418
 419         _entered = true;
 420         return false;
 421 }
 422
 423 bool
 424 MidiRegionView::leave_notify (GdkEventCrossing*)
 425 {
 426         _mouse_mode_connection.disconnect ();
 427
 428         leave_internal();
 429
 430         _entered = false;
 431         return false;
 432 }
 433
 434 void
 435 MidiRegionView::mouse_mode_changed ()
 436 {
 437         if (trackview.editor().internal_editing()) {
 438                 // Switched in to internal editing mode while entered
 439                 enter_internal();
 440         } else {
 441                 // Switched out of internal editing mode while entered
 442                 leave_internal();
 443         }
 444 }
 445
 446 void
 447 MidiRegionView::enter_internal()
 448 {
 449         if (trackview.editor().current_mouse_mode() == MouseDraw && _mouse_state != AddDragging) {
 450                 // Show ghost note under pencil
 451                 create_ghost_note(_last_event_x, _last_event_y);
 452         }
 453
 454         if (!_selection.empty()) {
 455                 // Grab keyboard for moving selected notes with arrow keys
 456                 Keyboard::magic_widget_grab_focus();
 457                 _grabbed_keyboard = true;
 458         }
 459 }
 460
 461 void
 462 MidiRegionView::leave_internal()
 463 {
 464         trackview.editor().verbose_cursor()->hide ();
 465         remove_ghost_note ();
 466
 467         if (_grabbed_keyboard) {
 468                 Keyboard::magic_widget_drop_focus();
 469                 _grabbed_keyboard = false;
 470         }
 471 }
 472
 473 bool
 474 MidiRegionView::button_press (GdkEventButton* ev)
 475 {
 476         if (ev->button != 1) {
 477                 return false;
 478         }
 479
 480         Editor* editor = dynamic_cast<Editor *> (&trackview.editor());
 481         MouseMode m = editor->current_mouse_mode();
 482
 483         if (m == MouseObject && Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier())) {
 484                 pre_press_cursor = editor->get_canvas_cursor ();
 485                 editor->set_canvas_cursor (editor->cursors()->midi_pencil);
 486         }
 487
 488         if (_mouse_state != SelectTouchDragging) {
 489
 490                 _pressed_button = ev->button;
 491                 _mouse_state = Pressed;
 492
 493                 return true;
 494         }
 495
 496         _pressed_button = ev->button;
 497
 498         return true;
 499 }
 500
 501 bool
 502 MidiRegionView::button_release (GdkEventButton* ev)
 503 {
 504         double event_x, event_y;
 505
 506         if (ev->button != 1) {
 507                 return false;
 508         }
 509
 510         event_x = ev->x;
 511         event_y = ev->y;
 512
 513         group->canvas_to_item (event_x, event_y);
 514         group->ungrab ();
 515
 516         PublicEditor& editor = trackview.editor ();
 517
 518         if (pre_press_cursor) {
 519                 dynamic_cast<Editor*>(&editor)->set_canvas_cursor (pre_press_cursor, false);
 520                 pre_press_cursor = 0;
 521         }
 522
 523         switch (_mouse_state) {
 524         case Pressed: // Clicked
 525
 526                 switch (editor.current_mouse_mode()) {
 527                 case MouseRange:
 528                         /* no motion occured - simple click */
 529                         clear_selection ();
 530                         break;
 531
 532                 case MouseObject:
 533                 case MouseTimeFX:
 534                         {
 535                                 clear_selection();
 536
 537                                 if (Keyboard::is_insert_note_event(ev)) {
 538
 539                                         double event_x, event_y;
 540
 541                                         event_x = ev->x;
 542                                         event_y = ev->y;
 543                                         group->canvas_to_item (event_x, event_y);
 544
 545                                         Evoral::MusicalTime beats = get_grid_beats(editor.pixel_to_sample(event_x));
 546
 547                                         /* Shorten the length by 1 tick so that we can add a new note at the next
 548                                            grid snap without it overlapping this one.
 549                                         */
 550                                         beats -= Evoral::MusicalTime::tick();
 551
 552                                         create_note_at (editor.pixel_to_sample (event_x), event_y, beats, true);
 553                                 }
 554
 555                                 break;
 556                         }
 557                 case MouseDraw:
 558                         {
 559                                 Evoral::MusicalTime beats = get_grid_beats(editor.pixel_to_sample(event_x));
 560
 561                                 /* Shorten the length by 1 tick so that we can add a new note at the next
 562                                    grid snap without it overlapping this one.
 563                                 */
 564                                 beats -= Evoral::MusicalTime::tick();
 565
 566                                 create_note_at (editor.pixel_to_sample (event_x), event_y, beats, true);
 567
 568                                 break;
 569                         }
 570                 default:
 571                         break;
 572                 }
 573
 574                 _mouse_state = None;
 575                 break;
 576
 577         case SelectRectDragging:
 578         case AddDragging:
 579                 editor.drags()->end_grab ((GdkEvent *) ev);
 580                 _mouse_state = None;
 581                 create_ghost_note (ev->x, ev->y);
 582                 break;
 583
 584
 585         default:
 586                 break;
 587         }
 588
 589         return false;
 590 }
 591
 592 bool
 593 MidiRegionView::motion (GdkEventMotion* ev)
 594 {
 595         PublicEditor& editor = trackview.editor ();
 596
 597         if (!_ghost_note && editor.current_mouse_mode() == MouseObject &&
 598             Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()) &&
 599             _mouse_state != AddDragging) {
 600
 601                 create_ghost_note (ev->x, ev->y);
 602
 603         } else if (_ghost_note && editor.current_mouse_mode() == MouseObject &&
 604                    Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier())) {
 605
 606                 update_ghost_note (ev->x, ev->y);
 607
 608         } else if (_ghost_note && editor.current_mouse_mode() == MouseObject) {
 609
 610                 remove_ghost_note ();
 611                 editor.verbose_cursor()->hide ();
 612
 613         } else if (_ghost_note && editor.current_mouse_mode() == MouseDraw) {
 614
 615                 update_ghost_note (ev->x, ev->y);
 616         }
 617
 618         /* any motion immediately hides velocity text that may have been visible */
 619
 620         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
 621                 (*i)->hide_velocity ();
 622         }
 623
 624         switch (_mouse_state) {
 625         case Pressed:
 626
 627                 if (_pressed_button == 1) {
 628
 629                         MouseMode m = editor.current_mouse_mode();
 630
 631                         if (m == MouseDraw || (m == MouseObject && Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()))) {
 632                                 editor.drags()->set (new NoteCreateDrag (dynamic_cast<Editor *> (&editor), group, this), (GdkEvent *) ev);
 633                                 _mouse_state = AddDragging;
 634                                 remove_ghost_note ();
 635                                 editor.verbose_cursor()->hide ();
 636                                 return true;
 637                         } else if (m == MouseObject) {
 638                                 editor.drags()->set (new MidiRubberbandSelectDrag (dynamic_cast<Editor *> (&editor), this), (GdkEvent *) ev);
 639                                 clear_selection ();
 640                                 _mouse_state = SelectRectDragging;
 641                                 return true;
 642                         } else if (m == MouseRange) {
 643                                 editor.drags()->set (new MidiVerticalSelectDrag (dynamic_cast<Editor *> (&editor), this), (GdkEvent *) ev);
 644                                 _mouse_state = SelectVerticalDragging;
 645                                 return true;
 646                         }
 647                 }
 648
 649                 return false;
 650
 651         case SelectRectDragging:
 652         case SelectVerticalDragging:
 653         case AddDragging:
 654                 editor.drags()->motion_handler ((GdkEvent *) ev, false);
 655                 break;
 656
 657         case SelectTouchDragging:
 658                 return false;
 659
 660         default:
 661                 break;
 662
 663         }
 664
 665         /* we may be dragging some non-note object (eg. patch-change, sysex)
 666          */
 667
 668         return editor.drags()->motion_handler ((GdkEvent *) ev, false);
 669 }
 670
 671
 672 bool
 673 MidiRegionView::scroll (GdkEventScroll* ev)
 674 {
 675         if (_selection.empty()) {
 676                 return false;
 677         }
 678
 679         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 680                 /* XXX: bit of a hack; allow PrimaryModifier scroll through so that
 681                    it still works for zoom.
 682                 */
 683                 return false;
 684         }
 685
 686         trackview.editor().verbose_cursor()->hide ();
 687
 688         bool fine = !Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
 689         bool together = Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier);
 690
 691         if (ev->direction == GDK_SCROLL_UP) {
 692                 change_velocities (true, fine, false, together);
 693         } else if (ev->direction == GDK_SCROLL_DOWN) {
 694                 change_velocities (false, fine, false, together);
 695         } else {
 696                 /* left, right: we don't use them */
 697                 return false;
 698         }
 699
 700         return true;
 701 }
 702
 703 bool
 704 MidiRegionView::key_press (GdkEventKey* ev)
 705 {
 706         /* since GTK bindings are generally activated on press, and since
 707            detectable auto-repeat is the name of the game and only sends
 708            repeated presses, carry out key actions at key press, not release.
 709         */
 710
 711         bool unmodified = Keyboard::no_modifier_keys_pressed (ev);
 712
 713         if (unmodified && (ev->keyval == GDK_Alt_L || ev->keyval == GDK_Alt_R)) {
 714                 _mouse_state = SelectTouchDragging;
 715                 return true;
 716
 717         } else if (ev->keyval == GDK_Escape && unmodified) {
 718                 clear_selection();
 719                 _mouse_state = None;
 720
 721         } else if (unmodified && (ev->keyval == GDK_comma || ev->keyval == GDK_period)) {
 722
 723                 bool start = (ev->keyval == GDK_comma);
 724                 bool end = (ev->keyval == GDK_period);
 725                 bool shorter = Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier);
 726                 bool fine = Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
 727
 728                 change_note_lengths (fine, shorter, Evoral::MusicalTime(), start, end);
 729
 730                 return true;
 731
 732         } else if ((ev->keyval == GDK_BackSpace || ev->keyval == GDK_Delete) && unmodified) {
 733
 734                 if (_selection.empty()) {
 735                         return false;
 736                 }
 737
 738                 delete_selection();
 739                 return true;
 740
 741         } else if (ev->keyval == GDK_Tab) {
 742
 743                 if (Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier)) {
 744                         goto_previous_note (Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier));
 745                 } else {
 746                         goto_next_note (Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier));
 747                 }
 748                 return true;
 749
 750         } else if (ev->keyval == GDK_ISO_Left_Tab) {
 751
 752                 /* Shift-TAB generates ISO Left Tab, for some reason */
 753
 754                 if (Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier)) {
 755                         goto_previous_note (Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier));
 756                 } else {
 757                         goto_next_note (Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier));
 758                 }
 759                 return true;
 760
 761
 762
 763         } else if (ev->keyval == GDK_Up) {
 764
 765                 bool allow_smush = Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier);
 766                 bool fine = !Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
 767                 bool together = Keyboard::modifier_state_contains (ev->state, Keyboard::Level4Modifier);
 768
 769                 if (Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier)) {
 770                         change_velocities (true, fine, allow_smush, together);
 771                 } else {
 772                         transpose (true, fine, allow_smush);
 773                 }
 774                 return true;
 775
 776         } else if (ev->keyval == GDK_Down) {
 777
 778                 bool allow_smush = Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier);
 779                 bool fine = !Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
 780                 bool together = Keyboard::modifier_state_contains (ev->state, Keyboard::Level4Modifier);
 781
 782                 if (Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier)) {
 783                         change_velocities (false, fine, allow_smush, together);
 784                 } else {
 785                         transpose (false, fine, allow_smush);
 786                 }
 787                 return true;
 788
 789         } else if (ev->keyval == GDK_Left && unmodified) {
 790
 791                 nudge_notes (false);
 792                 return true;
 793
 794         } else if (ev->keyval == GDK_Right && unmodified) {
 795
 796                 nudge_notes (true);
 797                 return true;
 798
 799         } else if (ev->keyval == GDK_c && unmodified) {
 800                 channel_edit ();
 801                 return true;
 802
 803         } else if (ev->keyval == GDK_v && unmodified) {
 804                 velocity_edit ();
 805                 return true;
 806         }
 807
 808         return false;
 809 }
 810
 811 bool
 812 MidiRegionView::key_release (GdkEventKey* ev)
 813 {
 814         if ((_mouse_state == SelectTouchDragging) && (ev->keyval == GDK_Alt_L || ev->keyval == GDK_Alt_R)) {
 815                 _mouse_state = None;
 816                 return true;
 817         }
 818         return false;
 819 }
 820
 821 void
 822 MidiRegionView::channel_edit ()
 823 {
 824         if (_selection.empty()) {
 825                 return;
 826         }
 827
 828         /* pick a note somewhat at random (since Selection is a set<>) to
 829          * provide the "current" channel for the dialog.
 830          */
 831
 832         uint8_t current_channel = (*_selection.begin())->note()->channel ();
 833         MidiChannelDialog channel_dialog (current_channel);
 834         int ret = channel_dialog.run ();
 835
 836         switch (ret) {
 837         case Gtk::RESPONSE_OK:
 838                 break;
 839         default:
 840                 return;
 841         }
 842
 843         uint8_t new_channel = channel_dialog.active_channel ();
 844
 845         start_note_diff_command (_("channel edit"));
 846
 847         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
 848                 Selection::iterator next = i;
 849                 ++next;
 850                 change_note_channel (*i, new_channel);
 851                 i = next;
 852         }
 853
 854         apply_diff ();
 855 }
 856
 857 void
 858 MidiRegionView::velocity_edit ()
 859 {
 860         if (_selection.empty()) {
 861                 return;
 862         }
 863
 864         /* pick a note somewhat at random (since Selection is a set<>) to
 865          * provide the "current" velocity for the dialog.
 866          */
 867
 868         uint8_t current_velocity = (*_selection.begin())->note()->velocity ();
 869         MidiVelocityDialog velocity_dialog (current_velocity);
 870         int ret = velocity_dialog.run ();
 871
 872         switch (ret) {
 873         case Gtk::RESPONSE_OK:
 874                 break;
 875         default:
 876                 return;
 877         }
 878
 879         uint8_t new_velocity = velocity_dialog.velocity ();
 880
 881         start_note_diff_command (_("velocity edit"));
 882
 883         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
 884                 Selection::iterator next = i;
 885                 ++next;
 886                 change_note_velocity (*i, new_velocity, false);
 887                 i = next;
 888         }
 889
 890         apply_diff ();
 891 }
 892
 893 void
 894 MidiRegionView::show_list_editor ()
 895 {
 896         if (!_list_editor) {
 897                 _list_editor = new MidiListEditor (trackview.session(), midi_region(), midi_view()->midi_track());
 898         }
 899         _list_editor->present ();
 900 }
 901
 902 /** Add a note to the model, and the view, at a canvas (click) coordinate.
 903  * \param t time in frames relative to the position of the region
 904  * \param y vertical position in pixels
 905  * \param length duration of the note in beats
 906  * \param snap_t true to snap t to the grid, otherwise false.
 907  */
 908 void
 909 MidiRegionView::create_note_at (framepos_t t, double y, Evoral::MusicalTime length, bool snap_t)
 910 {
 911         if (length < 2 * DBL_EPSILON) {
 912                 return;
 913         }
 914
 915         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
 916         MidiStreamView* const view = mtv->midi_view();
 917
 918         const double note = view->y_to_note(y);
 919
 920         // Start of note in frames relative to region start
 921         if (snap_t) {
 922                 framecnt_t grid_frames;
 923                 t = snap_frame_to_grid_underneath (t, grid_frames);
 924         }
 925
 926         const boost::shared_ptr<NoteType> new_note (
 927                 new NoteType (mtv->get_channel_for_add (),
 928                               region_frames_to_region_beats(t + _region->start()),
 929                               length,
 930                               (uint8_t)note, 0x40));
 931
 932         if (_model->contains (new_note)) {
 933                 return;
 934         }
 935
 936         view->update_note_range(new_note->note());
 937
 938         MidiModel::NoteDiffCommand* cmd = _model->new_note_diff_command(_("add note"));
 939         cmd->add (new_note);
 940         _model->apply_command(*trackview.session(), cmd);
 941
 942         play_midi_note (new_note);
 943 }
 944
 945 void
 946 MidiRegionView::clear_events (bool with_selection_signal)
 947 {
 948         clear_selection (with_selection_signal);
 949
 950         MidiGhostRegion* gr;
 951         for (std::vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
 952                 if ((gr = dynamic_cast<MidiGhostRegion*>(*g)) != 0) {
 953                         gr->clear_events();
 954                 }
 955         }
 956
 957         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
 958                 delete *i;
 959         }
 960
 961         _events.clear();
 962         _patch_changes.clear();
 963         _sys_exes.clear();
 964         _optimization_iterator = _events.end();
 965 }
 966
 967 void
 968 MidiRegionView::display_model(boost::shared_ptr<MidiModel> model)
 969 {
 970         _model = model;
 971
 972         content_connection.disconnect ();
 973         _model->ContentsChanged.connect (content_connection, invalidator (*this), boost::bind (&MidiRegionView::redisplay_model, this), gui_context());
 974
 975         clear_events ();
 976
 977         if (_enable_display) {
 978                 redisplay_model();
 979         }
 980 }
 981
 982 void
 983 MidiRegionView::start_note_diff_command (string name)
 984 {
 985         if (!_note_diff_command) {
 986                 _note_diff_command = _model->new_note_diff_command (name);
 987         }
 988 }
 989
 990 void
 991 MidiRegionView::note_diff_add_note (const boost::shared_ptr<NoteType> note, bool selected, bool show_velocity)
 992 {
 993         if (_note_diff_command) {
 994                 _note_diff_command->add (note);
 995         }
 996         if (selected) {
 997                 _marked_for_selection.insert(note);
 998         }
 999         if (show_velocity) {
1000                 _marked_for_velocity.insert(note);
1001         }
1002 }
1003
1004 void
1005 MidiRegionView::note_diff_remove_note (NoteBase* ev)
1006 {
1007         if (_note_diff_command && ev->note()) {
1008                 _note_diff_command->remove(ev->note());
1009         }
1010 }
1011
1012 void
1013 MidiRegionView::note_diff_add_change (NoteBase* ev,
1014                                       MidiModel::NoteDiffCommand::Property property,
1015                                       uint8_t val)
1016 {
1017         if (_note_diff_command) {
1018                 _note_diff_command->change (ev->note(), property, val);
1019         }
1020 }
1021
1022 void
1023 MidiRegionView::note_diff_add_change (NoteBase* ev,
1024                                       MidiModel::NoteDiffCommand::Property property,
1025                                       Evoral::MusicalTime val)
1026 {
1027         if (_note_diff_command) {
1028                 _note_diff_command->change (ev->note(), property, val);
1029         }
1030 }
1031
1032 void
1033 MidiRegionView::apply_diff (bool as_subcommand)
1034 {
1035         bool add_or_remove;
1036
1037         if (!_note_diff_command) {
1038                 return;
1039         }
1040
1041         if ((add_or_remove = _note_diff_command->adds_or_removes())) {
1042                 // Mark all selected notes for selection when model reloads
1043                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
1044                         _marked_for_selection.insert((*i)->note());
1045                 }
1046         }
1047
1048         if (as_subcommand) {
1049                 _model->apply_command_as_subcommand (*trackview.session(), _note_diff_command);
1050         } else {
1051                 _model->apply_command (*trackview.session(), _note_diff_command);
1052         }
1053
1054         _note_diff_command = 0;
1055         midi_view()->midi_track()->playlist_modified();
1056
1057         if (add_or_remove) {
1058                 _marked_for_selection.clear();
1059         }
1060
1061         _marked_for_velocity.clear();
1062 }
1063
1064 void
1065 MidiRegionView::abort_command()
1066 {
1067         delete _note_diff_command;
1068         _note_diff_command = 0;
1069         clear_selection();
1070 }
1071
1072 NoteBase*
1073 MidiRegionView::find_canvas_note (boost::shared_ptr<NoteType> note)
1074 {
1075         if (_optimization_iterator != _events.end()) {
1076                 ++_optimization_iterator;
1077         }
1078
1079         if (_optimization_iterator != _events.end() && (*_optimization_iterator)->note() == note) {
1080                 return *_optimization_iterator;
1081         }
1082
1083         for (_optimization_iterator = _events.begin(); _optimization_iterator != _events.end(); ++_optimization_iterator) {
1084                 if ((*_optimization_iterator)->note() == note) {
1085                         return *_optimization_iterator;
1086                 }
1087         }
1088
1089         return 0;
1090 }
1091
1092 void
1093 MidiRegionView::get_events (Events& e, Evoral::Sequence<Evoral::MusicalTime>::NoteOperator op, uint8_t val, int chan_mask)
1094 {
1095         MidiModel::Notes notes;
1096         _model->get_notes (notes, op, val, chan_mask);
1097
1098         for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
1099                 NoteBase* cne = find_canvas_note (*n);
1100                 if (cne) {
1101                         e.push_back (cne);
1102                 }
1103         }
1104 }
1105
1106 void
1107 MidiRegionView::redisplay_model()
1108 {
1109         // Don't redisplay the model if we're currently recording and displaying that
1110         if (_active_notes) {
1111                 return;
1112         }
1113
1114         if (!_model) {
1115                 return;
1116         }
1117
1118         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
1119                 (*i)->invalidate ();
1120         }
1121
1122         MidiModel::ReadLock lock(_model->read_lock());
1123
1124         MidiModel::Notes& notes (_model->notes());
1125         _optimization_iterator = _events.begin();
1126
1127         bool empty_when_starting = _events.empty();
1128
1129         for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
1130
1131                 boost::shared_ptr<NoteType> note (*n);
1132                 NoteBase* cne;
1133                 bool visible;
1134
1135                 if (note_in_region_range (note, visible)) {
1136
1137                         if (!empty_when_starting && (cne = find_canvas_note (note)) != 0) {
1138
1139                                 cne->validate ();
1140
1141                                 Note* cn;
1142                                 Hit* ch;
1143
1144                                 if ((cn = dynamic_cast<Note*>(cne)) != 0) {
1145                                         update_note (cn);
1146                                 } else if ((ch = dynamic_cast<Hit*>(cne)) != 0) {
1147                                         update_hit (ch);
1148                                 }
1149
1150                                 if (visible) {
1151                                         cne->show ();
1152                                 } else {
1153                                         cne->hide ();
1154                                 }
1155
1156                         } else {
1157
1158                                 add_note (note, visible);
1159                         }
1160
1161                 } else {
1162
1163                         if (!empty_when_starting && (cne = find_canvas_note (note)) != 0) {
1164                                 cne->validate ();
1165                                 cne->hide ();
1166                         }
1167                 }
1168         }
1169
1170
1171         /* remove note items that are no longer valid */
1172
1173         if (!empty_when_starting) {
1174                 for (Events::iterator i = _events.begin(); i != _events.end(); ) {
1175                         if (!(*i)->valid ()) {
1176
1177                                 for (vector<GhostRegion*>::iterator j = ghosts.begin(); j != ghosts.end(); ++j) {
1178                                         MidiGhostRegion* gr = dynamic_cast<MidiGhostRegion*> (*j);
1179                                         if (gr) {
1180                                                 gr->remove_note (*i);
1181                                         }
1182                                 }
1183
1184                                 delete *i;
1185                                 i = _events.erase (i);
1186
1187                         } else {
1188                                 ++i;
1189                         }
1190                 }
1191         }
1192
1193         _patch_changes.clear();
1194         _sys_exes.clear();
1195
1196         display_sysexes();
1197         display_patch_changes ();
1198
1199         _marked_for_selection.clear ();
1200         _marked_for_velocity.clear ();
1201
1202         /* we may have caused _events to contain things out of order (e.g. if a note
1203            moved earlier or later). we don't generally need them in time order, but
1204            make a note that a sort is required for those cases that require it.
1205         */
1206
1207         _sort_needed = true;
1208 }
1209
1210 void
1211 MidiRegionView::display_patch_changes ()
1212 {
1213         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
1214         uint16_t chn_mask = mtv->midi_track()->get_playback_channel_mask();
1215
1216         for (uint8_t i = 0; i < 16; ++i) {
1217                 display_patch_changes_on_channel (i, chn_mask & (1 << i));
1218         }
1219 }
1220
1221 /** @param active_channel true to display patch changes fully, false to display
1222  * them `greyed-out' (as on an inactive channel)
1223  */
1224 void
1225 MidiRegionView::display_patch_changes_on_channel (uint8_t channel, bool active_channel)
1226 {
1227         for (MidiModel::PatchChanges::const_iterator i = _model->patch_changes().begin(); i != _model->patch_changes().end(); ++i) {
1228
1229                 if ((*i)->channel() != channel) {
1230                         continue;
1231                 }
1232
1233                 const string patch_name = instrument_info().get_patch_name ((*i)->bank(), (*i)->program(), channel);
1234                 add_canvas_patch_change (*i, patch_name, active_channel);
1235         }
1236 }
1237
1238 void
1239 MidiRegionView::display_sysexes()
1240 {
1241         bool have_periodic_system_messages = false;
1242         bool display_periodic_messages = true;
1243
1244         if (!Config->get_never_display_periodic_midi()) {
1245
1246                 for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
1247                         const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::MusicalTime> > mev =
1248                                 boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::MusicalTime> > (*i);
1249
1250                         if (mev) {
1251                                 if (mev->is_spp() || mev->is_mtc_quarter() || mev->is_mtc_full()) {
1252                                         have_periodic_system_messages = true;
1253                                         break;
1254                                 }
1255                         }
1256                 }
1257
1258                 if (have_periodic_system_messages) {
1259                         double zoom = trackview.editor().get_current_zoom (); // frames per pixel
1260
1261                         /* get an approximate value for the number of samples per video frame */
1262
1263                         double video_frame = trackview.session()->frame_rate() * (1.0/30);
1264
1265                         /* if we are zoomed out beyond than the cutoff (i.e. more
1266                          * frames per pixel than frames per 4 video frames), don't
1267                          * show periodic sysex messages.
1268                          */
1269
1270                         if (zoom > (video_frame*4)) {
1271                                 display_periodic_messages = false;
1272                         }
1273                 }
1274         } else {
1275                 display_periodic_messages = false;
1276         }
1277
1278         for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
1279
1280                 const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::MusicalTime> > mev =
1281                         boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::MusicalTime> > (*i);
1282
1283                 Evoral::MusicalTime time = (*i)->time();
1284
1285                 if (mev) {
1286                         if (mev->is_spp() || mev->is_mtc_quarter() || mev->is_mtc_full()) {
1287                                 if (!display_periodic_messages) {
1288                                         continue;
1289                                 }
1290                         }
1291                 }
1292
1293                 ostringstream str;
1294                 str << hex;
1295                 for (uint32_t b = 0; b < (*i)->size(); ++b) {
1296                         str << int((*i)->buffer()[b]);
1297                         if (b != (*i)->size() -1) {
1298                                 str << " ";
1299                         }
1300                 }
1301                 string text = str.str();
1302
1303                 const double x = trackview.editor().sample_to_pixel(source_beats_to_region_frames(time));
1304
1305                 double height = midi_stream_view()->contents_height();
1306
1307                 // CAIROCANVAS: no longer passing *i (the sysex event) to the
1308                 // SysEx canvas object!!!
1309
1310                 boost::shared_ptr<SysEx> sysex = boost::shared_ptr<SysEx>(
1311                         new SysEx (*this, _note_group, text, height, x, 1.0));
1312
1313                 // Show unless message is beyond the region bounds
1314                 if (time - _region->start() >= _region->length() || time < _region->start()) {
1315                         sysex->hide();
1316                 } else {
1317                         sysex->show();
1318                 }
1319
1320                 _sys_exes.push_back(sysex);
1321         }
1322 }
1323
1324 MidiRegionView::~MidiRegionView ()
1325 {
1326         in_destructor = true;
1327
1328         trackview.editor().verbose_cursor()->hide ();
1329
1330         note_delete_connection.disconnect ();
1331
1332         delete _list_editor;
1333
1334         RegionViewGoingAway (this); /* EMIT_SIGNAL */
1335
1336         if (_active_notes) {
1337                 end_write();
1338         }
1339
1340         _selection_cleared_connection.disconnect ();
1341
1342         _selection.clear();
1343         clear_events (false);
1344
1345         delete _note_group;
1346         delete _note_diff_command;
1347         delete _step_edit_cursor;
1348         delete _temporary_note_group;
1349 }
1350
1351 void
1352 MidiRegionView::region_resized (const PropertyChange& what_changed)
1353 {
1354         RegionView::region_resized(what_changed);
1355
1356         if (what_changed.contains (ARDOUR::Properties::position)) {
1357                 _region_relative_time_converter.set_origin_b(_region->position());
1358                 set_duration(_region->length(), 0);
1359                 if (_enable_display) {
1360                         redisplay_model();
1361                 }
1362         }
1363
1364         if (what_changed.contains (ARDOUR::Properties::start) ||
1365             what_changed.contains (ARDOUR::Properties::position)) {
1366                 _source_relative_time_converter.set_origin_b (_region->position() - _region->start());
1367         }
1368 }
1369
1370 void
1371 MidiRegionView::reset_width_dependent_items (double pixel_width)
1372 {
1373         RegionView::reset_width_dependent_items(pixel_width);
1374
1375         if (_enable_display) {
1376                 redisplay_model();
1377         }
1378
1379         for (PatchChanges::iterator x = _patch_changes.begin(); x != _patch_changes.end(); ++x) {
1380                 if ((*x)->canvas_item()->width() >= _pixel_width) {
1381                         (*x)->hide();
1382                 } else {
1383                         (*x)->show();
1384                 }
1385         }
1386
1387         move_step_edit_cursor (_step_edit_cursor_position);
1388         set_step_edit_cursor_width (_step_edit_cursor_width);
1389 }
1390
1391 void
1392 MidiRegionView::set_height (double height)
1393 {
1394         double old_height = _height;
1395         RegionView::set_height(height);
1396
1397         apply_note_range (midi_stream_view()->lowest_note(),
1398                           midi_stream_view()->highest_note(),
1399                           height != old_height);
1400
1401         if (name_text) {
1402                 name_text->raise_to_top();
1403         }
1404
1405         for (PatchChanges::iterator x = _patch_changes.begin(); x != _patch_changes.end(); ++x) {
1406                 (*x)->set_height (midi_stream_view()->contents_height());
1407         }
1408
1409         if (_step_edit_cursor) {
1410                 _step_edit_cursor->set_y1 (midi_stream_view()->contents_height());
1411         }
1412 }
1413
1414
1415 /** Apply the current note range from the stream view
1416  * by repositioning/hiding notes as necessary
1417  */
1418 void
1419 MidiRegionView::apply_note_range (uint8_t min, uint8_t max, bool force)
1420 {
1421         if (!_enable_display) {
1422                 return;
1423         }
1424
1425         if (!force && _current_range_min == min && _current_range_max == max) {
1426                 return;
1427         }
1428
1429         _current_range_min = min;
1430         _current_range_max = max;
1431
1432         for (Events::const_iterator i = _events.begin(); i != _events.end(); ++i) {
1433                 NoteBase* event = *i;
1434                 boost::shared_ptr<NoteType> note (event->note());
1435
1436                 if (note->note() < _current_range_min ||
1437                     note->note() > _current_range_max) {
1438                         event->hide();
1439                 } else {
1440                         event->show();
1441                 }
1442
1443                 if (Note* cnote = dynamic_cast<Note*>(event)) {
1444
1445                         const double y0 = 1. + floor (midi_stream_view()->note_to_y(note->note()));
1446                         const double y1 = y0 + std::max(1., floor(midi_stream_view()->note_height()) - 1.);
1447
1448                         cnote->set_y0 (y0);
1449                         cnote->set_y1 (y1);
1450
1451                 } else if (Hit* chit = dynamic_cast<Hit*>(event)) {
1452                         update_hit (chit);
1453                 }
1454         }
1455 }
1456
1457 GhostRegion*
1458 MidiRegionView::add_ghost (TimeAxisView& tv)
1459 {
1460         Note* note;
1461
1462         double unit_position = _region->position () / samples_per_pixel;
1463         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&tv);
1464         MidiGhostRegion* ghost;
1465
1466         if (mtv && mtv->midi_view()) {
1467                 /* if ghost is inserted into midi track, use a dedicated midi ghost canvas group
1468                    to allow having midi notes on top of note lines and waveforms.
1469                 */
1470                 ghost = new MidiGhostRegion (*mtv->midi_view(), trackview, unit_position);
1471         } else {
1472                 ghost = new MidiGhostRegion (tv, trackview, unit_position);
1473         }
1474
1475         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
1476                 if ((note = dynamic_cast<Note*>(*i)) != 0) {
1477                         ghost->add_note(note);
1478                 }
1479         }
1480
1481         ghost->set_height ();
1482         ghost->set_duration (_region->length() / samples_per_pixel);
1483         ghosts.push_back (ghost);
1484
1485         GhostRegion::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&RegionView::remove_ghost, this, _1), gui_context());
1486
1487         return ghost;
1488 }
1489
1490
1491 /** Begin tracking note state for successive calls to add_event
1492  */
1493 void
1494 MidiRegionView::begin_write()
1495 {
1496         if (_active_notes) {
1497                 delete[] _active_notes;
1498         }
1499         _active_notes = new Note*[128];
1500         for (unsigned i = 0; i < 128; ++i) {
1501                 _active_notes[i] = 0;
1502         }
1503 }
1504
1505
1506 /** Destroy note state for add_event
1507  */
1508 void
1509 MidiRegionView::end_write()
1510 {
1511         delete[] _active_notes;
1512         _active_notes = 0;
1513         _marked_for_selection.clear();
1514         _marked_for_velocity.clear();
1515 }
1516
1517
1518 /** Resolve an active MIDI note (while recording).
1519  */
1520 void
1521 MidiRegionView::resolve_note(uint8_t note, Evoral::MusicalTime end_time)
1522 {
1523         if (midi_view()->note_mode() != Sustained) {
1524                 return;
1525         }
1526
1527         if (_active_notes && _active_notes[note]) {
1528
1529                 /* XXX is end_time really region-centric? I think so, because
1530                    this is a new region that we're recording, so source zero is
1531                    the same as region zero
1532                 */
1533                 const framepos_t end_time_frames = region_beats_to_region_frames(end_time);
1534
1535                 _active_notes[note]->set_x1 (trackview.editor().sample_to_pixel(end_time_frames));
1536                 _active_notes[note]->set_outline_all ();
1537                 _active_notes[note] = 0;
1538
1539         }
1540 }
1541
1542
1543 /** Extend active notes to rightmost edge of region (if length is changed)
1544  */
1545 void
1546 MidiRegionView::extend_active_notes()
1547 {
1548         if (!_active_notes) {
1549                 return;
1550         }
1551
1552         for (unsigned i=0; i < 128; ++i) {
1553                 if (_active_notes[i]) {
1554                         _active_notes[i]->set_x1 (trackview.editor().sample_to_pixel(_region->length()));
1555                 }
1556         }
1557 }
1558
1559
1560 void
1561 MidiRegionView::play_midi_note(boost::shared_ptr<NoteType> note)
1562 {
1563         if (_no_sound_notes || !Config->get_sound_midi_notes()) {
1564                 return;
1565         }
1566
1567         RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
1568
1569         if (!route_ui || !route_ui->midi_track()) {
1570                 return;
1571         }
1572
1573         NotePlayer* np = new NotePlayer (route_ui->midi_track ());
1574         np->add (note);
1575         np->play ();
1576
1577         /* NotePlayer deletes itself */
1578 }
1579
1580 void
1581 MidiRegionView::start_playing_midi_note(boost::shared_ptr<NoteType> note)
1582 {
1583         if (_no_sound_notes || !Config->get_sound_midi_notes()) {
1584                 return;
1585         }
1586
1587         RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
1588
1589         if (!route_ui || !route_ui->midi_track()) {
1590                 return;
1591         }
1592
1593         delete _note_player;
1594         _note_player = new NotePlayer (route_ui->midi_track ());
1595         _note_player->add (note);
1596         _note_player->on ();
1597 }
1598
1599 void
1600 MidiRegionView::start_playing_midi_chord (vector<boost::shared_ptr<NoteType> > notes)
1601 {
1602         if (_no_sound_notes || !Config->get_sound_midi_notes()) {
1603                 return;
1604         }
1605
1606         RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
1607
1608         if (!route_ui || !route_ui->midi_track()) {
1609                 return;
1610         }
1611
1612         delete _note_player;
1613         _note_player = new NotePlayer (route_ui->midi_track());
1614
1615         for (vector<boost::shared_ptr<NoteType> >::iterator n = notes.begin(); n != notes.end(); ++n) {
1616                 _note_player->add (*n);
1617         }
1618
1619         _note_player->on ();
1620 }
1621
1622
1623 bool
1624 MidiRegionView::note_in_region_range (const boost::shared_ptr<NoteType> note, bool& visible) const
1625 {
1626         const framepos_t note_start_frames = source_beats_to_region_frames (note->time());
1627         bool outside = (note_start_frames  < 0) || (note_start_frames > _region->last_frame());
1628
1629         visible = (note->note() >= midi_stream_view()->lowest_note()) &&
1630                 (note->note() <= midi_stream_view()->highest_note());
1631
1632         return !outside;
1633 }
1634
1635 /** Update a canvas note's size from its model note.
1636  *  @param ev Canvas note to update.
1637  *  @param update_ghost_regions true to update the note in any ghost regions that we have, otherwise false.
1638  */
1639 void
1640 MidiRegionView::update_note (Note* ev, bool update_ghost_regions)
1641 {
1642         boost::shared_ptr<NoteType> note = ev->note();
1643         const double x = trackview.editor().sample_to_pixel (source_beats_to_region_frames (note->time()));
1644         const double y0 = 1 + floor(midi_stream_view()->note_to_y(note->note()));
1645
1646         ev->set_x0 (x);
1647         ev->set_y0 (y0);
1648
1649         /* trim note display to not overlap the end of its region */
1650
1651         if (note->length() > 0) {
1652                 const framepos_t note_end_frames = min (source_beats_to_region_frames (note->end_time()), _region->length());
1653                 ev->set_x1 (trackview.editor().sample_to_pixel (note_end_frames));
1654         } else {
1655                 ev->set_x1 (trackview.editor().sample_to_pixel (_region->length()));
1656         }
1657
1658         ev->set_y1 (y0 + std::max(1., floor(midi_stream_view()->note_height()) - 1));
1659
1660         if (!note->length()) {
1661                 if (_active_notes && note->note() < 128) {
1662                         // If this note is already active there's a stuck note,
1663                         // finish the old note rectangle
1664                         if (_active_notes[note->note()]) {
1665                                 Note* const old_rect = _active_notes[note->note()];
1666                                 boost::shared_ptr<NoteType> old_note = old_rect->note();
1667                                 old_rect->set_x1 (x);
1668                                 old_rect->set_outline_all ();
1669                         }
1670                         _active_notes[note->note()] = ev;
1671                 }
1672                 /* outline all but right edge */
1673                 ev->set_outline_what (ArdourCanvas::Rectangle::What (
1674                                               ArdourCanvas::Rectangle::TOP|
1675                                               ArdourCanvas::Rectangle::LEFT|
1676                                               ArdourCanvas::Rectangle::BOTTOM));
1677         } else {
1678                 /* outline all edges */
1679                 ev->set_outline_all ();
1680         }
1681
1682         if (update_ghost_regions) {
1683                 for (std::vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
1684                         MidiGhostRegion* gr = dynamic_cast<MidiGhostRegion*> (*i);
1685                         if (gr) {
1686                                 gr->update_note (ev);
1687                         }
1688                 }
1689         }
1690 }
1691
1692 void
1693 MidiRegionView::update_hit (Hit* ev)
1694 {
1695         boost::shared_ptr<NoteType> note = ev->note();
1696
1697         const framepos_t note_start_frames = source_beats_to_region_frames(note->time());
1698         const double x = trackview.editor().sample_to_pixel(note_start_frames);
1699         const double diamond_size = std::max(1., floor(midi_stream_view()->note_height()) - 2.);
1700         const double y = 1.5 + floor(midi_stream_view()->note_to_y(note->note())) + diamond_size * .5;
1701
1702         ev->set_position (ArdourCanvas::Duple (x, y));
1703         ev->set_height (diamond_size);
1704 }
1705
1706 /** Add a MIDI note to the view (with length).
1707  *
1708  * If in sustained mode, notes with length 0 will be considered active
1709  * notes, and resolve_note should be called when the corresponding note off
1710  * event arrives, to properly display the note.
1711  */
1712 void
1713 MidiRegionView::add_note(const boost::shared_ptr<NoteType> note, bool visible)
1714 {
1715         NoteBase* event = 0;
1716
1717         if (midi_view()->note_mode() == Sustained) {
1718
1719                 Note* ev_rect = new Note (*this, _note_group, note);
1720
1721                 update_note (ev_rect);
1722
1723                 event = ev_rect;
1724
1725                 MidiGhostRegion* gr;
1726
1727                 for (std::vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
1728                         if ((gr = dynamic_cast<MidiGhostRegion*>(*g)) != 0) {
1729                                 gr->add_note(ev_rect);
1730                         }
1731                 }
1732
1733         } else if (midi_view()->note_mode() == Percussive) {
1734
1735                 const double diamond_size = std::max(1., floor(midi_stream_view()->note_height()) - 2.);
1736
1737                 Hit* ev_diamond = new Hit (*this, _note_group, diamond_size, note);
1738
1739                 update_hit (ev_diamond);
1740
1741                 event = ev_diamond;
1742
1743         } else {
1744                 event = 0;
1745         }
1746
1747         if (event) {
1748                 if (_marked_for_selection.find(note) != _marked_for_selection.end()) {
1749                         note_selected(event, true);
1750                 }
1751
1752                 if (_marked_for_velocity.find(note) != _marked_for_velocity.end()) {
1753                         event->show_velocity();
1754                 }
1755
1756                 event->on_channel_selection_change (get_selected_channels());
1757                 _events.push_back(event);
1758
1759                 if (visible) {
1760                         event->show();
1761                 } else {
1762                         event->hide ();
1763                 }
1764         }
1765
1766         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
1767         MidiStreamView* const view = mtv->midi_view();
1768
1769         view->update_note_range (note->note());
1770 }
1771
1772 void
1773 MidiRegionView::step_add_note (uint8_t channel, uint8_t number, uint8_t velocity,
1774                                Evoral::MusicalTime pos, Evoral::MusicalTime len)
1775 {
1776         boost::shared_ptr<NoteType> new_note (new NoteType (channel, pos, len, number, velocity));
1777
1778         /* potentially extend region to hold new note */
1779
1780         framepos_t end_frame = source_beats_to_absolute_frames (new_note->end_time());
1781         framepos_t region_end = _region->last_frame();
1782
1783         if (end_frame > region_end) {
1784                 _region->set_length (end_frame - _region->position());
1785         }
1786
1787         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
1788         MidiStreamView* const view = mtv->midi_view();
1789
1790         view->update_note_range(new_note->note());
1791
1792         _marked_for_selection.clear ();
1793         clear_selection ();
1794
1795         start_note_diff_command (_("step add"));
1796         note_diff_add_note (new_note, true, false);
1797         apply_diff();
1798
1799         // last_step_edit_note = new_note;
1800 }
1801
1802 void
1803 MidiRegionView::step_sustain (Evoral::MusicalTime beats)
1804 {
1805         change_note_lengths (false, false, beats, false, true);
1806 }
1807
1808 /** Add a new patch change flag to the canvas.
1809  * @param patch the patch change to add
1810  * @param the text to display in the flag
1811  * @param active_channel true to display the flag as on an active channel, false to grey it out for an inactive channel.
1812  */
1813 void
1814 MidiRegionView::add_canvas_patch_change (MidiModel::PatchChangePtr patch, const string& displaytext, bool /*active_channel*/)
1815 {
1816         framecnt_t region_frames = source_beats_to_region_frames (patch->time());
1817         const double x = trackview.editor().sample_to_pixel (region_frames);
1818
1819         double const height = midi_stream_view()->contents_height();
1820
1821         // CAIROCANVAS: active_channel info removed from PatcChange constructor
1822         // so we need to do something more sophisticated to keep its color
1823         // appearance (MidiPatchChangeFill/MidiPatchChangeInactiveChannelFill)
1824         // up to date.
1825
1826         boost::shared_ptr<PatchChange> patch_change = boost::shared_ptr<PatchChange>(
1827                 new PatchChange(*this, group,
1828                                 displaytext,
1829                                 height,
1830                                 x, 1.0,
1831                                 instrument_info(),
1832                                 patch));
1833
1834         if (patch_change->item().width() < _pixel_width) {
1835                 // Show unless patch change is beyond the region bounds
1836                 if (region_frames < 0 || region_frames >= _region->length()) {
1837                         patch_change->hide();
1838                 } else {
1839                         patch_change->show();
1840                 }
1841         } else {
1842                 patch_change->hide ();
1843         }
1844
1845         _patch_changes.push_back (patch_change);
1846 }
1847
1848 MIDI::Name::PatchPrimaryKey
1849 MidiRegionView::patch_change_to_patch_key (MidiModel::PatchChangePtr p)
1850 {
1851         return MIDI::Name::PatchPrimaryKey (p->program(), p->bank());
1852 }
1853
1854 /// Return true iff @p pc applies to the given time on the given channel.
1855 static bool
1856 patch_applies (const ARDOUR::MidiModel::constPatchChangePtr pc, Evoral::MusicalTime time, uint8_t channel)
1857 {
1858         return pc->time() <= time && pc->channel() == channel;
1859 }
1860
1861 void
1862 MidiRegionView::get_patch_key_at (Evoral::MusicalTime time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const
1863 {
1864         // The earliest event not before time
1865         MidiModel::PatchChanges::iterator i = _model->patch_change_lower_bound (time);
1866
1867         // Go backwards until we find the latest PC for this channel, or the start
1868         while (i != _model->patch_changes().begin() &&
1869                (i == _model->patch_changes().end() ||
1870                 !patch_applies(*i, time, channel))) {
1871                 --i;
1872         }
1873
1874         if (i != _model->patch_changes().end() && patch_applies(*i, time, channel)) {
1875                 key.bank_number    = (*i)->bank();
1876                 key.program_number = (*i)->program ();
1877         } else {
1878                 key.bank_number = key.program_number = 0;
1879         }
1880
1881         if (!key.is_sane()) {
1882                 error << string_compose(_("insane MIDI patch key %1:%2"),
1883                                         key.bank_number, key.program_number) << endmsg;
1884         }
1885 }
1886
1887 void
1888 MidiRegionView::change_patch_change (PatchChange& pc, const MIDI::Name::PatchPrimaryKey& new_patch)
1889 {
1890         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("alter patch change"));
1891
1892         if (pc.patch()->program() != new_patch.program_number) {
1893                 c->change_program (pc.patch (), new_patch.program_number);
1894         }
1895
1896         int const new_bank = new_patch.bank_number;
1897         if (pc.patch()->bank() != new_bank) {
1898                 c->change_bank (pc.patch (), new_bank);
1899         }
1900
1901         _model->apply_command (*trackview.session(), c);
1902
1903         _patch_changes.clear ();
1904         display_patch_changes ();
1905 }
1906
1907 void
1908 MidiRegionView::change_patch_change (MidiModel::PatchChangePtr old_change, const Evoral::PatchChange<Evoral::MusicalTime> & new_change)
1909 {
1910         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("alter patch change"));
1911
1912         if (old_change->time() != new_change.time()) {
1913                 c->change_time (old_change, new_change.time());
1914         }
1915
1916         if (old_change->channel() != new_change.channel()) {
1917                 c->change_channel (old_change, new_change.channel());
1918         }
1919
1920         if (old_change->program() != new_change.program()) {
1921                 c->change_program (old_change, new_change.program());
1922         }
1923
1924         if (old_change->bank() != new_change.bank()) {
1925                 c->change_bank (old_change, new_change.bank());
1926         }
1927
1928         _model->apply_command (*trackview.session(), c);
1929
1930         _patch_changes.clear ();
1931         display_patch_changes ();
1932 }
1933
1934 /** Add a patch change to the region.
1935  *  @param t Time in frames relative to region position
1936  *  @param patch Patch to add; time and channel are ignored (time is converted from t, and channel comes from
1937  *  MidiTimeAxisView::get_channel_for_add())
1938  */
1939 void
1940 MidiRegionView::add_patch_change (framecnt_t t, Evoral::PatchChange<Evoral::MusicalTime> const & patch)
1941 {
1942         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
1943
1944         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("add patch change"));
1945         c->add (MidiModel::PatchChangePtr (
1946                         new Evoral::PatchChange<Evoral::MusicalTime> (
1947                                 absolute_frames_to_source_beats (_region->position() + t),
1948                                 mtv->get_channel_for_add(), patch.program(), patch.bank()
1949                                 )
1950                         )
1951                 );
1952
1953         _model->apply_command (*trackview.session(), c);
1954
1955         _patch_changes.clear ();
1956         display_patch_changes ();
1957 }
1958
1959 void
1960 MidiRegionView::move_patch_change (PatchChange& pc, Evoral::MusicalTime t)
1961 {
1962         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("move patch change"));
1963         c->change_time (pc.patch (), t);
1964         _model->apply_command (*trackview.session(), c);
1965
1966         _patch_changes.clear ();
1967         display_patch_changes ();
1968 }
1969
1970 void
1971 MidiRegionView::delete_patch_change (PatchChange* pc)
1972 {
1973         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("delete patch change"));
1974         c->remove (pc->patch ());
1975         _model->apply_command (*trackview.session(), c);
1976
1977         _patch_changes.clear ();
1978         display_patch_changes ();
1979 }
1980
1981 void
1982 MidiRegionView::previous_patch (PatchChange& patch)
1983 {
1984         if (patch.patch()->program() < 127) {
1985                 MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key (patch.patch());
1986                 key.program_number++;
1987                 change_patch_change (patch, key);
1988         }
1989 }
1990
1991 void
1992 MidiRegionView::next_patch (PatchChange& patch)
1993 {
1994         if (patch.patch()->program() > 0) {
1995                 MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key (patch.patch());
1996                 key.program_number--;
1997                 change_patch_change (patch, key);
1998         }
1999 }
2000
2001 void
2002 MidiRegionView::next_bank (PatchChange& patch)
2003 {
2004         if (patch.patch()->program() < 127) {
2005                 MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key (patch.patch());
2006                 if (key.bank_number > 0) {
2007                         key.bank_number--;
2008                         change_patch_change (patch, key);
2009                 }
2010         }
2011 }
2012
2013 void
2014 MidiRegionView::previous_bank (PatchChange& patch)
2015 {
2016         if (patch.patch()->program() > 0) {
2017                 MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key (patch.patch());
2018                 if (key.bank_number < 127) {
2019                         key.bank_number++;
2020                         change_patch_change (patch, key);
2021                 }
2022         }
2023 }
2024
2025 void
2026 MidiRegionView::maybe_remove_deleted_note_from_selection (NoteBase* cne)
2027 {
2028         if (_selection.empty()) {
2029                 return;
2030         }
2031
2032         _selection.erase (cne);
2033 }
2034
2035 void
2036 MidiRegionView::delete_selection()
2037 {
2038         if (_selection.empty()) {
2039                 return;
2040         }
2041
2042         start_note_diff_command (_("delete selection"));
2043
2044         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2045                 if ((*i)->selected()) {
2046                         _note_diff_command->remove((*i)->note());
2047                 }
2048         }
2049
2050         _selection.clear();
2051
2052         apply_diff ();
2053 }
2054
2055 void
2056 MidiRegionView::delete_note (boost::shared_ptr<NoteType> n)
2057 {
2058         start_note_diff_command (_("delete note"));
2059         _note_diff_command->remove (n);
2060         apply_diff ();
2061
2062         trackview.editor().verbose_cursor()->hide ();
2063 }
2064
2065 void
2066 MidiRegionView::clear_selection_except (NoteBase* ev, bool signal)
2067 {
2068         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
2069                 if ((*i) != ev) {
2070                         Selection::iterator tmp = i;
2071                         ++tmp;
2072
2073                         (*i)->set_selected (false);
2074                         (*i)->hide_velocity ();
2075                         _selection.erase (i);
2076
2077                         i = tmp;
2078                 } else {
2079                         ++i;
2080                 }
2081         }
2082
2083         if (!ev && _entered) {
2084                 // Clearing selection entirely, ungrab keyboard
2085                 Keyboard::magic_widget_drop_focus();
2086                 _grabbed_keyboard = false;
2087         }
2088
2089         /* this does not change the status of this regionview w.r.t the editor
2090            selection.
2091         */
2092
2093         if (signal) {
2094                 SelectionCleared (this); /* EMIT SIGNAL */
2095         }
2096 }
2097
2098 void
2099 MidiRegionView::unique_select(NoteBase* ev)
2100 {
2101         const bool selection_was_empty = _selection.empty();
2102
2103         clear_selection_except (ev);
2104
2105         /* don't bother with checking to see if we should remove this
2106            regionview from the editor selection, since we're about to add
2107            another note, and thus put/keep this regionview in the editor
2108            selection anyway.
2109         */
2110
2111         if (!ev->selected()) {
2112                 add_to_selection (ev);
2113                 if (selection_was_empty && _entered) {
2114                         // Grab keyboard for moving notes with arrow keys
2115                         Keyboard::magic_widget_grab_focus();
2116                         _grabbed_keyboard = true;
2117                 }
2118         }
2119 }
2120
2121 void
2122 MidiRegionView::select_all_notes ()
2123 {
2124         clear_selection ();
2125
2126         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2127                 add_to_selection (*i);
2128         }
2129 }
2130
2131 void
2132 MidiRegionView::select_range (framepos_t start, framepos_t end)
2133 {
2134         clear_selection ();
2135
2136         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2137                 framepos_t t = source_beats_to_absolute_frames((*i)->note()->time());
2138                 if (t >= start && t <= end) {
2139                         add_to_selection (*i);
2140                 }
2141         }
2142 }
2143
2144 void
2145 MidiRegionView::invert_selection ()
2146 {
2147         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2148                 if ((*i)->selected()) {
2149                         remove_from_selection(*i);
2150                 } else {
2151                         add_to_selection (*i);
2152                 }
2153         }
2154 }
2155
2156 void
2157 MidiRegionView::select_matching_notes (uint8_t notenum, uint16_t channel_mask, bool add, bool extend)
2158 {
2159         bool have_selection = !_selection.empty();
2160         uint8_t low_note = 127;
2161         uint8_t high_note = 0;
2162         MidiModel::Notes& notes (_model->notes());
2163         _optimization_iterator = _events.begin();
2164
2165         if (extend && !have_selection) {
2166                 extend = false;
2167         }
2168
2169         /* scan existing selection to get note range */
2170
2171         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2172                 if ((*i)->note()->note() < low_note) {
2173                         low_note = (*i)->note()->note();
2174                 }
2175                 if ((*i)->note()->note() > high_note) {
2176                         high_note = (*i)->note()->note();
2177                 }
2178         }
2179
2180         if (!add) {
2181                 clear_selection ();
2182
2183                 if (!extend && (low_note == high_note) && (high_note == notenum)) {
2184                         /* only note previously selected is the one we are
2185                          * reselecting. treat this as cancelling the selection.
2186                          */
2187                         return;
2188                 }
2189         }
2190
2191         if (extend) {
2192                 low_note = min (low_note, notenum);
2193                 high_note = max (high_note, notenum);
2194         }
2195
2196         _no_sound_notes = true;
2197
2198         for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
2199
2200                 boost::shared_ptr<NoteType> note (*n);
2201                 NoteBase* cne;
2202                 bool select = false;
2203
2204                 if (((1 << note->channel()) & channel_mask) != 0) {
2205                         if (extend) {
2206                                 if ((note->note() >= low_note && note->note() <= high_note)) {
2207                                         select = true;
2208                                 }
2209                         } else if (note->note() == notenum) {
2210                                 select = true;
2211                         }
2212                 }
2213
2214                 if (select) {
2215                         if ((cne = find_canvas_note (note)) != 0) {
2216                                 // extend is false because we've taken care of it,
2217                                 // since it extends by time range, not pitch.
2218                                 note_selected (cne, add, false);
2219                         }
2220                 }
2221
2222                 add = true; // we need to add all remaining matching notes, even if the passed in value was false (for "set")
2223
2224         }
2225
2226         _no_sound_notes = false;
2227 }
2228
2229 void
2230 MidiRegionView::toggle_matching_notes (uint8_t notenum, uint16_t channel_mask)
2231 {
2232         MidiModel::Notes& notes (_model->notes());
2233         _optimization_iterator = _events.begin();
2234
2235         for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
2236
2237                 boost::shared_ptr<NoteType> note (*n);
2238                 NoteBase* cne;
2239
2240                 if (note->note() == notenum && (((0x0001 << note->channel()) & channel_mask) != 0)) {
2241                         if ((cne = find_canvas_note (note)) != 0) {
2242                                 if (cne->selected()) {
2243                                         note_deselected (cne);
2244                                 } else {
2245                                         note_selected (cne, true, false);
2246                                 }
2247                         }
2248                 }
2249         }
2250 }
2251
2252 void
2253 MidiRegionView::note_selected (NoteBase* ev, bool add, bool extend)
2254 {
2255         if (!add) {
2256                 clear_selection_except (ev);
2257                 if (!_selection.empty()) {
2258                         PublicEditor& editor (trackview.editor());
2259                         editor.get_selection().add (this);
2260                 }
2261         }
2262
2263         if (!extend) {
2264
2265                 if (!ev->selected()) {
2266                         add_to_selection (ev);
2267                 }
2268
2269         } else {
2270                 /* find end of latest note selected, select all between that and the start of "ev" */
2271
2272                 Evoral::MusicalTime earliest = Evoral::MaxMusicalTime;
2273                 Evoral::MusicalTime latest   = Evoral::MusicalTime();
2274
2275                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2276                         if ((*i)->note()->end_time() > latest) {
2277                                 latest = (*i)->note()->end_time();
2278                         }
2279                         if ((*i)->note()->time() < earliest) {
2280                                 earliest = (*i)->note()->time();
2281                         }
2282                 }
2283
2284                 if (ev->note()->end_time() > latest) {
2285                         latest = ev->note()->end_time();
2286                 }
2287
2288                 if (ev->note()->time() < earliest) {
2289                         earliest = ev->note()->time();
2290                 }
2291
2292                 for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2293
2294                         /* find notes entirely within OR spanning the earliest..latest range */
2295
2296                         if (((*i)->note()->time() >= earliest && (*i)->note()->end_time() <= latest) ||
2297                             ((*i)->note()->time() <= earliest && (*i)->note()->end_time() >= latest)) {
2298                                 add_to_selection (*i);
2299                         }
2300
2301                 }
2302         }
2303 }
2304
2305 void
2306 MidiRegionView::note_deselected(NoteBase* ev)
2307 {
2308         remove_from_selection (ev);
2309 }
2310
2311 void
2312 MidiRegionView::update_drag_selection(framepos_t start, framepos_t end, double gy0, double gy1, bool extend)
2313 {
2314         PublicEditor& editor = trackview.editor();
2315
2316         // Convert to local coordinates
2317         const framepos_t p  = _region->position();
2318         const double     y  = midi_view()->y_position();
2319         const double     x0 = editor.sample_to_pixel(max((framepos_t)0, start - p));
2320         const double     x1 = editor.sample_to_pixel(max((framepos_t)0, end - p));
2321         const double     y0 = max(0.0, gy0 - y);
2322         const double     y1 = max(0.0, gy1 - y);
2323
2324         // TODO: Make this faster by storing the last updated selection rect, and only
2325         // adjusting things that are in the area that appears/disappeared.
2326         // We probably need a tree to be able to find events in O(log(n)) time.
2327
2328         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2329                 if ((*i)->x0() < x1 && (*i)->x1() > x0 && (*i)->y0() < y1 && (*i)->y1() > y0) {
2330                         // Rectangles intersect
2331                         if (!(*i)->selected()) {
2332                                 add_to_selection (*i);
2333                         }
2334                 } else if ((*i)->selected() && !extend) {
2335                         // Rectangles do not intersect
2336                         remove_from_selection (*i);
2337                 }
2338         }
2339
2340         typedef RouteTimeAxisView::AutomationTracks ATracks;
2341         typedef std::list<Selectable*>              Selectables;
2342
2343         /* Add control points to selection. */
2344         const ATracks& atracks = midi_view()->automation_tracks();
2345         Selectables    selectables;
2346         editor.get_selection().clear_points();
2347         for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
2348                 a->second->get_selectables(start, end, gy0, gy1, selectables);
2349                 for (Selectables::const_iterator s = selectables.begin(); s != selectables.end(); ++s) {
2350                         ControlPoint* cp = dynamic_cast<ControlPoint*>(*s);
2351                         if (cp) {
2352                                 editor.get_selection().add(cp);
2353                         }
2354                 }
2355                 a->second->set_selected_points(editor.get_selection().points);
2356         }
2357 }
2358
2359 void
2360 MidiRegionView::update_vertical_drag_selection (double y1, double y2, bool extend)
2361 {
2362         if (y1 > y2) {
2363                 swap (y1, y2);
2364         }
2365
2366         // TODO: Make this faster by storing the last updated selection rect, and only
2367         // adjusting things that are in the area that appears/disappeared.
2368         // We probably need a tree to be able to find events in O(log(n)) time.
2369
2370         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2371                 if (((*i)->y1() >= y1 && (*i)->y1() <= y2)) {
2372                         // within y- (note-) range
2373                         if (!(*i)->selected()) {
2374                                 add_to_selection (*i);
2375                         }
2376                 } else if ((*i)->selected() && !extend) {
2377                         remove_from_selection (*i);
2378                 }
2379         }
2380 }
2381
2382 void
2383 MidiRegionView::remove_from_selection (NoteBase* ev)
2384 {
2385         Selection::iterator i = _selection.find (ev);
2386
2387         if (i != _selection.end()) {
2388                 _selection.erase (i);
2389                 if (_selection.empty() && _grabbed_keyboard) {
2390                         // Ungrab keyboard
2391                         Keyboard::magic_widget_drop_focus();
2392                         _grabbed_keyboard = false;
2393                 }
2394         }
2395
2396         ev->set_selected (false);
2397         ev->hide_velocity ();
2398
2399         if (_selection.empty()) {
2400                 PublicEditor& editor (trackview.editor());
2401                 editor.get_selection().remove (this);
2402         }
2403 }
2404
2405 void
2406 MidiRegionView::add_to_selection (NoteBase* ev)
2407 {
2408         const bool selection_was_empty = _selection.empty();
2409
2410         if (_selection.insert (ev).second) {
2411                 ev->set_selected (true);
2412                 start_playing_midi_note ((ev)->note());
2413                 if (selection_was_empty && _entered) {
2414                         // Grab keyboard for moving notes with arrow keys
2415                         Keyboard::magic_widget_grab_focus();
2416                         _grabbed_keyboard = true;
2417                 }
2418         }
2419
2420         if (selection_was_empty) {
2421                 PublicEditor& editor (trackview.editor());
2422                 editor.get_selection().add (this);
2423         }
2424 }
2425
2426 void
2427 MidiRegionView::move_selection(double dx, double dy, double cumulative_dy)
2428 {
2429         typedef vector<boost::shared_ptr<NoteType> > PossibleChord;
2430         PossibleChord to_play;
2431         Evoral::MusicalTime earliest = Evoral::MaxMusicalTime;
2432
2433         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2434                 if ((*i)->note()->time() < earliest) {
2435                         earliest = (*i)->note()->time();
2436                 }
2437         }
2438
2439         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2440                 if ((*i)->note()->time() == earliest) {
2441                         to_play.push_back ((*i)->note());
2442                 }
2443                 (*i)->move_event(dx, dy);
2444         }
2445
2446         if (dy && !_selection.empty() && !_no_sound_notes && Config->get_sound_midi_notes()) {
2447
2448                 if (to_play.size() > 1) {
2449
2450                         PossibleChord shifted;
2451
2452                         for (PossibleChord::iterator n = to_play.begin(); n != to_play.end(); ++n) {
2453                                 boost::shared_ptr<NoteType> moved_note (new NoteType (**n));
2454                                 moved_note->set_note (moved_note->note() + cumulative_dy);
2455                                 shifted.push_back (moved_note);
2456                         }
2457
2458                         start_playing_midi_chord (shifted);
2459
2460                 } else if (!to_play.empty()) {
2461
2462                         boost::shared_ptr<NoteType> moved_note (new NoteType (*to_play.front()));
2463                         moved_note->set_note (moved_note->note() + cumulative_dy);
2464                         start_playing_midi_note (moved_note);
2465                 }
2466         }
2467 }
2468
2469 void
2470 MidiRegionView::note_dropped(NoteBase *, frameoffset_t dt, int8_t dnote)
2471 {
2472         uint8_t lowest_note_in_selection  = 127;
2473         uint8_t highest_note_in_selection = 0;
2474         uint8_t highest_note_difference   = 0;
2475
2476         // find highest and lowest notes first
2477
2478         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2479                 uint8_t pitch = (*i)->note()->note();
2480                 lowest_note_in_selection  = std::min(lowest_note_in_selection,  pitch);
2481                 highest_note_in_selection = std::max(highest_note_in_selection, pitch);
2482         }
2483
2484         /*
2485           cerr << "dnote: " << (int) dnote << endl;
2486           cerr << "lowest note (streamview): " << int(midi_stream_view()->lowest_note())
2487           << " highest note (streamview): " << int(midi_stream_view()->highest_note()) << endl;
2488           cerr << "lowest note (selection): " << int(lowest_note_in_selection) << " highest note(selection): "
2489           << int(highest_note_in_selection) << endl;
2490           cerr << "selection size: " << _selection.size() << endl;
2491           cerr << "Highest note in selection: " << (int) highest_note_in_selection << endl;
2492         */
2493
2494         // Make sure the note pitch does not exceed the MIDI standard range
2495         if (highest_note_in_selection + dnote > 127) {
2496                 highest_note_difference = highest_note_in_selection - 127;
2497         }
2498
2499         start_note_diff_command (_("move notes"));
2500
2501         for (Selection::iterator i = _selection.begin(); i != _selection.end() ; ++i) {
2502
2503                 framepos_t new_frames = source_beats_to_absolute_frames ((*i)->note()->time()) + dt;
2504                 Evoral::MusicalTime new_time = absolute_frames_to_source_beats (new_frames);
2505
2506                 if (new_time < 0) {
2507                         continue;
2508                 }
2509
2510                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::StartTime, new_time);
2511
2512                 uint8_t original_pitch = (*i)->note()->note();
2513                 uint8_t new_pitch      = original_pitch + dnote - highest_note_difference;
2514
2515                 // keep notes in standard midi range
2516                 clamp_to_0_127(new_pitch);
2517
2518                 lowest_note_in_selection  = std::min(lowest_note_in_selection,  new_pitch);
2519                 highest_note_in_selection = std::max(highest_note_in_selection, new_pitch);
2520
2521                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::NoteNumber, new_pitch);
2522         }
2523
2524         apply_diff();
2525
2526         // care about notes being moved beyond the upper/lower bounds on the canvas
2527         if (lowest_note_in_selection  < midi_stream_view()->lowest_note() ||
2528             highest_note_in_selection > midi_stream_view()->highest_note()) {
2529                 midi_stream_view()->set_note_range(MidiStreamView::ContentsRange);
2530         }
2531 }
2532
2533 /** @param x Pixel relative to the region position.
2534  *  @return Snapped frame relative to the region position.
2535  */
2536 framepos_t
2537 MidiRegionView::snap_pixel_to_sample(double x)
2538 {
2539         PublicEditor& editor (trackview.editor());
2540         return snap_frame_to_frame (editor.pixel_to_sample (x));
2541 }
2542
2543 /** @param x Pixel relative to the region position.
2544  *  @return Snapped pixel relative to the region position.
2545  */
2546 double
2547 MidiRegionView::snap_to_pixel(double x)
2548 {
2549         return (double) trackview.editor().sample_to_pixel(snap_pixel_to_sample(x));
2550 }
2551
2552 double
2553 MidiRegionView::get_position_pixels()
2554 {
2555         framepos_t region_frame = get_position();
2556         return trackview.editor().sample_to_pixel(region_frame);
2557 }
2558
2559 double
2560 MidiRegionView::get_end_position_pixels()
2561 {
2562         framepos_t frame = get_position() + get_duration ();
2563         return trackview.editor().sample_to_pixel(frame);
2564 }
2565
2566 framepos_t
2567 MidiRegionView::source_beats_to_absolute_frames(Evoral::MusicalTime beats) const
2568 {
2569         /* the time converter will return the frame corresponding to `beats'
2570            relative to the start of the source. The start of the source
2571            is an implied position given by region->position - region->start
2572         */
2573         const framepos_t source_start = _region->position() - _region->start();
2574         return  source_start +  _source_relative_time_converter.to (beats);
2575 }
2576
2577 Evoral::MusicalTime
2578 MidiRegionView::absolute_frames_to_source_beats(framepos_t frames) const
2579 {
2580         /* the `frames' argument needs to be converted into a frame count
2581            relative to the start of the source before being passed in to the
2582            converter.
2583         */
2584         const framepos_t source_start = _region->position() - _region->start();
2585         return  _source_relative_time_converter.from (frames - source_start);
2586 }
2587
2588 framepos_t
2589 MidiRegionView::region_beats_to_region_frames(Evoral::MusicalTime beats) const
2590 {
2591         return _region_relative_time_converter.to(beats);
2592 }
2593
2594 Evoral::MusicalTime
2595 MidiRegionView::region_frames_to_region_beats(framepos_t frames) const
2596 {
2597         return _region_relative_time_converter.from(frames);
2598 }
2599
2600 void
2601 MidiRegionView::begin_resizing (bool /*at_front*/)
2602 {
2603         _resize_data.clear();
2604
2605         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2606                 Note *note = dynamic_cast<Note*> (*i);
2607
2608                 // only insert CanvasNotes into the map
2609                 if (note) {
2610                         NoteResizeData *resize_data = new NoteResizeData();
2611                         resize_data->note = note;
2612
2613                         // create a new SimpleRect from the note which will be the resize preview
2614                         ArdourCanvas::Rectangle *resize_rect = new ArdourCanvas::Rectangle (_note_group,
2615                                                                                             ArdourCanvas::Rect (note->x0(), note->y0(), note->x0(), note->y1()));
2616
2617                         // calculate the colors: get the color settings
2618                         uint32_t fill_color = UINT_RGBA_CHANGE_A(
2619                                 ARDOUR_UI::config()->get_MidiNoteSelected(),
2620                                 128);
2621
2622                         // make the resize preview notes more transparent and bright
2623                         fill_color = UINT_INTERPOLATE(fill_color, 0xFFFFFF40, 0.5);
2624
2625                         // calculate color based on note velocity
2626                         resize_rect->set_fill_color (UINT_INTERPOLATE(
2627                                 NoteBase::meter_style_fill_color(note->note()->velocity(), note->selected()),
2628                                 fill_color,
2629                                 0.85));
2630
2631                         resize_rect->set_outline_color (NoteBase::calculate_outline (
2632                                                                 ARDOUR_UI::config()->get_MidiNoteSelected()));
2633
2634                         resize_data->resize_rect = resize_rect;
2635                         _resize_data.push_back(resize_data);
2636                 }
2637         }
2638 }
2639
2640 /** Update resizing notes while user drags.
2641  * @param primary `primary' note for the drag; ie the one that is used as the reference in non-relative mode.
2642  * @param at_front which end of the note (true == note on, false == note off)
2643  * @param delta_x change in mouse position since the start of the drag
2644  * @param relative true if relative resizing is taking place, false if absolute resizing.  This only makes
2645  * a difference when multiple notes are being resized; in relative mode, each note's length is changed by the
2646  * amount of the drag.  In non-relative mode, all selected notes are set to have the same start or end point
2647  * as the \a primary note.
2648  */
2649 void
2650 MidiRegionView::update_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative)
2651 {
2652         bool cursor_set = false;
2653
2654         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2655                 ArdourCanvas::Rectangle* resize_rect = (*i)->resize_rect;
2656                 Note* canvas_note = (*i)->note;
2657                 double current_x;
2658
2659                 if (at_front) {
2660                         if (relative) {
2661                                 current_x = canvas_note->x0() + delta_x;
2662                         } else {
2663                                 current_x = primary->x0() + delta_x;
2664                         }
2665                 } else {
2666                         if (relative) {
2667                                 current_x = canvas_note->x1() + delta_x;
2668                         } else {
2669                                 current_x = primary->x1() + delta_x;
2670                         }
2671                 }
2672
2673                 if (current_x < 0) {
2674                         // This works even with snapping because RegionView::snap_frame_to_frame()
2675                         // snaps forward if the snapped sample is before the beginning of the region
2676                         current_x = 0;
2677                 }
2678                 if (current_x > trackview.editor().sample_to_pixel(_region->length())) {
2679                         current_x = trackview.editor().sample_to_pixel(_region->length());
2680                 }
2681
2682                 if (at_front) {
2683                         resize_rect->set_x0 (snap_to_pixel(current_x));
2684                         resize_rect->set_x1 (canvas_note->x1());
2685                 } else {
2686                         resize_rect->set_x1 (snap_to_pixel(current_x));
2687                         resize_rect->set_x0 (canvas_note->x0());
2688                 }
2689
2690                 if (!cursor_set) {
2691                         const double        snapped_x = snap_pixel_to_sample (current_x);
2692                         Evoral::MusicalTime beats     = region_frames_to_region_beats (snapped_x);
2693                         Evoral::MusicalTime len       = Evoral::MusicalTime();
2694
2695                         if (at_front) {
2696                                 if (beats < canvas_note->note()->end_time()) {
2697                                         len = canvas_note->note()->time() - beats;
2698                                         len += canvas_note->note()->length();
2699                                 }
2700                         } else {
2701                                 if (beats >= canvas_note->note()->time()) {
2702                                         len = beats - canvas_note->note()->time();
2703                                 }
2704                         }
2705
2706                         char buf[16];
2707                         snprintf (buf, sizeof (buf), "%.3g beats", len.to_double());
2708                         show_verbose_cursor (buf, 0, 0);
2709
2710                         cursor_set = true;
2711                 }
2712
2713         }
2714 }
2715
2716
2717 /** Finish resizing notes when the user releases the mouse button.
2718  *  Parameters the same as for \a update_resizing().
2719  */
2720 void
2721 MidiRegionView::commit_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative)
2722 {
2723         start_note_diff_command (_("resize notes"));
2724
2725         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2726                 Note*  canvas_note = (*i)->note;
2727                 ArdourCanvas::Rectangle*  resize_rect = (*i)->resize_rect;
2728
2729                 /* Get the new x position for this resize, which is in pixels relative
2730                  * to the region position.
2731                  */
2732
2733                 double current_x;
2734
2735                 if (at_front) {
2736                         if (relative) {
2737                                 current_x = canvas_note->x0() + delta_x;
2738                         } else {
2739                                 current_x = primary->x0() + delta_x;
2740                         }
2741                 } else {
2742                         if (relative) {
2743                                 current_x = canvas_note->x1() + delta_x;
2744                         } else {
2745                                 current_x = primary->x1() + delta_x;
2746                         }
2747                 }
2748
2749                 if (current_x < 0) {
2750                         current_x = 0;
2751                 }
2752                 if (current_x > trackview.editor().sample_to_pixel(_region->length())) {
2753                         current_x = trackview.editor().sample_to_pixel(_region->length());
2754                 }
2755
2756                 /* Convert that to a frame within the source */
2757                 current_x = snap_pixel_to_sample (current_x) + _region->start ();
2758
2759                 /* and then to beats */
2760                 const Evoral::MusicalTime x_beats = region_frames_to_region_beats (current_x);
2761
2762                 if (at_front && x_beats < canvas_note->note()->end_time()) {
2763                         note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::StartTime, x_beats);
2764
2765                         Evoral::MusicalTime len = canvas_note->note()->time() - x_beats;
2766                         len += canvas_note->note()->length();
2767
2768                         if (!!len) {
2769                                 note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
2770                         }
2771                 }
2772
2773                 if (!at_front) {
2774                         const Evoral::MusicalTime len = x_beats - canvas_note->note()->time();
2775
2776                         if (!!len) {
2777                                 /* XXX convert to beats */
2778                                 note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
2779                         }
2780                 }
2781
2782                 delete resize_rect;
2783                 delete (*i);
2784         }
2785
2786         _resize_data.clear();
2787         apply_diff();
2788 }
2789
2790 void
2791 MidiRegionView::abort_resizing ()
2792 {
2793         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2794                 delete (*i)->resize_rect;
2795                 delete *i;
2796         }
2797
2798         _resize_data.clear ();
2799 }
2800
2801 void
2802 MidiRegionView::change_note_velocity(NoteBase* event, int8_t velocity, bool relative)
2803 {
2804         uint8_t new_velocity;
2805
2806         if (relative) {
2807                 new_velocity = event->note()->velocity() + velocity;
2808                 clamp_to_0_127(new_velocity);
2809         } else {
2810                 new_velocity = velocity;
2811         }
2812
2813         event->set_selected (event->selected()); // change color
2814
2815         note_diff_add_change (event, MidiModel::NoteDiffCommand::Velocity, new_velocity);
2816 }
2817
2818 void
2819 MidiRegionView::change_note_note (NoteBase* event, int8_t note, bool relative)
2820 {
2821         uint8_t new_note;
2822
2823         if (relative) {
2824                 new_note = event->note()->note() + note;
2825         } else {
2826                 new_note = note;
2827         }
2828
2829         clamp_to_0_127 (new_note);
2830         note_diff_add_change (event, MidiModel::NoteDiffCommand::NoteNumber, new_note);
2831 }
2832
2833 void
2834 MidiRegionView::trim_note (NoteBase* event, Evoral::MusicalTime front_delta, Evoral::MusicalTime end_delta)
2835 {
2836         bool change_start = false;
2837         bool change_length = false;
2838         Evoral::MusicalTime new_start;
2839         Evoral::MusicalTime new_length;
2840
2841         /* NOTE: the semantics of the two delta arguments are slightly subtle:
2842
2843            front_delta: if positive - move the start of the note later in time (shortening it)
2844            if negative - move the start of the note earlier in time (lengthening it)
2845
2846            end_delta:   if positive - move the end of the note later in time (lengthening it)
2847            if negative - move the end of the note earlier in time (shortening it)
2848         */
2849
2850         if (!!front_delta) {
2851                 if (front_delta < 0) {
2852
2853                         if (event->note()->time() < -front_delta) {
2854                                 new_start = Evoral::MusicalTime();
2855                         } else {
2856                                 new_start = event->note()->time() + front_delta; // moves earlier
2857                         }
2858
2859                         /* start moved toward zero, so move the end point out to where it used to be.
2860                            Note that front_delta is negative, so this increases the length.
2861                         */
2862
2863                         new_length = event->note()->length() - front_delta;
2864                         change_start = true;
2865                         change_length = true;
2866
2867                 } else {
2868
2869                         Evoral::MusicalTime new_pos = event->note()->time() + front_delta;
2870
2871                         if (new_pos < event->note()->end_time()) {
2872                                 new_start = event->note()->time() + front_delta;
2873                                 /* start moved toward the end, so move the end point back to where it used to be */
2874                                 new_length = event->note()->length() - front_delta;
2875                                 change_start = true;
2876                                 change_length = true;
2877                         }
2878                 }
2879
2880         }
2881
2882         if (!!end_delta) {
2883                 bool can_change = true;
2884                 if (end_delta < 0) {
2885                         if (event->note()->length() < -end_delta) {
2886                                 can_change = false;
2887                         }
2888                 }
2889
2890                 if (can_change) {
2891                         new_length = event->note()->length() + end_delta;
2892                         change_length = true;
2893                 }
2894         }
2895
2896         if (change_start) {
2897                 note_diff_add_change (event, MidiModel::NoteDiffCommand::StartTime, new_start);
2898         }
2899
2900         if (change_length) {
2901                 note_diff_add_change (event, MidiModel::NoteDiffCommand::Length, new_length);
2902         }
2903 }
2904
2905 void
2906 MidiRegionView::change_note_channel (NoteBase* event, int8_t chn, bool relative)
2907 {
2908         uint8_t new_channel;
2909
2910         if (relative) {
2911                 if (chn < 0.0) {
2912                         if (event->note()->channel() < -chn) {
2913                                 new_channel = 0;
2914                         } else {
2915                                 new_channel = event->note()->channel() + chn;
2916                         }
2917                 } else {
2918                         new_channel = event->note()->channel() + chn;
2919                 }
2920         } else {
2921                 new_channel = (uint8_t) chn;
2922         }
2923
2924         note_diff_add_change (event, MidiModel::NoteDiffCommand::Channel, new_channel);
2925 }
2926
2927 void
2928 MidiRegionView::change_note_time (NoteBase* event, Evoral::MusicalTime delta, bool relative)
2929 {
2930         Evoral::MusicalTime new_time;
2931
2932         if (relative) {
2933                 if (delta < 0.0) {
2934                         if (event->note()->time() < -delta) {
2935                                 new_time = Evoral::MusicalTime();
2936                         } else {
2937                                 new_time = event->note()->time() + delta;
2938                         }
2939                 } else {
2940                         new_time = event->note()->time() + delta;
2941                 }
2942         } else {
2943                 new_time = delta;
2944         }
2945
2946         note_diff_add_change (event, MidiModel::NoteDiffCommand::StartTime, new_time);
2947 }
2948
2949 void
2950 MidiRegionView::change_note_length (NoteBase* event, Evoral::MusicalTime t)
2951 {
2952         note_diff_add_change (event, MidiModel::NoteDiffCommand::Length, t);
2953 }
2954
2955 void
2956 MidiRegionView::change_velocities (bool up, bool fine, bool allow_smush, bool all_together)
2957 {
2958         int8_t delta;
2959         int8_t value = 0;
2960
2961         if (_selection.empty()) {
2962                 return;
2963         }
2964
2965         if (fine) {
2966                 delta = 1;
2967         } else {
2968                 delta = 10;
2969         }
2970
2971         if (!up) {
2972                 delta = -delta;
2973         }
2974
2975         if (!allow_smush) {
2976                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2977                         if ((*i)->note()->velocity() < -delta || (*i)->note()->velocity() + delta > 127) {
2978                                 goto cursor_label;
2979                         }
2980                 }
2981         }
2982
2983         start_note_diff_command (_("change velocities"));
2984
2985         for (Selection::iterator i = _selection.begin(); i != _selection.end();) {
2986                 Selection::iterator next = i;
2987                 ++next;
2988
2989                 if (all_together) {
2990                         if (i == _selection.begin()) {
2991                                 change_note_velocity (*i, delta, true);
2992                                 value = (*i)->note()->velocity() + delta;
2993                         } else {
2994                                 change_note_velocity (*i, value, false);
2995                         }
2996
2997                 } else {
2998                         change_note_velocity (*i, delta, true);
2999                 }
3000
3001                 i = next;
3002         }
3003
3004         apply_diff();
3005
3006   cursor_label:
3007         if (!_selection.empty()) {
3008                 char buf[24];
3009                 snprintf (buf, sizeof (buf), "Vel %d",
3010                           (int) (*_selection.begin())->note()->velocity());
3011                 show_verbose_cursor (buf, 10, 10);
3012         }
3013 }
3014
3015
3016 void
3017 MidiRegionView::transpose (bool up, bool fine, bool allow_smush)
3018 {
3019         if (_selection.empty()) {
3020                 return;
3021         }
3022
3023         int8_t delta;
3024
3025         if (fine) {
3026                 delta = 1;
3027         } else {
3028                 delta = 12;
3029         }
3030
3031         if (!up) {
3032                 delta = -delta;
3033         }
3034
3035         if (!allow_smush) {
3036                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3037                         if (!up) {
3038                                 if ((int8_t) (*i)->note()->note() + delta <= 0) {
3039                                         return;
3040                                 }
3041                         } else {
3042                                 if ((int8_t) (*i)->note()->note() + delta > 127) {
3043                                         return;
3044                                 }
3045                         }
3046                 }
3047         }
3048
3049         start_note_diff_command (_("transpose"));
3050
3051         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3052                 Selection::iterator next = i;
3053                 ++next;
3054                 change_note_note (*i, delta, true);
3055                 i = next;
3056         }
3057
3058         apply_diff ();
3059 }
3060
3061 void
3062 MidiRegionView::change_note_lengths (bool fine, bool shorter, Evoral::MusicalTime delta, bool start, bool end)
3063 {
3064         if (!delta) {
3065                 if (fine) {
3066                         delta = Evoral::MusicalTime(1.0/128.0);
3067                 } else {
3068                         /* grab the current grid distance */
3069                         delta = get_grid_beats(_region->position());
3070                 }
3071         }
3072
3073         if (shorter) {
3074                 delta = -delta;
3075         }
3076
3077         start_note_diff_command (_("change note lengths"));
3078
3079         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3080                 Selection::iterator next = i;
3081                 ++next;
3082
3083                 /* note the negation of the delta for start */
3084
3085                 trim_note (*i,
3086                            (start ? -delta : Evoral::MusicalTime()),
3087                            (end   ? delta  : Evoral::MusicalTime()));
3088                 i = next;
3089         }
3090
3091         apply_diff ();
3092
3093 }
3094
3095 void
3096 MidiRegionView::nudge_notes (bool forward)
3097 {
3098         if (_selection.empty()) {
3099                 return;
3100         }
3101
3102         /* pick a note as the point along the timeline to get the nudge distance.
3103            its not necessarily the earliest note, so we may want to pull the notes out
3104            into a vector and sort before using the first one.
3105         */
3106
3107         framepos_t ref_point = source_beats_to_absolute_frames ((*(_selection.begin()))->note()->time());
3108         framepos_t unused;
3109         framecnt_t distance;
3110
3111         if (trackview.editor().snap_mode() == Editing::SnapOff) {
3112
3113                 /* grid is off - use nudge distance */
3114
3115                 distance = trackview.editor().get_nudge_distance (ref_point, unused);
3116
3117         } else {
3118
3119                 /* use grid */
3120
3121                 framepos_t next_pos = ref_point;
3122
3123                 if (forward) {
3124                         if (max_framepos - 1 < next_pos) {
3125                                 next_pos += 1;
3126                         }
3127                 } else {
3128                         if (next_pos == 0) {
3129                                 return;
3130                         }
3131                         next_pos -= 1;
3132                 }
3133
3134                 trackview.editor().snap_to (next_pos, (forward ? RoundUpAlways : RoundDownAlways), false);
3135                 distance = ref_point - next_pos;
3136         }
3137
3138         if (distance == 0) {
3139                 return;
3140         }
3141
3142         Evoral::MusicalTime delta = region_frames_to_region_beats (fabs ((double)distance));
3143
3144         if (!forward) {
3145                 delta = -delta;
3146         }
3147
3148         start_note_diff_command (_("nudge"));
3149
3150         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3151                 Selection::iterator next = i;
3152                 ++next;
3153                 change_note_time (*i, delta, true);
3154                 i = next;
3155         }
3156
3157         apply_diff ();
3158 }
3159
3160 void
3161 MidiRegionView::change_channel(uint8_t channel)
3162 {
3163         start_note_diff_command(_("change channel"));
3164         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3165                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::Channel, channel);
3166         }
3167
3168         apply_diff();
3169 }
3170
3171
3172 void
3173 MidiRegionView::note_entered(NoteBase* ev)
3174 {
3175         Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
3176
3177         pre_note_enter_cursor = editor->get_canvas_cursor ();
3178
3179         if (_mouse_state == SelectTouchDragging) {
3180                 note_selected (ev, true);
3181         }
3182
3183         show_verbose_cursor (ev->note ());
3184 }
3185
3186 void
3187 MidiRegionView::note_left (NoteBase*)
3188 {
3189         Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
3190
3191         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3192                 (*i)->hide_velocity ();
3193         }
3194
3195         editor->verbose_cursor()->hide ();
3196
3197         if (pre_note_enter_cursor) {
3198                 editor->set_canvas_cursor (pre_note_enter_cursor);
3199                 pre_note_enter_cursor = 0;
3200         }
3201 }
3202
3203 void
3204 MidiRegionView::patch_entered (PatchChange* p)
3205 {
3206         ostringstream s;
3207         /* XXX should get patch name if we can */
3208         s << _("Bank ") << (p->patch()->bank() + MIDI_BP_ZERO) << '\n'
3209           << _("Program ") << ((int) p->patch()->program()) + MIDI_BP_ZERO << '\n'
3210           << _("Channel ") << ((int) p->patch()->channel() + 1);
3211         show_verbose_cursor (s.str(), 10, 20);
3212         p->item().grab_focus();
3213 }
3214
3215 void
3216 MidiRegionView::patch_left (PatchChange *)
3217 {
3218         trackview.editor().verbose_cursor()->hide ();
3219         /* focus will transfer back via the enter-notify event sent to this
3220          * midi region view.
3221          */
3222 }
3223
3224 void
3225 MidiRegionView::sysex_entered (SysEx* p)
3226 {
3227         ostringstream s;
3228         // CAIROCANVAS
3229         // need a way to extract text from p->_flag->_text
3230         // s << p->text();
3231         // show_verbose_cursor (s.str(), 10, 20);
3232         p->item().grab_focus();
3233 }
3234
3235 void
3236 MidiRegionView::sysex_left (SysEx *)
3237 {
3238         trackview.editor().verbose_cursor()->hide ();
3239         /* focus will transfer back via the enter-notify event sent to this
3240          * midi region view.
3241          */
3242 }
3243
3244 void
3245 MidiRegionView::note_mouse_position (float x_fraction, float /*y_fraction*/, bool can_set_cursor)
3246 {
3247         Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
3248         Editing::MouseMode mm = editor->current_mouse_mode();
3249         bool trimmable = (mm == MouseObject || mm == MouseTimeFX || mm == MouseDraw);
3250
3251         if (can_set_cursor) {
3252                 if (trimmable && x_fraction > 0.0 && x_fraction < 0.2) {
3253                         editor->set_canvas_cursor (editor->cursors()->left_side_trim);
3254                 } else if (trimmable && x_fraction >= 0.8 && x_fraction < 1.0) {
3255                         editor->set_canvas_cursor (editor->cursors()->right_side_trim);
3256                 } else if (pre_note_enter_cursor) {
3257                         editor->set_canvas_cursor (pre_note_enter_cursor);
3258                 }
3259         }
3260 }
3261
3262 void
3263 MidiRegionView::set_frame_color()
3264 {
3265         uint32_t f;
3266
3267         TimeAxisViewItem::set_frame_color ();
3268
3269         if (!frame) {
3270                 return;
3271         }
3272
3273         if (_selected) {
3274                 f = ARDOUR_UI::config()->get_SelectedFrameBase();
3275         } else if (high_enough_for_name) {
3276                 f= ARDOUR_UI::config()->get_MidiFrameBase();
3277         } else {
3278                 f = fill_color;
3279         }
3280
3281         if (!rect_visible) {
3282                 f = UINT_RGBA_CHANGE_A (f, 80);
3283         }
3284
3285         frame->set_fill_color (f);
3286 }
3287
3288 void
3289 MidiRegionView::midi_channel_mode_changed ()
3290 {
3291         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3292         uint16_t mask = mtv->midi_track()->get_playback_channel_mask();
3293         ChannelMode mode = mtv->midi_track()->get_playback_channel_mode ();
3294
3295         if (mode == ForceChannel) {
3296                 mask = 0xFFFF; // Show all notes as active (below)
3297         }
3298
3299         // Update notes for selection
3300         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3301                 (*i)->on_channel_selection_change (mask);
3302         }
3303
3304         _patch_changes.clear ();
3305         display_patch_changes ();
3306 }
3307
3308 void
3309 MidiRegionView::instrument_settings_changed ()
3310 {
3311         redisplay_model();
3312 }
3313
3314 void
3315 MidiRegionView::cut_copy_clear (Editing::CutCopyOp op)
3316 {
3317         if (_selection.empty()) {
3318                 return;
3319         }
3320
3321         PublicEditor& editor (trackview.editor());
3322
3323         switch (op) {
3324         case Delete:
3325                 /* XXX what to do ? */
3326                 break;
3327         case Cut:
3328         case Copy:
3329                 editor.get_cut_buffer().add (selection_as_cut_buffer());
3330                 break;
3331         default:
3332                 break;
3333         }
3334
3335         if (op != Copy) {
3336
3337                 start_note_diff_command();
3338
3339                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3340                         switch (op) {
3341                         case Copy:
3342                                 break;
3343                         case Delete:
3344                         case Cut:
3345                         case Clear:
3346                                 note_diff_remove_note (*i);
3347                                 break;
3348                         }
3349                 }
3350
3351                 apply_diff();
3352         }
3353 }
3354
3355 MidiCutBuffer*
3356 MidiRegionView::selection_as_cut_buffer () const
3357 {
3358         Notes notes;
3359
3360         for (Selection::const_iterator i = _selection.begin(); i != _selection.end(); ++i) {
3361                 NoteType* n = (*i)->note().get();
3362                 notes.insert (boost::shared_ptr<NoteType> (new NoteType (*n)));
3363         }
3364
3365         MidiCutBuffer* cb = new MidiCutBuffer (trackview.session());
3366         cb->set (notes);
3367
3368         return cb;
3369 }
3370
3371 /** This method handles undo */
3372 bool
3373 MidiRegionView::paste (framepos_t pos, const ::Selection& selection, PasteContext& ctx)
3374 {
3375         trackview.session()->begin_reversible_command (Operations::paste);
3376
3377         // Paste notes, if available
3378         MidiNoteSelection::const_iterator m = selection.midi_notes.get_nth(ctx.counts.n_notes());
3379         if (m != selection.midi_notes.end()) {
3380                 ctx.counts.increase_n_notes();
3381                 paste_internal(pos, ctx.count, ctx.times, **m);
3382         }
3383
3384         // Paste control points to automation children, if available
3385         typedef RouteTimeAxisView::AutomationTracks ATracks;
3386         const ATracks& atracks = midi_view()->automation_tracks();
3387         for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
3388                 a->second->paste(pos, selection, ctx);
3389         }
3390
3391         trackview.session()->commit_reversible_command ();
3392
3393         return true;
3394 }
3395
3396 /** This method handles undo */
3397 void
3398 MidiRegionView::paste_internal (framepos_t pos, unsigned paste_count, float times, const MidiCutBuffer& mcb)
3399 {
3400         if (mcb.empty()) {
3401                 return;
3402         }
3403
3404         start_note_diff_command (_("paste"));
3405
3406         const Evoral::MusicalTime snap_beats    = get_grid_beats(pos);
3407         const Evoral::MusicalTime first_time    = (*mcb.notes().begin())->time();
3408         const Evoral::MusicalTime last_time     = (*mcb.notes().rbegin())->end_time();
3409         const Evoral::MusicalTime duration      = last_time - first_time;
3410         const Evoral::MusicalTime snap_duration = duration.snap_to(snap_beats);
3411         const Evoral::MusicalTime paste_offset  = snap_duration * paste_count;
3412         const Evoral::MusicalTime pos_beats     = absolute_frames_to_source_beats(pos) + paste_offset;
3413         Evoral::MusicalTime       end_point     = Evoral::MusicalTime();
3414
3415         DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste data spans from %1 to %2 (%3) ; paste pos beats = %4 (based on %5 - %6)\n",
3416                                                        first_time,
3417                                                        last_time,
3418                                                        duration, pos, _region->position(),
3419                                                        pos_beats));
3420
3421         clear_selection ();
3422
3423         for (int n = 0; n < (int) times; ++n) {
3424
3425                 for (Notes::const_iterator i = mcb.notes().begin(); i != mcb.notes().end(); ++i) {
3426
3427                         boost::shared_ptr<NoteType> copied_note (new NoteType (*((*i).get())));
3428                         copied_note->set_time (pos_beats + copied_note->time() - first_time);
3429
3430                         /* make all newly added notes selected */
3431
3432                         note_diff_add_note (copied_note, true);
3433                         end_point = copied_note->end_time();
3434                 }
3435         }
3436
3437         /* if we pasted past the current end of the region, extend the region */
3438
3439         framepos_t end_frame = source_beats_to_absolute_frames (end_point);
3440         framepos_t region_end = _region->position() + _region->length() - 1;
3441
3442         if (end_frame > region_end) {
3443
3444                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste extended region from %1 to %2\n", region_end, end_frame));
3445
3446                 _region->clear_changes ();
3447                 _region->set_length (end_frame - _region->position());
3448                 trackview.session()->add_command (new StatefulDiffCommand (_region));
3449         }
3450
3451         apply_diff (true);
3452 }
3453
3454 struct EventNoteTimeEarlyFirstComparator {
3455         bool operator() (NoteBase* a, NoteBase* b) {
3456                 return a->note()->time() < b->note()->time();
3457         }
3458 };
3459
3460 void
3461 MidiRegionView::time_sort_events ()
3462 {
3463         if (!_sort_needed) {
3464                 return;
3465         }
3466
3467         EventNoteTimeEarlyFirstComparator cmp;
3468         _events.sort (cmp);
3469
3470         _sort_needed = false;
3471 }
3472
3473 void
3474 MidiRegionView::goto_next_note (bool add_to_selection)
3475 {
3476         bool use_next = false;
3477
3478         if (_events.back()->selected()) {
3479                 return;
3480         }
3481
3482         time_sort_events ();
3483
3484         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3485         uint16_t const channel_mask = mtv->midi_track()->get_playback_channel_mask();
3486
3487         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3488                 if ((*i)->selected()) {
3489                         use_next = true;
3490                         continue;
3491                 } else if (use_next) {
3492                         if (channel_mask & (1 << (*i)->note()->channel())) {
3493                                 if (!add_to_selection) {
3494                                         unique_select (*i);
3495                                 } else {
3496                                         note_selected (*i, true, false);
3497                                 }
3498                                 return;
3499                         }
3500                 }
3501         }
3502
3503         /* use the first one */
3504
3505         if (!_events.empty() && (channel_mask & (1 << _events.front()->note()->channel ()))) {
3506                 unique_select (_events.front());
3507         }
3508 }
3509
3510 void
3511 MidiRegionView::goto_previous_note (bool add_to_selection)
3512 {
3513         bool use_next = false;
3514
3515         if (_events.front()->selected()) {
3516                 return;
3517         }
3518
3519         time_sort_events ();
3520
3521         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3522         uint16_t const channel_mask = mtv->midi_track()->get_playback_channel_mask ();
3523
3524         for (Events::reverse_iterator i = _events.rbegin(); i != _events.rend(); ++i) {
3525                 if ((*i)->selected()) {
3526                         use_next = true;
3527                         continue;
3528                 } else if (use_next) {
3529                         if (channel_mask & (1 << (*i)->note()->channel())) {
3530                                 if (!add_to_selection) {
3531                                         unique_select (*i);
3532                                 } else {
3533                                         note_selected (*i, true, false);
3534                                 }
3535                                 return;
3536                         }
3537                 }
3538         }
3539
3540         /* use the last one */
3541
3542         if (!_events.empty() && (channel_mask & (1 << (*_events.rbegin())->note()->channel ()))) {
3543                 unique_select (*(_events.rbegin()));
3544         }
3545 }
3546
3547 void
3548 MidiRegionView::selection_as_notelist (Notes& selected, bool allow_all_if_none_selected)
3549 {
3550         bool had_selected = false;
3551
3552         time_sort_events ();
3553
3554         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3555                 if ((*i)->selected()) {
3556                         selected.insert ((*i)->note());
3557                         had_selected = true;
3558                 }
3559         }
3560
3561         if (allow_all_if_none_selected && !had_selected) {
3562                 for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3563                         selected.insert ((*i)->note());
3564                 }
3565         }
3566 }
3567
3568 void
3569 MidiRegionView::update_ghost_note (double x, double y)
3570 {
3571         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3572
3573         _last_ghost_x = x;
3574         _last_ghost_y = y;
3575
3576         _note_group->canvas_to_item (x, y);
3577
3578         PublicEditor& editor = trackview.editor ();
3579
3580         framepos_t const unsnapped_frame = editor.pixel_to_sample (x);
3581         framecnt_t grid_frames;
3582         framepos_t const f = snap_frame_to_grid_underneath (unsnapped_frame, grid_frames);
3583
3584         /* use region_frames... because we are converting a delta within the region
3585         */
3586
3587         const Evoral::MusicalTime length = get_grid_beats(unsnapped_frame);
3588
3589         /* note that this sets the time of the ghost note in beats relative to
3590            the start of the source; that is how all note times are stored.
3591         */
3592         _ghost_note->note()->set_time (
3593                 std::max(Evoral::MusicalTime(),
3594                          absolute_frames_to_source_beats (f + _region->position ())));
3595         _ghost_note->note()->set_length (length);
3596         _ghost_note->note()->set_note (midi_stream_view()->y_to_note (y));
3597         _ghost_note->note()->set_channel (mtv->get_channel_for_add ());
3598
3599         /* the ghost note does not appear in ghost regions, so pass false in here */
3600         update_note (_ghost_note, false);
3601
3602         show_verbose_cursor (_ghost_note->note ());
3603 }
3604
3605 void
3606 MidiRegionView::create_ghost_note (double x, double y)
3607 {
3608         remove_ghost_note ();
3609
3610         boost::shared_ptr<NoteType> g (new NoteType);
3611         _ghost_note = new Note (*this, _note_group, g);
3612         _ghost_note->set_ignore_events (true);
3613         _ghost_note->set_outline_color (0x000000aa);
3614         if (x < 0) { x = 0; }
3615         update_ghost_note (x, y);
3616         _ghost_note->show ();
3617
3618         _last_ghost_x = x;
3619         _last_ghost_y = y;
3620
3621         show_verbose_cursor (_ghost_note->note ());
3622 }
3623
3624 void
3625 MidiRegionView::remove_ghost_note ()
3626 {
3627         delete _ghost_note;
3628         _ghost_note = 0;
3629 }
3630
3631 void
3632 MidiRegionView::snap_changed ()
3633 {
3634         if (!_ghost_note) {
3635                 return;
3636         }
3637
3638         create_ghost_note (_last_ghost_x, _last_ghost_y);
3639 }
3640
3641 void
3642 MidiRegionView::drop_down_keys ()
3643 {
3644         _mouse_state = None;
3645 }
3646
3647 void
3648 MidiRegionView::maybe_select_by_position (GdkEventButton* ev, double /*x*/, double y)
3649 {
3650         /* XXX: This is dead code.  What was it for? */
3651
3652         double note = midi_stream_view()->y_to_note(y);
3653         Events e;
3654         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3655
3656         uint16_t chn_mask = mtv->midi_track()->get_playback_channel_mask();
3657
3658         if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
3659                 get_events (e, Evoral::Sequence<Evoral::MusicalTime>::PitchGreaterThanOrEqual, (uint8_t) floor (note), chn_mask);
3660         } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
3661                 get_events (e, Evoral::Sequence<Evoral::MusicalTime>::PitchLessThanOrEqual, (uint8_t) floor (note), chn_mask);
3662         } else {
3663                 return;
3664         }
3665
3666         bool add_mrv_selection = false;
3667
3668         if (_selection.empty()) {
3669                 add_mrv_selection = true;
3670         }
3671
3672         for (Events::iterator i = e.begin(); i != e.end(); ++i) {
3673                 if (_selection.insert (*i).second) {
3674                         (*i)->set_selected (true);
3675                 }
3676         }
3677
3678         if (add_mrv_selection) {
3679                 PublicEditor& editor (trackview.editor());
3680                 editor.get_selection().add (this);
3681         }
3682 }
3683
3684 void
3685 MidiRegionView::color_handler ()
3686 {
3687         RegionView::color_handler ();
3688
3689         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3690                 (*i)->set_selected ((*i)->selected()); // will change color
3691         }
3692
3693         /* XXX probably more to do here */
3694 }
3695
3696 void
3697 MidiRegionView::enable_display (bool yn)
3698 {
3699         RegionView::enable_display (yn);
3700         if (yn) {
3701                 redisplay_model ();
3702         }
3703 }
3704
3705 void
3706 MidiRegionView::show_step_edit_cursor (Evoral::MusicalTime pos)
3707 {
3708         if (_step_edit_cursor == 0) {
3709                 ArdourCanvas::Item* const group = get_canvas_group();
3710
3711                 _step_edit_cursor = new ArdourCanvas::Rectangle (group);
3712                 _step_edit_cursor->set_y0 (0);
3713                 _step_edit_cursor->set_y1 (midi_stream_view()->contents_height());
3714                 _step_edit_cursor->set_fill_color (RGBA_TO_UINT (45,0,0,90));
3715                 _step_edit_cursor->set_outline_color (RGBA_TO_UINT (85,0,0,90));
3716         }
3717
3718         move_step_edit_cursor (pos);
3719         _step_edit_cursor->show ();
3720 }
3721
3722 void
3723 MidiRegionView::move_step_edit_cursor (Evoral::MusicalTime pos)
3724 {
3725         _step_edit_cursor_position = pos;
3726
3727         if (_step_edit_cursor) {
3728                 double pixel = trackview.editor().sample_to_pixel (region_beats_to_region_frames (pos));
3729                 _step_edit_cursor->set_x0 (pixel);
3730                 set_step_edit_cursor_width (_step_edit_cursor_width);
3731         }
3732 }
3733
3734 void
3735 MidiRegionView::hide_step_edit_cursor ()
3736 {
3737         if (_step_edit_cursor) {
3738                 _step_edit_cursor->hide ();
3739         }
3740 }
3741
3742 void
3743 MidiRegionView::set_step_edit_cursor_width (Evoral::MusicalTime beats)
3744 {
3745         _step_edit_cursor_width = beats;
3746
3747         if (_step_edit_cursor) {
3748                 _step_edit_cursor->set_x1 (_step_edit_cursor->x0() + trackview.editor().sample_to_pixel (region_beats_to_region_frames (beats)));
3749         }
3750 }
3751
3752 /** Called when a diskstream on our track has received some data.  Update the view, if applicable.
3753  *  @param w Source that the data will end up in.
3754  */
3755 void
3756 MidiRegionView::data_recorded (boost::weak_ptr<MidiSource> w)
3757 {
3758         if (!_active_notes) {
3759                 /* we aren't actively being recorded to */
3760                 return;
3761         }
3762
3763         boost::shared_ptr<MidiSource> src = w.lock ();
3764         if (!src || src != midi_region()->midi_source()) {
3765                 /* recorded data was not destined for our source */
3766                 return;
3767         }
3768
3769         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (&trackview);
3770
3771         boost::shared_ptr<MidiBuffer> buf = mtv->midi_track()->get_gui_feed_buffer ();
3772
3773         BeatsFramesConverter converter (trackview.session()->tempo_map(), mtv->midi_track()->get_capture_start_frame (0));
3774
3775         framepos_t back = max_framepos;
3776
3777         for (MidiBuffer::iterator i = buf->begin(); i != buf->end(); ++i) {
3778                 Evoral::MIDIEvent<MidiBuffer::TimeType> const ev (*i, false);
3779
3780                 if (ev.is_channel_event()) {
3781                         if (get_channel_mode() == FilterChannels) {
3782                                 if (((uint16_t(1) << ev.channel()) & get_selected_channels()) == 0) {
3783                                         continue;
3784                                 }
3785                         }
3786                 }
3787
3788                 /* ev.time() is in session frames, so (ev.time() - converter.origin_b()) is
3789                    frames from the start of the source, and so time_beats is in terms of the
3790                    source.
3791                 */
3792
3793                 Evoral::MusicalTime const time_beats = converter.from (ev.time () - converter.origin_b ());
3794
3795                 if (ev.type() == MIDI_CMD_NOTE_ON) {
3796                         boost::shared_ptr<NoteType> note (
3797                                 new NoteType (ev.channel(), time_beats, Evoral::MusicalTime(), ev.note(), ev.velocity()));
3798
3799                         add_note (note, true);
3800
3801                         /* fix up our note range */
3802                         if (ev.note() < _current_range_min) {
3803                                 midi_stream_view()->apply_note_range (ev.note(), _current_range_max, true);
3804                         } else if (ev.note() > _current_range_max) {
3805                                 midi_stream_view()->apply_note_range (_current_range_min, ev.note(), true);
3806                         }
3807
3808                 } else if (ev.type() == MIDI_CMD_NOTE_OFF) {
3809                         resolve_note (ev.note (), time_beats);
3810                 }
3811
3812                 back = ev.time ();
3813         }
3814
3815         midi_stream_view()->check_record_layers (region(), back);
3816 }
3817
3818 void
3819 MidiRegionView::trim_front_starting ()
3820 {
3821         /* Reparent the note group to the region view's parent, so that it doesn't change
3822            when the region view is trimmed.
3823         */
3824         _temporary_note_group = new ArdourCanvas::Container (group->parent ());
3825         _temporary_note_group->move (group->position ());
3826         _note_group->reparent (_temporary_note_group);
3827 }
3828
3829 void
3830 MidiRegionView::trim_front_ending ()
3831 {
3832         _note_group->reparent (group);
3833         delete _temporary_note_group;
3834         _temporary_note_group = 0;
3835
3836         if (_region->start() < 0) {
3837                 /* Trim drag made start time -ve; fix this */
3838                 midi_region()->fix_negative_start ();
3839         }
3840 }
3841
3842 void
3843 MidiRegionView::edit_patch_change (PatchChange* pc)
3844 {
3845         PatchChangeDialog d (&_source_relative_time_converter, trackview.session(), *pc->patch (), instrument_info(), Gtk::Stock::APPLY, true);
3846
3847         int response = d.run();
3848
3849         switch (response) {
3850         case Gtk::RESPONSE_ACCEPT:
3851                 break;
3852         case Gtk::RESPONSE_REJECT:
3853                 delete_patch_change (pc);
3854                 return;
3855         default:
3856                 return;
3857         }
3858
3859         change_patch_change (pc->patch(), d.patch ());
3860 }
3861
3862 void
3863 MidiRegionView::delete_sysex (SysEx* /*sysex*/)
3864 {
3865         // CAIROCANVAS
3866         // sysyex object doesn't have a pointer to a sysex event
3867         // MidiModel::SysExDiffCommand* c = _model->new_sysex_diff_command (_("delete sysex"));
3868         // c->remove (sysex->sysex());
3869         // _model->apply_command (*trackview.session(), c);
3870
3871         //_sys_exes.clear ();
3872         // display_sysexes();
3873 }
3874
3875 void
3876 MidiRegionView::show_verbose_cursor (boost::shared_ptr<NoteType> n) const
3877 {
3878         using namespace MIDI::Name;
3879
3880         std::string name;
3881
3882         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3883         if (mtv) {
3884                 boost::shared_ptr<MasterDeviceNames> device_names(mtv->get_device_names());
3885                 if (device_names) {
3886                         MIDI::Name::PatchPrimaryKey patch_key;
3887                         get_patch_key_at(n->time(), n->channel(), patch_key);
3888                         name = device_names->note_name(mtv->gui_property(X_("midnam-custom-device-mode")),
3889                                                        n->channel(),
3890                                                        patch_key.bank_number,
3891                                                        patch_key.program_number,
3892                                                        n->note());
3893                 }
3894         }
3895
3896         char buf[128];
3897         snprintf (buf, sizeof (buf), "%d %s\nCh %d Vel %d",
3898                   (int) n->note (),
3899                   name.empty() ? Evoral::midi_note_name (n->note()).c_str() : name.c_str(),
3900                   (int) n->channel() + 1,
3901                   (int) n->velocity());
3902
3903         show_verbose_cursor(buf, 10, 20);
3904 }
3905
3906 void
3907 MidiRegionView::show_verbose_cursor (string const & text, double xoffset, double yoffset) const
3908 {
3909         trackview.editor().verbose_cursor()->set (text);
3910         trackview.editor().verbose_cursor()->show ();
3911         trackview.editor().verbose_cursor()->set_offset (ArdourCanvas::Duple (xoffset, yoffset));
3912 }
3913
3914 /** @param p A session framepos.
3915  *  @param grid_frames Filled in with the number of frames that a grid interval is at p.
3916  *  @return p snapped to the grid subdivision underneath it.
3917  */
3918 framepos_t
3919 MidiRegionView::snap_frame_to_grid_underneath (framepos_t p, framecnt_t& grid_frames) const
3920 {
3921         PublicEditor& editor = trackview.editor ();
3922
3923         const Evoral::MusicalTime grid_beats = get_grid_beats(p);
3924
3925         grid_frames = region_beats_to_region_frames (grid_beats);
3926
3927         /* Hack so that we always snap to the note that we are over, instead of snapping
3928            to the next one if we're more than halfway through the one we're over.
3929         */
3930         if (editor.snap_mode() == SnapNormal && p >= grid_frames / 2) {
3931                 p -= grid_frames / 2;
3932         }
3933
3934         return snap_frame_to_frame (p);
3935 }
3936
3937 /** Called when the selection has been cleared in any MidiRegionView.
3938  *  @param rv MidiRegionView that the selection was cleared in.
3939  */
3940 void
3941 MidiRegionView::selection_cleared (MidiRegionView* rv)
3942 {
3943         if (rv == this) {
3944                 return;
3945         }
3946
3947         /* Clear our selection in sympathy; but don't signal the fact */
3948         clear_selection (false);
3949 }
3950
3951 void
3952 MidiRegionView::note_button_release ()
3953 {
3954         delete _note_player;
3955         _note_player = 0;
3956 }
3957
3958 ChannelMode
3959 MidiRegionView::get_channel_mode () const
3960 {
3961         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (&trackview);
3962         return rtav->midi_track()->get_playback_channel_mode();
3963 }
3964
3965 uint16_t
3966 MidiRegionView::get_selected_channels () const
3967 {
3968         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (&trackview);
3969         return rtav->midi_track()->get_playback_channel_mask();
3970 }
3971
3972
3973 Evoral::MusicalTime
3974 MidiRegionView::get_grid_beats(framepos_t pos) const
3975 {
3976         PublicEditor&       editor  = trackview.editor();
3977         bool                success = false;
3978         Evoral::MusicalTime beats   = editor.get_grid_type_as_beats(success, pos);
3979         if (!success) {
3980                 beats = Evoral::MusicalTime(1);
3981         }
3982         return beats;
3983 }