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