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