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