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