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