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         start_note_diff_command (_("delete selection"));
2124
2125         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2126                 if ((*i)->selected()) {
2127                         _note_diff_command->remove((*i)->note());
2128                 }
2129         }
2130
2131         _selection.clear();
2132
2133         apply_diff ();
2134         hide_verbose_cursor ();
2135 }
2136
2137 void
2138 MidiRegionView::delete_note (boost::shared_ptr<NoteType> n)
2139 {
2140         start_note_diff_command (_("delete note"));
2141         _note_diff_command->remove (n);
2142         apply_diff ();
2143
2144         hide_verbose_cursor ();
2145 }
2146
2147 void
2148 MidiRegionView::clear_editor_note_selection ()
2149 {
2150         DEBUG_TRACE(DEBUG::Selection, "MRV::clear_editor_note_selection\n");
2151         PublicEditor& editor(trackview.editor());
2152         editor.get_selection().clear_midi_notes();
2153 }
2154
2155 void
2156 MidiRegionView::clear_selection ()
2157 {
2158         clear_selection_internal();
2159         PublicEditor& editor(trackview.editor());
2160         editor.get_selection().remove(this);
2161 }
2162
2163 void
2164 MidiRegionView::clear_selection_internal ()
2165 {
2166         DEBUG_TRACE(DEBUG::Selection, "MRV::clear_selection_internal\n");
2167
2168         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2169                 (*i)->set_selected(false);
2170                 (*i)->hide_velocity();
2171         }
2172         _selection.clear();
2173
2174         if (_entered) {
2175                 // Clearing selection entirely, ungrab keyboard
2176                 Keyboard::magic_widget_drop_focus();
2177                 _grabbed_keyboard = false;
2178         }
2179 }
2180
2181 void
2182 MidiRegionView::unique_select(NoteBase* ev)
2183 {
2184         clear_editor_note_selection();
2185         add_to_selection(ev);
2186 }
2187
2188 void
2189 MidiRegionView::select_all_notes ()
2190 {
2191         clear_editor_note_selection ();
2192
2193         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2194                 add_to_selection (*i);
2195         }
2196 }
2197
2198 void
2199 MidiRegionView::select_range (framepos_t start, framepos_t end)
2200 {
2201         clear_editor_note_selection ();
2202
2203         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2204                 framepos_t t = source_beats_to_absolute_frames((*i)->note()->time());
2205                 if (t >= start && t <= end) {
2206                         add_to_selection (*i);
2207                 }
2208         }
2209 }
2210
2211 void
2212 MidiRegionView::invert_selection ()
2213 {
2214         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2215                 if ((*i)->selected()) {
2216                         remove_from_selection(*i);
2217                 } else {
2218                         add_to_selection (*i);
2219                 }
2220         }
2221 }
2222
2223 /** Used for selection undo/redo.
2224     The requested notes most likely won't exist in the view until the next model redisplay.
2225 */
2226 void
2227 MidiRegionView::select_notes (list<boost::shared_ptr<NoteType> > notes)
2228 {
2229         NoteBase* cne;
2230         list<boost::shared_ptr<NoteType> >::iterator n;
2231
2232         for (n = notes.begin(); n != notes.end(); ++n) {
2233                 if ((cne = find_canvas_note(*(*n))) != 0) {
2234                         add_to_selection (cne);
2235                 } else {
2236                         _pending_note_selection.insert(*n);
2237                 }
2238         }
2239 }
2240
2241 void
2242 MidiRegionView::select_matching_notes (uint8_t notenum, uint16_t channel_mask, bool add, bool extend)
2243 {
2244         bool have_selection = !_selection.empty();
2245         uint8_t low_note = 127;
2246         uint8_t high_note = 0;
2247         MidiModel::Notes& notes (_model->notes());
2248         _optimization_iterator = _events.begin();
2249
2250         if (extend && !have_selection) {
2251                 extend = false;
2252         }
2253
2254         /* scan existing selection to get note range */
2255
2256         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2257                 if ((*i)->note()->note() < low_note) {
2258                         low_note = (*i)->note()->note();
2259                 }
2260                 if ((*i)->note()->note() > high_note) {
2261                         high_note = (*i)->note()->note();
2262                 }
2263         }
2264
2265         if (!add) {
2266                 clear_editor_note_selection ();
2267
2268                 if (!extend && (low_note == high_note) && (high_note == notenum)) {
2269                         /* only note previously selected is the one we are
2270                          * reselecting. treat this as cancelling the selection.
2271                          */
2272                         return;
2273                 }
2274         }
2275
2276         if (extend) {
2277                 low_note = min (low_note, notenum);
2278                 high_note = max (high_note, notenum);
2279         }
2280
2281         _no_sound_notes = true;
2282
2283         for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
2284
2285                 boost::shared_ptr<NoteType> note (*n);
2286                 NoteBase* cne;
2287                 bool select = false;
2288
2289                 if (((1 << note->channel()) & channel_mask) != 0) {
2290                         if (extend) {
2291                                 if ((note->note() >= low_note && note->note() <= high_note)) {
2292                                         select = true;
2293                                 }
2294                         } else if (note->note() == notenum) {
2295                                 select = true;
2296                         }
2297                 }
2298
2299                 if (select) {
2300                         if ((cne = find_canvas_note (note)) != 0) {
2301                                 // extend is false because we've taken care of it,
2302                                 // since it extends by time range, not pitch.
2303                                 note_selected (cne, add, false);
2304                         }
2305                 }
2306
2307                 add = true; // we need to add all remaining matching notes, even if the passed in value was false (for "set")
2308
2309         }
2310
2311         _no_sound_notes = false;
2312 }
2313
2314 void
2315 MidiRegionView::toggle_matching_notes (uint8_t notenum, uint16_t channel_mask)
2316 {
2317         MidiModel::Notes& notes (_model->notes());
2318         _optimization_iterator = _events.begin();
2319
2320         for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
2321
2322                 boost::shared_ptr<NoteType> note (*n);
2323                 NoteBase* cne;
2324
2325                 if (note->note() == notenum && (((0x0001 << note->channel()) & channel_mask) != 0)) {
2326                         if ((cne = find_canvas_note (note)) != 0) {
2327                                 if (cne->selected()) {
2328                                         note_deselected (cne);
2329                                 } else {
2330                                         note_selected (cne, true, false);
2331                                 }
2332                         }
2333                 }
2334         }
2335 }
2336
2337 void
2338 MidiRegionView::note_selected (NoteBase* ev, bool add, bool extend)
2339 {
2340         if (!add) {
2341                 clear_editor_note_selection();
2342                 add_to_selection (ev);
2343         }
2344
2345         if (!extend) {
2346
2347                 if (!ev->selected()) {
2348                         add_to_selection (ev);
2349                 }
2350
2351         } else {
2352                 /* find end of latest note selected, select all between that and the start of "ev" */
2353
2354                 Evoral::Beats earliest = Evoral::MaxBeats;
2355                 Evoral::Beats latest   = Evoral::Beats();
2356
2357                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2358                         if ((*i)->note()->end_time() > latest) {
2359                                 latest = (*i)->note()->end_time();
2360                         }
2361                         if ((*i)->note()->time() < earliest) {
2362                                 earliest = (*i)->note()->time();
2363                         }
2364                 }
2365
2366                 if (ev->note()->end_time() > latest) {
2367                         latest = ev->note()->end_time();
2368                 }
2369
2370                 if (ev->note()->time() < earliest) {
2371                         earliest = ev->note()->time();
2372                 }
2373
2374                 for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2375
2376                         /* find notes entirely within OR spanning the earliest..latest range */
2377
2378                         if (((*i)->note()->time() >= earliest && (*i)->note()->end_time() <= latest) ||
2379                             ((*i)->note()->time() <= earliest && (*i)->note()->end_time() >= latest)) {
2380                                 add_to_selection (*i);
2381                         }
2382
2383                 }
2384         }
2385 }
2386
2387 void
2388 MidiRegionView::note_deselected(NoteBase* ev)
2389 {
2390         remove_from_selection (ev);
2391 }
2392
2393 void
2394 MidiRegionView::update_drag_selection(framepos_t start, framepos_t end, double gy0, double gy1, bool extend)
2395 {
2396         PublicEditor& editor = trackview.editor();
2397
2398         // Convert to local coordinates
2399         const framepos_t p  = _region->position();
2400         const double     y  = midi_view()->y_position();
2401         const double     x0 = editor.sample_to_pixel(max((framepos_t)0, start - p));
2402         const double     x1 = editor.sample_to_pixel(max((framepos_t)0, end - p));
2403         const double     y0 = max(0.0, gy0 - y);
2404         const double     y1 = max(0.0, gy1 - y);
2405
2406         // TODO: Make this faster by storing the last updated selection rect, and only
2407         // adjusting things that are in the area that appears/disappeared.
2408         // We probably need a tree to be able to find events in O(log(n)) time.
2409
2410         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2411                 if ((*i)->x0() < x1 && (*i)->x1() > x0 && (*i)->y0() < y1 && (*i)->y1() > y0) {
2412                         // Rectangles intersect
2413                         if (!(*i)->selected()) {
2414                                 add_to_selection (*i);
2415                         }
2416                 } else if ((*i)->selected() && !extend) {
2417                         // Rectangles do not intersect
2418                         remove_from_selection (*i);
2419                 }
2420         }
2421
2422         typedef RouteTimeAxisView::AutomationTracks ATracks;
2423         typedef std::list<Selectable*>              Selectables;
2424
2425         /* Add control points to selection. */
2426         const ATracks& atracks = midi_view()->automation_tracks();
2427         Selectables    selectables;
2428         editor.get_selection().clear_points();
2429         for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
2430                 a->second->get_selectables(start, end, gy0, gy1, selectables);
2431                 for (Selectables::const_iterator s = selectables.begin(); s != selectables.end(); ++s) {
2432                         ControlPoint* cp = dynamic_cast<ControlPoint*>(*s);
2433                         if (cp) {
2434                                 editor.get_selection().add(cp);
2435                         }
2436                 }
2437                 a->second->set_selected_points(editor.get_selection().points);
2438         }
2439 }
2440
2441 void
2442 MidiRegionView::update_vertical_drag_selection (double y1, double y2, bool extend)
2443 {
2444         if (y1 > y2) {
2445                 swap (y1, y2);
2446         }
2447
2448         // TODO: Make this faster by storing the last updated selection rect, and only
2449         // adjusting things that are in the area that appears/disappeared.
2450         // We probably need a tree to be able to find events in O(log(n)) time.
2451
2452         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2453                 if (((*i)->y1() >= y1 && (*i)->y1() <= y2)) {
2454                         // within y- (note-) range
2455                         if (!(*i)->selected()) {
2456                                 add_to_selection (*i);
2457                         }
2458                 } else if ((*i)->selected() && !extend) {
2459                         remove_from_selection (*i);
2460                 }
2461         }
2462 }
2463
2464 void
2465 MidiRegionView::remove_from_selection (NoteBase* ev)
2466 {
2467         Selection::iterator i = _selection.find (ev);
2468
2469         if (i != _selection.end()) {
2470                 _selection.erase (i);
2471                 if (_selection.empty() && _grabbed_keyboard) {
2472                         // Ungrab keyboard
2473                         Keyboard::magic_widget_drop_focus();
2474                         _grabbed_keyboard = false;
2475                 }
2476         }
2477
2478         ev->set_selected (false);
2479         ev->hide_velocity ();
2480
2481         if (_selection.empty()) {
2482                 PublicEditor& editor (trackview.editor());
2483                 editor.get_selection().remove (this);
2484         }
2485 }
2486
2487 void
2488 MidiRegionView::add_to_selection (NoteBase* ev)
2489 {
2490         const bool selection_was_empty = _selection.empty();
2491
2492         if (_selection.insert (ev).second) {
2493                 ev->set_selected (true);
2494                 start_playing_midi_note ((ev)->note());
2495                 if (selection_was_empty && _entered) {
2496                         // Grab keyboard for moving notes with arrow keys
2497                         Keyboard::magic_widget_grab_focus();
2498                         _grabbed_keyboard = true;
2499                 }
2500         }
2501
2502         if (selection_was_empty) {
2503                 PublicEditor& editor (trackview.editor());
2504                 editor.get_selection().add (this);
2505         }
2506 }
2507
2508 void
2509 MidiRegionView::move_selection(double dx, double dy, double cumulative_dy)
2510 {
2511         typedef vector<boost::shared_ptr<NoteType> > PossibleChord;
2512         PossibleChord to_play;
2513         Evoral::Beats earliest = Evoral::MaxBeats;
2514
2515         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2516                 if ((*i)->note()->time() < earliest) {
2517                         earliest = (*i)->note()->time();
2518                 }
2519         }
2520
2521         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2522                 if ((*i)->note()->time() == earliest) {
2523                         to_play.push_back ((*i)->note());
2524                 }
2525                 (*i)->move_event(dx, dy);
2526         }
2527
2528         if (dy && !_selection.empty() && !_no_sound_notes && UIConfiguration::instance().get_sound_midi_notes()) {
2529
2530                 if (to_play.size() > 1) {
2531
2532                         PossibleChord shifted;
2533
2534                         for (PossibleChord::iterator n = to_play.begin(); n != to_play.end(); ++n) {
2535                                 boost::shared_ptr<NoteType> moved_note (new NoteType (**n));
2536                                 moved_note->set_note (moved_note->note() + cumulative_dy);
2537                                 shifted.push_back (moved_note);
2538                         }
2539
2540                         start_playing_midi_chord (shifted);
2541
2542                 } else if (!to_play.empty()) {
2543
2544                         boost::shared_ptr<NoteType> moved_note (new NoteType (*to_play.front()));
2545                         moved_note->set_note (moved_note->note() + cumulative_dy);
2546                         start_playing_midi_note (moved_note);
2547                 }
2548         }
2549 }
2550
2551 void
2552 MidiRegionView::note_dropped(NoteBase *, frameoffset_t dt, int8_t dnote)
2553 {
2554         uint8_t lowest_note_in_selection  = 127;
2555         uint8_t highest_note_in_selection = 0;
2556         uint8_t highest_note_difference   = 0;
2557
2558         // find highest and lowest notes first
2559
2560         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2561                 uint8_t pitch = (*i)->note()->note();
2562                 lowest_note_in_selection  = std::min(lowest_note_in_selection,  pitch);
2563                 highest_note_in_selection = std::max(highest_note_in_selection, pitch);
2564         }
2565
2566         /*
2567           cerr << "dnote: " << (int) dnote << endl;
2568           cerr << "lowest note (streamview): " << int(midi_stream_view()->lowest_note())
2569           << " highest note (streamview): " << int(midi_stream_view()->highest_note()) << endl;
2570           cerr << "lowest note (selection): " << int(lowest_note_in_selection) << " highest note(selection): "
2571           << int(highest_note_in_selection) << endl;
2572           cerr << "selection size: " << _selection.size() << endl;
2573           cerr << "Highest note in selection: " << (int) highest_note_in_selection << endl;
2574         */
2575
2576         // Make sure the note pitch does not exceed the MIDI standard range
2577         if (highest_note_in_selection + dnote > 127) {
2578                 highest_note_difference = highest_note_in_selection - 127;
2579         }
2580         TempoMap& map (trackview.session()->tempo_map());
2581
2582         start_note_diff_command (_("move notes"));
2583
2584         for (Selection::iterator i = _selection.begin(); i != _selection.end() ; ++i) {
2585
2586                 double const start_qn = (_region->pulse() - midi_region()->start_pulse()) * 4.0;
2587                 framepos_t new_frames = map.frame_at_quarter_note (start_qn + (*i)->note()->time().to_double()) + dt;
2588                 Evoral::Beats new_time = Evoral::Beats (map.quarter_note_at_frame (new_frames) - start_qn);
2589                 if (new_time < 0) {
2590                         continue;
2591                 }
2592
2593                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::StartTime, new_time);
2594
2595                 uint8_t original_pitch = (*i)->note()->note();
2596                 uint8_t new_pitch      = original_pitch + dnote - highest_note_difference;
2597
2598                 // keep notes in standard midi range
2599                 clamp_to_0_127(new_pitch);
2600
2601                 lowest_note_in_selection  = std::min(lowest_note_in_selection,  new_pitch);
2602                 highest_note_in_selection = std::max(highest_note_in_selection, new_pitch);
2603
2604                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::NoteNumber, new_pitch);
2605         }
2606
2607         apply_diff();
2608
2609         // care about notes being moved beyond the upper/lower bounds on the canvas
2610         if (lowest_note_in_selection  < midi_stream_view()->lowest_note() ||
2611             highest_note_in_selection > midi_stream_view()->highest_note()) {
2612                 midi_stream_view()->set_note_range(MidiStreamView::ContentsRange);
2613         }
2614 }
2615
2616 /** @param x Pixel relative to the region position.
2617  *  @param ensure_snap defaults to false. true = snap always, ignoring snap mode and magnetic snap.
2618  *  Used for inverting the snap logic with key modifiers and snap delta calculation.
2619  *  @return Snapped frame relative to the region position.
2620  */
2621 framepos_t
2622 MidiRegionView::snap_pixel_to_sample(double x, bool ensure_snap)
2623 {
2624         PublicEditor& editor (trackview.editor());
2625         return snap_frame_to_frame (editor.pixel_to_sample (x), ensure_snap);
2626 }
2627
2628 /** @param x Pixel relative to the region position.
2629  *  @param ensure_snap defaults to false. true = ignore magnetic snap and snap mode (used for snap delta calculation).
2630  *  @return Snapped pixel relative to the region position.
2631  */
2632 double
2633 MidiRegionView::snap_to_pixel(double x, bool ensure_snap)
2634 {
2635         return (double) trackview.editor().sample_to_pixel(snap_pixel_to_sample(x, ensure_snap));
2636 }
2637
2638 double
2639 MidiRegionView::get_position_pixels()
2640 {
2641         framepos_t region_frame = get_position();
2642         return trackview.editor().sample_to_pixel(region_frame);
2643 }
2644
2645 double
2646 MidiRegionView::get_end_position_pixels()
2647 {
2648         framepos_t frame = get_position() + get_duration ();
2649         return trackview.editor().sample_to_pixel(frame);
2650 }
2651
2652 framepos_t
2653 MidiRegionView::source_beats_to_absolute_frames(Evoral::Beats beats) const
2654 {
2655         /* the time converter will return the frame corresponding to `beats'
2656            relative to the start of the source. The start of the source
2657            is an implied position given by region->position - region->start
2658         */
2659         const framepos_t source_start = _region->position() - _region->start();
2660         return  source_start +  _source_relative_time_converter.to (beats);
2661 }
2662
2663 Evoral::Beats
2664 MidiRegionView::absolute_frames_to_source_beats(framepos_t frames) const
2665 {
2666         /* the `frames' argument needs to be converted into a frame count
2667            relative to the start of the source before being passed in to the
2668            converter.
2669         */
2670         const framepos_t source_start = _region->position() - _region->start();
2671         return  _source_relative_time_converter.from (frames - source_start);
2672 }
2673
2674 framepos_t
2675 MidiRegionView::region_beats_to_region_frames(Evoral::Beats beats) const
2676 {
2677         return _region_relative_time_converter.to(beats);
2678 }
2679
2680 Evoral::Beats
2681 MidiRegionView::region_frames_to_region_beats(framepos_t frames) const
2682 {
2683         return _region_relative_time_converter.from(frames);
2684 }
2685
2686 double
2687 MidiRegionView::region_frames_to_region_beats_double (framepos_t frames) const
2688 {
2689         return _region_relative_time_converter_double.from(frames);
2690 }
2691
2692 void
2693 MidiRegionView::begin_resizing (bool /*at_front*/)
2694 {
2695         _resize_data.clear();
2696
2697         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2698                 Note *note = dynamic_cast<Note*> (*i);
2699
2700                 // only insert CanvasNotes into the map
2701                 if (note) {
2702                         NoteResizeData *resize_data = new NoteResizeData();
2703                         resize_data->note = note;
2704
2705                         // create a new SimpleRect from the note which will be the resize preview
2706                         ArdourCanvas::Rectangle *resize_rect = new ArdourCanvas::Rectangle (_note_group,
2707                                                                                             ArdourCanvas::Rect (note->x0(), note->y0(), note->x0(), note->y1()));
2708
2709                         // calculate the colors: get the color settings
2710                         uint32_t fill_color = UINT_RGBA_CHANGE_A(
2711                                 UIConfiguration::instance().color ("midi note selected"),
2712                                 128);
2713
2714                         // make the resize preview notes more transparent and bright
2715                         fill_color = UINT_INTERPOLATE(fill_color, 0xFFFFFF40, 0.5);
2716
2717                         // calculate color based on note velocity
2718                         resize_rect->set_fill_color (UINT_INTERPOLATE(
2719                                 NoteBase::meter_style_fill_color(note->note()->velocity(), note->selected()),
2720                                 fill_color,
2721                                 0.85));
2722
2723                         resize_rect->set_outline_color (NoteBase::calculate_outline (
2724                                                                 UIConfiguration::instance().color ("midi note selected")));
2725
2726                         resize_data->resize_rect = resize_rect;
2727                         _resize_data.push_back(resize_data);
2728                 }
2729         }
2730 }
2731
2732 /** Update resizing notes while user drags.
2733  * @param primary `primary' note for the drag; ie the one that is used as the reference in non-relative mode.
2734  * @param at_front which end of the note (true == note on, false == note off)
2735  * @param delta_x change in mouse position since the start of the drag
2736  * @param relative true if relative resizing is taking place, false if absolute resizing.  This only makes
2737  * a difference when multiple notes are being resized; in relative mode, each note's length is changed by the
2738  * amount of the drag.  In non-relative mode, all selected notes are set to have the same start or end point
2739  * as the \a primary note.
2740  * @param snap_delta snap offset of the primary note in pixels. used in SnapRelative SnapDelta mode.
2741  * @param with_snap true if snap is to be used to determine the position, false if no snap is to be used.
2742  */
2743 void
2744 MidiRegionView::update_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative, double snap_delta, bool with_snap)
2745 {
2746         TempoMap& tmap (trackview.session()->tempo_map());
2747         bool cursor_set = false;
2748         bool const ensure_snap = trackview.editor().snap_mode () != SnapMagnetic;
2749
2750         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2751                 ArdourCanvas::Rectangle* resize_rect = (*i)->resize_rect;
2752                 Note* canvas_note = (*i)->note;
2753                 double current_x;
2754
2755                 if (at_front) {
2756                         if (relative) {
2757                                 current_x = canvas_note->x0() + delta_x + snap_delta;
2758                         } else {
2759                                 current_x = primary->x0() + delta_x + snap_delta;
2760                         }
2761                 } else {
2762                         if (relative) {
2763                                 current_x = canvas_note->x1() + delta_x + snap_delta;
2764                         } else {
2765                                 current_x = primary->x1() + delta_x + snap_delta;
2766                         }
2767                 }
2768
2769                 if (current_x < 0) {
2770                         // This works even with snapping because RegionView::snap_frame_to_frame()
2771                         // snaps forward if the snapped sample is before the beginning of the region
2772                         current_x = 0;
2773                 }
2774                 if (current_x > trackview.editor().sample_to_pixel(_region->length())) {
2775                         current_x = trackview.editor().sample_to_pixel(_region->length());
2776                 }
2777
2778                 if (at_front) {
2779                         if (with_snap) {
2780                                 resize_rect->set_x0 (snap_to_pixel (current_x, ensure_snap) - snap_delta);
2781                         } else {
2782                                 resize_rect->set_x0 (current_x - snap_delta);
2783                         }
2784                         resize_rect->set_x1 (canvas_note->x1());
2785                 } else {
2786                         if (with_snap) {
2787                                 resize_rect->set_x1 (snap_to_pixel (current_x, ensure_snap) - snap_delta);
2788                         } else {
2789                                 resize_rect->set_x1 (current_x - snap_delta);
2790                         }
2791                         resize_rect->set_x0 (canvas_note->x0());
2792                 }
2793
2794                 if (!cursor_set) {
2795                         /* Convert snap delta from pixels to beats. */
2796                         framepos_t snap_delta_samps = trackview.editor().pixel_to_sample (snap_delta);
2797                         double snap_delta_beats = 0.0;
2798                         int sign = 1;
2799
2800                         /* negative beat offsets aren't allowed */
2801                         if (snap_delta_samps > 0) {
2802                                 snap_delta_beats = region_frames_to_region_beats_double (snap_delta_samps);
2803                         } else if (snap_delta_samps < 0) {
2804                                 snap_delta_beats = region_frames_to_region_beats_double ( - snap_delta_samps);
2805                                 sign = -1;
2806                         }
2807
2808                         double  snapped_x;
2809                         int32_t divisions = 0;
2810
2811                         if (with_snap) {
2812                                 snapped_x = snap_pixel_to_sample (current_x, ensure_snap);
2813                                 divisions = trackview.editor().get_grid_music_divisions (0);
2814                         } else {
2815                                 snapped_x = trackview.editor ().pixel_to_sample (current_x);
2816                         }
2817                         const Evoral::Beats beats = Evoral::Beats (tmap.exact_beat_at_frame (snapped_x + midi_region()->position(), divisions)
2818                                                                      - midi_region()->beat()) + midi_region()->start_beats();
2819
2820                         Evoral::Beats len         = Evoral::Beats();
2821
2822                         if (at_front) {
2823                                 if (beats < canvas_note->note()->end_time()) {
2824                                         len = canvas_note->note()->time() - beats + (sign * snap_delta_beats);
2825                                         len += canvas_note->note()->length();
2826                                 }
2827                         } else {
2828                                 if (beats >= canvas_note->note()->time()) {
2829                                         len = beats - canvas_note->note()->time() - (sign * snap_delta_beats);
2830                                 }
2831                         }
2832
2833                         len = std::max(Evoral::Beats(1 / 512.0), len);
2834
2835                         char buf[16];
2836                         snprintf (buf, sizeof (buf), "%.3g beats", len.to_double());
2837                         show_verbose_cursor (buf, 0, 0);
2838
2839                         cursor_set = true;
2840                 }
2841
2842         }
2843 }
2844
2845
2846 /** Finish resizing notes when the user releases the mouse button.
2847  *  Parameters the same as for \a update_resizing().
2848  */
2849 void
2850 MidiRegionView::commit_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative, double snap_delta, bool with_snap)
2851 {
2852         _note_diff_command = _model->new_note_diff_command (_("resize notes"));
2853         TempoMap& tmap (trackview.session()->tempo_map());
2854
2855         /* XX why doesn't snap_pixel_to_sample() handle this properly? */
2856         bool const ensure_snap = trackview.editor().snap_mode () != SnapMagnetic;
2857
2858         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2859                 Note*  canvas_note = (*i)->note;
2860                 ArdourCanvas::Rectangle*  resize_rect = (*i)->resize_rect;
2861
2862                 /* Get the new x position for this resize, which is in pixels relative
2863                  * to the region position.
2864                  */
2865
2866                 double current_x;
2867
2868                 if (at_front) {
2869                         if (relative) {
2870                                 current_x = canvas_note->x0() + delta_x + snap_delta;
2871                         } else {
2872                                 current_x = primary->x0() + delta_x + snap_delta;
2873                         }
2874                 } else {
2875                         if (relative) {
2876                                 current_x = canvas_note->x1() + delta_x + snap_delta;
2877                         } else {
2878                                 current_x = primary->x1() + delta_x + snap_delta;
2879                         }
2880                 }
2881
2882                 if (current_x < 0) {
2883                         current_x = 0;
2884                 }
2885                 if (current_x > trackview.editor().sample_to_pixel(_region->length())) {
2886                         current_x = trackview.editor().sample_to_pixel(_region->length());
2887                 }
2888
2889                 /* Convert snap delta from pixels to beats with sign. */
2890                 framepos_t snap_delta_samps = trackview.editor().pixel_to_sample (snap_delta);
2891                 double snap_delta_beats = 0.0;
2892                 int sign = 1;
2893
2894                 if (snap_delta_samps > 0) {
2895                         snap_delta_beats = region_frames_to_region_beats_double (snap_delta_samps);
2896                 } else if (snap_delta_samps < 0) {
2897                         snap_delta_beats = region_frames_to_region_beats_double ( - snap_delta_samps);
2898                         sign = -1;
2899                 }
2900
2901                 uint32_t divisions = 0;
2902                 /* Convert the new x position to a frame within the source */
2903                 framepos_t current_fr;
2904                 if (with_snap) {
2905                         current_fr = snap_pixel_to_sample (current_x, ensure_snap);
2906                         divisions = trackview.editor().get_grid_music_divisions (0);
2907                 } else {
2908                         current_fr = trackview.editor().pixel_to_sample (current_x);
2909                 }
2910
2911                 /* and then to beats */
2912                 const double e_baf = tmap.exact_beat_at_frame (current_fr + midi_region()->position(), divisions);
2913                 const double quarter_note_start_beat = tmap.quarter_note_at_beat (_region->beat() - midi_region()->start_beats().to_double());
2914                 const Evoral::Beats x_beats = Evoral::Beats (tmap.quarter_note_at_beat (e_baf) - quarter_note_start_beat);
2915
2916                 if (at_front && x_beats < canvas_note->note()->end_time()) {
2917                         note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::StartTime, x_beats - (sign * snap_delta_beats));
2918                         Evoral::Beats len = canvas_note->note()->time() - x_beats + (sign * snap_delta_beats);
2919                         len += canvas_note->note()->length();
2920
2921                         if (!!len) {
2922                                 note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
2923                         }
2924                 }
2925
2926                 if (!at_front) {
2927                         Evoral::Beats len = std::max(Evoral::Beats(1 / 512.0),
2928                                                      x_beats - canvas_note->note()->time() - (sign * snap_delta_beats));
2929                         note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
2930                 }
2931
2932                 delete resize_rect;
2933                 delete (*i);
2934         }
2935
2936         _resize_data.clear();
2937         apply_diff(true);
2938 }
2939
2940 void
2941 MidiRegionView::abort_resizing ()
2942 {
2943         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2944                 delete (*i)->resize_rect;
2945                 delete *i;
2946         }
2947
2948         _resize_data.clear ();
2949 }
2950
2951 void
2952 MidiRegionView::change_note_velocity(NoteBase* event, int8_t velocity, bool relative)
2953 {
2954         uint8_t new_velocity;
2955
2956         if (relative) {
2957                 new_velocity = event->note()->velocity() + velocity;
2958                 clamp_to_0_127(new_velocity);
2959         } else {
2960                 new_velocity = velocity;
2961         }
2962
2963         event->set_selected (event->selected()); // change color
2964
2965         note_diff_add_change (event, MidiModel::NoteDiffCommand::Velocity, new_velocity);
2966 }
2967
2968 void
2969 MidiRegionView::change_note_note (NoteBase* event, int8_t note, bool relative)
2970 {
2971         uint8_t new_note;
2972
2973         if (relative) {
2974                 new_note = event->note()->note() + note;
2975         } else {
2976                 new_note = note;
2977         }
2978
2979         clamp_to_0_127 (new_note);
2980         note_diff_add_change (event, MidiModel::NoteDiffCommand::NoteNumber, new_note);
2981 }
2982
2983 void
2984 MidiRegionView::trim_note (NoteBase* event, Evoral::Beats front_delta, Evoral::Beats end_delta)
2985 {
2986         bool change_start = false;
2987         bool change_length = false;
2988         Evoral::Beats new_start;
2989         Evoral::Beats new_length;
2990
2991         /* NOTE: the semantics of the two delta arguments are slightly subtle:
2992
2993            front_delta: if positive - move the start of the note later in time (shortening it)
2994            if negative - move the start of the note earlier in time (lengthening it)
2995
2996            end_delta:   if positive - move the end of the note later in time (lengthening it)
2997            if negative - move the end of the note earlier in time (shortening it)
2998         */
2999
3000         if (!!front_delta) {
3001                 if (front_delta < 0) {
3002
3003                         if (event->note()->time() < -front_delta) {
3004                                 new_start = Evoral::Beats();
3005                         } else {
3006                                 new_start = event->note()->time() + front_delta; // moves earlier
3007                         }
3008
3009                         /* start moved toward zero, so move the end point out to where it used to be.
3010                            Note that front_delta is negative, so this increases the length.
3011                         */
3012
3013                         new_length = event->note()->length() - front_delta;
3014                         change_start = true;
3015                         change_length = true;
3016
3017                 } else {
3018
3019                         Evoral::Beats new_pos = event->note()->time() + front_delta;
3020
3021                         if (new_pos < event->note()->end_time()) {
3022                                 new_start = event->note()->time() + front_delta;
3023                                 /* start moved toward the end, so move the end point back to where it used to be */
3024                                 new_length = event->note()->length() - front_delta;
3025                                 change_start = true;
3026                                 change_length = true;
3027                         }
3028                 }
3029
3030         }
3031
3032         if (!!end_delta) {
3033                 bool can_change = true;
3034                 if (end_delta < 0) {
3035                         if (event->note()->length() < -end_delta) {
3036                                 can_change = false;
3037                         }
3038                 }
3039
3040                 if (can_change) {
3041                         new_length = event->note()->length() + end_delta;
3042                         change_length = true;
3043                 }
3044         }
3045
3046         if (change_start) {
3047                 note_diff_add_change (event, MidiModel::NoteDiffCommand::StartTime, new_start);
3048         }
3049
3050         if (change_length) {
3051                 note_diff_add_change (event, MidiModel::NoteDiffCommand::Length, new_length);
3052         }
3053 }
3054
3055 void
3056 MidiRegionView::change_note_channel (NoteBase* event, int8_t chn, bool relative)
3057 {
3058         uint8_t new_channel;
3059
3060         if (relative) {
3061                 if (chn < 0.0) {
3062                         if (event->note()->channel() < -chn) {
3063                                 new_channel = 0;
3064                         } else {
3065                                 new_channel = event->note()->channel() + chn;
3066                         }
3067                 } else {
3068                         new_channel = event->note()->channel() + chn;
3069                 }
3070         } else {
3071                 new_channel = (uint8_t) chn;
3072         }
3073
3074         note_diff_add_change (event, MidiModel::NoteDiffCommand::Channel, new_channel);
3075 }
3076
3077 void
3078 MidiRegionView::change_note_time (NoteBase* event, Evoral::Beats delta, bool relative)
3079 {
3080         Evoral::Beats new_time;
3081
3082         if (relative) {
3083                 if (delta < 0.0) {
3084                         if (event->note()->time() < -delta) {
3085                                 new_time = Evoral::Beats();
3086                         } else {
3087                                 new_time = event->note()->time() + delta;
3088                         }
3089                 } else {
3090                         new_time = event->note()->time() + delta;
3091                 }
3092         } else {
3093                 new_time = delta;
3094         }
3095
3096         note_diff_add_change (event, MidiModel::NoteDiffCommand::StartTime, new_time);
3097 }
3098
3099 void
3100 MidiRegionView::change_note_length (NoteBase* event, Evoral::Beats t)
3101 {
3102         note_diff_add_change (event, MidiModel::NoteDiffCommand::Length, t);
3103 }
3104
3105 void
3106 MidiRegionView::change_velocities (bool up, bool fine, bool allow_smush, bool all_together)
3107 {
3108         int8_t delta;
3109         int8_t value = 0;
3110
3111         if (_selection.empty()) {
3112                 return;
3113         }
3114
3115         if (fine) {
3116                 delta = 1;
3117         } else {
3118                 delta = 10;
3119         }
3120
3121         if (!up) {
3122                 delta = -delta;
3123         }
3124
3125         if (!allow_smush) {
3126                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3127                         if ((*i)->note()->velocity() < -delta || (*i)->note()->velocity() + delta > 127) {
3128                                 goto cursor_label;
3129                         }
3130                 }
3131         }
3132
3133         start_note_diff_command (_("change velocities"));
3134
3135         for (Selection::iterator i = _selection.begin(); i != _selection.end();) {
3136                 Selection::iterator next = i;
3137                 ++next;
3138
3139                 if (all_together) {
3140                         if (i == _selection.begin()) {
3141                                 change_note_velocity (*i, delta, true);
3142                                 value = (*i)->note()->velocity() + delta;
3143                         } else {
3144                                 change_note_velocity (*i, value, false);
3145                         }
3146
3147                 } else {
3148                         change_note_velocity (*i, delta, true);
3149                 }
3150
3151                 i = next;
3152         }
3153
3154         apply_diff();
3155
3156   cursor_label:
3157         if (!_selection.empty()) {
3158                 char buf[24];
3159                 snprintf (buf, sizeof (buf), "Vel %d",
3160                           (int) (*_selection.begin())->note()->velocity());
3161                 show_verbose_cursor (buf, 10, 10);
3162         }
3163 }
3164
3165
3166 void
3167 MidiRegionView::transpose (bool up, bool fine, bool allow_smush)
3168 {
3169         if (_selection.empty()) {
3170                 return;
3171         }
3172
3173         int8_t delta;
3174
3175         if (fine) {
3176                 delta = 1;
3177         } else {
3178                 delta = 12;
3179         }
3180
3181         if (!up) {
3182                 delta = -delta;
3183         }
3184
3185         if (!allow_smush) {
3186                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3187                         if (!up) {
3188                                 if ((int8_t) (*i)->note()->note() + delta <= 0) {
3189                                         return;
3190                                 }
3191                         } else {
3192                                 if ((int8_t) (*i)->note()->note() + delta > 127) {
3193                                         return;
3194                                 }
3195                         }
3196                 }
3197         }
3198
3199         start_note_diff_command (_("transpose"));
3200
3201         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3202                 Selection::iterator next = i;
3203                 ++next;
3204                 change_note_note (*i, delta, true);
3205                 i = next;
3206         }
3207
3208         apply_diff ();
3209 }
3210
3211 void
3212 MidiRegionView::change_note_lengths (bool fine, bool shorter, Evoral::Beats delta, bool start, bool end)
3213 {
3214         if (!delta) {
3215                 if (fine) {
3216                         delta = Evoral::Beats(1.0/128.0);
3217                 } else {
3218                         /* grab the current grid distance */
3219                         delta = get_grid_beats(_region->position());
3220                 }
3221         }
3222
3223         if (shorter) {
3224                 delta = -delta;
3225         }
3226
3227         start_note_diff_command (_("change note lengths"));
3228
3229         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3230                 Selection::iterator next = i;
3231                 ++next;
3232
3233                 /* note the negation of the delta for start */
3234
3235                 trim_note (*i,
3236                            (start ? -delta : Evoral::Beats()),
3237                            (end   ? delta  : Evoral::Beats()));
3238                 i = next;
3239         }
3240
3241         apply_diff ();
3242
3243 }
3244
3245 void
3246 MidiRegionView::nudge_notes (bool forward, bool fine)
3247 {
3248         if (_selection.empty()) {
3249                 return;
3250         }
3251
3252         /* pick a note as the point along the timeline to get the nudge distance.
3253            its not necessarily the earliest note, so we may want to pull the notes out
3254            into a vector and sort before using the first one.
3255         */
3256
3257         const framepos_t ref_point = source_beats_to_absolute_frames ((*(_selection.begin()))->note()->time());
3258         Evoral::Beats    delta;
3259
3260         if (!fine) {
3261
3262                 /* non-fine, move by 1 bar regardless of snap */
3263                 delta = Evoral::Beats(trackview.session()->tempo_map().meter_at_frame (ref_point).divisions_per_bar());
3264
3265         } else if (trackview.editor().snap_mode() == Editing::SnapOff) {
3266
3267                 /* grid is off - use nudge distance */
3268
3269                 framepos_t       unused;
3270                 const framecnt_t distance = trackview.editor().get_nudge_distance (ref_point, unused);
3271                 delta = region_frames_to_region_beats (fabs ((double)distance));
3272
3273         } else {
3274
3275                 /* use grid */
3276
3277                 framepos_t next_pos = ref_point;
3278
3279                 if (forward) {
3280                         if (max_framepos - 1 < next_pos) {
3281                                 next_pos += 1;
3282                         }
3283                 } else {
3284                         if (next_pos == 0) {
3285                                 return;
3286                         }
3287                         next_pos -= 1;
3288                 }
3289
3290                 trackview.editor().snap_to (next_pos, (forward ? RoundUpAlways : RoundDownAlways), false);
3291                 const framecnt_t distance = ref_point - next_pos;
3292                 delta = region_frames_to_region_beats (fabs ((double)distance));
3293         }
3294
3295         if (!delta) {
3296                 return;
3297         }
3298
3299         if (!forward) {
3300                 delta = -delta;
3301         }
3302
3303         start_note_diff_command (_("nudge"));
3304
3305         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3306                 Selection::iterator next = i;
3307                 ++next;
3308                 change_note_time (*i, delta, true);
3309                 i = next;
3310         }
3311
3312         apply_diff ();
3313 }
3314
3315 void
3316 MidiRegionView::change_channel(uint8_t channel)
3317 {
3318         start_note_diff_command(_("change channel"));
3319         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3320                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::Channel, channel);
3321         }
3322
3323         apply_diff();
3324 }
3325
3326
3327 void
3328 MidiRegionView::note_entered(NoteBase* ev)
3329 {
3330         _note_entered = true;
3331
3332         Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
3333
3334         if (_mouse_state == SelectTouchDragging) {
3335
3336                 note_selected (ev, true);
3337
3338         } else if (editor->current_mouse_mode() == MouseContent) {
3339
3340                 remove_ghost_note ();
3341                 show_verbose_cursor (ev->note ());
3342
3343         } else if (editor->current_mouse_mode() == MouseDraw) {
3344
3345                 remove_ghost_note ();
3346                 show_verbose_cursor (ev->note ());
3347         }
3348 }
3349
3350 void
3351 MidiRegionView::note_left (NoteBase*)
3352 {
3353         _note_entered = false;
3354
3355         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3356                 (*i)->hide_velocity ();
3357         }
3358
3359         hide_verbose_cursor ();
3360 }
3361
3362 void
3363 MidiRegionView::patch_entered (PatchChange* p)
3364 {
3365         ostringstream s;
3366         s << _("Bank ") << (p->patch()->bank() + MIDI_BP_ZERO) << '\n'
3367           << instrument_info().get_patch_name_without (p->patch()->bank(), p->patch()->program(), p->patch()->channel()) << '\n'
3368           << _("Channel ") << ((int) p->patch()->channel() + 1);
3369         show_verbose_cursor (s.str(), 10, 20);
3370         p->item().grab_focus();
3371 }
3372
3373 void
3374 MidiRegionView::patch_left (PatchChange *)
3375 {
3376         hide_verbose_cursor ();
3377         /* focus will transfer back via the enter-notify event sent to this
3378          * midi region view.
3379          */
3380 }
3381
3382 void
3383 MidiRegionView::sysex_entered (SysEx* p)
3384 {
3385         ostringstream s;
3386         // CAIROCANVAS
3387         // need a way to extract text from p->_flag->_text
3388         // s << p->text();
3389         // show_verbose_cursor (s.str(), 10, 20);
3390         p->item().grab_focus();
3391 }
3392
3393 void
3394 MidiRegionView::sysex_left (SysEx *)
3395 {
3396         hide_verbose_cursor ();
3397         /* focus will transfer back via the enter-notify event sent to this
3398          * midi region view.
3399          */
3400 }
3401
3402 void
3403 MidiRegionView::note_mouse_position (float x_fraction, float /*y_fraction*/, bool can_set_cursor)
3404 {
3405         Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
3406         Editing::MouseMode mm = editor->current_mouse_mode();
3407         bool trimmable = (mm == MouseContent || mm == MouseTimeFX || mm == MouseDraw);
3408
3409         Editor::EnterContext* ctx = editor->get_enter_context(NoteItem);
3410         if (can_set_cursor && ctx) {
3411                 if (trimmable && x_fraction > 0.0 && x_fraction < 0.2) {
3412                         ctx->cursor_ctx->change(editor->cursors()->left_side_trim);
3413                 } else if (trimmable && x_fraction >= 0.8 && x_fraction < 1.0) {
3414                         ctx->cursor_ctx->change(editor->cursors()->right_side_trim);
3415                 } else {
3416                         ctx->cursor_ctx->change(editor->cursors()->grabber_note);
3417                 }
3418         }
3419 }
3420
3421 uint32_t
3422 MidiRegionView::get_fill_color() const
3423 {
3424         const std::string mod_name = (_dragging ? "dragging region" :
3425                                       trackview.editor().internal_editing() ? "editable region" :
3426                                       "midi frame base");
3427         if (_selected) {
3428                 return UIConfiguration::instance().color_mod ("selected region base", mod_name);
3429         } else if ((!UIConfiguration::instance().get_show_name_highlight() || high_enough_for_name) &&
3430                    !UIConfiguration::instance().get_color_regions_using_track_color()) {
3431                 return UIConfiguration::instance().color_mod ("midi frame base", mod_name);
3432         }
3433         return UIConfiguration::instance().color_mod (fill_color, mod_name);
3434 }
3435
3436 void
3437 MidiRegionView::midi_channel_mode_changed ()
3438 {
3439         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3440         uint16_t mask = mtv->midi_track()->get_playback_channel_mask();
3441         ChannelMode mode = mtv->midi_track()->get_playback_channel_mode ();
3442
3443         if (mode == ForceChannel) {
3444                 mask = 0xFFFF; // Show all notes as active (below)
3445         }
3446
3447         // Update notes for selection
3448         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3449                 (*i)->on_channel_selection_change (mask);
3450         }
3451
3452         _patch_changes.clear ();
3453         display_patch_changes ();
3454 }
3455
3456 void
3457 MidiRegionView::instrument_settings_changed ()
3458 {
3459         redisplay_model();
3460 }
3461
3462 void
3463 MidiRegionView::cut_copy_clear (Editing::CutCopyOp op)
3464 {
3465         if (_selection.empty()) {
3466                 return;
3467         }
3468
3469         PublicEditor& editor (trackview.editor());
3470
3471         switch (op) {
3472         case Delete:
3473                 /* XXX what to do ? */
3474                 break;
3475         case Cut:
3476         case Copy:
3477                 editor.get_cut_buffer().add (selection_as_cut_buffer());
3478                 break;
3479         default:
3480                 break;
3481         }
3482
3483         if (op != Copy) {
3484
3485                 start_note_diff_command();
3486
3487                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3488                         switch (op) {
3489                         case Copy:
3490                                 break;
3491                         case Delete:
3492                         case Cut:
3493                         case Clear:
3494                                 note_diff_remove_note (*i);
3495                                 break;
3496                         }
3497                 }
3498
3499                 apply_diff();
3500         }
3501 }
3502
3503 MidiCutBuffer*
3504 MidiRegionView::selection_as_cut_buffer () const
3505 {
3506         Notes notes;
3507
3508         for (Selection::const_iterator i = _selection.begin(); i != _selection.end(); ++i) {
3509                 NoteType* n = (*i)->note().get();
3510                 notes.insert (boost::shared_ptr<NoteType> (new NoteType (*n)));
3511         }
3512
3513         MidiCutBuffer* cb = new MidiCutBuffer (trackview.session());
3514         cb->set (notes);
3515
3516         return cb;
3517 }
3518
3519 /** This method handles undo */
3520 bool
3521 MidiRegionView::paste (framepos_t pos, const ::Selection& selection, PasteContext& ctx, const int32_t sub_num)
3522 {
3523         bool commit = false;
3524         // Paste notes, if available
3525         MidiNoteSelection::const_iterator m = selection.midi_notes.get_nth(ctx.counts.n_notes());
3526         if (m != selection.midi_notes.end()) {
3527                 ctx.counts.increase_n_notes();
3528                 if (!(*m)->empty()) {
3529                         commit = true;
3530                 }
3531                 paste_internal(pos, ctx.count, ctx.times, **m);
3532         }
3533
3534         // Paste control points to automation children, if available
3535         typedef RouteTimeAxisView::AutomationTracks ATracks;
3536         const ATracks& atracks = midi_view()->automation_tracks();
3537         for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
3538                 if (a->second->paste(pos, selection, ctx, sub_num)) {
3539                         if(!commit) {
3540                                 trackview.editor().begin_reversible_command (Operations::paste);
3541                         }
3542                         commit = true;
3543                 }
3544         }
3545
3546         if (commit) {
3547                 trackview.editor().commit_reversible_command ();
3548         }
3549         return true;
3550 }
3551
3552 /** This method handles undo */
3553 void
3554 MidiRegionView::paste_internal (framepos_t pos, unsigned paste_count, float times, const MidiCutBuffer& mcb)
3555 {
3556         if (mcb.empty()) {
3557                 return;
3558         }
3559
3560         start_note_diff_command (_("paste"));
3561
3562         const Evoral::Beats snap_beats    = get_grid_beats(pos);
3563         const Evoral::Beats first_time    = (*mcb.notes().begin())->time();
3564         const Evoral::Beats last_time     = (*mcb.notes().rbegin())->end_time();
3565         const Evoral::Beats duration      = last_time - first_time;
3566         const Evoral::Beats snap_duration = duration.snap_to(snap_beats);
3567         const Evoral::Beats paste_offset  = snap_duration * paste_count;
3568         const Evoral::Beats pos_beats     = absolute_frames_to_source_beats(pos) + paste_offset;
3569         Evoral::Beats       end_point     = Evoral::Beats();
3570
3571         DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste data spans from %1 to %2 (%3) ; paste pos beats = %4 (based on %5 - %6)\n",
3572                                                        first_time,
3573                                                        last_time,
3574                                                        duration, pos, _region->position(),
3575                                                        pos_beats));
3576
3577         clear_editor_note_selection ();
3578
3579         for (int n = 0; n < (int) times; ++n) {
3580
3581                 for (Notes::const_iterator i = mcb.notes().begin(); i != mcb.notes().end(); ++i) {
3582
3583                         boost::shared_ptr<NoteType> copied_note (new NoteType (*((*i).get())));
3584                         copied_note->set_time (pos_beats + copied_note->time() - first_time);
3585                         copied_note->set_id (Evoral::next_event_id());
3586
3587                         /* make all newly added notes selected */
3588
3589                         note_diff_add_note (copied_note, true);
3590                         end_point = copied_note->end_time();
3591                 }
3592         }
3593
3594         /* if we pasted past the current end of the region, extend the region */
3595
3596         framepos_t end_frame = source_beats_to_absolute_frames (end_point);
3597         framepos_t region_end = _region->position() + _region->length() - 1;
3598
3599         if (end_frame > region_end) {
3600
3601                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste extended region from %1 to %2\n", region_end, end_frame));
3602
3603                 _region->clear_changes ();
3604                 /* we probably need to get the snap modifier somehow to make this correct for non-musical use */
3605                 _region->set_length (end_frame - _region->position(), trackview.editor().get_grid_music_divisions (0));
3606                 trackview.session()->add_command (new StatefulDiffCommand (_region));
3607         }
3608
3609         apply_diff (true);
3610 }
3611
3612 struct EventNoteTimeEarlyFirstComparator {
3613         bool operator() (NoteBase* a, NoteBase* b) {
3614                 return a->note()->time() < b->note()->time();
3615         }
3616 };
3617
3618 void
3619 MidiRegionView::time_sort_events ()
3620 {
3621         if (!_sort_needed) {
3622                 return;
3623         }
3624
3625         EventNoteTimeEarlyFirstComparator cmp;
3626         _events.sort (cmp);
3627
3628         _sort_needed = false;
3629 }
3630
3631 void
3632 MidiRegionView::goto_next_note (bool add_to_selection)
3633 {
3634         bool use_next = false;
3635
3636         if (_events.back()->selected()) {
3637                 return;
3638         }
3639
3640         time_sort_events ();
3641
3642         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3643         uint16_t const channel_mask = mtv->midi_track()->get_playback_channel_mask();
3644
3645         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3646                 if ((*i)->selected()) {
3647                         use_next = true;
3648                         continue;
3649                 } else if (use_next) {
3650                         if (channel_mask & (1 << (*i)->note()->channel())) {
3651                                 if (!add_to_selection) {
3652                                         unique_select (*i);
3653                                 } else {
3654                                         note_selected (*i, true, false);
3655                                 }
3656                                 return;
3657                         }
3658                 }
3659         }
3660
3661         /* use the first one */
3662
3663         if (!_events.empty() && (channel_mask & (1 << _events.front()->note()->channel ()))) {
3664                 unique_select (_events.front());
3665         }
3666 }
3667
3668 void
3669 MidiRegionView::goto_previous_note (bool add_to_selection)
3670 {
3671         bool use_next = false;
3672
3673         if (_events.front()->selected()) {
3674                 return;
3675         }
3676
3677         time_sort_events ();
3678
3679         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3680         uint16_t const channel_mask = mtv->midi_track()->get_playback_channel_mask ();
3681
3682         for (Events::reverse_iterator i = _events.rbegin(); i != _events.rend(); ++i) {
3683                 if ((*i)->selected()) {
3684                         use_next = true;
3685                         continue;
3686                 } else if (use_next) {
3687                         if (channel_mask & (1 << (*i)->note()->channel())) {
3688                                 if (!add_to_selection) {
3689                                         unique_select (*i);
3690                                 } else {
3691                                         note_selected (*i, true, false);
3692                                 }
3693                                 return;
3694                         }
3695                 }
3696         }
3697
3698         /* use the last one */
3699
3700         if (!_events.empty() && (channel_mask & (1 << (*_events.rbegin())->note()->channel ()))) {
3701                 unique_select (*(_events.rbegin()));
3702         }
3703 }
3704
3705 void
3706 MidiRegionView::selection_as_notelist (Notes& selected, bool allow_all_if_none_selected)
3707 {
3708         bool had_selected = false;
3709
3710         time_sort_events ();
3711
3712         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3713                 if ((*i)->selected()) {
3714                         selected.insert ((*i)->note());
3715                         had_selected = true;
3716                 }
3717         }
3718
3719         if (allow_all_if_none_selected && !had_selected) {
3720                 for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3721                         selected.insert ((*i)->note());
3722                 }
3723         }
3724 }
3725
3726 void
3727 MidiRegionView::update_ghost_note (double x, double y, uint32_t state)
3728 {
3729         x = std::max(0.0, x);
3730
3731         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3732
3733         _last_ghost_x = x;
3734         _last_ghost_y = y;
3735
3736         _note_group->canvas_to_item (x, y);
3737
3738         PublicEditor& editor = trackview.editor ();
3739
3740         framepos_t const unsnapped_frame = editor.pixel_to_sample (x);
3741
3742         const int32_t divisions = editor.get_grid_music_divisions (state);
3743         const double snapped_region_qn = snap_frame_to_grid_underneath (unsnapped_frame, divisions).to_double();
3744
3745         Evoral::Beats snapped_beats = Evoral::Beats (snapped_region_qn);
3746         /* calculate time in beats relative to start of source */
3747         const Evoral::Beats length = get_grid_beats(unsnapped_frame + _region->position());
3748
3749         _ghost_note->note()->set_time (snapped_beats);
3750         _ghost_note->note()->set_length (length);
3751         _ghost_note->note()->set_note (midi_stream_view()->y_to_note (y));
3752         _ghost_note->note()->set_channel (mtv->get_channel_for_add ());
3753         _ghost_note->note()->set_velocity (get_velocity_for_add (snapped_beats));
3754         /* the ghost note does not appear in ghost regions, so pass false in here */
3755         update_note (_ghost_note, false);
3756
3757         show_verbose_cursor (_ghost_note->note ());
3758 }
3759
3760 void
3761 MidiRegionView::create_ghost_note (double x, double y, uint32_t state)
3762 {
3763         remove_ghost_note ();
3764
3765         boost::shared_ptr<NoteType> g (new NoteType);
3766         if (midi_view()->note_mode() == Sustained) {
3767                 _ghost_note = new Note (*this, _note_group, g);
3768         } else {
3769                 _ghost_note = new Hit (*this, _note_group, 10, g);
3770         }
3771         _ghost_note->set_ignore_events (true);
3772         _ghost_note->set_outline_color (0x000000aa);
3773         update_ghost_note (x, y, state);
3774         _ghost_note->show ();
3775
3776         show_verbose_cursor (_ghost_note->note ());
3777 }
3778
3779 void
3780 MidiRegionView::remove_ghost_note ()
3781 {
3782         delete _ghost_note;
3783         _ghost_note = 0;
3784 }
3785
3786 void
3787 MidiRegionView::hide_verbose_cursor ()
3788 {
3789         trackview.editor().verbose_cursor()->hide ();
3790         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3791         if (mtv) {
3792                 mtv->set_note_highlight (NO_MIDI_NOTE);
3793         }
3794 }
3795
3796 void
3797 MidiRegionView::snap_changed ()
3798 {
3799         if (!_ghost_note) {
3800                 return;
3801         }
3802
3803         create_ghost_note (_last_ghost_x, _last_ghost_y, 0);
3804 }
3805
3806 void
3807 MidiRegionView::drop_down_keys ()
3808 {
3809         _mouse_state = None;
3810 }
3811
3812 void
3813 MidiRegionView::maybe_select_by_position (GdkEventButton* ev, double /*x*/, double y)
3814 {
3815         /* XXX: This is dead code.  What was it for? */
3816
3817         double note = midi_stream_view()->y_to_note(y);
3818         Events e;
3819         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3820
3821         uint16_t chn_mask = mtv->midi_track()->get_playback_channel_mask();
3822
3823         if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
3824                 get_events (e, Evoral::Sequence<Evoral::Beats>::PitchGreaterThanOrEqual, (uint8_t) floor (note), chn_mask);
3825         } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
3826                 get_events (e, Evoral::Sequence<Evoral::Beats>::PitchLessThanOrEqual, (uint8_t) floor (note), chn_mask);
3827         } else {
3828                 return;
3829         }
3830
3831         bool add_mrv_selection = false;
3832
3833         if (_selection.empty()) {
3834                 add_mrv_selection = true;
3835         }
3836
3837         for (Events::iterator i = e.begin(); i != e.end(); ++i) {
3838                 if (_selection.insert (*i).second) {
3839                         (*i)->set_selected (true);
3840                 }
3841         }
3842
3843         if (add_mrv_selection) {
3844                 PublicEditor& editor (trackview.editor());
3845                 editor.get_selection().add (this);
3846         }
3847 }
3848
3849 void
3850 MidiRegionView::color_handler ()
3851 {
3852         RegionView::color_handler ();
3853
3854         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3855                 (*i)->set_selected ((*i)->selected()); // will change color
3856         }
3857
3858         /* XXX probably more to do here */
3859 }
3860
3861 void
3862 MidiRegionView::enable_display (bool yn)
3863 {
3864         RegionView::enable_display (yn);
3865 }
3866
3867 void
3868 MidiRegionView::show_step_edit_cursor (Evoral::Beats pos)
3869 {
3870         if (_step_edit_cursor == 0) {
3871                 ArdourCanvas::Item* const group = get_canvas_group();
3872
3873                 _step_edit_cursor = new ArdourCanvas::Rectangle (group);
3874                 _step_edit_cursor->set_y0 (0);
3875                 _step_edit_cursor->set_y1 (midi_stream_view()->contents_height());
3876                 _step_edit_cursor->set_fill_color (RGBA_TO_UINT (45,0,0,90));
3877                 _step_edit_cursor->set_outline_color (RGBA_TO_UINT (85,0,0,90));
3878         }
3879
3880         move_step_edit_cursor (pos);
3881         _step_edit_cursor->show ();
3882 }
3883
3884 void
3885 MidiRegionView::move_step_edit_cursor (Evoral::Beats pos)
3886 {
3887         _step_edit_cursor_position = pos;
3888
3889         if (_step_edit_cursor) {
3890                 double pixel = trackview.editor().sample_to_pixel (region_beats_to_region_frames (pos));
3891                 _step_edit_cursor->set_x0 (pixel);
3892                 set_step_edit_cursor_width (_step_edit_cursor_width);
3893         }
3894 }
3895
3896 void
3897 MidiRegionView::hide_step_edit_cursor ()
3898 {
3899         if (_step_edit_cursor) {
3900                 _step_edit_cursor->hide ();
3901         }
3902 }
3903
3904 void
3905 MidiRegionView::set_step_edit_cursor_width (Evoral::Beats beats)
3906 {
3907         _step_edit_cursor_width = beats;
3908
3909         if (_step_edit_cursor) {
3910                 _step_edit_cursor->set_x1 (_step_edit_cursor->x0() + trackview.editor().sample_to_pixel (
3911                                                    region_beats_to_region_frames (_step_edit_cursor_position + beats)
3912                                                    - region_beats_to_region_frames (_step_edit_cursor_position)));
3913         }
3914 }
3915
3916 /** Called when a diskstream on our track has received some data.  Update the view, if applicable.
3917  *  @param w Source that the data will end up in.
3918  */
3919 void
3920 MidiRegionView::data_recorded (boost::weak_ptr<MidiSource> w)
3921 {
3922         if (!_active_notes) {
3923                 /* we aren't actively being recorded to */
3924                 return;
3925         }
3926
3927         boost::shared_ptr<MidiSource> src = w.lock ();
3928         if (!src || src != midi_region()->midi_source()) {
3929                 /* recorded data was not destined for our source */
3930                 return;
3931         }
3932
3933         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (&trackview);
3934
3935         boost::shared_ptr<MidiBuffer> buf = mtv->midi_track()->get_gui_feed_buffer ();
3936
3937         framepos_t back = max_framepos;
3938
3939         for (MidiBuffer::iterator i = buf->begin(); i != buf->end(); ++i) {
3940                 Evoral::MIDIEvent<MidiBuffer::TimeType> const ev (*i, false);
3941
3942                 if (ev.is_channel_event()) {
3943                         if (get_channel_mode() == FilterChannels) {
3944                                 if (((uint16_t(1) << ev.channel()) & get_selected_channels()) == 0) {
3945                                         continue;
3946                                 }
3947                         }
3948                 }
3949
3950                 /* convert from session frames to source beats */
3951                 Evoral::Beats const time_beats = _source_relative_time_converter.from(
3952                         ev.time() - src->timeline_position() + _region->start());
3953
3954                 if (ev.type() == MIDI_CMD_NOTE_ON) {
3955                         boost::shared_ptr<NoteType> note (
3956                                 new NoteType (ev.channel(), time_beats, Evoral::Beats(), ev.note(), ev.velocity()));
3957
3958                         add_note (note, true);
3959
3960                         /* fix up our note range */
3961                         if (ev.note() < _current_range_min) {
3962                                 midi_stream_view()->apply_note_range (ev.note(), _current_range_max, true);
3963                         } else if (ev.note() > _current_range_max) {
3964                                 midi_stream_view()->apply_note_range (_current_range_min, ev.note(), true);
3965                         }
3966
3967                 } else if (ev.type() == MIDI_CMD_NOTE_OFF) {
3968                         resolve_note (ev.note (), time_beats);
3969                 }
3970
3971                 back = ev.time ();
3972         }
3973
3974         midi_stream_view()->check_record_layers (region(), back);
3975 }
3976
3977 void
3978 MidiRegionView::trim_front_starting ()
3979 {
3980         /* We used to eparent the note group to the region view's parent, so that it didn't change.
3981            now we update it.
3982         */
3983 }
3984
3985 void
3986 MidiRegionView::trim_front_ending ()
3987 {
3988         if (_region->start() < 0) {
3989                 /* Trim drag made start time -ve; fix this */
3990                 midi_region()->fix_negative_start ();
3991         }
3992 }
3993
3994 void
3995 MidiRegionView::edit_patch_change (PatchChange* pc)
3996 {
3997         PatchChangeDialog d (&_source_relative_time_converter, trackview.session(), *pc->patch (), instrument_info(), Gtk::Stock::APPLY, true);
3998
3999         int response = d.run();
4000
4001         switch (response) {
4002         case Gtk::RESPONSE_ACCEPT:
4003                 break;
4004         case Gtk::RESPONSE_REJECT:
4005                 delete_patch_change (pc);
4006                 return;
4007         default:
4008                 return;
4009         }
4010
4011         change_patch_change (pc->patch(), d.patch ());
4012 }
4013
4014 void
4015 MidiRegionView::delete_sysex (SysEx* /*sysex*/)
4016 {
4017         // CAIROCANVAS
4018         // sysyex object doesn't have a pointer to a sysex event
4019         // MidiModel::SysExDiffCommand* c = _model->new_sysex_diff_command (_("delete sysex"));
4020         // c->remove (sysex->sysex());
4021         // _model->apply_command (*trackview.session(), c);
4022
4023         //_sys_exes.clear ();
4024         // display_sysexes();
4025 }
4026
4027 std::string
4028 MidiRegionView::get_note_name (boost::shared_ptr<NoteType> n, uint8_t note_value) const
4029 {
4030         using namespace MIDI::Name;
4031         std::string name;
4032
4033         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
4034         if (mtv) {
4035                 boost::shared_ptr<MasterDeviceNames> device_names(mtv->get_device_names());
4036                 if (device_names) {
4037                         MIDI::Name::PatchPrimaryKey patch_key;
4038                         get_patch_key_at(n->time(), n->channel(), patch_key);
4039                         name = device_names->note_name(mtv->gui_property(X_("midnam-custom-device-mode")),
4040                                                        n->channel(),
4041                                                        patch_key.bank(),
4042                                                        patch_key.program(),
4043                                                        note_value);
4044                 }
4045         }
4046
4047         char buf[128];
4048         snprintf (buf, sizeof (buf), "%d %s\nCh %d Vel %d",
4049                   (int) note_value,
4050                   name.empty() ? ParameterDescriptor::midi_note_name (note_value).c_str() : name.c_str(),
4051                   (int) n->channel() + 1,
4052                   (int) n->velocity());
4053
4054         return buf;
4055 }
4056
4057 void
4058 MidiRegionView::show_verbose_cursor_for_new_note_value(boost::shared_ptr<NoteType> current_note,
4059                                                        uint8_t new_value) const
4060 {
4061         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
4062         if (mtv) {
4063                 mtv->set_note_highlight (new_value);
4064         }
4065
4066         show_verbose_cursor(get_note_name(current_note, new_value), 10, 20);
4067 }
4068
4069 void
4070 MidiRegionView::show_verbose_cursor (boost::shared_ptr<NoteType> n) const
4071 {
4072         show_verbose_cursor_for_new_note_value(n, n->note());
4073 }
4074
4075 void
4076 MidiRegionView::show_verbose_cursor (string const & text, double xoffset, double yoffset) const
4077 {
4078         trackview.editor().verbose_cursor()->set (text);
4079         trackview.editor().verbose_cursor()->show ();
4080         trackview.editor().verbose_cursor()->set_offset (ArdourCanvas::Duple (xoffset, yoffset));
4081 }
4082
4083 uint8_t
4084 MidiRegionView::get_velocity_for_add (MidiModel::TimeType time) const
4085 {
4086         if (_model->notes().empty()) {
4087                 return 0x40;  // No notes, use default
4088         }
4089
4090         MidiModel::Notes::const_iterator m = _model->note_lower_bound(time);
4091         if (m == _model->notes().begin()) {
4092                 // Before the start, use the velocity of the first note
4093                 return (*m)->velocity();
4094         } else if (m == _model->notes().end()) {
4095                 // Past the end, use the velocity of the last note
4096                 --m;
4097                 return (*m)->velocity();
4098         }
4099
4100         // Interpolate velocity of surrounding notes
4101         MidiModel::Notes::const_iterator n = m;
4102         --n;
4103
4104         const double frac = ((time - (*n)->time()).to_double() /
4105                              ((*m)->time() - (*n)->time()).to_double());
4106
4107         return (*n)->velocity() + (frac * ((*m)->velocity() - (*n)->velocity()));
4108 }
4109
4110 /** @param p A session framepos.
4111  *  @param divisions beat division to snap given by Editor::get_grid_music_divisions() where
4112  *  bar is -1, 0 is audio samples and a positive integer is beat subdivisions.
4113  *  @return beat duration of p snapped to the grid subdivision underneath it.
4114  */
4115 Evoral::Beats
4116 MidiRegionView::snap_frame_to_grid_underneath (framepos_t p, int32_t divisions) const
4117 {
4118         TempoMap& map (trackview.session()->tempo_map());
4119
4120         const double qaf = map.quarter_note_at_frame (p + _region->position());
4121         double eqaf;
4122         if (divisions != 0) {
4123                 eqaf = map.exact_qn_at_frame (p + _region->position(), divisions);
4124                 /* Hack so that we always snap to the note that we are over, instead of snapping
4125                    to the next one if we're more than halfway through the one we're over.
4126                 */
4127                 const Evoral::Beats grid_beats = get_grid_beats (p + _region->position());
4128                 const double rem = fmod (qaf, grid_beats.to_double());
4129                 if (rem >= grid_beats.to_double() / 2.0) {
4130                         eqaf -= grid_beats.to_double();
4131                 }
4132         } else {
4133                 eqaf = qaf;
4134         }
4135
4136         return Evoral::Beats (eqaf - ((_region->pulse() - midi_region()->start_pulse()) * 4.0));
4137 }
4138
4139 ChannelMode
4140 MidiRegionView::get_channel_mode () const
4141 {
4142         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (&trackview);
4143         return rtav->midi_track()->get_playback_channel_mode();
4144 }
4145
4146 uint16_t
4147 MidiRegionView::get_selected_channels () const
4148 {
4149         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (&trackview);
4150         return rtav->midi_track()->get_playback_channel_mask();
4151 }
4152
4153
4154 Evoral::Beats
4155 MidiRegionView::get_grid_beats(framepos_t pos) const
4156 {
4157         PublicEditor& editor  = trackview.editor();
4158         bool          success = false;
4159         Evoral::Beats beats   = editor.get_grid_type_as_beats (success, pos);
4160         if (!success) {
4161                 beats = Evoral::Beats(1);
4162         }
4163         return beats;
4164 }