gtk2_ardour/editor_drag.cc

   1 /*
   2     Copyright (C) 2009 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include <stdint.h>
  25 #include <algorithm>
  26
  27 #include "pbd/memento_command.h"
  28 #include "pbd/basename.h"
  29 #include "pbd/stateful_diff_command.h"
  30
  31 #include "gtkmm2ext/utils.h"
  32
  33 #include "ardour/audioengine.h"
  34 #include "ardour/audioregion.h"
  35 #include "ardour/audio_track.h"
  36 #include "ardour/dB.h"
  37 #include "ardour/midi_region.h"
  38 #include "ardour/midi_track.h"
  39 #include "ardour/operations.h"
  40 #include "ardour/region_factory.h"
  41 #include "ardour/session.h"
  42
  43 #include "canvas/canvas.h"
  44 #include "canvas/scroll_group.h"
  45
  46 #include "editor.h"
  47 #include "i18n.h"
  48 #include "keyboard.h"
  49 #include "audio_region_view.h"
  50 #include "automation_region_view.h"
  51 #include "midi_region_view.h"
  52 #include "ardour_ui.h"
  53 #include "gui_thread.h"
  54 #include "control_point.h"
  55 #include "region_gain_line.h"
  56 #include "editor_drag.h"
  57 #include "audio_time_axis.h"
  58 #include "midi_time_axis.h"
  59 #include "selection.h"
  60 #include "midi_selection.h"
  61 #include "automation_time_axis.h"
  62 #include "debug.h"
  63 #include "editor_cursors.h"
  64 #include "mouse_cursors.h"
  65 #include "note_base.h"
  66 #include "patch_change.h"
  67 #include "ui_config.h"
  68 #include "verbose_cursor.h"
  69
  70 using namespace std;
  71 using namespace ARDOUR;
  72 using namespace PBD;
  73 using namespace Gtk;
  74 using namespace Gtkmm2ext;
  75 using namespace Editing;
  76 using namespace ArdourCanvas;
  77
  78 using Gtkmm2ext::Keyboard;
  79
  80 double ControlPointDrag::_zero_gain_fraction = -1.0;
  81
  82 DragManager::DragManager (Editor* e)
  83         : _editor (e)
  84         , _ending (false)
  85         , _current_pointer_x (0.0)
  86         , _current_pointer_y (0.0)
  87         , _current_pointer_frame (0)
  88         , _old_follow_playhead (false)
  89 {
  90 }
  91
  92 DragManager::~DragManager ()
  93 {
  94         abort ();
  95 }
  96
  97 /** Call abort for each active drag */
  98 void
  99 DragManager::abort ()
 100 {
 101         _ending = true;
 102
 103         for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
 104                 (*i)->abort ();
 105                 delete *i;
 106         }
 107
 108         if (!_drags.empty ()) {
 109                 _editor->set_follow_playhead (_old_follow_playhead, false);
 110         }
 111
 112         _drags.clear ();
 113         _editor->abort_reversible_command();
 114
 115         _ending = false;
 116 }
 117
 118 void
 119 DragManager::add (Drag* d)
 120 {
 121         d->set_manager (this);
 122         _drags.push_back (d);
 123 }
 124
 125 void
 126 DragManager::set (Drag* d, GdkEvent* e, Gdk::Cursor* c)
 127 {
 128         d->set_manager (this);
 129         _drags.push_back (d);
 130         start_grab (e, c);
 131 }
 132
 133 void
 134 DragManager::start_grab (GdkEvent* e, Gdk::Cursor* c)
 135 {
 136         /* Prevent follow playhead during the drag to be nice to the user */
 137         _old_follow_playhead = _editor->follow_playhead ();
 138         _editor->set_follow_playhead (false);
 139
 140         _current_pointer_frame = _editor->canvas_event_sample (e, &_current_pointer_x, &_current_pointer_y);
 141
 142         for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
 143                 (*i)->start_grab (e, c);
 144         }
 145 }
 146
 147 /** Call end_grab for each active drag.
 148  *  @return true if any drag reported movement having occurred.
 149  */
 150 bool
 151 DragManager::end_grab (GdkEvent* e)
 152 {
 153         _ending = true;
 154
 155         bool r = false;
 156         for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
 157                 bool const t = (*i)->end_grab (e);
 158                 if (t) {
 159                         r = true;
 160                 }
 161                 delete *i;
 162         }
 163
 164         _drags.clear ();
 165
 166         _ending = false;
 167
 168         _editor->set_follow_playhead (_old_follow_playhead, false);
 169
 170         return r;
 171 }
 172
 173 void
 174 DragManager::mark_double_click ()
 175 {
 176         for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
 177                 (*i)->set_double_click (true);
 178         }
 179 }
 180
 181 bool
 182 DragManager::motion_handler (GdkEvent* e, bool from_autoscroll)
 183 {
 184         bool r = false;
 185
 186         /* calling this implies that we expect the event to have canvas
 187          * coordinates
 188          *
 189          * Can we guarantee that this is true?
 190          */
 191
 192         _current_pointer_frame = _editor->canvas_event_sample (e, &_current_pointer_x, &_current_pointer_y);
 193
 194         for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
 195                 bool const t = (*i)->motion_handler (e, from_autoscroll);
 196                 /* run all handlers; return true if at least one of them
 197                    returns true (indicating that the event has been handled).
 198                 */
 199                 if (t) {
 200                         r = true;
 201                 }
 202
 203         }
 204
 205         return r;
 206 }
 207
 208 bool
 209 DragManager::have_item (ArdourCanvas::Item* i) const
 210 {
 211         list<Drag*>::const_iterator j = _drags.begin ();
 212         while (j != _drags.end() && (*j)->item () != i) {
 213                 ++j;
 214         }
 215
 216         return j != _drags.end ();
 217 }
 218
 219 Drag::Drag (Editor* e, ArdourCanvas::Item* i, bool trackview_only)
 220         : _editor (e)
 221         , _drags (0)
 222         , _item (i)
 223         , _pointer_frame_offset (0)
 224         , _x_constrained (false)
 225         , _y_constrained (false)
 226         , _was_rolling (false)
 227         , _trackview_only (trackview_only)
 228         , _move_threshold_passed (false)
 229         , _starting_point_passed (false)
 230         , _initially_vertical (false)
 231         , _was_double_click (false)
 232         , _grab_x (0.0)
 233         , _grab_y (0.0)
 234         , _last_pointer_x (0.0)
 235         , _last_pointer_y (0.0)
 236         , _raw_grab_frame (0)
 237         , _grab_frame (0)
 238         , _last_pointer_frame (0)
 239         , _snap_delta (0)
 240 {
 241
 242 }
 243
 244 void
 245 Drag::swap_grab (ArdourCanvas::Item* new_item, Gdk::Cursor* cursor, uint32_t /*time*/)
 246 {
 247         _item->ungrab ();
 248         _item = new_item;
 249
 250         if (!_cursor_ctx) {
 251                 _cursor_ctx = CursorContext::create (*_editor, cursor);
 252         } else {
 253                 _cursor_ctx->change (cursor);
 254         }
 255
 256         _item->grab ();
 257 }
 258
 259 void
 260 Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
 261 {
 262
 263         /* we set up x/y dragging constraints on first move */
 264
 265         _raw_grab_frame = _editor->canvas_event_sample (event, &_grab_x, &_grab_y);
 266
 267         setup_pointer_frame_offset ();
 268         _grab_frame = adjusted_frame (_raw_grab_frame, event);
 269         _last_pointer_frame = _grab_frame;
 270         _last_pointer_x = _grab_x;
 271
 272         if (_trackview_only) {
 273                 _grab_y = _grab_y - _editor->get_trackview_group()->canvas_origin().y;
 274         }
 275
 276         _last_pointer_y = _grab_y;
 277
 278         _item->grab ();
 279
 280         if (!_editor->cursors()->is_invalid (cursor)) {
 281                 /* CAIROCANVAS need a variant here that passes *cursor */
 282                 _cursor_ctx = CursorContext::create (*_editor, cursor);
 283         }
 284
 285         if (_editor->session() && _editor->session()->transport_rolling()) {
 286                 _was_rolling = true;
 287         } else {
 288                 _was_rolling = false;
 289         }
 290
 291         switch (_editor->snap_type()) {
 292         case SnapToRegionStart:
 293         case SnapToRegionEnd:
 294         case SnapToRegionSync:
 295         case SnapToRegionBoundary:
 296                 _editor->build_region_boundary_cache ();
 297                 break;
 298         default:
 299                 break;
 300         }
 301 }
 302
 303 /** Call to end a drag `successfully'.  Ungrabs item and calls
 304  *  subclass' finished() method.
 305  *
 306  *  @param event GDK event, or 0.
 307  *  @return true if some movement occurred, otherwise false.
 308  */
 309 bool
 310 Drag::end_grab (GdkEvent* event)
 311 {
 312         _editor->stop_canvas_autoscroll ();
 313
 314         _item->ungrab ();
 315
 316         finished (event, _move_threshold_passed);
 317
 318         _editor->verbose_cursor()->hide ();
 319         _cursor_ctx.reset();
 320
 321         return _move_threshold_passed;
 322 }
 323
 324 framepos_t
 325 Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
 326 {
 327         framepos_t pos = 0;
 328
 329         if (f > _pointer_frame_offset) {
 330                 pos = f - _pointer_frame_offset;
 331         }
 332
 333         if (snap) {
 334                 _editor->snap_to_with_modifier (pos, event);
 335         }
 336
 337         return pos;
 338 }
 339
 340 framepos_t
 341 Drag::adjusted_current_frame (GdkEvent const * event, bool snap) const
 342 {
 343         return adjusted_frame (_drags->current_pointer_frame (), event, snap);
 344 }
 345
 346 frameoffset_t
 347 Drag::snap_delta (guint state) const
 348 {
 349         if (ArdourKeyboard::indicates_snap_delta (state)) {
 350                 return _snap_delta;
 351         }
 352
 353         return 0;
 354 }
 355
 356 double
 357 Drag::current_pointer_x() const
 358 {
 359         return _drags->current_pointer_x ();
 360 }
 361
 362 double
 363 Drag::current_pointer_y () const
 364 {
 365         if (!_trackview_only) {
 366                 return _drags->current_pointer_y ();
 367         }
 368
 369         return _drags->current_pointer_y () - _editor->get_trackview_group()->canvas_origin().y;
 370 }
 371
 372 void
 373 Drag::setup_snap_delta (framepos_t pos)
 374 {
 375         framepos_t temp = pos;
 376         _editor->snap_to (temp, ARDOUR::RoundNearest, false, true);
 377         _snap_delta = temp - pos;
 378 }
 379
 380 bool
 381 Drag::motion_handler (GdkEvent* event, bool from_autoscroll)
 382 {
 383         /* check to see if we have moved in any way that matters since the last motion event */
 384         if (_move_threshold_passed &&
 385             (!x_movement_matters() || _last_pointer_x == current_pointer_x ()) &&
 386             (!y_movement_matters() || _last_pointer_y == current_pointer_y ()) ) {
 387                 return false;
 388         }
 389
 390         pair<framecnt_t, int> const threshold = move_threshold ();
 391
 392         bool const old_move_threshold_passed = _move_threshold_passed;
 393
 394         if (!_move_threshold_passed) {
 395
 396                 bool const xp = (::llabs (_drags->current_pointer_frame () - _raw_grab_frame) >= threshold.first);
 397                 bool const yp = (::fabs ((current_pointer_y () - _grab_y)) >= threshold.second);
 398
 399                 _move_threshold_passed = ((xp && x_movement_matters()) || (yp && y_movement_matters()));
 400         }
 401
 402         if (active (_editor->mouse_mode) && _move_threshold_passed) {
 403
 404                 if (event->motion.state & Gdk::BUTTON1_MASK || event->motion.state & Gdk::BUTTON2_MASK) {
 405
 406                         if (old_move_threshold_passed != _move_threshold_passed) {
 407
 408                                 /* just changed */
 409
 410                                 if (fabs (current_pointer_y() - _grab_y) > fabs (current_pointer_x() - _grab_x)) {
 411                                         _initially_vertical = true;
 412                                 } else {
 413                                         _initially_vertical = false;
 414                                 }
 415                                 /** check constraints for this drag.
 416                                  *  Note that the current convention is to use "contains" for
 417                                  *  key modifiers during motion and "equals" when initiating a drag.
 418                                  *  In this case we haven't moved yet, so "equals" applies here.
 419                                  */
 420                                 if (Config->get_edit_mode() != Lock) {
 421                                         if (event->motion.state & Gdk::BUTTON2_MASK) {
 422                                                 // if dragging with button2, the motion is x constrained, with constraint modifier it is y constrained
 423                                                 if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::constraint_modifier ())) {
 424                                                         _x_constrained = false;
 425                                                         _y_constrained = true;
 426                                                 } else {
 427                                                         _x_constrained = true;
 428                                                         _y_constrained = false;
 429                                                 }
 430                                         } else if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::constraint_modifier ())) {
 431                                                 // if dragging normally, the motion is constrained to the first direction of movement.
 432                                                 if (_initially_vertical) {
 433                                                         _x_constrained = true;
 434                                                         _y_constrained = false;
 435                                                 } else {
 436                                                         _x_constrained = false;
 437                                                         _y_constrained = true;
 438                                                 }
 439                                         }
 440                                 } else {
 441                                         if (event->button.state & Gdk::BUTTON2_MASK) {
 442                                                 _x_constrained = false;
 443                                         } else {
 444                                                 _x_constrained = true;
 445                                         }
 446                                         _y_constrained = false;
 447                                 }
 448                         }
 449
 450                         if (!from_autoscroll) {
 451                                 _editor->maybe_autoscroll (true, allow_vertical_autoscroll (), false);
 452                         }
 453
 454                         if (!_editor->autoscroll_active() || from_autoscroll) {
 455
 456
 457                                 bool first_move = (_move_threshold_passed != old_move_threshold_passed) || from_autoscroll;
 458
 459                                 motion (event, first_move && !_starting_point_passed);
 460
 461                                 if (first_move && !_starting_point_passed) {
 462                                         _starting_point_passed = true;
 463                                 }
 464
 465                                 _last_pointer_x = _drags->current_pointer_x ();
 466                                 _last_pointer_y = current_pointer_y ();
 467                                 _last_pointer_frame = adjusted_current_frame (event, false);
 468                         }
 469
 470                         return true;
 471                 }
 472         }
 473
 474         return false;
 475 }
 476
 477 /** Call to abort a drag.  Ungrabs item and calls subclass's aborted () */
 478 void
 479 Drag::abort ()
 480 {
 481         if (_item) {
 482                 _item->ungrab ();
 483         }
 484
 485         aborted (_move_threshold_passed);
 486
 487         _editor->stop_canvas_autoscroll ();
 488         _editor->verbose_cursor()->hide ();
 489 }
 490
 491 void
 492 Drag::show_verbose_cursor_time (framepos_t frame)
 493 {
 494         _editor->verbose_cursor()->set_time (frame);
 495         _editor->verbose_cursor()->show ();
 496 }
 497
 498 void
 499 Drag::show_verbose_cursor_duration (framepos_t start, framepos_t end, double /*xoffset*/)
 500 {
 501         _editor->verbose_cursor()->set_duration (start, end);
 502         _editor->verbose_cursor()->show ();
 503 }
 504
 505 void
 506 Drag::show_verbose_cursor_text (string const & text)
 507 {
 508         _editor->verbose_cursor()->set (text);
 509         _editor->verbose_cursor()->show ();
 510 }
 511
 512 boost::shared_ptr<Region>
 513 Drag::add_midi_region (MidiTimeAxisView* view, bool commit)
 514 {
 515         if (_editor->session()) {
 516                 const TempoMap& map (_editor->session()->tempo_map());
 517                 framecnt_t pos = grab_frame();
 518                 const Meter& m = map.meter_at (pos);
 519                 /* not that the frame rate used here can be affected by pull up/down which
 520                    might be wrong.
 521                 */
 522                 framecnt_t len = m.frames_per_bar (map.tempo_at (pos), _editor->session()->frame_rate());
 523                 return view->add_region (grab_frame(), len, commit);
 524         }
 525
 526         return boost::shared_ptr<Region>();
 527 }
 528
 529 struct EditorOrderTimeAxisViewSorter {
 530         bool operator() (TimeAxisView* a, TimeAxisView* b) {
 531                 RouteTimeAxisView* ra = dynamic_cast<RouteTimeAxisView*> (a);
 532                 RouteTimeAxisView* rb = dynamic_cast<RouteTimeAxisView*> (b);
 533                 assert (ra && rb);
 534                 return ra->route()->order_key () < rb->route()->order_key ();
 535         }
 536 };
 537
 538 RegionDrag::RegionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
 539         : Drag (e, i)
 540         , _primary (p)
 541         , _ntracks (0)
 542 {
 543         _editor->visible_order_range (&_visible_y_low, &_visible_y_high);
 544
 545         /* Make a list of tracks to refer to during the drag; we include hidden tracks,
 546            as some of the regions we are dragging may be on such tracks.
 547         */
 548
 549         TrackViewList track_views = _editor->track_views;
 550         track_views.sort (EditorOrderTimeAxisViewSorter ());
 551
 552         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 553                 _time_axis_views.push_back (*i);
 554
 555                 TimeAxisView::Children children_list = (*i)->get_child_list ();
 556                 for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) {
 557                         _time_axis_views.push_back (j->get());
 558                 }
 559         }
 560
 561         /* the list of views can be empty at this point if this is a region list-insert drag
 562          */
 563
 564         for (list<RegionView*>::const_iterator i = v.begin(); i != v.end(); ++i) {
 565                 _views.push_back (DraggingView (*i, this, &(*i)->get_time_axis_view()));
 566         }
 567
 568         RegionView::RegionViewGoingAway.connect (death_connection, invalidator (*this), boost::bind (&RegionDrag::region_going_away, this, _1), gui_context());
 569 }
 570
 571 void
 572 RegionDrag::region_going_away (RegionView* v)
 573 {
 574         list<DraggingView>::iterator i = _views.begin ();
 575         while (i != _views.end() && i->view != v) {
 576                 ++i;
 577         }
 578
 579         if (i != _views.end()) {
 580                 _views.erase (i);
 581         }
 582 }
 583
 584 /** Given a TimeAxisView, return the index of it into the _time_axis_views vector,
 585  *  or -1 if it is not found.
 586  */
 587 int
 588 RegionDrag::find_time_axis_view (TimeAxisView* t) const
 589 {
 590         int i = 0;
 591         int const N = _time_axis_views.size ();
 592         while (i < N && _time_axis_views[i] != t) {
 593                 ++i;
 594         }
 595
 596         if (_time_axis_views[i] != t) {
 597                 return -1;
 598         }
 599
 600         return i;
 601 }
 602
 603 RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
 604         : RegionDrag (e, i, p, v)
 605         , _brushing (b)
 606         , _ignore_video_lock (false)
 607         , _total_x_delta (0)
 608         , _last_pointer_time_axis_view (0)
 609         , _last_pointer_layer (0)
 610         , _ndropzone (0)
 611         , _pdropzone (0)
 612         , _ddropzone (0)
 613 {
 614         DEBUG_TRACE (DEBUG::Drags, "New RegionMotionDrag\n");
 615 }
 616
 617 void
 618 RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 619 {
 620         Drag::start_grab (event, cursor);
 621         setup_snap_delta (_last_frame_position);
 622
 623         show_verbose_cursor_time (_last_frame_position);
 624
 625         pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (current_pointer_y ());
 626         if (tv.first) {
 627                 _last_pointer_time_axis_view = find_time_axis_view (tv.first);
 628                 assert(_last_pointer_time_axis_view >= 0);
 629                 _last_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
 630         }
 631
 632         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::TertiaryModifier))) {
 633                 _ignore_video_lock = true;
 634         }
 635
 636         if (_brushing) {
 637                 /* cross track dragging seems broken here. disabled for now. */
 638                 _y_constrained = true;
 639         }
 640 }
 641
 642 double
 643 RegionMotionDrag::compute_x_delta (GdkEvent const * event, framepos_t* pending_region_position)
 644 {
 645         /* compute the amount of pointer motion in frames, and where
 646            the region would be if we moved it by that much.
 647         */
 648         *pending_region_position = adjusted_frame (_drags->current_pointer_frame (), event, false);
 649
 650         framepos_t sync_frame;
 651         framecnt_t sync_offset;
 652         int32_t sync_dir;
 653
 654         sync_offset = _primary->region()->sync_offset (sync_dir);
 655
 656         /* we don't handle a sync point that lies before zero.
 657          */
 658         if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) {
 659
 660                 framecnt_t const sd = snap_delta (event->button.state);
 661                 sync_frame = *pending_region_position + (sync_dir * sync_offset) + sd;
 662
 663                 _editor->snap_to_with_modifier (sync_frame, event);
 664
 665                 *pending_region_position = _primary->region()->adjust_to_sync (sync_frame) - sd;
 666
 667         } else {
 668                 *pending_region_position = _last_frame_position;
 669         }
 670
 671         if (*pending_region_position > max_framepos - _primary->region()->length()) {
 672                 *pending_region_position = _last_frame_position;
 673         }
 674
 675         double dx = 0;
 676
 677         bool const x_move_allowed = !_x_constrained;
 678
 679         if ((*pending_region_position != _last_frame_position) && x_move_allowed) {
 680
 681                 /* x movement since last time (in pixels) */
 682                 dx = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->samples_per_pixel;
 683
 684                 /* total x movement */
 685                 framecnt_t total_dx = *pending_region_position;
 686                 if (regions_came_from_canvas()) {
 687                         total_dx = total_dx - grab_frame ();
 688                 }
 689
 690                 /* check that no regions have gone off the start of the session */
 691                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 692                         if ((i->view->region()->position() + total_dx) < 0) {
 693                                 dx = 0;
 694                                 *pending_region_position = _last_frame_position;
 695                                 break;
 696                         }
 697                 }
 698
 699         }
 700
 701         return dx;
 702 }
 703
 704 int
 705 RegionDrag::apply_track_delta (const int start, const int delta, const int skip, const bool distance_only) const
 706 {
 707         if (delta == 0) {
 708                 return start;
 709         }
 710
 711         const int tavsize  = _time_axis_views.size();
 712         const int dt = delta > 0 ? +1 : -1;
 713         int current  = start;
 714         int target   = start + delta - skip;
 715
 716         assert (current < 0 || current >= tavsize || !_time_axis_views[current]->hidden());
 717         assert (skip == 0 || (skip < 0 && delta < 0) || (skip > 0 && delta > 0));
 718
 719         while (current >= 0 && current != target) {
 720                 current += dt;
 721                 if (current < 0 && dt < 0) {
 722                         break;
 723                 }
 724                 if (current >= tavsize && dt > 0) {
 725                         break;
 726                 }
 727                 if (current < 0 || current >= tavsize) {
 728                         continue;
 729                 }
 730
 731                 RouteTimeAxisView const * rtav = dynamic_cast<RouteTimeAxisView const *> (_time_axis_views[current]);
 732                 if (_time_axis_views[current]->hidden() || !rtav || !rtav->is_track()) {
 733                         target += dt;
 734                 }
 735
 736                 if (distance_only && current == start + delta) {
 737                         break;
 738                 }
 739         }
 740         return target;
 741 }
 742
 743 bool
 744 RegionMotionDrag::y_movement_allowed (int delta_track, double delta_layer, int skip_invisible) const
 745 {
 746         if (_y_constrained) {
 747                 return false;
 748         }
 749
 750         const int tavsize  = _time_axis_views.size();
 751         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 752                 int n = apply_track_delta (i->time_axis_view, delta_track, skip_invisible);
 753                 assert (n < 0 || n >= tavsize || !_time_axis_views[n]->hidden());
 754
 755                 if (i->time_axis_view < 0 || i->time_axis_view >= tavsize) {
 756                         /* already in the drop zone */
 757                         if (delta_track >= 0) {
 758                                 /* downward motion - OK if others are still not in the dropzone */
 759                                 continue;
 760                         }
 761
 762                 }
 763
 764                 if (n < 0) {
 765                         /* off the top */
 766                         return false;
 767                 } else if (n >= tavsize) {
 768                         /* downward motion into drop zone. That's fine. */
 769                         continue;
 770                 }
 771
 772                 RouteTimeAxisView const * to = dynamic_cast<RouteTimeAxisView const *> (_time_axis_views[n]);
 773                 if (to == 0 || to->hidden() || !to->is_track() || to->track()->data_type() != i->view->region()->data_type()) {
 774                         /* not a track, or the wrong type */
 775                         return false;
 776                 }
 777
 778                 double const l = i->layer + delta_layer;
 779
 780                 /* Note that we allow layer to be up to 0.5 below zero, as this is used by `Expanded'
 781                    mode to allow the user to place a region below another on layer 0.
 782                 */
 783                 if (delta_track == 0 && (l < -0.5 || l >= int (to->view()->layers()))) {
 784                         /* Off the top or bottom layer; note that we only refuse if the track hasn't changed.
 785                            If it has, the layers will be munged later anyway, so it's ok.
 786                         */
 787                         return false;
 788                 }
 789         }
 790
 791         /* all regions being dragged are ok with this change */
 792         return true;
 793 }
 794
 795 struct DraggingViewSorter {
 796         bool operator() (const DraggingView& a, const DraggingView& b) {
 797                 return a.time_axis_view < b.time_axis_view;
 798         }
 799 };
 800
 801 void
 802 RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 803 {
 804         double delta_layer = 0;
 805         int delta_time_axis_view = 0;
 806         int current_pointer_time_axis_view = -1;
 807
 808         assert (!_views.empty ());
 809
 810         /* Note: time axis views in this method are often expressed as an index into the _time_axis_views vector */
 811
 812         /* Find the TimeAxisView that the pointer is now over */
 813         const double cur_y = current_pointer_y ();
 814         pair<TimeAxisView*, double> const r = _editor->trackview_by_y_position (cur_y);
 815         TimeAxisView* tv = r.first;
 816
 817         if (!tv && cur_y < 0) {
 818                 /* above trackview area, autoscroll hasn't moved us since last time, nothing to do */
 819                 return;
 820         }
 821
 822         /* find drop-zone y-position */
 823         Coord last_track_bottom_edge;
 824         last_track_bottom_edge = 0;
 825         for (std::vector<TimeAxisView*>::reverse_iterator t = _time_axis_views.rbegin(); t != _time_axis_views.rend(); ++t) {
 826                 if (!(*t)->hidden()) {
 827                         last_track_bottom_edge = (*t)->canvas_display()->canvas_origin ().y + (*t)->effective_height();
 828                         break;
 829                 }
 830         }
 831
 832         if (tv && tv->view()) {
 833                 /* the mouse is over a track */
 834                 double layer = r.second;
 835
 836                 if (first_move && tv->view()->layer_display() == Stacked) {
 837                         tv->view()->set_layer_display (Expanded);
 838                 }
 839
 840                 /* Here's the current pointer position in terms of time axis view and layer */
 841                 current_pointer_time_axis_view = find_time_axis_view (tv);
 842                 assert(current_pointer_time_axis_view >= 0);
 843
 844                 double const current_pointer_layer = tv->layer_display() == Overlaid ? 0 : layer;
 845
 846                 /* Work out the change in y */
 847
 848                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
 849                 if (!rtv || !rtv->is_track()) {
 850                         /* ignore busses early on. we can't move any regions on them */
 851                 } else if (_last_pointer_time_axis_view < 0) {
 852                         /* Was in the drop-zone, now over a track.
 853                          * Hence it must be an upward move (from the bottom)
 854                          *
 855                          * track_index is still -1, so delta must be set to
 856                          * move up the correct number of tracks from the bottom.
 857                          *
 858                          * This is necessary because steps may be skipped if
 859                          * the bottom-most track is not a valid target and/or
 860                          * if there are hidden tracks at the bottom.
 861                          * Hence the initial offset (_ddropzone) as well as the
 862                          * last valid pointer position (_pdropzone) need to be
 863                          * taken into account.
 864                          */
 865                         delta_time_axis_view = current_pointer_time_axis_view - _time_axis_views.size () + _ddropzone - _pdropzone;
 866                 } else {
 867                         delta_time_axis_view = current_pointer_time_axis_view - _last_pointer_time_axis_view;
 868                 }
 869
 870                 /* TODO needs adjustment per DraggingView,
 871                  *
 872                  * e.g. select one region on the top-layer of a track
 873                  * and one region which is at the bottom-layer of another track
 874                  * drag both.
 875                  *
 876                  * Indicated drop-zones and layering is wrong.
 877                  * and may infer additional layers on the target-track
 878                  * (depending how many layers the original track had).
 879                  *
 880                  * Or select two regions (different layers) on a same track,
 881                  * move across a non-layer track.. -> layering info is lost.
 882                  * on drop either of the regions may be on top.
 883                  *
 884                  * Proposed solution: screw it :) well,
 885                  *   don't use delta_layer, use an absolute value
 886                  *   1) remember DraggingView's layer  as float 0..1  [current layer / all layers of source]
 887                  *   2) calculate current mouse pos, y-pos inside track divided by height of mouse-over track.
 888                  *   3) iterate over all DraggingView, find the one that is over the track with most layers
 889                  *   4) proportionally scale layer to layers available on target
 890                  */
 891                 delta_layer = current_pointer_layer - _last_pointer_layer;
 892
 893         }
 894         /* for automation lanes, there is a TimeAxisView but no ->view()
 895          * if (!tv) -> dropzone
 896          */
 897         else if (!tv && cur_y >= 0 && _last_pointer_time_axis_view >= 0) {
 898                 /* Moving into the drop-zone.. */
 899                 delta_time_axis_view = _time_axis_views.size () - _last_pointer_time_axis_view;
 900                 /* delta_time_axis_view may not be sufficient to move into the DZ
 901                  * the mouse may enter it, but it may not be a valid move due to
 902                  * constraints.
 903                  *
 904                  * -> remember the delta needed to move into the dropzone
 905                  */
 906                 _ddropzone = delta_time_axis_view;
 907                 /* ..but subtract hidden tracks (or routes) at the bottom.
 908                  * we silently move mover them
 909                  */
 910                 _ddropzone -= apply_track_delta(_last_pointer_time_axis_view, delta_time_axis_view, 0, true)
 911                               - _time_axis_views.size();
 912         }
 913         else if (!tv && cur_y >= 0 && _last_pointer_time_axis_view < 0) {
 914                 /* move around inside the zone.
 915                  * This allows to move further down until all regions are in the zone.
 916                  */
 917                 const double ptr_y = cur_y + _editor->get_trackview_group()->canvas_origin().y;
 918                 assert(ptr_y >= last_track_bottom_edge);
 919                 assert(_ddropzone > 0);
 920
 921                 /* calculate mouse position in 'tracks' below last track. */
 922                 const double dzi_h = TimeAxisView::preset_height (HeightNormal);
 923                 uint32_t dzpos = _ddropzone + floor((1 + ptr_y - last_track_bottom_edge) / dzi_h);
 924
 925                 if (dzpos > _pdropzone && _ndropzone < _ntracks) {
 926                         // move further down
 927                         delta_time_axis_view =  dzpos - _pdropzone;
 928                 } else if (dzpos < _pdropzone && _ndropzone > 0) {
 929                         // move up inside the DZ
 930                         delta_time_axis_view =  dzpos - _pdropzone;
 931                 }
 932         }
 933
 934         /* Work out the change in x */
 935         framepos_t pending_region_position;
 936         double const x_delta = compute_x_delta (event, &pending_region_position);
 937         _last_frame_position = pending_region_position;
 938
 939         /* calculate hidden tracks in current y-axis delta */
 940         int delta_skip = 0;
 941         if (_last_pointer_time_axis_view < 0 && _pdropzone > 0) {
 942                 /* The mouse is more than one track below the dropzone.
 943                  * distance calculation is not needed (and would not work, either
 944                  * because the dropzone is "packed").
 945                  *
 946                  * Except when [partially] moving regions out of dropzone in a large step.
 947                  * (the mouse may or may not remain in the DZ)
 948                  * Hidden tracks at the bottom of the TAV need to be skipped.
 949                  *
 950                  * This also handles the case if the mouse entered the DZ
 951                  * in a large step (exessive delta), either due to fast-movement,
 952                  * autoscroll, laggy UI. _ddropzone copensates for that (see "move into dz" above)
 953                  */
 954                 if (delta_time_axis_view < 0 && (int)_ddropzone - delta_time_axis_view >= (int)_pdropzone) {
 955                         const int dt = delta_time_axis_view + (int)_pdropzone - (int)_ddropzone;
 956                         assert(dt <= 0);
 957                         delta_skip = apply_track_delta(_time_axis_views.size(), dt, 0, true)
 958                                 -_time_axis_views.size() - dt;
 959                 }
 960         }
 961         else if (_last_pointer_time_axis_view < 0) {
 962                 /* Moving out of the zone. Check for hidden tracks at the bottom. */
 963                 delta_skip = apply_track_delta(_time_axis_views.size(), delta_time_axis_view, 0, true)
 964                              -_time_axis_views.size() - delta_time_axis_view;
 965         } else {
 966                 /* calculate hidden tracks that are skipped by the pointer movement */
 967                 delta_skip = apply_track_delta(_last_pointer_time_axis_view, delta_time_axis_view, 0, true)
 968                              - _last_pointer_time_axis_view
 969                              - delta_time_axis_view;
 970         }
 971
 972         /* Verify change in y */
 973         if (!y_movement_allowed (delta_time_axis_view, delta_layer, delta_skip)) {
 974                 /* this y movement is not allowed, so do no y movement this time */
 975                 delta_time_axis_view = 0;
 976                 delta_layer = 0;
 977                 delta_skip = 0;
 978         }
 979
 980         if (x_delta == 0 && (tv && tv->view() && delta_time_axis_view == 0) && delta_layer == 0 && !first_move) {
 981                 /* haven't reached next snap point, and we're not switching
 982                    trackviews nor layers. nothing to do.
 983                 */
 984                 return;
 985         }
 986
 987         typedef map<boost::shared_ptr<Playlist>, double> PlaylistDropzoneMap;
 988         PlaylistDropzoneMap playlist_dropzone_map;
 989         _ndropzone = 0; // number of elements currently in the dropzone
 990
 991         if (first_move) {
 992                 /* sort views by time_axis.
 993                  * This retains track order in the dropzone, regardless
 994                  * of actual selection order
 995                  */
 996                 _views.sort (DraggingViewSorter());
 997
 998                 /* count number of distinct tracks of all regions
 999                  * being dragged, used for dropzone.
1000                  */
1001                 int prev_track = -1;
1002                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1003                         if (i->time_axis_view != prev_track) {
1004                                 prev_track = i->time_axis_view;
1005                                 ++_ntracks;
1006                         }
1007                 }
1008 #ifndef NDEBUG
1009                 int spread =
1010                         _views.back().time_axis_view -
1011                         _views.front().time_axis_view;
1012
1013                 spread -= apply_track_delta (_views.front().time_axis_view, spread, 0, true)
1014                           -  _views.back().time_axis_view;
1015
1016                 printf("Dragging region(s) from %d different track(s), max dist: %d\n", _ntracks, spread);
1017 #endif
1018         }
1019
1020         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
1021
1022                 RegionView* rv = i->view;
1023                 double y_delta;
1024
1025                 y_delta = 0;
1026
1027                 if (rv->region()->locked() || (rv->region()->video_locked() && !_ignore_video_lock)) {
1028                         continue;
1029                 }
1030
1031                 if (first_move) {
1032                         rv->drag_start ();
1033
1034                         /* reparent the regionview into a group above all
1035                          * others
1036                          */
1037
1038                         ArdourCanvas::Item* rvg = rv->get_canvas_group();
1039                         Duple rv_canvas_offset = rvg->parent()->canvas_origin ();
1040                         Duple dmg_canvas_offset = _editor->_drag_motion_group->canvas_origin ();
1041                         rv->get_canvas_group()->reparent (_editor->_drag_motion_group);
1042                         /* move the item so that it continues to appear at the
1043                            same location now that its parent has changed.
1044                            */
1045                         rvg->move (rv_canvas_offset - dmg_canvas_offset);
1046                 }
1047
1048                 /* If we have moved tracks, we'll fudge the layer delta so that the
1049                    region gets moved back onto layer 0 on its new track; this avoids
1050                    confusion when dragging regions from non-zero layers onto different
1051                    tracks.
1052                 */
1053                 double this_delta_layer = delta_layer;
1054                 if (delta_time_axis_view != 0) {
1055                         this_delta_layer = - i->layer;
1056                 }
1057
1058                 int this_delta_time_axis_view = apply_track_delta(i->time_axis_view, delta_time_axis_view, delta_skip) - i->time_axis_view;
1059
1060                 int track_index = i->time_axis_view + this_delta_time_axis_view;
1061                 assert(track_index >= 0);
1062
1063                 if (track_index < 0 || track_index >= (int) _time_axis_views.size()) {
1064                         /* Track is in the Dropzone */
1065
1066                         i->time_axis_view = track_index;
1067                         assert(i->time_axis_view >= (int) _time_axis_views.size());
1068                         if (cur_y >= 0) {
1069
1070                                 double yposition = 0;
1071                                 PlaylistDropzoneMap::iterator pdz = playlist_dropzone_map.find (i->view->region()->playlist());
1072                                 rv->set_height (TimeAxisView::preset_height (HeightNormal));
1073                                 ++_ndropzone;
1074
1075                                 /* store index of each new playlist as a negative count, starting at -1 */
1076
1077                                 if (pdz == playlist_dropzone_map.end()) {
1078                                         /* compute where this new track (which doesn't exist yet) will live
1079                                            on the y-axis.
1080                                         */
1081                                         yposition = last_track_bottom_edge; /* where to place the top edge of the regionview */
1082
1083                                         /* How high is this region view ? */
1084
1085                                         boost::optional<ArdourCanvas::Rect> obbox = rv->get_canvas_group()->bounding_box ();
1086                                         ArdourCanvas::Rect bbox;
1087
1088                                         if (obbox) {
1089                                                 bbox = obbox.get ();
1090                                         }
1091
1092                                         last_track_bottom_edge += bbox.height();
1093
1094                                         playlist_dropzone_map.insert (make_pair (i->view->region()->playlist(), yposition));
1095
1096                                 } else {
1097                                         yposition = pdz->second;
1098                                 }
1099
1100                                 /* values are zero or negative, hence the use of min() */
1101                                 y_delta = yposition - rv->get_canvas_group()->canvas_origin().y;
1102                         }
1103
1104                 } else {
1105
1106                         /* The TimeAxisView that this region is now over */
1107                         TimeAxisView* current_tv = _time_axis_views[track_index];
1108
1109                         /* Ensure it is moved from stacked -> expanded if appropriate */
1110                         if (current_tv->view()->layer_display() == Stacked) {
1111                                 current_tv->view()->set_layer_display (Expanded);
1112                         }
1113
1114                         /* We're only allowed to go -ve in layer on Expanded views */
1115                         if (current_tv->view()->layer_display() != Expanded && (i->layer + this_delta_layer) < 0) {
1116                                 this_delta_layer = - i->layer;
1117                         }
1118
1119                         /* Set height */
1120                         rv->set_height (current_tv->view()->child_height ());
1121
1122                         /* Update show/hidden status as the region view may have come from a hidden track,
1123                            or have moved to one.
1124                         */
1125                         if (current_tv->hidden ()) {
1126                                 rv->get_canvas_group()->hide ();
1127                         } else {
1128                                 rv->get_canvas_group()->show ();
1129                         }
1130
1131                         /* Update the DraggingView */
1132                         i->time_axis_view = track_index;
1133                         i->layer += this_delta_layer;
1134
1135                         if (_brushing) {
1136                                 _editor->mouse_brush_insert_region (rv, pending_region_position);
1137                         } else {
1138                                 Duple track_origin;
1139
1140                                 /* Get the y coordinate of the top of the track that this region is now over */
1141                                 track_origin = current_tv->canvas_display()->item_to_canvas (track_origin);
1142
1143                                 /* And adjust for the layer that it should be on */
1144                                 StreamView* cv = current_tv->view ();
1145                                 switch (cv->layer_display ()) {
1146                                 case Overlaid:
1147                                         break;
1148                                 case Stacked:
1149                                         track_origin.y += (cv->layers() - i->layer - 1) * cv->child_height ();
1150                                         break;
1151                                 case Expanded:
1152                                         track_origin.y += (cv->layers() - i->layer - 0.5) * 2 * cv->child_height ();
1153                                         break;
1154                                 }
1155
1156                                 /* need to get the parent of the regionview
1157                                  * canvas group and get its position in
1158                                  * equivalent coordinate space as the trackview
1159                                  * we are now dragging over.
1160                                  */
1161
1162                                 y_delta = track_origin.y - rv->get_canvas_group()->canvas_origin().y;
1163
1164                         }
1165                 }
1166
1167                 /* Now move the region view */
1168                 rv->move (x_delta, y_delta);
1169
1170         } /* foreach region */
1171
1172         _total_x_delta += x_delta;
1173
1174         if (x_delta != 0 && !_brushing) {
1175                 show_verbose_cursor_time (_last_frame_position);
1176         }
1177
1178         /* keep track of pointer movement */
1179         if (tv) {
1180                 /* the pointer is currently over a time axis view */
1181
1182                 if (_last_pointer_time_axis_view < 0) {
1183                         /* last motion event was not over a time axis view
1184                          * or last y-movement out of the dropzone was not valid
1185                          */
1186                         int dtz = 0;
1187                         if (delta_time_axis_view < 0) {
1188                                 /* in the drop zone, moving up */
1189
1190                                 /* _pdropzone is the last known pointer y-axis position inside the DZ.
1191                                  * We do not use negative _last_pointer_time_axis_view because
1192                                  * the dropzone is "packed" (the actual track offset is ignored)
1193                                  *
1194                                  * As opposed to the actual number
1195                                  * of elements in the dropzone (_ndropzone)
1196                                  * _pdropzone is not constrained. This is necessary
1197                                  * to allow moving multiple regions with y-distance
1198                                  * into the DZ.
1199                                  *
1200                                  * There can be 0 elements in the dropzone,
1201                                  * even though the drag-pointer is inside the DZ.
1202                                  *
1203                                  * example:
1204                                  * [ Audio-track, Midi-track, Audio-track, DZ ]
1205                                  * move regions from both audio tracks at the same time into the
1206                                  * DZ by grabbing the region in the bottom track.
1207                                  */
1208                                 assert(current_pointer_time_axis_view >= 0);
1209                                 dtz = std::min((int)_pdropzone, (int)_ddropzone - delta_time_axis_view);
1210                                 _pdropzone -= dtz;
1211                         }
1212
1213                         /* only move out of the zone if the movement is OK */
1214                         if (_pdropzone == 0 && delta_time_axis_view != 0) {
1215                                 assert(delta_time_axis_view < 0);
1216                                 _last_pointer_time_axis_view = current_pointer_time_axis_view;
1217                                 /* if all logic and maths are correct, there is no need to assign the 'current' pointer.
1218                                  * the current position can be calculated as follows:
1219                                  */
1220                                 // a well placed oofus attack can still throw this off.
1221                                 // likley auto-scroll related, printf() debugging may tell, commented out for now.
1222                                 //assert (current_pointer_time_axis_view == _time_axis_views.size() - dtz + _ddropzone + delta_time_axis_view);
1223                         }
1224                 } else {
1225                         /* last motion event was also over a time axis view */
1226                         _last_pointer_time_axis_view += delta_time_axis_view;
1227                         assert(_last_pointer_time_axis_view >= 0);
1228                 }
1229
1230         } else {
1231
1232                 /* the pointer is not over a time axis view */
1233                 assert ((delta_time_axis_view > 0) || (((int)_pdropzone) >= (delta_skip - delta_time_axis_view)));
1234                 _pdropzone += delta_time_axis_view - delta_skip;
1235                 _last_pointer_time_axis_view = -1; // <0 : we're in the zone, value does not matter.
1236         }
1237
1238         _last_pointer_layer += delta_layer;
1239 }
1240
1241 void
1242 RegionMoveDrag::motion (GdkEvent* event, bool first_move)
1243 {
1244         if (_copy && first_move) {
1245                 if (_x_constrained && !_brushing) {
1246                         _editor->begin_reversible_command (Operations::fixed_time_region_copy);
1247                 } else if (!_brushing) {
1248                         _editor->begin_reversible_command (Operations::region_copy);
1249                 } else if (_brushing) {
1250                         _editor->begin_reversible_command (Operations::drag_region_brush);
1251                 }
1252                 /* duplicate the regionview(s) and region(s) */
1253
1254                 list<DraggingView> new_regionviews;
1255
1256                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1257
1258                         RegionView* rv = i->view;
1259                         AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
1260                         MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
1261
1262                         const boost::shared_ptr<const Region> original = rv->region();
1263                         boost::shared_ptr<Region> region_copy = RegionFactory::create (original, true);
1264                         region_copy->set_position (original->position());
1265                         /* need to set this so that the drop zone code can work. This doesn't
1266                            actually put the region into the playlist, but just sets a weak pointer
1267                            to it.
1268                         */
1269                         region_copy->set_playlist (original->playlist());
1270
1271                         RegionView* nrv;
1272                         if (arv) {
1273                                 boost::shared_ptr<AudioRegion> audioregion_copy
1274                                 = boost::dynamic_pointer_cast<AudioRegion>(region_copy);
1275
1276                                 nrv = new AudioRegionView (*arv, audioregion_copy);
1277                         } else if (mrv) {
1278                                 boost::shared_ptr<MidiRegion> midiregion_copy
1279                                         = boost::dynamic_pointer_cast<MidiRegion>(region_copy);
1280                                 nrv = new MidiRegionView (*mrv, midiregion_copy);
1281                         } else {
1282                                 continue;
1283                         }
1284
1285                         nrv->get_canvas_group()->show ();
1286                         new_regionviews.push_back (DraggingView (nrv, this, i->initial_time_axis_view));
1287
1288                         /* swap _primary to the copy */
1289
1290                         if (rv == _primary) {
1291                                 _primary = nrv;
1292                         }
1293
1294                         /* ..and deselect the one we copied */
1295
1296                         rv->set_selected (false);
1297                 }
1298
1299                 if (!new_regionviews.empty()) {
1300
1301                         /* reflect the fact that we are dragging the copies */
1302
1303                         _views = new_regionviews;
1304
1305                         swap_grab (new_regionviews.front().view->get_canvas_group (), 0, event ? event->motion.time : 0);
1306                 }
1307
1308         } else if (!_copy && first_move) {
1309                 if (_x_constrained && !_brushing) {
1310                         _editor->begin_reversible_command (_("fixed time region drag"));
1311                 } else if (!_brushing) {
1312                         _editor->begin_reversible_command (Operations::region_drag);
1313                 } else if (_brushing) {
1314                         _editor->begin_reversible_command (Operations::drag_region_brush);
1315                 }
1316         }
1317         RegionMotionDrag::motion (event, first_move);
1318 }
1319
1320 void
1321 RegionMotionDrag::finished (GdkEvent *, bool)
1322 {
1323         for (vector<TimeAxisView*>::iterator i = _time_axis_views.begin(); i != _time_axis_views.end(); ++i) {
1324                 if (!(*i)->view()) {
1325                         continue;
1326                 }
1327
1328                 if ((*i)->view()->layer_display() == Expanded) {
1329                         (*i)->view()->set_layer_display (Stacked);
1330                 }
1331         }
1332 }
1333
1334 void
1335 RegionMoveDrag::finished (GdkEvent* ev, bool movement_occurred)
1336 {
1337         RegionMotionDrag::finished (ev, movement_occurred);
1338
1339         if (!movement_occurred) {
1340
1341                 /* just a click */
1342
1343                 if (was_double_click() && !_views.empty()) {
1344                         DraggingView dv = _views.front();
1345                         dv.view->show_region_editor ();
1346
1347                 }
1348
1349                 return;
1350         }
1351
1352         assert (!_views.empty ());
1353
1354         /* We might have hidden region views so that they weren't visible during the drag
1355            (when they have been reparented).  Now everything can be shown again, as region
1356            views are back in their track parent groups.
1357         */
1358         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
1359                 i->view->get_canvas_group()->show ();
1360         }
1361
1362         bool const changed_position = (_last_frame_position != _primary->region()->position());
1363         bool const changed_tracks = (_time_axis_views[_views.front().time_axis_view] != &_views.front().view->get_time_axis_view());
1364         framecnt_t const drag_delta = _primary->region()->position() - _last_frame_position;
1365
1366         if (_copy) {
1367
1368                 finished_copy (
1369                         changed_position,
1370                         changed_tracks,
1371                         drag_delta
1372                         );
1373
1374         } else {
1375
1376                 finished_no_copy (
1377                         changed_position,
1378                         changed_tracks,
1379                         drag_delta
1380                         );
1381
1382         }
1383
1384         _editor->maybe_locate_with_edit_preroll (_editor->get_selection().regions.start());
1385 }
1386
1387 RouteTimeAxisView*
1388 RegionMoveDrag::create_destination_time_axis (boost::shared_ptr<Region> region, TimeAxisView* original)
1389 {
1390         /* Add a new track of the correct type, and return the RouteTimeAxisView that is created to display the
1391            new track.
1392          */
1393
1394         try {
1395                 if (boost::dynamic_pointer_cast<AudioRegion> (region)) {
1396                         list<boost::shared_ptr<AudioTrack> > audio_tracks;
1397                         uint32_t output_chan = region->n_channels();
1398                         if ((Config->get_output_auto_connect() & AutoConnectMaster) && _editor->session()->master_out()) {
1399                                 output_chan =  _editor->session()->master_out()->n_inputs().n_audio();
1400                         }
1401                         audio_tracks = _editor->session()->new_audio_track (region->n_channels(), output_chan, ARDOUR::Normal, 0, 1, region->name());
1402                         RouteTimeAxisView* rtav = _editor->axis_view_from_route (audio_tracks.front());
1403                         if (rtav) {
1404                                 rtav->set_height (original->current_height());
1405                         }
1406                         return rtav;
1407                 } else {
1408                         ChanCount one_midi_port (DataType::MIDI, 1);
1409                         list<boost::shared_ptr<MidiTrack> > midi_tracks;
1410                         midi_tracks = _editor->session()->new_midi_track (one_midi_port, one_midi_port, boost::shared_ptr<ARDOUR::PluginInfo>(), ARDOUR::Normal, 0, 1, region->name());
1411                         RouteTimeAxisView* rtav = _editor->axis_view_from_route (midi_tracks.front());
1412                         if (rtav) {
1413                                 rtav->set_height (original->current_height());
1414                         }
1415                         return rtav;
1416                 }
1417         } catch (...) {
1418                 error << _("Could not create new track after region placed in the drop zone") << endmsg;
1419                 return 0;
1420         }
1421 }
1422
1423 void
1424 RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, framecnt_t const drag_delta)
1425 {
1426         RegionSelection new_views;
1427         PlaylistSet modified_playlists;
1428         RouteTimeAxisView* new_time_axis_view = 0;
1429
1430         if (_brushing) {
1431                 /* all changes were made during motion event handlers */
1432
1433                 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
1434                         delete i->view;
1435                 }
1436
1437                 _editor->commit_reversible_command ();
1438                 return;
1439         }
1440
1441         typedef map<boost::shared_ptr<Playlist>, RouteTimeAxisView*> PlaylistMapping;
1442         PlaylistMapping playlist_mapping;
1443
1444         /* insert the regions into their new playlists */
1445         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end();) {
1446
1447                 RouteTimeAxisView* dest_rtv = 0;
1448
1449                 if (i->view->region()->locked() || (i->view->region()->video_locked() && !_ignore_video_lock)) {
1450                         continue;
1451                 }
1452
1453                 framepos_t where;
1454
1455                 if (changed_position && !_x_constrained) {
1456                         where = i->view->region()->position() - drag_delta;
1457                 } else {
1458                         where = i->view->region()->position();
1459                 }
1460
1461                 if (i->time_axis_view < 0 || i->time_axis_view >= (int)_time_axis_views.size()) {
1462                         /* dragged to drop zone */
1463
1464                         PlaylistMapping::iterator pm;
1465
1466                         if ((pm = playlist_mapping.find (i->view->region()->playlist())) == playlist_mapping.end()) {
1467                                 /* first region from this original playlist: create a new track */
1468                                 new_time_axis_view = create_destination_time_axis (i->view->region(), i->initial_time_axis_view);
1469                                 playlist_mapping.insert (make_pair (i->view->region()->playlist(), new_time_axis_view));
1470                                 dest_rtv = new_time_axis_view;
1471                         } else {
1472                                 /* we already created a new track for regions from this playlist, use it */
1473                                 dest_rtv = pm->second;
1474                         }
1475                 } else {
1476                         /* destination time axis view is the one we dragged to */
1477                         dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]);
1478                 }
1479
1480                 if (dest_rtv != 0) {
1481                         RegionView* new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where, modified_playlists);
1482                         if (new_view != 0) {
1483                                 new_views.push_back (new_view);
1484                         }
1485                 }
1486
1487                 /* Delete the copy of the view that was used for dragging. Need to play safe with the iterator
1488                    since deletion will automagically remove it from _views, thus invalidating i as an iterator.
1489                  */
1490
1491                 list<DraggingView>::const_iterator next = i;
1492                 ++next;
1493                 delete i->view;
1494                 i = next;
1495         }
1496
1497         /* If we've created new regions either by copying or moving
1498            to a new track, we want to replace the old selection with the new ones
1499         */
1500
1501         if (new_views.size() > 0) {
1502                 _editor->selection->set (new_views);
1503         }
1504
1505         /* write commands for the accumulated diffs for all our modified playlists */
1506         add_stateful_diff_commands_for_playlists (modified_playlists);
1507
1508         _editor->commit_reversible_command ();
1509 }
1510
1511 void
1512 RegionMoveDrag::finished_no_copy (
1513         bool const changed_position,
1514         bool const changed_tracks,
1515         framecnt_t const drag_delta
1516         )
1517 {
1518         RegionSelection new_views;
1519         PlaylistSet modified_playlists;
1520         PlaylistSet frozen_playlists;
1521         set<RouteTimeAxisView*> views_to_update;
1522         RouteTimeAxisView* new_time_axis_view = 0;
1523
1524         typedef map<boost::shared_ptr<Playlist>, RouteTimeAxisView*> PlaylistMapping;
1525         PlaylistMapping playlist_mapping;
1526
1527         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ) {
1528
1529                 RegionView* rv = i->view;
1530                 RouteTimeAxisView* dest_rtv = 0;
1531
1532                 if (rv->region()->locked() || (rv->region()->video_locked() && !_ignore_video_lock)) {
1533                         ++i;
1534                         continue;
1535                 }
1536
1537                 if (i->time_axis_view < 0 || i->time_axis_view >= (int)_time_axis_views.size()) {
1538                         /* dragged to drop zone */
1539
1540                         PlaylistMapping::iterator pm;
1541
1542                         if ((pm = playlist_mapping.find (i->view->region()->playlist())) == playlist_mapping.end()) {
1543                                 /* first region from this original playlist: create a new track */
1544                                 new_time_axis_view = create_destination_time_axis (i->view->region(), i->initial_time_axis_view);
1545                                 playlist_mapping.insert (make_pair (i->view->region()->playlist(), new_time_axis_view));
1546                                 dest_rtv = new_time_axis_view;
1547                         } else {
1548                                 /* we already created a new track for regions from this playlist, use it */
1549                                 dest_rtv = pm->second;
1550                         }
1551
1552                 } else {
1553                         /* destination time axis view is the one we dragged to */
1554                         dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]);
1555                 }
1556
1557                 assert (dest_rtv);
1558
1559                 double const dest_layer = i->layer;
1560
1561                 views_to_update.insert (dest_rtv);
1562
1563                 framepos_t where;
1564
1565                 if (changed_position && !_x_constrained) {
1566                         where = rv->region()->position() - drag_delta;
1567                 } else {
1568                         where = rv->region()->position();
1569                 }
1570
1571                 if (changed_tracks) {
1572
1573                         /* insert into new playlist */
1574
1575                         RegionView* new_view = insert_region_into_playlist (
1576                                 RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where, modified_playlists
1577                                 );
1578
1579                         if (new_view == 0) {
1580                                 ++i;
1581                                 continue;
1582                         }
1583
1584                         new_views.push_back (new_view);
1585
1586                         /* remove from old playlist */
1587
1588                         /* the region that used to be in the old playlist is not
1589                            moved to the new one - we use a copy of it. as a result,
1590                            any existing editor for the region should no longer be
1591                            visible.
1592                         */
1593                         rv->hide_region_editor();
1594
1595
1596                         remove_region_from_playlist (rv->region(), i->initial_playlist, modified_playlists);
1597
1598                 } else {
1599
1600                         boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
1601
1602                         /* this movement may result in a crossfade being modified, or a layering change,
1603                            so we need to get undo data from the playlist as well as the region.
1604                         */
1605
1606                         pair<PlaylistSet::iterator, bool> r = modified_playlists.insert (playlist);
1607                         if (r.second) {
1608                                 playlist->clear_changes ();
1609                         }
1610
1611                         rv->region()->clear_changes ();
1612
1613                         /*
1614                            motion on the same track. plonk the previously reparented region
1615                            back to its original canvas group (its streamview).
1616                            No need to do anything for copies as they are fake regions which will be deleted.
1617                         */
1618
1619                         rv->get_canvas_group()->reparent (dest_rtv->view()->canvas_item());
1620                         rv->get_canvas_group()->set_y_position (i->initial_y);
1621                         rv->drag_end ();
1622
1623                         /* just change the model */
1624                         if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
1625                                 playlist->set_layer (rv->region(), dest_layer);
1626                         }
1627
1628                         /* freeze playlist to avoid lots of relayering in the case of a multi-region drag */
1629
1630                         r = frozen_playlists.insert (playlist);
1631
1632                         if (r.second) {
1633                                 playlist->freeze ();
1634                         }
1635
1636                         rv->region()->set_position (where);
1637                         _editor->session()->add_command (new StatefulDiffCommand (rv->region()));
1638                 }
1639
1640                 if (changed_tracks) {
1641
1642                         /* OK, this is where it gets tricky. If the playlist was being used by >1 tracks, and the region
1643                            was selected in all of them, then removing it from a playlist will have removed all
1644                            trace of it from _views (i.e. there were N regions selected, we removed 1,
1645                            but since its the same playlist for N tracks, all N tracks updated themselves, removed the
1646                            corresponding regionview, and _views is now empty).
1647
1648                            This could have invalidated any and all iterators into _views.
1649
1650                            The heuristic we use here is: if the region selection is empty, break out of the loop
1651                            here. if the region selection is not empty, then restart the loop because we know that
1652                            we must have removed at least the region(view) we've just been working on as well as any
1653                            that we processed on previous iterations.
1654
1655                            EXCEPT .... if we are doing a copy drag, then _views hasn't been modified and
1656                            we can just iterate.
1657                         */
1658
1659
1660                         if (_views.empty()) {
1661                                 break;
1662                         } else {
1663                                 i = _views.begin();
1664                         }
1665
1666                 } else {
1667                         ++i;
1668                 }
1669         }
1670
1671         /* If we've created new regions either by copying or moving
1672            to a new track, we want to replace the old selection with the new ones
1673         */
1674
1675         if (new_views.size() > 0) {
1676                 _editor->selection->set (new_views);
1677         }
1678
1679         for (set<boost::shared_ptr<Playlist> >::iterator p = frozen_playlists.begin(); p != frozen_playlists.end(); ++p) {
1680                 (*p)->thaw();
1681         }
1682
1683         /* write commands for the accumulated diffs for all our modified playlists */
1684         add_stateful_diff_commands_for_playlists (modified_playlists);
1685         /* applies to _brushing */
1686         _editor->commit_reversible_command ();
1687
1688         /* We have futzed with the layering of canvas items on our streamviews.
1689            If any region changed layer, this will have resulted in the stream
1690            views being asked to set up their region views, and all will be well.
1691            If not, we might now have badly-ordered region views.  Ask the StreamViews
1692            involved to sort themselves out, just in case.
1693         */
1694
1695         for (set<RouteTimeAxisView*>::iterator i = views_to_update.begin(); i != views_to_update.end(); ++i) {
1696                 (*i)->view()->playlist_layered ((*i)->track ());
1697         }
1698 }
1699
1700 /** Remove a region from a playlist, clearing the diff history of the playlist first if necessary.
1701  *  @param region Region to remove.
1702  *  @param playlist playlist To remove from.
1703  *  @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
1704  *  that clear_changes () is only called once per playlist.
1705  */
1706 void
1707 RegionMoveDrag::remove_region_from_playlist (
1708         boost::shared_ptr<Region> region,
1709         boost::shared_ptr<Playlist> playlist,
1710         PlaylistSet& modified_playlists
1711         )
1712 {
1713         pair<set<boost::shared_ptr<Playlist> >::iterator, bool> r = modified_playlists.insert (playlist);
1714
1715         if (r.second) {
1716                 playlist->clear_changes ();
1717         }
1718
1719         playlist->remove_region (region); // should be no need to ripple; we better already have rippled the playlist in RegionRippleDrag
1720 }
1721
1722
1723 /** Insert a region into a playlist, handling the recovery of the resulting new RegionView, and
1724  *  clearing the playlist's diff history first if necessary.
1725  *  @param region Region to insert.
1726  *  @param dest_rtv Destination RouteTimeAxisView.
1727  *  @param dest_layer Destination layer.
1728  *  @param where Destination position.
1729  *  @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
1730  *  that clear_changes () is only called once per playlist.
1731  *  @return New RegionView, or 0 if no insert was performed.
1732  */
1733 RegionView *
1734 RegionMoveDrag::insert_region_into_playlist (
1735         boost::shared_ptr<Region> region,
1736         RouteTimeAxisView* dest_rtv,
1737         layer_t dest_layer,
1738         framecnt_t where,
1739         PlaylistSet& modified_playlists
1740         )
1741 {
1742         boost::shared_ptr<Playlist> dest_playlist = dest_rtv->playlist ();
1743         if (!dest_playlist) {
1744                 return 0;
1745         }
1746
1747         /* arrange to collect the new region view that will be created as a result of our playlist insertion */
1748         _new_region_view = 0;
1749         sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &RegionMoveDrag::collect_new_region_view));
1750
1751         /* clear history for the playlist we are about to insert to, provided we haven't already done so */
1752         pair<PlaylistSet::iterator, bool> r = modified_playlists.insert (dest_playlist);
1753         if (r.second) {
1754                 dest_playlist->clear_changes ();
1755         }
1756
1757         dest_playlist->add_region (region, where);
1758
1759         if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
1760                 dest_playlist->set_layer (region, dest_layer);
1761         }
1762
1763         c.disconnect ();
1764
1765         assert (_new_region_view);
1766
1767         return _new_region_view;
1768 }
1769
1770 void
1771 RegionMoveDrag::collect_new_region_view (RegionView* rv)
1772 {
1773         _new_region_view = rv;
1774 }
1775
1776 void
1777 RegionMoveDrag::add_stateful_diff_commands_for_playlists (PlaylistSet const & playlists)
1778 {
1779         for (PlaylistSet::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
1780                 StatefulDiffCommand* c = new StatefulDiffCommand (*i);
1781                 if (!c->empty()) {
1782                         _editor->session()->add_command (c);
1783                 } else {
1784                         delete c;
1785                 }
1786         }
1787 }
1788
1789
1790 void
1791 RegionMoveDrag::aborted (bool movement_occurred)
1792 {
1793         if (_copy) {
1794
1795                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end();) {
1796                         list<DraggingView>::const_iterator next = i;
1797                         ++next;
1798                         delete i->view;
1799                         i = next;
1800                 }
1801
1802                 _views.clear ();
1803
1804         } else {
1805                 RegionMotionDrag::aborted (movement_occurred);
1806         }
1807 }
1808
1809 void
1810 RegionMotionDrag::aborted (bool)
1811 {
1812         for (vector<TimeAxisView*>::iterator i = _time_axis_views.begin(); i != _time_axis_views.end(); ++i) {
1813
1814                 StreamView* sview = (*i)->view();
1815
1816                 if (sview) {
1817                         if (sview->layer_display() == Expanded) {
1818                                 sview->set_layer_display (Stacked);
1819                         }
1820                 }
1821         }
1822
1823         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1824                 RegionView* rv = i->view;
1825                 TimeAxisView* tv = &(rv->get_time_axis_view ());
1826                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
1827                 assert (rtv);
1828                 rv->get_canvas_group()->reparent (rtv->view()->canvas_item());
1829                 rv->get_canvas_group()->set_y_position (0);
1830                 rv->drag_end ();
1831                 rv->move (-_total_x_delta, 0);
1832                 rv->set_height (rtv->view()->child_height ());
1833         }
1834 }
1835
1836 /** @param b true to brush, otherwise false.
1837  *  @param c true to make copies of the regions being moved, otherwise false.
1838  */
1839 RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b, bool c)
1840         : RegionMotionDrag (e, i, p, v, b)
1841         , _copy (c)
1842         , _new_region_view (0)
1843 {
1844         DEBUG_TRACE (DEBUG::Drags, "New RegionMoveDrag\n");
1845
1846         double speed = 1;
1847         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&_primary->get_time_axis_view ());
1848         if (rtv && rtv->is_track()) {
1849                 speed = rtv->track()->speed ();
1850         }
1851
1852         _last_frame_position = static_cast<framepos_t> (_primary->region()->position() / speed);
1853 }
1854
1855 void
1856 RegionMoveDrag::setup_pointer_frame_offset ()
1857 {
1858         _pointer_frame_offset = raw_grab_frame() - _last_frame_position;
1859 }
1860
1861 RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, framepos_t pos)
1862         : RegionMotionDrag (e, 0, 0, list<RegionView*> (), false)
1863 {
1864         DEBUG_TRACE (DEBUG::Drags, "New RegionInsertDrag\n");
1865
1866         assert ((boost::dynamic_pointer_cast<AudioRegion> (r) && dynamic_cast<AudioTimeAxisView*> (v)) ||
1867                 (boost::dynamic_pointer_cast<MidiRegion> (r) && dynamic_cast<MidiTimeAxisView*> (v)));
1868
1869         _primary = v->view()->create_region_view (r, false, false);
1870
1871         _primary->get_canvas_group()->show ();
1872         _primary->set_position (pos, 0);
1873         _views.push_back (DraggingView (_primary, this, v));
1874
1875         _last_frame_position = pos;
1876
1877         _item = _primary->get_canvas_group ();
1878 }
1879
1880 void
1881 RegionInsertDrag::finished (GdkEvent *, bool)
1882 {
1883         int pos = _views.front().time_axis_view;
1884         assert(pos >= 0 && pos < (int)_time_axis_views.size());
1885
1886         RouteTimeAxisView* dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[pos]);
1887
1888         _primary->get_canvas_group()->reparent (dest_rtv->view()->canvas_item());
1889         _primary->get_canvas_group()->set_y_position (0);
1890
1891         boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
1892
1893         _editor->begin_reversible_command (Operations::insert_region);
1894         playlist->clear_changes ();
1895         playlist->add_region (_primary->region (), _last_frame_position);
1896
1897         // Mixbus doesn't seem to ripple when inserting regions from the list: should we? yes, probably
1898         if (Config->get_edit_mode() == Ripple) {
1899                 playlist->ripple (_last_frame_position, _primary->region()->length(), _primary->region());
1900         }
1901
1902         _editor->session()->add_command (new StatefulDiffCommand (playlist));
1903         _editor->commit_reversible_command ();
1904
1905         delete _primary;
1906         _primary = 0;
1907         _views.clear ();
1908 }
1909
1910 void
1911 RegionInsertDrag::aborted (bool)
1912 {
1913         delete _primary;
1914         _primary = 0;
1915         _views.clear ();
1916 }
1917
1918 RegionSpliceDrag::RegionSpliceDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
1919         : RegionMoveDrag (e, i, p, v, false, false)
1920 {
1921         DEBUG_TRACE (DEBUG::Drags, "New RegionSpliceDrag\n");
1922 }
1923
1924 struct RegionSelectionByPosition {
1925         bool operator() (RegionView*a, RegionView* b) {
1926                 return a->region()->position () < b->region()->position();
1927         }
1928 };
1929
1930 void
1931 RegionSpliceDrag::motion (GdkEvent* event, bool)
1932 {
1933         /* Which trackview is this ? */
1934
1935         pair<TimeAxisView*, double> const tvp = _editor->trackview_by_y_position (current_pointer_y ());
1936         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
1937
1938         /* The region motion is only processed if the pointer is over
1939            an audio track.
1940         */
1941
1942         if (!tv || !tv->is_track()) {
1943                 /* To make sure we hide the verbose canvas cursor when the mouse is
1944                    not held over an audio track.
1945                 */
1946                 _editor->verbose_cursor()->hide ();
1947                 return;
1948         } else {
1949                 _editor->verbose_cursor()->show ();
1950         }
1951
1952         int dir;
1953
1954         if ((_drags->current_pointer_x() - last_pointer_x()) > 0) {
1955                 dir = 1;
1956         } else {
1957                 dir = -1;
1958         }
1959
1960         RegionSelection copy;
1961         _editor->selection->regions.by_position(copy);
1962
1963         framepos_t const pf = adjusted_current_frame (event);
1964
1965         for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
1966
1967                 RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*> (&(*i)->get_time_axis_view());
1968
1969                 if (!atv) {
1970                         continue;
1971                 }
1972
1973                 boost::shared_ptr<Playlist> playlist;
1974
1975                 if ((playlist = atv->playlist()) == 0) {
1976                         continue;
1977                 }
1978
1979                 if (!playlist->region_is_shuffle_constrained ((*i)->region())) {
1980                         continue;
1981                 }
1982
1983                 if (dir > 0) {
1984                         if (pf < (*i)->region()->last_frame() + 1) {
1985                                 continue;
1986                         }
1987                 } else {
1988                         if (pf > (*i)->region()->first_frame()) {
1989                                 continue;
1990                         }
1991                 }
1992
1993
1994                 playlist->shuffle ((*i)->region(), dir);
1995         }
1996 }
1997
1998 void
1999 RegionSpliceDrag::finished (GdkEvent* event, bool movement_occurred)
2000 {
2001         RegionMoveDrag::finished (event, movement_occurred);
2002 }
2003
2004 void
2005 RegionSpliceDrag::aborted (bool)
2006 {
2007         /* XXX: TODO */
2008 }
2009
2010 /***
2011  * ripple mode...
2012  */
2013
2014 void
2015 RegionRippleDrag::add_all_after_to_views(TimeAxisView *tav, framepos_t where, const RegionSelection &exclude, bool drag_in_progress)
2016 {
2017
2018         boost::shared_ptr<RegionList> rl = tav->playlist()->regions_with_start_within (Evoral::Range<framepos_t>(where, max_framepos));
2019
2020         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(tav);
2021         RegionSelection to_ripple;
2022         for (RegionList::iterator i = rl->begin(); i != rl->end(); ++i) {
2023                 if ((*i)->position() >= where) {
2024                         to_ripple.push_back (rtv->view()->find_view(*i));
2025                 }
2026         }
2027
2028         for (RegionSelection::iterator i = to_ripple.begin(); i != to_ripple.end(); ++i) {
2029                 if (!exclude.contains (*i)) {
2030                         // the selection has already been added to _views
2031
2032                         if (drag_in_progress) {
2033                                 // do the same things that RegionMotionDrag::motion does when
2034                                 // first_move is true, for the region views that we're adding
2035                                 // to _views this time
2036
2037                                 (*i)->drag_start();
2038                                 ArdourCanvas::Item* rvg = (*i)->get_canvas_group();
2039                                 Duple rv_canvas_offset = rvg->item_to_canvas (Duple (0,0));
2040                                 Duple dmg_canvas_offset = _editor->_drag_motion_group->canvas_origin ();
2041                                 rvg->reparent (_editor->_drag_motion_group);
2042
2043                                 // we only need to move in the y direction
2044                                 Duple fudge = rv_canvas_offset - dmg_canvas_offset;
2045                                 fudge.x = 0;
2046                                 rvg->move (fudge);
2047
2048                         }
2049                         _views.push_back (DraggingView (*i, this, tav));
2050                 }
2051         }
2052 }
2053
2054 void
2055 RegionRippleDrag::remove_unselected_from_views(framecnt_t amount, bool move_regions)
2056 {
2057
2058         for (std::list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ) {
2059                 // we added all the regions after the selection
2060
2061                 std::list<DraggingView>::iterator to_erase = i++;
2062                 if (!_editor->selection->regions.contains (to_erase->view)) {
2063                         // restore the non-selected regions to their original playlist & positions,
2064                         // and then ripple them back by the length of the regions that were dragged away
2065                         // do the same things as RegionMotionDrag::aborted
2066
2067                         RegionView *rv = to_erase->view;
2068                         TimeAxisView* tv = &(rv->get_time_axis_view ());
2069                         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
2070                         assert (rtv);
2071
2072                         // plonk them back onto their own track
2073                         rv->get_canvas_group()->reparent(rtv->view()->canvas_item());
2074                         rv->get_canvas_group()->set_y_position (0);
2075                         rv->drag_end ();
2076
2077                         if (move_regions) {
2078                                 // move the underlying region to match the view
2079                                 rv->region()->set_position (rv->region()->position() + amount);
2080                         } else {
2081                                 // restore the view to match the underlying region's original position
2082                                 rv->move(-amount, 0);   // second parameter is y delta - seems 0 is OK
2083                         }
2084
2085                         rv->set_height (rtv->view()->child_height ());
2086                         _views.erase (to_erase);
2087                 }
2088         }
2089 }
2090
2091 bool
2092 RegionRippleDrag::y_movement_allowed (int delta_track, double delta_layer, int skip_invisible) const
2093 {
2094         if (RegionMotionDrag::y_movement_allowed (delta_track, delta_layer, skip_invisible)) {
2095                 if (delta_track) {
2096                         return allow_moves_across_tracks;
2097                 } else {
2098                         return true;
2099                 }
2100         }
2101         return false;
2102 }
2103
2104 RegionRippleDrag::RegionRippleDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
2105         : RegionMoveDrag (e, i, p, v, false, false)
2106 {
2107         DEBUG_TRACE (DEBUG::Drags, "New RegionRippleDrag\n");
2108         // compute length of selection
2109         RegionSelection selected_regions = _editor->selection->regions;
2110         selection_length = selected_regions.end_frame() - selected_regions.start();
2111
2112         // we'll only allow dragging to another track in ripple mode if all the regions
2113         // being dragged start off on the same track
2114         allow_moves_across_tracks = (selected_regions.playlists().size() == 1);
2115         prev_tav = NULL;
2116         prev_amount = 0;
2117         exclude = new RegionList;
2118         for (RegionSelection::iterator i =selected_regions.begin(); i != selected_regions.end(); ++i) {
2119                 exclude->push_back((*i)->region());
2120         }
2121
2122         // also add regions before start of selection to exclude, to be consistent with how Mixbus does ripple
2123         RegionSelection copy;
2124         selected_regions.by_position(copy); // get selected regions sorted by position into copy
2125
2126         std::set<boost::shared_ptr<ARDOUR::Playlist> > playlists = copy.playlists();
2127         std::set<boost::shared_ptr<ARDOUR::Playlist> >::const_iterator pi;
2128
2129         for (pi = playlists.begin(); pi != playlists.end(); ++pi) {
2130                 // find ripple start point on each applicable playlist
2131                 RegionView *first_selected_on_this_track = NULL;
2132                 for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
2133                         if ((*i)->region()->playlist() == (*pi)) {
2134                                 // region is on this playlist - it's the first, because they're sorted
2135                                 first_selected_on_this_track = *i;
2136                                 break;
2137                         }
2138                 }
2139                 assert (first_selected_on_this_track); // we should always find the region in one of the playlists...
2140                 add_all_after_to_views (
2141                                 &first_selected_on_this_track->get_time_axis_view(),
2142                                 first_selected_on_this_track->region()->position(),
2143                                 selected_regions, false);
2144         }
2145
2146         if (allow_moves_across_tracks) {
2147                 orig_tav = &(*selected_regions.begin())->get_time_axis_view();
2148         } else {
2149                 orig_tav = NULL;
2150         }
2151
2152 }
2153
2154 void
2155 RegionRippleDrag::motion (GdkEvent* event, bool first_move)
2156 {
2157         /* Which trackview is this ? */
2158
2159         pair<TimeAxisView*, double> const tvp = _editor->trackview_by_y_position (current_pointer_y ());
2160         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
2161
2162         /* The region motion is only processed if the pointer is over
2163            an audio track.
2164          */
2165
2166         if (!tv || !tv->is_track()) {
2167                 /* To make sure we hide the verbose canvas cursor when the mouse is
2168                    not held over an audiotrack.
2169                  */
2170                 _editor->verbose_cursor()->hide ();
2171                 return;
2172         }
2173
2174         framepos_t where = adjusted_current_frame (event);
2175         assert (where >= 0);
2176         framepos_t after;
2177         double delta = compute_x_delta (event, &after);
2178
2179         framecnt_t amount = _editor->pixel_to_sample (delta);
2180
2181         if (allow_moves_across_tracks) {
2182                 // all the originally selected regions were on the same track
2183
2184                 framecnt_t adjust = 0;
2185                 if (prev_tav && tv != prev_tav) {
2186                         // dragged onto a different track
2187                         // remove the unselected regions from _views, restore them to their original positions
2188                         // and add the regions after the drop point on the new playlist to _views instead.
2189                         // undo the effect of rippling the previous playlist, and include the effect of removing
2190                         // the dragged region(s) from this track
2191
2192                         remove_unselected_from_views (prev_amount, false);
2193                         // ripple previous playlist according to the regions that have been removed onto the new playlist
2194                         prev_tav->playlist()->ripple(prev_position, -selection_length, exclude);
2195                         prev_amount = 0;
2196
2197                         // move just the selected regions
2198                         RegionMoveDrag::motion(event, first_move);
2199
2200                         // ensure that the ripple operation on the new playlist inserts selection_length time
2201                         adjust = selection_length;
2202                         // ripple the new current playlist
2203                         tv->playlist()->ripple (where, amount+adjust, exclude);
2204
2205                         // add regions after point where drag entered this track to subsequent ripples
2206                         add_all_after_to_views (tv, where, _editor->selection->regions, true);
2207
2208                 } else {
2209                         // motion on same track
2210                         RegionMoveDrag::motion(event, first_move);
2211                 }
2212                 prev_tav = tv;
2213
2214                 // remember what we've done to this playlist so we can undo it if the selection is dragged to another track
2215                 prev_position = where;
2216         } else {
2217                 // selection encompasses multiple tracks - just drag
2218                 // cross-track drags are forbidden
2219                 RegionMoveDrag::motion(event, first_move);
2220         }
2221
2222         if (!_x_constrained) {
2223                 prev_amount += amount;
2224         }
2225
2226         _last_frame_position = after;
2227 }
2228
2229 void
2230 RegionRippleDrag::finished (GdkEvent* event, bool movement_occurred)
2231 {
2232         if (!movement_occurred) {
2233
2234                 /* just a click */
2235
2236                 if (was_double_click() && !_views.empty()) {
2237                         DraggingView dv = _views.front();
2238                         dv.view->show_region_editor ();
2239
2240                 }
2241
2242                 return;
2243         }
2244
2245         _editor->begin_reversible_command(_("Ripple drag"));
2246
2247         // remove the regions being rippled from the dragging view, updating them to
2248         // their new positions
2249         remove_unselected_from_views (prev_amount, true);
2250
2251         if (allow_moves_across_tracks) {
2252                 if (orig_tav) {
2253                         // if regions were dragged across tracks, we've rippled any later
2254                         // regions on the track the regions were dragged off, so we need
2255                         // to add the original track to the undo record
2256                         orig_tav->playlist()->clear_changes();
2257                         vector<Command*> cmds;
2258                         orig_tav->playlist()->rdiff (cmds);
2259                         _editor->session()->add_commands (cmds);
2260                 }
2261                 if (prev_tav && prev_tav != orig_tav) {
2262                         prev_tav->playlist()->clear_changes();
2263                         vector<Command*> cmds;
2264                         prev_tav->playlist()->rdiff (cmds);
2265                         _editor->session()->add_commands (cmds);
2266                 }
2267         } else {
2268                 // selection spanned multiple tracks - all will need adding to undo record
2269
2270                 std::set<boost::shared_ptr<ARDOUR::Playlist> > playlists = _editor->selection->regions.playlists();
2271                 std::set<boost::shared_ptr<ARDOUR::Playlist> >::const_iterator pi;
2272
2273                 for (pi = playlists.begin(); pi != playlists.end(); ++pi) {
2274                         (*pi)->clear_changes();
2275                         vector<Command*> cmds;
2276                         (*pi)->rdiff (cmds);
2277                         _editor->session()->add_commands (cmds);
2278                 }
2279         }
2280
2281         // other modified playlists are added to undo by RegionMoveDrag::finished()
2282         RegionMoveDrag::finished (event, movement_occurred);
2283         _editor->commit_reversible_command();
2284 }
2285
2286 void
2287 RegionRippleDrag::aborted (bool movement_occurred)
2288 {
2289         RegionMoveDrag::aborted (movement_occurred);
2290         _views.clear ();
2291 }
2292
2293
2294 RegionCreateDrag::RegionCreateDrag (Editor* e, ArdourCanvas::Item* i, TimeAxisView* v)
2295         : Drag (e, i),
2296           _view (dynamic_cast<MidiTimeAxisView*> (v))
2297 {
2298         DEBUG_TRACE (DEBUG::Drags, "New RegionCreateDrag\n");
2299
2300         assert (_view);
2301 }
2302
2303 void
2304 RegionCreateDrag::motion (GdkEvent* event, bool first_move)
2305 {
2306         if (first_move) {
2307                 _editor->begin_reversible_command (_("create region"));
2308                 _region = add_midi_region (_view, false);
2309                 _view->playlist()->freeze ();
2310         } else {
2311                 if (_region) {
2312                         framepos_t const f = adjusted_current_frame (event);
2313                         if (f < grab_frame()) {
2314                                 _region->set_initial_position (f);
2315                         }
2316
2317                         /* Don't use a zero-length region, and subtract 1 frame from the snapped length
2318                            so that if this region is duplicated, its duplicate starts on
2319                            a snap point rather than 1 frame after a snap point.  Otherwise things get
2320                            a bit confusing as if a region starts 1 frame after a snap point, one cannot
2321                            place snapped notes at the start of the region.
2322                         */
2323
2324                         framecnt_t const len = (framecnt_t) fabs ((double)(f - grab_frame () - 1));
2325                         _region->set_length (len < 1 ? 1 : len);
2326                 }
2327         }
2328 }
2329
2330 void
2331 RegionCreateDrag::finished (GdkEvent*, bool movement_occurred)
2332 {
2333         if (!movement_occurred) {
2334                 add_midi_region (_view, true);
2335         } else {
2336                 _view->playlist()->thaw ();
2337                 _editor->commit_reversible_command();
2338         }
2339 }
2340
2341 void
2342 RegionCreateDrag::aborted (bool)
2343 {
2344         if (_region) {
2345                 _view->playlist()->thaw ();
2346         }
2347
2348         /* XXX */
2349 }
2350
2351 NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i)
2352         : Drag (e, i)
2353         , region (0)
2354         , relative (false)
2355         , at_front (true)
2356         , _was_selected (false)
2357         , _snap_delta (0)
2358 {
2359         DEBUG_TRACE (DEBUG::Drags, "New NoteResizeDrag\n");
2360 }
2361
2362 void
2363 NoteResizeDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*ignored*/)
2364 {
2365         Gdk::Cursor* cursor;
2366         NoteBase* cnote = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
2367         assert (cnote);
2368         float x_fraction = cnote->mouse_x_fraction ();
2369
2370         if (x_fraction > 0.0 && x_fraction < 0.25) {
2371                 cursor = _editor->cursors()->left_side_trim;
2372                 at_front = true;
2373         } else  {
2374                 cursor = _editor->cursors()->right_side_trim;
2375                 at_front = false;
2376         }
2377
2378         Drag::start_grab (event, cursor);
2379
2380         region = &cnote->region_view();
2381
2382         double temp;
2383         temp = region->snap_to_pixel (cnote->x0 (), true);
2384         _snap_delta = temp - cnote->x0 ();
2385
2386         _item->grab ();
2387
2388         if (event->motion.state & ArdourKeyboard::note_size_relative_modifier ()) {
2389                 relative = false;
2390         } else {
2391                 relative = true;
2392         }
2393         MidiRegionSelection& ms (_editor->get_selection().midi_regions);
2394         if (ms.size() > 1) {
2395                 /* has to be relative, may make no sense otherwise */
2396                 relative = true;
2397         }
2398
2399         if (!(_was_selected = cnote->selected())) {
2400
2401                 /* tertiary-click means extend selection - we'll do that on button release,
2402                    so don't add it here, because otherwise we make it hard to figure
2403                    out the "extend-to" range.
2404                 */
2405
2406                 bool extend = Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier);
2407
2408                 if (!extend) {
2409                         bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
2410
2411                         if (add) {
2412                                 region->note_selected (cnote, true);
2413                         } else {
2414                                 _editor->get_selection().clear_points();
2415                                 region->unique_select (cnote);
2416                         }
2417                 }
2418         }
2419 }
2420
2421 void
2422 NoteResizeDrag::motion (GdkEvent* event, bool first_move)
2423 {
2424         MidiRegionSelection& ms (_editor->get_selection().midi_regions);
2425         if (first_move) {
2426                 _editor->begin_reversible_command (_("resize notes"));
2427
2428                 for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ) {
2429                         MidiRegionSelection::iterator next;
2430                         next = r;
2431                         ++next;
2432                         MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
2433                         if (mrv) {
2434                                 mrv->begin_resizing (at_front);
2435                         }
2436                         r = next;
2437                 }
2438         }
2439
2440         for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
2441                 NoteBase* nb = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
2442                 assert (nb);
2443                 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
2444                 if (mrv) {
2445                         double sd = 0.0;
2446                         bool snap = true;
2447                         bool apply_snap_delta = ArdourKeyboard::indicates_snap_delta (event->button.state);
2448
2449                         if (ArdourKeyboard::indicates_snap (event->button.state)) {
2450                                 if (_editor->snap_mode () != SnapOff) {
2451                                         snap = false;
2452                                 }
2453                         } else {
2454                                 if (_editor->snap_mode () == SnapOff) {
2455                                         snap = false;
2456                                         /* inverted logic here - we;re in snapoff but we've pressed the snap delta modifier */
2457                                         if (apply_snap_delta) {
2458                                                 snap = true;
2459                                         }
2460                                 }
2461                         }
2462
2463                         if (apply_snap_delta) {
2464                                 sd = _snap_delta;
2465                         }
2466
2467                         mrv->update_resizing (nb, at_front, _drags->current_pointer_x() - grab_x(), relative, sd, snap);
2468                 }
2469         }
2470 }
2471
2472 void
2473 NoteResizeDrag::finished (GdkEvent* event, bool movement_occurred)
2474 {
2475         if (!movement_occurred) {
2476                 /* no motion - select note */
2477                 NoteBase* cnote = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
2478                 if (_editor->current_mouse_mode() == Editing::MouseContent ||
2479                     _editor->current_mouse_mode() == Editing::MouseDraw) {
2480
2481                         bool changed = false;
2482
2483                         if (_was_selected) {
2484                                 bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
2485                                 if (add) {
2486                                         region->note_deselected (cnote);
2487                                         changed = true;
2488                                 } else {
2489                                         _editor->get_selection().clear_points();
2490                                         region->unique_select (cnote);
2491                                         changed = true;
2492                                 }
2493                         } else {
2494                                 bool extend = Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier);
2495                                 bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
2496
2497                                 if (!extend && !add && region->selection_size() > 1) {
2498                                         _editor->get_selection().clear_points();
2499                                         region->unique_select (cnote);
2500                                         changed = true;
2501                                 } else if (extend) {
2502                                         region->note_selected (cnote, true, true);
2503                                         changed = true;
2504                                 } else {
2505                                         /* it was added during button press */
2506                                         changed = true;
2507                                 }
2508                         }
2509
2510                         if (changed) {
2511                                 _editor->begin_reversible_selection_op(X_("Resize Select Note Release"));
2512                                 _editor->commit_reversible_selection_op();
2513                         }
2514                 }
2515
2516                 return;
2517         }
2518
2519         MidiRegionSelection& ms (_editor->get_selection().midi_regions);
2520         for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
2521                 NoteBase* nb = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
2522                 assert (nb);
2523                 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
2524                 double sd = 0.0;
2525                 bool snap = true;
2526                 bool apply_snap_delta = ArdourKeyboard::indicates_snap_delta (event->button.state);
2527                 if (mrv) {
2528                         if (ArdourKeyboard::indicates_snap (event->button.state)) {
2529                                 if (_editor->snap_mode () != SnapOff) {
2530                                         snap = false;
2531                                 }
2532                         } else {
2533                                 if (_editor->snap_mode () == SnapOff) {
2534                                         snap = false;
2535                                         /* inverted logic here - we;re in snapoff but we've pressed the snap delta modifier */
2536                                         if (apply_snap_delta) {
2537                                                 snap = true;
2538                                         }
2539                                 }
2540                         }
2541
2542                         if (apply_snap_delta) {
2543                                 sd = _snap_delta;
2544                         }
2545
2546                         mrv->commit_resizing (nb, at_front, _drags->current_pointer_x() - grab_x(), relative, sd, snap);
2547                 }
2548         }
2549
2550         _editor->commit_reversible_command ();
2551 }
2552
2553 void
2554 NoteResizeDrag::aborted (bool)
2555 {
2556         MidiRegionSelection& ms (_editor->get_selection().midi_regions);
2557         for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
2558                 MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*r);
2559                 if (mrv) {
2560                         mrv->abort_resizing ();
2561                 }
2562         }
2563 }
2564
2565 AVDraggingView::AVDraggingView (RegionView* v)
2566         : view (v)
2567 {
2568         initial_position = v->region()->position ();
2569 }
2570
2571 VideoTimeLineDrag::VideoTimeLineDrag (Editor* e, ArdourCanvas::Item* i)
2572         : Drag (e, i)
2573 {
2574         DEBUG_TRACE (DEBUG::Drags, "New VideoTimeLineDrag\n");
2575
2576         RegionSelection rs;
2577         TrackViewList empty;
2578         empty.clear();
2579         _editor->get_regions_after(rs, (framepos_t) 0, empty);
2580         std::list<RegionView*> views = rs.by_layer();
2581
2582         _stuck = false;
2583         for (list<RegionView*>::iterator i = views.begin(); i != views.end(); ++i) {
2584                 RegionView* rv = (*i);
2585                 if (!rv->region()->video_locked()) {
2586                         continue;
2587                 }
2588                 if (rv->region()->locked()) {
2589                         _stuck = true;
2590                 }
2591                 _views.push_back (AVDraggingView (rv));
2592         }
2593 }
2594
2595 void
2596 VideoTimeLineDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
2597 {
2598         Drag::start_grab (event);
2599         if (_editor->session() == 0) {
2600                 return;
2601         }
2602
2603         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::TertiaryModifier))) {
2604                 _stuck = false;
2605                 _views.clear();
2606         }
2607
2608         if (_stuck) {
2609                 show_verbose_cursor_text (_("One or more Audio Regions\nare both Locked and\nLocked to Video.\nThe video cannot me moved."));
2610                 return;
2611         }
2612
2613         _startdrag_video_offset=ARDOUR_UI::instance()->video_timeline->get_offset();
2614         _max_backwards_drag = (
2615                           ARDOUR_UI::instance()->video_timeline->get_duration()
2616                         + ARDOUR_UI::instance()->video_timeline->get_offset()
2617                         - ceil(ARDOUR_UI::instance()->video_timeline->get_apv())
2618                         );
2619
2620         for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2621                 if (i->initial_position < _max_backwards_drag || _max_backwards_drag < 0) {
2622                         _max_backwards_drag = ARDOUR_UI::instance()->video_timeline->quantify_frames_to_apv (i->initial_position);
2623                 }
2624         }
2625         DEBUG_TRACE (DEBUG::Drags, string_compose("VideoTimeLineDrag: max backwards-drag: %1\n", _max_backwards_drag));
2626
2627         char buf[128];
2628         Timecode::Time timecode;
2629         _editor->session()->sample_to_timecode(abs(_startdrag_video_offset), timecode, true /* use_offset */, false /* use_subframes */ );
2630         snprintf (buf, sizeof (buf), "Video Start:\n%c%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32, (_startdrag_video_offset<0?'-':' '), timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
2631         show_verbose_cursor_text (buf);
2632 }
2633
2634 void
2635 VideoTimeLineDrag::motion (GdkEvent* event, bool first_move)
2636 {
2637         if (_editor->session() == 0) {
2638                 return;
2639         }
2640         if (ARDOUR_UI::instance()->video_timeline->is_offset_locked()) {
2641                 return;
2642         }
2643         if (_stuck) {
2644                 show_verbose_cursor_text (_("One or more Audio Regions\nare both Locked and\nLocked to Video.\nThe video cannot me moved."));
2645                 return;
2646         }
2647
2648         framecnt_t dt = adjusted_current_frame (event) - raw_grab_frame() + _pointer_frame_offset;
2649         dt = ARDOUR_UI::instance()->video_timeline->quantify_frames_to_apv(_startdrag_video_offset+dt) - _startdrag_video_offset;
2650
2651         if (_max_backwards_drag >= 0 && dt <= - _max_backwards_drag) {
2652                 dt = - _max_backwards_drag;
2653         }
2654
2655         ARDOUR_UI::instance()->video_timeline->set_offset(_startdrag_video_offset+dt);
2656         ARDOUR_UI::instance()->flush_videotimeline_cache(true);
2657
2658         for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2659                 RegionView* rv = i->view;
2660                 DEBUG_TRACE (DEBUG::Drags, string_compose("SHIFT REGION at %1 by %2\n", i->initial_position, dt));
2661                 if (first_move) {
2662                         rv->drag_start ();
2663                         rv->region()->clear_changes ();
2664                         rv->region()->suspend_property_changes();
2665                 }
2666                 rv->region()->set_position(i->initial_position + dt);
2667                 rv->region_changed(ARDOUR::Properties::position);
2668         }
2669
2670         const framepos_t offset = ARDOUR_UI::instance()->video_timeline->get_offset();
2671         Timecode::Time timecode;
2672         Timecode::Time timediff;
2673         char buf[128];
2674         _editor->session()->sample_to_timecode(abs(offset), timecode, true /* use_offset */, false /* use_subframes */ );
2675         _editor->session()->sample_to_timecode(abs(dt), timediff, false /* use_offset */, false /* use_subframes */ );
2676         snprintf (buf, sizeof (buf),
2677                         "%s\n%c%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32
2678                         "\n%s\n%c%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32
2679                         , _("Video Start:"),
2680                                 (offset<0?'-':' '), timecode.hours, timecode.minutes, timecode.seconds, timecode.frames
2681                         , _("Diff:"),
2682                                 (dt<0?'-':' '), timediff.hours, timediff.minutes, timediff.seconds, timediff.frames
2683                                 );
2684         show_verbose_cursor_text (buf);
2685 }
2686
2687 void
2688 VideoTimeLineDrag::finished (GdkEvent * /*event*/, bool movement_occurred)
2689 {
2690         if (ARDOUR_UI::instance()->video_timeline->is_offset_locked()) {
2691                 return;
2692         }
2693         if (_stuck) {
2694                 return;
2695         }
2696
2697         if (!movement_occurred || ! _editor->session()) {
2698                 return;
2699         }
2700
2701         ARDOUR_UI::instance()->flush_videotimeline_cache(true);
2702
2703         _editor->begin_reversible_command (_("Move Video"));
2704
2705         XMLNode &before = ARDOUR_UI::instance()->video_timeline->get_state();
2706         ARDOUR_UI::instance()->video_timeline->save_undo();
2707         XMLNode &after = ARDOUR_UI::instance()->video_timeline->get_state();
2708         _editor->session()->add_command(new MementoCommand<VideoTimeLine>(*(ARDOUR_UI::instance()->video_timeline), &before, &after));
2709
2710         for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2711                 i->view->drag_end();
2712                 i->view->region()->resume_property_changes ();
2713
2714                 _editor->session()->add_command (new StatefulDiffCommand (i->view->region()));
2715         }
2716
2717         _editor->session()->maybe_update_session_range(
2718                         std::max(ARDOUR_UI::instance()->video_timeline->get_offset(), (ARDOUR::frameoffset_t) 0),
2719                         std::max(ARDOUR_UI::instance()->video_timeline->get_offset() + ARDOUR_UI::instance()->video_timeline->get_duration(), (ARDOUR::frameoffset_t) 0)
2720                         );
2721
2722
2723         _editor->commit_reversible_command ();
2724 }
2725
2726 void
2727 VideoTimeLineDrag::aborted (bool)
2728 {
2729         if (ARDOUR_UI::instance()->video_timeline->is_offset_locked()) {
2730                 return;
2731         }
2732         ARDOUR_UI::instance()->video_timeline->set_offset(_startdrag_video_offset);
2733         ARDOUR_UI::instance()->flush_videotimeline_cache(true);
2734
2735         for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2736                 i->view->region()->resume_property_changes ();
2737                 i->view->region()->set_position(i->initial_position);
2738         }
2739 }
2740
2741 TrimDrag::TrimDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool preserve_fade_anchor)
2742         : RegionDrag (e, i, p, v)
2743         , _operation (StartTrim)
2744         , _preserve_fade_anchor (preserve_fade_anchor)
2745         , _jump_position_when_done (false)
2746 {
2747         DEBUG_TRACE (DEBUG::Drags, "New TrimDrag\n");
2748 }
2749
2750 void
2751 TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
2752 {
2753         double speed = 1.0;
2754         TimeAxisView* tvp = &_primary->get_time_axis_view ();
2755         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
2756
2757         if (tv && tv->is_track()) {
2758                 speed = tv->track()->speed();
2759         }
2760
2761         framepos_t const region_start = (framepos_t) (_primary->region()->position() / speed);
2762         framepos_t const region_end = (framepos_t) (_primary->region()->last_frame() / speed);
2763         framecnt_t const region_length = (framecnt_t) (_primary->region()->length() / speed);
2764
2765         framepos_t const pf = adjusted_current_frame (event);
2766         setup_snap_delta (region_start);
2767
2768         if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::trim_contents_modifier ())) {
2769                 /* Move the contents of the region around without changing the region bounds */
2770                 _operation = ContentsTrim;
2771                 Drag::start_grab (event, _editor->cursors()->trimmer);
2772         } else {
2773                 /* These will get overridden for a point trim.*/
2774                 if (pf < (region_start + region_length/2)) {
2775                         /* closer to front */
2776                         _operation = StartTrim;
2777                         if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::trim_anchored_modifier ())) {
2778                                 Drag::start_grab (event, _editor->cursors()->anchored_left_side_trim);
2779                         } else {
2780                                 Drag::start_grab (event, _editor->cursors()->left_side_trim);
2781                         }
2782                 } else {
2783                         /* closer to end */
2784                         _operation = EndTrim;
2785                         if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::trim_anchored_modifier ())) {
2786                                 Drag::start_grab (event, _editor->cursors()->anchored_right_side_trim);
2787                         } else {
2788                                 Drag::start_grab (event, _editor->cursors()->right_side_trim);
2789                         }
2790                 }
2791         }
2792         /* jump trim disabled for now
2793         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::trim_jump_modifier ())) {
2794                 _jump_position_when_done = true;
2795         }
2796         */
2797
2798         switch (_operation) {
2799         case StartTrim:
2800                 show_verbose_cursor_time (region_start);
2801                 break;
2802         case EndTrim:
2803                 show_verbose_cursor_duration (region_start, region_end);
2804                 break;
2805         case ContentsTrim:
2806                 show_verbose_cursor_time (pf);
2807                 break;
2808         }
2809
2810         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2811                 i->view->region()->suspend_property_changes ();
2812         }
2813 }
2814
2815 void
2816 TrimDrag::motion (GdkEvent* event, bool first_move)
2817 {
2818         RegionView* rv = _primary;
2819
2820         double speed = 1.0;
2821         TimeAxisView* tvp = &_primary->get_time_axis_view ();
2822         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
2823         pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
2824         frameoffset_t frame_delta = 0;
2825
2826         if (tv && tv->is_track()) {
2827                 speed = tv->track()->speed();
2828         }
2829         framecnt_t adj_frame = adjusted_frame (_drags->current_pointer_frame () + snap_delta (event->button.state), event, true);
2830         framecnt_t dt = adj_frame - raw_grab_frame () + _pointer_frame_offset - snap_delta (event->button.state);
2831
2832         if (first_move) {
2833
2834                 string trim_type;
2835
2836                 switch (_operation) {
2837                 case StartTrim:
2838                         trim_type = "Region start trim";
2839                         break;
2840                 case EndTrim:
2841                         trim_type = "Region end trim";
2842                         break;
2843                 case ContentsTrim:
2844                         trim_type = "Region content trim";
2845                         break;
2846                 default:
2847                         assert(0);
2848                         break;
2849                 }
2850
2851                 _editor->begin_reversible_command (trim_type);
2852
2853                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2854                         RegionView* rv = i->view;
2855                         rv->enable_display (false);
2856                         rv->region()->playlist()->clear_owned_changes ();
2857
2858                         if (_operation == StartTrim) {
2859                                 rv->trim_front_starting ();
2860                         }
2861
2862                         AudioRegionView* const arv = dynamic_cast<AudioRegionView*> (rv);
2863
2864                         if (arv) {
2865                                 arv->temporarily_hide_envelope ();
2866                                 arv->drag_start ();
2867                         }
2868
2869                         boost::shared_ptr<Playlist> pl = rv->region()->playlist();
2870                         insert_result = _editor->motion_frozen_playlists.insert (pl);
2871
2872                         if (insert_result.second) {
2873                                 pl->freeze();
2874                         }
2875                 }
2876         }
2877
2878         bool non_overlap_trim = false;
2879
2880         if (event && Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::trim_overlap_modifier ())) {
2881                 non_overlap_trim = true;
2882         }
2883
2884         /* contstrain trim to fade length */
2885         if (_preserve_fade_anchor) {
2886                 switch (_operation) {
2887                         case StartTrim:
2888                                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2889                                         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2890                                         if (!arv) continue;
2891                                         boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2892                                         if (ar->locked()) continue;
2893                                         framecnt_t len = ar->fade_in()->back()->when;
2894                                         if (len < dt) dt = min(dt, len);
2895                                 }
2896                                 break;
2897                         case EndTrim:
2898                                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2899                                         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2900                                         if (!arv) continue;
2901                                         boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2902                                         if (ar->locked()) continue;
2903                                         framecnt_t len = ar->fade_out()->back()->when;
2904                                         if (len < -dt) dt = max(dt, -len);
2905                                 }
2906                                 break;
2907                         case ContentsTrim:
2908                                 break;
2909                 }
2910         }
2911
2912
2913         switch (_operation) {
2914         case StartTrim:
2915                 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2916                         bool changed = i->view->trim_front (i->initial_position + dt, non_overlap_trim);
2917                         if (changed && _preserve_fade_anchor) {
2918                                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2919                                 if (arv) {
2920                                         boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2921                                         framecnt_t len = ar->fade_in()->back()->when;
2922                                         framecnt_t diff = ar->first_frame() - i->initial_position;
2923                                         framepos_t new_length = len - diff;
2924                                         i->anchored_fade_length = min (ar->length(), new_length);
2925                                         //i->anchored_fade_length = ar->verify_xfade_bounds (new_length, true  /*START*/ );
2926                                         arv->reset_fade_in_shape_width (ar, i->anchored_fade_length, true);
2927                                 }
2928                         }
2929                 }
2930                 break;
2931
2932         case EndTrim:
2933                 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2934                         bool changed = i->view->trim_end (i->initial_end + dt, non_overlap_trim);
2935                         if (changed && _preserve_fade_anchor) {
2936                                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2937                                 if (arv) {
2938                                         boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2939                                         framecnt_t len = ar->fade_out()->back()->when;
2940                                         framecnt_t diff = 1 + ar->last_frame() - i->initial_end;
2941                                         framepos_t new_length = len + diff;
2942                                         i->anchored_fade_length = min (ar->length(), new_length);
2943                                         //i->anchored_fade_length = ar->verify_xfade_bounds (new_length, false  /*END*/ );
2944                                         arv->reset_fade_out_shape_width (ar, i->anchored_fade_length, true);
2945                                 }
2946                         }
2947                 }
2948                 break;
2949
2950         case ContentsTrim:
2951                 {
2952                         frame_delta = (last_pointer_frame() - adjusted_current_frame(event));
2953
2954                         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2955                                 i->view->move_contents (frame_delta);
2956                         }
2957                 }
2958                 break;
2959         }
2960
2961         switch (_operation) {
2962         case StartTrim:
2963                 show_verbose_cursor_time ((framepos_t) (rv->region()->position() / speed));
2964                 break;
2965         case EndTrim:
2966                 show_verbose_cursor_duration ((framepos_t)  rv->region()->position() / speed, (framepos_t) rv->region()->last_frame() / speed);
2967                 break;
2968         case ContentsTrim:
2969                 // show_verbose_cursor_time (frame_delta);
2970                 break;
2971         }
2972 }
2973
2974 void
2975 TrimDrag::finished (GdkEvent* event, bool movement_occurred)
2976 {
2977         if (movement_occurred) {
2978                 motion (event, false);
2979
2980                 if (_operation == StartTrim) {
2981                         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
2982                                 {
2983                                         /* This must happen before the region's StatefulDiffCommand is created, as it may
2984                                            `correct' (ahem) the region's _start from being negative to being zero.  It
2985                                            needs to be zero in the undo record.
2986                                         */
2987                                         i->view->trim_front_ending ();
2988                                 }
2989                                 if (_preserve_fade_anchor) {
2990                                         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
2991                                         if (arv) {
2992                                                 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
2993                                                 arv->reset_fade_in_shape_width (ar, i->anchored_fade_length);
2994                                                 ar->set_fade_in_length(i->anchored_fade_length);
2995                                                 ar->set_fade_in_active(true);
2996                                         }
2997                                 }
2998                                 if (_jump_position_when_done) {
2999                                         i->view->region()->set_position (i->initial_position);
3000                                 }
3001                         }
3002                 } else if (_operation == EndTrim) {
3003                         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
3004                                 if (_preserve_fade_anchor) {
3005                                         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
3006                                         if (arv) {
3007                                                 boost::shared_ptr<AudioRegion> ar (arv->audio_region());
3008                                                 arv->reset_fade_out_shape_width (ar, i->anchored_fade_length);
3009                                                 ar->set_fade_out_length(i->anchored_fade_length);
3010                                                 ar->set_fade_out_active(true);
3011                                         }
3012                                 }
3013                                 if (_jump_position_when_done) {
3014                                         i->view->region()->set_position (i->initial_end - i->view->region()->length());
3015                                 }
3016                         }
3017                 }
3018
3019                 if (!_views.empty()) {
3020                         if (_operation == StartTrim) {
3021                                 _editor->maybe_locate_with_edit_preroll(
3022                                         _views.begin()->view->region()->position());
3023                         }
3024                         if (_operation == EndTrim) {
3025                                 _editor->maybe_locate_with_edit_preroll(
3026                                         _views.begin()->view->region()->position() +
3027                                         _views.begin()->view->region()->length());
3028                         }
3029                 }
3030
3031                 if (!_editor->selection->selected (_primary)) {
3032                         _primary->thaw_after_trim ();
3033                 } else {
3034
3035                         set<boost::shared_ptr<Playlist> > diffed_playlists;
3036
3037                         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
3038                                 i->view->thaw_after_trim ();
3039                                 i->view->enable_display (true);
3040
3041                                 /* Trimming one region may affect others on the playlist, so we need
3042                                    to get undo Commands from the whole playlist rather than just the
3043                                    region.  Use diffed_playlists to make sure we don't diff a given
3044                                    playlist more than once.
3045                                 */
3046                                 boost::shared_ptr<Playlist> p = i->view->region()->playlist ();
3047                                 if (diffed_playlists.find (p) == diffed_playlists.end()) {
3048                                         vector<Command*> cmds;
3049                                         p->rdiff (cmds);
3050                                         _editor->session()->add_commands (cmds);
3051                                         diffed_playlists.insert (p);
3052                                 }
3053                         }
3054                 }
3055
3056                 for (set<boost::shared_ptr<Playlist> >::iterator p = _editor->motion_frozen_playlists.begin(); p != _editor->motion_frozen_playlists.end(); ++p) {
3057                         (*p)->thaw ();
3058                 }
3059
3060                 _editor->motion_frozen_playlists.clear ();
3061                 _editor->commit_reversible_command();
3062
3063         } else {
3064                 /* no mouse movement */
3065                 if (adjusted_current_frame (event) != adjusted_frame (_drags->current_pointer_frame(), event, false)) {
3066                         _editor->point_trim (event, adjusted_current_frame (event));
3067                 }
3068         }
3069
3070         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
3071                 i->view->region()->resume_property_changes ();
3072         }
3073 }
3074
3075 void
3076 TrimDrag::aborted (bool movement_occurred)
3077 {
3078         /* Our motion method is changing model state, so use the Undo system
3079            to cancel.  Perhaps not ideal, as this will leave an Undo point
3080            behind which may be slightly odd from the user's point of view.
3081         */
3082
3083         finished (0, true);
3084
3085         if (movement_occurred) {
3086                 _editor->undo ();
3087         }
3088
3089         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
3090                 i->view->region()->resume_property_changes ();
3091         }
3092 }
3093
3094 void
3095 TrimDrag::setup_pointer_frame_offset ()
3096 {
3097         list<DraggingView>::iterator i = _views.begin ();
3098         while (i != _views.end() && i->view != _primary) {
3099                 ++i;
3100         }
3101
3102         if (i == _views.end()) {
3103                 return;
3104         }
3105
3106         switch (_operation) {
3107         case StartTrim:
3108                 _pointer_frame_offset = raw_grab_frame() - i->initial_position;
3109                 break;
3110         case EndTrim:
3111                 _pointer_frame_offset = raw_grab_frame() - i->initial_end;
3112                 break;
3113         case ContentsTrim:
3114                 break;
3115         }
3116 }
3117
3118 MeterMarkerDrag::MeterMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
3119         : Drag (e, i),
3120           _copy (c)
3121         , before_state (0)
3122 {
3123         DEBUG_TRACE (DEBUG::Drags, "New MeterMarkerDrag\n");
3124         _marker = reinterpret_cast<MeterMarker*> (_item->get_data ("marker"));
3125         assert (_marker);
3126 }
3127
3128 void
3129 MeterMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3130 {
3131         Drag::start_grab (event, cursor);
3132         show_verbose_cursor_time (adjusted_current_frame(event));
3133 }
3134
3135 void
3136 MeterMarkerDrag::setup_pointer_frame_offset ()
3137 {
3138         _pointer_frame_offset = raw_grab_frame() - _marker->meter().frame();
3139 }
3140
3141 void
3142 MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
3143 {
3144         if (!_marker->meter().movable()) {
3145                 return;
3146         }
3147
3148         if (first_move) {
3149
3150                 // create a dummy marker for visual representation of moving the
3151                 // section, because whether its a copy or not, we're going to
3152                 // leave or lose the original marker (leave if its a copy; lose if its
3153                 // not, because we'll remove it from the map).
3154
3155                 MeterSection section (_marker->meter());
3156
3157                 if (!section.movable()) {
3158                         return;
3159                 }
3160
3161                 char name[64];
3162                 snprintf (name, sizeof(name), "%g/%g", _marker->meter().divisions_per_bar(), _marker->meter().note_divisor ());
3163
3164                 _marker = new MeterMarker (
3165                         *_editor,
3166                         *_editor->meter_group,
3167                         UIConfiguration::instance().color ("meter marker"),
3168                         name,
3169                         *new MeterSection (_marker->meter())
3170                 );
3171
3172                 /* use the new marker for the grab */
3173                 swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
3174
3175                 if (!_copy) {
3176                         TempoMap& map (_editor->session()->tempo_map());
3177                         /* get current state */
3178                         before_state = &map.get_state();
3179                         /* remove the section while we drag it */
3180                         map.remove_meter (section, true);
3181                 }
3182         }
3183
3184         framepos_t const pf = adjusted_current_frame (event);
3185
3186         _marker->set_position (pf);
3187         show_verbose_cursor_time (pf);
3188 }
3189
3190 void
3191 MeterMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
3192 {
3193         if (!movement_occurred) {
3194                 if (was_double_click()) {
3195                         _editor->edit_meter_marker (*_marker);
3196                 }
3197                 return;
3198         }
3199
3200         if (!_marker->meter().movable()) {
3201                 return;
3202         }
3203
3204         motion (event, false);
3205
3206         Timecode::BBT_Time when;
3207
3208         TempoMap& map (_editor->session()->tempo_map());
3209         map.bbt_time (_marker->position(), when);
3210
3211         if (_copy == true) {
3212                 _editor->begin_reversible_command (_("copy meter mark"));
3213                 XMLNode &before = map.get_state();
3214                 map.add_meter (_marker->meter(), when);
3215                 XMLNode &after = map.get_state();
3216                 _editor->session()->add_command(new MementoCommand<TempoMap>(map, &before, &after));
3217                 _editor->commit_reversible_command ();
3218
3219         } else {
3220                 _editor->begin_reversible_command (_("move meter mark"));
3221
3222                 /* we removed it before, so add it back now */
3223
3224                 map.add_meter (_marker->meter(), when);
3225                 XMLNode &after = map.get_state();
3226                 _editor->session()->add_command(new MementoCommand<TempoMap>(map, before_state, &after));
3227                 _editor->commit_reversible_command ();
3228         }
3229
3230         // delete the dummy marker we used for visual representation while moving.
3231         // a new visual marker will show up automatically.
3232         delete _marker;
3233 }
3234
3235 void
3236 MeterMarkerDrag::aborted (bool moved)
3237 {
3238         _marker->set_position (_marker->meter().frame ());
3239
3240         if (moved) {
3241                 TempoMap& map (_editor->session()->tempo_map());
3242                 /* we removed it before, so add it back now */
3243                 map.add_meter (_marker->meter(), _marker->meter().frame());
3244                 // delete the dummy marker we used for visual representation while moving.
3245                 // a new visual marker will show up automatically.
3246                 delete _marker;
3247         }
3248 }
3249
3250 TempoMarkerDrag::TempoMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
3251         : Drag (e, i)
3252         , _copy (c)
3253         , before_state (0)
3254 {
3255         DEBUG_TRACE (DEBUG::Drags, "New TempoMarkerDrag\n");
3256
3257         _marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
3258         assert (_marker);
3259 }
3260
3261 void
3262 TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3263 {
3264         Drag::start_grab (event, cursor);
3265         show_verbose_cursor_time (adjusted_current_frame (event));
3266 }
3267
3268 void
3269 TempoMarkerDrag::setup_pointer_frame_offset ()
3270 {
3271         _pointer_frame_offset = raw_grab_frame() - _marker->tempo().frame();
3272 }
3273
3274 void
3275 TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
3276 {
3277         if (!_marker->tempo().movable()) {
3278                 return;
3279         }
3280
3281         if (first_move) {
3282
3283                 // create a dummy marker for visual representation of moving the
3284                 // section, because whether its a copy or not, we're going to
3285                 // leave or lose the original marker (leave if its a copy; lose if its
3286                 // not, because we'll remove it from the map).
3287
3288                 // create a dummy marker for visual representation of moving the copy.
3289                 // The actual copying is not done before we reach the finish callback.
3290
3291                 char name[64];
3292                 snprintf (name, sizeof (name), "%.2f", _marker->tempo().beats_per_minute());
3293
3294                 TempoSection section (_marker->tempo());
3295
3296                 _marker = new TempoMarker (
3297                         *_editor,
3298                         *_editor->tempo_group,
3299                         UIConfiguration::instance().color ("tempo marker"),
3300                         name,
3301                         *new TempoSection (_marker->tempo())
3302                         );
3303
3304                 /* use the new marker for the grab */
3305                 swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
3306
3307                 if (!_copy) {
3308                         _editor->begin_reversible_command (_("move tempo mark"));
3309                         TempoMap& map (_editor->session()->tempo_map());
3310                         /* get current state */
3311                         before_state = &map.get_state();
3312                         /* remove the section while we drag it */
3313                         map.remove_tempo (section, true);
3314                 }
3315         }
3316
3317         framepos_t const pf = adjusted_current_frame (event);
3318         _marker->set_position (pf);
3319         show_verbose_cursor_time (pf);
3320 }
3321
3322 void
3323 TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
3324 {
3325         if (!movement_occurred) {
3326                 if (was_double_click()) {
3327                         _editor->edit_tempo_marker (*_marker);
3328                 }
3329                 return;
3330         }
3331
3332         if (!_marker->tempo().movable()) {
3333                 return;
3334         }
3335
3336         motion (event, false);
3337
3338         TempoMap& map (_editor->session()->tempo_map());
3339         framepos_t beat_time = map.round_to_beat (_marker->position(), RoundNearest);
3340         Timecode::BBT_Time when;
3341
3342         map.bbt_time (beat_time, when);
3343
3344         if (_copy == true) {
3345                 _editor->begin_reversible_command (_("copy tempo mark"));
3346                 XMLNode &before = map.get_state();
3347                 map.add_tempo (_marker->tempo(), when);
3348                 XMLNode &after = map.get_state();
3349                 _editor->session()->add_command (new MementoCommand<TempoMap>(map, &before, &after));
3350                 _editor->commit_reversible_command ();
3351
3352         } else {
3353                 /* we removed it before, so add it back now */
3354                 map.add_tempo (_marker->tempo(), when);
3355                 XMLNode &after = map.get_state();
3356                 _editor->session()->add_command (new MementoCommand<TempoMap>(map, before_state, &after));
3357                 _editor->commit_reversible_command ();
3358         }
3359
3360         // delete the dummy marker we used for visual representation while moving.
3361         // a new visual marker will show up automatically.
3362         delete _marker;
3363 }
3364
3365 void
3366 TempoMarkerDrag::aborted (bool moved)
3367 {
3368         _marker->set_position (_marker->tempo().frame());
3369         if (moved) {
3370                 TempoMap& map (_editor->session()->tempo_map());
3371                 /* we removed it before, so add it back now */
3372                 map.add_tempo (_marker->tempo(), _marker->tempo().start());
3373                 // delete the dummy marker we used for visual representation while moving.
3374                 // a new visual marker will show up automatically.
3375                 delete _marker;
3376         }
3377 }
3378
3379 CursorDrag::CursorDrag (Editor* e, EditorCursor& c, bool s)
3380         : Drag (e, &c.track_canvas_item(), false)
3381         , _cursor (c)
3382         , _stop (s)
3383         , _grab_zoom (0.0)
3384 {
3385         DEBUG_TRACE (DEBUG::Drags, "New CursorDrag\n");
3386 }
3387
3388 /** Do all the things we do when dragging the playhead to make it look as though
3389  *  we have located, without actually doing the locate (because that would cause
3390  *  the diskstream buffers to be refilled, which is too slow).
3391  */
3392 void
3393 CursorDrag::fake_locate (framepos_t t)
3394 {
3395         if (_editor->session () == 0) {
3396                 return;
3397         }
3398
3399         _editor->playhead_cursor->set_position (t);
3400
3401         Session* s = _editor->session ();
3402         if (s->timecode_transmission_suspended ()) {
3403                 framepos_t const f = _editor->playhead_cursor->current_frame ();
3404                 /* This is asynchronous so it will be sent "now"
3405                  */
3406                 s->send_mmc_locate (f);
3407                 /* These are synchronous and will be sent during the next
3408                    process cycle
3409                 */
3410                 s->queue_full_time_code ();
3411                 s->queue_song_position_pointer ();
3412         }
3413
3414         show_verbose_cursor_time (t);
3415         _editor->UpdateAllTransportClocks (t);
3416 }
3417
3418 void
3419 CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
3420 {
3421         Drag::start_grab (event, c);
3422         setup_snap_delta (_editor->playhead_cursor->current_frame ());
3423
3424         _grab_zoom = _editor->samples_per_pixel;
3425
3426         framepos_t where = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
3427
3428         _editor->snap_to_with_modifier (where, event);
3429
3430         _editor->_dragging_playhead = true;
3431
3432         Session* s = _editor->session ();
3433
3434         /* grab the track canvas item as well */
3435
3436         _cursor.track_canvas_item().grab();
3437
3438         if (s) {
3439                 if (_was_rolling && _stop) {
3440                         s->request_stop ();
3441                 }
3442
3443                 if (s->is_auditioning()) {
3444                         s->cancel_audition ();
3445                 }
3446
3447
3448                 if (AudioEngine::instance()->connected()) {
3449
3450                         /* do this only if we're the engine is connected
3451                          * because otherwise this request will never be
3452                          * serviced and we'll busy wait forever. likewise,
3453                          * notice if we are disconnected while waiting for the
3454                          * request to be serviced.
3455                          */
3456
3457                         s->request_suspend_timecode_transmission ();
3458                         while (AudioEngine::instance()->connected() && !s->timecode_transmission_suspended ()) {
3459                                 /* twiddle our thumbs */
3460                         }
3461                 }
3462         }
3463
3464         fake_locate (where - snap_delta (event->button.state));
3465 }
3466
3467 void
3468 CursorDrag::motion (GdkEvent* event, bool)
3469 {
3470         framepos_t where = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
3471         _editor->snap_to_with_modifier (where, event);
3472         if (where != last_pointer_frame()) {
3473                 fake_locate (where - snap_delta (event->button.state));
3474         }
3475 }
3476
3477 void
3478 CursorDrag::finished (GdkEvent* event, bool movement_occurred)
3479 {
3480         _editor->_dragging_playhead = false;
3481
3482         _cursor.track_canvas_item().ungrab();
3483
3484         if (!movement_occurred && _stop) {
3485                 return;
3486         }
3487
3488         motion (event, false);
3489
3490         Session* s = _editor->session ();
3491         if (s) {
3492                 s->request_locate (_editor->playhead_cursor->current_frame (), _was_rolling);
3493                 _editor->_pending_locate_request = true;
3494                 s->request_resume_timecode_transmission ();
3495         }
3496 }
3497
3498 void
3499 CursorDrag::aborted (bool)
3500 {
3501         _cursor.track_canvas_item().ungrab();
3502
3503         if (_editor->_dragging_playhead) {
3504                 _editor->session()->request_resume_timecode_transmission ();
3505                 _editor->_dragging_playhead = false;
3506         }
3507
3508         _editor->playhead_cursor->set_position (adjusted_frame (grab_frame (), 0, false));
3509 }
3510
3511 FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
3512         : RegionDrag (e, i, p, v)
3513 {
3514         DEBUG_TRACE (DEBUG::Drags, "New FadeInDrag\n");
3515 }
3516
3517 void
3518 FadeInDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3519 {
3520         Drag::start_grab (event, cursor);
3521
3522         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
3523         boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
3524         setup_snap_delta (r->position ());
3525
3526         show_verbose_cursor_duration (r->position(), r->position() + r->fade_in()->back()->when, 32);
3527 }
3528
3529 void
3530 FadeInDrag::setup_pointer_frame_offset ()
3531 {
3532         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
3533         boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
3534         _pointer_frame_offset = raw_grab_frame() - ((framecnt_t) r->fade_in()->back()->when + r->position());
3535 }
3536
3537 void
3538 FadeInDrag::motion (GdkEvent* event, bool)
3539 {
3540         framecnt_t fade_length;
3541
3542         framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
3543         _editor->snap_to_with_modifier (pos, event);
3544         pos -= snap_delta (event->button.state);
3545
3546         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
3547
3548         if (pos < (region->position() + 64)) {
3549                 fade_length = 64; // this should be a minimum defined somewhere
3550         } else if (pos > region->position() + region->length() - region->fade_out()->back()->when) {
3551                 fade_length = region->length() - region->fade_out()->back()->when - 1;
3552         } else {
3553                 fade_length = pos - region->position();
3554         }
3555
3556         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3557
3558                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3559
3560                 if (!tmp) {
3561                         continue;
3562                 }
3563
3564                 tmp->reset_fade_in_shape_width (tmp->audio_region(), fade_length);
3565         }
3566
3567         show_verbose_cursor_duration (region->position(), region->position() + fade_length, 32);
3568 }
3569
3570 void
3571 FadeInDrag::finished (GdkEvent* event, bool movement_occurred)
3572 {
3573         if (!movement_occurred) {
3574                 return;
3575         }
3576
3577         framecnt_t fade_length;
3578         framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
3579         _editor->snap_to_with_modifier (pos, event);
3580         pos -= snap_delta (event->button.state);
3581
3582         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
3583
3584         if (pos < (region->position() + 64)) {
3585                 fade_length = 64; // this should be a minimum defined somewhere
3586         } else if (pos >= region->position() + region->length() - region->fade_out()->back()->when) {
3587                 fade_length = region->length() - region->fade_out()->back()->when - 1;
3588         } else {
3589                 fade_length = pos - region->position();
3590         }
3591
3592         bool in_command = false;
3593
3594         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3595
3596                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3597
3598                 if (!tmp) {
3599                         continue;
3600                 }
3601
3602                 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_in();
3603                 XMLNode &before = alist->get_state();
3604
3605                 tmp->audio_region()->set_fade_in_length (fade_length);
3606                 tmp->audio_region()->set_fade_in_active (true);
3607
3608                 if (!in_command) {
3609                         _editor->begin_reversible_command (_("change fade in length"));
3610                         in_command = true;
3611                 }
3612                 XMLNode &after = alist->get_state();
3613                 _editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
3614         }
3615
3616         if (in_command) {
3617                 _editor->commit_reversible_command ();
3618         }
3619 }
3620
3621 void
3622 FadeInDrag::aborted (bool)
3623 {
3624         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3625                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3626
3627                 if (!tmp) {
3628                         continue;
3629                 }
3630
3631                 tmp->reset_fade_in_shape_width (tmp->audio_region(), tmp->audio_region()->fade_in()->back()->when);
3632         }
3633 }
3634
3635 FadeOutDrag::FadeOutDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
3636         : RegionDrag (e, i, p, v)
3637 {
3638         DEBUG_TRACE (DEBUG::Drags, "New FadeOutDrag\n");
3639 }
3640
3641 void
3642 FadeOutDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3643 {
3644         Drag::start_grab (event, cursor);
3645
3646         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
3647         boost::shared_ptr<AudioRegion> r = arv->audio_region ();
3648         setup_snap_delta (r->last_frame ());
3649
3650         show_verbose_cursor_duration (r->last_frame() - r->fade_out()->back()->when, r->last_frame());
3651 }
3652
3653 void
3654 FadeOutDrag::setup_pointer_frame_offset ()
3655 {
3656         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
3657         boost::shared_ptr<AudioRegion> r = arv->audio_region ();
3658         _pointer_frame_offset = raw_grab_frame() - (r->length() - (framecnt_t) r->fade_out()->back()->when + r->position());
3659 }
3660
3661 void
3662 FadeOutDrag::motion (GdkEvent* event, bool)
3663 {
3664         framecnt_t fade_length;
3665
3666         framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
3667         _editor->snap_to_with_modifier (pos, event);
3668         pos -= snap_delta (event->button.state);
3669
3670         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
3671
3672         if (pos > (region->last_frame() - 64)) {
3673                 fade_length = 64; // this should really be a minimum fade defined somewhere
3674         } else if (pos <= region->position() + region->fade_in()->back()->when) {
3675                 fade_length = region->length() - region->fade_in()->back()->when - 1;
3676         } else {
3677                 fade_length = region->last_frame() - pos;
3678         }
3679
3680         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3681
3682                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3683
3684                 if (!tmp) {
3685                         continue;
3686                 }
3687
3688                 tmp->reset_fade_out_shape_width (tmp->audio_region(), fade_length);
3689         }
3690
3691         show_verbose_cursor_duration (region->last_frame() - fade_length, region->last_frame());
3692 }
3693
3694 void
3695 FadeOutDrag::finished (GdkEvent* event, bool movement_occurred)
3696 {
3697         if (!movement_occurred) {
3698                 return;
3699         }
3700
3701         framecnt_t fade_length;
3702
3703         framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
3704         _editor->snap_to_with_modifier (pos, event);
3705         pos -= snap_delta (event->button.state);
3706
3707         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
3708
3709         if (pos > (region->last_frame() - 64)) {
3710                 fade_length = 64; // this should really be a minimum fade defined somewhere
3711         } else if (pos <= region->position() + region->fade_in()->back()->when) {
3712                 fade_length = region->length() - region->fade_in()->back()->when - 1;
3713         } else {
3714                 fade_length = region->last_frame() - pos;
3715         }
3716
3717         bool in_command = false;
3718
3719         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3720
3721                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3722
3723                 if (!tmp) {
3724                         continue;
3725                 }
3726
3727                 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_out();
3728                 XMLNode &before = alist->get_state();
3729
3730                 tmp->audio_region()->set_fade_out_length (fade_length);
3731                 tmp->audio_region()->set_fade_out_active (true);
3732
3733                 if (!in_command) {
3734                         _editor->begin_reversible_command (_("change fade out length"));
3735                         in_command = true;
3736                 }
3737                 XMLNode &after = alist->get_state();
3738                 _editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
3739         }
3740
3741         if (in_command) {
3742                 _editor->commit_reversible_command ();
3743         }
3744 }
3745
3746 void
3747 FadeOutDrag::aborted (bool)
3748 {
3749         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
3750                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
3751
3752                 if (!tmp) {
3753                         continue;
3754                 }
3755
3756                 tmp->reset_fade_out_shape_width (tmp->audio_region(), tmp->audio_region()->fade_out()->back()->when);
3757         }
3758 }
3759
3760 MarkerDrag::MarkerDrag (Editor* e, ArdourCanvas::Item* i)
3761         : Drag (e, i)
3762         , _selection_changed (false)
3763 {
3764         DEBUG_TRACE (DEBUG::Drags, "New MarkerDrag\n");
3765         Gtk::Window* toplevel = _editor->current_toplevel();
3766         _marker = reinterpret_cast<ArdourMarker*> (_item->get_data ("marker"));
3767
3768         assert (_marker);
3769
3770         _points.push_back (ArdourCanvas::Duple (0, 0));
3771
3772         _points.push_back (ArdourCanvas::Duple (0, toplevel ? physical_screen_height (toplevel->get_window()) : 900));
3773 }
3774
3775 MarkerDrag::~MarkerDrag ()
3776 {
3777         for (CopiedLocationInfo::iterator i = _copied_locations.begin(); i != _copied_locations.end(); ++i) {
3778                 delete i->location;
3779         }
3780 }
3781
3782 MarkerDrag::CopiedLocationMarkerInfo::CopiedLocationMarkerInfo (Location* l, ArdourMarker* m)
3783 {
3784         location = new Location (*l);
3785         markers.push_back (m);
3786         move_both = false;
3787 }
3788
3789 void
3790 MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3791 {
3792         Drag::start_grab (event, cursor);
3793
3794         bool is_start;
3795
3796         Location *location = _editor->find_location_from_marker (_marker, is_start);
3797         _editor->_dragging_edit_point = true;
3798
3799         update_item (location);
3800
3801         // _drag_line->show();
3802         // _line->raise_to_top();
3803
3804         if (is_start) {
3805                 show_verbose_cursor_time (location->start());
3806         } else {
3807                 show_verbose_cursor_time (location->end());
3808         }
3809         setup_snap_delta (is_start ? location->start() : location->end());
3810
3811         Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
3812
3813         switch (op) {
3814         case Selection::Toggle:
3815                 /* we toggle on the button release */
3816                 break;
3817         case Selection::Set:
3818                 if (!_editor->selection->selected (_marker)) {
3819                         _editor->selection->set (_marker);
3820                         _selection_changed = true;
3821                 }
3822                 break;
3823         case Selection::Extend:
3824         {
3825                 Locations::LocationList ll;
3826                 list<ArdourMarker*> to_add;
3827                 framepos_t s, e;
3828                 _editor->selection->markers.range (s, e);
3829                 s = min (_marker->position(), s);
3830                 e = max (_marker->position(), e);
3831                 s = min (s, e);
3832                 e = max (s, e);
3833                 if (e < max_framepos) {
3834                         ++e;
3835                 }
3836                 _editor->session()->locations()->find_all_between (s, e, ll, Location::Flags (0));
3837                 for (Locations::LocationList::iterator i = ll.begin(); i != ll.end(); ++i) {
3838                         Editor::LocationMarkers* lm = _editor->find_location_markers (*i);
3839                         if (lm) {
3840                                 if (lm->start) {
3841                                         to_add.push_back (lm->start);
3842                                 }
3843                                 if (lm->end) {
3844                                         to_add.push_back (lm->end);
3845                                 }
3846                         }
3847                 }
3848                 if (!to_add.empty()) {
3849                         _editor->selection->add (to_add);
3850                         _selection_changed = true;
3851                 }
3852                 break;
3853         }
3854         case Selection::Add:
3855                 _editor->selection->add (_marker);
3856                 _selection_changed = true;
3857
3858                 break;
3859         }
3860
3861         /* Set up copies for us to manipulate during the drag
3862          */
3863
3864         for (MarkerSelection::iterator i = _editor->selection->markers.begin(); i != _editor->selection->markers.end(); ++i) {
3865
3866                 Location* l = _editor->find_location_from_marker (*i, is_start);
3867
3868                 if (!l) {
3869                         continue;
3870                 }
3871
3872                 if (l->is_mark()) {
3873                         _copied_locations.push_back (CopiedLocationMarkerInfo (l, *i));
3874                 } else {
3875                         /* range: check that the other end of the range isn't
3876                            already there.
3877                         */
3878                         CopiedLocationInfo::iterator x;
3879                         for (x = _copied_locations.begin(); x != _copied_locations.end(); ++x) {
3880                                 if (*(*x).location == *l) {
3881                                         break;
3882                                 }
3883                         }
3884                         if (x == _copied_locations.end()) {
3885                                 _copied_locations.push_back (CopiedLocationMarkerInfo (l, *i));
3886                         } else {
3887                                 (*x).markers.push_back (*i);
3888                                 (*x).move_both = true;
3889                         }
3890                 }
3891
3892         }
3893 }
3894
3895 void
3896 MarkerDrag::setup_pointer_frame_offset ()
3897 {
3898         bool is_start;
3899         Location *location = _editor->find_location_from_marker (_marker, is_start);
3900         _pointer_frame_offset = raw_grab_frame() - (is_start ? location->start() : location->end());
3901 }
3902
3903 void
3904 MarkerDrag::motion (GdkEvent* event, bool)
3905 {
3906         framecnt_t f_delta = 0;
3907         bool is_start;
3908         bool move_both = false;
3909         Location *real_location;
3910         Location *copy_location = 0;
3911         framecnt_t const sd = snap_delta (event->button.state);
3912
3913         framecnt_t const newframe = adjusted_frame (_drags->current_pointer_frame () + sd, event, true) - sd;
3914         framepos_t next = newframe;
3915
3916         if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::push_points_modifier ())) {
3917                 move_both = true;
3918         }
3919
3920         CopiedLocationInfo::iterator x;
3921
3922         /* find the marker we're dragging, and compute the delta */
3923
3924         for (x = _copied_locations.begin(); x != _copied_locations.end(); ++x) {
3925
3926                 copy_location = (*x).location;
3927
3928                 if (find (x->markers.begin(), x->markers.end(), _marker) != x->markers.end()) {
3929
3930                         /* this marker is represented by this
3931                          * CopiedLocationMarkerInfo
3932                          */
3933
3934                         if ((real_location = _editor->find_location_from_marker (_marker, is_start)) == 0) {
3935                                 /* que pasa ?? */
3936                                 return;
3937                         }
3938
3939                         if (real_location->is_mark()) {
3940                                 f_delta = newframe - copy_location->start();
3941                         } else {
3942
3943
3944                                 switch (_marker->type()) {
3945                                 case ArdourMarker::SessionStart:
3946                                 case ArdourMarker::RangeStart:
3947                                 case ArdourMarker::LoopStart:
3948                                 case ArdourMarker::PunchIn:
3949                                         f_delta = newframe - copy_location->start();
3950                                         break;
3951
3952                                 case ArdourMarker::SessionEnd:
3953                                 case ArdourMarker::RangeEnd:
3954                                 case ArdourMarker::LoopEnd:
3955                                 case ArdourMarker::PunchOut:
3956                                         f_delta = newframe - copy_location->end();
3957                                         break;
3958                                 default:
3959                                         /* what kind of marker is this ? */
3960                                         return;
3961                                 }
3962                         }
3963
3964                         break;
3965                 }
3966         }
3967
3968         if (x == _copied_locations.end()) {
3969                 /* hmm, impossible - we didn't find the dragged marker */
3970                 return;
3971         }
3972
3973         /* now move them all */
3974
3975         for (x = _copied_locations.begin(); x != _copied_locations.end(); ++x) {
3976
3977                 copy_location = x->location;
3978
3979                 if ((real_location = _editor->find_location_from_marker (x->markers.front(), is_start)) == 0) {
3980                         continue;
3981                 }
3982
3983                 if (real_location->locked()) {
3984                         continue;
3985                 }
3986
3987                 if (copy_location->is_mark()) {
3988
3989                         /* now move it */
3990
3991                         copy_location->set_start (copy_location->start() + f_delta);
3992
3993                 } else {
3994
3995                         framepos_t new_start = copy_location->start() + f_delta;
3996                         framepos_t new_end = copy_location->end() + f_delta;
3997
3998                         if (is_start) { // start-of-range marker
3999
4000                                 if (move_both || (*x).move_both) {
4001                                         copy_location->set_start (new_start);
4002                                         copy_location->set_end (new_end);
4003                                 } else  if (new_start < copy_location->end()) {
4004                                         copy_location->set_start (new_start);
4005                                 } else if (newframe > 0) {
4006                                         //_editor->snap_to (next, RoundUpAlways, true);
4007                                         copy_location->set_end (next);
4008                                         copy_location->set_start (newframe);
4009                                 }
4010
4011                         } else { // end marker
4012
4013                                 if (move_both || (*x).move_both) {
4014                                         copy_location->set_end (new_end);
4015                                         copy_location->set_start (new_start);
4016                                 } else if (new_end > copy_location->start()) {
4017                                         copy_location->set_end (new_end);
4018                                 } else if (newframe > 0) {
4019                                         //_editor->snap_to (next, RoundDownAlways, true);
4020                                         copy_location->set_start (next);
4021                                         copy_location->set_end (newframe);
4022                                 }
4023                         }
4024                 }
4025
4026                 update_item (copy_location);
4027
4028                 /* now lookup the actual GUI items used to display this
4029                  * location and move them to wherever the copy of the location
4030                  * is now. This means that the logic in ARDOUR::Location is
4031                  * still enforced, even though we are not (yet) modifying
4032                  * the real Location itself.
4033                  */
4034
4035                 Editor::LocationMarkers* lm = _editor->find_location_markers (real_location);
4036
4037                 if (lm) {
4038                         lm->set_position (copy_location->start(), copy_location->end());
4039                 }
4040
4041         }
4042
4043         assert (!_copied_locations.empty());
4044
4045         show_verbose_cursor_time (newframe);
4046 }
4047
4048 void
4049 MarkerDrag::finished (GdkEvent* event, bool movement_occurred)
4050 {
4051         if (!movement_occurred) {
4052
4053                 if (was_double_click()) {
4054                         _editor->rename_marker (_marker);
4055                         return;
4056                 }
4057
4058                 /* just a click, do nothing but finish
4059                    off the selection process
4060                 */
4061
4062                 Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
4063                 switch (op) {
4064                 case Selection::Set:
4065                         if (_editor->selection->selected (_marker) && _editor->selection->markers.size() > 1) {
4066                                 _editor->selection->set (_marker);
4067                                 _selection_changed = true;
4068                         }
4069                         break;
4070
4071                 case Selection::Toggle:
4072                         /* we toggle on the button release, click only */
4073                         _editor->selection->toggle (_marker);
4074                         _selection_changed = true;
4075
4076                         break;
4077
4078                 case Selection::Extend:
4079                 case Selection::Add:
4080                         break;
4081                 }
4082
4083                 if (_selection_changed) {
4084                         _editor->begin_reversible_selection_op(X_("Select Marker Release"));
4085                         _editor->commit_reversible_selection_op();
4086                 }
4087
4088                 return;
4089         }
4090
4091         _editor->_dragging_edit_point = false;
4092
4093         XMLNode &before = _editor->session()->locations()->get_state();
4094         bool in_command = false;
4095
4096         MarkerSelection::iterator i;
4097         CopiedLocationInfo::iterator x;
4098         bool is_start;
4099
4100         for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
4101              x != _copied_locations.end() && i != _editor->selection->markers.end();
4102              ++i, ++x) {
4103
4104                 Location * location = _editor->find_location_from_marker (*i, is_start);
4105
4106                 if (location) {
4107
4108                         if (location->locked()) {
4109                                 continue;
4110                         }
4111                         if (!in_command) {
4112                                 _editor->begin_reversible_command ( _("move marker") );
4113                                 in_command = true;
4114                         }
4115                         if (location->is_mark()) {
4116                                 location->set_start (((*x).location)->start());
4117                         } else {
4118                                 location->set (((*x).location)->start(), ((*x).location)->end());
4119                         }
4120                 }
4121         }
4122
4123         if (in_command) {
4124                 XMLNode &after = _editor->session()->locations()->get_state();
4125                 _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
4126                 _editor->commit_reversible_command ();
4127         }
4128 }
4129
4130 void
4131 MarkerDrag::aborted (bool movement_occurred)
4132 {
4133         if (!movement_occurred) {
4134                 return;
4135         }
4136
4137         for (CopiedLocationInfo::iterator x = _copied_locations.begin(); x != _copied_locations.end(); ++x) {
4138
4139                 /* move all markers to their original location */
4140
4141
4142                 for (vector<ArdourMarker*>::iterator m = x->markers.begin(); m != x->markers.end(); ++m) {
4143
4144                         bool is_start;
4145                         Location * location = _editor->find_location_from_marker (*m, is_start);
4146
4147                         if (location) {
4148                                 (*m)->set_position (is_start ? location->start() : location->end());
4149                         }
4150                 }
4151         }
4152 }
4153
4154 void
4155 MarkerDrag::update_item (Location*)
4156 {
4157         /* noop */
4158 }
4159
4160 ControlPointDrag::ControlPointDrag (Editor* e, ArdourCanvas::Item* i)
4161         : Drag (e, i)
4162         , _fixed_grab_x (0.0)
4163         , _fixed_grab_y (0.0)
4164         , _cumulative_x_drag (0.0)
4165         , _cumulative_y_drag (0.0)
4166         , _pushing (false)
4167         , _final_index (0)
4168 {
4169         if (_zero_gain_fraction < 0.0) {
4170                 _zero_gain_fraction = gain_to_slider_position_with_max (dB_to_coefficient (0.0), Config->get_max_gain());
4171         }
4172
4173         DEBUG_TRACE (DEBUG::Drags, "New ControlPointDrag\n");
4174
4175         _point = reinterpret_cast<ControlPoint*> (_item->get_data ("control_point"));
4176         assert (_point);
4177 }
4178
4179
4180 void
4181 ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
4182 {
4183         Drag::start_grab (event, _editor->cursors()->fader);
4184
4185         // start the grab at the center of the control point so
4186         // the point doesn't 'jump' to the mouse after the first drag
4187         _fixed_grab_x = _point->get_x();
4188         _fixed_grab_y = _point->get_y();
4189
4190         framepos_t pos = _editor->pixel_to_sample (_fixed_grab_x);
4191         setup_snap_delta (pos);
4192
4193         float const fraction = 1 - (_point->get_y() / _point->line().height());
4194         show_verbose_cursor_text (_point->line().get_verbose_cursor_string (fraction));
4195
4196         _pushing = Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::push_points_modifier ());
4197
4198         if (!_point->can_slide ()) {
4199                 _x_constrained = true;
4200         }
4201 }
4202
4203 void
4204 ControlPointDrag::motion (GdkEvent* event, bool first_motion)
4205 {
4206         double dx = _drags->current_pointer_x() - last_pointer_x();
4207         double dy = current_pointer_y() - last_pointer_y();
4208         bool need_snap = true;
4209
4210         if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::fine_adjust_modifier ())) {
4211                 dx *= 0.1;
4212                 dy *= 0.1;
4213                 need_snap = false;
4214         }
4215
4216         /* coordinate in pixels relative to the start of the region (for region-based automation)
4217            or track (for track-based automation) */
4218         double cx = _fixed_grab_x + _cumulative_x_drag + dx;
4219         double cy = _fixed_grab_y + _cumulative_y_drag + dy;
4220
4221         // calculate zero crossing point. back off by .01 to stay on the
4222         // positive side of zero
4223         double const zero_gain_y = (1.0 - _zero_gain_fraction) * _point->line().height() - .01;
4224
4225         if (_x_constrained) {
4226                 cx = _fixed_grab_x;
4227         }
4228         if (_y_constrained) {
4229                 cy = _fixed_grab_y;
4230         }
4231
4232         _cumulative_x_drag = cx - _fixed_grab_x;
4233         _cumulative_y_drag = cy - _fixed_grab_y;
4234
4235         cx = max (0.0, cx);
4236         cy = max (0.0, cy);
4237         cy = min ((double) _point->line().height(), cy);
4238
4239         // make sure we hit zero when passing through
4240         if ((cy < zero_gain_y && (cy - dy) > zero_gain_y) || (cy > zero_gain_y && (cy - dy) < zero_gain_y)) {
4241                 cy = zero_gain_y;
4242         }
4243
4244         framepos_t cx_frames = _editor->pixel_to_sample (cx) + snap_delta (event->button.state);
4245
4246         if (!_x_constrained && need_snap) {
4247                 _editor->snap_to_with_modifier (cx_frames, event);
4248         }
4249
4250         cx_frames -= snap_delta (event->button.state);
4251         cx_frames = min (cx_frames, _point->line().maximum_time());
4252
4253         float const fraction = 1.0 - (cy / _point->line().height());
4254
4255         if (first_motion) {
4256                 float const initial_fraction = 1.0 - (_fixed_grab_y / _point->line().height());
4257                 _editor->begin_reversible_command (_("automation event move"));
4258                 _point->line().start_drag_single (_point, _fixed_grab_x, initial_fraction);
4259         }
4260         pair<double, float> result;
4261         result = _point->line().drag_motion (_editor->sample_to_pixel_unrounded (cx_frames), fraction, false, _pushing, _final_index);
4262
4263         show_verbose_cursor_text (_point->line().get_verbose_cursor_string (result.second));
4264 }
4265
4266 void
4267 ControlPointDrag::finished (GdkEvent* event, bool movement_occurred)
4268 {
4269         if (!movement_occurred) {
4270
4271                 /* just a click */
4272                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::TertiaryModifier))) {
4273                         _editor->reset_point_selection ();
4274                 }
4275
4276         } else {
4277                 _point->line().end_drag (_pushing, _final_index);
4278                 _editor->commit_reversible_command ();
4279         }
4280 }
4281
4282 void
4283 ControlPointDrag::aborted (bool)
4284 {
4285         _point->line().reset ();
4286 }
4287
4288 bool
4289 ControlPointDrag::active (Editing::MouseMode m)
4290 {
4291         if (m == Editing::MouseDraw) {
4292                 /* always active in mouse draw */
4293                 return true;
4294         }
4295
4296         /* otherwise active if the point is on an automation line (ie not if its on a region gain line) */
4297         return dynamic_cast<AutomationLine*> (&(_point->line())) != 0;
4298 }
4299
4300 LineDrag::LineDrag (Editor* e, ArdourCanvas::Item* i)
4301         : Drag (e, i)
4302         , _line (0)
4303         , _fixed_grab_x (0.0)
4304         , _fixed_grab_y (0.0)
4305         , _cumulative_y_drag (0)
4306         , _before (0)
4307         , _after (0)
4308 {
4309         DEBUG_TRACE (DEBUG::Drags, "New LineDrag\n");
4310 }
4311
4312 void
4313 LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
4314 {
4315         _line = reinterpret_cast<AutomationLine*> (_item->get_data ("line"));
4316         assert (_line);
4317
4318         _item = &_line->grab_item ();
4319
4320         /* need to get x coordinate in terms of parent (TimeAxisItemView)
4321            origin, and ditto for y.
4322         */
4323
4324         double mx = event->button.x;
4325         double my = event->button.y;
4326
4327         _line->grab_item().canvas_to_item (mx, my);
4328
4329         framecnt_t const frame_within_region = (framecnt_t) floor (mx * _editor->samples_per_pixel);
4330
4331         if (!_line->control_points_adjacent (frame_within_region, _before, _after)) {
4332                 /* no adjacent points */
4333                 return;
4334         }
4335
4336         Drag::start_grab (event, _editor->cursors()->fader);
4337
4338         /* store grab start in item frame */
4339         double const bx = _line->nth (_before)->get_x();
4340         double const ax = _line->nth (_after)->get_x();
4341         double const click_ratio = (ax - mx) / (ax - bx);
4342
4343         double const cy = ((_line->nth (_before)->get_y() * click_ratio) + (_line->nth (_after)->get_y() * (1 - click_ratio)));
4344
4345         _fixed_grab_x = mx;
4346         _fixed_grab_y = cy;
4347
4348         double fraction = 1.0 - (cy / _line->height());
4349
4350         show_verbose_cursor_text (_line->get_verbose_cursor_string (fraction));
4351 }
4352
4353 void
4354 LineDrag::motion (GdkEvent* event, bool first_move)
4355 {
4356         double dy = current_pointer_y() - last_pointer_y();
4357
4358         if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::fine_adjust_modifier ())) {
4359                 dy *= 0.1;
4360         }
4361
4362         double cy = _fixed_grab_y + _cumulative_y_drag + dy;
4363
4364         _cumulative_y_drag = cy - _fixed_grab_y;
4365
4366         cy = max (0.0, cy);
4367         cy = min ((double) _line->height(), cy);
4368
4369         double const fraction = 1.0 - (cy / _line->height());
4370         uint32_t ignored;
4371
4372         if (first_move) {
4373                 float const initial_fraction = 1.0 - (_fixed_grab_y / _line->height());
4374
4375                 _editor->begin_reversible_command (_("automation range move"));
4376                 _line->start_drag_line (_before, _after, initial_fraction);
4377         }
4378
4379         /* we are ignoring x position for this drag, so we can just pass in anything */
4380         pair<double, float> result;
4381
4382         result = _line->drag_motion (0, fraction, true, false, ignored);
4383         show_verbose_cursor_text (_line->get_verbose_cursor_string (result.second));
4384 }
4385
4386 void
4387 LineDrag::finished (GdkEvent* event, bool movement_occurred)
4388 {
4389         if (movement_occurred) {
4390                 motion (event, false);
4391                 _line->end_drag (false, 0);
4392                 _editor->commit_reversible_command ();
4393         } else {
4394                 /* add a new control point on the line */
4395
4396                 AutomationTimeAxisView* atv;
4397
4398                 if ((atv = dynamic_cast<AutomationTimeAxisView*>(_editor->clicked_axisview)) != 0) {
4399                         framepos_t where = grab_frame ();
4400
4401                         double cx = 0;
4402                         double cy = _fixed_grab_y;
4403
4404                         _line->grab_item().item_to_canvas (cx, cy);
4405
4406                         atv->add_automation_event (event, where, cy, false);
4407                 } else if (dynamic_cast<AudioTimeAxisView*>(_editor->clicked_axisview) != 0) {
4408                         AudioRegionView* arv;
4409
4410                         if ((arv = dynamic_cast<AudioRegionView*>(_editor->clicked_regionview)) != 0) {
4411                                 arv->add_gain_point_event (&arv->get_gain_line()->grab_item(), event, false);
4412                         }
4413                 }
4414         }
4415 }
4416
4417 void
4418 LineDrag::aborted (bool)
4419 {
4420         _line->reset ();
4421 }
4422
4423 FeatureLineDrag::FeatureLineDrag (Editor* e, ArdourCanvas::Item* i)
4424         : Drag (e, i),
4425           _line (0),
4426           _arv (0),
4427           _region_view_grab_x (0.0),
4428           _cumulative_x_drag (0),
4429           _before (0.0),
4430           _max_x (0)
4431 {
4432         DEBUG_TRACE (DEBUG::Drags, "New FeatureLineDrag\n");
4433 }
4434
4435 void
4436 FeatureLineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
4437 {
4438         Drag::start_grab (event);
4439
4440         _line = reinterpret_cast<Line*> (_item);
4441         assert (_line);
4442
4443         /* need to get x coordinate in terms of parent (AudioRegionView) origin. */
4444
4445         double cx = event->button.x;
4446         double cy = event->button.y;
4447
4448         _item->parent()->canvas_to_item (cx, cy);
4449
4450         /* store grab start in parent frame */
4451         _region_view_grab_x = cx;
4452
4453         _before = *(float*) _item->get_data ("position");
4454
4455         _arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
4456
4457         _max_x = _editor->sample_to_pixel(_arv->get_duration());
4458 }
4459
4460 void
4461 FeatureLineDrag::motion (GdkEvent*, bool)
4462 {
4463         double dx = _drags->current_pointer_x() - last_pointer_x();
4464
4465         double cx = _region_view_grab_x + _cumulative_x_drag + dx;
4466
4467         _cumulative_x_drag += dx;
4468
4469         /* Clamp the min and max extent of the drag to keep it within the region view bounds */
4470
4471         if (cx > _max_x){
4472                 cx = _max_x;
4473         }
4474         else if(cx < 0){
4475                 cx = 0;
4476         }
4477
4478         boost::optional<ArdourCanvas::Rect> bbox = _line->bounding_box ();
4479         assert (bbox);
4480         _line->set (ArdourCanvas::Duple (cx, 2.0), ArdourCanvas::Duple (cx, bbox.get().height ()));
4481
4482         float *pos = new float;
4483         *pos = cx;
4484
4485         _line->set_data ("position", pos);
4486
4487         _before = cx;
4488 }
4489
4490 void
4491 FeatureLineDrag::finished (GdkEvent*, bool)
4492 {
4493         _arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
4494         _arv->update_transient(_before, _before);
4495 }
4496
4497 void
4498 FeatureLineDrag::aborted (bool)
4499 {
4500         //_line->reset ();
4501 }
4502
4503 RubberbandSelectDrag::RubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
4504         : Drag (e, i)
4505         , _vertical_only (false)
4506 {
4507         DEBUG_TRACE (DEBUG::Drags, "New RubberbandSelectDrag\n");
4508 }
4509
4510 void
4511 RubberbandSelectDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
4512 {
4513         Drag::start_grab (event);
4514         show_verbose_cursor_time (adjusted_current_frame (event, UIConfiguration::instance().get_rubberbanding_snaps_to_grid()));
4515 }
4516
4517 void
4518 RubberbandSelectDrag::motion (GdkEvent* event, bool)
4519 {
4520         framepos_t start;
4521         framepos_t end;
4522         double y1;
4523         double y2;
4524
4525         framepos_t const pf = adjusted_current_frame (event, UIConfiguration::instance().get_rubberbanding_snaps_to_grid());
4526
4527         framepos_t grab = grab_frame ();
4528         if (UIConfiguration::instance().get_rubberbanding_snaps_to_grid ()) {
4529                 _editor->snap_to_with_modifier (grab, event);
4530         } else {
4531                 grab = raw_grab_frame ();
4532         }
4533
4534         /* base start and end on initial click position */
4535
4536         if (pf < grab) {
4537                 start = pf;
4538                 end = grab;
4539         } else {
4540                 end = pf;
4541                 start = grab;
4542         }
4543
4544         if (current_pointer_y() < grab_y()) {
4545                 y1 = current_pointer_y();
4546                 y2 = grab_y();
4547         } else {
4548                 y2 = current_pointer_y();
4549                 y1 = grab_y();
4550         }
4551
4552         if (start != end || y1 != y2) {
4553
4554                 double x1 = _editor->sample_to_pixel (start);
4555                 double x2 = _editor->sample_to_pixel (end);
4556                 const double min_dimension = 2.0;
4557
4558                 if (_vertical_only) {
4559                         /* fixed 10 pixel width */
4560                         x2 = x1 + 10;
4561                 } else {
4562                         if (x2 < x1) {
4563                                 x2 = min (x1 - min_dimension, x2);
4564                         } else {
4565                                 x2 = max (x1 + min_dimension, x2);
4566                         }
4567                 }
4568
4569                 if (y2 < y1) {
4570                         y2 = min (y1 - min_dimension, y2);
4571                 } else {
4572                         y2 = max (y1 + min_dimension, y2);
4573                 }
4574
4575                 /* translate rect into item space and set */
4576
4577                 ArdourCanvas::Rect r (x1, y1, x2, y2);
4578
4579                 /* this drag is a _trackview_only == true drag, so the y1 and
4580                  * y2 (computed using current_pointer_y() and grab_y()) will be
4581                  * relative to the top of the trackview group). The
4582                  * rubberband rect has the same parent/scroll offset as the
4583                  * the trackview group, so we can use the "r" rect directly
4584                  * to set the shape of the rubberband.
4585                  */
4586
4587                 _editor->rubberband_rect->set (r);
4588                 _editor->rubberband_rect->show();
4589                 _editor->rubberband_rect->raise_to_top();
4590
4591                 show_verbose_cursor_time (pf);
4592
4593                 do_select_things (event, true);
4594         }
4595 }
4596
4597 void
4598 RubberbandSelectDrag::do_select_things (GdkEvent* event, bool drag_in_progress)
4599 {
4600         framepos_t x1;
4601         framepos_t x2;
4602         framepos_t grab = grab_frame ();
4603         framepos_t lpf = last_pointer_frame ();
4604
4605         if (!UIConfiguration::instance().get_rubberbanding_snaps_to_grid ()) {
4606                 grab = raw_grab_frame ();
4607                 lpf = _editor->pixel_to_sample_from_event (last_pointer_x());
4608         }
4609
4610         if (grab < lpf) {
4611                 x1 = grab;
4612                 x2 = lpf;
4613         } else {
4614                 x2 = grab;
4615                 x1 = lpf;
4616         }
4617
4618         double y1;
4619         double y2;
4620
4621         if (current_pointer_y() < grab_y()) {
4622                 y1 = current_pointer_y();
4623                 y2 = grab_y();
4624         } else {
4625                 y2 = current_pointer_y();
4626                 y1 = grab_y();
4627         }
4628
4629         select_things (event->button.state, x1, x2, y1, y2, drag_in_progress);
4630 }
4631
4632 void
4633 RubberbandSelectDrag::finished (GdkEvent* event, bool movement_occurred)
4634 {
4635         if (movement_occurred) {
4636
4637                 motion (event, false);
4638                 do_select_things (event, false);
4639
4640         } else {
4641
4642                 /* just a click */
4643
4644                 bool do_deselect = true;
4645                 MidiTimeAxisView* mtv;
4646
4647                 if ((mtv = dynamic_cast<MidiTimeAxisView*>(_editor->clicked_axisview)) != 0) {
4648                         /* MIDI track */
4649                         if (_editor->selection->empty() && _editor->mouse_mode == MouseDraw) {
4650                                 /* nothing selected */
4651                                 add_midi_region (mtv, true);
4652                                 do_deselect = false;
4653                         }
4654                 }
4655
4656                 /* do not deselect if Primary or Tertiary (toggle-select or
4657                  * extend-select are pressed.
4658                  */
4659
4660                 if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier) &&
4661                     !Keyboard::modifier_state_contains (event->button.state, Keyboard::TertiaryModifier) &&
4662                     do_deselect) {
4663                         deselect_things ();
4664                 }
4665
4666         }
4667
4668         _editor->rubberband_rect->hide();
4669 }
4670
4671 void
4672 RubberbandSelectDrag::aborted (bool)
4673 {
4674         _editor->rubberband_rect->hide ();
4675 }
4676
4677 TimeFXDrag::TimeFXDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, std::list<RegionView*> const & v)
4678         : RegionDrag (e, i, p, v)
4679 {
4680         DEBUG_TRACE (DEBUG::Drags, "New TimeFXDrag\n");
4681 }
4682
4683 void
4684 TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
4685 {
4686         Drag::start_grab (event, cursor);
4687
4688         _editor->get_selection().add (_primary);
4689
4690         framepos_t where = _primary->region()->position();
4691         setup_snap_delta (where);
4692
4693         show_verbose_cursor_duration (where, adjusted_current_frame (event), 0);
4694 }
4695
4696 void
4697 TimeFXDrag::motion (GdkEvent* event, bool)
4698 {
4699         RegionView* rv = _primary;
4700         StreamView* cv = rv->get_time_axis_view().view ();
4701
4702         pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (grab_y());
4703         int layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
4704         int layers = tv.first->layer_display() == Overlaid ? 1 : cv->layers();
4705         framepos_t pf = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
4706         _editor->snap_to_with_modifier (pf, event);
4707         pf -= snap_delta (event->button.state);
4708
4709         if (pf > rv->region()->position()) {
4710                 rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf, layers, layer);
4711         }
4712
4713         show_verbose_cursor_duration (_primary->region()->position(), pf, 0);
4714 }
4715
4716 void
4717 TimeFXDrag::finished (GdkEvent* event, bool movement_occurred)
4718 {
4719         /* this may have been a single click, no drag. We still want the dialog
4720            to show up in that case, so that the user can manually edit the
4721            parameters for the timestretch.
4722         */
4723
4724         float fraction = 1.0;
4725
4726         if (movement_occurred) {
4727
4728                 motion (event, false);
4729
4730                 _primary->get_time_axis_view().hide_timestretch ();
4731
4732                 framepos_t adjusted_frame_pos = adjusted_current_frame (event);
4733
4734                 if (adjusted_frame_pos < _primary->region()->position()) {
4735                         /* backwards drag of the left edge - not usable */
4736                         return;
4737                 }
4738
4739                 framecnt_t newlen = adjusted_frame_pos - _primary->region()->position();
4740
4741                 fraction = (double) newlen / (double) _primary->region()->length();
4742
4743 #ifndef USE_RUBBERBAND
4744                 // Soundtouch uses fraction / 100 instead of normal (/ 1)
4745                 if (_primary->region()->data_type() == DataType::AUDIO) {
4746                         fraction = (float) ((double) newlen - (double) _primary->region()->length()) / ((double) newlen) * 100.0f;
4747                 }
4748 #endif
4749         }
4750
4751         if (!_editor->get_selection().regions.empty()) {
4752                 /* primary will already be included in the selection, and edit
4753                    group shared editing will propagate selection across
4754                    equivalent regions, so just use the current region
4755                    selection.
4756                 */
4757
4758                 if (_editor->time_stretch (_editor->get_selection().regions, fraction) == -1) {
4759                         error << _("An error occurred while executing time stretch operation") << endmsg;
4760                 }
4761         }
4762 }
4763
4764 void
4765 TimeFXDrag::aborted (bool)
4766 {
4767         _primary->get_time_axis_view().hide_timestretch ();
4768 }
4769
4770 ScrubDrag::ScrubDrag (Editor* e, ArdourCanvas::Item* i)
4771         : Drag (e, i)
4772 {
4773         DEBUG_TRACE (DEBUG::Drags, "New ScrubDrag\n");
4774 }
4775
4776 void
4777 ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
4778 {
4779         Drag::start_grab (event);
4780 }
4781
4782 void
4783 ScrubDrag::motion (GdkEvent* /*event*/, bool)
4784 {
4785         _editor->scrub (adjusted_current_frame (0, false), _drags->current_pointer_x ());
4786 }
4787
4788 void
4789 ScrubDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
4790 {
4791         if (movement_occurred && _editor->session()) {
4792                 /* make sure we stop */
4793                 _editor->session()->request_transport_speed (0.0);
4794         }
4795 }
4796
4797 void
4798 ScrubDrag::aborted (bool)
4799 {
4800         /* XXX: TODO */
4801 }
4802
4803 SelectionDrag::SelectionDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
4804         : Drag (e, i)
4805         , _operation (o)
4806         , _add (false)
4807         , _time_selection_at_start (!_editor->get_selection().time.empty())
4808 {
4809         DEBUG_TRACE (DEBUG::Drags, "New SelectionDrag\n");
4810
4811         if (_time_selection_at_start) {
4812                 start_at_start = _editor->get_selection().time.start();
4813                 end_at_start = _editor->get_selection().time.end_frame();
4814         }
4815 }
4816
4817 void
4818 SelectionDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
4819 {
4820         if (_editor->session() == 0) {
4821                 return;
4822         }
4823
4824         Gdk::Cursor* cursor = MouseCursors::invalid_cursor();
4825
4826         switch (_operation) {
4827         case CreateSelection:
4828                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::CopyModifier)) {
4829                         _add = true;
4830                 } else {
4831                         _add = false;
4832                 }
4833                 cursor = _editor->cursors()->selector;
4834                 Drag::start_grab (event, cursor);
4835                 break;
4836
4837         case SelectionStartTrim:
4838                 if (_editor->clicked_axisview) {
4839                         _editor->clicked_axisview->order_selection_trims (_item, true);
4840                 }
4841                 Drag::start_grab (event, _editor->cursors()->left_side_trim);
4842                 break;
4843
4844         case SelectionEndTrim:
4845                 if (_editor->clicked_axisview) {
4846                         _editor->clicked_axisview->order_selection_trims (_item, false);
4847                 }
4848                 Drag::start_grab (event, _editor->cursors()->right_side_trim);
4849                 break;
4850
4851         case SelectionMove:
4852                 Drag::start_grab (event, cursor);
4853                 break;
4854
4855         case SelectionExtend:
4856                 Drag::start_grab (event, cursor);
4857                 break;
4858         }
4859
4860         if (_operation == SelectionMove) {
4861                 show_verbose_cursor_time (_editor->selection->time[_editor->clicked_selection].start);
4862         } else {
4863                 show_verbose_cursor_time (adjusted_current_frame (event));
4864         }
4865 }
4866
4867 void
4868 SelectionDrag::setup_pointer_frame_offset ()
4869 {
4870         switch (_operation) {
4871         case CreateSelection:
4872                 _pointer_frame_offset = 0;
4873                 break;
4874
4875         case SelectionStartTrim:
4876         case SelectionMove:
4877                 _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].start;
4878                 break;
4879
4880         case SelectionEndTrim:
4881                 _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].end;
4882                 break;
4883
4884         case SelectionExtend:
4885                 break;
4886         }
4887 }
4888
4889 void
4890 SelectionDrag::motion (GdkEvent* event, bool first_move)
4891 {
4892         framepos_t start = 0;
4893         framepos_t end = 0;
4894         framecnt_t length = 0;
4895         framecnt_t distance = 0;
4896
4897         framepos_t const pending_position = adjusted_current_frame (event);
4898
4899         if (_operation != CreateSelection && pending_position == last_pointer_frame()) {
4900                 return;
4901         }
4902
4903         switch (_operation) {
4904         case CreateSelection:
4905         {
4906                 framepos_t grab = grab_frame ();
4907
4908                 if (first_move) {
4909                         grab = adjusted_current_frame (event, false);
4910                         if (grab < pending_position) {
4911                                 _editor->snap_to (grab, RoundDownMaybe);
4912                         }  else {
4913                                 _editor->snap_to (grab, RoundUpMaybe);
4914                         }
4915                 }
4916
4917                 if (pending_position < grab) {
4918                         start = pending_position;
4919                         end = grab;
4920                 } else {
4921                         end = pending_position;
4922                         start = grab;
4923                 }
4924
4925                 /* first drag: Either add to the selection
4926                    or create a new selection
4927                 */
4928
4929                 if (first_move) {
4930
4931                         if (_add) {
4932
4933                                 /* adding to the selection */
4934                                 _editor->set_selected_track_as_side_effect (Selection::Add);
4935                                 _editor->clicked_selection = _editor->selection->add (start, end);
4936                                 _add = false;
4937
4938                         } else {
4939
4940                                 /* new selection */
4941
4942                                 if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
4943                                         _editor->set_selected_track_as_side_effect (Selection::Set);
4944                                 }
4945
4946                                 _editor->clicked_selection = _editor->selection->set (start, end);
4947                         }
4948                 }
4949
4950                 //if user is selecting a range on an automation track, bail out here before we get to the grouped stuff,
4951                 // because the grouped stuff will start working on tracks (routeTAVs), and end up removing this
4952                 AutomationTimeAxisView *atest = dynamic_cast<AutomationTimeAxisView *>(_editor->clicked_axisview);
4953                 if (atest) {
4954                         _editor->selection->add (atest);
4955                         break;
4956                 }
4957
4958                 /* select all tracks within the rectangle that we've marked out so far */
4959                 TrackViewList new_selection;
4960                 TrackViewList& all_tracks (_editor->track_views);
4961
4962                 ArdourCanvas::Coord const top = grab_y();
4963                 ArdourCanvas::Coord const bottom = current_pointer_y();
4964
4965                 if (top >= 0 && bottom >= 0) {
4966
4967                         //first, find the tracks that are covered in the y range selection
4968                         for (TrackViewList::const_iterator i = all_tracks.begin(); i != all_tracks.end(); ++i) {
4969                                 if ((*i)->covered_by_y_range (top, bottom)) {
4970                                         new_selection.push_back (*i);
4971                                 }
4972                         }
4973
4974                         //now find any tracks that are GROUPED with the tracks we selected
4975                         TrackViewList grouped_add = new_selection;
4976                         for (TrackViewList::const_iterator i = new_selection.begin(); i != new_selection.end(); ++i) {
4977                                 RouteTimeAxisView *n = dynamic_cast<RouteTimeAxisView *>(*i);
4978                                 if ( n && n->route()->route_group() && n->route()->route_group()->is_active() && n->route()->route_group()->enabled_property (ARDOUR::Properties::select.property_id) ) {
4979                                         for (TrackViewList::const_iterator j = all_tracks.begin(); j != all_tracks.end(); ++j) {
4980                                                 RouteTimeAxisView *check = dynamic_cast<RouteTimeAxisView *>(*j);
4981                                                 if ( check && (n != check) && (check->route()->route_group() == n->route()->route_group()) )
4982                                                         grouped_add.push_back (*j);
4983                                         }
4984                                 }
4985                         }
4986
4987                         //now compare our list with the current selection, and add or remove as necessary
4988                         //( NOTE: most mouse moves don't change the selection so we can't just SET it for every mouse move; it gets clunky )
4989                         TrackViewList tracks_to_add;
4990                         TrackViewList tracks_to_remove;
4991                         for (TrackViewList::const_iterator i = grouped_add.begin(); i != grouped_add.end(); ++i)
4992                                 if ( !_editor->selection->tracks.contains ( *i ) )
4993                                         tracks_to_add.push_back ( *i );
4994                         for (TrackViewList::const_iterator i = _editor->selection->tracks.begin(); i != _editor->selection->tracks.end(); ++i)
4995                                 if ( !grouped_add.contains ( *i ) )
4996                                         tracks_to_remove.push_back ( *i );
4997                         _editor->selection->add(tracks_to_add);
4998                         _editor->selection->remove(tracks_to_remove);
4999
5000                 }
5001         }
5002         break;
5003
5004         case SelectionStartTrim:
5005
5006                 end = _editor->selection->time[_editor->clicked_selection].end;
5007
5008                 if (pending_position > end) {
5009                         start = end;
5010                 } else {
5011                         start = pending_position;
5012                 }
5013                 break;
5014
5015         case SelectionEndTrim:
5016
5017                 start = _editor->selection->time[_editor->clicked_selection].start;
5018
5019                 if (pending_position < start) {
5020                         end = start;
5021                 } else {
5022                         end = pending_position;
5023                 }
5024
5025                 break;
5026
5027         case SelectionMove:
5028
5029                 start = _editor->selection->time[_editor->clicked_selection].start;
5030                 end = _editor->selection->time[_editor->clicked_selection].end;
5031
5032                 length = end - start;
5033                 distance = pending_position - start;
5034                 start = pending_position;
5035                 _editor->snap_to (start);
5036
5037                 end = start + length;
5038
5039                 break;
5040
5041         case SelectionExtend:
5042                 break;
5043         }
5044
5045         if (start != end) {
5046                 switch (_operation) {
5047                 case SelectionMove:
5048                         if (_time_selection_at_start) {
5049                                 _editor->selection->move_time (distance);
5050                         }
5051                         break;
5052                 default:
5053                         _editor->selection->replace (_editor->clicked_selection, start, end);
5054                 }
5055         }
5056
5057         if (_operation == SelectionMove) {
5058                 show_verbose_cursor_time(start);
5059         } else {
5060                 show_verbose_cursor_time(pending_position);
5061         }
5062 }
5063
5064 void
5065 SelectionDrag::finished (GdkEvent* event, bool movement_occurred)
5066 {
5067         Session* s = _editor->session();
5068
5069         _editor->begin_reversible_selection_op (X_("Change Time Selection"));
5070         if (movement_occurred) {
5071                 motion (event, false);
5072                 /* XXX this is not object-oriented programming at all. ick */
5073                 if (_editor->selection->time.consolidate()) {
5074                         _editor->selection->TimeChanged ();
5075                 }
5076
5077                 /* XXX what if its a music time selection? */
5078                 if (s) {
5079                         if (s->get_play_range() && s->transport_rolling()) {
5080                                 s->request_play_range (&_editor->selection->time, true);
5081                         } else if (!s->config.get_external_sync()) {
5082                                 if (UIConfiguration::instance().get_follow_edits() && !s->transport_rolling()) {
5083                                         if (_operation == SelectionEndTrim)
5084                                                 _editor->maybe_locate_with_edit_preroll( _editor->get_selection().time.end_frame());
5085                                         else
5086                                                 s->request_locate (_editor->get_selection().time.start());
5087                                 }
5088                         }
5089
5090                         if (_editor->get_selection().time.length() != 0) {
5091                                 s->set_range_selection (_editor->get_selection().time.start(), _editor->get_selection().time.end_frame());
5092                         } else {
5093                                 s->clear_range_selection ();
5094                         }
5095                 }
5096
5097         } else {
5098                 /* just a click, no pointer movement.
5099                  */
5100
5101                 if (_operation == SelectionExtend) {
5102                         if (_time_selection_at_start) {
5103                                 framepos_t pos = adjusted_current_frame (event, false);
5104                                 framepos_t start = min (pos, start_at_start);
5105                                 framepos_t end = max (pos, end_at_start);
5106                                 _editor->selection->set (start, end);
5107                         }
5108                 } else {
5109                         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::CopyModifier)) {
5110                                 if (_editor->clicked_selection) {
5111                                         _editor->selection->remove (_editor->clicked_selection);
5112                                 }
5113                         } else {
5114                                 if (!_editor->clicked_selection) {
5115                                         _editor->selection->clear_time();
5116                                 }
5117                         }
5118                 }
5119
5120                 if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
5121                         _editor->selection->set (_editor->clicked_axisview);
5122                 }
5123
5124                 if (s && s->get_play_range () && s->transport_rolling()) {
5125                         s->request_stop (false, false);
5126                 }
5127
5128         }
5129
5130         _editor->stop_canvas_autoscroll ();
5131         _editor->clicked_selection = 0;
5132         _editor->commit_reversible_selection_op ();
5133 }
5134
5135 void
5136 SelectionDrag::aborted (bool)
5137 {
5138         /* XXX: TODO */
5139 }
5140
5141 RangeMarkerBarDrag::RangeMarkerBarDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
5142         : Drag (e, i, false),
5143           _operation (o),
5144           _copy (false)
5145 {
5146         DEBUG_TRACE (DEBUG::Drags, "New RangeMarkerBarDrag\n");
5147
5148         _drag_rect = new ArdourCanvas::Rectangle (_editor->time_line_group,
5149                                                   ArdourCanvas::Rect (0.0, 0.0, 0.0,
5150                                                                       physical_screen_height (_editor->current_toplevel()->get_window())));
5151         _drag_rect->hide ();
5152
5153         _drag_rect->set_fill_color (UIConfiguration::instance().color ("range drag rect"));
5154         _drag_rect->set_outline_color (UIConfiguration::instance().color ("range drag rect"));
5155 }
5156
5157 RangeMarkerBarDrag::~RangeMarkerBarDrag()
5158 {
5159         /* normal canvas items will be cleaned up when their parent group is deleted. But
5160            this item is created as the child of a long-lived parent group, and so we
5161            need to explicitly delete it.
5162         */
5163         delete _drag_rect;
5164 }
5165
5166 void
5167 RangeMarkerBarDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
5168 {
5169         if (_editor->session() == 0) {
5170                 return;
5171         }
5172
5173         Gdk::Cursor* cursor = MouseCursors::invalid_cursor();
5174
5175         if (!_editor->temp_location) {
5176                 _editor->temp_location = new Location (*_editor->session());
5177         }
5178
5179         switch (_operation) {
5180         case CreateSkipMarker:
5181         case CreateRangeMarker:
5182         case CreateTransportMarker:
5183         case CreateCDMarker:
5184
5185                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::CopyModifier)) {
5186                         _copy = true;
5187                 } else {
5188                         _copy = false;
5189                 }
5190                 cursor = _editor->cursors()->selector;
5191                 break;
5192         }
5193
5194         Drag::start_grab (event, cursor);
5195
5196         show_verbose_cursor_time (adjusted_current_frame (event));
5197 }
5198
5199 void
5200 RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move)
5201 {
5202         framepos_t start = 0;
5203         framepos_t end = 0;
5204         ArdourCanvas::Rectangle *crect;
5205
5206         switch (_operation) {
5207         case CreateSkipMarker:
5208                 crect = _editor->range_bar_drag_rect;
5209                 break;
5210         case CreateRangeMarker:
5211                 crect = _editor->range_bar_drag_rect;
5212                 break;
5213         case CreateTransportMarker:
5214                 crect = _editor->transport_bar_drag_rect;
5215                 break;
5216         case CreateCDMarker:
5217                 crect = _editor->cd_marker_bar_drag_rect;
5218                 break;
5219         default:
5220                 error << string_compose (_("programming_error: %1"), "Error: unknown range marker op passed to Editor::drag_range_markerbar_op ()") << endmsg;
5221                 return;
5222                 break;
5223         }
5224
5225         framepos_t const pf = adjusted_current_frame (event);
5226
5227         if (_operation == CreateSkipMarker || _operation == CreateRangeMarker || _operation == CreateTransportMarker || _operation == CreateCDMarker) {
5228                 framepos_t grab = grab_frame ();
5229                 _editor->snap_to (grab);
5230
5231                 if (pf < grab_frame()) {
5232                         start = pf;
5233                         end = grab;
5234                 } else {
5235                         end = pf;
5236                         start = grab;
5237                 }
5238
5239                 /* first drag: Either add to the selection
5240                    or create a new selection.
5241                 */
5242
5243                 if (first_move) {
5244
5245                         _editor->temp_location->set (start, end);
5246
5247                         crect->show ();
5248
5249                         update_item (_editor->temp_location);
5250                         _drag_rect->show();
5251                         //_drag_rect->raise_to_top();
5252
5253                 }
5254         }
5255
5256         if (start != end) {
5257                 _editor->temp_location->set (start, end);
5258
5259                 double x1 = _editor->sample_to_pixel (start);
5260                 double x2 = _editor->sample_to_pixel (end);
5261                 crect->set_x0 (x1);
5262                 crect->set_x1 (x2);
5263
5264                 update_item (_editor->temp_location);
5265         }
5266
5267         show_verbose_cursor_time (pf);
5268
5269 }
5270
5271 void
5272 RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred)
5273 {
5274         Location * newloc = 0;
5275         string rangename;
5276         int flags;
5277
5278         if (movement_occurred) {
5279                 motion (event, false);
5280                 _drag_rect->hide();
5281
5282                 switch (_operation) {
5283                 case CreateSkipMarker:
5284                 case CreateRangeMarker:
5285                 case CreateCDMarker:
5286                     {
5287                         XMLNode &before = _editor->session()->locations()->get_state();
5288                         if (_operation == CreateSkipMarker) {
5289                                 _editor->begin_reversible_command (_("new skip marker"));
5290                                 _editor->session()->locations()->next_available_name(rangename,_("skip"));
5291                                 flags = Location::IsRangeMarker | Location::IsSkip;
5292                                 _editor->range_bar_drag_rect->hide();
5293                         } else if (_operation == CreateCDMarker) {
5294                                 _editor->session()->locations()->next_available_name(rangename, _("CD"));
5295                                 _editor->begin_reversible_command (_("new CD marker"));
5296                                 flags = Location::IsRangeMarker | Location::IsCDMarker;
5297                                 _editor->cd_marker_bar_drag_rect->hide();
5298                         } else {
5299                                 _editor->begin_reversible_command (_("new skip marker"));
5300                                 _editor->session()->locations()->next_available_name(rangename, _("unnamed"));
5301                                 flags = Location::IsRangeMarker;
5302                                 _editor->range_bar_drag_rect->hide();
5303                         }
5304                         newloc = new Location (
5305                                 *_editor->session(), _editor->temp_location->start(), _editor->temp_location->end(), rangename, (Location::Flags) flags
5306                                 );
5307
5308                         _editor->session()->locations()->add (newloc, true);
5309                         XMLNode &after = _editor->session()->locations()->get_state();
5310                         _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
5311                         _editor->commit_reversible_command ();
5312                         break;
5313                     }
5314
5315                 case CreateTransportMarker:
5316                         // popup menu to pick loop or punch
5317                         _editor->new_transport_marker_context_menu (&event->button, _item);
5318                         break;
5319                 }
5320
5321         } else {
5322
5323                 /* just a click, no pointer movement. remember that context menu stuff was handled elsewhere */
5324
5325                 if (_operation == CreateTransportMarker) {
5326
5327                         /* didn't drag, so just locate */
5328
5329                         _editor->session()->request_locate (grab_frame(), _editor->session()->transport_rolling());
5330
5331                 } else if (_operation == CreateCDMarker) {
5332
5333                         /* didn't drag, but mark is already created so do
5334                          * nothing */
5335
5336                 } else { /* operation == CreateRangeMarker || CreateSkipMarker */
5337
5338                         framepos_t start;
5339                         framepos_t end;
5340
5341                         _editor->session()->locations()->marks_either_side (grab_frame(), start, end);
5342
5343                         if (end == max_framepos) {
5344                                 end = _editor->session()->current_end_frame ();
5345                         }
5346
5347                         if (start == max_framepos) {
5348                                 start = _editor->session()->current_start_frame ();
5349                         }
5350
5351                         switch (_editor->mouse_mode) {
5352                         case MouseObject:
5353                                 /* find the two markers on either side and then make the selection from it */
5354                                 _editor->select_all_within (start, end, 0.0f, FLT_MAX, _editor->track_views, Selection::Set, false);
5355                                 break;
5356
5357                         case MouseRange:
5358                                 /* find the two markers on either side of the click and make the range out of it */
5359                                 _editor->selection->set (start, end);
5360                                 break;
5361
5362                         default:
5363                                 break;
5364                         }
5365                 }
5366         }
5367
5368         _editor->stop_canvas_autoscroll ();
5369 }
5370
5371 void
5372 RangeMarkerBarDrag::aborted (bool movement_occurred)
5373 {
5374         if (movement_occurred) {
5375                 _drag_rect->hide ();
5376         }
5377 }
5378
5379 void
5380 RangeMarkerBarDrag::update_item (Location* location)
5381 {
5382         double const x1 = _editor->sample_to_pixel (location->start());
5383         double const x2 = _editor->sample_to_pixel (location->end());
5384
5385         _drag_rect->set_x0 (x1);
5386         _drag_rect->set_x1 (x2);
5387 }
5388
5389 NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i)
5390         : Drag (e, i)
5391         , _cumulative_dx (0)
5392         , _cumulative_dy (0)
5393         , _was_selected (false)
5394 {
5395         DEBUG_TRACE (DEBUG::Drags, "New NoteDrag\n");
5396
5397         _primary = reinterpret_cast<NoteBase*> (_item->get_data ("notebase"));
5398         assert (_primary);
5399         _region = &_primary->region_view ();
5400         _note_height = _region->midi_stream_view()->note_height ();
5401 }
5402
5403 void
5404 NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
5405 {
5406         Drag::start_grab (event);
5407         setup_snap_delta (_region->source_beats_to_absolute_frames (_primary->note()->time ()));
5408
5409         if (!(_was_selected = _primary->selected())) {
5410
5411                 /* tertiary-click means extend selection - we'll do that on button release,
5412                    so don't add it here, because otherwise we make it hard to figure
5413                    out the "extend-to" range.
5414                 */
5415
5416                 bool extend = Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier);
5417
5418                 if (!extend) {
5419                         bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
5420
5421                         if (add) {
5422                                 _region->note_selected (_primary, true);
5423                         } else {
5424                                 _editor->get_selection().clear_points();
5425                                 _region->unique_select (_primary);
5426                         }
5427                 }
5428         }
5429 }
5430
5431 /** @return Current total drag x change in frames */
5432 frameoffset_t
5433 NoteDrag::total_dx (const guint state) const
5434 {
5435         /* dx in frames */
5436         frameoffset_t const dx = _editor->pixel_to_sample (_drags->current_pointer_x() - grab_x());
5437
5438         /* primary note time */
5439         frameoffset_t const n = _region->source_beats_to_absolute_frames (_primary->note()->time ());
5440
5441         /* new time of the primary note in session frames */
5442         frameoffset_t st = n + dx + snap_delta (state);
5443
5444         framepos_t const rp = _region->region()->position ();
5445
5446         /* prevent the note being dragged earlier than the region's position */
5447         st = max (st, rp);
5448
5449         /* possibly snap and return corresponding delta */
5450
5451         bool snap = true;
5452
5453         if (ArdourKeyboard::indicates_snap (state)) {
5454                 if (_editor->snap_mode () != SnapOff) {
5455                         snap = false;
5456                 }
5457         } else {
5458                 if (_editor->snap_mode () == SnapOff) {
5459                         snap = false;
5460                         /* inverted logic here - we;re in snapoff but we've pressed the snap delta modifier */
5461                         if (ArdourKeyboard::indicates_snap_delta (state)) {
5462                                 snap = true;
5463                         }
5464                 }
5465         }
5466
5467         frameoffset_t ret;
5468         if (snap) {
5469                 bool const ensure_snap = _editor->snap_mode () != SnapMagnetic;
5470                 ret =  _region->snap_frame_to_frame (st - rp, ensure_snap) + rp - n - snap_delta (state);
5471         } else {
5472                 ret = st - n - snap_delta (state);
5473         }
5474         return ret;
5475 }
5476
5477 /** @return Current total drag y change in note number */
5478 int8_t
5479 NoteDrag::total_dy () const
5480 {
5481         MidiStreamView* msv = _region->midi_stream_view ();
5482         double const y = _region->midi_view()->y_position ();
5483         /* new current note */
5484         uint8_t n = msv->y_to_note (current_pointer_y () - y);
5485         /* clamp */
5486         n = max (msv->lowest_note(), n);
5487         n = min (msv->highest_note(), n);
5488         /* and work out delta */
5489         return n - msv->y_to_note (grab_y() - y);
5490 }
5491
5492 void
5493 NoteDrag::motion (GdkEvent * event, bool)
5494 {
5495         /* Total change in x and y since the start of the drag */
5496         frameoffset_t const dx = total_dx (event->button.state);
5497         int8_t const dy = total_dy ();
5498
5499         /* Now work out what we have to do to the note canvas items to set this new drag delta */
5500         double const tdx = _editor->sample_to_pixel (dx) - _cumulative_dx;
5501         double const tdy = -dy * _note_height - _cumulative_dy;
5502
5503         if (tdx || tdy) {
5504                 _cumulative_dx += tdx;
5505                 _cumulative_dy += tdy;
5506
5507                 int8_t note_delta = total_dy();
5508
5509                 _region->move_selection (tdx, tdy, note_delta);
5510
5511                 /* the new note value may be the same as the old one, but we
5512                  * don't know what that means because the selection may have
5513                  * involved more than one note and we might be doing something
5514                  * odd with them. so show the note value anyway, always.
5515                  */
5516
5517                 uint8_t new_note = min (max (_primary->note()->note() + note_delta, 0), 127);
5518
5519                 _region->show_verbose_cursor_for_new_note_value (_primary->note(), new_note);
5520         }
5521 }
5522
5523 void
5524 NoteDrag::finished (GdkEvent* ev, bool moved)
5525 {
5526         if (!moved) {
5527                 /* no motion - select note */
5528
5529                 if (_editor->current_mouse_mode() == Editing::MouseContent ||
5530                     _editor->current_mouse_mode() == Editing::MouseDraw) {
5531
5532                         bool changed = false;
5533
5534                         if (_was_selected) {
5535                                 bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
5536                                 if (add) {
5537                                         _region->note_deselected (_primary);
5538                                         changed = true;
5539                                 } else {
5540                                         _editor->get_selection().clear_points();
5541                                         _region->unique_select (_primary);
5542                                         changed = true;
5543                                 }
5544                         } else {
5545                                 bool extend = Keyboard::modifier_state_equals (ev->button.state, Keyboard::TertiaryModifier);
5546                                 bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
5547
5548                                 if (!extend && !add && _region->selection_size() > 1) {
5549                                         _editor->get_selection().clear_points();
5550                                         _region->unique_select (_primary);
5551                                         changed = true;
5552                                 } else if (extend) {
5553                                         _region->note_selected (_primary, true, true);
5554                                         changed = true;
5555                                 } else {
5556                                         /* it was added during button press */
5557                                         changed = true;
5558
5559                                 }
5560                         }
5561
5562                         if (changed) {
5563                                 _editor->begin_reversible_selection_op(X_("Select Note Release"));
5564                                 _editor->commit_reversible_selection_op();
5565                         }
5566                 }
5567         } else {
5568                 _region->note_dropped (_primary, total_dx (ev->button.state), total_dy());
5569         }
5570 }
5571
5572 void
5573 NoteDrag::aborted (bool)
5574 {
5575         /* XXX: TODO */
5576 }
5577
5578 /** Make an AutomationRangeDrag for lines in an AutomationTimeAxisView */
5579 AutomationRangeDrag::AutomationRangeDrag (Editor* editor, AutomationTimeAxisView* atv, list<AudioRange> const & r)
5580         : Drag (editor, atv->base_item ())
5581         , _ranges (r)
5582         , _y_origin (atv->y_position())
5583         , _nothing_to_drag (false)
5584 {
5585         DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
5586         setup (atv->lines ());
5587 }
5588
5589 /** Make an AutomationRangeDrag for region gain lines or MIDI controller regions */
5590 AutomationRangeDrag::AutomationRangeDrag (Editor* editor, RegionView* rv, list<AudioRange> const & r)
5591         : Drag (editor, rv->get_canvas_group ())
5592         , _ranges (r)
5593         , _y_origin (rv->get_time_axis_view().y_position())
5594         , _nothing_to_drag (false)
5595         , _integral (false)
5596 {
5597         DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
5598
5599         list<boost::shared_ptr<AutomationLine> > lines;
5600
5601         AudioRegionView*      audio_view;
5602         AutomationRegionView* automation_view;
5603         if ((audio_view = dynamic_cast<AudioRegionView*>(rv))) {
5604                 lines.push_back (audio_view->get_gain_line ());
5605         } else if ((automation_view = dynamic_cast<AutomationRegionView*>(rv))) {
5606                 lines.push_back (automation_view->line ());
5607                 _integral = true;
5608         } else {
5609                 error << _("Automation range drag created for invalid region type") << endmsg;
5610         }
5611
5612         setup (lines);
5613 }
5614
5615 /** @param lines AutomationLines to drag.
5616  *  @param offset Offset from the session start to the points in the AutomationLines.
5617  */
5618 void
5619 AutomationRangeDrag::setup (list<boost::shared_ptr<AutomationLine> > const & lines)
5620 {
5621         /* find the lines that overlap the ranges being dragged */
5622         list<boost::shared_ptr<AutomationLine> >::const_iterator i = lines.begin ();
5623         while (i != lines.end ()) {
5624                 list<boost::shared_ptr<AutomationLine> >::const_iterator j = i;
5625                 ++j;
5626
5627                 pair<framepos_t, framepos_t> r = (*i)->get_point_x_range ();
5628
5629                 /* check this range against all the AudioRanges that we are using */
5630                 list<AudioRange>::const_iterator k = _ranges.begin ();
5631                 while (k != _ranges.end()) {
5632                         if (k->coverage (r.first, r.second) != Evoral::OverlapNone) {
5633                                 break;
5634                         }
5635                         ++k;
5636                 }
5637
5638                 /* add it to our list if it overlaps at all */
5639                 if (k != _ranges.end()) {
5640                         Line n;
5641                         n.line = *i;
5642                         n.state = 0;
5643                         n.range = r;
5644                         _lines.push_back (n);
5645                 }
5646
5647                 i = j;
5648         }
5649
5650         /* Now ::lines contains the AutomationLines that somehow overlap our drag */
5651 }
5652
5653 double
5654 AutomationRangeDrag::y_fraction (boost::shared_ptr<AutomationLine> line, double global_y) const
5655 {
5656         return 1.0 - ((global_y - _y_origin) / line->height());
5657 }
5658
5659 double
5660 AutomationRangeDrag::value (boost::shared_ptr<AutomationList> list, double x) const
5661 {
5662         const double v = list->eval(x);
5663         return _integral ? rint(v) : v;
5664 }
5665
5666 void
5667 AutomationRangeDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
5668 {
5669         Drag::start_grab (event, cursor);
5670
5671         /* Get line states before we start changing things */
5672         for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5673                 i->state = &i->line->get_state ();
5674                 i->original_fraction = y_fraction (i->line, current_pointer_y());
5675         }
5676
5677         if (_ranges.empty()) {
5678
5679                 /* No selected time ranges: drag all points */
5680                 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5681                         uint32_t const N = i->line->npoints ();
5682                         for (uint32_t j = 0; j < N; ++j) {
5683                                 i->points.push_back (i->line->nth (j));
5684                         }
5685                 }
5686
5687         }
5688
5689         if (_nothing_to_drag) {
5690                 return;
5691         }
5692 }
5693
5694 void
5695 AutomationRangeDrag::motion (GdkEvent*, bool first_move)
5696 {
5697         if (_nothing_to_drag && !first_move) {
5698                 return;
5699         }
5700
5701         if (first_move) {
5702                 _editor->begin_reversible_command (_("automation range move"));
5703
5704                 if (!_ranges.empty()) {
5705
5706                         for (list<AudioRange>::const_iterator i = _ranges.begin(); i != _ranges.end(); ++i) {
5707
5708                                 framecnt_t const half = (i->start + i->end) / 2;
5709
5710                                 /* find the line that this audio range starts in */
5711                                 list<Line>::iterator j = _lines.begin();
5712                                 while (j != _lines.end() && (j->range.first > i->start || j->range.second < i->start)) {
5713                                         ++j;
5714                                 }
5715
5716                                 if (j != _lines.end()) {
5717                                         boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
5718
5719                                 /* j is the line that this audio range starts in; fade into it;
5720                                    64 samples length plucked out of thin air.
5721                                 */
5722
5723                                         framepos_t a = i->start + 64;
5724                                         if (a > half) {
5725                                                 a = half;
5726                                         }
5727
5728                                         double const p = j->line->time_converter().from (i->start - j->line->time_converter().origin_b ());
5729                                         double const q = j->line->time_converter().from (a - j->line->time_converter().origin_b ());
5730
5731                                         XMLNode &before = the_list->get_state();
5732                                         bool const add_p = the_list->editor_add (p, value (the_list, p), false);
5733                                         bool const add_q = the_list->editor_add (q, value (the_list, q), false);
5734
5735                                         if (add_p || add_q) {
5736                                                 _editor->session()->add_command (
5737                                                         new MementoCommand<AutomationList>(*the_list.get (), &before, &the_list->get_state()));
5738                                         }
5739                                 }
5740
5741                                 /* same thing for the end */
5742
5743                                 j = _lines.begin();
5744                                 while (j != _lines.end() && (j->range.first > i->end || j->range.second < i->end)) {
5745                                         ++j;
5746                                 }
5747
5748                                 if (j != _lines.end()) {
5749                                         boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
5750
5751                                         /* j is the line that this audio range starts in; fade out of it;
5752                                            64 samples length plucked out of thin air.
5753                                         */
5754
5755                                         framepos_t b = i->end - 64;
5756                                         if (b < half) {
5757                                                 b = half;
5758                                         }
5759
5760                                         double const p = j->line->time_converter().from (b - j->line->time_converter().origin_b ());
5761                                         double const q = j->line->time_converter().from (i->end - j->line->time_converter().origin_b ());
5762
5763                                         XMLNode &before = the_list->get_state();
5764                                         bool const add_p = the_list->editor_add (p, value (the_list, p), false);
5765                                         bool const add_q = the_list->editor_add (q, value (the_list, q), false);
5766
5767                                         if (add_p || add_q) {
5768                                                 _editor->session()->add_command (
5769                                                         new MementoCommand<AutomationList>(*the_list.get (), &before, &the_list->get_state()));
5770                                         }
5771                                 }
5772                         }
5773
5774                         _nothing_to_drag = true;
5775
5776                         /* Find all the points that should be dragged and put them in the relevant
5777                            points lists in the Line structs.
5778                         */
5779
5780                         for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5781
5782                                 uint32_t const N = i->line->npoints ();
5783                                 for (uint32_t j = 0; j < N; ++j) {
5784
5785                                         /* here's a control point on this line */
5786                                         ControlPoint* p = i->line->nth (j);
5787                                         double const w = i->line->time_converter().to ((*p->model())->when) + i->line->time_converter().origin_b ();
5788
5789                                         /* see if it's inside a range */
5790                                         list<AudioRange>::const_iterator k = _ranges.begin ();
5791                                         while (k != _ranges.end() && (k->start >= w || k->end <= w)) {
5792                                                 ++k;
5793                                         }
5794
5795                                         if (k != _ranges.end()) {
5796                                                 /* dragging this point */
5797                                                 _nothing_to_drag = false;
5798                                                 i->points.push_back (p);
5799                                         }
5800                                 }
5801                         }
5802                 }
5803
5804                 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5805                         i->line->start_drag_multiple (i->points, y_fraction (i->line, current_pointer_y()), i->state);
5806                 }
5807         }
5808
5809         for (list<Line>::iterator l = _lines.begin(); l != _lines.end(); ++l) {
5810                 float const f = y_fraction (l->line, current_pointer_y());
5811                 /* we are ignoring x position for this drag, so we can just pass in anything */
5812                 pair<double, float> result;
5813                 uint32_t ignored;
5814                 result = l->line->drag_motion (0, f, true, false, ignored);
5815                 show_verbose_cursor_text (l->line->get_verbose_cursor_relative_string (l->original_fraction, result.second));
5816         }
5817 }
5818
5819 void
5820 AutomationRangeDrag::finished (GdkEvent* event, bool motion_occurred)
5821 {
5822         if (_nothing_to_drag || !motion_occurred) {
5823                 return;
5824         }
5825
5826         motion (event, false);
5827         for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5828                 i->line->end_drag (false, 0);
5829         }
5830
5831         _editor->commit_reversible_command ();
5832 }
5833
5834 void
5835 AutomationRangeDrag::aborted (bool)
5836 {
5837         for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
5838                 i->line->reset ();
5839         }
5840 }
5841
5842 DraggingView::DraggingView (RegionView* v, RegionDrag* parent, TimeAxisView* itav)
5843         : view (v)
5844         , initial_time_axis_view (itav)
5845 {
5846         /* note that time_axis_view may be null if the regionview was created
5847          * as part of a copy operation.
5848          */
5849         time_axis_view = parent->find_time_axis_view (&v->get_time_axis_view ());
5850         layer = v->region()->layer ();
5851         initial_y = v->get_canvas_group()->position().y;
5852         initial_playlist = v->region()->playlist ();
5853         initial_position = v->region()->position ();
5854         initial_end = v->region()->position () + v->region()->length ();
5855 }
5856
5857 PatchChangeDrag::PatchChangeDrag (Editor* e, PatchChange* i, MidiRegionView* r)
5858         : Drag (e, i->canvas_item ())
5859         , _region_view (r)
5860         , _patch_change (i)
5861         , _cumulative_dx (0)
5862 {
5863         DEBUG_TRACE (DEBUG::Drags, string_compose ("New PatchChangeDrag, patch @ %1, grab @ %2\n",
5864                                                    _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time()),
5865                                                    grab_frame()));
5866 }
5867
5868 void
5869 PatchChangeDrag::motion (GdkEvent* ev, bool)
5870 {
5871         framepos_t f = adjusted_current_frame (ev);
5872         boost::shared_ptr<Region> r = _region_view->region ();
5873         f = max (f, r->position ());
5874         f = min (f, r->last_frame ());
5875
5876         framecnt_t const dxf = f - grab_frame(); // permitted dx in frames
5877         double const dxu = _editor->sample_to_pixel (dxf); // permitted fx in units
5878         _patch_change->move (ArdourCanvas::Duple (dxu - _cumulative_dx, 0));
5879         _cumulative_dx = dxu;
5880 }
5881
5882 void
5883 PatchChangeDrag::finished (GdkEvent* ev, bool movement_occurred)
5884 {
5885         if (!movement_occurred) {
5886                 return;
5887         }
5888
5889         boost::shared_ptr<Region> r (_region_view->region ());
5890         framepos_t f = adjusted_current_frame (ev);
5891         f = max (f, r->position ());
5892         f = min (f, r->last_frame ());
5893
5894         _region_view->move_patch_change (
5895                 *_patch_change,
5896                 _region_view->region_frames_to_region_beats (f - (r->position() - r->start()))
5897                 );
5898 }
5899
5900 void
5901 PatchChangeDrag::aborted (bool)
5902 {
5903         _patch_change->move (ArdourCanvas::Duple (-_cumulative_dx, 0));
5904 }
5905
5906 void
5907 PatchChangeDrag::setup_pointer_frame_offset ()
5908 {
5909         boost::shared_ptr<Region> region = _region_view->region ();
5910         _pointer_frame_offset = raw_grab_frame() - _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time());
5911 }
5912
5913 MidiRubberbandSelectDrag::MidiRubberbandSelectDrag (Editor* e, MidiRegionView* rv)
5914         : RubberbandSelectDrag (e, rv->get_canvas_group ())
5915         , _region_view (rv)
5916 {
5917
5918 }
5919
5920 void
5921 MidiRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool /*drag_in_progress*/)
5922 {
5923         _region_view->update_drag_selection (
5924                 x1, x2, y1, y2,
5925                 Keyboard::modifier_state_contains (button_state, Keyboard::TertiaryModifier));
5926 }
5927
5928 void
5929 MidiRubberbandSelectDrag::deselect_things ()
5930 {
5931         /* XXX */
5932 }
5933
5934 MidiVerticalSelectDrag::MidiVerticalSelectDrag (Editor* e, MidiRegionView* rv)
5935         : RubberbandSelectDrag (e, rv->get_canvas_group ())
5936         , _region_view (rv)
5937 {
5938         _vertical_only = true;
5939 }
5940
5941 void
5942 MidiVerticalSelectDrag::select_things (int button_state, framepos_t /*x1*/, framepos_t /*x2*/, double y1, double y2, bool /*drag_in_progress*/)
5943 {
5944         double const y = _region_view->midi_view()->y_position ();
5945
5946         y1 = max (0.0, y1 - y);
5947         y2 = max (0.0, y2 - y);
5948
5949         _region_view->update_vertical_drag_selection (
5950                 y1,
5951                 y2,
5952                 Keyboard::modifier_state_contains (button_state, Keyboard::TertiaryModifier)
5953                 );
5954 }
5955
5956 void
5957 MidiVerticalSelectDrag::deselect_things ()
5958 {
5959         /* XXX */
5960 }
5961
5962 EditorRubberbandSelectDrag::EditorRubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
5963         : RubberbandSelectDrag (e, i)
5964 {
5965
5966 }
5967
5968 void
5969 EditorRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool drag_in_progress)
5970 {
5971         if (drag_in_progress) {
5972                 /* We just want to select things at the end of the drag, not during it */
5973                 return;
5974         }
5975
5976         Selection::Operation op = ArdourKeyboard::selection_type (button_state);
5977
5978         _editor->begin_reversible_selection_op (X_("rubberband selection"));
5979
5980         _editor->select_all_within (x1, x2 - 1, y1, y2, _editor->track_views, op, false);
5981
5982         _editor->commit_reversible_selection_op ();
5983 }
5984
5985 void
5986 EditorRubberbandSelectDrag::deselect_things ()
5987 {
5988         _editor->begin_reversible_selection_op (X_("Clear Selection (rubberband)"));
5989
5990         _editor->selection->clear_tracks();
5991         _editor->selection->clear_regions();
5992         _editor->selection->clear_points ();
5993         _editor->selection->clear_lines ();
5994         _editor->selection->clear_midi_notes ();
5995
5996         _editor->commit_reversible_selection_op();
5997 }
5998
5999 NoteCreateDrag::NoteCreateDrag (Editor* e, ArdourCanvas::Item* i, MidiRegionView* rv)
6000         : Drag (e, i)
6001         , _region_view (rv)
6002         , _drag_rect (0)
6003 {
6004         _note[0] = _note[1] = 0;
6005 }
6006
6007 NoteCreateDrag::~NoteCreateDrag ()
6008 {
6009         delete _drag_rect;
6010 }
6011
6012 framecnt_t
6013 NoteCreateDrag::grid_frames (framepos_t t) const
6014 {
6015         bool success;
6016         Evoral::Beats grid_beats = _editor->get_grid_type_as_beats (success, t);
6017         if (!success) {
6018                 grid_beats = Evoral::Beats(1);
6019         }
6020
6021         return _region_view->region_beats_to_region_frames (grid_beats);
6022 }
6023
6024 void
6025 NoteCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
6026 {
6027         Drag::start_grab (event, cursor);
6028
6029         _drag_rect = new ArdourCanvas::Rectangle (_region_view->get_canvas_group ());
6030
6031         framepos_t pf = _drags->current_pointer_frame ();
6032         framecnt_t const g = grid_frames (pf);
6033
6034         /* Hack so that we always snap to the note that we are over, instead of snapping
6035            to the next one if we're more than halfway through the one we're over.
6036         */
6037         if (_editor->snap_mode() == SnapNormal && pf > g / 2) {
6038                 pf -= g / 2;
6039         }
6040
6041         _note[0] = adjusted_frame (pf, event) - _region_view->region()->position ();
6042         _note[1] = _note[0];
6043
6044         MidiStreamView* sv = _region_view->midi_stream_view ();
6045         double const x = _editor->sample_to_pixel (_note[0]);
6046         double const y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
6047
6048         _drag_rect->set (ArdourCanvas::Rect (x, y, x, y + floor (_region_view->midi_stream_view()->note_height ())));
6049         _drag_rect->set_outline_all ();
6050         _drag_rect->set_outline_color (0xffffff99);
6051         _drag_rect->set_fill_color (0xffffff66);
6052 }
6053
6054 void
6055 NoteCreateDrag::motion (GdkEvent* event, bool)
6056 {
6057         _note[1] = max ((framepos_t)0, adjusted_current_frame (event) - _region_view->region()->position ());
6058         double const x0 = _editor->sample_to_pixel (_note[0]);
6059         double const x1 = _editor->sample_to_pixel (_note[1]);
6060         _drag_rect->set_x0 (std::min(x0, x1));
6061         _drag_rect->set_x1 (std::max(x0, x1));
6062 }
6063
6064 void
6065 NoteCreateDrag::finished (GdkEvent*, bool had_movement)
6066 {
6067         if (!had_movement) {
6068                 return;
6069         }
6070
6071         framepos_t const start = min (_note[0], _note[1]);
6072         framecnt_t length = (framecnt_t) fabs ((double)(_note[0] - _note[1]));
6073
6074         framecnt_t const g = grid_frames (start);
6075         Evoral::Beats const one_tick = Evoral::Beats::ticks(1);
6076
6077         if (_editor->snap_mode() == SnapNormal && length < g) {
6078                 length = g;
6079         }
6080
6081         Evoral::Beats length_beats = max (
6082                 one_tick, _region_view->region_frames_to_region_beats (length) - one_tick);
6083
6084         _region_view->create_note_at (start, _drag_rect->y0(), length_beats, false);
6085 }
6086
6087 double
6088 NoteCreateDrag::y_to_region (double y) const
6089 {
6090         double x = 0;
6091         _region_view->get_canvas_group()->canvas_to_item (x, y);
6092         return y;
6093 }
6094
6095 void
6096 NoteCreateDrag::aborted (bool)
6097 {
6098
6099 }
6100
6101 CrossfadeEdgeDrag::CrossfadeEdgeDrag (Editor* e, AudioRegionView* rv, ArdourCanvas::Item* i, bool start_yn)
6102         : Drag (e, i)
6103         , arv (rv)
6104         , start (start_yn)
6105 {
6106         std::cout << ("CrossfadeEdgeDrag is DEPRECATED.  See TrimDrag::preserve_fade_anchor") << endl;
6107 }
6108
6109 void
6110 CrossfadeEdgeDrag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
6111 {
6112         Drag::start_grab (event, cursor);
6113 }
6114
6115 void
6116 CrossfadeEdgeDrag::motion (GdkEvent*, bool)
6117 {
6118         double distance;
6119         double new_length;
6120         framecnt_t len;
6121
6122         boost::shared_ptr<AudioRegion> ar (arv->audio_region());
6123
6124         if (start) {
6125                 distance = _drags->current_pointer_x() - grab_x();
6126                 len = ar->fade_in()->back()->when;
6127         } else {
6128                 distance = grab_x() - _drags->current_pointer_x();
6129                 len = ar->fade_out()->back()->when;
6130         }
6131
6132         /* how long should it be ? */
6133
6134         new_length = len + _editor->pixel_to_sample (distance);
6135
6136         /* now check with the region that this is legal */
6137
6138         new_length = ar->verify_xfade_bounds (new_length, start);
6139
6140         if (start) {
6141                 arv->reset_fade_in_shape_width (ar, new_length);
6142         } else {
6143                 arv->reset_fade_out_shape_width (ar, new_length);
6144         }
6145 }
6146
6147 void
6148 CrossfadeEdgeDrag::finished (GdkEvent*, bool)
6149 {
6150         double distance;
6151         double new_length;
6152         framecnt_t len;
6153
6154         boost::shared_ptr<AudioRegion> ar (arv->audio_region());
6155
6156         if (start) {
6157                 distance = _drags->current_pointer_x() - grab_x();
6158                 len = ar->fade_in()->back()->when;
6159         } else {
6160                 distance = grab_x() - _drags->current_pointer_x();
6161                 len = ar->fade_out()->back()->when;
6162         }
6163
6164         new_length = ar->verify_xfade_bounds (len + _editor->pixel_to_sample (distance), start);
6165
6166         _editor->begin_reversible_command ("xfade trim");
6167         ar->playlist()->clear_owned_changes ();
6168
6169         if (start) {
6170                 ar->set_fade_in_length (new_length);
6171         } else {
6172                 ar->set_fade_out_length (new_length);
6173         }
6174
6175         /* Adjusting the xfade may affect other regions in the playlist, so we need
6176            to get undo Commands from the whole playlist rather than just the
6177            region.
6178         */
6179
6180         vector<Command*> cmds;
6181         ar->playlist()->rdiff (cmds);
6182         _editor->session()->add_commands (cmds);
6183         _editor->commit_reversible_command ();
6184
6185 }
6186
6187 void
6188 CrossfadeEdgeDrag::aborted (bool)
6189 {
6190         if (start) {
6191                 // arv->redraw_start_xfade ();
6192         } else {
6193                 // arv->redraw_end_xfade ();
6194         }
6195 }
6196
6197 RegionCutDrag::RegionCutDrag (Editor* e, ArdourCanvas::Item* item, framepos_t pos)
6198         : Drag (e, item, true)
6199         , line (new EditorCursor (*e))
6200 {
6201         line->set_position (pos);
6202         line->show ();
6203 }
6204
6205 RegionCutDrag::~RegionCutDrag ()
6206 {
6207         delete line;
6208 }
6209
6210 void
6211 RegionCutDrag::motion (GdkEvent*, bool)
6212 {
6213         framepos_t where = _drags->current_pointer_frame();
6214         _editor->snap_to (where);
6215
6216         line->set_position (where);
6217 }
6218
6219 void
6220 RegionCutDrag::finished (GdkEvent*, bool)
6221 {
6222         _editor->get_track_canvas()->canvas()->re_enter();
6223
6224         framepos_t pos = _drags->current_pointer_frame();
6225
6226         line->hide ();
6227
6228         RegionSelection rs = _editor->get_regions_from_selection_and_mouse (pos);
6229
6230         if (rs.empty()) {
6231                 return;
6232         }
6233
6234         _editor->split_regions_at (pos, rs);
6235 }
6236
6237 void
6238 RegionCutDrag::aborted (bool)
6239 {
6240 }