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         , _note_entered (false)
 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         , _note_entered (false)
 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         , _note_entered (false)
 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         , _note_entered (false)
 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 _note_entered 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 (!_note_entered) {
 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         _note_entered = false;
 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                 _mouse_state = Pressed;
 501
 502                 return true;
 503         }
 504
 505         _pressed_button = ev->button;
 506         _mouse_changed_selection = false;
 507
 508         return true;
 509 }
 510
 511 bool
 512 MidiRegionView::button_release (GdkEventButton* ev)
 513 {
 514         double event_x, event_y;
 515
 516         if (ev->button != 1) {
 517                 return false;
 518         }
 519
 520         event_x = ev->x;
 521         event_y = ev->y;
 522
 523         group->canvas_to_item (event_x, event_y);
 524         group->ungrab ();
 525
 526         PublicEditor& editor = trackview.editor ();
 527
 528         _press_cursor_ctx.reset();
 529
 530         switch (_mouse_state) {
 531         case Pressed: // Clicked
 532
 533                 switch (editor.current_mouse_mode()) {
 534                 case MouseRange:
 535                         /* no motion occurred - simple click */
 536                         clear_editor_note_selection ();
 537                         _mouse_changed_selection = true;
 538                         break;
 539
 540                 case MouseContent:
 541                 case MouseTimeFX:
 542                         {
 543                                 _mouse_changed_selection = true;
 544
 545                                 if (Keyboard::is_insert_note_event(ev)) {
 546
 547                                         double event_x, event_y;
 548
 549                                         event_x = ev->x;
 550                                         event_y = ev->y;
 551                                         group->canvas_to_item (event_x, event_y);
 552
 553                                         Evoral::Beats beats = get_grid_beats(editor.pixel_to_sample(event_x) + _region->position());
 554                                         create_note_at (editor.pixel_to_sample (event_x), event_y, beats, ev->state, true);
 555                                 } else {
 556                                         clear_editor_note_selection ();
 557                                 }
 558
 559                                 break;
 560                         }
 561                 case MouseDraw:
 562                         {
 563                                 Evoral::Beats beats = get_grid_beats(editor.pixel_to_sample(event_x) + _region->position());
 564                                 create_note_at (editor.pixel_to_sample (event_x), event_y, beats, ev->state, true);
 565                                 break;
 566                         }
 567                 default:
 568                         break;
 569                 }
 570
 571                 _mouse_state = None;
 572                 break;
 573
 574         case AddDragging:
 575                 /* Only create a ghost note when we added a note, not when we were drag-selecting. */
 576                 create_ghost_note (ev->x, ev->y, ev->state);
 577         case SelectRectDragging:
 578                 editor.drags()->end_grab ((GdkEvent *) ev);
 579                 _mouse_state = None;
 580                 break;
 581
 582
 583         default:
 584                 break;
 585         }
 586
 587         if (_mouse_changed_selection) {
 588                 trackview.editor().begin_reversible_selection_op (X_("Mouse Selection Change"));
 589                 trackview.editor().commit_reversible_selection_op ();
 590         }
 591
 592         return false;
 593 }
 594
 595 bool
 596 MidiRegionView::motion (GdkEventMotion* ev)
 597 {
 598         PublicEditor& editor = trackview.editor ();
 599
 600         if (!_note_entered) {
 601
 602                 if (!_ghost_note && editor.current_mouse_mode() == MouseContent &&
 603                     Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()) &&
 604                     _mouse_state != AddDragging) {
 605
 606                         create_ghost_note (ev->x, ev->y, ev->state);
 607
 608                 } else if (_ghost_note && editor.current_mouse_mode() == MouseContent &&
 609                            Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier())) {
 610
 611                         update_ghost_note (ev->x, ev->y, ev->state);
 612
 613                 } else if (_ghost_note && editor.current_mouse_mode() == MouseContent) {
 614
 615                         remove_ghost_note ();
 616                         hide_verbose_cursor ();
 617
 618                 } else if (editor.current_mouse_mode() == MouseDraw) {
 619
 620                         if (_ghost_note) {
 621                                 update_ghost_note (ev->x, ev->y, ev->state);
 622                         }
 623                         else {
 624                                 create_ghost_note (ev->x, ev->y, ev->state);
 625                         }
 626                 }
 627         }
 628
 629         /* any motion immediately hides velocity text that may have been visible */
 630
 631         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
 632                 (*i)->hide_velocity ();
 633         }
 634
 635         switch (_mouse_state) {
 636         case Pressed:
 637
 638                 if (_pressed_button == 1) {
 639
 640                         MouseMode m = editor.current_mouse_mode();
 641
 642                         if (m == MouseDraw || (m == MouseContent && Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()))) {
 643                                 editor.drags()->set (new NoteCreateDrag (dynamic_cast<Editor *> (&editor), group, this), (GdkEvent *) ev);
 644                                 _mouse_state = AddDragging;
 645                                 remove_ghost_note ();
 646                                 hide_verbose_cursor ();
 647                                 return true;
 648                         } else if (m == MouseContent) {
 649                                 editor.drags()->set (new MidiRubberbandSelectDrag (dynamic_cast<Editor *> (&editor), this), (GdkEvent *) ev);
 650                                 if (!Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 651                                         clear_editor_note_selection ();
 652                                         _mouse_changed_selection = true;
 653                                 }
 654                                 _mouse_state = SelectRectDragging;
 655                                 return true;
 656                         } else if (m == MouseRange) {
 657                                 editor.drags()->set (new MidiVerticalSelectDrag (dynamic_cast<Editor *> (&editor), this), (GdkEvent *) ev);
 658                                 _mouse_state = SelectVerticalDragging;
 659                                 return true;
 660                         }
 661                 }
 662
 663                 return false;
 664
 665         case SelectRectDragging:
 666         case SelectVerticalDragging:
 667         case AddDragging:
 668                 editor.drags()->motion_handler ((GdkEvent *) ev, false);
 669                 break;
 670
 671         case SelectTouchDragging:
 672                 return false;
 673
 674         default:
 675                 break;
 676
 677         }
 678
 679         /* we may be dragging some non-note object (eg. patch-change, sysex)
 680          */
 681
 682         return editor.drags()->motion_handler ((GdkEvent *) ev, false);
 683 }
 684
 685
 686 bool
 687 MidiRegionView::scroll (GdkEventScroll* ev)
 688 {
 689         if (_selection.empty()) {
 690                 return false;
 691         }
 692
 693         if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier) ||
 694             Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 695                 /* XXX: bit of a hack; allow PrimaryModifier and TertiaryModifier scroll
 696                  * through so that it still works for navigation.
 697                 */
 698                 return false;
 699         }
 700
 701         hide_verbose_cursor ();
 702
 703         bool fine = !Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
 704         Keyboard::ModifierMask mask_together(Keyboard::PrimaryModifier|Keyboard::TertiaryModifier);
 705         bool together = Keyboard::modifier_state_contains (ev->state, mask_together);
 706
 707         if (ev->direction == GDK_SCROLL_UP) {
 708                 change_velocities (true, fine, false, together);
 709         } else if (ev->direction == GDK_SCROLL_DOWN) {
 710                 change_velocities (false, fine, false, together);
 711         } else {
 712                 /* left, right: we don't use them */
 713                 return false;
 714         }
 715
 716         return true;
 717 }
 718
 719 bool
 720 MidiRegionView::key_press (GdkEventKey* ev)
 721 {
 722         /* since GTK bindings are generally activated on press, and since
 723            detectable auto-repeat is the name of the game and only sends
 724            repeated presses, carry out key actions at key press, not release.
 725         */
 726
 727         bool unmodified = Keyboard::no_modifier_keys_pressed (ev);
 728
 729         if (unmodified && (ev->keyval == GDK_Alt_L || ev->keyval == GDK_Alt_R)) {
 730                 _mouse_state = SelectTouchDragging;
 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
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         for (Events::const_iterator i = _events.begin(); i != _events.end(); ++i) {
1484                 NoteBase* event = *i;
1485                 boost::shared_ptr<NoteType> note (event->note());
1486
1487                 if (note->note() < _current_range_min ||
1488                     note->note() > _current_range_max) {
1489                         event->hide();
1490                 } else {
1491                         event->show();
1492                 }
1493
1494                 if (Note* cnote = dynamic_cast<Note*>(event)) {
1495
1496                         const double y0 = 1. + floor (midi_stream_view()->note_to_y(note->note()));
1497                         const double y1 = y0 + std::max(1., floor(midi_stream_view()->note_height()) - 1.);
1498
1499                         if (y0 < 0 || y1 >= _height) {
1500                                 /* During DnD, the region uses the 'old/current'
1501                                  * midi_stream_view()'s range and its position/height calculation.
1502                                  *
1503                                  * Ideally DnD would decouple the midi_stream_view() for the
1504                                  * region(s) being dragged and set it to the target's range
1505                                  * (or in case of the drop-zone, FullRange).
1506                                  * but I don't see how this can be done without major rework.
1507                                  *
1508                                  * For now, just prevent visual bleeding of events in case
1509                                  * the target-track is smaller.
1510                                  */
1511                                 event->hide();
1512                                 continue;
1513                         }
1514                         cnote->set_y0 (y0);
1515                         cnote->set_y1 (y1);
1516
1517                 } else if (Hit* chit = dynamic_cast<Hit*>(event)) {
1518                         update_hit (chit);
1519                 }
1520         }
1521 }
1522
1523 GhostRegion*
1524 MidiRegionView::add_ghost (TimeAxisView& tv)
1525 {
1526         double unit_position = _region->position () / samples_per_pixel;
1527         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&tv);
1528         MidiGhostRegion* ghost;
1529
1530         if (mtv && mtv->midi_view()) {
1531                 /* if ghost is inserted into midi track, use a dedicated midi ghost canvas group
1532                    to allow having midi notes on top of note lines and waveforms.
1533                 */
1534                 ghost = new MidiGhostRegion (*this, *mtv->midi_view(), trackview, unit_position);
1535         } else {
1536                 ghost = new MidiGhostRegion (*this, tv, trackview, unit_position);
1537         }
1538
1539         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
1540                 ghost->add_note(*i);
1541         }
1542
1543         ghost->set_colors ();
1544         ghost->set_height ();
1545         ghost->set_duration (_region->length() / samples_per_pixel);
1546         ghosts.push_back (ghost);
1547
1548         return ghost;
1549 }
1550
1551
1552 /** Begin tracking note state for successive calls to add_event
1553  */
1554 void
1555 MidiRegionView::begin_write()
1556 {
1557         if (_active_notes) {
1558                 delete[] _active_notes;
1559         }
1560         _active_notes = new Note*[128];
1561         for (unsigned i = 0; i < 128; ++i) {
1562                 _active_notes[i] = 0;
1563         }
1564 }
1565
1566
1567 /** Destroy note state for add_event
1568  */
1569 void
1570 MidiRegionView::end_write()
1571 {
1572         delete[] _active_notes;
1573         _active_notes = 0;
1574         _marked_for_selection.clear();
1575         _marked_for_velocity.clear();
1576 }
1577
1578
1579 /** Resolve an active MIDI note (while recording).
1580  */
1581 void
1582 MidiRegionView::resolve_note(uint8_t note, Evoral::Beats end_time)
1583 {
1584         if (midi_view()->note_mode() != Sustained) {
1585                 return;
1586         }
1587
1588         if (_active_notes && _active_notes[note]) {
1589                 /* Set note length so update_note() works.  Note this is a local note
1590                    for recording, not from a model, so we can safely mess with it. */
1591                 _active_notes[note]->note()->set_length(
1592                         end_time - _active_notes[note]->note()->time());
1593
1594                 /* End time is relative to the region being recorded. */
1595                 const framepos_t end_time_frames = region_beats_to_region_frames(end_time);
1596
1597                 _active_notes[note]->set_x1 (trackview.editor().sample_to_pixel(end_time_frames));
1598                 _active_notes[note]->set_outline_all ();
1599                 _active_notes[note] = 0;
1600         }
1601 }
1602
1603
1604 /** Extend active notes to rightmost edge of region (if length is changed)
1605  */
1606 void
1607 MidiRegionView::extend_active_notes()
1608 {
1609         if (!_active_notes) {
1610                 return;
1611         }
1612
1613         for (unsigned i = 0; i < 128; ++i) {
1614                 if (_active_notes[i]) {
1615                         _active_notes[i]->set_x1(
1616                                 trackview.editor().sample_to_pixel(_region->length()));
1617                 }
1618         }
1619 }
1620
1621 void
1622 MidiRegionView::play_midi_note(boost::shared_ptr<NoteType> note)
1623 {
1624         if (_no_sound_notes || !UIConfiguration::instance().get_sound_midi_notes()) {
1625                 return;
1626         }
1627
1628         RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
1629
1630         if (!route_ui || !route_ui->midi_track()) {
1631                 return;
1632         }
1633
1634         NotePlayer* np = new NotePlayer (route_ui->midi_track ());
1635         np->add (note);
1636         np->play ();
1637
1638         /* NotePlayer deletes itself */
1639 }
1640
1641 void
1642 MidiRegionView::start_playing_midi_note(boost::shared_ptr<NoteType> note)
1643 {
1644         const std::vector< boost::shared_ptr<NoteType> > notes(1, note);
1645         start_playing_midi_chord(notes);
1646 }
1647
1648 void
1649 MidiRegionView::start_playing_midi_chord (vector<boost::shared_ptr<NoteType> > notes)
1650 {
1651         if (_no_sound_notes || !UIConfiguration::instance().get_sound_midi_notes()) {
1652                 return;
1653         }
1654
1655         RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
1656
1657         if (!route_ui || !route_ui->midi_track()) {
1658                 return;
1659         }
1660
1661         NotePlayer* player = new NotePlayer (route_ui->midi_track());
1662
1663         for (vector<boost::shared_ptr<NoteType> >::iterator n = notes.begin(); n != notes.end(); ++n) {
1664                 player->add (*n);
1665         }
1666
1667         player->play ();
1668 }
1669
1670
1671 bool
1672 MidiRegionView::note_in_region_range (const boost::shared_ptr<NoteType> note, bool& visible) const
1673 {
1674         const boost::shared_ptr<ARDOUR::MidiRegion> midi_reg = midi_region();
1675
1676         /* must compare double explicitly as Beats::operator< rounds to ppqn */
1677         const bool outside = (note->time().to_double() < midi_reg->start_beats() ||
1678                               note->time().to_double() > midi_reg->start_beats() + midi_reg->length_beats());
1679
1680         visible = (note->note() >= midi_stream_view()->lowest_note()) &&
1681                 (note->note() <= midi_stream_view()->highest_note());
1682
1683         return !outside;
1684 }
1685
1686 void
1687 MidiRegionView::update_note (NoteBase* note, bool update_ghost_regions)
1688 {
1689         Note* sus = NULL;
1690         Hit*  hit = NULL;
1691         if ((sus = dynamic_cast<Note*>(note))) {
1692                 update_sustained(sus, update_ghost_regions);
1693         } else if ((hit = dynamic_cast<Hit*>(note))) {
1694                 update_hit(hit, update_ghost_regions);
1695         }
1696 }
1697
1698 /** Update a canvas note's size from its model note.
1699  *  @param ev Canvas note to update.
1700  *  @param update_ghost_regions true to update the note in any ghost regions that we have, otherwise false.
1701  */
1702 void
1703 MidiRegionView::update_sustained (Note* ev, bool update_ghost_regions)
1704 {
1705         TempoMap& map (trackview.session()->tempo_map());
1706         const boost::shared_ptr<ARDOUR::MidiRegion> mr = midi_region();
1707         boost::shared_ptr<NoteType> note = ev->note();
1708
1709         const double session_source_start = (_region->pulse() * 4.0) - mr->start_beats();
1710         const framepos_t note_start_frames = map.frame_at_quarter_note (note->time().to_double() + session_source_start) - _region->position();
1711
1712         const double x0 = trackview.editor().sample_to_pixel (note_start_frames);
1713         double x1;
1714         const double y0 = 1 + floor(midi_stream_view()->note_to_y(note->note()));
1715         double y1;
1716
1717         /* trim note display to not overlap the end of its region */
1718         if (note->length() > 0) {
1719                 double note_end_time = note->end_time().to_double();
1720
1721                 if (note_end_time > mr->start_beats() + mr->length_beats()) {
1722                         note_end_time = mr->start_beats() + mr->length_beats();
1723                 }
1724
1725                 const framepos_t note_end_frames = map.frame_at_quarter_note (session_source_start + note_end_time) - _region->position();
1726
1727                 x1 = std::max(1., trackview.editor().sample_to_pixel (note_end_frames)) - 1;
1728         } else {
1729                 x1 = std::max(1., trackview.editor().sample_to_pixel (_region->length())) - 1;
1730         }
1731
1732         y1 = y0 + std::max(1., floor(midi_stream_view()->note_height()) - 1);
1733
1734         ev->set (ArdourCanvas::Rect (x0, y0, x1, y1));
1735
1736         if (!note->length()) {
1737                 if (_active_notes && note->note() < 128) {
1738                         Note* const old_rect = _active_notes[note->note()];
1739                         if (old_rect) {
1740                                 /* There is an active note on this key, so we have a stuck
1741                                    note.  Finish the old rectangle here. */
1742                                 old_rect->set_x1 (x1);
1743                                 old_rect->set_outline_all ();
1744                         }
1745                         _active_notes[note->note()] = ev;
1746                 }
1747                 /* outline all but right edge */
1748                 ev->set_outline_what (ArdourCanvas::Rectangle::What (
1749                                               ArdourCanvas::Rectangle::TOP|
1750                                               ArdourCanvas::Rectangle::LEFT|
1751                                               ArdourCanvas::Rectangle::BOTTOM));
1752         } else {
1753                 /* outline all edges */
1754                 ev->set_outline_all ();
1755         }
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_note (ev);
1767                         }
1768                 }
1769         }
1770 }
1771
1772 void
1773 MidiRegionView::update_hit (Hit* ev, bool update_ghost_regions)
1774 {
1775         boost::shared_ptr<NoteType> note = ev->note();
1776
1777         const double note_time_qn = note->time().to_double() + ((_region->pulse() * 4.0) - midi_region()->start_beats());
1778         const framepos_t note_start_frames = trackview.session()->tempo_map().frame_at_quarter_note (note_time_qn) - _region->position();
1779
1780         const double x = trackview.editor().sample_to_pixel(note_start_frames);
1781         const double diamond_size = std::max(1., floor(midi_stream_view()->note_height()) - 2.);
1782         const double y = 1.5 + floor(midi_stream_view()->note_to_y(note->note())) + diamond_size * .5;
1783
1784         // see DnD note in MidiRegionView::apply_note_range() above
1785         if (y <= 0 || y >= _height) {
1786                 ev->hide();
1787         } else {
1788                 ev->show();
1789         }
1790
1791         ev->set_position (ArdourCanvas::Duple (x, y));
1792         ev->set_height (diamond_size);
1793
1794         // Update color in case velocity has changed
1795         const uint32_t base_col = ev->base_color();
1796         ev->set_fill_color(base_col);
1797         ev->set_outline_color(ev->calculate_outline(base_col, ev->selected()));
1798
1799         if (update_ghost_regions) {
1800                 for (std::vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
1801                         MidiGhostRegion* gr = dynamic_cast<MidiGhostRegion*> (*i);
1802                         if (gr) {
1803                                 gr->update_hit (ev);
1804                         }
1805                 }
1806         }
1807 }
1808
1809 /** Add a MIDI note to the view (with length).
1810  *
1811  * If in sustained mode, notes with length 0 will be considered active
1812  * notes, and resolve_note should be called when the corresponding note off
1813  * event arrives, to properly display the note.
1814  */
1815 NoteBase*
1816 MidiRegionView::add_note(const boost::shared_ptr<NoteType> note, bool visible)
1817 {
1818         NoteBase* event = 0;
1819
1820         if (midi_view()->note_mode() == Sustained) {
1821
1822                 Note* ev_rect = new Note (*this, _note_group, note);
1823
1824                 update_sustained (ev_rect);
1825
1826                 event = ev_rect;
1827
1828         } else if (midi_view()->note_mode() == Percussive) {
1829
1830                 const double diamond_size = std::max(1., floor(midi_stream_view()->note_height()) - 2.);
1831
1832                 Hit* ev_diamond = new Hit (*this, _note_group, diamond_size, note);
1833
1834                 update_hit (ev_diamond);
1835
1836                 event = ev_diamond;
1837
1838         } else {
1839                 event = 0;
1840         }
1841
1842         if (event) {
1843                 MidiGhostRegion* gr;
1844
1845                 for (std::vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
1846                         if ((gr = dynamic_cast<MidiGhostRegion*>(*g)) != 0) {
1847                                 gr->add_note(event);
1848                         }
1849                 }
1850
1851                 if (_marked_for_selection.find(note) != _marked_for_selection.end()) {
1852                         note_selected(event, true);
1853                 }
1854
1855                 if (_marked_for_velocity.find(note) != _marked_for_velocity.end()) {
1856                         event->show_velocity();
1857                 }
1858
1859                 event->on_channel_selection_change (get_selected_channels());
1860                 _events.push_back(event);
1861
1862                 if (visible) {
1863                         event->show();
1864                 } else {
1865                         event->hide ();
1866                 }
1867         }
1868
1869         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
1870         MidiStreamView* const view = mtv->midi_view();
1871
1872         view->update_note_range (note->note());
1873         return event;
1874 }
1875
1876 void
1877 MidiRegionView::step_add_note (uint8_t channel, uint8_t number, uint8_t velocity,
1878                                Evoral::Beats pos, Evoral::Beats len)
1879 {
1880         boost::shared_ptr<NoteType> new_note (new NoteType (channel, pos, len, number, velocity));
1881
1882         /* potentially extend region to hold new note */
1883
1884         framepos_t end_frame = source_beats_to_absolute_frames (new_note->end_time());
1885         framepos_t region_end = _region->last_frame();
1886
1887         if (end_frame > region_end) {
1888                 /* XX sets length in beats from audio space. make musical */
1889                 _region->set_length (end_frame - _region->position(), 0);
1890         }
1891
1892         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
1893         MidiStreamView* const view = mtv->midi_view();
1894
1895         view->update_note_range(new_note->note());
1896
1897         _marked_for_selection.clear ();
1898
1899         start_note_diff_command (_("step add"));
1900
1901         clear_editor_note_selection ();
1902         note_diff_add_note (new_note, true, false);
1903
1904         apply_diff();
1905
1906         // last_step_edit_note = new_note;
1907 }
1908
1909 void
1910 MidiRegionView::step_sustain (Evoral::Beats beats)
1911 {
1912         change_note_lengths (false, false, beats, false, true);
1913 }
1914
1915 /** Add a new patch change flag to the canvas.
1916  * @param patch the patch change to add
1917  * @param the text to display in the flag
1918  * @param active_channel true to display the flag as on an active channel, false to grey it out for an inactive channel.
1919  */
1920 void
1921 MidiRegionView::add_canvas_patch_change (MidiModel::PatchChangePtr patch, const string& displaytext, bool /*active_channel*/)
1922 {
1923         framecnt_t region_frames = source_beats_to_region_frames (patch->time());
1924         const double x = trackview.editor().sample_to_pixel (region_frames);
1925
1926         double const height = midi_stream_view()->contents_height();
1927
1928         // CAIROCANVAS: active_channel info removed from PatcChange constructor
1929         // so we need to do something more sophisticated to keep its color
1930         // appearance (MidiPatchChangeFill/MidiPatchChangeInactiveChannelFill)
1931         // up to date.
1932
1933         boost::shared_ptr<PatchChange> patch_change = boost::shared_ptr<PatchChange>(
1934                 new PatchChange(*this, group,
1935                                 displaytext,
1936                                 height,
1937                                 x, 1.0,
1938                                 instrument_info(),
1939                                 patch));
1940
1941         if (patch_change->item().width() < _pixel_width) {
1942                 // Show unless patch change is beyond the region bounds
1943                 if (region_frames < 0 || region_frames >= _region->length()) {
1944                         patch_change->hide();
1945                 } else {
1946                         patch_change->show();
1947                 }
1948         } else {
1949                 patch_change->hide ();
1950         }
1951
1952         _patch_changes.push_back (patch_change);
1953 }
1954
1955 MIDI::Name::PatchPrimaryKey
1956 MidiRegionView::patch_change_to_patch_key (MidiModel::PatchChangePtr p)
1957 {
1958         return MIDI::Name::PatchPrimaryKey (p->program(), p->bank());
1959 }
1960
1961 /// Return true iff @p pc applies to the given time on the given channel.
1962 static bool
1963 patch_applies (const ARDOUR::MidiModel::constPatchChangePtr pc, Evoral::Beats time, uint8_t channel)
1964 {
1965         return pc->time() <= time && pc->channel() == channel;
1966 }
1967
1968 void
1969 MidiRegionView::get_patch_key_at (Evoral::Beats time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const
1970 {
1971         // The earliest event not before time
1972         MidiModel::PatchChanges::iterator i = _model->patch_change_lower_bound (time);
1973
1974         // Go backwards until we find the latest PC for this channel, or the start
1975         while (i != _model->patch_changes().begin() &&
1976                (i == _model->patch_changes().end() ||
1977                 !patch_applies(*i, time, channel))) {
1978                 --i;
1979         }
1980
1981         if (i != _model->patch_changes().end() && patch_applies(*i, time, channel)) {
1982                 key.set_bank((*i)->bank());
1983                 key.set_program((*i)->program ());
1984         } else {
1985                 key.set_bank(0);
1986                 key.set_program(0);
1987         }
1988 }
1989
1990 void
1991 MidiRegionView::change_patch_change (PatchChange& pc, const MIDI::Name::PatchPrimaryKey& new_patch)
1992 {
1993         string name = _("alter patch change");
1994         trackview.editor().begin_reversible_command (name);
1995         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (name);
1996
1997         if (pc.patch()->program() != new_patch.program()) {
1998                 c->change_program (pc.patch (), new_patch.program());
1999         }
2000
2001         int const new_bank = new_patch.bank();
2002         if (pc.patch()->bank() != new_bank) {
2003                 c->change_bank (pc.patch (), new_bank);
2004         }
2005
2006         _model->apply_command (*trackview.session(), c);
2007         trackview.editor().commit_reversible_command ();
2008
2009         _patch_changes.clear ();
2010         display_patch_changes ();
2011 }
2012
2013 void
2014 MidiRegionView::change_patch_change (MidiModel::PatchChangePtr old_change, const Evoral::PatchChange<Evoral::Beats> & new_change)
2015 {
2016         string name = _("alter patch change");
2017         trackview.editor().begin_reversible_command (name);
2018         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (name);
2019
2020         if (old_change->time() != new_change.time()) {
2021                 c->change_time (old_change, new_change.time());
2022         }
2023
2024         if (old_change->channel() != new_change.channel()) {
2025                 c->change_channel (old_change, new_change.channel());
2026         }
2027
2028         if (old_change->program() != new_change.program()) {
2029                 c->change_program (old_change, new_change.program());
2030         }
2031
2032         if (old_change->bank() != new_change.bank()) {
2033                 c->change_bank (old_change, new_change.bank());
2034         }
2035
2036         _model->apply_command (*trackview.session(), c);
2037         trackview.editor().commit_reversible_command ();
2038
2039         _patch_changes.clear ();
2040         display_patch_changes ();
2041 }
2042
2043 /** Add a patch change to the region.
2044  *  @param t Time in frames relative to region position
2045  *  @param patch Patch to add; time and channel are ignored (time is converted from t, and channel comes from
2046  *  MidiTimeAxisView::get_channel_for_add())
2047  */
2048 void
2049 MidiRegionView::add_patch_change (framecnt_t t, Evoral::PatchChange<Evoral::Beats> const & patch)
2050 {
2051         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
2052         string name = _("add patch change");
2053
2054         trackview.editor().begin_reversible_command (name);
2055         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (name);
2056         c->add (MidiModel::PatchChangePtr (
2057                         new Evoral::PatchChange<Evoral::Beats> (
2058                                 absolute_frames_to_source_beats (_region->position() + t),
2059                                 mtv->get_channel_for_add(), patch.program(), patch.bank()
2060                                 )
2061                         )
2062                 );
2063
2064         _model->apply_command (*trackview.session(), c);
2065         trackview.editor().commit_reversible_command ();
2066
2067         _patch_changes.clear ();
2068         display_patch_changes ();
2069 }
2070
2071 void
2072 MidiRegionView::move_patch_change (PatchChange& pc, Evoral::Beats t)
2073 {
2074         trackview.editor().begin_reversible_command (_("move patch change"));
2075         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("move patch change"));
2076         c->change_time (pc.patch (), t);
2077         _model->apply_command (*trackview.session(), c);
2078         trackview.editor().commit_reversible_command ();
2079
2080         _patch_changes.clear ();
2081         display_patch_changes ();
2082 }
2083
2084 void
2085 MidiRegionView::delete_patch_change (PatchChange* pc)
2086 {
2087         trackview.editor().begin_reversible_command (_("delete patch change"));
2088         MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("delete patch change"));
2089         c->remove (pc->patch ());
2090         _model->apply_command (*trackview.session(), c);
2091         trackview.editor().commit_reversible_command ();
2092
2093         _patch_changes.clear ();
2094         display_patch_changes ();
2095 }
2096
2097 void
2098 MidiRegionView::step_patch (PatchChange& patch, bool bank, int delta)
2099 {
2100         MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key(patch.patch());
2101         if (bank) {
2102                 key.set_bank(key.bank() + delta);
2103         } else {
2104                 key.set_program(key.program() + delta);
2105         }
2106         change_patch_change(patch, key);
2107 }
2108
2109 void
2110 MidiRegionView::note_deleted (NoteBase* cne)
2111 {
2112         if (_selection.empty()) {
2113                 return;
2114         }
2115
2116         _selection.erase (cne);
2117 }
2118
2119 void
2120 MidiRegionView::delete_selection()
2121 {
2122         if (_selection.empty()) {
2123                 return;
2124         }
2125
2126         if (trackview.editor().drags()->active()) {
2127                 return;
2128         }
2129
2130         start_note_diff_command (_("delete selection"));
2131
2132         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2133                 if ((*i)->selected()) {
2134                         _note_diff_command->remove((*i)->note());
2135                 }
2136         }
2137
2138         _selection.clear();
2139
2140         apply_diff ();
2141         hide_verbose_cursor ();
2142 }
2143
2144 void
2145 MidiRegionView::delete_note (boost::shared_ptr<NoteType> n)
2146 {
2147         start_note_diff_command (_("delete note"));
2148         _note_diff_command->remove (n);
2149         apply_diff ();
2150
2151         hide_verbose_cursor ();
2152 }
2153
2154 void
2155 MidiRegionView::clear_editor_note_selection ()
2156 {
2157         DEBUG_TRACE(DEBUG::Selection, "MRV::clear_editor_note_selection\n");
2158         PublicEditor& editor(trackview.editor());
2159         editor.get_selection().clear_midi_notes();
2160 }
2161
2162 void
2163 MidiRegionView::clear_selection ()
2164 {
2165         clear_selection_internal();
2166         PublicEditor& editor(trackview.editor());
2167         editor.get_selection().remove(this);
2168 }
2169
2170 void
2171 MidiRegionView::clear_selection_internal ()
2172 {
2173         DEBUG_TRACE(DEBUG::Selection, "MRV::clear_selection_internal\n");
2174
2175         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2176                 (*i)->set_selected(false);
2177                 (*i)->hide_velocity();
2178         }
2179         _selection.clear();
2180
2181         if (_entered) {
2182                 // Clearing selection entirely, ungrab keyboard
2183                 Keyboard::magic_widget_drop_focus();
2184                 _grabbed_keyboard = false;
2185         }
2186 }
2187
2188 void
2189 MidiRegionView::unique_select(NoteBase* ev)
2190 {
2191         clear_editor_note_selection();
2192         add_to_selection(ev);
2193 }
2194
2195 void
2196 MidiRegionView::select_all_notes ()
2197 {
2198         clear_editor_note_selection ();
2199
2200         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2201                 add_to_selection (*i);
2202         }
2203 }
2204
2205 void
2206 MidiRegionView::select_range (framepos_t start, framepos_t end)
2207 {
2208         clear_editor_note_selection ();
2209
2210         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2211                 framepos_t t = source_beats_to_absolute_frames((*i)->note()->time());
2212                 if (t >= start && t <= end) {
2213                         add_to_selection (*i);
2214                 }
2215         }
2216 }
2217
2218 void
2219 MidiRegionView::invert_selection ()
2220 {
2221         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2222                 if ((*i)->selected()) {
2223                         remove_from_selection(*i);
2224                 } else {
2225                         add_to_selection (*i);
2226                 }
2227         }
2228 }
2229
2230 /** Used for selection undo/redo.
2231     The requested notes most likely won't exist in the view until the next model redisplay.
2232 */
2233 void
2234 MidiRegionView::select_notes (list<Evoral::event_id_t> notes)
2235 {
2236         NoteBase* cne;
2237         list<Evoral::event_id_t>::iterator n;
2238
2239         for (n = notes.begin(); n != notes.end(); ++n) {
2240                 if ((cne = find_canvas_note(*n)) != 0) {
2241                         add_to_selection (cne);
2242                 } else {
2243                         _pending_note_selection.insert(*n);
2244                 }
2245         }
2246 }
2247
2248 void
2249 MidiRegionView::select_matching_notes (uint8_t notenum, uint16_t channel_mask, bool add, bool extend)
2250 {
2251         bool have_selection = !_selection.empty();
2252         uint8_t low_note = 127;
2253         uint8_t high_note = 0;
2254         MidiModel::Notes& notes (_model->notes());
2255         _optimization_iterator = _events.begin();
2256
2257         if (extend && !have_selection) {
2258                 extend = false;
2259         }
2260
2261         /* scan existing selection to get note range */
2262
2263         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2264                 if ((*i)->note()->note() < low_note) {
2265                         low_note = (*i)->note()->note();
2266                 }
2267                 if ((*i)->note()->note() > high_note) {
2268                         high_note = (*i)->note()->note();
2269                 }
2270         }
2271
2272         if (!add) {
2273                 clear_editor_note_selection ();
2274
2275                 if (!extend && (low_note == high_note) && (high_note == notenum)) {
2276                         /* only note previously selected is the one we are
2277                          * reselecting. treat this as cancelling the selection.
2278                          */
2279                         return;
2280                 }
2281         }
2282
2283         if (extend) {
2284                 low_note = min (low_note, notenum);
2285                 high_note = max (high_note, notenum);
2286         }
2287
2288         _no_sound_notes = true;
2289
2290         for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
2291
2292                 boost::shared_ptr<NoteType> note (*n);
2293                 NoteBase* cne;
2294                 bool select = false;
2295
2296                 if (((1 << note->channel()) & channel_mask) != 0) {
2297                         if (extend) {
2298                                 if ((note->note() >= low_note && note->note() <= high_note)) {
2299                                         select = true;
2300                                 }
2301                         } else if (note->note() == notenum) {
2302                                 select = true;
2303                         }
2304                 }
2305
2306                 if (select) {
2307                         if ((cne = find_canvas_note (note)) != 0) {
2308                                 // extend is false because we've taken care of it,
2309                                 // since it extends by time range, not pitch.
2310                                 note_selected (cne, add, false);
2311                         }
2312                 }
2313
2314                 add = true; // we need to add all remaining matching notes, even if the passed in value was false (for "set")
2315
2316         }
2317
2318         _no_sound_notes = false;
2319 }
2320
2321 void
2322 MidiRegionView::toggle_matching_notes (uint8_t notenum, uint16_t channel_mask)
2323 {
2324         MidiModel::Notes& notes (_model->notes());
2325         _optimization_iterator = _events.begin();
2326
2327         for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
2328
2329                 boost::shared_ptr<NoteType> note (*n);
2330                 NoteBase* cne;
2331
2332                 if (note->note() == notenum && (((0x0001 << note->channel()) & channel_mask) != 0)) {
2333                         if ((cne = find_canvas_note (note)) != 0) {
2334                                 if (cne->selected()) {
2335                                         note_deselected (cne);
2336                                 } else {
2337                                         note_selected (cne, true, false);
2338                                 }
2339                         }
2340                 }
2341         }
2342 }
2343
2344 void
2345 MidiRegionView::note_selected (NoteBase* ev, bool add, bool extend)
2346 {
2347         if (!add) {
2348                 clear_editor_note_selection();
2349                 add_to_selection (ev);
2350         }
2351
2352         if (!extend) {
2353
2354                 if (!ev->selected()) {
2355                         add_to_selection (ev);
2356                 }
2357
2358         } else {
2359                 /* find end of latest note selected, select all between that and the start of "ev" */
2360
2361                 Evoral::Beats earliest = Evoral::MaxBeats;
2362                 Evoral::Beats latest   = Evoral::Beats();
2363
2364                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2365                         if ((*i)->note()->end_time() > latest) {
2366                                 latest = (*i)->note()->end_time();
2367                         }
2368                         if ((*i)->note()->time() < earliest) {
2369                                 earliest = (*i)->note()->time();
2370                         }
2371                 }
2372
2373                 if (ev->note()->end_time() > latest) {
2374                         latest = ev->note()->end_time();
2375                 }
2376
2377                 if (ev->note()->time() < earliest) {
2378                         earliest = ev->note()->time();
2379                 }
2380
2381                 for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2382
2383                         /* find notes entirely within OR spanning the earliest..latest range */
2384
2385                         if (((*i)->note()->time() >= earliest && (*i)->note()->end_time() <= latest) ||
2386                             ((*i)->note()->time() <= earliest && (*i)->note()->end_time() >= latest)) {
2387                                 add_to_selection (*i);
2388                         }
2389
2390                 }
2391         }
2392 }
2393
2394 void
2395 MidiRegionView::note_deselected(NoteBase* ev)
2396 {
2397         remove_from_selection (ev);
2398 }
2399
2400 void
2401 MidiRegionView::update_drag_selection(framepos_t start, framepos_t end, double gy0, double gy1, bool extend)
2402 {
2403         PublicEditor& editor = trackview.editor();
2404
2405         // Convert to local coordinates
2406         const framepos_t p  = _region->position();
2407         const double     y  = midi_view()->y_position();
2408         const double     x0 = editor.sample_to_pixel(max((framepos_t)0, start - p));
2409         const double     x1 = editor.sample_to_pixel(max((framepos_t)0, end - p));
2410         const double     y0 = max(0.0, gy0 - y);
2411         const double     y1 = max(0.0, gy1 - y);
2412
2413         // TODO: Make this faster by storing the last updated selection rect, and only
2414         // adjusting things that are in the area that appears/disappeared.
2415         // We probably need a tree to be able to find events in O(log(n)) time.
2416
2417         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2418                 if ((*i)->x0() < x1 && (*i)->x1() > x0 && (*i)->y0() < y1 && (*i)->y1() > y0) {
2419                         // Rectangles intersect
2420                         if (!(*i)->selected()) {
2421                                 add_to_selection (*i);
2422                         }
2423                 } else if ((*i)->selected() && !extend) {
2424                         // Rectangles do not intersect
2425                         remove_from_selection (*i);
2426                 }
2427         }
2428
2429         typedef RouteTimeAxisView::AutomationTracks ATracks;
2430         typedef std::list<Selectable*>              Selectables;
2431
2432         /* Add control points to selection. */
2433         const ATracks& atracks = midi_view()->automation_tracks();
2434         Selectables    selectables;
2435         editor.get_selection().clear_points();
2436         for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
2437                 a->second->get_selectables(start, end, gy0, gy1, selectables);
2438                 for (Selectables::const_iterator s = selectables.begin(); s != selectables.end(); ++s) {
2439                         ControlPoint* cp = dynamic_cast<ControlPoint*>(*s);
2440                         if (cp) {
2441                                 editor.get_selection().add(cp);
2442                         }
2443                 }
2444                 a->second->set_selected_points(editor.get_selection().points);
2445         }
2446 }
2447
2448 void
2449 MidiRegionView::update_vertical_drag_selection (double y1, double y2, bool extend)
2450 {
2451         if (y1 > y2) {
2452                 swap (y1, y2);
2453         }
2454
2455         // TODO: Make this faster by storing the last updated selection rect, and only
2456         // adjusting things that are in the area that appears/disappeared.
2457         // We probably need a tree to be able to find events in O(log(n)) time.
2458
2459         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
2460                 if (((*i)->y1() >= y1 && (*i)->y1() <= y2)) {
2461                         // within y- (note-) range
2462                         if (!(*i)->selected()) {
2463                                 add_to_selection (*i);
2464                         }
2465                 } else if ((*i)->selected() && !extend) {
2466                         remove_from_selection (*i);
2467                 }
2468         }
2469 }
2470
2471 void
2472 MidiRegionView::remove_from_selection (NoteBase* ev)
2473 {
2474         Selection::iterator i = _selection.find (ev);
2475
2476         if (i != _selection.end()) {
2477                 _selection.erase (i);
2478                 if (_selection.empty() && _grabbed_keyboard) {
2479                         // Ungrab keyboard
2480                         Keyboard::magic_widget_drop_focus();
2481                         _grabbed_keyboard = false;
2482                 }
2483         }
2484
2485         ev->set_selected (false);
2486         ev->hide_velocity ();
2487
2488         if (_selection.empty()) {
2489                 PublicEditor& editor (trackview.editor());
2490                 editor.get_selection().remove (this);
2491         }
2492 }
2493
2494 void
2495 MidiRegionView::add_to_selection (NoteBase* ev)
2496 {
2497         const bool selection_was_empty = _selection.empty();
2498
2499         if (_selection.insert (ev).second) {
2500                 ev->set_selected (true);
2501                 start_playing_midi_note ((ev)->note());
2502                 if (selection_was_empty && _entered) {
2503                         // Grab keyboard for moving notes with arrow keys
2504                         Keyboard::magic_widget_grab_focus();
2505                         _grabbed_keyboard = true;
2506                 }
2507         }
2508
2509         if (selection_was_empty) {
2510                 PublicEditor& editor (trackview.editor());
2511                 editor.get_selection().add (this);
2512         }
2513 }
2514
2515 void
2516 MidiRegionView::move_selection(double dx, double dy, double cumulative_dy)
2517 {
2518         typedef vector<boost::shared_ptr<NoteType> > PossibleChord;
2519         PossibleChord to_play;
2520         Evoral::Beats earliest = Evoral::MaxBeats;
2521
2522         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2523                 if ((*i)->note()->time() < earliest) {
2524                         earliest = (*i)->note()->time();
2525                 }
2526         }
2527
2528         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2529                 if ((*i)->note()->time() == earliest) {
2530                         to_play.push_back ((*i)->note());
2531                 }
2532                 (*i)->move_event(dx, dy);
2533         }
2534
2535         if (dy && !_selection.empty() && !_no_sound_notes && UIConfiguration::instance().get_sound_midi_notes()) {
2536
2537                 if (to_play.size() > 1) {
2538
2539                         PossibleChord shifted;
2540
2541                         for (PossibleChord::iterator n = to_play.begin(); n != to_play.end(); ++n) {
2542                                 boost::shared_ptr<NoteType> moved_note (new NoteType (**n));
2543                                 moved_note->set_note (moved_note->note() + cumulative_dy);
2544                                 shifted.push_back (moved_note);
2545                         }
2546
2547                         start_playing_midi_chord (shifted);
2548
2549                 } else if (!to_play.empty()) {
2550
2551                         boost::shared_ptr<NoteType> moved_note (new NoteType (*to_play.front()));
2552                         moved_note->set_note (moved_note->note() + cumulative_dy);
2553                         start_playing_midi_note (moved_note);
2554                 }
2555         }
2556 }
2557
2558 void
2559 MidiRegionView::note_dropped(NoteBase *, frameoffset_t dt, int8_t dnote)
2560 {
2561         uint8_t lowest_note_in_selection  = 127;
2562         uint8_t highest_note_in_selection = 0;
2563         uint8_t highest_note_difference   = 0;
2564
2565         // find highest and lowest notes first
2566
2567         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2568                 uint8_t pitch = (*i)->note()->note();
2569                 lowest_note_in_selection  = std::min(lowest_note_in_selection,  pitch);
2570                 highest_note_in_selection = std::max(highest_note_in_selection, pitch);
2571         }
2572
2573         /*
2574           cerr << "dnote: " << (int) dnote << endl;
2575           cerr << "lowest note (streamview): " << int(midi_stream_view()->lowest_note())
2576           << " highest note (streamview): " << int(midi_stream_view()->highest_note()) << endl;
2577           cerr << "lowest note (selection): " << int(lowest_note_in_selection) << " highest note(selection): "
2578           << int(highest_note_in_selection) << endl;
2579           cerr << "selection size: " << _selection.size() << endl;
2580           cerr << "Highest note in selection: " << (int) highest_note_in_selection << endl;
2581         */
2582
2583         // Make sure the note pitch does not exceed the MIDI standard range
2584         if (highest_note_in_selection + dnote > 127) {
2585                 highest_note_difference = highest_note_in_selection - 127;
2586         }
2587         TempoMap& map (trackview.session()->tempo_map());
2588
2589         start_note_diff_command (_("move notes"));
2590
2591         for (Selection::iterator i = _selection.begin(); i != _selection.end() ; ++i) {
2592
2593                 double const start_qn = (_region->pulse() * 4.0) - midi_region()->start_beats();
2594                 framepos_t new_frames = map.frame_at_quarter_note (start_qn + (*i)->note()->time().to_double()) + dt;
2595                 Evoral::Beats new_time = Evoral::Beats (map.quarter_note_at_frame (new_frames) - start_qn);
2596                 if (new_time < 0) {
2597                         continue;
2598                 }
2599
2600                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::StartTime, new_time);
2601
2602                 uint8_t original_pitch = (*i)->note()->note();
2603                 uint8_t new_pitch      = original_pitch + dnote - highest_note_difference;
2604
2605                 // keep notes in standard midi range
2606                 clamp_to_0_127(new_pitch);
2607
2608                 lowest_note_in_selection  = std::min(lowest_note_in_selection,  new_pitch);
2609                 highest_note_in_selection = std::max(highest_note_in_selection, new_pitch);
2610
2611                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::NoteNumber, new_pitch);
2612         }
2613
2614         apply_diff();
2615
2616         // care about notes being moved beyond the upper/lower bounds on the canvas
2617         if (lowest_note_in_selection  < midi_stream_view()->lowest_note() ||
2618             highest_note_in_selection > midi_stream_view()->highest_note()) {
2619                 midi_stream_view()->set_note_range(MidiStreamView::ContentsRange);
2620         }
2621 }
2622
2623 /** @param x Pixel relative to the region position.
2624  *  @param ensure_snap defaults to false. true = snap always, ignoring snap mode and magnetic snap.
2625  *  Used for inverting the snap logic with key modifiers and snap delta calculation.
2626  *  @return Snapped frame relative to the region position.
2627  */
2628 framepos_t
2629 MidiRegionView::snap_pixel_to_sample(double x, bool ensure_snap)
2630 {
2631         PublicEditor& editor (trackview.editor());
2632         return snap_frame_to_frame (editor.pixel_to_sample (x), ensure_snap);
2633 }
2634
2635 /** @param x Pixel relative to the region position.
2636  *  @param ensure_snap defaults to false. true = ignore magnetic snap and snap mode (used for snap delta calculation).
2637  *  @return Snapped pixel relative to the region position.
2638  */
2639 double
2640 MidiRegionView::snap_to_pixel(double x, bool ensure_snap)
2641 {
2642         return (double) trackview.editor().sample_to_pixel(snap_pixel_to_sample(x, ensure_snap));
2643 }
2644
2645 double
2646 MidiRegionView::get_position_pixels()
2647 {
2648         framepos_t region_frame = get_position();
2649         return trackview.editor().sample_to_pixel(region_frame);
2650 }
2651
2652 double
2653 MidiRegionView::get_end_position_pixels()
2654 {
2655         framepos_t frame = get_position() + get_duration ();
2656         return trackview.editor().sample_to_pixel(frame);
2657 }
2658
2659 framepos_t
2660 MidiRegionView::source_beats_to_absolute_frames(Evoral::Beats beats) const
2661 {
2662         /* the time converter will return the frame corresponding to `beats'
2663            relative to the start of the source. The start of the source
2664            is an implied position given by region->position - region->start
2665         */
2666         const framepos_t source_start = _region->position() - _region->start();
2667         return  source_start +  _source_relative_time_converter.to (beats);
2668 }
2669
2670 Evoral::Beats
2671 MidiRegionView::absolute_frames_to_source_beats(framepos_t frames) const
2672 {
2673         /* the `frames' argument needs to be converted into a frame count
2674            relative to the start of the source before being passed in to the
2675            converter.
2676         */
2677         const framepos_t source_start = _region->position() - _region->start();
2678         return  _source_relative_time_converter.from (frames - source_start);
2679 }
2680
2681 framepos_t
2682 MidiRegionView::region_beats_to_region_frames(Evoral::Beats beats) const
2683 {
2684         return _region_relative_time_converter.to(beats);
2685 }
2686
2687 Evoral::Beats
2688 MidiRegionView::region_frames_to_region_beats(framepos_t frames) const
2689 {
2690         return _region_relative_time_converter.from(frames);
2691 }
2692
2693 double
2694 MidiRegionView::region_frames_to_region_beats_double (framepos_t frames) const
2695 {
2696         return _region_relative_time_converter_double.from(frames);
2697 }
2698
2699 void
2700 MidiRegionView::begin_resizing (bool /*at_front*/)
2701 {
2702         _resize_data.clear();
2703
2704         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
2705                 Note *note = dynamic_cast<Note*> (*i);
2706
2707                 // only insert CanvasNotes into the map
2708                 if (note) {
2709                         NoteResizeData *resize_data = new NoteResizeData();
2710                         resize_data->note = note;
2711
2712                         // create a new SimpleRect from the note which will be the resize preview
2713                         ArdourCanvas::Rectangle *resize_rect = new ArdourCanvas::Rectangle (_note_group,
2714                                                                                             ArdourCanvas::Rect (note->x0(), note->y0(), note->x0(), note->y1()));
2715
2716                         // calculate the colors: get the color settings
2717                         uint32_t fill_color = UINT_RGBA_CHANGE_A(
2718                                 UIConfiguration::instance().color ("midi note selected"),
2719                                 128);
2720
2721                         // make the resize preview notes more transparent and bright
2722                         fill_color = UINT_INTERPOLATE(fill_color, 0xFFFFFF40, 0.5);
2723
2724                         // calculate color based on note velocity
2725                         resize_rect->set_fill_color (UINT_INTERPOLATE(
2726                                 NoteBase::meter_style_fill_color(note->note()->velocity(), note->selected()),
2727                                 fill_color,
2728                                 0.85));
2729
2730                         resize_rect->set_outline_color (NoteBase::calculate_outline (
2731                                                                 UIConfiguration::instance().color ("midi note selected")));
2732
2733                         resize_data->resize_rect = resize_rect;
2734                         _resize_data.push_back(resize_data);
2735                 }
2736         }
2737 }
2738
2739 /** Update resizing notes while user drags.
2740  * @param primary `primary' note for the drag; ie the one that is used as the reference in non-relative mode.
2741  * @param at_front which end of the note (true == note on, false == note off)
2742  * @param delta_x change in mouse position since the start of the drag
2743  * @param relative true if relative resizing is taking place, false if absolute resizing.  This only makes
2744  * a difference when multiple notes are being resized; in relative mode, each note's length is changed by the
2745  * amount of the drag.  In non-relative mode, all selected notes are set to have the same start or end point
2746  * as the \a primary note.
2747  * @param snap_delta snap offset of the primary note in pixels. used in SnapRelative SnapDelta mode.
2748  * @param with_snap true if snap is to be used to determine the position, false if no snap is to be used.
2749  */
2750 void
2751 MidiRegionView::update_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative, double snap_delta, bool with_snap)
2752 {
2753         TempoMap& tmap (trackview.session()->tempo_map());
2754         bool cursor_set = false;
2755         bool const ensure_snap = trackview.editor().snap_mode () != SnapMagnetic;
2756
2757         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2758                 ArdourCanvas::Rectangle* resize_rect = (*i)->resize_rect;
2759                 Note* canvas_note = (*i)->note;
2760                 double current_x;
2761
2762                 if (at_front) {
2763                         if (relative) {
2764                                 current_x = canvas_note->x0() + delta_x + snap_delta;
2765                         } else {
2766                                 current_x = primary->x0() + delta_x + snap_delta;
2767                         }
2768                 } else {
2769                         if (relative) {
2770                                 current_x = canvas_note->x1() + delta_x + snap_delta;
2771                         } else {
2772                                 current_x = primary->x1() + delta_x + snap_delta;
2773                         }
2774                 }
2775
2776                 if (current_x < 0) {
2777                         // This works even with snapping because RegionView::snap_frame_to_frame()
2778                         // snaps forward if the snapped sample is before the beginning of the region
2779                         current_x = 0;
2780                 }
2781                 if (current_x > trackview.editor().sample_to_pixel(_region->length())) {
2782                         current_x = trackview.editor().sample_to_pixel(_region->length());
2783                 }
2784
2785                 if (at_front) {
2786                         if (with_snap) {
2787                                 resize_rect->set_x0 (snap_to_pixel (current_x, ensure_snap) - snap_delta);
2788                         } else {
2789                                 resize_rect->set_x0 (current_x - snap_delta);
2790                         }
2791                         resize_rect->set_x1 (canvas_note->x1());
2792                 } else {
2793                         if (with_snap) {
2794                                 resize_rect->set_x1 (snap_to_pixel (current_x, ensure_snap) - snap_delta);
2795                         } else {
2796                                 resize_rect->set_x1 (current_x - snap_delta);
2797                         }
2798                         resize_rect->set_x0 (canvas_note->x0());
2799                 }
2800
2801                 if (!cursor_set) {
2802                         /* Convert snap delta from pixels to beats. */
2803                         framepos_t snap_delta_samps = trackview.editor().pixel_to_sample (snap_delta);
2804                         double snap_delta_beats = 0.0;
2805                         int sign = 1;
2806
2807                         /* negative beat offsets aren't allowed */
2808                         if (snap_delta_samps > 0) {
2809                                 snap_delta_beats = region_frames_to_region_beats_double (snap_delta_samps);
2810                         } else if (snap_delta_samps < 0) {
2811                                 snap_delta_beats = region_frames_to_region_beats_double ( - snap_delta_samps);
2812                                 sign = -1;
2813                         }
2814
2815                         double  snapped_x;
2816                         int32_t divisions = 0;
2817
2818                         if (with_snap) {
2819                                 snapped_x = snap_pixel_to_sample (current_x, ensure_snap);
2820                                 divisions = trackview.editor().get_grid_music_divisions (0);
2821                         } else {
2822                                 snapped_x = trackview.editor ().pixel_to_sample (current_x);
2823                         }
2824                         const Evoral::Beats beats = Evoral::Beats (tmap.exact_beat_at_frame (snapped_x + midi_region()->position(), divisions)
2825                                                                      - midi_region()->beat()) + midi_region()->start_beats();
2826
2827                         Evoral::Beats len         = Evoral::Beats();
2828
2829                         if (at_front) {
2830                                 if (beats < canvas_note->note()->end_time()) {
2831                                         len = canvas_note->note()->time() - beats + (sign * snap_delta_beats);
2832                                         len += canvas_note->note()->length();
2833                                 }
2834                         } else {
2835                                 if (beats >= canvas_note->note()->time()) {
2836                                         len = beats - canvas_note->note()->time() - (sign * snap_delta_beats);
2837                                 }
2838                         }
2839
2840                         len = std::max(Evoral::Beats(1 / 512.0), len);
2841
2842                         char buf[16];
2843                         snprintf (buf, sizeof (buf), "%.3g beats", len.to_double());
2844                         show_verbose_cursor (buf, 0, 0);
2845
2846                         cursor_set = true;
2847                 }
2848
2849         }
2850 }
2851
2852
2853 /** Finish resizing notes when the user releases the mouse button.
2854  *  Parameters the same as for \a update_resizing().
2855  */
2856 void
2857 MidiRegionView::commit_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative, double snap_delta, bool with_snap)
2858 {
2859         _note_diff_command = _model->new_note_diff_command (_("resize notes"));
2860         TempoMap& tmap (trackview.session()->tempo_map());
2861
2862         /* XX why doesn't snap_pixel_to_sample() handle this properly? */
2863         bool const ensure_snap = trackview.editor().snap_mode () != SnapMagnetic;
2864
2865         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2866                 Note*  canvas_note = (*i)->note;
2867                 ArdourCanvas::Rectangle*  resize_rect = (*i)->resize_rect;
2868
2869                 /* Get the new x position for this resize, which is in pixels relative
2870                  * to the region position.
2871                  */
2872
2873                 double current_x;
2874
2875                 if (at_front) {
2876                         if (relative) {
2877                                 current_x = canvas_note->x0() + delta_x + snap_delta;
2878                         } else {
2879                                 current_x = primary->x0() + delta_x + snap_delta;
2880                         }
2881                 } else {
2882                         if (relative) {
2883                                 current_x = canvas_note->x1() + delta_x + snap_delta;
2884                         } else {
2885                                 current_x = primary->x1() + delta_x + snap_delta;
2886                         }
2887                 }
2888
2889                 if (current_x < 0) {
2890                         current_x = 0;
2891                 }
2892                 if (current_x > trackview.editor().sample_to_pixel(_region->length())) {
2893                         current_x = trackview.editor().sample_to_pixel(_region->length());
2894                 }
2895
2896                 /* Convert snap delta from pixels to beats with sign. */
2897                 framepos_t snap_delta_samps = trackview.editor().pixel_to_sample (snap_delta);
2898                 double snap_delta_beats = 0.0;
2899                 int sign = 1;
2900
2901                 if (snap_delta_samps > 0) {
2902                         snap_delta_beats = region_frames_to_region_beats_double (snap_delta_samps);
2903                 } else if (snap_delta_samps < 0) {
2904                         snap_delta_beats = region_frames_to_region_beats_double ( - snap_delta_samps);
2905                         sign = -1;
2906                 }
2907
2908                 uint32_t divisions = 0;
2909                 /* Convert the new x position to a frame within the source */
2910                 framepos_t current_fr;
2911                 if (with_snap) {
2912                         current_fr = snap_pixel_to_sample (current_x, ensure_snap);
2913                         divisions = trackview.editor().get_grid_music_divisions (0);
2914                 } else {
2915                         current_fr = trackview.editor().pixel_to_sample (current_x);
2916                 }
2917
2918                 /* and then to beats */
2919                 const double e_qaf = tmap.exact_qn_at_frame (current_fr + midi_region()->position(), divisions);
2920                 const double quarter_note_start = (_region->pulse() * 4.0) - midi_region()->start_beats();
2921                 const Evoral::Beats x_beats = Evoral::Beats (e_qaf - quarter_note_start);
2922
2923                 if (at_front && x_beats < canvas_note->note()->end_time()) {
2924                         note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::StartTime, x_beats - (sign * snap_delta_beats));
2925                         Evoral::Beats len = canvas_note->note()->time() - x_beats + (sign * snap_delta_beats);
2926                         len += canvas_note->note()->length();
2927
2928                         if (!!len) {
2929                                 note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
2930                         }
2931                 }
2932
2933                 if (!at_front) {
2934                         Evoral::Beats len = std::max(Evoral::Beats(1 / 512.0),
2935                                                      x_beats - canvas_note->note()->time() - (sign * snap_delta_beats));
2936                         note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
2937                 }
2938
2939                 delete resize_rect;
2940                 delete (*i);
2941         }
2942
2943         _resize_data.clear();
2944         apply_diff(true);
2945 }
2946
2947 void
2948 MidiRegionView::abort_resizing ()
2949 {
2950         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
2951                 delete (*i)->resize_rect;
2952                 delete *i;
2953         }
2954
2955         _resize_data.clear ();
2956 }
2957
2958 void
2959 MidiRegionView::change_note_velocity(NoteBase* event, int8_t velocity, bool relative)
2960 {
2961         uint8_t new_velocity;
2962
2963         if (relative) {
2964                 new_velocity = event->note()->velocity() + velocity;
2965                 clamp_to_0_127(new_velocity);
2966         } else {
2967                 new_velocity = velocity;
2968         }
2969
2970         event->set_selected (event->selected()); // change color
2971
2972         note_diff_add_change (event, MidiModel::NoteDiffCommand::Velocity, new_velocity);
2973 }
2974
2975 void
2976 MidiRegionView::change_note_note (NoteBase* event, int8_t note, bool relative)
2977 {
2978         uint8_t new_note;
2979
2980         if (relative) {
2981                 new_note = event->note()->note() + note;
2982         } else {
2983                 new_note = note;
2984         }
2985
2986         clamp_to_0_127 (new_note);
2987         note_diff_add_change (event, MidiModel::NoteDiffCommand::NoteNumber, new_note);
2988 }
2989
2990 void
2991 MidiRegionView::trim_note (NoteBase* event, Evoral::Beats front_delta, Evoral::Beats end_delta)
2992 {
2993         bool change_start = false;
2994         bool change_length = false;
2995         Evoral::Beats new_start;
2996         Evoral::Beats new_length;
2997
2998         /* NOTE: the semantics of the two delta arguments are slightly subtle:
2999
3000            front_delta: if positive - move the start of the note later in time (shortening it)
3001            if negative - move the start of the note earlier in time (lengthening it)
3002
3003            end_delta:   if positive - move the end of the note later in time (lengthening it)
3004            if negative - move the end of the note earlier in time (shortening it)
3005         */
3006
3007         if (!!front_delta) {
3008                 if (front_delta < 0) {
3009
3010                         if (event->note()->time() < -front_delta) {
3011                                 new_start = Evoral::Beats();
3012                         } else {
3013                                 new_start = event->note()->time() + front_delta; // moves earlier
3014                         }
3015
3016                         /* start moved toward zero, so move the end point out to where it used to be.
3017                            Note that front_delta is negative, so this increases the length.
3018                         */
3019
3020                         new_length = event->note()->length() - front_delta;
3021                         change_start = true;
3022                         change_length = true;
3023
3024                 } else {
3025
3026                         Evoral::Beats new_pos = event->note()->time() + front_delta;
3027
3028                         if (new_pos < event->note()->end_time()) {
3029                                 new_start = event->note()->time() + front_delta;
3030                                 /* start moved toward the end, so move the end point back to where it used to be */
3031                                 new_length = event->note()->length() - front_delta;
3032                                 change_start = true;
3033                                 change_length = true;
3034                         }
3035                 }
3036
3037         }
3038
3039         if (!!end_delta) {
3040                 bool can_change = true;
3041                 if (end_delta < 0) {
3042                         if (event->note()->length() < -end_delta) {
3043                                 can_change = false;
3044                         }
3045                 }
3046
3047                 if (can_change) {
3048                         new_length = event->note()->length() + end_delta;
3049                         change_length = true;
3050                 }
3051         }
3052
3053         if (change_start) {
3054                 note_diff_add_change (event, MidiModel::NoteDiffCommand::StartTime, new_start);
3055         }
3056
3057         if (change_length) {
3058                 note_diff_add_change (event, MidiModel::NoteDiffCommand::Length, new_length);
3059         }
3060 }
3061
3062 void
3063 MidiRegionView::change_note_channel (NoteBase* event, int8_t chn, bool relative)
3064 {
3065         uint8_t new_channel;
3066
3067         if (relative) {
3068                 if (chn < 0.0) {
3069                         if (event->note()->channel() < -chn) {
3070                                 new_channel = 0;
3071                         } else {
3072                                 new_channel = event->note()->channel() + chn;
3073                         }
3074                 } else {
3075                         new_channel = event->note()->channel() + chn;
3076                 }
3077         } else {
3078                 new_channel = (uint8_t) chn;
3079         }
3080
3081         note_diff_add_change (event, MidiModel::NoteDiffCommand::Channel, new_channel);
3082 }
3083
3084 void
3085 MidiRegionView::change_note_time (NoteBase* event, Evoral::Beats delta, bool relative)
3086 {
3087         Evoral::Beats new_time;
3088
3089         if (relative) {
3090                 if (delta < 0.0) {
3091                         if (event->note()->time() < -delta) {
3092                                 new_time = Evoral::Beats();
3093                         } else {
3094                                 new_time = event->note()->time() + delta;
3095                         }
3096                 } else {
3097                         new_time = event->note()->time() + delta;
3098                 }
3099         } else {
3100                 new_time = delta;
3101         }
3102
3103         note_diff_add_change (event, MidiModel::NoteDiffCommand::StartTime, new_time);
3104 }
3105
3106 void
3107 MidiRegionView::change_note_length (NoteBase* event, Evoral::Beats t)
3108 {
3109         note_diff_add_change (event, MidiModel::NoteDiffCommand::Length, t);
3110 }
3111
3112 void
3113 MidiRegionView::change_velocities (bool up, bool fine, bool allow_smush, bool all_together)
3114 {
3115         int8_t delta;
3116         int8_t value = 0;
3117
3118         if (_selection.empty()) {
3119                 return;
3120         }
3121
3122         if (fine) {
3123                 delta = 1;
3124         } else {
3125                 delta = 10;
3126         }
3127
3128         if (!up) {
3129                 delta = -delta;
3130         }
3131
3132         if (!allow_smush) {
3133                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3134                         if ((*i)->note()->velocity() < -delta || (*i)->note()->velocity() + delta > 127) {
3135                                 goto cursor_label;
3136                         }
3137                 }
3138         }
3139
3140         start_note_diff_command (_("change velocities"));
3141
3142         for (Selection::iterator i = _selection.begin(); i != _selection.end();) {
3143                 Selection::iterator next = i;
3144                 ++next;
3145
3146                 if (all_together) {
3147                         if (i == _selection.begin()) {
3148                                 change_note_velocity (*i, delta, true);
3149                                 value = (*i)->note()->velocity() + delta;
3150                         } else {
3151                                 change_note_velocity (*i, value, false);
3152                         }
3153
3154                 } else {
3155                         change_note_velocity (*i, delta, true);
3156                 }
3157
3158                 i = next;
3159         }
3160
3161         apply_diff();
3162
3163   cursor_label:
3164         if (!_selection.empty()) {
3165                 char buf[24];
3166                 snprintf (buf, sizeof (buf), "Vel %d",
3167                           (int) (*_selection.begin())->note()->velocity());
3168                 show_verbose_cursor (buf, 10, 10);
3169         }
3170 }
3171
3172
3173 void
3174 MidiRegionView::transpose (bool up, bool fine, bool allow_smush)
3175 {
3176         if (_selection.empty()) {
3177                 return;
3178         }
3179
3180         int8_t delta;
3181
3182         if (fine) {
3183                 delta = 1;
3184         } else {
3185                 delta = 12;
3186         }
3187
3188         if (!up) {
3189                 delta = -delta;
3190         }
3191
3192         if (!allow_smush) {
3193                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3194                         if (!up) {
3195                                 if ((int8_t) (*i)->note()->note() + delta <= 0) {
3196                                         return;
3197                                 }
3198                         } else {
3199                                 if ((int8_t) (*i)->note()->note() + delta > 127) {
3200                                         return;
3201                                 }
3202                         }
3203                 }
3204         }
3205
3206         start_note_diff_command (_("transpose"));
3207
3208         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3209                 Selection::iterator next = i;
3210                 ++next;
3211                 change_note_note (*i, delta, true);
3212                 i = next;
3213         }
3214
3215         apply_diff ();
3216 }
3217
3218 void
3219 MidiRegionView::change_note_lengths (bool fine, bool shorter, Evoral::Beats delta, bool start, bool end)
3220 {
3221         if (!delta) {
3222                 if (fine) {
3223                         delta = Evoral::Beats(1.0/128.0);
3224                 } else {
3225                         /* grab the current grid distance */
3226                         delta = get_grid_beats(_region->position());
3227                 }
3228         }
3229
3230         if (shorter) {
3231                 delta = -delta;
3232         }
3233
3234         start_note_diff_command (_("change note lengths"));
3235
3236         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3237                 Selection::iterator next = i;
3238                 ++next;
3239
3240                 /* note the negation of the delta for start */
3241
3242                 trim_note (*i,
3243                            (start ? -delta : Evoral::Beats()),
3244                            (end   ? delta  : Evoral::Beats()));
3245                 i = next;
3246         }
3247
3248         apply_diff ();
3249
3250 }
3251
3252 void
3253 MidiRegionView::nudge_notes (bool forward, bool fine)
3254 {
3255         if (_selection.empty()) {
3256                 return;
3257         }
3258
3259         /* pick a note as the point along the timeline to get the nudge distance.
3260            its not necessarily the earliest note, so we may want to pull the notes out
3261            into a vector and sort before using the first one.
3262         */
3263
3264         const framepos_t ref_point = source_beats_to_absolute_frames ((*(_selection.begin()))->note()->time());
3265         Evoral::Beats    delta;
3266
3267         if (!fine) {
3268
3269                 /* non-fine, move by 1 bar regardless of snap */
3270                 delta = Evoral::Beats(trackview.session()->tempo_map().meter_at_frame (ref_point).divisions_per_bar());
3271
3272         } else if (trackview.editor().snap_mode() == Editing::SnapOff) {
3273
3274                 /* grid is off - use nudge distance */
3275
3276                 framepos_t       unused;
3277                 const framecnt_t distance = trackview.editor().get_nudge_distance (ref_point, unused);
3278                 delta = region_frames_to_region_beats (fabs ((double)distance));
3279
3280         } else {
3281
3282                 /* use grid */
3283
3284                 framepos_t next_pos = ref_point;
3285
3286                 if (forward) {
3287                         if (max_framepos - 1 < next_pos) {
3288                                 next_pos += 1;
3289                         }
3290                 } else {
3291                         if (next_pos == 0) {
3292                                 return;
3293                         }
3294                         next_pos -= 1;
3295                 }
3296
3297                 trackview.editor().snap_to (next_pos, (forward ? RoundUpAlways : RoundDownAlways), false);
3298                 const framecnt_t distance = ref_point - next_pos;
3299                 delta = region_frames_to_region_beats (fabs ((double)distance));
3300         }
3301
3302         if (!delta) {
3303                 return;
3304         }
3305
3306         if (!forward) {
3307                 delta = -delta;
3308         }
3309
3310         start_note_diff_command (_("nudge"));
3311
3312         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
3313                 Selection::iterator next = i;
3314                 ++next;
3315                 change_note_time (*i, delta, true);
3316                 i = next;
3317         }
3318
3319         apply_diff ();
3320 }
3321
3322 void
3323 MidiRegionView::change_channel(uint8_t channel)
3324 {
3325         start_note_diff_command(_("change channel"));
3326         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3327                 note_diff_add_change (*i, MidiModel::NoteDiffCommand::Channel, channel);
3328         }
3329
3330         apply_diff();
3331 }
3332
3333
3334 void
3335 MidiRegionView::note_entered(NoteBase* ev)
3336 {
3337         _note_entered = true;
3338
3339         Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
3340
3341         if (_mouse_state == SelectTouchDragging) {
3342
3343                 note_selected (ev, true);
3344
3345         } else if (editor->current_mouse_mode() == MouseContent) {
3346
3347                 remove_ghost_note ();
3348                 show_verbose_cursor (ev->note ());
3349
3350         } else if (editor->current_mouse_mode() == MouseDraw) {
3351
3352                 remove_ghost_note ();
3353                 show_verbose_cursor (ev->note ());
3354         }
3355 }
3356
3357 void
3358 MidiRegionView::note_left (NoteBase*)
3359 {
3360         _note_entered = false;
3361
3362         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3363                 (*i)->hide_velocity ();
3364         }
3365
3366         hide_verbose_cursor ();
3367 }
3368
3369 void
3370 MidiRegionView::patch_entered (PatchChange* p)
3371 {
3372         ostringstream s;
3373         s << _("Bank ") << (p->patch()->bank() + MIDI_BP_ZERO) << '\n'
3374           << instrument_info().get_patch_name_without (p->patch()->bank(), p->patch()->program(), p->patch()->channel()) << '\n'
3375           << _("Channel ") << ((int) p->patch()->channel() + 1);
3376         show_verbose_cursor (s.str(), 10, 20);
3377         p->item().grab_focus();
3378 }
3379
3380 void
3381 MidiRegionView::patch_left (PatchChange *)
3382 {
3383         hide_verbose_cursor ();
3384         /* focus will transfer back via the enter-notify event sent to this
3385          * midi region view.
3386          */
3387 }
3388
3389 void
3390 MidiRegionView::sysex_entered (SysEx* p)
3391 {
3392         ostringstream s;
3393         // CAIROCANVAS
3394         // need a way to extract text from p->_flag->_text
3395         // s << p->text();
3396         // show_verbose_cursor (s.str(), 10, 20);
3397         p->item().grab_focus();
3398 }
3399
3400 void
3401 MidiRegionView::sysex_left (SysEx *)
3402 {
3403         hide_verbose_cursor ();
3404         /* focus will transfer back via the enter-notify event sent to this
3405          * midi region view.
3406          */
3407 }
3408
3409 void
3410 MidiRegionView::note_mouse_position (float x_fraction, float /*y_fraction*/, bool can_set_cursor)
3411 {
3412         Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
3413         Editing::MouseMode mm = editor->current_mouse_mode();
3414         bool trimmable = (mm == MouseContent || mm == MouseTimeFX || mm == MouseDraw);
3415
3416         Editor::EnterContext* ctx = editor->get_enter_context(NoteItem);
3417         if (can_set_cursor && ctx) {
3418                 if (trimmable && x_fraction > 0.0 && x_fraction < 0.2) {
3419                         ctx->cursor_ctx->change(editor->cursors()->left_side_trim);
3420                 } else if (trimmable && x_fraction >= 0.8 && x_fraction < 1.0) {
3421                         ctx->cursor_ctx->change(editor->cursors()->right_side_trim);
3422                 } else {
3423                         ctx->cursor_ctx->change(editor->cursors()->grabber_note);
3424                 }
3425         }
3426 }
3427
3428 uint32_t
3429 MidiRegionView::get_fill_color() const
3430 {
3431         const std::string mod_name = (_dragging ? "dragging region" :
3432                                       trackview.editor().internal_editing() ? "editable region" :
3433                                       "midi frame base");
3434         if (_selected) {
3435                 return UIConfiguration::instance().color_mod ("selected region base", mod_name);
3436         } else if ((!UIConfiguration::instance().get_show_name_highlight() || high_enough_for_name) &&
3437                    !UIConfiguration::instance().get_color_regions_using_track_color()) {
3438                 return UIConfiguration::instance().color_mod ("midi frame base", mod_name);
3439         }
3440         return UIConfiguration::instance().color_mod (fill_color, mod_name);
3441 }
3442
3443 void
3444 MidiRegionView::midi_channel_mode_changed ()
3445 {
3446         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3447         uint16_t mask = mtv->midi_track()->get_playback_channel_mask();
3448         ChannelMode mode = mtv->midi_track()->get_playback_channel_mode ();
3449
3450         if (mode == ForceChannel) {
3451                 mask = 0xFFFF; // Show all notes as active (below)
3452         }
3453
3454         // Update notes for selection
3455         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3456                 (*i)->on_channel_selection_change (mask);
3457         }
3458
3459         _patch_changes.clear ();
3460         display_patch_changes ();
3461 }
3462
3463 void
3464 MidiRegionView::instrument_settings_changed ()
3465 {
3466         redisplay_model();
3467 }
3468
3469 void
3470 MidiRegionView::cut_copy_clear (Editing::CutCopyOp op)
3471 {
3472         if (_selection.empty()) {
3473                 return;
3474         }
3475
3476         PublicEditor& editor (trackview.editor());
3477
3478         switch (op) {
3479         case Delete:
3480                 /* XXX what to do ? */
3481                 break;
3482         case Cut:
3483         case Copy:
3484                 editor.get_cut_buffer().add (selection_as_cut_buffer());
3485                 break;
3486         default:
3487                 break;
3488         }
3489
3490         if (op != Copy) {
3491
3492                 start_note_diff_command();
3493
3494                 for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
3495                         switch (op) {
3496                         case Copy:
3497                                 break;
3498                         case Delete:
3499                         case Cut:
3500                         case Clear:
3501                                 note_diff_remove_note (*i);
3502                                 break;
3503                         }
3504                 }
3505
3506                 apply_diff();
3507         }
3508 }
3509
3510 MidiCutBuffer*
3511 MidiRegionView::selection_as_cut_buffer () const
3512 {
3513         Notes notes;
3514
3515         for (Selection::const_iterator i = _selection.begin(); i != _selection.end(); ++i) {
3516                 NoteType* n = (*i)->note().get();
3517                 notes.insert (boost::shared_ptr<NoteType> (new NoteType (*n)));
3518         }
3519
3520         MidiCutBuffer* cb = new MidiCutBuffer (trackview.session());
3521         cb->set (notes);
3522
3523         return cb;
3524 }
3525
3526 /** This method handles undo */
3527 bool
3528 MidiRegionView::paste (framepos_t pos, const ::Selection& selection, PasteContext& ctx, const int32_t sub_num)
3529 {
3530         bool commit = false;
3531         // Paste notes, if available
3532         MidiNoteSelection::const_iterator m = selection.midi_notes.get_nth(ctx.counts.n_notes());
3533         if (m != selection.midi_notes.end()) {
3534                 ctx.counts.increase_n_notes();
3535                 if (!(*m)->empty()) {
3536                         commit = true;
3537                 }
3538                 paste_internal(pos, ctx.count, ctx.times, **m);
3539         }
3540
3541         // Paste control points to automation children, if available
3542         typedef RouteTimeAxisView::AutomationTracks ATracks;
3543         const ATracks& atracks = midi_view()->automation_tracks();
3544         for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
3545                 if (a->second->paste(pos, selection, ctx, sub_num)) {
3546                         if(!commit) {
3547                                 trackview.editor().begin_reversible_command (Operations::paste);
3548                         }
3549                         commit = true;
3550                 }
3551         }
3552
3553         if (commit) {
3554                 trackview.editor().commit_reversible_command ();
3555         }
3556         return true;
3557 }
3558
3559 /** This method handles undo */
3560 void
3561 MidiRegionView::paste_internal (framepos_t pos, unsigned paste_count, float times, const MidiCutBuffer& mcb)
3562 {
3563         if (mcb.empty()) {
3564                 return;
3565         }
3566
3567         start_note_diff_command (_("paste"));
3568
3569         const Evoral::Beats snap_beats    = get_grid_beats(pos);
3570         const Evoral::Beats first_time    = (*mcb.notes().begin())->time();
3571         const Evoral::Beats last_time     = (*mcb.notes().rbegin())->end_time();
3572         const Evoral::Beats duration      = last_time - first_time;
3573         const Evoral::Beats snap_duration = duration.snap_to(snap_beats);
3574         const Evoral::Beats paste_offset  = snap_duration * paste_count;
3575         const Evoral::Beats pos_beats     = absolute_frames_to_source_beats(pos) + paste_offset;
3576         Evoral::Beats       end_point     = Evoral::Beats();
3577
3578         DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste data spans from %1 to %2 (%3) ; paste pos beats = %4 (based on %5 - %6)\n",
3579                                                        first_time,
3580                                                        last_time,
3581                                                        duration, pos, _region->position(),
3582                                                        pos_beats));
3583
3584         clear_editor_note_selection ();
3585
3586         for (int n = 0; n < (int) times; ++n) {
3587
3588                 for (Notes::const_iterator i = mcb.notes().begin(); i != mcb.notes().end(); ++i) {
3589
3590                         boost::shared_ptr<NoteType> copied_note (new NoteType (*((*i).get())));
3591                         copied_note->set_time (pos_beats + copied_note->time() - first_time);
3592                         copied_note->set_id (Evoral::next_event_id());
3593
3594                         /* make all newly added notes selected */
3595
3596                         note_diff_add_note (copied_note, true);
3597                         end_point = copied_note->end_time();
3598                 }
3599         }
3600
3601         /* if we pasted past the current end of the region, extend the region */
3602
3603         framepos_t end_frame = source_beats_to_absolute_frames (end_point);
3604         framepos_t region_end = _region->position() + _region->length() - 1;
3605
3606         if (end_frame > region_end) {
3607
3608                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste extended region from %1 to %2\n", region_end, end_frame));
3609
3610                 _region->clear_changes ();
3611                 /* we probably need to get the snap modifier somehow to make this correct for non-musical use */
3612                 _region->set_length (end_frame - _region->position(), trackview.editor().get_grid_music_divisions (0));
3613                 trackview.session()->add_command (new StatefulDiffCommand (_region));
3614         }
3615
3616         apply_diff (true);
3617 }
3618
3619 struct EventNoteTimeEarlyFirstComparator {
3620         bool operator() (NoteBase* a, NoteBase* b) {
3621                 return a->note()->time() < b->note()->time();
3622         }
3623 };
3624
3625 void
3626 MidiRegionView::time_sort_events ()
3627 {
3628         if (!_sort_needed) {
3629                 return;
3630         }
3631
3632         EventNoteTimeEarlyFirstComparator cmp;
3633         _events.sort (cmp);
3634
3635         _sort_needed = false;
3636 }
3637
3638 void
3639 MidiRegionView::goto_next_note (bool add_to_selection)
3640 {
3641         bool use_next = false;
3642
3643         if (_events.back()->selected()) {
3644                 return;
3645         }
3646
3647         time_sort_events ();
3648
3649         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3650         uint16_t const channel_mask = mtv->midi_track()->get_playback_channel_mask();
3651
3652         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3653                 if ((*i)->selected()) {
3654                         use_next = true;
3655                         continue;
3656                 } else if (use_next) {
3657                         if (channel_mask & (1 << (*i)->note()->channel())) {
3658                                 if (!add_to_selection) {
3659                                         unique_select (*i);
3660                                 } else {
3661                                         note_selected (*i, true, false);
3662                                 }
3663                                 return;
3664                         }
3665                 }
3666         }
3667
3668         /* use the first one */
3669
3670         if (!_events.empty() && (channel_mask & (1 << _events.front()->note()->channel ()))) {
3671                 unique_select (_events.front());
3672         }
3673 }
3674
3675 void
3676 MidiRegionView::goto_previous_note (bool add_to_selection)
3677 {
3678         bool use_next = false;
3679
3680         if (_events.front()->selected()) {
3681                 return;
3682         }
3683
3684         time_sort_events ();
3685
3686         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3687         uint16_t const channel_mask = mtv->midi_track()->get_playback_channel_mask ();
3688
3689         for (Events::reverse_iterator i = _events.rbegin(); i != _events.rend(); ++i) {
3690                 if ((*i)->selected()) {
3691                         use_next = true;
3692                         continue;
3693                 } else if (use_next) {
3694                         if (channel_mask & (1 << (*i)->note()->channel())) {
3695                                 if (!add_to_selection) {
3696                                         unique_select (*i);
3697                                 } else {
3698                                         note_selected (*i, true, false);
3699                                 }
3700                                 return;
3701                         }
3702                 }
3703         }
3704
3705         /* use the last one */
3706
3707         if (!_events.empty() && (channel_mask & (1 << (*_events.rbegin())->note()->channel ()))) {
3708                 unique_select (*(_events.rbegin()));
3709         }
3710 }
3711
3712 void
3713 MidiRegionView::selection_as_notelist (Notes& selected, bool allow_all_if_none_selected)
3714 {
3715         bool had_selected = false;
3716
3717         time_sort_events ();
3718
3719         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3720                 if ((*i)->selected()) {
3721                         selected.insert ((*i)->note());
3722                         had_selected = true;
3723                 }
3724         }
3725
3726         if (allow_all_if_none_selected && !had_selected) {
3727                 for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3728                         selected.insert ((*i)->note());
3729                 }
3730         }
3731 }
3732
3733 void
3734 MidiRegionView::update_ghost_note (double x, double y, uint32_t state)
3735 {
3736         x = std::max(0.0, x);
3737
3738         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3739
3740         _last_ghost_x = x;
3741         _last_ghost_y = y;
3742
3743         _note_group->canvas_to_item (x, y);
3744
3745         PublicEditor& editor = trackview.editor ();
3746
3747         framepos_t const unsnapped_frame = editor.pixel_to_sample (x);
3748
3749         const int32_t divisions = editor.get_grid_music_divisions (state);
3750         const double snapped_region_qn = snap_frame_to_grid_underneath (unsnapped_frame, divisions, true).to_double();
3751
3752         Evoral::Beats snapped_beats = Evoral::Beats (snapped_region_qn);
3753         /* calculate time in beats relative to start of source */
3754         const Evoral::Beats length = get_grid_beats(unsnapped_frame + _region->position());
3755
3756         _ghost_note->note()->set_time (snapped_beats);
3757         _ghost_note->note()->set_length (length);
3758         _ghost_note->note()->set_note (midi_stream_view()->y_to_note (y));
3759         _ghost_note->note()->set_channel (mtv->get_channel_for_add ());
3760         _ghost_note->note()->set_velocity (get_velocity_for_add (snapped_beats));
3761         /* the ghost note does not appear in ghost regions, so pass false in here */
3762         update_note (_ghost_note, false);
3763
3764         show_verbose_cursor (_ghost_note->note ());
3765 }
3766
3767 void
3768 MidiRegionView::create_ghost_note (double x, double y, uint32_t state)
3769 {
3770         remove_ghost_note ();
3771
3772         boost::shared_ptr<NoteType> g (new NoteType);
3773         if (midi_view()->note_mode() == Sustained) {
3774                 _ghost_note = new Note (*this, _note_group, g);
3775         } else {
3776                 _ghost_note = new Hit (*this, _note_group, 10, g);
3777         }
3778         _ghost_note->set_ignore_events (true);
3779         _ghost_note->set_outline_color (0x000000aa);
3780         update_ghost_note (x, y, state);
3781         _ghost_note->show ();
3782
3783         show_verbose_cursor (_ghost_note->note ());
3784 }
3785
3786 void
3787 MidiRegionView::remove_ghost_note ()
3788 {
3789         delete _ghost_note;
3790         _ghost_note = 0;
3791 }
3792
3793 void
3794 MidiRegionView::hide_verbose_cursor ()
3795 {
3796         trackview.editor().verbose_cursor()->hide ();
3797         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3798         if (mtv) {
3799                 mtv->set_note_highlight (NO_MIDI_NOTE);
3800         }
3801 }
3802
3803 void
3804 MidiRegionView::snap_changed ()
3805 {
3806         if (!_ghost_note) {
3807                 return;
3808         }
3809
3810         create_ghost_note (_last_ghost_x, _last_ghost_y, 0);
3811 }
3812
3813 void
3814 MidiRegionView::drop_down_keys ()
3815 {
3816         _mouse_state = None;
3817 }
3818
3819 void
3820 MidiRegionView::maybe_select_by_position (GdkEventButton* ev, double /*x*/, double y)
3821 {
3822         /* XXX: This is dead code.  What was it for? */
3823
3824         double note = midi_stream_view()->y_to_note(y);
3825         Events e;
3826         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
3827
3828         uint16_t chn_mask = mtv->midi_track()->get_playback_channel_mask();
3829
3830         if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
3831                 get_events (e, Evoral::Sequence<Evoral::Beats>::PitchGreaterThanOrEqual, (uint8_t) floor (note), chn_mask);
3832         } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
3833                 get_events (e, Evoral::Sequence<Evoral::Beats>::PitchLessThanOrEqual, (uint8_t) floor (note), chn_mask);
3834         } else {
3835                 return;
3836         }
3837
3838         bool add_mrv_selection = false;
3839
3840         if (_selection.empty()) {
3841                 add_mrv_selection = true;
3842         }
3843
3844         for (Events::iterator i = e.begin(); i != e.end(); ++i) {
3845                 if (_selection.insert (*i).second) {
3846                         (*i)->set_selected (true);
3847                 }
3848         }
3849
3850         if (add_mrv_selection) {
3851                 PublicEditor& editor (trackview.editor());
3852                 editor.get_selection().add (this);
3853         }
3854 }
3855
3856 void
3857 MidiRegionView::color_handler ()
3858 {
3859         RegionView::color_handler ();
3860
3861         for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
3862                 (*i)->set_selected ((*i)->selected()); // will change color
3863         }
3864
3865         /* XXX probably more to do here */
3866 }
3867
3868 void
3869 MidiRegionView::enable_display (bool yn)
3870 {
3871         RegionView::enable_display (yn);
3872 }
3873
3874 void
3875 MidiRegionView::show_step_edit_cursor (Evoral::Beats pos)
3876 {
3877         if (_step_edit_cursor == 0) {
3878                 ArdourCanvas::Item* const group = get_canvas_group();
3879
3880                 _step_edit_cursor = new ArdourCanvas::Rectangle (group);
3881                 _step_edit_cursor->set_y0 (0);
3882                 _step_edit_cursor->set_y1 (midi_stream_view()->contents_height());
3883                 _step_edit_cursor->set_fill_color (RGBA_TO_UINT (45,0,0,90));
3884                 _step_edit_cursor->set_outline_color (RGBA_TO_UINT (85,0,0,90));
3885         }
3886
3887         move_step_edit_cursor (pos);
3888         _step_edit_cursor->show ();
3889 }
3890
3891 void
3892 MidiRegionView::move_step_edit_cursor (Evoral::Beats pos)
3893 {
3894         _step_edit_cursor_position = pos;
3895
3896         if (_step_edit_cursor) {
3897                 double pixel = trackview.editor().sample_to_pixel (region_beats_to_region_frames (pos));
3898                 _step_edit_cursor->set_x0 (pixel);
3899                 set_step_edit_cursor_width (_step_edit_cursor_width);
3900         }
3901 }
3902
3903 void
3904 MidiRegionView::hide_step_edit_cursor ()
3905 {
3906         if (_step_edit_cursor) {
3907                 _step_edit_cursor->hide ();
3908         }
3909 }
3910
3911 void
3912 MidiRegionView::set_step_edit_cursor_width (Evoral::Beats beats)
3913 {
3914         _step_edit_cursor_width = beats;
3915
3916         if (_step_edit_cursor) {
3917                 _step_edit_cursor->set_x1 (_step_edit_cursor->x0() + trackview.editor().sample_to_pixel (
3918                                                    region_beats_to_region_frames (_step_edit_cursor_position + beats)
3919                                                    - region_beats_to_region_frames (_step_edit_cursor_position)));
3920         }
3921 }
3922
3923 /** Called when a diskstream on our track has received some data.  Update the view, if applicable.
3924  *  @param w Source that the data will end up in.
3925  */
3926 void
3927 MidiRegionView::data_recorded (boost::weak_ptr<MidiSource> w)
3928 {
3929         if (!_active_notes) {
3930                 /* we aren't actively being recorded to */
3931                 return;
3932         }
3933
3934         boost::shared_ptr<MidiSource> src = w.lock ();
3935         if (!src || src != midi_region()->midi_source()) {
3936                 /* recorded data was not destined for our source */
3937                 return;
3938         }
3939
3940         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (&trackview);
3941
3942         boost::shared_ptr<MidiBuffer> buf = mtv->midi_track()->get_gui_feed_buffer ();
3943
3944         framepos_t back = max_framepos;
3945
3946         for (MidiBuffer::iterator i = buf->begin(); i != buf->end(); ++i) {
3947                 Evoral::MIDIEvent<MidiBuffer::TimeType> const ev (*i, false);
3948
3949                 if (ev.is_channel_event()) {
3950                         if (get_channel_mode() == FilterChannels) {
3951                                 if (((uint16_t(1) << ev.channel()) & get_selected_channels()) == 0) {
3952                                         continue;
3953                                 }
3954                         }
3955                 }
3956
3957                 /* convert from session frames to source beats */
3958                 Evoral::Beats const time_beats = _source_relative_time_converter.from(
3959                         ev.time() - src->timeline_position() + _region->start());
3960
3961                 if (ev.type() == MIDI_CMD_NOTE_ON) {
3962                         boost::shared_ptr<NoteType> note (
3963                                 new NoteType (ev.channel(), time_beats, Evoral::Beats(), ev.note(), ev.velocity()));
3964
3965                         add_note (note, true);
3966
3967                         /* fix up our note range */
3968                         if (ev.note() < _current_range_min) {
3969                                 midi_stream_view()->apply_note_range (ev.note(), _current_range_max, true);
3970                         } else if (ev.note() > _current_range_max) {
3971                                 midi_stream_view()->apply_note_range (_current_range_min, ev.note(), true);
3972                         }
3973
3974                 } else if (ev.type() == MIDI_CMD_NOTE_OFF) {
3975                         resolve_note (ev.note (), time_beats);
3976                 }
3977
3978                 back = ev.time ();
3979         }
3980
3981         midi_stream_view()->check_record_layers (region(), back);
3982 }
3983
3984 void
3985 MidiRegionView::trim_front_starting ()
3986 {
3987         /* We used to eparent the note group to the region view's parent, so that it didn't change.
3988            now we update it.
3989         */
3990 }
3991
3992 void
3993 MidiRegionView::trim_front_ending ()
3994 {
3995         if (_region->start() < 0) {
3996                 /* Trim drag made start time -ve; fix this */
3997                 midi_region()->fix_negative_start ();
3998         }
3999 }
4000
4001 void
4002 MidiRegionView::edit_patch_change (PatchChange* pc)
4003 {
4004         PatchChangeDialog d (&_source_relative_time_converter, trackview.session(), *pc->patch (), instrument_info(), Gtk::Stock::APPLY, true);
4005
4006         int response = d.run();
4007
4008         switch (response) {
4009         case Gtk::RESPONSE_ACCEPT:
4010                 break;
4011         case Gtk::RESPONSE_REJECT:
4012                 delete_patch_change (pc);
4013                 return;
4014         default:
4015                 return;
4016         }
4017
4018         change_patch_change (pc->patch(), d.patch ());
4019 }
4020
4021 void
4022 MidiRegionView::delete_sysex (SysEx* /*sysex*/)
4023 {
4024         // CAIROCANVAS
4025         // sysyex object doesn't have a pointer to a sysex event
4026         // MidiModel::SysExDiffCommand* c = _model->new_sysex_diff_command (_("delete sysex"));
4027         // c->remove (sysex->sysex());
4028         // _model->apply_command (*trackview.session(), c);
4029
4030         //_sys_exes.clear ();
4031         // display_sysexes();
4032 }
4033
4034 std::string
4035 MidiRegionView::get_note_name (boost::shared_ptr<NoteType> n, uint8_t note_value) const
4036 {
4037         using namespace MIDI::Name;
4038         std::string name;
4039
4040         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
4041         if (mtv) {
4042                 boost::shared_ptr<MasterDeviceNames> device_names(mtv->get_device_names());
4043                 if (device_names) {
4044                         MIDI::Name::PatchPrimaryKey patch_key;
4045                         get_patch_key_at(n->time(), n->channel(), patch_key);
4046                         name = device_names->note_name(mtv->gui_property(X_("midnam-custom-device-mode")),
4047                                                        n->channel(),
4048                                                        patch_key.bank(),
4049                                                        patch_key.program(),
4050                                                        note_value);
4051                 }
4052         }
4053
4054         char buf[128];
4055         snprintf (buf, sizeof (buf), "%d %s\nCh %d Vel %d",
4056                   (int) note_value,
4057                   name.empty() ? ParameterDescriptor::midi_note_name (note_value).c_str() : name.c_str(),
4058                   (int) n->channel() + 1,
4059                   (int) n->velocity());
4060
4061         return buf;
4062 }
4063
4064 void
4065 MidiRegionView::show_verbose_cursor_for_new_note_value(boost::shared_ptr<NoteType> current_note,
4066                                                        uint8_t new_value) const
4067 {
4068         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
4069         if (mtv) {
4070                 mtv->set_note_highlight (new_value);
4071         }
4072
4073         show_verbose_cursor(get_note_name(current_note, new_value), 10, 20);
4074 }
4075
4076 void
4077 MidiRegionView::show_verbose_cursor (boost::shared_ptr<NoteType> n) const
4078 {
4079         show_verbose_cursor_for_new_note_value(n, n->note());
4080 }
4081
4082 void
4083 MidiRegionView::show_verbose_cursor (string const & text, double xoffset, double yoffset) const
4084 {
4085         trackview.editor().verbose_cursor()->set (text);
4086         trackview.editor().verbose_cursor()->show ();
4087         trackview.editor().verbose_cursor()->set_offset (ArdourCanvas::Duple (xoffset, yoffset));
4088 }
4089
4090 uint8_t
4091 MidiRegionView::get_velocity_for_add (MidiModel::TimeType time) const
4092 {
4093         if (_model->notes().empty()) {
4094                 return 0x40;  // No notes, use default
4095         }
4096
4097         MidiModel::Notes::const_iterator m = _model->note_lower_bound(time);
4098         if (m == _model->notes().begin()) {
4099                 // Before the start, use the velocity of the first note
4100                 return (*m)->velocity();
4101         } else if (m == _model->notes().end()) {
4102                 // Past the end, use the velocity of the last note
4103                 --m;
4104                 return (*m)->velocity();
4105         }
4106
4107         // Interpolate velocity of surrounding notes
4108         MidiModel::Notes::const_iterator n = m;
4109         --n;
4110
4111         const double frac = ((time - (*n)->time()).to_double() /
4112                              ((*m)->time() - (*n)->time()).to_double());
4113
4114         return (*n)->velocity() + (frac * ((*m)->velocity() - (*n)->velocity()));
4115 }
4116
4117 /** @param p A session framepos.
4118  *  @param divisions beat division to snap given by Editor::get_grid_music_divisions() where
4119  *  bar is -1, 0 is audio samples and a positive integer is beat subdivisions.
4120  *  @return beat duration of p snapped to the grid subdivision underneath it.
4121  */
4122 Evoral::Beats
4123 MidiRegionView::snap_frame_to_grid_underneath (framepos_t p, int32_t divisions, bool shift_snap) const
4124 {
4125         TempoMap& map (trackview.session()->tempo_map());
4126         double eqaf = map.exact_qn_at_frame (p + _region->position(), divisions);
4127
4128         if (divisions != 0 && shift_snap) {
4129                 const double qaf = map.quarter_note_at_frame (p + _region->position());
4130                 /* Hack so that we always snap to the note that we are over, instead of snapping
4131                    to the next one if we're more than halfway through the one we're over.
4132                 */
4133                 const Evoral::Beats grid_beats = get_grid_beats (p + _region->position());
4134                 const double rem = eqaf - qaf;
4135                 if (rem >= 0.0 && eqaf - grid_beats.to_double() > _region->pulse() * 4.0) {
4136                         eqaf -= grid_beats.to_double();
4137                 }
4138         }
4139         const double session_start_off = (_region->pulse() * 4.0) - midi_region()->start_beats();
4140
4141         return Evoral::Beats (eqaf - session_start_off);
4142 }
4143
4144 ChannelMode
4145 MidiRegionView::get_channel_mode () const
4146 {
4147         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (&trackview);
4148         return rtav->midi_track()->get_playback_channel_mode();
4149 }
4150
4151 uint16_t
4152 MidiRegionView::get_selected_channels () const
4153 {
4154         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (&trackview);
4155         return rtav->midi_track()->get_playback_channel_mask();
4156 }
4157
4158
4159 Evoral::Beats
4160 MidiRegionView::get_grid_beats(framepos_t pos) const
4161 {
4162         PublicEditor& editor  = trackview.editor();
4163         bool          success = false;
4164         Evoral::Beats beats   = editor.get_grid_type_as_beats (success, pos);
4165         if (!success) {
4166                 beats = Evoral::Beats(1);
4167         }
4168         return beats;
4169 }