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