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