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