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