gtk2_ardour/midi_region_view.cc

   1 /*
   2     Copyright (C) 2001-2007 Paul Davis
   3     Author: Dave 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 <cassert>
  22 #include <algorithm>
  23
  24 #include <gtkmm.h>
  25
  26 #include <gtkmm2ext/gtk_ui.h>
  27
  28 #include <sigc++/signal.h>
  29
  30 #include <ardour/playlist.h>
  31 #include <ardour/tempo.h>
  32 #include <ardour/midi_region.h>
  33 #include <ardour/midi_source.h>
  34 #include <ardour/midi_diskstream.h>
  35 #include <ardour/midi_model.h>
  36
  37 #include "streamview.h"
  38 #include "midi_region_view.h"
  39 #include "midi_streamview.h"
  40 #include "midi_time_axis.h"
  41 #include "simpleline.h"
  42 #include "canvas-hit.h"
  43 #include "public_editor.h"
  44 #include "ghostregion.h"
  45 #include "midi_time_axis.h"
  46 #include "automation_time_axis.h"
  47 #include "automation_region_view.h"
  48 #include "utils.h"
  49 #include "midi_util.h"
  50 #include "gui_thread.h"
  51 #include "keyboard.h"
  52
  53 #include "i18n.h"
  54
  55 using namespace sigc;
  56 using namespace ARDOUR;
  57 using namespace PBD;
  58 using namespace Editing;
  59 using namespace ArdourCanvas;
  60
  61 MidiRegionView::MidiRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv, boost::shared_ptr<MidiRegion> r, double spu, Gdk::Color& basic_color)
  62         : RegionView (parent, tv, r, spu, basic_color)
  63         , _default_note_length(0.0)
  64         , _active_notes(0)
  65         , _note_group(new ArdourCanvas::Group(*parent))
  66         , _delta_command(NULL)
  67         , _mouse_state(None)
  68         , _pressed_button(0)
  69 {
  70         group->lower_to_bottom();
  71         _note_group->raise_to_top();
  72
  73         frame->property_fill_color_rgba() = 0xff000033;
  74 }
  75
  76 MidiRegionView::MidiRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv, boost::shared_ptr<MidiRegion> r, double spu, Gdk::Color& basic_color, TimeAxisViewItem::Visibility visibility)
  77         : RegionView (parent, tv, r, spu, basic_color, visibility)
  78         , _default_note_length(0.0)
  79         , _active_notes(0)
  80         , _note_group(new ArdourCanvas::Group(*parent))
  81         , _delta_command(NULL)
  82         , _mouse_state(None)
  83         , _pressed_button(0)
  84 {
  85         _note_group->raise_to_top();
  86 }
  87
  88 void
  89 MidiRegionView::init (Gdk::Color& basic_color, bool wfd)
  90 {
  91         if (wfd)
  92                 midi_region()->midi_source(0)->load_model();
  93
  94         const Meter& m = trackview.session().tempo_map().meter_at(_region->position());
  95         const Tempo& t = trackview.session().tempo_map().tempo_at(_region->position());
  96         _default_note_length = m.frames_per_bar(t, trackview.session().frame_rate())
  97                         / m.beats_per_bar();
  98
  99         _model = midi_region()->midi_source(0)->model();
 100         _enable_display = false;
 101
 102         RegionView::init(basic_color, false);
 103
 104         compute_colors (basic_color);
 105
 106         reset_width_dependent_items ((double) _region->length() / samples_per_unit);
 107
 108         set_y_position_and_height (0, trackview.height);
 109
 110         region_muted ();
 111         region_resized (BoundsChanged);
 112         region_locked ();
 113
 114         _region->StateChanged.connect (mem_fun(*this, &MidiRegionView::region_changed));
 115
 116         set_colors ();
 117
 118         _enable_display = true;
 119
 120         if (_model) {
 121                 if (wfd) {
 122                         redisplay_model();
 123                 }
 124                 _model->ContentsChanged.connect(sigc::mem_fun(this, &MidiRegionView::redisplay_model));
 125         }
 126
 127         midi_region()->midi_source(0)->Switched.connect(sigc::mem_fun(this, &MidiRegionView::switch_source));
 128
 129         group->signal_event().connect (mem_fun (this, &MidiRegionView::canvas_event), false);
 130
 131 }
 132
 133 bool
 134 MidiRegionView::canvas_event(GdkEvent* ev)
 135 {
 136         static bool delete_mod = false;
 137         static Editing::MidiEditMode original_mode;
 138
 139         static double drag_start_x, drag_start_y;
 140         static double last_x, last_y;
 141         double event_x, event_y;
 142         nframes_t event_frame = 0;
 143
 144         static ArdourCanvas::SimpleRect* drag_rect = NULL;
 145
 146         if (trackview.editor.current_mouse_mode() != MouseNote)
 147                 return false;
 148
 149         // Mmmm, spaghetti
 150
 151         switch (ev->type) {
 152         case GDK_KEY_PRESS:
 153                 if (ev->key.keyval == GDK_Delete && !delete_mod) {
 154                         delete_mod = true;
 155                         original_mode = trackview.editor.current_midi_edit_mode();
 156                         trackview.editor.set_midi_edit_mode(MidiEditErase);
 157                         start_delta_command(_("erase notes"));
 158                         _mouse_state = EraseTouchDragging;
 159                         return true;
 160                 } else if (ev->key.keyval == GDK_Shift_L || ev->key.keyval == GDK_Control_L) {
 161                         _mouse_state = SelectTouchDragging;
 162                         return true;
 163                 } else if (ev->key.keyval == GDK_Escape) {
 164                         clear_selection();
 165                         _mouse_state = None;
 166                 }
 167                 return false;
 168
 169         case GDK_KEY_RELEASE:
 170                 if (ev->key.keyval == GDK_Delete) {
 171                         if (_mouse_state == EraseTouchDragging) {
 172                                 delete_selection();
 173                                 apply_command();
 174                         }
 175                         if (delete_mod) {
 176                                 trackview.editor.set_midi_edit_mode(original_mode);
 177                                 delete_mod = false;
 178                         }
 179                         return true;
 180                 } else if (ev->key.keyval == GDK_Shift_L || ev->key.keyval == GDK_Control_L) {
 181                         _mouse_state = None;
 182                         return true;
 183                 }
 184                 return false;
 185
 186         case GDK_BUTTON_PRESS:
 187                 if (_mouse_state != SelectTouchDragging &&
 188                         _mouse_state != EraseTouchDragging &&
 189                         ev->button.button == 1  ) {
 190                         _pressed_button = ev->button.button;
 191                         _mouse_state = Pressed;
 192                         return true;
 193                 }
 194                 _pressed_button = ev->button.button;
 195                 return false;
 196
 197         case GDK_ENTER_NOTIFY:
 198                 /* FIXME: do this on switch to note tool, too, if the pointer is already in */
 199                 Keyboard::magic_widget_grab_focus();
 200                 group->grab_focus();
 201                 break;
 202
 203         case GDK_MOTION_NOTIFY:
 204                 event_x = ev->motion.x;
 205                 event_y = ev->motion.y;
 206                 group->w2i(event_x, event_y);
 207
 208                 // convert event_x to global frame
 209                 event_frame = trackview.editor.pixel_to_frame(event_x) + _region->position();
 210                 trackview.editor.snap_to(event_frame);
 211                 // convert event_frame back to local coordinates relative to position
 212                 event_frame -= _region->position();
 213
 214                 switch (_mouse_state) {
 215                 case Pressed: // Drag start
 216
 217                         // Select drag start
 218                         if (_pressed_button == 1 && trackview.editor.current_midi_edit_mode() == MidiEditSelect) {
 219                                 group->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
 220                                                 Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
 221                                 last_x = event_x;
 222                                 last_y = event_y;
 223                                 drag_start_x = event_x;
 224                                 drag_start_y = event_y;
 225
 226                                 drag_rect = new ArdourCanvas::SimpleRect(*group);
 227                                 drag_rect->property_x1() = event_x;
 228                                 drag_rect->property_y1() = event_y;
 229                                 drag_rect->property_x2() = event_x;
 230                                 drag_rect->property_y2() = event_y;
 231                                 drag_rect->property_outline_what() = 0xFF;
 232                                 drag_rect->property_outline_color_rgba()
 233                                         = ARDOUR_UI::config()->canvasvar_MidiSelectRectOutline.get();
 234                                 drag_rect->property_fill_color_rgba()
 235                                         = ARDOUR_UI::config()->canvasvar_MidiSelectRectFill.get();
 236
 237                                 _mouse_state = SelectRectDragging;
 238                                 return true;
 239
 240                         // Add note drag start
 241                         } else if (trackview.editor.current_midi_edit_mode() == MidiEditPencil) {
 242                                 group->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
 243                                                 Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
 244                                 last_x = event_x;
 245                                 last_y = event_y;
 246                                 drag_start_x = event_x;
 247                                 drag_start_y = event_y;
 248
 249                                 drag_rect = new ArdourCanvas::SimpleRect(*group);
 250                                 drag_rect->property_x1() = trackview.editor.frame_to_pixel(event_frame);
 251
 252                                 drag_rect->property_y1() = midi_stream_view()->note_to_y(midi_stream_view()->y_to_note(event_y));
 253                                 drag_rect->property_x2() = event_x;
 254                                 drag_rect->property_y2() = drag_rect->property_y1() + floor(midi_stream_view()->note_height());
 255                                 drag_rect->property_outline_what() = 0xFF;
 256                                 drag_rect->property_outline_color_rgba() = 0xFFFFFF99;
 257
 258                                 drag_rect->property_fill_color_rgba() = 0xFFFFFF66;
 259
 260                                 _mouse_state = AddDragging;
 261                                 return true;
 262                         }
 263
 264                         return false;
 265
 266                 case SelectRectDragging: // Select drag motion
 267                 case AddDragging: // Add note drag motion
 268                         if (ev->motion.is_hint) {
 269                                 int t_x;
 270                                 int t_y;
 271                                 GdkModifierType state;
 272                                 gdk_window_get_pointer(ev->motion.window, &t_x, &t_y, &state);
 273                                 event_x = t_x;
 274                                 event_y = t_y;
 275                         }
 276
 277                         if (_mouse_state == AddDragging)
 278                                 event_x = trackview.editor.frame_to_pixel(event_frame);
 279
 280                         if (drag_rect)
 281                                 if (event_x > drag_start_x)
 282                                         drag_rect->property_x2() = event_x;
 283                                 else
 284                                         drag_rect->property_x1() = event_x;
 285
 286                         if (drag_rect && _mouse_state == SelectRectDragging) {
 287                                 if (event_y > drag_start_y)
 288                                         drag_rect->property_y2() = event_y;
 289                                 else
 290                                         drag_rect->property_y1() = event_y;
 291
 292                                 update_drag_selection(drag_start_x, event_x, drag_start_y, event_y);
 293                         }
 294
 295                         last_x = event_x;
 296                         last_y = event_y;
 297
 298                 case EraseTouchDragging:
 299                 case SelectTouchDragging:
 300                         return false;
 301
 302                 default:
 303                         break;
 304                 }
 305                 break;
 306
 307         case GDK_BUTTON_RELEASE:
 308                 event_x = ev->motion.x;
 309                 event_y = ev->motion.y;
 310                 group->w2i(event_x, event_y);
 311                 group->ungrab(ev->button.time);
 312                 event_frame = trackview.editor.pixel_to_frame(event_x);
 313
 314                 if(_pressed_button != 1) {
 315                         return false;
 316                 }
 317
 318                 switch (_mouse_state) {
 319                 case Pressed: // Clicked
 320                         switch (trackview.editor.current_midi_edit_mode()) {
 321                         case MidiEditSelect:
 322                         case MidiEditResize:
 323                                 clear_selection();
 324                                 break;
 325                         case MidiEditPencil:
 326                                 create_note_at(event_x, event_y, _default_note_length);
 327                         default:
 328                                 break;
 329                         }
 330                         _mouse_state = None;
 331                         return true;
 332                 case SelectRectDragging: // Select drag done
 333                         _mouse_state = None;
 334                         delete drag_rect;
 335                         drag_rect = NULL;
 336                         return true;
 337                 case AddDragging: // Add drag done
 338                         _mouse_state = None;
 339                         if (drag_rect->property_x2() > drag_rect->property_x1() + 2) {
 340                                 const double x      = drag_rect->property_x1();
 341                                 const double length = trackview.editor.pixel_to_frame(
 342                                                         drag_rect->property_x2() - drag_rect->property_x1());
 343
 344                                 create_note_at(x, drag_rect->property_y1(), length);
 345                         }
 346
 347                         delete drag_rect;
 348                         drag_rect = NULL;
 349                         return true;
 350                 default:
 351                         break;
 352                 }
 353
 354         default:
 355                 break;
 356         }
 357
 358         return false;
 359 }
 360
 361
 362 /** Add a note to the model, and the view, at a canvas (click) coordinate */
 363 void
 364 MidiRegionView::create_note_at(double x, double y, double duration)
 365 {
 366         MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
 367         MidiStreamView* const view = mtv->midi_view();
 368
 369         double note = midi_stream_view()->y_to_note(y);
 370
 371         assert(note >= 0.0);
 372         assert(note <= 127.0);
 373
 374         nframes_t new_note_time = trackview.editor.pixel_to_frame (x);
 375         assert(new_note_time >= 0);
 376         new_note_time += _region->start();
 377
 378         /*
 379         const Meter& m = trackview.session().tempo_map().meter_at(new_note_time);
 380         const Tempo& t = trackview.session().tempo_map().tempo_at(new_note_time);
 381         double duration = m.frames_per_bar(t, trackview.session().frame_rate()) / m.beats_per_bar();
 382         */
 383
 384         // we need to snap here again in nframes_t in order to be sample accurate
 385         // since note time is region-absolute but snap_to_frame expects position-relative
 386         // time we have to coordinate transform back and forth here.
 387         nframes_t new_note_time_position_relative = new_note_time      - _region->start();
 388         new_note_time = snap_to_frame(new_note_time_position_relative) + _region->start();
 389
 390         // we need to snap the duration too to be sample accurate
 391         nframes_t new_note_duration = nframes_t(duration);
 392         new_note_duration = snap_to_frame(new_note_time_position_relative + new_note_duration) + _region->start()
 393                             - new_note_time;
 394
 395         const boost::shared_ptr<Note> new_note(new Note(0, new_note_time, new_note_duration, (uint8_t)note, 0x40));
 396         view->update_bounds(new_note->note());
 397
 398         MidiModel::DeltaCommand* cmd = _model->new_delta_command("add note");
 399         cmd->add(new_note);
 400         _model->apply_command(cmd);
 401
 402         //add_note(new_note);
 403 }
 404
 405
 406 void
 407 MidiRegionView::clear_events()
 408 {
 409         clear_selection();
 410
 411         MidiGhostRegion* gr;
 412         for (std::vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
 413                 if ((gr = dynamic_cast<MidiGhostRegion*>(*g)) != 0) {
 414                         gr->clear_events();
 415                 }
 416         }
 417
 418         for (std::vector<CanvasMidiEvent*>::iterator i = _events.begin(); i != _events.end(); ++i)
 419                 delete *i;
 420
 421         _events.clear();
 422 }
 423
 424
 425 void
 426 MidiRegionView::display_model(boost::shared_ptr<MidiModel> model)
 427 {
 428         _model = model;
 429
 430         if (_enable_display)
 431                 redisplay_model();
 432 }
 433
 434
 435 void
 436 MidiRegionView::redisplay_model()
 437 {
 438         // Don't redisplay the model if we're currently recording and displaying that
 439         if (_active_notes)
 440                 return;
 441
 442         if (_model) {
 443
 444                 clear_events();
 445                 begin_write();
 446
 447                 _model->read_lock();
 448
 449                 /*
 450                 MidiModel::Notes notes = _model->notes();
 451                 cerr << endl << "Model contains " << notes.size() << " Notes:" << endl;
 452                 for(MidiModel::Notes::iterator i = notes.begin(); i != notes.end(); ++i) {
 453                         Note note = *(*i).get();
 454                         cerr << "MODEL: Note time: " << note.time() << " duration: " << note.duration()
 455                              << "   end-time: " << note.end_time()
 456                              << "   velocity: " << int(note.velocity())
 457                              //<< " Note-on: " << note.on_event().
 458                              //<< " Note-off: " << note.off_event()
 459                              << endl;
 460                 }*/
 461
 462                 for (size_t i=0; i < _model->n_notes(); ++i) {
 463                         add_note(_model->note_at(i));
 464                 }
 465
 466                 end_write();
 467
 468                 /*for (Automatable::Controls::const_iterator i = _model->controls().begin();
 469                                 i != _model->controls().end(); ++i) {
 470
 471                         assert(i->second);
 472
 473                         boost::shared_ptr<AutomationTimeAxisView> at
 474                                 = midi_view()->automation_child(i->second->parameter());
 475                         if (!at)
 476                                 continue;
 477
 478                         Gdk::Color col = midi_stream_view()->get_region_color();
 479
 480                         boost::shared_ptr<AutomationRegionView> arv;
 481
 482                         {
 483                                 Glib::Mutex::Lock list_lock (i->second->list()->lock());
 484
 485                                 arv = boost::shared_ptr<AutomationRegionView>(
 486                                                 new AutomationRegionView(at->canvas_display,
 487                                                         *at.get(), _region, i->second->list(),
 488                                                         midi_stream_view()->get_samples_per_unit(), col));
 489                         }
 490
 491                         arv->set_duration(_region->length(), this);
 492                         arv->init(col, true);
 493
 494                         _automation_children.insert(std::make_pair(i->second->parameter(), arv));
 495                 }*/
 496
 497                 _model->read_unlock();
 498
 499         } else {
 500                 cerr << "MidiRegionView::redisplay_model called without a model" << endmsg;
 501         }
 502 }
 503
 504
 505 MidiRegionView::~MidiRegionView ()
 506 {
 507         in_destructor = true;
 508
 509         RegionViewGoingAway (this); /* EMIT_SIGNAL */
 510
 511         if (_active_notes)
 512                 end_write();
 513
 514         _selection.clear();
 515         clear_events();
 516         delete _note_group;
 517         delete _delta_command;
 518 }
 519
 520
 521 void
 522 MidiRegionView::region_resized (Change what_changed)
 523 {
 524         RegionView::region_resized(what_changed);
 525
 526         if (what_changed & ARDOUR::PositionChanged) {
 527                 if (_enable_display)
 528                         redisplay_model();
 529         }
 530 }
 531
 532 void
 533 MidiRegionView::reset_width_dependent_items (double pixel_width)
 534 {
 535         RegionView::reset_width_dependent_items(pixel_width);
 536         assert(_pixel_width == pixel_width);
 537
 538         if (_enable_display)
 539                 redisplay_model();
 540 }
 541
 542 void
 543 MidiRegionView::set_y_position_and_height (double y, double h)
 544 {
 545         RegionView::set_y_position_and_height(y, h - 1);
 546
 547         if (_enable_display) {
 548
 549                 _model->read_lock();
 550
 551                 for (std::vector<CanvasMidiEvent*>::const_iterator i = _events.begin(); i != _events.end(); ++i) {
 552                         CanvasNote* note = dynamic_cast<CanvasNote*>(*i);
 553                         if (note && note->note()) {
 554                                 if (note->note()->note() < midi_stream_view()->lowest_note() ||
 555                                    note->note()->note() > midi_stream_view()->highest_note()) {
 556                                         if (canvas_item_visible(note)) {
 557                                                 note->hide();
 558                                         }
 559                                 }
 560                                 else {
 561                                         const double y1 = midi_stream_view()->note_to_y(note->note()->note());
 562                                         const double y2 = y1 + floor(midi_stream_view()->note_height());
 563
 564                                         if (!canvas_item_visible(note)) {
 565                                                 note->show();
 566                                         }
 567
 568                                         note->hide_velocity();
 569                                         note->property_y1() = y1;
 570                                         note->property_y2() = y2;
 571                                         if(note->selected()) {
 572                                                 note->show_velocity();
 573                                 }
 574                         }
 575                 }
 576                 }
 577
 578                 _model->read_unlock();
 579         }
 580
 581         if (name_text) {
 582                 name_text->raise_to_top();
 583         }
 584 }
 585
 586 GhostRegion*
 587 MidiRegionView::add_ghost (TimeAxisView& tv)
 588 {
 589         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&trackview);
 590         CanvasNote* note;
 591         assert(rtv);
 592
 593         double unit_position = _region->position () / samples_per_unit;
 594         MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&tv);
 595         MidiGhostRegion* ghost;
 596
 597         if (mtv && mtv->midi_view()) {
 598                 /* if ghost is inserted into midi track, use a dedicated midi ghost canvas group.
 599                    this is because it's nice to have midi notes on top of the note lines and
 600                    audio waveforms under it.
 601                  */
 602                 ghost = new MidiGhostRegion (*mtv->midi_view(), trackview, unit_position);
 603         }
 604         else {
 605                 ghost = new MidiGhostRegion (tv, trackview, unit_position);
 606         }
 607
 608         ghost->set_height ();
 609         ghost->set_duration (_region->length() / samples_per_unit);
 610         ghosts.push_back (ghost);
 611
 612         for (std::vector<CanvasMidiEvent*>::iterator i = _events.begin(); i != _events.end(); ++i) {
 613                 if ((note = dynamic_cast<CanvasNote*>(*i)) != 0) {
 614                         ghost->add_note(note);
 615                 }
 616         }
 617
 618         ghost->GoingAway.connect (mem_fun(*this, &MidiRegionView::remove_ghost));
 619
 620         return ghost;
 621 }
 622
 623
 624 /** Begin tracking note state for successive calls to add_event
 625  */
 626 void
 627 MidiRegionView::begin_write()
 628 {
 629         assert(!_active_notes);
 630         _active_notes = new CanvasNote*[128];
 631         for (unsigned i=0; i < 128; ++i)
 632                 _active_notes[i] = NULL;
 633 }
 634
 635
 636 /** Destroy note state for add_event
 637  */
 638 void
 639 MidiRegionView::end_write()
 640 {
 641         delete[] _active_notes;
 642         _active_notes = NULL;
 643         _marked_for_selection.clear();
 644 }
 645
 646
 647 /** Resolve an active MIDI note (while recording).
 648  */
 649 void
 650 MidiRegionView::resolve_note(uint8_t note, double end_time)
 651 {
 652         if (midi_view()->note_mode() != Sustained)
 653                 return;
 654
 655         if (_active_notes && _active_notes[note]) {
 656                 _active_notes[note]->property_x2() = trackview.editor.frame_to_pixel((nframes_t)end_time);
 657                 _active_notes[note]->property_outline_what() = (guint32) 0xF; // all edges
 658                 _active_notes[note] = NULL;
 659         }
 660 }
 661
 662
 663 /** Extend active notes to rightmost edge of region (if length is changed)
 664  */
 665 void
 666 MidiRegionView::extend_active_notes()
 667 {
 668         if (!_active_notes)
 669                 return;
 670
 671         for (unsigned i=0; i < 128; ++i)
 672                 if (_active_notes[i])
 673                         _active_notes[i]->property_x2() = trackview.editor.frame_to_pixel(_region->length());
 674 }
 675
 676
 677 /** Add a MIDI note to the view (with duration).
 678  *
 679  * If in sustained mode, notes with duration 0 will be considered active
 680  * notes, and resolve_note should be called when the corresponding note off
 681  * event arrives, to properly display the note.
 682  */
 683 void
 684 MidiRegionView::add_note(const boost::shared_ptr<Note> note)
 685 {
 686         assert(note->time() >= 0);
 687         assert(midi_view()->note_mode() == Sustained || midi_view()->note_mode() == Percussive);
 688
 689         // dont display notes beyond the region bounds
 690         if(
 691                         note->time() - _region->start() >= _region->length() ||
 692                         note->time() <  _region->start() ||
 693                         note->note() < midi_stream_view()->lowest_note() ||
 694                         note->note() > midi_stream_view()->highest_note()
 695           ) {
 696                 return;
 697         }
 698
 699         ArdourCanvas::Group* const group = (ArdourCanvas::Group*)get_canvas_group();
 700
 701         CanvasMidiEvent *event = 0;
 702
 703         const double x = trackview.editor.frame_to_pixel((nframes_t)note->time() - _region->start());
 704
 705         if (midi_view()->note_mode() == Sustained) {
 706
 707                 //cerr << "MRV::add_note sustained " << note->note() << " @ " << note->time()
 708                 //      << " .. " << note->end_time() << endl;
 709
 710                 const double y1 = midi_stream_view()->note_to_y(note->note());
 711                 const double note_endpixel =
 712                         trackview.editor.frame_to_pixel((nframes_t)note->end_time() - _region->start());
 713
 714                 CanvasNote* ev_rect = new CanvasNote(*this, *group, note);
 715                 ev_rect->property_x1() = x;
 716                 ev_rect->property_y1() = y1;
 717                 if (note->duration() > 0)
 718                         ev_rect->property_x2() = note_endpixel;
 719                 else
 720                         ev_rect->property_x2() = trackview.editor.frame_to_pixel(_region->length());
 721                 ev_rect->property_y2() = y1 + floor(midi_stream_view()->note_height());
 722
 723                 ev_rect->property_fill_color_rgba() = note_fill_color(note->velocity());
 724                 ev_rect->property_outline_color_rgba() = note_outline_color(note->velocity());
 725
 726                 if (note->duration() == 0) {
 727                         _active_notes[note->note()] = ev_rect;
 728                         /* outline all but right edge */
 729                         ev_rect->property_outline_what() = (guint32) (0x1 & 0x4 & 0x8);
 730                 } else {
 731                         /* outline all edges */
 732                         ev_rect->property_outline_what() = (guint32) 0xF;
 733                 }
 734
 735                 ev_rect->show();
 736                 _events.push_back(ev_rect);
 737                 event = ev_rect;
 738
 739                 MidiGhostRegion* gr;
 740
 741                 for (std::vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
 742                         if ((gr = dynamic_cast<MidiGhostRegion*>(*g)) != 0) {
 743                                 gr->add_note(ev_rect);
 744                         }
 745                 }
 746
 747         } else if (midi_view()->note_mode() == Percussive) {
 748
 749                 //cerr << "MRV::add_note percussive " << note->note() << " @ " << note->time()
 750                 //      << " .. " << note->end_time() << endl;
 751
 752                 const double diamond_size = midi_stream_view()->note_height() / 2.0;
 753                 const double y = midi_stream_view()->note_to_y(note->note()) + ((diamond_size-2) / 4.0);
 754
 755                 CanvasHit* ev_diamond = new CanvasHit(*this, *group, diamond_size);
 756                 ev_diamond->move(x, y);
 757                 ev_diamond->show();
 758                 ev_diamond->property_fill_color_rgba() = note_fill_color(note->velocity());
 759                 ev_diamond->property_outline_color_rgba() = note_outline_color(note->velocity());
 760                 _events.push_back(ev_diamond);
 761                 event = ev_diamond;
 762         } else {
 763                 event = 0;
 764         }
 765
 766         if(event) {
 767                 if(_marked_for_selection.find(event->note()) != _marked_for_selection.end()) {
 768                                 note_selected(event, true);
 769                 }
 770         }
 771 }
 772
 773 void
 774 MidiRegionView::delete_selection()
 775 {
 776         assert(_delta_command);
 777
 778         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i)
 779                 if ((*i)->selected())
 780                         _delta_command->remove((*i)->note());
 781
 782         _selection.clear();
 783 }
 784
 785 void
 786 MidiRegionView::clear_selection_except(ArdourCanvas::CanvasMidiEvent* ev)
 787 {
 788         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i)
 789                 if ((*i)->selected() && (*i) != ev)
 790                         (*i)->selected(false);
 791
 792         _selection.clear();
 793 }
 794
 795 void
 796 MidiRegionView::unique_select(ArdourCanvas::CanvasMidiEvent* ev)
 797 {
 798         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i)
 799                 if ((*i) != ev)
 800                         (*i)->selected(false);
 801
 802         _selection.clear();
 803         _selection.insert(ev);
 804
 805         if ( ! ev->selected())
 806                 ev->selected(true);
 807 }
 808
 809 void
 810 MidiRegionView::note_selected(ArdourCanvas::CanvasMidiEvent* ev, bool add)
 811 {
 812         if ( ! add)
 813                 clear_selection_except(ev);
 814
 815         _selection.insert(ev);
 816
 817         if ( ! ev->selected())
 818                 ev->selected(true);
 819 }
 820
 821
 822 void
 823 MidiRegionView::note_deselected(ArdourCanvas::CanvasMidiEvent* ev, bool add)
 824 {
 825         if ( ! add)
 826                 clear_selection_except(ev);
 827
 828         _selection.erase(ev);
 829
 830         if (ev->selected())
 831                 ev->selected(false);
 832 }
 833
 834
 835 void
 836 MidiRegionView::update_drag_selection(double x1, double x2, double y1, double y2)
 837 {
 838         const double last_y = std::min(y1, y2);
 839         const double y      = std::max(y1, y2);
 840
 841         // FIXME: so, so, so much slower than this should be
 842
 843         if (x1 < x2) {
 844                 for (std::vector<CanvasMidiEvent*>::iterator i = _events.begin(); i != _events.end(); ++i) {
 845                         if ((*i)->x1() >= x1 && (*i)->x1() <= x2 && (*i)->y1() >= last_y && (*i)->y1() <= y) {
 846                                 (*i)->selected(true);
 847                                 _selection.insert(*i);
 848                         } else {
 849                                 (*i)->selected(false);
 850                                 _selection.erase(*i);
 851                         }
 852                 }
 853         } else {
 854                 for (std::vector<CanvasMidiEvent*>::iterator i = _events.begin(); i != _events.end(); ++i) {
 855                         if ((*i)->x2() <= x1 && (*i)->x2() >= x2 && (*i)->y1() >= last_y && (*i)->y1() <= y) {
 856                                 (*i)->selected(true);
 857                                 _selection.insert(*i);
 858                         } else {
 859                                 (*i)->selected(false);
 860                                 _selection.erase(*i);
 861                         }
 862                 }
 863         }
 864 }
 865
 866
 867 void
 868 MidiRegionView::move_selection(double dx, double dy)
 869 {
 870         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i)
 871                 (*i)->move_event(dx, dy);
 872 }
 873
 874
 875 void
 876 MidiRegionView::note_dropped(CanvasMidiEvent* ev, double dt, uint8_t dnote)
 877 {
 878         // TODO: This would be faster/nicer with a MoveCommand that doesn't need to copy...
 879         if (_selection.find(ev) != _selection.end()) {
 880                 uint8_t lowest_note_in_selection  = midi_stream_view()->lowest_note();
 881                 uint8_t highest_note_in_selection = midi_stream_view()->highest_note();
 882                 uint8_t highest_note_difference = 0;
 883
 884                 // find highest and lowest notes first
 885                 for (Selection::iterator i = _selection.begin(); i != _selection.end() ; ) {
 886                         Selection::iterator next = i;
 887                         ++next;
 888
 889                         uint8_t pitch = (*i)->note()->note();
 890                         lowest_note_in_selection  = std::min(lowest_note_in_selection,  pitch);
 891                         highest_note_in_selection = std::max(highest_note_in_selection, pitch);
 892
 893                         i = next;
 894                 }
 895
 896                 /*
 897                 cerr << "dnote: " << (int) dnote << endl;
 898                 cerr << "lowest note (streamview): " << int(midi_stream_view()->lowest_note())
 899                      << " highest note (streamview): " << int(midi_stream_view()->highest_note()) << endl;
 900                 cerr << "lowest note (selection): " << int(lowest_note_in_selection) << " highest note(selection): "
 901                      << int(highest_note_in_selection) << endl;
 902                 cerr << "selection size: " << _selection.size() << endl;
 903                 cerr << "Highest note in selection: " << (int) highest_note_in_selection << endl;
 904                 */
 905
 906                 // Make sure the note pitch does not exceed the MIDI standard range
 907                 if (dnote <= 127 && (highest_note_in_selection + dnote > 127)) {
 908                         highest_note_difference = highest_note_in_selection - 127;
 909                 }
 910
 911                 start_delta_command(_("move notes"));
 912
 913                 for (Selection::iterator i = _selection.begin(); i != _selection.end() ; ) {
 914                         Selection::iterator next = i;
 915                         ++next;
 916
 917                         command_remove_note(*i);
 918                         const boost::shared_ptr<Note> copy(new Note(*(*i)->note().get()));
 919
 920                         // we need to snap here again in nframes_t in order to be sample accurate
 921                         double new_note_time = (*i)->note()->time();
 922                         new_note_time +=  dt;
 923
 924                         // keep notes inside region if dragged beyond left region bound
 925                         if(new_note_time < _region->start()) {
 926                                 new_note_time = _region->start();
 927                         }
 928
 929                         // since note time is region-absolute but snap_to_frame expects position-relative
 930                         // time we have to coordinate transform back and forth here.
 931                         new_note_time = snap_to_frame(nframes_t(new_note_time) - _region->start()) + _region->start();
 932
 933                         copy->set_time(new_note_time);
 934
 935                         uint8_t original_pitch = (*i)->note()->note();
 936                         uint8_t new_pitch =  original_pitch + dnote - highest_note_difference;
 937
 938                         // keep notes in standard midi range
 939                         clamp_0_to_127(new_pitch);
 940
 941                         //notes which are dragged beyond the standard midi range snap back to their original place
 942                         if((original_pitch != 0 && new_pitch == 0) || (original_pitch != 127 && new_pitch == 127)) {
 943                                 new_pitch = original_pitch;
 944                         }
 945
 946                         lowest_note_in_selection  = std::min(lowest_note_in_selection,  new_pitch);
 947                         highest_note_in_selection = std::max(highest_note_in_selection, new_pitch);
 948
 949                         copy->set_note(new_pitch);
 950
 951                         command_add_note(copy);
 952
 953                         _marked_for_selection.insert(copy);
 954                         i = next;
 955                 }
 956
 957                 apply_command();
 958
 959                 // care about notes being moved beyond the upper/lower bounds on the canvas
 960                 if(lowest_note_in_selection  < midi_stream_view()->lowest_note() ||
 961                    highest_note_in_selection > midi_stream_view()->highest_note()
 962                 ) {
 963                         midi_stream_view()->set_note_range(MidiStreamView::ContentsRange);
 964         }
 965 }
 966 }
 967
 968 nframes_t
 969 MidiRegionView::snap_to_frame(double x)
 970 {
 971         PublicEditor &editor = trackview.editor;
 972         // x is region relative
 973         // convert x to global frame
 974         nframes_t frame = editor.pixel_to_frame(x) + _region->position();
 975         editor.snap_to(frame);
 976         // convert event_frame back to local coordinates relative to position
 977         frame -= _region->position();
 978         return frame;
 979 }
 980
 981 nframes_t
 982 MidiRegionView::snap_to_frame(nframes_t x)
 983 {
 984         PublicEditor &editor = trackview.editor;
 985         // x is region relative
 986         // convert x to global frame
 987         nframes_t frame = x + _region->position();
 988         editor.snap_to(frame);
 989         // convert event_frame back to local coordinates relative to position
 990         frame -= _region->position();
 991         return frame;
 992 }
 993
 994 double
 995 MidiRegionView::snap_to_pixel(double x)
 996 {
 997         return (double) trackview.editor.frame_to_pixel(snap_to_frame(x));
 998 }
 999
