gtk2_ardour/editor_drag.cc

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