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
  26 #include "pbd/memento_command.h"
  27 #include "pbd/basename.h"
  28 #include "pbd/stateful_diff_command.h"
  29
  30 #include "gtkmm2ext/utils.h"
  31
  32 #include "ardour/audioengine.h"
  33 #include "ardour/audioregion.h"
  34 #include "ardour/dB.h"
  35 #include "ardour/midi_region.h"
  36 #include "ardour/operations.h"
  37 #include "ardour/region_factory.h"
  38 #include "ardour/session.h"
  39
  40 #include "editor.h"
  41 #include "i18n.h"
  42 #include "keyboard.h"
  43 #include "audio_region_view.h"
  44 #include "midi_region_view.h"
  45 #include "ardour_ui.h"
  46 #include "gui_thread.h"
  47 #include "control_point.h"
  48 #include "utils.h"
  49 #include "region_gain_line.h"
  50 #include "editor_drag.h"
  51 #include "audio_time_axis.h"
  52 #include "midi_time_axis.h"
  53 #include "canvas-note.h"
  54 #include "selection.h"
  55 #include "midi_selection.h"
  56 #include "automation_time_axis.h"
  57 #include "debug.h"
  58 #include "editor_cursors.h"
  59 #include "mouse_cursors.h"
  60 #include "verbose_cursor.h"
  61
  62 using namespace std;
  63 using namespace ARDOUR;
  64 using namespace PBD;
  65 using namespace Gtk;
  66 using namespace Gtkmm2ext;
  67 using namespace Editing;
  68 using namespace ArdourCanvas;
  69
  70 using Gtkmm2ext::Keyboard;
  71
  72 double ControlPointDrag::_zero_gain_fraction = -1.0;
  73
  74 DragManager::DragManager (Editor* e)
  75         : _editor (e)
  76         , _ending (false)
  77         , _current_pointer_frame (0)
  78 {
  79 }
  80
  81 DragManager::~DragManager ()
  82 {
  83         abort ();
  84 }
  85
  86 /** Call abort for each active drag */
  87 void
  88 DragManager::abort ()
  89 {
  90         _ending = true;
  91
  92         for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
  93                 (*i)->abort ();
  94                 delete *i;
  95         }
  96
  97         if (!_drags.empty ()) {
  98                 _editor->set_follow_playhead (_old_follow_playhead, false);
  99         }
 100
 101         _drags.clear ();
 102
 103         _ending = false;
 104 }
 105
 106 void
 107 DragManager::add (Drag* d)
 108 {
 109         d->set_manager (this);
 110         _drags.push_back (d);
 111 }
 112
 113 void
 114 DragManager::set (Drag* d, GdkEvent* e, Gdk::Cursor* c)
 115 {
 116         d->set_manager (this);
 117         _drags.push_back (d);
 118         start_grab (e, c);
 119 }
 120
 121 void
 122 DragManager::start_grab (GdkEvent* e, Gdk::Cursor* c)
 123 {
 124         /* Prevent follow playhead during the drag to be nice to the user */
 125         _old_follow_playhead = _editor->follow_playhead ();
 126         _editor->set_follow_playhead (false);
 127
 128         _current_pointer_frame = _editor->event_frame (e, &_current_pointer_x, &_current_pointer_y);
 129
 130         for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
 131                 (*i)->start_grab (e, c);
 132         }
 133 }
 134
 135 /** Call end_grab for each active drag.
 136  *  @return true if any drag reported movement having occurred.
 137  */
 138 bool
 139 DragManager::end_grab (GdkEvent* e)
 140 {
 141         _ending = true;
 142
 143         bool r = false;
 144         for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
 145                 bool const t = (*i)->end_grab (e);
 146                 if (t) {
 147                         r = true;
 148                 }
 149                 delete *i;
 150         }
 151
 152         _drags.clear ();
 153
 154         _ending = false;
 155
 156         _editor->set_follow_playhead (_old_follow_playhead, false);
 157
 158         return r;
 159 }
 160
 161 bool
 162 DragManager::motion_handler (GdkEvent* e, bool from_autoscroll)
 163 {
 164         bool r = false;
 165
 166         _current_pointer_frame = _editor->event_frame (e, &_current_pointer_x, &_current_pointer_y);
 167
 168         for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
 169                 bool const t = (*i)->motion_handler (e, from_autoscroll);
 170                 if (t) {
 171                         r = true;
 172                 }
 173
 174         }
 175
 176         return r;
 177 }
 178
 179 bool
 180 DragManager::have_item (ArdourCanvas::Item* i) const
 181 {
 182         list<Drag*>::const_iterator j = _drags.begin ();
 183         while (j != _drags.end() && (*j)->item () != i) {
 184                 ++j;
 185         }
 186
 187         return j != _drags.end ();
 188 }
 189
 190 Drag::Drag (Editor* e, ArdourCanvas::Item* i)
 191         : _editor (e)
 192         , _item (i)
 193         , _pointer_frame_offset (0)
 194         , _move_threshold_passed (false)
 195         , _raw_grab_frame (0)
 196         , _grab_frame (0)
 197         , _last_pointer_frame (0)
 198 {
 199
 200 }
 201
 202 void
 203 Drag::swap_grab (ArdourCanvas::Item* new_item, Gdk::Cursor* cursor, uint32_t time)
 204 {
 205         _item->ungrab (0);
 206         _item = new_item;
 207
 208         if (cursor == 0) {
 209                 _item->grab (Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK, time);
 210         } else {
 211                 _item->grab (Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK, *cursor, time);
 212         }
 213 }
 214
 215 void
 216 Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
 217 {
 218         // if dragging with button2, the motion is x constrained, with Alt-button2 it is y constrained
 219
 220         if (Keyboard::is_button2_event (&event->button)) {
 221                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::SecondaryModifier)) {
 222                         _y_constrained = true;
 223                         _x_constrained = false;
 224                 } else {
 225                         _y_constrained = false;
 226                         _x_constrained = true;
 227                 }
 228         } else {
 229                 _x_constrained = false;
 230                 _y_constrained = false;
 231         }
 232
 233         _raw_grab_frame = _editor->event_frame (event, &_grab_x, &_grab_y);
 234         setup_pointer_frame_offset ();
 235         _grab_frame = adjusted_frame (_raw_grab_frame, event);
 236         _last_pointer_frame = _grab_frame;
 237         _last_pointer_x = _grab_x;
 238         _last_pointer_y = _grab_y;
 239
 240         if (cursor == 0) {
 241                 _item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK,
 242                              event->button.time);
 243         } else {
 244                 _item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK,
 245                              *cursor,
 246                              event->button.time);
 247         }
 248
 249         if (_editor->session() && _editor->session()->transport_rolling()) {
 250                 _was_rolling = true;
 251         } else {
 252                 _was_rolling = false;
 253         }
 254
 255         switch (_editor->snap_type()) {
 256         case SnapToRegionStart:
 257         case SnapToRegionEnd:
 258         case SnapToRegionSync:
 259         case SnapToRegionBoundary:
 260                 _editor->build_region_boundary_cache ();
 261                 break;
 262         default:
 263                 break;
 264         }
 265 }
 266
 267 /** Call to end a drag `successfully'.  Ungrabs item and calls
 268  *  subclass' finished() method.
 269  *
 270  *  @param event GDK event, or 0.
 271  *  @return true if some movement occurred, otherwise false.
 272  */
 273 bool
 274 Drag::end_grab (GdkEvent* event)
 275 {
 276         _editor->stop_canvas_autoscroll ();
 277
 278         _item->ungrab (event ? event->button.time : 0);
 279
 280         finished (event, _move_threshold_passed);
 281
 282         _editor->verbose_cursor()->hide ();
 283
 284         return _move_threshold_passed;
 285 }
 286
 287 framepos_t
 288 Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
 289 {
 290         framepos_t pos = 0;
 291
 292         if (f > _pointer_frame_offset) {
 293                 pos = f - _pointer_frame_offset;
 294         }
 295
 296         if (snap) {
 297                 _editor->snap_to_with_modifier (pos, event);
 298         }
 299
 300         return pos;
 301 }
 302
 303 framepos_t
 304 Drag::adjusted_current_frame (GdkEvent const * event, bool snap) const
 305 {
 306         return adjusted_frame (_drags->current_pointer_frame (), event, snap);
 307 }
 308
 309 bool
 310 Drag::motion_handler (GdkEvent* event, bool from_autoscroll)
 311 {
 312         /* check to see if we have moved in any way that matters since the last motion event */
 313         if (_move_threshold_passed &&
 314             (!x_movement_matters() || _last_pointer_frame == adjusted_current_frame (event)) &&
 315             (!y_movement_matters() || _last_pointer_y == _drags->current_pointer_y ()) ) {
 316                 return false;
 317         }
 318
 319         pair<framecnt_t, int> const threshold = move_threshold ();
 320
 321         bool const old_move_threshold_passed = _move_threshold_passed;
 322
 323         if (!from_autoscroll && !_move_threshold_passed) {
 324
 325                 bool const xp = (::llabs (_drags->current_pointer_frame () - _raw_grab_frame) >= threshold.first);
 326                 bool const yp = (::fabs ((_drags->current_pointer_y () - _grab_y)) >= threshold.second);
 327
 328                 _move_threshold_passed = ((xp && x_movement_matters()) || (yp && y_movement_matters()));
 329         }
 330
 331         if (active (_editor->mouse_mode) && _move_threshold_passed) {
 332
 333                 if (event->motion.state & Gdk::BUTTON1_MASK || event->motion.state & Gdk::BUTTON2_MASK) {
 334                         if (!from_autoscroll) {
 335                                 bool const moving_left = _drags->current_pointer_x() < _last_pointer_x;
 336                                 bool const moving_up = _drags->current_pointer_y() < _last_pointer_y;
 337                                 _editor->maybe_autoscroll (true, allow_vertical_autoscroll (), moving_left, moving_up);
 338                         }
 339
 340                         motion (event, _move_threshold_passed != old_move_threshold_passed);
 341
 342                         _last_pointer_x = _drags->current_pointer_x ();
 343                         _last_pointer_y = _drags->current_pointer_y ();
 344                         _last_pointer_frame = adjusted_current_frame (event);
 345
 346                         return true;
 347                 }
 348         }
 349         return false;
 350 }
 351
 352 /** Call to abort a drag.  Ungrabs item and calls subclass's aborted () */
 353 void
 354 Drag::abort ()
 355 {
 356         if (_item) {
 357                 _item->ungrab (0);
 358         }
 359
 360         aborted (_move_threshold_passed);
 361
 362         _editor->stop_canvas_autoscroll ();
 363         _editor->verbose_cursor()->hide ();
 364 }
 365
 366 void
 367 Drag::show_verbose_cursor_time (framepos_t frame)
 368 {
 369         _editor->verbose_cursor()->set_time (
 370                 frame,
 371                 _drags->current_pointer_x() + 10 - _editor->horizontal_position(),
 372                 _drags->current_pointer_y() + 10 - _editor->vertical_adjustment.get_value() + _editor->canvas_timebars_vsize
 373                 );
 374
 375         _editor->verbose_cursor()->show ();
 376 }
 377
 378 void
 379 Drag::show_verbose_cursor_duration (framepos_t start, framepos_t end, double xoffset)
 380 {
 381         _editor->verbose_cursor()->show (xoffset);
 382
 383         _editor->verbose_cursor()->set_duration (
 384                 start, end,
 385                 _drags->current_pointer_x() + 10 - _editor->horizontal_position(),
 386                 _drags->current_pointer_y() + 10 - _editor->vertical_adjustment.get_value() + _editor->canvas_timebars_vsize
 387                 );
 388 }
 389
 390 void
 391 Drag::show_verbose_cursor_text (string const & text)
 392 {
 393         _editor->verbose_cursor()->show ();
 394
 395         _editor->verbose_cursor()->set (
 396                 text,
 397                 _drags->current_pointer_x() + 10 - _editor->horizontal_position(),
 398                 _drags->current_pointer_y() + 10 - _editor->vertical_adjustment.get_value() + _editor->canvas_timebars_vsize
 399                 );
 400 }
 401
 402 boost::shared_ptr<Region>
 403 Drag::add_midi_region (MidiTimeAxisView* view)
 404 {
 405         if (_editor->session()) {
 406                 const TempoMap& map (_editor->session()->tempo_map());
 407                 framecnt_t pos = grab_frame();
 408                 const Meter& m = map.meter_at (pos);
 409                 /* not that the frame rate used here can be affected by pull up/down which
 410                    might be wrong.
 411                 */
 412                 framecnt_t len = m.frames_per_bar (map.tempo_at (pos), _editor->session()->frame_rate());
 413                 return view->add_region (grab_frame(), len, true);
 414         }
 415
 416         return boost::shared_ptr<Region>();
 417 }
 418
 419 struct EditorOrderTimeAxisViewSorter {
 420     bool operator() (TimeAxisView* a, TimeAxisView* b) {
 421             RouteTimeAxisView* ra = dynamic_cast<RouteTimeAxisView*> (a);
 422             RouteTimeAxisView* rb = dynamic_cast<RouteTimeAxisView*> (b);
 423             assert (ra && rb);
 424             return ra->route()->order_key (EditorSort) < rb->route()->order_key (EditorSort);
 425     }
 426 };
 427
 428 RegionDrag::RegionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
 429         : Drag (e, i),
 430           _primary (p)
 431 {
 432         _editor->visible_order_range (&_visible_y_low, &_visible_y_high);
 433
 434         /* Make a list of tracks to refer to during the drag; we include hidden tracks,
 435            as some of the regions we are dragging may be on such tracks.
 436         */
 437
 438         TrackViewList track_views = _editor->track_views;
 439         track_views.sort (EditorOrderTimeAxisViewSorter ());
 440
 441         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 442                 _time_axis_views.push_back (*i);
 443
 444                 TimeAxisView::Children children_list = (*i)->get_child_list ();
 445                 for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) {
 446                         _time_axis_views.push_back (j->get());
 447                 }
 448         }
 449
 450         /* the list of views can be empty at this point if this is a region list-insert drag
 451          */
 452
 453         for (list<RegionView*>::const_iterator i = v.begin(); i != v.end(); ++i) {
 454                 _views.push_back (DraggingView (*i, this));
 455         }
 456
 457         RegionView::RegionViewGoingAway.connect (death_connection, invalidator (*this), boost::bind (&RegionDrag::region_going_away, this, _1), gui_context());
 458 }
 459
 460 void
 461 RegionDrag::region_going_away (RegionView* v)
 462 {
 463         list<DraggingView>::iterator i = _views.begin ();
 464         while (i != _views.end() && i->view != v) {
 465                 ++i;
 466         }
 467
 468         if (i != _views.end()) {
 469                 _views.erase (i);
 470         }
 471 }
 472
 473 /** Given a TimeAxisView, return the index of it into the _time_axis_views vector,
 474  *  or -1 if it is not found.
 475  */
 476 int
 477 RegionDrag::find_time_axis_view (TimeAxisView* t) const
 478 {
 479         int i = 0;
 480         int const N = _time_axis_views.size ();
 481         while (i < N && _time_axis_views[i] != t) {
 482                 ++i;
 483         }
 484
 485         if (i == N) {
 486                 return -1;
 487         }
 488
 489         return i;
 490 }
 491
 492 RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
 493         : RegionDrag (e, i, p, v),
 494           _brushing (b),
 495           _total_x_delta (0)
 496 {
 497
 498 }
 499
 500
 501 void
 502 RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 503 {
 504         Drag::start_grab (event, cursor);
 505
 506         show_verbose_cursor_time (_last_frame_position);
 507
 508         pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (_drags->current_pointer_y ());
 509         _last_pointer_time_axis_view = find_time_axis_view (tv.first);
 510         _last_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
 511 }
 512
 513 double
 514 RegionMotionDrag::compute_x_delta (GdkEvent const * event, framepos_t* pending_region_position)
 515 {
 516         /* compute the amount of pointer motion in frames, and where
 517            the region would be if we moved it by that much.
 518         */
 519         *pending_region_position = adjusted_current_frame (event);
 520
 521         framepos_t sync_frame;
 522         framecnt_t sync_offset;
 523         int32_t sync_dir;
 524
 525         sync_offset = _primary->region()->sync_offset (sync_dir);
 526
 527         /* we don't handle a sync point that lies before zero.
 528          */
 529         if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) {
 530
 531                 sync_frame = *pending_region_position + (sync_dir*sync_offset);
 532
 533                 _editor->snap_to_with_modifier (sync_frame, event);
 534
 535                 *pending_region_position = _primary->region()->adjust_to_sync (sync_frame);
 536
 537         } else {
 538                 *pending_region_position = _last_frame_position;
 539         }
 540
 541         if (*pending_region_position > max_framepos - _primary->region()->length()) {
 542                 *pending_region_position = _last_frame_position;
 543         }
 544
 545         double dx = 0;
 546
 547         /* in locked edit mode, reverse the usual meaning of _x_constrained */
 548         bool const x_move_allowed = Config->get_edit_mode() == Lock ? _x_constrained : !_x_constrained;
 549
 550         if ((*pending_region_position != _last_frame_position) && x_move_allowed) {
 551
 552                 /* x movement since last time (in pixels) */
 553                 dx = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->frames_per_unit;
 554
 555                 /* total x movement */
 556                 framecnt_t total_dx = *pending_region_position;
 557                 if (regions_came_from_canvas()) {
 558                         total_dx = total_dx - grab_frame ();
 559                 }
 560
 561                 /* check that no regions have gone off the start of the session */
 562                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 563                         if ((i->view->region()->position() + total_dx) < 0) {
 564                                 dx = 0;
 565                                 *pending_region_position = _last_frame_position;
 566                                 break;
 567                         }
 568                 }
 569
 570                 _last_frame_position = *pending_region_position;
 571         }
 572
 573         return dx;
 574 }
 575
 576 bool
 577 RegionMotionDrag::y_movement_allowed (int delta_track, double delta_layer) const
 578 {
 579         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 580                 int const n = i->time_axis_view + delta_track;
 581                 if (n < 0 || n >= int (_time_axis_views.size())) {
 582                         /* off the top or bottom track */
 583                         return false;
 584                 }
 585
 586                 RouteTimeAxisView const * to = dynamic_cast<RouteTimeAxisView const *> (_time_axis_views[n]);
 587                 if (to == 0 || !to->is_track() || to->track()->data_type() != i->view->region()->data_type()) {
 588                         /* not a track, or the wrong type */
 589                         return false;
 590                 }
 591
 592                 double const l = i->layer + delta_layer;
 593
 594                 /* Note that we allow layer to be up to 0.5 below zero, as this is used by `Expanded'
 595                    mode to allow the user to place a region below another on layer 0.
 596                 */
 597                 if (delta_track == 0 && (l < -0.5 || l >= int (to->view()->layers()))) {
 598                         /* Off the top or bottom layer; note that we only refuse if the track hasn't changed.
 599                            If it has, the layers will be munged later anyway, so it's ok.
 600                         */
 601                         return false;
 602                 }
 603         }
 604
 605         /* all regions being dragged are ok with this change */
 606         return true;
 607 }
 608
 609 void
 610 RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 611 {
 612         assert (!_views.empty ());
 613
 614         /* Find the TimeAxisView that the pointer is now over */
 615         pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (_drags->current_pointer_y ());
 616
 617         if (first_move && tv.first->view()->layer_display() == Stacked) {
 618                 tv.first->view()->set_layer_display (Expanded);
 619         }
 620
 621         /* Bail early if we're not over a track */
 622         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv.first);
 623         if (!rtv || !rtv->is_track()) {
 624                 _editor->verbose_cursor()->hide ();
 625                 return;
 626         }
 627
 628         /* Note: time axis views in this method are often expressed as an index into the _time_axis_views vector */
 629
 630         /* Here's the current pointer position in terms of time axis view and layer */
 631         int const current_pointer_time_axis_view = find_time_axis_view (tv.first);
 632         double const current_pointer_layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
 633
 634         /* Work out the change in x */
 635         framepos_t pending_region_position;
 636         double const x_delta = compute_x_delta (event, &pending_region_position);
 637
 638         /* Work out the change in y */
 639         int delta_time_axis_view = current_pointer_time_axis_view - _last_pointer_time_axis_view;
 640         double delta_layer = current_pointer_layer - _last_pointer_layer;
 641
 642         if (!y_movement_allowed (delta_time_axis_view, delta_layer)) {
 643                 /* this y movement is not allowed, so do no y movement this time */
 644                 delta_time_axis_view = 0;
 645                 delta_layer = 0;
 646         }
 647
 648         if (x_delta == 0 && delta_time_axis_view == 0 && delta_layer == 0 && !first_move) {
 649                 /* haven't reached next snap point, and we're not switching
 650                    trackviews nor layers. nothing to do.
 651                 */
 652                 return;
 653         }
 654
 655         pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
 656
 657         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
 658
 659                 RegionView* rv = i->view;
 660
 661                 if (rv->region()->locked()) {
 662                         continue;
 663                 }
 664
 665                 if (first_move) {
 666
 667                         rv->drag_start ();
 668
 669                         /* Absolutely no idea why this is necessary, but it is; without
 670                            it, the region view disappears after the reparent.
 671                         */
 672                         _editor->update_canvas_now ();
 673
 674                         /* Reparent to a non scrolling group so that we can keep the
 675                            region selection above all time axis views.
 676                            Reparenting means that we will have to move the region view
 677                            later, as the two parent groups have different coordinates.
 678                         */
 679
 680                         rv->get_canvas_group()->reparent (*(_editor->_region_motion_group));
 681
 682                         rv->fake_set_opaque (true);
 683                 }
 684
 685                 /* If we have moved tracks, we'll fudge the layer delta so that the
 686                    region gets moved back onto layer 0 on its new track; this avoids
 687                    confusion when dragging regions from non-zero layers onto different
 688                    tracks.
 689                 */
 690                 double this_delta_layer = delta_layer;
 691                 if (delta_time_axis_view != 0) {
 692                         this_delta_layer = - i->layer;
 693                 }
 694
 695                 /* The TimeAxisView that this region is now on */
 696                 TimeAxisView* tv = _time_axis_views[i->time_axis_view + delta_time_axis_view];
 697
 698                 /* Ensure it is moved from stacked -> expanded if appropriate */
 699                 if (tv->view()->layer_display() == Stacked) {
 700                         tv->view()->set_layer_display (Expanded);
 701                 }
 702
 703                 /* We're only allowed to go -ve in layer on Expanded views */
 704                 if (tv->view()->layer_display() != Expanded && (i->layer + this_delta_layer) < 0) {
 705                         this_delta_layer = - i->layer;
 706                 }
 707
 708                 /* Set height */
 709                 rv->set_height (tv->view()->child_height ());
 710
 711                 /* Update show/hidden status as the region view may have come from a hidden track,
 712                    or have moved to one.
 713                 */
 714                 if (tv->hidden ()) {
 715                         rv->get_canvas_group()->hide ();
 716                 } else {
 717                         rv->get_canvas_group()->show ();
 718                 }
 719
 720                 /* Update the DraggingView */
 721                 i->time_axis_view += delta_time_axis_view;
 722                 i->layer += this_delta_layer;
 723
 724                 if (_brushing) {
 725                         _editor->mouse_brush_insert_region (rv, pending_region_position);
 726                 } else {
 727                         double x = 0;
 728                         double y = 0;
 729
 730                         /* Get the y coordinate of the top of the track that this region is now on */
 731                         tv->canvas_display()->i2w (x, y);
 732                         y += _editor->get_trackview_group_vertical_offset();
 733
 734                         /* And adjust for the layer that it should be on */
 735                         StreamView* cv = tv->view ();
 736                         switch (cv->layer_display ()) {
 737                         case Overlaid:
 738                                 break;
 739                         case Stacked:
 740                                 y += (cv->layers() - i->layer - 1) * cv->child_height ();
 741                                 break;
 742                         case Expanded:
 743                                 y += (cv->layers() - i->layer - 0.5) * 2 * cv->child_height ();
 744                                 break;
 745                         }
 746
 747                         /* Now move the region view */
 748                         rv->move (x_delta, y - rv->get_canvas_group()->property_y());
 749                 }
 750
 751         } /* foreach region */
 752
 753         _total_x_delta += x_delta;
 754
 755         if (first_move) {
 756                 _editor->cursor_group->raise_to_top();
 757         }
 758
 759         if (x_delta != 0 && !_brushing) {
 760                 show_verbose_cursor_time (_last_frame_position);
 761         }
 762
 763         _last_pointer_time_axis_view += delta_time_axis_view;
 764         _last_pointer_layer += delta_layer;
 765 }
 766
 767 void
 768 RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 769 {
 770         if (_copy && first_move) {
 771
 772                 /* duplicate the regionview(s) and region(s) */
 773
 774                 list<DraggingView> new_regionviews;
 775
 776                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 777
 778                         RegionView* rv = i->view;
 779                         AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
 780                         MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
 781
 782                         const boost::shared_ptr<const Region> original = rv->region();
 783                         boost::shared_ptr<Region> region_copy = RegionFactory::create (original, true);
 784                         region_copy->set_position (original->position());
 785
 786                         RegionView* nrv;
 787                         if (arv) {
 788                                 boost::shared_ptr<AudioRegion> audioregion_copy
 789                                 = boost::dynamic_pointer_cast<AudioRegion>(region_copy);
 790
 791                                 nrv = new AudioRegionView (*arv, audioregion_copy);
 792                         } else if (mrv) {
 793                                 boost::shared_ptr<MidiRegion> midiregion_copy
 794                                         = boost::dynamic_pointer_cast<MidiRegion>(region_copy);
 795                                 nrv = new MidiRegionView (*mrv, midiregion_copy);
 796                         } else {
 797                                 continue;
 798                         }
 799
 800                         nrv->get_canvas_group()->show ();
 801                         new_regionviews.push_back (DraggingView (nrv, this));
 802
 803                         /* swap _primary to the copy */
 804
 805                         if (rv == _primary) {
 806                                 _primary = nrv;
 807                         }
 808
 809                         /* ..and deselect the one we copied */
 810
 811                         rv->set_selected (false);
 812                 }
 813
 814                 if (!new_regionviews.empty()) {
 815
 816                         /* reflect the fact that we are dragging the copies */
 817
 818                         _views = new_regionviews;
 819
 820                         swap_grab (new_regionviews.front().view->get_canvas_group (), 0, event ? event->motion.time : 0);
 821
 822                         /*
 823                           sync the canvas to what we think is its current state
 824                           without it, the canvas seems to
 825                           "forget" to update properly after the upcoming reparent()
 826                           ..only if the mouse is in rapid motion at the time of the grab.
 827                           something to do with regionview creation taking so long?
 828                         */
 829                         _editor->update_canvas_now();
 830                 }
 831         }
 832
 833         RegionMotionDrag::motion (event, first_move);
 834 }
 835
 836 void
 837 RegionMotionDrag::finished (GdkEvent *, bool)
 838 {
 839         for (vector<TimeAxisView*>::iterator i = _time_axis_views.begin(); i != _time_axis_views.end(); ++i) {
 840                 if (!(*i)->view()) {
 841                         continue;
 842                 }
 843
 844                 if ((*i)->view()->layer_display() == Expanded) {
 845                         (*i)->view()->set_layer_display (Stacked);
 846                 }
 847         }
 848 }
 849
 850 void
 851 RegionMoveDrag::finished (GdkEvent* ev, bool movement_occurred)
 852 {
 853         RegionMotionDrag::finished (ev, movement_occurred);
 854
 855         if (!movement_occurred) {
 856                 /* just a click */
 857                 return;
 858         }
 859
 860         /* reverse this here so that we have the correct logic to finalize
 861            the drag.
 862         */
 863
 864         if (Config->get_edit_mode() == Lock) {
 865                 _x_constrained = !_x_constrained;
 866         }
 867
 868         assert (!_views.empty ());
 869
 870         /* We might have hidden region views so that they weren't visible during the drag
 871            (when they have been reparented).  Now everything can be shown again, as region
 872            views are back in their track parent groups.
 873         */
 874         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
 875                 i->view->get_canvas_group()->show ();
 876         }
 877
 878         bool const changed_position = (_last_frame_position != _primary->region()->position());
 879         bool const changed_tracks = (_time_axis_views[_views.front().time_axis_view] != &_views.front().view->get_time_axis_view());
 880         framecnt_t const drag_delta = _primary->region()->position() - _last_frame_position;
 881
 882         _editor->update_canvas_now ();
 883
 884         if (_copy) {
 885
 886                 finished_copy (
 887                         changed_position,
 888                         changed_tracks,
 889                         drag_delta
 890                         );
 891
 892         } else {
 893
 894                 finished_no_copy (
 895                         changed_position,
 896                         changed_tracks,
 897                         drag_delta
 898                         );
 899
 900         }
 901
 902         if (_editor->session() && Config->get_always_play_range()) {
 903                 _editor->session()->request_locate (_editor->get_selection().regions.start());
 904         }
 905 }
 906
 907 void
 908 RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, framecnt_t const drag_delta)
 909 {
 910         RegionSelection new_views;
 911         PlaylistSet modified_playlists;
 912         list<RegionView*> views_to_delete;
 913
 914         if (_brushing) {
 915                 /* all changes were made during motion event handlers */
 916
 917                 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
 918                         delete i->view;
 919                 }
 920
 921                 _editor->commit_reversible_command ();
 922                 return;
 923         }
 924
 925         if (_x_constrained) {
 926                 _editor->begin_reversible_command (Operations::fixed_time_region_copy);
 927         } else {
 928                 _editor->begin_reversible_command (Operations::region_copy);
 929         }
 930
 931         /* insert the regions into their new playlists */
 932         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 933
 934                 if (i->view->region()->locked()) {
 935                         continue;
 936                 }
 937
 938                 framepos_t where;
 939
 940                 if (changed_position && !_x_constrained) {
 941                         where = i->view->region()->position() - drag_delta;
 942                 } else {
 943                         where = i->view->region()->position();
 944                 }
 945
 946                 RegionView* new_view = insert_region_into_playlist (
 947                         i->view->region(), dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]), i->layer, where, modified_playlists
 948                         );
 949
 950                 if (new_view == 0) {
 951                         continue;
 952                 }
 953
 954                 new_views.push_back (new_view);
 955
 956                 /* we don't need the copied RegionView any more */
 957                 views_to_delete.push_back (i->view);
 958         }
 959
 960         /* Delete views that are no longer needed; we can't do this directly in the iteration over _views
 961            because when views are deleted they are automagically removed from _views, which messes
 962            up the iteration.
 963         */
 964         for (list<RegionView*>::iterator i = views_to_delete.begin(); i != views_to_delete.end(); ++i) {
 965                 delete *i;
 966         }
 967
 968         /* If we've created new regions either by copying or moving
 969            to a new track, we want to replace the old selection with the new ones
 970         */
 971
 972         if (new_views.size() > 0) {
 973                 _editor->selection->set (new_views);
 974         }
 975
 976         /* write commands for the accumulated diffs for all our modified playlists */
 977         add_stateful_diff_commands_for_playlists (modified_playlists);
 978
 979         _editor->commit_reversible_command ();
 980 }
 981
 982 void
 983 RegionMoveDrag::finished_no_copy (
 984         bool const changed_position,
 985         bool const changed_tracks,
 986         framecnt_t const drag_delta
 987         )
 988 {
 989         RegionSelection new_views;
 990         PlaylistSet modified_playlists;
 991         PlaylistSet frozen_playlists;
 992         set<RouteTimeAxisView*> views_to_update;
 993
 994         if (_brushing) {
 995                 /* all changes were made during motion event handlers */
 996                 _editor->commit_reversible_command ();
 997                 return;
 998         }
 999
1000         if (_x_constrained) {
1001                 _editor->begin_reversible_command (_("fixed time region drag"));
1002         } else {
1003                 _editor->begin_reversible_command (Operations::region_drag);
1004         }
1005
1006         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ) {
1007
1008                 RegionView* rv = i->view;
1009
1010                 RouteTimeAxisView* const dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[i->time_axis_view]);
1011                 double const dest_layer = i->layer;
1012
1013                 if (rv->region()->locked()) {
1014                         ++i;
1015                         continue;
1016                 }
1017
1018                 views_to_update.insert (dest_rtv);
1019
1020                 framepos_t where;
1021
1022                 if (changed_position && !_x_constrained) {
1023                         where = rv->region()->position() - drag_delta;
1024                 } else {
1025                         where = rv->region()->position();
1026                 }
1027
1028                 if (changed_tracks) {
1029
1030                         /* insert into new playlist */
1031
1032                         RegionView* new_view = insert_region_into_playlist (
1033                                 RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where, modified_playlists
1034                                 );
1035
1036                         if (new_view == 0) {
1037                                 ++i;
1038                                 continue;
1039                         }
1040
1041                         new_views.push_back (new_view);
1042
1043                         /* remove from old playlist */
1044
1045                         /* the region that used to be in the old playlist is not
1046                            moved to the new one - we use a copy of it. as a result,
1047                            any existing editor for the region should no longer be
1048                            visible.
1049                         */
1050                         rv->hide_region_editor();
1051                         rv->fake_set_opaque (false);
1052
1053                         remove_region_from_playlist (rv->region(), i->initial_playlist, modified_playlists);
1054
1055                 } else {
1056
1057                         rv->region()->clear_changes ();
1058
1059                         /*
1060                            motion on the same track. plonk the previously reparented region
1061                            back to its original canvas group (its streamview).
1062                            No need to do anything for copies as they are fake regions which will be deleted.
1063                         */
1064
1065                         rv->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
1066                         rv->get_canvas_group()->property_y() = i->initial_y;
1067                         rv->drag_end ();
1068
1069                         /* just change the model */
1070
1071                         boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
1072
1073                         if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
1074                                 playlist->set_layer (rv->region(), dest_layer);
1075                         }
1076
1077                         /* freeze playlist to avoid lots of relayering in the case of a multi-region drag */
1078
1079                         pair<PlaylistSet::iterator, bool> r = frozen_playlists.insert (playlist);
1080
1081                         if (r.second) {
1082                                 playlist->freeze ();
1083                         }
1084
1085                         /* this movement may result in a crossfade being modified, so we need to get undo
1086                            data from the playlist as well as the region.
1087                         */
1088
1089                         r = modified_playlists.insert (playlist);
1090                         if (r.second) {
1091                                 playlist->clear_changes ();
1092                         }
1093
1094                         rv->region()->set_position (where);
1095
1096                         _editor->session()->add_command (new StatefulDiffCommand (rv->region()));
1097                 }
1098
1099                 if (changed_tracks) {
1100
1101                         /* OK, this is where it gets tricky. If the playlist was being used by >1 tracks, and the region
1102                            was selected in all of them, then removing it from a playlist will have removed all
1103                            trace of it from _views (i.e. there were N regions selected, we removed 1,
1104                            but since its the same playlist for N tracks, all N tracks updated themselves, removed the
1105                            corresponding regionview, and _views is now empty).
1106
1107                            This could have invalidated any and all iterators into _views.
1108
1109                            The heuristic we use here is: if the region selection is empty, break out of the loop
1110                            here. if the region selection is not empty, then restart the loop because we know that
1111                            we must have removed at least the region(view) we've just been working on as well as any
1112                            that we processed on previous iterations.
1113
1114                            EXCEPT .... if we are doing a copy drag, then _views hasn't been modified and
1115                            we can just iterate.
1116                         */
1117
1118
1119                         if (_views.empty()) {
1120                                 break;
1121                         } else {
1122                                 i = _views.begin();
1123                         }
1124
1125                 } else {
1126                         ++i;
1127                 }
1128         }
1129
1130         /* If we've created new regions either by copying or moving
1131            to a new track, we want to replace the old selection with the new ones
1132         */
1133
1134         if (new_views.size() > 0) {
1135                 _editor->selection->set (new_views);
1136         }
1137
1138         for (set<boost::shared_ptr<Playlist> >::iterator p = frozen_playlists.begin(); p != frozen_playlists.end(); ++p) {
1139                 (*p)->thaw();
1140         }
1141
1142         /* write commands for the accumulated diffs for all our modified playlists */
1143         add_stateful_diff_commands_for_playlists (modified_playlists);
1144
1145         _editor->commit_reversible_command ();
1146
1147         /* We have futzed with the layering of canvas items on our streamviews.
1148            If any region changed layer, this will have resulted in the stream
1149            views being asked to set up their region views, and all will be well.
1150            If not, we might now have badly-ordered region views.  Ask the StreamViews
1151            involved to sort themselves out, just in case.
1152         */
1153
1154         for (set<RouteTimeAxisView*>::iterator i = views_to_update.begin(); i != views_to_update.end(); ++i) {
1155                 (*i)->view()->playlist_layered ((*i)->track ());
1156         }
1157 }
1158
1159 /** Remove a region from a playlist, clearing the diff history of the playlist first if necessary.
1160  *  @param region Region to remove.
1161  *  @param playlist playlist To remove from.
1162  *  @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
1163  *  that clear_changes () is only called once per playlist.
1164  */
1165 void
1166 RegionMoveDrag::remove_region_from_playlist (
1167         boost::shared_ptr<Region> region,
1168         boost::shared_ptr<Playlist> playlist,
1169         PlaylistSet& modified_playlists
1170         )
1171 {
1172         pair<set<boost::shared_ptr<Playlist> >::iterator, bool> r = modified_playlists.insert (playlist);
1173
1174         if (r.second) {
1175                 playlist->clear_changes ();
1176         }
1177
1178         playlist->remove_region (region);
1179 }
1180
1181
1182 /** Insert a region into a playlist, handling the recovery of the resulting new RegionView, and
1183  *  clearing the playlist's diff history first if necessary.
1184  *  @param region Region to insert.
1185  *  @param dest_rtv Destination RouteTimeAxisView.
1186  *  @param dest_layer Destination layer.
1187  *  @param where Destination position.
1188  *  @param modified_playlists The playlist will be added to this if it is not there already; used to ensure
1189  *  that clear_changes () is only called once per playlist.
1190  *  @return New RegionView, or 0 if no insert was performed.
1191  */
1192 RegionView *
1193 RegionMoveDrag::insert_region_into_playlist (
1194         boost::shared_ptr<Region> region,
1195         RouteTimeAxisView* dest_rtv,
1196         layer_t dest_layer,
1197         framecnt_t where,
1198         PlaylistSet& modified_playlists
1199         )
1200 {
1201         boost::shared_ptr<Playlist> dest_playlist = dest_rtv->playlist ();
1202         if (!dest_playlist) {
1203                 return 0;
1204         }
1205
1206         /* arrange to collect the new region view that will be created as a result of our playlist insertion */
1207         _new_region_view = 0;
1208         sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &RegionMoveDrag::collect_new_region_view));
1209
1210         /* clear history for the playlist we are about to insert to, provided we haven't already done so */
1211         pair<PlaylistSet::iterator, bool> r = modified_playlists.insert (dest_playlist);
1212         if (r.second) {
1213                 dest_playlist->clear_changes ();
1214         }
1215
1216         dest_playlist->add_region (region, where);
1217
1218         if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
1219                 dest_playlist->set_layer (region, dest_layer);
1220         }
1221
1222         c.disconnect ();
1223
1224         assert (_new_region_view);
1225
1226         return _new_region_view;
1227 }
1228
1229 void
1230 RegionMoveDrag::collect_new_region_view (RegionView* rv)
1231 {
1232         _new_region_view = rv;
1233 }
1234
1235 void
1236 RegionMoveDrag::add_stateful_diff_commands_for_playlists (PlaylistSet const & playlists)
1237 {
1238         for (PlaylistSet::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
1239                 StatefulDiffCommand* c = new StatefulDiffCommand (*i);
1240                 if (!c->empty()) {
1241                         _editor->session()->add_command (c);
1242                 } else {
1243                         delete c;
1244                 }
1245         }
1246 }
1247
1248
1249 void
1250 RegionMoveDrag::aborted (bool movement_occurred)
1251 {
1252         if (_copy) {
1253
1254                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1255                         delete i->view;
1256                 }
1257
1258                 _views.clear ();
1259
1260         } else {
1261                 RegionMotionDrag::aborted (movement_occurred);
1262         }
1263 }
1264
1265 void
1266 RegionMotionDrag::aborted (bool)
1267 {
1268         for (vector<TimeAxisView*>::iterator i = _time_axis_views.begin(); i != _time_axis_views.end(); ++i) {
1269                 if ((*i)->view()->layer_display() == Expanded) {
1270                         (*i)->view()->set_layer_display (Stacked);
1271                 }
1272         }
1273
1274         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1275                 RegionView* rv = i->view;
1276                 TimeAxisView* tv = &(rv->get_time_axis_view ());
1277                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
1278                 assert (rtv);
1279                 rv->get_canvas_group()->reparent (*rtv->view()->canvas_item());
1280                 rv->get_canvas_group()->property_y() = 0;
1281                 rv->drag_end ();
1282                 rv->fake_set_opaque (false);
1283                 rv->move (-_total_x_delta, 0);
1284                 rv->set_height (rtv->view()->child_height ());
1285         }
1286
1287         _editor->update_canvas_now ();
1288 }
1289
1290 /** @param b true to brush, otherwise false.
1291  *  @param c true to make copies of the regions being moved, otherwise false.
1292  */
1293 RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b, bool c)
1294         : RegionMotionDrag (e, i, p, v, b),
1295           _copy (c)
1296 {
1297         DEBUG_TRACE (DEBUG::Drags, "New RegionMoveDrag\n");
1298
1299         double speed = 1;
1300         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&_primary->get_time_axis_view ());
1301         if (rtv && rtv->is_track()) {
1302                 speed = rtv->track()->speed ();
1303         }
1304
1305         _last_frame_position = static_cast<framepos_t> (_primary->region()->position() / speed);
1306 }
1307
1308 void
1309 RegionMoveDrag::setup_pointer_frame_offset ()
1310 {
1311         _pointer_frame_offset = raw_grab_frame() - _last_frame_position;
1312 }
1313
1314 RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, framepos_t pos)
1315         : RegionMotionDrag (e, 0, 0, list<RegionView*> (), false)
1316 {
1317         DEBUG_TRACE (DEBUG::Drags, "New RegionInsertDrag\n");
1318
1319         assert ((boost::dynamic_pointer_cast<AudioRegion> (r) && dynamic_cast<AudioTimeAxisView*> (v)) ||
1320                 (boost::dynamic_pointer_cast<MidiRegion> (r) && dynamic_cast<MidiTimeAxisView*> (v)));
1321
1322         _primary = v->view()->create_region_view (r, false, false);
1323
1324         _primary->get_canvas_group()->show ();
1325         _primary->set_position (pos, 0);
1326         _views.push_back (DraggingView (_primary, this));
1327
1328         _last_frame_position = pos;
1329
1330         _item = _primary->get_canvas_group ();
1331 }
1332
1333 void
1334 RegionInsertDrag::finished (GdkEvent *, bool)
1335 {
1336         _editor->update_canvas_now ();
1337
1338         RouteTimeAxisView* dest_rtv = dynamic_cast<RouteTimeAxisView*> (_time_axis_views[_views.front().time_axis_view]);
1339
1340         _primary->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
1341         _primary->get_canvas_group()->property_y() = 0;
1342
1343         boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
1344
1345         _editor->begin_reversible_command (Operations::insert_region);
1346         playlist->clear_changes ();
1347         playlist->add_region (_primary->region (), _last_frame_position);
1348         _editor->session()->add_command (new StatefulDiffCommand (playlist));
1349         _editor->commit_reversible_command ();
1350
1351         delete _primary;
1352         _primary = 0;
1353         _views.clear ();
1354 }
1355
1356 void
1357 RegionInsertDrag::aborted (bool)
1358 {
1359         delete _primary;
1360         _primary = 0;
1361         _views.clear ();
1362 }
1363
1364 RegionSpliceDrag::RegionSpliceDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
1365         : RegionMoveDrag (e, i, p, v, false, false)
1366 {
1367         DEBUG_TRACE (DEBUG::Drags, "New RegionSpliceDrag\n");
1368 }
1369
1370 struct RegionSelectionByPosition {
1371     bool operator() (RegionView*a, RegionView* b) {
1372             return a->region()->position () < b->region()->position();
1373     }
1374 };
1375
1376 void
1377 RegionSpliceDrag::motion (GdkEvent* event, bool)
1378 {
1379         /* Which trackview is this ? */
1380
1381         pair<TimeAxisView*, double> const tvp = _editor->trackview_by_y_position (_drags->current_pointer_y ());
1382         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
1383
1384         /* The region motion is only processed if the pointer is over
1385            an audio track.
1386         */
1387
1388         if (!tv || !tv->is_track()) {
1389                 /* To make sure we hide the verbose canvas cursor when the mouse is
1390                    not held over and audiotrack.
1391                 */
1392                 _editor->verbose_cursor()->hide ();
1393                 return;
1394         }
1395
1396         int dir;
1397
1398         if ((_drags->current_pointer_x() - last_pointer_x()) > 0) {
1399                 dir = 1;
1400         } else {
1401                 dir = -1;
1402         }
1403
1404         RegionSelection copy (_editor->selection->regions);
1405
1406         RegionSelectionByPosition cmp;
1407         copy.sort (cmp);
1408
1409         framepos_t const pf = adjusted_current_frame (event);
1410
1411         for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
1412
1413                 RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*> (&(*i)->get_time_axis_view());
1414
1415                 if (!atv) {
1416                         continue;
1417                 }
1418
1419                 boost::shared_ptr<Playlist> playlist;
1420
1421                 if ((playlist = atv->playlist()) == 0) {
1422                         continue;
1423                 }
1424
1425                 if (!playlist->region_is_shuffle_constrained ((*i)->region())) {
1426                         continue;
1427                 }
1428
1429                 if (dir > 0) {
1430                         if (pf < (*i)->region()->last_frame() + 1) {
1431                                 continue;
1432                         }
1433                 } else {
1434                         if (pf > (*i)->region()->first_frame()) {
1435                                 continue;
1436                         }
1437                 }
1438
1439
1440                 playlist->shuffle ((*i)->region(), dir);
1441         }
1442 }
1443
1444 void
1445 RegionSpliceDrag::finished (GdkEvent* event, bool movement_occurred)
1446 {
1447         RegionMoveDrag::finished (event, movement_occurred);
1448 }
1449
1450 void
1451 RegionSpliceDrag::aborted (bool)
1452 {
1453         /* XXX: TODO */
1454 }
1455
1456 RegionCreateDrag::RegionCreateDrag (Editor* e, ArdourCanvas::Item* i, TimeAxisView* v)
1457         : Drag (e, i),
1458           _view (dynamic_cast<MidiTimeAxisView*> (v))
1459 {
1460         DEBUG_TRACE (DEBUG::Drags, "New RegionCreateDrag\n");
1461
1462         assert (_view);
1463 }
1464
1465 void
1466 RegionCreateDrag::motion (GdkEvent* event, bool first_move)
1467 {
1468         if (first_move) {
1469                 _region = add_midi_region (_view);
1470                 _view->playlist()->freeze ();
1471         } else {
1472                 if (_region) {
1473                         framepos_t const f = adjusted_current_frame (event);
1474                         if (f < grab_frame()) {
1475                                 _region->set_position (f);
1476                         }
1477
1478                         /* Don't use a zero-length region, and subtract 1 frame from the snapped length
1479                            so that if this region is duplicated, its duplicate starts on
1480                            a snap point rather than 1 frame after a snap point.  Otherwise things get
1481                            a bit confusing as if a region starts 1 frame after a snap point, one cannot
1482                            place snapped notes at the start of the region.
1483                         */
1484
1485                         framecnt_t const len = abs (f - grab_frame () - 1);
1486                         _region->set_length (len < 1 ? 1 : len);
1487                 }
1488         }
1489 }
1490
1491 void
1492 RegionCreateDrag::finished (GdkEvent*, bool movement_occurred)
1493 {
1494         if (!movement_occurred) {
1495                 add_midi_region (_view);
1496         } else {
1497                 _view->playlist()->thaw ();
1498         }
1499 }
1500
1501 void
1502 RegionCreateDrag::aborted (bool)
1503 {
1504         if (_region) {
1505                 _view->playlist()->thaw ();
1506         }
1507
1508         /* XXX */
1509 }
1510
1511 NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i)
1512         : Drag (e, i)
1513         , region (0)
1514 {
1515         DEBUG_TRACE (DEBUG::Drags, "New NoteResizeDrag\n");
1516 }
1517
1518 void
1519 NoteResizeDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*ignored*/)
1520 {
1521         Gdk::Cursor* cursor;
1522         ArdourCanvas::CanvasNoteEvent* cnote = dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item);
1523         float x_fraction = cnote->mouse_x_fraction ();
1524
1525         if (x_fraction > 0.0 && x_fraction < 0.25) {
1526                 cursor = _editor->cursors()->left_side_trim;
1527         } else  {
1528                 cursor = _editor->cursors()->right_side_trim;
1529         }
1530
1531         Drag::start_grab (event, cursor);
1532
1533         region = &cnote->region_view();
1534
1535         double const region_start = region->get_position_pixels();
1536         double const middle_point = region_start + cnote->x1() + (cnote->x2() - cnote->x1()) / 2.0L;
1537
1538         if (grab_x() <= middle_point) {
1539                 cursor = _editor->cursors()->left_side_trim;
1540                 at_front = true;
1541         } else {
1542                 cursor = _editor->cursors()->right_side_trim;
1543                 at_front = false;
1544         }
1545
1546         _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, *cursor, event->motion.time);
1547
1548         if (event->motion.state & Keyboard::PrimaryModifier) {
1549                 relative = false;
1550         } else {
1551                 relative = true;
1552         }
1553
1554         MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1555
1556         if (ms.size() > 1) {
1557                 /* has to be relative, may make no sense otherwise */
1558                 relative = true;
1559         }
1560
1561         /* select this note; if it is already selected, preserve the existing selection,
1562            otherwise make this note the only one selected.
1563         */
1564         region->note_selected (cnote, cnote->selected ());
1565
1566         for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ) {
1567                 MidiRegionSelection::iterator next;
1568                 next = r;
1569                 ++next;
1570                 (*r)->begin_resizing (at_front);
1571                 r = next;
1572         }
1573 }
1574
1575 void
1576 NoteResizeDrag::motion (GdkEvent* /*event*/, bool /*first_move*/)
1577 {
1578         MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1579         for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
1580                 (*r)->update_resizing (dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item), at_front, _drags->current_pointer_x() - grab_x(), relative);
1581         }
1582 }
1583
1584 void
1585 NoteResizeDrag::finished (GdkEvent*, bool /*movement_occurred*/)
1586 {
1587         MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1588         for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
1589                 (*r)->commit_resizing (dynamic_cast<ArdourCanvas::CanvasNoteEvent*>(_item), at_front, _drags->current_pointer_x() - grab_x(), relative);
1590         }
1591 }
1592
1593 void
1594 NoteResizeDrag::aborted (bool)
1595 {
1596         MidiRegionSelection& ms (_editor->get_selection().midi_regions);
1597         for (MidiRegionSelection::iterator r = ms.begin(); r != ms.end(); ++r) {
1598                 (*r)->abort_resizing ();
1599         }
1600 }
1601
1602 TrimDrag::TrimDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
1603         : RegionDrag (e, i, p, v)
1604 {
1605         DEBUG_TRACE (DEBUG::Drags, "New TrimDrag\n");
1606 }
1607
1608 void
1609 TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
1610 {
1611         double speed = 1.0;
1612         TimeAxisView* tvp = &_primary->get_time_axis_view ();
1613         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
1614
1615         if (tv && tv->is_track()) {
1616                 speed = tv->track()->speed();
1617         }
1618
1619         framepos_t const region_start = (framepos_t) (_primary->region()->position() / speed);
1620         framepos_t const region_end = (framepos_t) (_primary->region()->last_frame() / speed);
1621         framecnt_t const region_length = (framecnt_t) (_primary->region()->length() / speed);
1622
1623         framepos_t const pf = adjusted_current_frame (event);
1624
1625         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
1626                 /* Move the contents of the region around without changing the region bounds */
1627                 _operation = ContentsTrim;
1628                 Drag::start_grab (event, _editor->cursors()->trimmer);
1629         } else {
1630                 /* These will get overridden for a point trim.*/
1631                 if (pf < (region_start + region_length/2)) {
1632                         /* closer to front */
1633                         _operation = StartTrim;
1634                         Drag::start_grab (event, _editor->cursors()->left_side_trim);
1635                 } else {
1636                         /* closer to end */
1637                         _operation = EndTrim;
1638                         Drag::start_grab (event, _editor->cursors()->right_side_trim);
1639                 }
1640         }
1641
1642         switch (_operation) {
1643         case StartTrim:
1644                 show_verbose_cursor_time (region_start);
1645                 for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
1646                         i->view->trim_front_starting ();
1647                 }
1648                 break;
1649         case EndTrim:
1650                 show_verbose_cursor_time (region_end);
1651                 break;
1652         case ContentsTrim:
1653                 show_verbose_cursor_time (pf);
1654                 break;
1655         }
1656
1657         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1658                 i->view->region()->suspend_property_changes ();
1659         }
1660 }
1661
1662 void
1663 TrimDrag::motion (GdkEvent* event, bool first_move)
1664 {
1665         RegionView* rv = _primary;
1666
1667         double speed = 1.0;
1668         TimeAxisView* tvp = &_primary->get_time_axis_view ();
1669         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
1670         pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
1671
1672         if (tv && tv->is_track()) {
1673                 speed = tv->track()->speed();
1674         }
1675
1676         framecnt_t const dt = adjusted_current_frame (event) - raw_grab_frame () + _pointer_frame_offset;
1677
1678         if (first_move) {
1679
1680                 string trim_type;
1681
1682                 switch (_operation) {
1683                 case StartTrim:
1684                         trim_type = "Region start trim";
1685                         break;
1686                 case EndTrim:
1687                         trim_type = "Region end trim";
1688                         break;
1689                 case ContentsTrim:
1690                         trim_type = "Region content trim";
1691                         break;
1692                 }
1693
1694                 _editor->begin_reversible_command (trim_type);
1695
1696                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1697                         RegionView* rv = i->view;
1698                         rv->fake_set_opaque (false);
1699                         rv->enable_display (false);
1700                         rv->region()->playlist()->clear_owned_changes ();
1701
1702                         AudioRegionView* const arv = dynamic_cast<AudioRegionView*> (rv);
1703
1704                         if (arv) {
1705                                 arv->temporarily_hide_envelope ();
1706                                 arv->drag_start ();
1707                         }
1708
1709                         boost::shared_ptr<Playlist> pl = rv->region()->playlist();
1710                         insert_result = _editor->motion_frozen_playlists.insert (pl);
1711
1712                         if (insert_result.second) {
1713                                 pl->freeze();
1714                         }
1715                 }
1716         }
1717
1718         bool non_overlap_trim = false;
1719
1720         if (event && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
1721                 non_overlap_trim = true;
1722         }
1723
1724         switch (_operation) {
1725         case StartTrim:
1726                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1727                         i->view->trim_front (i->initial_position + dt, non_overlap_trim);
1728                 }
1729                 break;
1730
1731         case EndTrim:
1732                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1733                         i->view->trim_end (i->initial_end + dt, non_overlap_trim);
1734                 }
1735                 break;
1736
1737         case ContentsTrim:
1738                 {
1739                         bool swap_direction = false;
1740
1741                         if (event && Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
1742                                 swap_direction = true;
1743                         }
1744
1745                         framecnt_t frame_delta = 0;
1746
1747                         bool left_direction = false;
1748                         if (last_pointer_frame() > adjusted_current_frame(event)) {
1749                                 left_direction = true;
1750                         }
1751
1752                         if (left_direction) {
1753                                 frame_delta = (last_pointer_frame() - adjusted_current_frame(event));
1754                         } else {
1755                                 frame_delta = (adjusted_current_frame(event) - last_pointer_frame());
1756                         }
1757
1758                         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1759                                 i->view->trim_contents (frame_delta, left_direction, swap_direction);
1760                         }
1761                 }
1762                 break;
1763         }
1764
1765         switch (_operation) {
1766         case StartTrim:
1767                 show_verbose_cursor_time ((framepos_t) (rv->region()->position() / speed));
1768                 break;
1769         case EndTrim:
1770                 show_verbose_cursor_time ((framepos_t) (rv->region()->last_frame() / speed));
1771                 break;
1772         case ContentsTrim:
1773                 show_verbose_cursor_time (adjusted_current_frame (event));
1774                 break;
1775         }
1776 }
1777
1778
1779 void
1780 TrimDrag::finished (GdkEvent* event, bool movement_occurred)
1781 {
1782         if (movement_occurred) {
1783                 motion (event, false);
1784
1785                 /* This must happen before the region's StatefulDiffCommand is created, as it may
1786                    `correct' (ahem) the region's _start from being negative to being zero.  It
1787                    needs to be zero in the undo record.
1788                 */
1789                 if (_operation == StartTrim) {
1790                         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1791                                 i->view->trim_front_ending ();
1792                         }
1793                 }
1794
1795                 if (_operation == StartTrim) {
1796                         _editor->maybe_locate_with_edit_preroll ( _views.begin()->view->region()->position() );
1797                 }
1798                 if (_operation == EndTrim) {
1799                         _editor->maybe_locate_with_edit_preroll ( _views.begin()->view->region()->position() + _views.begin()->view->region()->length() );
1800                 }
1801
1802                 if (!_editor->selection->selected (_primary)) {
1803                         _primary->thaw_after_trim ();
1804                 } else {
1805
1806                         set<boost::shared_ptr<Playlist> > diffed_playlists;
1807
1808                         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1809                                 i->view->thaw_after_trim ();
1810                                 i->view->enable_display (true);
1811                                 i->view->fake_set_opaque (true);
1812
1813                                 /* Trimming one region may affect others on the playlist, so we need
1814                                    to get undo Commands from the whole playlist rather than just the
1815                                    region.  Use diffed_playlists to make sure we don't diff a given
1816                                    playlist more than once.
1817                                 */
1818                                 boost::shared_ptr<Playlist> p = i->view->region()->playlist ();
1819                                 if (diffed_playlists.find (p) == diffed_playlists.end()) {
1820                                         vector<Command*> cmds;
1821                                         p->rdiff (cmds);
1822                                         _editor->session()->add_commands (cmds);
1823                                         diffed_playlists.insert (p);
1824                                 }
1825                         }
1826                 }
1827                 for (set<boost::shared_ptr<Playlist> >::iterator p = _editor->motion_frozen_playlists.begin(); p != _editor->motion_frozen_playlists.end(); ++p) {
1828                         (*p)->thaw ();
1829                 }
1830
1831                 _editor->motion_frozen_playlists.clear ();
1832                 _editor->commit_reversible_command();
1833
1834                 for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1835                         i->view->drag_end ();
1836                 }
1837
1838         } else {
1839                 /* no mouse movement */
1840                 _editor->point_trim (event, adjusted_current_frame (event));
1841         }
1842
1843         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1844                 if (_operation == StartTrim) {
1845                         i->view->trim_front_ending ();
1846                 }
1847
1848                 i->view->region()->resume_property_changes ();
1849         }
1850 }
1851
1852 void
1853 TrimDrag::aborted (bool movement_occurred)
1854 {
1855         /* Our motion method is changing model state, so use the Undo system
1856            to cancel.  Perhaps not ideal, as this will leave an Undo point
1857            behind which may be slightly odd from the user's point of view.
1858         */
1859
1860         finished (0, true);
1861
1862         if (movement_occurred) {
1863                 _editor->undo ();
1864         }
1865
1866         for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
1867                 i->view->region()->resume_property_changes ();
1868         }
1869 }
1870
1871 void
1872 TrimDrag::setup_pointer_frame_offset ()
1873 {
1874         list<DraggingView>::iterator i = _views.begin ();
1875         while (i != _views.end() && i->view != _primary) {
1876                 ++i;
1877         }
1878
1879         if (i == _views.end()) {
1880                 return;
1881         }
1882
1883         switch (_operation) {
1884         case StartTrim:
1885                 _pointer_frame_offset = raw_grab_frame() - i->initial_position;
1886                 break;
1887         case EndTrim:
1888                 _pointer_frame_offset = raw_grab_frame() - i->initial_end;
1889                 break;
1890         case ContentsTrim:
1891                 break;
1892         }
1893 }
1894
1895 MeterMarkerDrag::MeterMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
1896         : Drag (e, i),
1897           _copy (c)
1898 {
1899         DEBUG_TRACE (DEBUG::Drags, "New MeterMarkerDrag\n");
1900         _marker = reinterpret_cast<MeterMarker*> (_item->get_data ("marker"));
1901         assert (_marker);
1902 }
1903
1904 void
1905 MeterMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
1906 {
1907         Drag::start_grab (event, cursor);
1908         show_verbose_cursor_time (adjusted_current_frame(event));
1909 }
1910
1911 void
1912 MeterMarkerDrag::setup_pointer_frame_offset ()
1913 {
1914         _pointer_frame_offset = raw_grab_frame() - _marker->meter().frame();
1915 }
1916
1917 void
1918 MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
1919 {
1920         if (first_move) {
1921
1922                 // create a dummy marker for visual representation of moving the
1923                 // section, because whether its a copy or not, we're going to
1924                 // leave or lose the original marker (leave if its a copy; lose if its
1925                 // not, because we'll remove it from the map).
1926
1927                 MeterSection section (_marker->meter());
1928
1929                 if (!section.movable()) {
1930                         return;
1931                 }
1932
1933                 char name[64];
1934                 snprintf (name, sizeof(name), "%g/%g", _marker->meter().divisions_per_bar(), _marker->meter().note_divisor ());
1935
1936                 _marker = new MeterMarker (
1937                         *_editor,
1938                         *_editor->meter_group,
1939                         ARDOUR_UI::config()->canvasvar_MeterMarker.get(),
1940                         name,
1941                         *new MeterSection (_marker->meter())
1942                 );
1943
1944                 /* use the new marker for the grab */
1945                 swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
1946
1947                 if (!_copy) {
1948                         TempoMap& map (_editor->session()->tempo_map());
1949                         /* get current state */
1950                         before_state = &map.get_state();
1951                         /* remove the section while we drag it */
1952                         map.remove_meter (section, true);
1953                 }
1954         }
1955
1956         framepos_t const pf = adjusted_current_frame (event);
1957         _marker->set_position (pf);
1958         show_verbose_cursor_time (pf);
1959 }
1960
1961 void
1962 MeterMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
1963 {
1964         if (!movement_occurred) {
1965                 return;
1966         }
1967
1968         motion (event, false);
1969
1970         Timecode::BBT_Time when;
1971
1972         TempoMap& map (_editor->session()->tempo_map());
1973         map.bbt_time (last_pointer_frame(), when);
1974
1975         if (_copy == true) {
1976                 _editor->begin_reversible_command (_("copy meter mark"));
1977                 XMLNode &before = map.get_state();
1978                 map.add_meter (_marker->meter(), when);
1979                 XMLNode &after = map.get_state();
1980                 _editor->session()->add_command(new MementoCommand<TempoMap>(map, &before, &after));
1981                 _editor->commit_reversible_command ();
1982
1983         } else {
1984                 _editor->begin_reversible_command (_("move meter mark"));
1985
1986                 /* we removed it before, so add it back now */
1987
1988                 map.add_meter (_marker->meter(), when);
1989                 XMLNode &after = map.get_state();
1990                 _editor->session()->add_command(new MementoCommand<TempoMap>(map, before_state, &after));
1991                 _editor->commit_reversible_command ();
1992         }
1993
1994         // delete the dummy marker we used for visual representation while moving.
1995         // a new visual marker will show up automatically.
1996         delete _marker;
1997 }
1998
1999 void
2000 MeterMarkerDrag::aborted (bool moved)
2001 {
2002         _marker->set_position (_marker->meter().frame ());
2003
2004         if (moved) {
2005                 TempoMap& map (_editor->session()->tempo_map());
2006                 /* we removed it before, so add it back now */
2007                 map.add_meter (_marker->meter(), _marker->meter().frame());
2008                 // delete the dummy marker we used for visual representation while moving.
2009                 // a new visual marker will show up automatically.
2010                 delete _marker;
2011         }
2012 }
2013
2014 TempoMarkerDrag::TempoMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
2015         : Drag (e, i),
2016           _copy (c)
2017 {
2018         DEBUG_TRACE (DEBUG::Drags, "New TempoMarkerDrag\n");
2019
2020         _marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
2021         assert (_marker);
2022 }
2023
2024 void
2025 TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2026 {
2027         Drag::start_grab (event, cursor);
2028         show_verbose_cursor_time (adjusted_current_frame (event));
2029 }
2030
2031 void
2032 TempoMarkerDrag::setup_pointer_frame_offset ()
2033 {
2034         _pointer_frame_offset = raw_grab_frame() - _marker->tempo().frame();
2035 }
2036
2037 void
2038 TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
2039 {
2040         if (first_move) {
2041
2042                 // create a dummy marker for visual representation of moving the
2043                 // section, because whether its a copy or not, we're going to
2044                 // leave or lose the original marker (leave if its a copy; lose if its
2045                 // not, because we'll remove it from the map).
2046
2047                 // create a dummy marker for visual representation of moving the copy.
2048                 // The actual copying is not done before we reach the finish callback.
2049
2050                 char name[64];
2051                 snprintf (name, sizeof (name), "%.2f", _marker->tempo().beats_per_minute());
2052
2053                 TempoSection section (_marker->tempo());
2054
2055                 _marker = new TempoMarker (
2056                         *_editor,
2057                         *_editor->tempo_group,
2058                         ARDOUR_UI::config()->canvasvar_TempoMarker.get(),
2059                         name,
2060                         *new TempoSection (_marker->tempo())
2061                         );
2062
2063                 /* use the new marker for the grab */
2064                 swap_grab (&_marker->the_item(), 0, GDK_CURRENT_TIME);
2065
2066                 if (!_copy) {
2067                         TempoMap& map (_editor->session()->tempo_map());
2068                         /* get current state */
2069                         before_state = &map.get_state();
2070                         /* remove the section while we drag it */
2071                         map.remove_tempo (section, true);
2072                 }
2073         }
2074
2075         framepos_t const pf = adjusted_current_frame (event);
2076         _marker->set_position (pf);
2077         show_verbose_cursor_time (pf);
2078 }
2079
2080 void
2081 TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
2082 {
2083         if (!movement_occurred) {
2084                 return;
2085         }
2086
2087         motion (event, false);
2088
2089         TempoMap& map (_editor->session()->tempo_map());
2090         framepos_t beat_time = map.round_to_beat (last_pointer_frame(), 0);
2091         Timecode::BBT_Time when;
2092
2093         map.bbt_time (beat_time, when);
2094
2095         if (_copy == true) {
2096                 _editor->begin_reversible_command (_("copy tempo mark"));
2097                 XMLNode &before = map.get_state();
2098                 map.add_tempo (_marker->tempo(), when);
2099                 XMLNode &after = map.get_state();
2100                 _editor->session()->add_command (new MementoCommand<TempoMap>(map, &before, &after));
2101                 _editor->commit_reversible_command ();
2102
2103         } else {
2104                 _editor->begin_reversible_command (_("move tempo mark"));
2105                 /* we removed it before, so add it back now */
2106                 map.add_tempo (_marker->tempo(), when);
2107                 XMLNode &after = map.get_state();
2108                 _editor->session()->add_command (new MementoCommand<TempoMap>(map, before_state, &after));
2109                 _editor->commit_reversible_command ();
2110         }
2111
2112         // delete the dummy marker we used for visual representation while moving.
2113         // a new visual marker will show up automatically.
2114         delete _marker;
2115 }
2116
2117 void
2118 TempoMarkerDrag::aborted (bool moved)
2119 {
2120         _marker->set_position (_marker->tempo().frame());
2121         if (moved) {
2122                 TempoMap& map (_editor->session()->tempo_map());
2123                 /* we removed it before, so add it back now */
2124                 map.add_tempo (_marker->tempo(), _marker->tempo().start());
2125                 // delete the dummy marker we used for visual representation while moving.
2126                 // a new visual marker will show up automatically.
2127                 delete _marker;
2128         }
2129 }
2130
2131 CursorDrag::CursorDrag (Editor* e, ArdourCanvas::Item* i, bool s)
2132         : Drag (e, i),
2133           _stop (s)
2134 {
2135         DEBUG_TRACE (DEBUG::Drags, "New CursorDrag\n");
2136 }
2137
2138 /** Do all the things we do when dragging the playhead to make it look as though
2139  *  we have located, without actually doing the locate (because that would cause
2140  *  the diskstream buffers to be refilled, which is too slow).
2141  */
2142 void
2143 CursorDrag::fake_locate (framepos_t t)
2144 {
2145         _editor->playhead_cursor->set_position (t);
2146
2147         Session* s = _editor->session ();
2148         if (s->timecode_transmission_suspended ()) {
2149                 framepos_t const f = _editor->playhead_cursor->current_frame;
2150                 s->send_mmc_locate (f);
2151                 s->send_full_time_code (f);
2152         }
2153
2154         show_verbose_cursor_time (t);
2155         _editor->UpdateAllTransportClocks (t);
2156 }
2157
2158 void
2159 CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
2160 {
2161         Drag::start_grab (event, c);
2162
2163         _grab_zoom = _editor->frames_per_unit;
2164
2165         framepos_t where = _editor->event_frame (event, 0, 0);
2166         _editor->snap_to_with_modifier (where, event);
2167
2168         _editor->_dragging_playhead = true;
2169
2170         Session* s = _editor->session ();
2171
2172         if (s) {
2173                 if (_was_rolling && _stop) {
2174                         s->request_stop ();
2175                 }
2176
2177                 if (s->is_auditioning()) {
2178                         s->cancel_audition ();
2179                 }
2180
2181
2182                 if (AudioEngine::instance()->connected()) {
2183
2184                         /* do this only if we're the engine is connected
2185                          * because otherwise this request will never be
2186                          * serviced and we'll busy wait forever. likewise,
2187                          * notice if we are disconnected while waiting for the
2188                          * request to be serviced.
2189                          */
2190
2191                         s->request_suspend_timecode_transmission ();
2192                         while (AudioEngine::instance()->connected() && !s->timecode_transmission_suspended ()) {
2193                                 /* twiddle our thumbs */
2194                         }
2195                 }
2196         }
2197
2198         fake_locate (where);
2199 }
2200
2201 void
2202 CursorDrag::motion (GdkEvent* event, bool)
2203 {
2204         framepos_t const adjusted_frame = adjusted_current_frame (event);
2205         if (adjusted_frame != last_pointer_frame()) {
2206                 fake_locate (adjusted_frame);
2207 #ifdef GTKOSX
2208                 _editor->update_canvas_now ();
2209 #endif
2210         }
2211 }
2212
2213 void
2214 CursorDrag::finished (GdkEvent* event, bool movement_occurred)
2215 {
2216         _editor->_dragging_playhead = false;
2217
2218         if (!movement_occurred && _stop) {
2219                 return;
2220         }
2221
2222         motion (event, false);
2223
2224         Session* s = _editor->session ();
2225         if (s) {
2226                 s->request_locate (_editor->playhead_cursor->current_frame, _was_rolling);
2227                 _editor->_pending_locate_request = true;
2228                 s->request_resume_timecode_transmission ();
2229         }
2230 }
2231
2232 void
2233 CursorDrag::aborted (bool)
2234 {
2235         if (_editor->_dragging_playhead) {
2236                 _editor->session()->request_resume_timecode_transmission ();
2237                 _editor->_dragging_playhead = false;
2238         }
2239
2240         _editor->playhead_cursor->set_position (adjusted_frame (grab_frame (), 0, false));
2241 }
2242
2243 FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
2244         : RegionDrag (e, i, p, v)
2245 {
2246         DEBUG_TRACE (DEBUG::Drags, "New FadeInDrag\n");
2247 }
2248
2249 void
2250 FadeInDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2251 {
2252         Drag::start_grab (event, cursor);
2253
2254         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2255         boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
2256
2257         show_verbose_cursor_duration (r->position(), r->position() + r->fade_in()->back()->when, 32);
2258
2259         arv->show_fade_line((framepos_t) r->fade_in()->back()->when);
2260 }
2261
2262 void
2263 FadeInDrag::setup_pointer_frame_offset ()
2264 {
2265         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2266         boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
2267         _pointer_frame_offset = raw_grab_frame() - ((framecnt_t) r->fade_in()->back()->when + r->position());
2268 }
2269
2270 void
2271 FadeInDrag::motion (GdkEvent* event, bool)
2272 {
2273         framecnt_t fade_length;
2274
2275         framepos_t const pos = adjusted_current_frame (event);
2276
2277         boost::shared_ptr<Region> region = _primary->region ();
2278
2279         if (pos < (region->position() + 64)) {
2280                 fade_length = 64; // this should be a minimum defined somewhere
2281         } else if (pos > region->last_frame()) {
2282                 fade_length = region->length();
2283         } else {
2284                 fade_length = pos - region->position();
2285         }
2286
2287         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2288
2289                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2290
2291                 if (!tmp) {
2292                         continue;
2293                 }
2294
2295                 tmp->reset_fade_in_shape_width (fade_length);
2296                 tmp->show_fade_line((framecnt_t) fade_length);
2297         }
2298
2299         show_verbose_cursor_duration (region->position(), region->position() + fade_length, 32);
2300 }
2301
2302 void
2303 FadeInDrag::finished (GdkEvent* event, bool movement_occurred)
2304 {
2305         if (!movement_occurred) {
2306                 return;
2307         }
2308
2309         framecnt_t fade_length;
2310
2311         framepos_t const pos = adjusted_current_frame (event);
2312
2313         boost::shared_ptr<Region> region = _primary->region ();
2314
2315         if (pos < (region->position() + 64)) {
2316                 fade_length = 64; // this should be a minimum defined somewhere
2317         } else if (pos > region->last_frame()) {
2318                 fade_length = region->length();
2319         } else {
2320                 fade_length = pos - region->position();
2321         }
2322
2323         _editor->begin_reversible_command (_("change fade in length"));
2324
2325         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2326
2327                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2328
2329                 if (!tmp) {
2330                         continue;
2331                 }
2332
2333                 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_in();
2334                 XMLNode &before = alist->get_state();
2335
2336                 tmp->audio_region()->set_fade_in_length (fade_length);
2337                 tmp->audio_region()->set_fade_in_active (true);
2338                 tmp->hide_fade_line();
2339
2340                 XMLNode &after = alist->get_state();
2341                 _editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
2342         }
2343
2344         _editor->commit_reversible_command ();
2345 }
2346
2347 void
2348 FadeInDrag::aborted (bool)
2349 {
2350         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2351                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2352
2353                 if (!tmp) {
2354                         continue;
2355                 }
2356
2357                 tmp->reset_fade_in_shape_width (tmp->audio_region()->fade_in()->back()->when);
2358                 tmp->hide_fade_line();
2359         }
2360 }
2361
2362 FadeOutDrag::FadeOutDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
2363         : RegionDrag (e, i, p, v)
2364 {
2365         DEBUG_TRACE (DEBUG::Drags, "New FadeOutDrag\n");
2366 }
2367
2368 void
2369 FadeOutDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2370 {
2371         Drag::start_grab (event, cursor);
2372
2373         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2374         boost::shared_ptr<AudioRegion> r = arv->audio_region ();
2375
2376         show_verbose_cursor_duration (r->last_frame() - r->fade_out()->back()->when, r->last_frame());
2377
2378         arv->show_fade_line(r->length() - r->fade_out()->back()->when);
2379 }
2380
2381 void
2382 FadeOutDrag::setup_pointer_frame_offset ()
2383 {
2384         AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
2385         boost::shared_ptr<AudioRegion> r = arv->audio_region ();
2386         _pointer_frame_offset = raw_grab_frame() - (r->length() - (framecnt_t) r->fade_out()->back()->when + r->position());
2387 }
2388
2389 void
2390 FadeOutDrag::motion (GdkEvent* event, bool)
2391 {
2392         framecnt_t fade_length;
2393
2394         framepos_t const pos = adjusted_current_frame (event);
2395
2396         boost::shared_ptr<Region> region = _primary->region ();
2397
2398         if (pos > (region->last_frame() - 64)) {
2399                 fade_length = 64; // this should really be a minimum fade defined somewhere
2400         }
2401         else if (pos < region->position()) {
2402                 fade_length = region->length();
2403         }
2404         else {
2405                 fade_length = region->last_frame() - pos;
2406         }
2407
2408         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2409
2410                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2411
2412                 if (!tmp) {
2413                         continue;
2414                 }
2415
2416                 tmp->reset_fade_out_shape_width (fade_length);
2417                 tmp->show_fade_line(region->length() - fade_length);
2418         }
2419
2420         show_verbose_cursor_duration (region->last_frame() - fade_length, region->last_frame());
2421 }
2422
2423 void
2424 FadeOutDrag::finished (GdkEvent* event, bool movement_occurred)
2425 {
2426         if (!movement_occurred) {
2427                 return;
2428         }
2429
2430         framecnt_t fade_length;
2431
2432         framepos_t const pos = adjusted_current_frame (event);
2433
2434         boost::shared_ptr<Region> region = _primary->region ();
2435
2436         if (pos > (region->last_frame() - 64)) {
2437                 fade_length = 64; // this should really be a minimum fade defined somewhere
2438         }
2439         else if (pos < region->position()) {
2440                 fade_length = region->length();
2441         }
2442         else {
2443                 fade_length = region->last_frame() - pos;
2444         }
2445
2446         _editor->begin_reversible_command (_("change fade out length"));
2447
2448         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2449
2450                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2451
2452                 if (!tmp) {
2453                         continue;
2454                 }
2455
2456                 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_out();
2457                 XMLNode &before = alist->get_state();
2458
2459                 tmp->audio_region()->set_fade_out_length (fade_length);
2460                 tmp->audio_region()->set_fade_out_active (true);
2461                 tmp->hide_fade_line();
2462
2463                 XMLNode &after = alist->get_state();
2464                 _editor->session()->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
2465         }
2466
2467         _editor->commit_reversible_command ();
2468 }
2469
2470 void
2471 FadeOutDrag::aborted (bool)
2472 {
2473         for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
2474                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (i->view);
2475
2476                 if (!tmp) {
2477                         continue;
2478                 }
2479
2480                 tmp->reset_fade_out_shape_width (tmp->audio_region()->fade_out()->back()->when);
2481                 tmp->hide_fade_line();
2482         }
2483 }
2484
2485 MarkerDrag::MarkerDrag (Editor* e, ArdourCanvas::Item* i)
2486         : Drag (e, i)
2487 {
2488         DEBUG_TRACE (DEBUG::Drags, "New MarkerDrag\n");
2489
2490         _marker = reinterpret_cast<Marker*> (_item->get_data ("marker"));
2491         assert (_marker);
2492
2493         _points.push_back (Gnome::Art::Point (0, 0));
2494         _points.push_back (Gnome::Art::Point (0, physical_screen_height (_editor->get_window())));
2495 }
2496
2497 MarkerDrag::~MarkerDrag ()
2498 {
2499         for (list<Location*>::iterator i = _copied_locations.begin(); i != _copied_locations.end(); ++i) {
2500                 delete *i;
2501         }
2502 }
2503
2504 void
2505 MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
2506 {
2507         Drag::start_grab (event, cursor);
2508
2509         bool is_start;
2510
2511         Location *location = _editor->find_location_from_marker (_marker, is_start);
2512         _editor->_dragging_edit_point = true;
2513
2514         update_item (location);
2515
2516         // _drag_line->show();
2517         // _line->raise_to_top();
2518
2519         if (is_start) {
2520                 show_verbose_cursor_time (location->start());
2521         } else {
2522                 show_verbose_cursor_time (location->end());
2523         }
2524
2525         Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
2526
2527         switch (op) {
2528         case Selection::Toggle:
2529                 _editor->selection->toggle (_marker);
2530                 break;
2531         case Selection::Set:
2532                 if (!_editor->selection->selected (_marker)) {
2533                         _editor->selection->set (_marker);
2534                 }
2535                 break;
2536         case Selection::Extend:
2537         {
2538                 Locations::LocationList ll;
2539                 list<Marker*> to_add;
2540                 framepos_t s, e;
2541                 _editor->selection->markers.range (s, e);
2542                 s = min (_marker->position(), s);
2543                 e = max (_marker->position(), e);
2544                 s = min (s, e);
2545                 e = max (s, e);
2546                 if (e < max_framepos) {
2547                         ++e;
2548                 }
2549                 _editor->session()->locations()->find_all_between (s, e, ll, Location::Flags (0));
2550                 for (Locations::LocationList::iterator i = ll.begin(); i != ll.end(); ++i) {
2551                         Editor::LocationMarkers* lm = _editor->find_location_markers (*i);
2552                         if (lm) {
2553                                 if (lm->start) {
2554                                         to_add.push_back (lm->start);
2555                                 }
2556                                 if (lm->end) {
2557                                         to_add.push_back (lm->end);
2558                                 }
2559                         }
2560                 }
2561                 if (!to_add.empty()) {
2562                         _editor->selection->add (to_add);
2563                 }
2564                 break;
2565         }
2566         case Selection::Add:
2567                 _editor->selection->add (_marker);
2568                 break;
2569         }
2570
2571         /* Set up copies for us to manipulate during the drag */
2572
2573         for (MarkerSelection::iterator i = _editor->selection->markers.begin(); i != _editor->selection->markers.end(); ++i) {
2574                 Location* l = _editor->find_location_from_marker (*i, is_start);
2575                 _copied_locations.push_back (new Location (*l));
2576         }
2577 }
2578
2579 void
2580 MarkerDrag::setup_pointer_frame_offset ()
2581 {
2582         bool is_start;
2583         Location *location = _editor->find_location_from_marker (_marker, is_start);
2584         _pointer_frame_offset = raw_grab_frame() - (is_start ? location->start() : location->end());
2585 }
2586
2587 void
2588 MarkerDrag::motion (GdkEvent* event, bool)
2589 {
2590         framecnt_t f_delta = 0;
2591         bool is_start;
2592         bool move_both = false;
2593         Marker* marker;
2594         Location *real_location;
2595         Location *copy_location = 0;
2596
2597         framepos_t const newframe = adjusted_current_frame (event);
2598
2599         framepos_t next = newframe;
2600
2601         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
2602                 move_both = true;
2603         }
2604
2605         MarkerSelection::iterator i;
2606         list<Location*>::iterator x;
2607
2608         /* find the marker we're dragging, and compute the delta */
2609
2610         for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
2611              x != _copied_locations.end() && i != _editor->selection->markers.end();
2612              ++i, ++x) {
2613
2614                 copy_location = *x;
2615                 marker = *i;
2616
2617                 if (marker == _marker) {
2618
2619                         if ((real_location = _editor->find_location_from_marker (marker, is_start)) == 0) {
2620                                 /* que pasa ?? */
2621                                 return;
2622                         }
2623
2624                         if (real_location->is_mark()) {
2625                                 f_delta = newframe - copy_location->start();
2626                         } else {
2627
2628
2629                                 switch (marker->type()) {
2630                                 case Marker::SessionStart:
2631                                 case Marker::RangeStart:
2632                                 case Marker::LoopStart:
2633                                 case Marker::PunchIn:
2634                                         f_delta = newframe - copy_location->start();
2635                                         break;
2636
2637                                 case Marker::SessionEnd:
2638                                 case Marker::RangeEnd:
2639                                 case Marker::LoopEnd:
2640                                 case Marker::PunchOut:
2641                                         f_delta = newframe - copy_location->end();
2642                                         break;
2643                                 default:
2644                                         /* what kind of marker is this ? */
2645                                         return;
2646                                 }
2647                         }
2648                         break;
2649                 }
2650         }
2651
2652         if (i == _editor->selection->markers.end()) {
2653                 /* hmm, impossible - we didn't find the dragged marker */
2654                 return;
2655         }
2656
2657         /* now move them all */
2658
2659         for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
2660              x != _copied_locations.end() && i != _editor->selection->markers.end();
2661              ++i, ++x) {
2662
2663                 copy_location = *x;
2664                 marker = *i;
2665
2666                 /* call this to find out if its the start or end */
2667
2668                 if ((real_location = _editor->find_location_from_marker (marker, is_start)) == 0) {
2669                         continue;
2670                 }
2671
2672                 if (real_location->locked()) {
2673                         continue;
2674                 }
2675
2676                 if (copy_location->is_mark()) {
2677
2678                         /* now move it */
2679
2680                         copy_location->set_start (copy_location->start() + f_delta);
2681
2682                 } else {
2683
2684                         framepos_t new_start = copy_location->start() + f_delta;
2685                         framepos_t new_end = copy_location->end() + f_delta;
2686
2687                         if (is_start) { // start-of-range marker
2688
2689                                 if (move_both) {
2690                                         copy_location->set_start (new_start);
2691                                         copy_location->set_end (new_end);
2692                                 } else  if (new_start < copy_location->end()) {
2693                                         copy_location->set_start (new_start);
2694                                 } else if (newframe > 0) {
2695                                         _editor->snap_to (next, 1, true);
2696                                         copy_location->set_end (next);
2697                                         copy_location->set_start (newframe);
2698                                 }
2699
2700                         } else { // end marker
2701
2702                                 if (move_both) {
2703                                         copy_location->set_end (new_end);
2704                                         copy_location->set_start (new_start);
2705                                 } else if (new_end > copy_location->start()) {
2706                                         copy_location->set_end (new_end);
2707                                 } else if (newframe > 0) {
2708                                         _editor->snap_to (next, -1, true);
2709                                         copy_location->set_start (next);
2710                                         copy_location->set_end (newframe);
2711                                 }
2712                         }
2713                 }
2714
2715                 update_item (copy_location);
2716
2717                 Editor::LocationMarkers* lm = _editor->find_location_markers (real_location);
2718
2719                 if (lm) {
2720                         lm->set_position (copy_location->start(), copy_location->end());
2721                 }
2722         }
2723
2724         assert (!_copied_locations.empty());
2725
2726         show_verbose_cursor_time (newframe);
2727
2728 #ifdef GTKOSX
2729         _editor->update_canvas_now ();
2730 #endif
2731 }
2732
2733 void
2734 MarkerDrag::finished (GdkEvent* event, bool movement_occurred)
2735 {
2736         if (!movement_occurred) {
2737
2738                 /* just a click, do nothing but finish
2739                    off the selection process
2740                 */
2741
2742                 Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
2743
2744                 switch (op) {
2745                 case Selection::Set:
2746                         if (_editor->selection->selected (_marker) && _editor->selection->markers.size() > 1) {
2747                                 _editor->selection->set (_marker);
2748                         }
2749                         break;
2750
2751                 case Selection::Toggle:
2752                 case Selection::Extend:
2753                 case Selection::Add:
2754                         break;
2755                 }
2756
2757                 return;
2758         }
2759
2760         _editor->_dragging_edit_point = false;
2761
2762         _editor->begin_reversible_command ( _("move marker") );
2763         XMLNode &before = _editor->session()->locations()->get_state();
2764
2765         MarkerSelection::iterator i;
2766         list<Location*>::iterator x;
2767         bool is_start;
2768
2769         for (i = _editor->selection->markers.begin(), x = _copied_locations.begin();
2770              x != _copied_locations.end() && i != _editor->selection->markers.end();
2771              ++i, ++x) {
2772
2773                 Location * location = _editor->find_location_from_marker (*i, is_start);
2774
2775                 if (location) {
2776
2777                         if (location->locked()) {
2778                                 return;
2779                         }
2780
2781                         if (location->is_mark()) {
2782                                 location->set_start ((*x)->start());
2783                         } else {
2784                                 location->set ((*x)->start(), (*x)->end());
2785                         }
2786                 }
2787         }
2788
2789         XMLNode &after = _editor->session()->locations()->get_state();
2790         _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
2791         _editor->commit_reversible_command ();
2792 }
2793
2794 void
2795 MarkerDrag::aborted (bool)
2796 {
2797         /* XXX: TODO */
2798 }
2799
2800 void
2801 MarkerDrag::update_item (Location*)
2802 {
2803         /* noop */
2804 }
2805
2806 ControlPointDrag::ControlPointDrag (Editor* e, ArdourCanvas::Item* i)
2807         : Drag (e, i),
2808           _cumulative_x_drag (0),
2809           _cumulative_y_drag (0)
2810 {
2811         if (_zero_gain_fraction < 0.0) {
2812                 _zero_gain_fraction = gain_to_slider_position_with_max (dB_to_coefficient (0.0), Config->get_max_gain());
2813         }
2814
2815         DEBUG_TRACE (DEBUG::Drags, "New ControlPointDrag\n");
2816
2817         _point = reinterpret_cast<ControlPoint*> (_item->get_data ("control_point"));
2818         assert (_point);
2819 }
2820
2821
2822 void
2823 ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
2824 {
2825         Drag::start_grab (event, _editor->cursors()->fader);
2826
2827         // start the grab at the center of the control point so
2828         // the point doesn't 'jump' to the mouse after the first drag
2829         _fixed_grab_x = _point->get_x();
2830         _fixed_grab_y = _point->get_y();
2831
2832         float const fraction = 1 - (_point->get_y() / _point->line().height());
2833
2834         _point->line().start_drag_single (_point, _fixed_grab_x, fraction);
2835
2836         _editor->verbose_cursor()->set (_point->line().get_verbose_cursor_string (fraction),
2837                                         event->button.x + 10, event->button.y + 10);
2838
2839         _editor->verbose_cursor()->show ();
2840
2841         if (!_point->can_slide ()) {
2842                 _x_constrained = true;
2843         }
2844 }
2845
2846 void
2847 ControlPointDrag::motion (GdkEvent* event, bool)
2848 {
2849         double dx = _drags->current_pointer_x() - last_pointer_x();
2850         double dy = _drags->current_pointer_y() - last_pointer_y();
2851
2852         if (event->button.state & Keyboard::SecondaryModifier) {
2853                 dx *= 0.1;
2854                 dy *= 0.1;
2855         }
2856
2857         /* coordinate in pixels relative to the start of the region (for region-based automation)
2858            or track (for track-based automation) */
2859         double cx = _fixed_grab_x + _cumulative_x_drag + dx;
2860         double cy = _fixed_grab_y + _cumulative_y_drag + dy;
2861
2862         // calculate zero crossing point. back off by .01 to stay on the
2863         // positive side of zero
2864         double const zero_gain_y = (1.0 - _zero_gain_fraction) * _point->line().height() - .01;
2865
2866         // make sure we hit zero when passing through
2867         if ((cy < zero_gain_y && (cy - dy) > zero_gain_y) || (cy > zero_gain_y && (cy - dy) < zero_gain_y)) {
2868                 cy = zero_gain_y;
2869         }
2870
2871         if (_x_constrained) {
2872                 cx = _fixed_grab_x;
2873         }
2874         if (_y_constrained) {
2875                 cy = _fixed_grab_y;
2876         }
2877
2878         _cumulative_x_drag = cx - _fixed_grab_x;
2879         _cumulative_y_drag = cy - _fixed_grab_y;
2880
2881         cx = max (0.0, cx);
2882         cy = max (0.0, cy);
2883         cy = min ((double) _point->line().height(), cy);
2884
2885         framepos_t cx_frames = _editor->unit_to_frame (cx);
2886
2887         if (!_x_constrained) {
2888                 _editor->snap_to_with_modifier (cx_frames, event);
2889         }
2890
2891         cx_frames = min (cx_frames, _point->line().maximum_time());
2892
2893         float const fraction = 1.0 - (cy / _point->line().height());
2894         bool const push = Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier);
2895
2896         _point->line().drag_motion (_editor->frame_to_unit_unrounded (cx_frames), fraction, false, push);
2897
2898         _editor->verbose_cursor()->set_text (_point->line().get_verbose_cursor_string (fraction));
2899 }
2900
2901 void
2902 ControlPointDrag::finished (GdkEvent* event, bool movement_occurred)
2903 {
2904         if (!movement_occurred) {
2905
2906                 /* just a click */
2907
2908                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
2909                         _editor->reset_point_selection ();
2910                 }
2911
2912         } else {
2913                 motion (event, false);
2914         }
2915
2916         _point->line().end_drag ();
2917         _editor->session()->commit_reversible_command ();
2918 }
2919
2920 void
2921 ControlPointDrag::aborted (bool)
2922 {
2923         _point->line().reset ();
2924 }
2925
2926 bool
2927 ControlPointDrag::active (Editing::MouseMode m)
2928 {
2929         if (m == Editing::MouseGain) {
2930                 /* always active in mouse gain */
2931                 return true;
2932         }
2933
2934         /* otherwise active if the point is on an automation line (ie not if its on a region gain line) */
2935         return dynamic_cast<AutomationLine*> (&(_point->line())) != 0;
2936 }
2937
2938 LineDrag::LineDrag (Editor* e, ArdourCanvas::Item* i)
2939         : Drag (e, i),
2940           _line (0),
2941           _cumulative_y_drag (0)
2942 {
2943         DEBUG_TRACE (DEBUG::Drags, "New LineDrag\n");
2944 }
2945
2946 void
2947 LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
2948 {
2949         _line = reinterpret_cast<AutomationLine*> (_item->get_data ("line"));
2950         assert (_line);
2951
2952         _item = &_line->grab_item ();
2953
2954         /* need to get x coordinate in terms of parent (TimeAxisItemView)
2955            origin, and ditto for y.
2956         */
2957
2958         double cx = event->button.x;
2959         double cy = event->button.y;
2960
2961         _line->parent_group().w2i (cx, cy);
2962
2963         framecnt_t const frame_within_region = (framecnt_t) floor (cx * _editor->frames_per_unit);
2964
2965         uint32_t before;
2966         uint32_t after;
2967
2968         if (!_line->control_points_adjacent (frame_within_region, before, after)) {
2969                 /* no adjacent points */
2970                 return;
2971         }
2972
2973         Drag::start_grab (event, _editor->cursors()->fader);
2974
2975         /* store grab start in parent frame */
2976
2977         _fixed_grab_x = cx;
2978         _fixed_grab_y = cy;
2979
2980         double fraction = 1.0 - (cy / _line->height());
2981
2982         _line->start_drag_line (before, after, fraction);
2983
2984         _editor->verbose_cursor()->set (_line->get_verbose_cursor_string (fraction),
2985                                         event->button.x + 10, event->button.y + 10);
2986
2987         _editor->verbose_cursor()->show ();
2988 }
2989
2990 void
2991 LineDrag::motion (GdkEvent* event, bool)
2992 {
2993         double dy = _drags->current_pointer_y() - last_pointer_y();
2994
2995         if (event->button.state & Keyboard::SecondaryModifier) {
2996                 dy *= 0.1;
2997         }
2998
2999         double cy = _fixed_grab_y + _cumulative_y_drag + dy;
3000
3001         _cumulative_y_drag = cy - _fixed_grab_y;
3002
3003         cy = max (0.0, cy);
3004         cy = min ((double) _line->height(), cy);
3005
3006         double const fraction = 1.0 - (cy / _line->height());
3007         bool const push = !Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier);
3008
3009         /* we are ignoring x position for this drag, so we can just pass in anything */
3010         _line->drag_motion (0, fraction, true, push);
3011
3012         _editor->verbose_cursor()->set_text (_line->get_verbose_cursor_string (fraction));
3013 }
3014
3015 void
3016 LineDrag::finished (GdkEvent* event, bool)
3017 {
3018         motion (event, false);
3019         _line->end_drag ();
3020         _editor->session()->commit_reversible_command ();
3021 }
3022
3023 void
3024 LineDrag::aborted (bool)
3025 {
3026         _line->reset ();
3027 }
3028
3029 FeatureLineDrag::FeatureLineDrag (Editor* e, ArdourCanvas::Item* i)
3030         : Drag (e, i),
3031           _line (0),
3032           _cumulative_x_drag (0)
3033 {
3034         DEBUG_TRACE (DEBUG::Drags, "New FeatureLineDrag\n");
3035 }
3036
3037 void
3038 FeatureLineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
3039 {
3040         Drag::start_grab (event);
3041
3042         _line = reinterpret_cast<Line*> (_item);
3043         assert (_line);
3044
3045         /* need to get x coordinate in terms of parent (AudioRegionView) origin. */
3046
3047         double cx = event->button.x;
3048         double cy = event->button.y;
3049
3050         _item->property_parent().get_value()->w2i(cx, cy);
3051
3052         /* store grab start in parent frame */
3053         _region_view_grab_x = cx;
3054
3055         _before = *(float*) _item->get_data ("position");
3056
3057         _arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
3058
3059         _max_x = _editor->frame_to_pixel(_arv->get_duration());
3060 }
3061
3062 void
3063 FeatureLineDrag::motion (GdkEvent*, bool)
3064 {
3065         double dx = _drags->current_pointer_x() - last_pointer_x();
3066
3067         double cx = _region_view_grab_x + _cumulative_x_drag + dx;
3068
3069         _cumulative_x_drag += dx;
3070
3071         /* Clamp the min and max extent of the drag to keep it within the region view bounds */
3072
3073         if (cx > _max_x){
3074                 cx = _max_x;
3075         }
3076         else if(cx < 0){
3077                 cx = 0;
3078         }
3079
3080         ArdourCanvas::Points points;
3081
3082         double x1 = 0, x2 = 0, y1 = 0, y2 = 0;
3083
3084         _line->get_bounds(x1, y2, x2, y2);
3085
3086         points.push_back(Gnome::Art::Point(cx, 2.0)); // first x-coord needs to be a non-normal value
3087         points.push_back(Gnome::Art::Point(cx, y2 - y1));
3088
3089         _line->property_points() = points;
3090
3091         float *pos = new float;
3092         *pos = cx;
3093
3094         _line->set_data ("position", pos);
3095
3096         _before = cx;
3097 }
3098
3099 void
3100 FeatureLineDrag::finished (GdkEvent*, bool)
3101 {
3102         _arv = reinterpret_cast<AudioRegionView*> (_item->get_data ("regionview"));
3103         _arv->update_transient(_before, _before);
3104 }
3105
3106 void
3107 FeatureLineDrag::aborted (bool)
3108 {
3109         //_line->reset ();
3110 }
3111
3112 RubberbandSelectDrag::RubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
3113         : Drag (e, i)
3114         , _vertical_only (false)
3115 {
3116         DEBUG_TRACE (DEBUG::Drags, "New RubberbandSelectDrag\n");
3117 }
3118
3119 void
3120 RubberbandSelectDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3121 {
3122         Drag::start_grab (event);
3123         show_verbose_cursor_time (adjusted_current_frame (event));
3124 }
3125
3126 void
3127 RubberbandSelectDrag::motion (GdkEvent* event, bool)
3128 {
3129         framepos_t start;
3130         framepos_t end;
3131         double y1;
3132         double y2;
3133
3134         framepos_t const pf = adjusted_current_frame (event, Config->get_rubberbanding_snaps_to_grid ());
3135
3136         framepos_t grab = grab_frame ();
3137         if (Config->get_rubberbanding_snaps_to_grid ()) {
3138                 _editor->snap_to_with_modifier (grab, event);
3139         }
3140
3141         /* base start and end on initial click position */
3142
3143         if (pf < grab) {
3144                 start = pf;
3145                 end = grab;
3146         } else {
3147                 end = pf;
3148                 start = grab;
3149         }
3150
3151         if (_drags->current_pointer_y() < grab_y()) {
3152                 y1 = _drags->current_pointer_y();
3153                 y2 = grab_y();
3154         } else {
3155                 y2 = _drags->current_pointer_y();
3156                 y1 = grab_y();
3157         }
3158
3159
3160         if (start != end || y1 != y2) {
3161
3162                 double x1 = _editor->frame_to_pixel (start);
3163                 double x2 = _editor->frame_to_pixel (end);
3164
3165                 _editor->rubberband_rect->property_x1() = x1;
3166                 if (_vertical_only) {
3167                         /* fixed 10 pixel width */
3168                         _editor->rubberband_rect->property_x2() = x1 + 10;
3169                 } else {
3170                         _editor->rubberband_rect->property_x2() = x2;
3171                 }
3172
3173                 _editor->rubberband_rect->property_y1() = y1;
3174                 _editor->rubberband_rect->property_y2() = y2;
3175
3176                 _editor->rubberband_rect->show();
3177                 _editor->rubberband_rect->raise_to_top();
3178
3179                 show_verbose_cursor_time (pf);
3180
3181                 do_select_things (event, true);
3182         }
3183 }
3184
3185 void
3186 RubberbandSelectDrag::do_select_things (GdkEvent* event, bool drag_in_progress)
3187 {
3188         framepos_t x1;
3189         framepos_t x2;
3190
3191         if (grab_frame() < last_pointer_frame()) {
3192                 x1 = grab_frame ();
3193                 x2 = last_pointer_frame ();
3194         } else {
3195                 x2 = grab_frame ();
3196                 x1 = last_pointer_frame ();
3197         }
3198
3199         double y1;
3200         double y2;
3201
3202         if (_drags->current_pointer_y() < grab_y()) {
3203                 y1 = _drags->current_pointer_y();
3204                 y2 = grab_y();
3205         } else {
3206                 y2 = _drags->current_pointer_y();
3207                 y1 = grab_y();
3208         }
3209
3210         select_things (event->button.state, x1, x2, y1, y2, drag_in_progress);
3211 }
3212
3213 void
3214 RubberbandSelectDrag::finished (GdkEvent* event, bool movement_occurred)
3215 {
3216         if (movement_occurred) {
3217
3218                 motion (event, false);
3219                 do_select_things (event, false);
3220
3221         } else {
3222
3223                 /* just a click */
3224
3225                 bool do_deselect = true;
3226                 MidiTimeAxisView* mtv;
3227
3228                 if ((mtv = dynamic_cast<MidiTimeAxisView*>(_editor->clicked_axisview)) != 0) {
3229                         /* MIDI track */
3230                         if (_editor->selection->empty()) {
3231                                 /* nothing selected */
3232                                 add_midi_region (mtv);
3233                                 do_deselect = false;
3234                         }
3235                 }
3236
3237                 if (do_deselect) {
3238                         deselect_things ();
3239                 }
3240
3241         }
3242
3243         _editor->rubberband_rect->hide();
3244 }
3245
3246 void
3247 RubberbandSelectDrag::aborted (bool)
3248 {
3249         _editor->rubberband_rect->hide ();
3250 }
3251
3252 TimeFXDrag::TimeFXDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, std::list<RegionView*> const & v)
3253         : RegionDrag (e, i, p, v)
3254 {
3255         DEBUG_TRACE (DEBUG::Drags, "New TimeFXDrag\n");
3256 }
3257
3258 void
3259 TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
3260 {
3261         Drag::start_grab (event, cursor);
3262
3263         show_verbose_cursor_time (adjusted_current_frame (event));
3264 }
3265
3266 void
3267 TimeFXDrag::motion (GdkEvent* event, bool)
3268 {
3269         RegionView* rv = _primary;
3270         StreamView* cv = rv->get_time_axis_view().view ();
3271
3272         pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (grab_y());
3273         int layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
3274         int layers = tv.first->layer_display() == Overlaid ? 1 : cv->layers();
3275
3276         framepos_t const pf = adjusted_current_frame (event);
3277
3278         if (pf > rv->region()->position()) {
3279                 rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf, layers, layer);
3280         }
3281
3282         show_verbose_cursor_time (pf);
3283 }
3284
3285 void
3286 TimeFXDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
3287 {
3288         _primary->get_time_axis_view().hide_timestretch ();
3289
3290         if (!movement_occurred) {
3291                 return;
3292         }
3293
3294         if (last_pointer_frame() < _primary->region()->position()) {
3295                 /* backwards drag of the left edge - not usable */
3296                 return;
3297         }
3298
3299         framecnt_t newlen = last_pointer_frame() - _primary->region()->position();
3300
3301         float percentage = (double) newlen / (double) _primary->region()->length();
3302
3303 #ifndef USE_RUBBERBAND
3304         // Soundtouch uses percentage / 100 instead of normal (/ 1)
3305         if (_primary->region()->data_type() == DataType::AUDIO) {
3306                 percentage = (float) ((double) newlen - (double) _primary->region()->length()) / ((double) newlen) * 100.0f;
3307         }
3308 #endif
3309
3310         if (!_editor->get_selection().regions.empty()) {
3311                 /* primary will already be included in the selection, and edit
3312                    group shared editing will propagate selection across
3313                    equivalent regions, so just use the current region
3314                    selection.
3315                 */
3316
3317                 if (_editor->time_stretch (_editor->get_selection().regions, percentage) == -1) {
3318                         error << _("An error occurred while executing time stretch operation") << endmsg;
3319                 }
3320         }
3321 }
3322
3323 void
3324 TimeFXDrag::aborted (bool)
3325 {
3326         _primary->get_time_axis_view().hide_timestretch ();
3327 }
3328
3329 ScrubDrag::ScrubDrag (Editor* e, ArdourCanvas::Item* i)
3330         : Drag (e, i)
3331 {
3332         DEBUG_TRACE (DEBUG::Drags, "New ScrubDrag\n");
3333 }
3334
3335 void
3336 ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3337 {
3338         Drag::start_grab (event);
3339 }
3340
3341 void
3342 ScrubDrag::motion (GdkEvent* /*event*/, bool)
3343 {
3344         _editor->scrub (adjusted_current_frame (0, false), _drags->current_pointer_x ());
3345 }
3346
3347 void
3348 ScrubDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
3349 {
3350         if (movement_occurred && _editor->session()) {
3351                 /* make sure we stop */
3352                 _editor->session()->request_transport_speed (0.0);
3353         }
3354 }
3355
3356 void
3357 ScrubDrag::aborted (bool)
3358 {
3359         /* XXX: TODO */
3360 }
3361
3362 SelectionDrag::SelectionDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
3363         : Drag (e, i)
3364         , _operation (o)
3365         , _copy (false)
3366         , _original_pointer_time_axis (-1)
3367         , _last_pointer_time_axis (-1)
3368         , _time_selection_at_start (!_editor->get_selection().time.empty())
3369 {
3370         DEBUG_TRACE (DEBUG::Drags, "New SelectionDrag\n");
3371 }
3372
3373 void
3374 SelectionDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
3375 {
3376         if (_editor->session() == 0) {
3377                 return;
3378         }
3379
3380         Gdk::Cursor* cursor = 0;
3381
3382         switch (_operation) {
3383         case CreateSelection:
3384                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
3385                         _copy = true;
3386                 } else {
3387                         _copy = false;
3388                 }
3389                 cursor = _editor->cursors()->selector;
3390                 Drag::start_grab (event, cursor);
3391                 break;
3392
3393         case SelectionStartTrim:
3394                 if (_editor->clicked_axisview) {
3395                         _editor->clicked_axisview->order_selection_trims (_item, true);
3396                 }
3397                 Drag::start_grab (event, _editor->cursors()->left_side_trim);
3398                 break;
3399
3400         case SelectionEndTrim:
3401                 if (_editor->clicked_axisview) {
3402                         _editor->clicked_axisview->order_selection_trims (_item, false);
3403                 }
3404                 Drag::start_grab (event, _editor->cursors()->right_side_trim);
3405                 break;
3406
3407         case SelectionMove:
3408                 Drag::start_grab (event, cursor);
3409                 break;
3410         }
3411
3412         if (_operation == SelectionMove) {
3413                 show_verbose_cursor_time (_editor->selection->time[_editor->clicked_selection].start);
3414         } else {
3415                 show_verbose_cursor_time (adjusted_current_frame (event));
3416         }
3417
3418         _original_pointer_time_axis = _editor->trackview_by_y_position (_drags->current_pointer_y ()).first->order ();
3419 }
3420
3421 void
3422 SelectionDrag::setup_pointer_frame_offset ()
3423 {
3424         switch (_operation) {
3425         case CreateSelection:
3426                 _pointer_frame_offset = 0;
3427                 break;
3428
3429         case SelectionStartTrim:
3430         case SelectionMove:
3431                 _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].start;
3432                 break;
3433
3434         case SelectionEndTrim:
3435                 _pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].end;
3436                 break;
3437         }
3438 }
3439
3440 void
3441 SelectionDrag::motion (GdkEvent* event, bool first_move)
3442 {
3443         framepos_t start = 0;
3444         framepos_t end = 0;
3445         framecnt_t length;
3446
3447         pair<TimeAxisView*, int> const pending_time_axis = _editor->trackview_by_y_position (_drags->current_pointer_y ());
3448         if (pending_time_axis.first == 0) {
3449                 return;
3450         }
3451
3452         framepos_t const pending_position = adjusted_current_frame (event);
3453
3454         /* only alter selection if things have changed */
3455
3456         if (pending_time_axis.first->order() == _last_pointer_time_axis && pending_position == last_pointer_frame()) {
3457                 return;
3458         }
3459
3460         switch (_operation) {
3461         case CreateSelection:
3462         {
3463                 framepos_t grab = grab_frame ();
3464
3465                 if (first_move) {
3466                         grab = adjusted_current_frame (event, false);
3467                         if (grab < pending_position) {
3468                                 _editor->snap_to (grab, -1);
3469                         }  else {
3470                                 _editor->snap_to (grab, 1);
3471                         }
3472                 }
3473
3474                 if (pending_position < grab) {
3475                         start = pending_position;
3476                         end = grab;
3477                 } else {
3478                         end = pending_position;
3479                         start = grab;
3480                 }
3481
3482                 /* first drag: Either add to the selection
3483                    or create a new selection
3484                 */
3485
3486                 if (first_move) {
3487
3488                         if (_copy) {
3489                                 /* adding to the selection */
3490                                 _editor->set_selected_track_as_side_effect (Selection::Add);
3491                                 //_editor->selection->add (_editor->clicked_axisview);
3492                                 _editor->clicked_selection = _editor->selection->add (start, end);
3493                                 _copy = false;
3494                         } else {
3495                                 /* new selection */
3496
3497                                 if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
3498                                         //_editor->selection->set (_editor->clicked_axisview);
3499                                         _editor->set_selected_track_as_side_effect (Selection::Set);
3500                                 }
3501
3502                                 _editor->clicked_selection = _editor->selection->set (start, end);
3503                         }
3504                 }
3505
3506                 /* select the track that we're in */
3507                 if (find (_added_time_axes.begin(), _added_time_axes.end(), pending_time_axis.first) == _added_time_axes.end()) {
3508                         // _editor->set_selected_track_as_side_effect (Selection::Add);
3509                         _editor->selection->add (pending_time_axis.first);
3510                         _added_time_axes.push_back (pending_time_axis.first);
3511                 }
3512
3513                 /* deselect any tracks that this drag no longer includes, being careful to only deselect
3514                    tracks that we selected in the first place.
3515                 */
3516
3517                 int min_order = min (_original_pointer_time_axis, pending_time_axis.first->order());
3518                 int max_order = max (_original_pointer_time_axis, pending_time_axis.first->order());
3519
3520                 list<TimeAxisView*>::iterator i = _added_time_axes.begin();
3521                 while (i != _added_time_axes.end()) {
3522
3523                         list<TimeAxisView*>::iterator tmp = i;
3524                         ++tmp;
3525
3526                         if ((*i)->order() < min_order || (*i)->order() > max_order) {
3527                                 _editor->selection->remove (*i);
3528                                 _added_time_axes.remove (*i);
3529                         }
3530
3531                         i = tmp;
3532                 }
3533
3534         }
3535         break;
3536
3537         case SelectionStartTrim:
3538
3539                 start = _editor->selection->time[_editor->clicked_selection].start;
3540                 end = _editor->selection->time[_editor->clicked_selection].end;
3541
3542                 if (pending_position > end) {
3543                         start = end;
3544                 } else {
3545                         start = pending_position;
3546                 }
3547                 break;
3548
3549         case SelectionEndTrim:
3550
3551                 start = _editor->selection->time[_editor->clicked_selection].start;
3552                 end = _editor->selection->time[_editor->clicked_selection].end;
3553
3554                 if (pending_position < start) {
3555                         end = start;
3556                 } else {
3557                         end = pending_position;
3558                 }
3559
3560                 break;
3561
3562         case SelectionMove:
3563
3564                 start = _editor->selection->time[_editor->clicked_selection].start;
3565                 end = _editor->selection->time[_editor->clicked_selection].end;
3566
3567                 length = end - start;
3568
3569                 start = pending_position;
3570                 _editor->snap_to (start);
3571
3572                 end = start + length;
3573
3574                 break;
3575         }
3576
3577         if (event->button.x >= _editor->horizontal_position() + _editor->_canvas_width) {
3578                 _editor->start_canvas_autoscroll (1, 0);
3579         }
3580
3581         if (start != end) {
3582                 _editor->selection->replace (_editor->clicked_selection, start, end);
3583         }
3584
3585         if (_operation == SelectionMove) {
3586                 show_verbose_cursor_time(start);
3587         } else {
3588                 show_verbose_cursor_time(pending_position);
3589         }
3590 }
3591
3592 void
3593 SelectionDrag::finished (GdkEvent* event, bool movement_occurred)
3594 {
3595         Session* s = _editor->session();
3596
3597         if (movement_occurred) {
3598                 motion (event, false);
3599                 /* XXX this is not object-oriented programming at all. ick */
3600                 if (_editor->selection->time.consolidate()) {
3601                         _editor->selection->TimeChanged ();
3602                 }
3603
3604                 /* XXX what if its a music time selection? */
3605                 if (s) {
3606                         if ((s->config.get_auto_play() || (s->get_play_range() && s->transport_rolling()))) {
3607                                 s->request_play_range (&_editor->selection->time, true);
3608                         } else {
3609                                 if (Config->get_always_play_range()) {
3610                                         if (_editor->doing_range_stuff()) {
3611                                                 s->request_locate (_editor->get_selection().time.start());
3612                                         }
3613                                 }
3614                         }
3615                 }
3616
3617         } else {
3618                 /* just a click, no pointer movement.
3619                  */
3620
3621                 if (Keyboard::no_modifier_keys_pressed (&event->button)) {
3622                         if (!_time_selection_at_start) {
3623                                 if (_editor->clicked_regionview) {
3624                                         if (_editor->get_selection().selected (_editor->clicked_regionview)) {
3625                                                 /* range select the entire current
3626                                                    region selection
3627                                                 */
3628                                                 _editor->select_range (_editor->get_selection().regions.start(),
3629                                                                        _editor->get_selection().regions.end_frame());
3630                                         } else {
3631                                                 /* range select this (unselected)
3632                                                  * region
3633                                                  */
3634                                                 _editor->select_range (_editor->clicked_regionview->region()->position(),
3635                                                                        _editor->clicked_regionview->region()->last_frame());
3636                                         }
3637                                 }
3638                         } else {
3639                                 _editor->selection->clear_time();
3640                         }
3641                 }
3642
3643                 if (_editor->clicked_axisview && !_editor->selection->selected (_editor->clicked_axisview)) {
3644                         _editor->selection->set (_editor->clicked_axisview);
3645                 }
3646
3647                 if (s && s->get_play_range () && s->transport_rolling()) {
3648                         s->request_stop (false, false);
3649                 }
3650
3651         }
3652
3653         _editor->stop_canvas_autoscroll ();
3654 }
3655
3656 void
3657 SelectionDrag::aborted (bool)
3658 {
3659         /* XXX: TODO */
3660 }
3661
3662 RangeMarkerBarDrag::RangeMarkerBarDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
3663         : Drag (e, i),
3664           _operation (o),
3665           _copy (false)
3666 {
3667         DEBUG_TRACE (DEBUG::Drags, "New RangeMarkerBarDrag\n");
3668
3669         _drag_rect = new ArdourCanvas::SimpleRect (*_editor->time_line_group, 0.0, 0.0, 0.0,
3670                                                    physical_screen_height (_editor->get_window()));
3671         _drag_rect->hide ();
3672
3673         _drag_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_RangeDragRect.get();
3674         _drag_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_RangeDragRect.get();
3675 }
3676
3677 void
3678 RangeMarkerBarDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3679 {
3680         if (_editor->session() == 0) {
3681                 return;
3682         }
3683
3684         Gdk::Cursor* cursor = 0;
3685
3686         if (!_editor->temp_location) {
3687                 _editor->temp_location = new Location (*_editor->session());
3688         }
3689
3690         switch (_operation) {
3691         case CreateRangeMarker:
3692         case CreateTransportMarker:
3693         case CreateCDMarker:
3694
3695                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
3696                         _copy = true;
3697                 } else {
3698                         _copy = false;
3699                 }
3700                 cursor = _editor->cursors()->selector;
3701                 break;
3702         }
3703
3704         Drag::start_grab (event, cursor);
3705
3706         show_verbose_cursor_time (adjusted_current_frame (event));
3707 }
3708
3709 void
3710 RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move)
3711 {
3712         framepos_t start = 0;
3713         framepos_t end = 0;
3714         ArdourCanvas::SimpleRect *crect;
3715
3716         switch (_operation) {
3717         case CreateRangeMarker:
3718                 crect = _editor->range_bar_drag_rect;
3719                 break;
3720         case CreateTransportMarker:
3721                 crect = _editor->transport_bar_drag_rect;
3722                 break;
3723         case CreateCDMarker:
3724                 crect = _editor->cd_marker_bar_drag_rect;
3725                 break;
3726         default:
3727                 error << string_compose (_("programming_error: %1"), "Error: unknown range marker op passed to Editor::drag_range_markerbar_op ()") << endmsg;
3728                 return;
3729                 break;
3730         }
3731
3732         framepos_t const pf = adjusted_current_frame (event);
3733
3734         if (_operation == CreateRangeMarker || _operation == CreateTransportMarker || _operation == CreateCDMarker) {
3735                 framepos_t grab = grab_frame ();
3736                 _editor->snap_to (grab);
3737
3738                 if (pf < grab_frame()) {
3739                         start = pf;
3740                         end = grab;
3741                 } else {
3742                         end = pf;
3743                         start = grab;
3744                 }
3745
3746                 /* first drag: Either add to the selection
3747                    or create a new selection.
3748                 */
3749
3750                 if (first_move) {
3751
3752                         _editor->temp_location->set (start, end);
3753
3754                         crect->show ();
3755
3756                         update_item (_editor->temp_location);
3757                         _drag_rect->show();
3758                         //_drag_rect->raise_to_top();
3759
3760                 }
3761         }
3762
3763         if (event->button.x >= _editor->horizontal_position() + _editor->_canvas_width) {
3764                 _editor->start_canvas_autoscroll (1, 0);
3765         }
3766
3767         if (start != end) {
3768                 _editor->temp_location->set (start, end);
3769
3770                 double x1 = _editor->frame_to_pixel (start);
3771                 double x2 = _editor->frame_to_pixel (end);
3772                 crect->property_x1() = x1;
3773                 crect->property_x2() = x2;
3774
3775                 update_item (_editor->temp_location);
3776         }
3777
3778         show_verbose_cursor_time (pf);
3779
3780 }
3781
3782 void
3783 RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred)
3784 {
3785         Location * newloc = 0;
3786         string rangename;
3787         int flags;
3788
3789         if (movement_occurred) {
3790                 motion (event, false);
3791                 _drag_rect->hide();
3792
3793                 switch (_operation) {
3794                 case CreateRangeMarker:
3795                 case CreateCDMarker:
3796                     {
3797                         _editor->begin_reversible_command (_("new range marker"));
3798                         XMLNode &before = _editor->session()->locations()->get_state();
3799                         _editor->session()->locations()->next_available_name(rangename,"unnamed");
3800                         if (_operation == CreateCDMarker) {
3801                                 flags = Location::IsRangeMarker | Location::IsCDMarker;
3802                                 _editor->cd_marker_bar_drag_rect->hide();
3803                         }
3804                         else {
3805                                 flags = Location::IsRangeMarker;
3806                                 _editor->range_bar_drag_rect->hide();
3807                         }
3808                         newloc = new Location (
3809                                 *_editor->session(), _editor->temp_location->start(), _editor->temp_location->end(), rangename, (Location::Flags) flags
3810                                 );
3811
3812                         _editor->session()->locations()->add (newloc, true);
3813                         XMLNode &after = _editor->session()->locations()->get_state();
3814                         _editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
3815                         _editor->commit_reversible_command ();
3816                         break;
3817                     }
3818
3819                 case CreateTransportMarker:
3820                         // popup menu to pick loop or punch
3821                         _editor->new_transport_marker_context_menu (&event->button, _item);
3822                         break;
3823                 }
3824         } else {
3825                 /* just a click, no pointer movement. remember that context menu stuff was handled elsewhere */
3826
3827                 if (Keyboard::no_modifier_keys_pressed (&event->button) && _operation != CreateCDMarker) {
3828
3829                         framepos_t start;
3830                         framepos_t end;
3831
3832                         _editor->session()->locations()->marks_either_side (grab_frame(), start, end);
3833
3834                         if (end == max_framepos) {
3835                                 end = _editor->session()->current_end_frame ();
3836                         }
3837
3838                         if (start == max_framepos) {
3839                                 start = _editor->session()->current_start_frame ();
3840                         }
3841
3842                         switch (_editor->mouse_mode) {
3843                         case MouseObject:
3844                                 /* find the two markers on either side and then make the selection from it */
3845                                 _editor->select_all_within (start, end, 0.0f, FLT_MAX, _editor->track_views, Selection::Set, false);
3846                                 break;
3847
3848                         case MouseRange:
3849                                 /* find the two markers on either side of the click and make the range out of it */
3850                                 _editor->selection->set (start, end);
3851                                 break;
3852
3853                         default:
3854                                 break;
3855                         }
3856                 }
3857         }
3858
3859         _editor->stop_canvas_autoscroll ();
3860 }
3861
3862 void
3863 RangeMarkerBarDrag::aborted (bool)
3864 {
3865         /* XXX: TODO */
3866 }
3867
3868 void
3869 RangeMarkerBarDrag::update_item (Location* location)
3870 {
3871         double const x1 = _editor->frame_to_pixel (location->start());
3872         double const x2 = _editor->frame_to_pixel (location->end());
3873
3874         _drag_rect->property_x1() = x1;
3875         _drag_rect->property_x2() = x2;
3876 }
3877
3878 MouseZoomDrag::MouseZoomDrag (Editor* e, ArdourCanvas::Item* i)
3879         : Drag (e, i)
3880         , _zoom_out (false)
3881 {
3882         DEBUG_TRACE (DEBUG::Drags, "New MouseZoomDrag\n");
3883 }
3884
3885 void
3886 MouseZoomDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3887 {
3888         if (Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
3889                 Drag::start_grab (event, _editor->cursors()->zoom_out);
3890                 _zoom_out = true;
3891         } else {
3892                 Drag::start_grab (event, _editor->cursors()->zoom_in);
3893                 _zoom_out = false;
3894         }
3895
3896         show_verbose_cursor_time (adjusted_current_frame (event));
3897 }
3898
3899 void
3900 MouseZoomDrag::motion (GdkEvent* event, bool first_move)
3901 {
3902         framepos_t start;
3903         framepos_t end;
3904
3905         framepos_t const pf = adjusted_current_frame (event);
3906
3907         framepos_t grab = grab_frame ();
3908         _editor->snap_to_with_modifier (grab, event);
3909
3910         /* base start and end on initial click position */
3911         if (pf < grab) {
3912                 start = pf;
3913                 end = grab;
3914         } else {
3915                 end = pf;
3916                 start = grab;
3917         }
3918
3919         if (start != end) {
3920
3921                 if (first_move) {
3922                         _editor->zoom_rect->show();
3923                         _editor->zoom_rect->raise_to_top();
3924                 }
3925
3926                 _editor->reposition_zoom_rect(start, end);
3927
3928                 show_verbose_cursor_time (pf);
3929         }
3930 }
3931
3932 void
3933 MouseZoomDrag::finished (GdkEvent* event, bool movement_occurred)
3934 {
3935         if (movement_occurred) {
3936                 motion (event, false);
3937
3938                 if (grab_frame() < last_pointer_frame()) {
3939                         _editor->temporal_zoom_by_frame (grab_frame(), last_pointer_frame());
3940                 } else {
3941                         _editor->temporal_zoom_by_frame (last_pointer_frame(), grab_frame());
3942                 }
3943         } else {
3944                 if (Keyboard::the_keyboard().key_is_down (GDK_Shift_L)) {
3945                         _editor->tav_zoom_step (_zoom_out);
3946                 } else {
3947                         _editor->temporal_zoom_to_frame (_zoom_out, grab_frame());
3948                 }
3949         }
3950
3951         _editor->zoom_rect->hide();
3952 }
3953
3954 void
3955 MouseZoomDrag::aborted (bool)
3956 {
3957         _editor->zoom_rect->hide ();
3958 }
3959
3960 NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i)
3961         : Drag (e, i)
3962         , _cumulative_dx (0)
3963         , _cumulative_dy (0)
3964 {
3965         DEBUG_TRACE (DEBUG::Drags, "New NoteDrag\n");
3966
3967         _primary = dynamic_cast<CanvasNoteEvent*> (_item);
3968         _region = &_primary->region_view ();
3969         _note_height = _region->midi_stream_view()->note_height ();
3970 }
3971
3972 void
3973 NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
3974 {
3975         Drag::start_grab (event);
3976
3977         if (!(_was_selected = _primary->selected())) {
3978
3979                 /* tertiary-click means extend selection - we'll do that on button release,
3980                    so don't add it here, because otherwise we make it hard to figure
3981                    out the "extend-to" range.
3982                 */
3983
3984                 bool extend = Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier);
3985
3986                 if (!extend) {
3987                         bool add = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
3988
3989                         if (add) {
3990                                 _region->note_selected (_primary, true);
3991                         } else {
3992                                 _region->unique_select (_primary);
3993                         }
3994                 }
3995         }
3996 }
3997
3998 /** @return Current total drag x change in frames */
3999 frameoffset_t
4000 NoteDrag::total_dx () const
4001 {
4002         /* dx in frames */
4003         frameoffset_t const dx = _editor->unit_to_frame (_drags->current_pointer_x() - grab_x());
4004
4005         /* primary note time */
4006         frameoffset_t const n = _region->source_beats_to_absolute_frames (_primary->note()->time ());
4007
4008         /* new time of the primary note in session frames */
4009         frameoffset_t st = n + dx;
4010
4011         framepos_t const rp = _region->region()->position ();
4012
4013         /* prevent the note being dragged earlier than the region's position */
4014         st = max (st, rp);
4015
4016         /* snap and return corresponding delta */
4017         return _region->snap_frame_to_frame (st - rp) + rp - n;
4018 }
4019
4020 /** @return Current total drag y change in note number */
4021 int8_t
4022 NoteDrag::total_dy () const
4023 {
4024         MidiStreamView* msv = _region->midi_stream_view ();
4025         double const y = _region->midi_view()->y_position ();
4026         /* new current note */
4027         uint8_t n = msv->y_to_note (_drags->current_pointer_y () - y);
4028         /* clamp */
4029         n = max (msv->lowest_note(), n);
4030         n = min (msv->highest_note(), n);
4031         /* and work out delta */
4032         return n - msv->y_to_note (grab_y() - y);
4033 }
4034
4035 void
4036 NoteDrag::motion (GdkEvent *, bool)
4037 {
4038         /* Total change in x and y since the start of the drag */
4039         frameoffset_t const dx = total_dx ();
4040         int8_t const dy = total_dy ();
4041
4042         /* Now work out what we have to do to the note canvas items to set this new drag delta */
4043         double const tdx = _editor->frame_to_unit (dx) - _cumulative_dx;
4044         double const tdy = -dy * _note_height - _cumulative_dy;
4045
4046         if (tdx || tdy) {
4047                 _cumulative_dx += tdx;
4048                 _cumulative_dy += tdy;
4049
4050                 int8_t note_delta = total_dy();
4051
4052                 _region->move_selection (tdx, tdy, note_delta);
4053
4054                 /* the new note value may be the same as the old one, but we
4055                  * don't know what that means because the selection may have
4056                  * involved more than one note and we might be doing something
4057                  * odd with them. so show the note value anyway, always.
4058                  */
4059
4060                 char buf[12];
4061                 uint8_t new_note = min (max (_primary->note()->note() + note_delta, 0), 127);
4062
4063                 snprintf (buf, sizeof (buf), "%s (%d)", Evoral::midi_note_name (new_note).c_str(),
4064                           (int) floor (new_note));
4065
4066                 show_verbose_cursor_text (buf);
4067         }
4068 }
4069
4070 void
4071 NoteDrag::finished (GdkEvent* ev, bool moved)
4072 {
4073         if (!moved) {
4074                 /* no motion - select note */
4075
4076                 if (_editor->current_mouse_mode() == Editing::MouseObject ||
4077                     _editor->current_mouse_mode() == Editing::MouseDraw) {
4078
4079                         if (_was_selected) {
4080                                 bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
4081                                 if (add) {
4082                                         _region->note_deselected (_primary);
4083                                 }
4084                         } else {
4085                                 bool extend = Keyboard::modifier_state_equals (ev->button.state, Keyboard::TertiaryModifier);
4086                                 bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
4087
4088                                 if (!extend && !add && _region->selection_size() > 1) {
4089                                         _region->unique_select (_primary);
4090                                 } else if (extend) {
4091                                         _region->note_selected (_primary, true, true);
4092                                 } else {
4093                                         /* it was added during button press */
4094                                 }
4095                         }
4096                 }
4097         } else {
4098                 _region->note_dropped (_primary, total_dx(), total_dy());
4099         }
4100 }
4101
4102 void
4103 NoteDrag::aborted (bool)
4104 {
4105         /* XXX: TODO */
4106 }
4107
4108 /** Make an AutomationRangeDrag for lines in an AutomationTimeAxisView */
4109 AutomationRangeDrag::AutomationRangeDrag (Editor* editor, AutomationTimeAxisView* atv, list<AudioRange> const & r)
4110         : Drag (editor, atv->base_item ())
4111         , _ranges (r)
4112         , _nothing_to_drag (false)
4113 {
4114         DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
4115         y_origin = atv->y_position();
4116         setup (atv->lines ());
4117 }
4118
4119 /** Make an AutomationRangeDrag for region gain lines */
4120 AutomationRangeDrag::AutomationRangeDrag (Editor* editor, AudioRegionView* rv, list<AudioRange> const & r)
4121         : Drag (editor, rv->get_canvas_group ())
4122         , _ranges (r)
4123         , _nothing_to_drag (false)
4124 {
4125         DEBUG_TRACE (DEBUG::Drags, "New AutomationRangeDrag\n");
4126
4127         list<boost::shared_ptr<AutomationLine> > lines;
4128         lines.push_back (rv->get_gain_line ());
4129         y_origin = rv->get_time_axis_view().y_position();
4130         setup (lines);
4131 }
4132
4133 /** @param lines AutomationLines to drag.
4134  *  @param offset Offset from the session start to the points in the AutomationLines.
4135  */
4136 void
4137 AutomationRangeDrag::setup (list<boost::shared_ptr<AutomationLine> > const & lines)
4138 {
4139         /* find the lines that overlap the ranges being dragged */
4140         list<boost::shared_ptr<AutomationLine> >::const_iterator i = lines.begin ();
4141         while (i != lines.end ()) {
4142                 list<boost::shared_ptr<AutomationLine> >::const_iterator j = i;
4143                 ++j;
4144
4145                 pair<framepos_t, framepos_t> r = (*i)->get_point_x_range ();
4146
4147                 /* check this range against all the AudioRanges that we are using */
4148                 list<AudioRange>::const_iterator k = _ranges.begin ();
4149                 while (k != _ranges.end()) {
4150                         if (k->coverage (r.first, r.second) != Evoral::OverlapNone) {
4151                                 break;
4152                         }
4153                         ++k;
4154                 }
4155
4156                 /* add it to our list if it overlaps at all */
4157                 if (k != _ranges.end()) {
4158                         Line n;
4159                         n.line = *i;
4160                         n.state = 0;
4161                         n.range = r;
4162                         _lines.push_back (n);
4163                 }
4164
4165                 i = j;
4166         }
4167
4168         /* Now ::lines contains the AutomationLines that somehow overlap our drag */
4169 }
4170
4171 double
4172 AutomationRangeDrag::y_fraction (boost::shared_ptr<AutomationLine> line, double global_y) const
4173 {
4174         return 1.0 - ((global_y - y_origin) / line->height());
4175 }
4176
4177 void
4178 AutomationRangeDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
4179 {
4180         Drag::start_grab (event, cursor);
4181
4182         /* Get line states before we start changing things */
4183         for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4184                 i->state = &i->line->get_state ();
4185                 i->original_fraction = y_fraction (i->line, _drags->current_pointer_y());
4186         }
4187
4188         if (_ranges.empty()) {
4189
4190                 /* No selected time ranges: drag all points */
4191                 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4192                         uint32_t const N = i->line->npoints ();
4193                         for (uint32_t j = 0; j < N; ++j) {
4194                                 i->points.push_back (i->line->nth (j));
4195                         }
4196                 }
4197
4198         } else {
4199
4200                 for (list<AudioRange>::const_iterator i = _ranges.begin(); i != _ranges.end(); ++i) {
4201
4202                         framecnt_t const half = (i->start + i->end) / 2;
4203
4204                         /* find the line that this audio range starts in */
4205                         list<Line>::iterator j = _lines.begin();
4206                         while (j != _lines.end() && (j->range.first > i->start || j->range.second < i->start)) {
4207                                 ++j;
4208                         }
4209
4210                         if (j != _lines.end()) {
4211                                 boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
4212
4213                                 /* j is the line that this audio range starts in; fade into it;
4214                                    64 samples length plucked out of thin air.
4215                                 */
4216
4217                                 framepos_t a = i->start + 64;
4218                                 if (a > half) {
4219                                         a = half;
4220                                 }
4221
4222                                 double const p = j->line->time_converter().from (i->start - j->line->time_converter().origin_b ());
4223                                 double const q = j->line->time_converter().from (a - j->line->time_converter().origin_b ());
4224
4225                                 the_list->add (p, the_list->eval (p));
4226                                 the_list->add (q, the_list->eval (q));
4227                         }
4228
4229                         /* same thing for the end */
4230
4231                         j = _lines.begin();
4232                         while (j != _lines.end() && (j->range.first > i->end || j->range.second < i->end)) {
4233                                 ++j;
4234                         }
4235
4236                         if (j != _lines.end()) {
4237                                 boost::shared_ptr<AutomationList> the_list = j->line->the_list ();
4238
4239                                 /* j is the line that this audio range starts in; fade out of it;
4240                                    64 samples length plucked out of thin air.
4241                                 */
4242
4243                                 framepos_t b = i->end - 64;
4244                                 if (b < half) {
4245                                         b = half;
4246                                 }
4247
4248                                 double const p = j->line->time_converter().from (b - j->line->time_converter().origin_b ());
4249                                 double const q = j->line->time_converter().from (i->end - j->line->time_converter().origin_b ());
4250
4251                                 the_list->add (p, the_list->eval (p));
4252                                 the_list->add (q, the_list->eval (q));
4253                         }
4254                 }
4255
4256                 _nothing_to_drag = true;
4257
4258                 /* Find all the points that should be dragged and put them in the relevant
4259                    points lists in the Line structs.
4260                 */
4261
4262                 for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4263
4264                         uint32_t const N = i->line->npoints ();
4265                         for (uint32_t j = 0; j < N; ++j) {
4266
4267                                 /* here's a control point on this line */
4268                                 ControlPoint* p = i->line->nth (j);
4269                                 double const w = i->line->time_converter().to ((*p->model())->when) + i->line->time_converter().origin_b ();
4270
4271                                 /* see if it's inside a range */
4272                                 list<AudioRange>::const_iterator k = _ranges.begin ();
4273                                 while (k != _ranges.end() && (k->start >= w || k->end <= w)) {
4274                                         ++k;
4275                                 }
4276
4277                                 if (k != _ranges.end()) {
4278                                         /* dragging this point */
4279                                         _nothing_to_drag = false;
4280                                         i->points.push_back (p);
4281                                 }
4282                         }
4283                 }
4284         }
4285
4286         if (_nothing_to_drag) {
4287                 return;
4288         }
4289
4290         for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4291                 i->line->start_drag_multiple (i->points, y_fraction (i->line, _drags->current_pointer_y()), i->state);
4292         }
4293 }
4294
4295 void
4296 AutomationRangeDrag::motion (GdkEvent*, bool /*first_move*/)
4297 {
4298         if (_nothing_to_drag) {
4299                 return;
4300         }
4301
4302         for (list<Line>::iterator l = _lines.begin(); l != _lines.end(); ++l) {
4303                 float const f = y_fraction (l->line, _drags->current_pointer_y());
4304                 /* we are ignoring x position for this drag, so we can just pass in anything */
4305                 l->line->drag_motion (0, f, true, false);
4306                 show_verbose_cursor_text (l->line->get_verbose_cursor_relative_string (l->original_fraction, f));
4307         }
4308 }
4309
4310 void
4311 AutomationRangeDrag::finished (GdkEvent* event, bool)
4312 {
4313         if (_nothing_to_drag) {
4314                 return;
4315         }
4316
4317         motion (event, false);
4318         for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4319                 i->line->end_drag ();
4320         }
4321
4322         _editor->session()->commit_reversible_command ();
4323 }
4324
4325 void
4326 AutomationRangeDrag::aborted (bool)
4327 {
4328         for (list<Line>::iterator i = _lines.begin(); i != _lines.end(); ++i) {
4329                 i->line->reset ();
4330         }
4331 }
4332
4333 DraggingView::DraggingView (RegionView* v, RegionDrag* parent)
4334         : view (v)
4335 {
4336         time_axis_view = parent->find_time_axis_view (&v->get_time_axis_view ());
4337         layer = v->region()->layer ();
4338         initial_y = v->get_canvas_group()->property_y ();
4339         initial_playlist = v->region()->playlist ();
4340         initial_position = v->region()->position ();
4341         initial_end = v->region()->position () + v->region()->length ();
4342 }
4343
4344 PatchChangeDrag::PatchChangeDrag (Editor* e, CanvasPatchChange* i, MidiRegionView* r)
4345         : Drag (e, i)
4346         , _region_view (r)
4347         , _patch_change (i)
4348         , _cumulative_dx (0)
4349 {
4350         DEBUG_TRACE (DEBUG::Drags, string_compose ("New PatchChangeDrag, patch @ %1, grab @ %2\n",
4351                                                    _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time()),
4352                                                    grab_frame()));
4353 }
4354
4355 void
4356 PatchChangeDrag::motion (GdkEvent* ev, bool)
4357 {
4358         framepos_t f = adjusted_current_frame (ev);
4359         boost::shared_ptr<Region> r = _region_view->region ();
4360         f = max (f, r->position ());
4361         f = min (f, r->last_frame ());
4362
4363         framecnt_t const dxf = f - grab_frame(); // permitted dx in frames
4364         double const dxu = _editor->frame_to_unit (dxf); // permitted fx in units
4365         _patch_change->move (dxu - _cumulative_dx, 0);
4366         _cumulative_dx = dxu;
4367 }
4368
4369 void
4370 PatchChangeDrag::finished (GdkEvent* ev, bool movement_occurred)
4371 {
4372         if (!movement_occurred) {
4373                 return;
4374         }
4375
4376         boost::shared_ptr<Region> r (_region_view->region ());
4377         framepos_t f = adjusted_current_frame (ev);
4378         f = max (f, r->position ());
4379         f = min (f, r->last_frame ());
4380
4381         _region_view->move_patch_change (
4382                 *_patch_change,
4383                 _region_view->region_frames_to_region_beats (f - (r->position() - r->start()))
4384                 );
4385 }
4386
4387 void
4388 PatchChangeDrag::aborted (bool)
4389 {
4390         _patch_change->move (-_cumulative_dx, 0);
4391 }
4392
4393 void
4394 PatchChangeDrag::setup_pointer_frame_offset ()
4395 {
4396         boost::shared_ptr<Region> region = _region_view->region ();
4397         _pointer_frame_offset = raw_grab_frame() - _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time());
4398 }
4399
4400 MidiRubberbandSelectDrag::MidiRubberbandSelectDrag (Editor* e, MidiRegionView* rv)
4401         : RubberbandSelectDrag (e, rv->get_canvas_frame ())
4402         , _region_view (rv)
4403 {
4404
4405 }
4406
4407 void
4408 MidiRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool /*drag_in_progress*/)
4409 {
4410         framepos_t const p = _region_view->region()->position ();
4411         double const y = _region_view->midi_view()->y_position ();
4412
4413         x1 = max ((framepos_t) 0, x1 - p);
4414         x2 = max ((framepos_t) 0, x2 - p);
4415         y1 = max (0.0, y1 - y);
4416         y2 = max (0.0, y2 - y);
4417
4418         _region_view->update_drag_selection (
4419                 _editor->frame_to_pixel (x1),
4420                 _editor->frame_to_pixel (x2),
4421                 y1,
4422                 y2,
4423                 Keyboard::modifier_state_contains (button_state, Keyboard::TertiaryModifier)
4424                 );
4425 }
4426
4427 void
4428 MidiRubberbandSelectDrag::deselect_things ()
4429 {
4430         /* XXX */
4431 }
4432
4433 MidiVerticalSelectDrag::MidiVerticalSelectDrag (Editor* e, MidiRegionView* rv)
4434         : RubberbandSelectDrag (e, rv->get_canvas_frame ())
4435         , _region_view (rv)
4436 {
4437         _vertical_only = true;
4438 }
4439
4440 void
4441 MidiVerticalSelectDrag::select_things (int button_state, framepos_t /*x1*/, framepos_t /*x2*/, double y1, double y2, bool /*drag_in_progress*/)
4442 {
4443         double const y = _region_view->midi_view()->y_position ();
4444
4445         y1 = max (0.0, y1 - y);
4446         y2 = max (0.0, y2 - y);
4447
4448         _region_view->update_vertical_drag_selection (
4449                 y1,
4450                 y2,
4451                 Keyboard::modifier_state_contains (button_state, Keyboard::TertiaryModifier)
4452                 );
4453 }
4454
4455 void
4456 MidiVerticalSelectDrag::deselect_things ()
4457 {
4458         /* XXX */
4459 }
4460
4461 EditorRubberbandSelectDrag::EditorRubberbandSelectDrag (Editor* e, ArdourCanvas::Item* i)
4462         : RubberbandSelectDrag (e, i)
4463 {
4464
4465 }
4466
4467 void
4468 EditorRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool drag_in_progress)
4469 {
4470         if (drag_in_progress) {
4471                 /* We just want to select things at the end of the drag, not during it */
4472                 return;
4473         }
4474
4475         Selection::Operation op = ArdourKeyboard::selection_type (button_state);
4476
4477         _editor->begin_reversible_command (_("rubberband selection"));
4478         _editor->select_all_within (x1, x2 - 1, y1, y2, _editor->track_views, op, false);
4479         _editor->commit_reversible_command ();
4480 }
4481
4482 void
4483 EditorRubberbandSelectDrag::deselect_things ()
4484 {
4485         if (!getenv("ARDOUR_SAE")) {
4486                 _editor->selection->clear_tracks();
4487         }
4488         _editor->selection->clear_regions();
4489         _editor->selection->clear_points ();
4490         _editor->selection->clear_lines ();
4491 }
4492
4493 NoteCreateDrag::NoteCreateDrag (Editor* e, ArdourCanvas::Item* i, MidiRegionView* rv)
4494         : Drag (e, i)
4495         , _region_view (rv)
4496         , _drag_rect (0)
4497 {
4498
4499 }
4500
4501 NoteCreateDrag::~NoteCreateDrag ()
4502 {
4503         delete _drag_rect;
4504 }
4505
4506 framecnt_t
4507 NoteCreateDrag::grid_frames (framepos_t t) const
4508 {
4509         bool success;
4510         Evoral::MusicalTime grid_beats = _editor->get_grid_type_as_beats (success, t);
4511         if (!success) {
4512                 grid_beats = 1;
4513         }
4514
4515         return _region_view->region_beats_to_region_frames (grid_beats);
4516 }
4517
4518 void
4519 NoteCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
4520 {
4521         Drag::start_grab (event, cursor);
4522
4523         _drag_rect = new ArdourCanvas::SimpleRect (*_region_view->get_canvas_group ());
4524
4525         framepos_t pf = _drags->current_pointer_frame ();
4526         framecnt_t const g = grid_frames (pf);
4527
4528         /* Hack so that we always snap to the note that we are over, instead of snapping
4529            to the next one if we're more than halfway through the one we're over.
4530         */
4531         if (_editor->snap_mode() == SnapNormal && pf > g / 2) {
4532                 pf -= g / 2;
4533         }
4534
4535         _note[0] = adjusted_frame (pf, event) - _region_view->region()->position ();
4536
4537         MidiStreamView* sv = _region_view->midi_stream_view ();
4538         double const x = _editor->frame_to_pixel (_note[0]);
4539         double const y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
4540
4541         _drag_rect->property_x1() = x;
4542         _drag_rect->property_y1() = y;
4543         _drag_rect->property_x2() = x;
4544         _drag_rect->property_y2() = y + floor (_region_view->midi_stream_view()->note_height ());
4545
4546         _drag_rect->property_outline_what() = 0xff;
4547         _drag_rect->property_outline_color_rgba() = 0xffffff99;
4548         _drag_rect->property_fill_color_rgba()    = 0xffffff66;
4549 }
4550
4551 void
4552 NoteCreateDrag::motion (GdkEvent* event, bool)
4553 {
4554         _note[1] = max ((framepos_t)0, adjusted_current_frame (event) - _region_view->region()->position ());
4555         double const x = _editor->frame_to_pixel (_note[1]);
4556         if (_note[1] > _note[0]) {
4557                 _drag_rect->property_x2() = x;
4558         } else {
4559                 _drag_rect->property_x1() = x;
4560         }
4561 }
4562
4563 void
4564 NoteCreateDrag::finished (GdkEvent*, bool had_movement)
4565 {
4566         if (!had_movement) {
4567                 return;
4568         }
4569
4570         framepos_t const start = min (_note[0], _note[1]);
4571         framecnt_t length = abs (_note[0] - _note[1]);
4572
4573         framecnt_t const g = grid_frames (start);
4574         double const one_tick = 1 / Timecode::BBT_Time::ticks_per_beat;
4575
4576         if (_editor->snap_mode() == SnapNormal && length < g) {
4577                 length = g - one_tick;
4578         }
4579
4580         double const length_beats = max (one_tick, _region_view->region_frames_to_region_beats (length));
4581
4582         _region_view->create_note_at (start, _drag_rect->property_y1(), length_beats, false);
4583 }
4584
4585 double
4586 NoteCreateDrag::y_to_region (double y) const
4587 {
4588         double x = 0;
4589         _region_view->get_canvas_group()->w2i (x, y);
4590         return y;
4591 }
4592
4593 void
4594 NoteCreateDrag::aborted (bool)
4595 {
4596
4597 }
4598
4599 CrossfadeEdgeDrag::CrossfadeEdgeDrag (Editor* e, AudioRegionView* rv, ArdourCanvas::Item* i, bool start_yn)
4600         : Drag (e, i)
4601         , arv (rv)
4602         , start (start_yn)
4603 {
4604 }
4605
4606 void
4607 CrossfadeEdgeDrag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
4608 {
4609         Drag::start_grab (event, cursor);
4610 }
4611
4612 void
4613 CrossfadeEdgeDrag::motion (GdkEvent*, bool)
4614 {
4615         double distance;
4616         double new_length;
4617         framecnt_t len;
4618
4619         boost::shared_ptr<AudioRegion> ar (arv->audio_region());
4620
4621         if (start) {
4622                 distance = _drags->current_pointer_x() - grab_x();
4623                 len = ar->fade_in()->back()->when;
4624         } else {
4625                 distance = grab_x() - _drags->current_pointer_x();
4626                 len = ar->fade_out()->back()->when;
4627         }
4628
4629         /* how long should it be ? */
4630
4631         new_length = len + _editor->unit_to_frame (distance);
4632
4633         /* now check with the region that this is legal */
4634
4635         new_length = ar->verify_xfade_bounds (new_length, start);
4636
4637         if (start) {
4638                 arv->redraw_start_xfade_to (ar, new_length);
4639         } else {
4640                 arv->redraw_end_xfade_to (ar, new_length);
4641         }
4642 }
4643
4644 void
4645 CrossfadeEdgeDrag::finished (GdkEvent*, bool)
4646 {
4647         double distance;
4648         double new_length;
4649         framecnt_t len;
4650
4651         boost::shared_ptr<AudioRegion> ar (arv->audio_region());
4652
4653         if (start) {
4654                 distance = _drags->current_pointer_x() - grab_x();
4655                 len = ar->fade_in()->back()->when;
4656         } else {
4657                 distance = grab_x() - _drags->current_pointer_x();
4658                 len = ar->fade_out()->back()->when;
4659         }
4660
4661         new_length = ar->verify_xfade_bounds (len + _editor->unit_to_frame (distance), start);
4662
4663         _editor->begin_reversible_command ("xfade trim");
4664         ar->playlist()->clear_owned_changes ();
4665
4666         if (start) {
4667                 ar->set_fade_in_length (new_length);
4668         } else {
4669                 ar->set_fade_out_length (new_length);
4670         }
4671
4672         /* Adjusting the xfade may affect other regions in the playlist, so we need
4673            to get undo Commands from the whole playlist rather than just the
4674            region.
4675         */
4676
4677         vector<Command*> cmds;
4678         ar->playlist()->rdiff (cmds);
4679         _editor->session()->add_commands (cmds);
4680         _editor->commit_reversible_command ();
4681
4682 }
4683
4684 void
4685 CrossfadeEdgeDrag::aborted (bool)
4686 {
4687         if (start) {
4688                 arv->redraw_start_xfade ();
4689         } else {
4690                 arv->redraw_end_xfade ();
4691         }
4692 }
4693