gtk2_ardour/midi_region_view.cc

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