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