1000 double
1001 MidiRegionView::get_position_pixels(void)
1002 {
1003         nframes_t  region_frame  = get_position();
1004         return trackview.editor.frame_to_pixel(region_frame);
1005 }
1006
1007 void
1008 MidiRegionView::begin_resizing(CanvasNote::NoteEnd note_end)
1009 {
1010         _resize_data.clear();
1011
1012         for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
1013                 CanvasNote *note = dynamic_cast<CanvasNote *> (*i);
1014
1015                 // only insert CanvasNotes into the map
1016                 if(note) {
1017                         NoteResizeData *resize_data = new NoteResizeData();
1018                         resize_data->canvas_note = note;
1019
1020                         // create a new SimpleRect from the note which will be the resize preview
1021                         SimpleRect *resize_rect =
1022                                 new SimpleRect(
1023                                                 *group,
1024                                                 note->x1(),
1025                                                 note->y1(),
1026                                                 note->x2(),
1027                                                 note->y2());
1028
1029                         // calculate the colors: get the color settings
1030                         uint fill_color =
1031                                 UINT_RGBA_CHANGE_A(
1032                                                 ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get(),
1033                                                 128);
1034
1035                         // make the resize preview notes more transparent and bright
1036                         fill_color = UINT_INTERPOLATE(fill_color, 0xFFFFFF40, 0.5);
1037
1038                         // calculate color based on note velocity
1039                         resize_rect->property_fill_color_rgba() =
1040                                 UINT_INTERPOLATE(
1041                                         note_fill_color(note->note()->velocity()),
1042                                         fill_color,
1043                                         0.85);
1044
1045                         resize_rect->property_outline_color_rgba() =
1046                                 ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get();
1047
1048                         resize_data->resize_rect = resize_rect;
1049
1050                         if(note_end == CanvasNote::NOTE_ON) {
1051                                 resize_data->current_x = note->x1();
1052                         } else { // NOTE_OFF
1053                                 resize_data->current_x = note->x2();
1054                         }
1055
1056                         _resize_data.push_back(resize_data);
1057                 }
1058         }
1059 }
1060
1061 void
1062 MidiRegionView::update_resizing(CanvasNote::NoteEnd note_end, double x, bool relative)
1063 {
1064         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
1065                 SimpleRect     *resize_rect = (*i)->resize_rect;
1066                 CanvasNote     *canvas_note = (*i)->canvas_note;
1067
1068                 const double region_start = get_position_pixels();
1069
1070                 if(relative) {
1071                         (*i)->current_x = (*i)->current_x + x;
1072                 } else {
1073                         // x is in track relative, transform it to region relative
1074                         (*i)->current_x = x - region_start;
1075                 }
1076
1077                 double current_x = (*i)->current_x;
1078
1079                 if(note_end == CanvasNote::NOTE_ON) {
1080                         resize_rect->property_x1() = snap_to_pixel(current_x);
1081                         resize_rect->property_x2() = canvas_note->x2();
1082                 } else {
1083                         resize_rect->property_x2() = snap_to_pixel(current_x);
1084                         resize_rect->property_x1() = canvas_note->x1();
1085                 }
1086         }
1087 }
1088
1089 void
1090 MidiRegionView::commit_resizing(CanvasNote::NoteEnd note_end, double event_x, bool relative)
1091 {
1092         start_delta_command(_("resize notes"));
1093
1094         for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
1095                 CanvasNote *canvas_note = (*i)->canvas_note;
1096                 SimpleRect *resize_rect = (*i)->resize_rect;
1097                 double      current_x   = (*i)->current_x;
1098                 const double position = get_position_pixels();
1099
1100                 if(!relative) {
1101                         // event_x is in track relative, transform it to region relative
1102                         current_x = event_x - position;
1103                 }
1104
1105                 // because snapping works on world coordinates we have to transform current_x
1106                 // to world coordinates before snapping and transform it back afterwards
1107                 nframes_t current_frame = snap_to_frame(current_x);
1108                 // transform to region start relative
1109                 current_frame += _region->start();
1110
1111                 const boost::shared_ptr<Note> copy(new Note(*(canvas_note->note().get())));
1112
1113                 // resize beginning of note
1114                 if (note_end == CanvasNote::NOTE_ON && current_frame < copy->end_time()) {
1115                         command_remove_note(canvas_note);
1116                         copy->on_event().time() = current_frame;
1117                         command_add_note(copy);
1118                         _marked_for_selection.insert(copy);
1119                 }
1120                 // resize end of note
1121                 if (note_end == CanvasNote::NOTE_OFF && current_frame > copy->time()) {
1122                         command_remove_note(canvas_note);
1123                         command_remove_note(canvas_note);
1124                         copy->off_event().time() = current_frame;
1125                         command_add_note(copy);
1126                         _marked_for_selection.insert(copy);
1127                 }
1128
1129                 delete resize_rect;
1130                 delete (*i);
1131         }
1132
1133         _resize_data.clear();
1134         apply_command();
1135 }
1136
1137
1138 void
1139 MidiRegionView::change_velocity(uint8_t velocity, bool relative)
1140 {
1141         start_delta_command(_("change velocity"));
1142         for (Selection::iterator i = _selection.begin(); i != _selection.end();) {
1143                 Selection::iterator next = i;
1144                 ++next;
1145
1146                 CanvasMidiEvent *event = *i;
1147                 const boost::shared_ptr<Note> copy(new Note(*(event->note().get())));
1148
1149                 if(relative) {
1150                         uint8_t new_velocity = copy->velocity() + velocity;
1151                         clamp_0_to_127(new_velocity);
1152
1153                         copy->set_velocity(new_velocity);
1154                 } else { // absolute
1155                         copy->set_velocity(velocity);
1156                 }
1157
1158                 command_remove_note(event);
1159                 command_add_note(copy);
1160
1161                 _marked_for_selection.insert(copy);
1162                 i = next;
1163         }
1164
1165         // dont keep notes selected if tweaking a single note
1166         if(_marked_for_selection.size() == 1) {
1167                 _marked_for_selection.clear();
1168         }
1169
1170         apply_command();
1171 }
1172
1173 void
1174 MidiRegionView::change_channel(uint8_t channel)
1175 {
1176         start_delta_command(_("change channel"));
1177         for (Selection::iterator i = _selection.begin(); i != _selection.end();) {
1178                 Selection::iterator next = i;
1179                 ++next;
1180
1181                 CanvasMidiEvent *event = *i;
1182                 const boost::shared_ptr<Note> copy(new Note(*(event->note().get())));
1183
1184                 copy->set_channel(channel);
1185
1186                 command_remove_note(event);
1187                 command_add_note(copy);
1188
1189                 _marked_for_selection.insert(copy);
1190                 i = next;
1191         }
1192
1193         // dont keep notes selected if tweaking a single note
1194         if(_marked_for_selection.size() == 1) {
1195                 _marked_for_selection.clear();
1196         }
1197
1198         apply_command();
1199 }
1200
1201
1202 void
1203 MidiRegionView::note_entered(ArdourCanvas::CanvasMidiEvent* ev)
1204 {
1205         if (ev->note() && _mouse_state == EraseTouchDragging) {
1206                 start_delta_command(_("note entered"));
1207                 ev->selected(true);
1208                 _delta_command->remove(ev->note());
1209         } else if (_mouse_state == SelectTouchDragging) {
1210                 note_selected(ev, true);
1211         }
1212 }
1213
1214
1215 void
1216 MidiRegionView::switch_source(boost::shared_ptr<Source> src)
1217 {
1218         boost::shared_ptr<MidiSource> msrc = boost::dynamic_pointer_cast<MidiSource>(src);
1219         if (msrc)
1220                 display_model(msrc->model());
1221 }
1222
1223 void
1224 MidiRegionView::set_frame_color()
1225 {
1226         if (frame) {
1227                 if (_selected && should_show_selection) {
1228                         frame->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_SelectedFrameBase.get();
1229                 } else {
1230                         frame->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiFrameBase.get();
1231                 }
1232         }
1233 }