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