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