gtk2_ardour/editor_drag.cc

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