gtk2_ardour/midi_region_view.cc

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