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