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