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