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