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