gtk2_ardour/midi_region_view.cc

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