gtk2_ardour/editor_drag.h

   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 #ifndef __gtk2_ardour_editor_drag_h_
  21 #define __gtk2_ardour_editor_drag_h_
  22
  23 #include <list>
  24
  25 #include <gdk/gdk.h>
  26 #include <stdint.h>
  27
  28 #include "ardour/types.h"
  29
  30 #include "canvas.h"
  31 #include "editor_items.h"
  32
  33 namespace ARDOUR {
  34         class Location;
  35 }
  36
  37 namespace PBD {
  38         class StatefulDiffCommand;
  39 }
  40
  41 namespace Gnome {
  42         namespace Canvas {
  43                 class CanvasNoteEvent;
  44                 class CanvasPatchChange;
  45         }
  46 }
  47
  48 class Editor;
  49 class EditorCursor;
  50 class TimeAxisView;
  51 class MidiTimeAxisView;
  52 class Drag;
  53
  54 /** Class to manage current drags */
  55 class DragManager
  56 {
  57 public:
  58
  59         DragManager (Editor* e);
  60         ~DragManager ();
  61
  62         bool motion_handler (GdkEvent *, bool);
  63
  64         void abort ();
  65         void add (Drag *);
  66         void set (Drag *, GdkEvent *, Gdk::Cursor* c = 0);
  67         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
  68         bool end_grab (GdkEvent *);
  69         bool have_item (ArdourCanvas::Item *) const;
  70
  71         /** @return true if an end drag or abort is in progress */
  72         bool ending () const {
  73                 return _ending;
  74         }
  75
  76         bool active () const {
  77                 return !_drags.empty ();
  78         }
  79
  80         /** @return current pointer x position in trackview coordinates */
  81         double current_pointer_x () const {
  82                 return _current_pointer_x;
  83         }
  84
  85         /** @return current pointer y position in trackview coordinates */
  86         double current_pointer_y () const {
  87                 return _current_pointer_y;
  88         }
  89
  90         /** @return current pointer frame */
  91         ARDOUR::framepos_t current_pointer_frame () const {
  92                 return _current_pointer_frame;
  93         }
  94
  95 private:
  96         Editor* _editor;
  97         std::list<Drag*> _drags;
  98         bool _ending; ///< true if end_grab or abort is in progress, otherwise false
  99         double _current_pointer_x; ///< trackview x of the current pointer
 100         double _current_pointer_y; ///< trackview y of the current pointer
 101         ARDOUR::framepos_t _current_pointer_frame; ///< frame that the pointer is now at
 102         bool _old_follow_playhead; ///< state of Editor::follow_playhead() before the drags started
 103 };
 104
 105 /** Abstract base class for dragging of things within the editor */
 106 class Drag
 107 {
 108 public:
 109         Drag (Editor *, ArdourCanvas::Item *);
 110         virtual ~Drag () {}
 111
 112         void set_manager (DragManager* m) {
 113                 _drags = m;
 114         }
 115
 116         /** @return the canvas item being dragged */
 117         ArdourCanvas::Item* item () const {
 118                 return _item;
 119         }
 120
 121         void swap_grab (ArdourCanvas::Item *, Gdk::Cursor *, uint32_t);
 122         bool motion_handler (GdkEvent*, bool);
 123         void abort ();
 124
 125         ARDOUR::framepos_t adjusted_frame (ARDOUR::framepos_t, GdkEvent const *, bool snap = true) const;
 126         ARDOUR::framepos_t adjusted_current_frame (GdkEvent const *, bool snap = true) const;
 127
 128         /** Called to start a grab of an item.
 129          *  @param e Event that caused the grab to start.
 130          *  @param c Cursor to use, or 0.
 131          */
 132         virtual void start_grab (GdkEvent* e, Gdk::Cursor* c = 0);
 133
 134         virtual bool end_grab (GdkEvent *);
 135
 136         /** Called when a drag motion has occurred.
 137          *  @param e Event describing the motion.
 138          *  @param f true if this is the first movement, otherwise false.
 139          */
 140         virtual void motion (GdkEvent* e, bool f) = 0;
 141
 142         /** Called when a drag has finished.
 143          *  @param e Event describing the finish.
 144          *  @param m true if some movement occurred, otherwise false.
 145          */
 146         virtual void finished (GdkEvent* e, bool m) = 0;
 147
 148         /** Called to abort a drag and return things to how
 149          *  they were before it started.
 150          *  @param m true if some movement occurred, otherwise false.
 151          */
 152         virtual void aborted (bool m) = 0;
 153
 154         /** @param m Mouse mode.
 155          *  @return true if this drag should happen in this mouse mode.
 156          */
 157         virtual bool active (Editing::MouseMode m) {
 158                 return (m != Editing::MouseGain);
 159         }
 160
 161         /** @return minimum number of frames (in x) and pixels (in y) that should be considered a movement */
 162         virtual std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
 163                 return std::make_pair (1, 1);
 164         }
 165
 166         virtual bool allow_vertical_autoscroll () const {
 167                 return true;
 168         }
 169
 170         /** @return true if x movement matters to this drag */
 171         virtual bool x_movement_matters () const {
 172                 return true;
 173         }
 174
 175         /** @return true if y movement matters to this drag */
 176         virtual bool y_movement_matters () const {
 177                 return true;
 178         }
 179
 180         /** Set up the _pointer_frame_offset */
 181         virtual void setup_pointer_frame_offset () {
 182                 _pointer_frame_offset = 0;
 183         }
 184
 185 protected:
 186
 187         double grab_x () const {
 188                 return _grab_x;
 189         }
 190
 191         double grab_y () const {
 192                 return _grab_y;
 193         }
 194
 195         ARDOUR::framepos_t raw_grab_frame () const {
 196                 return _raw_grab_frame;
 197         }
 198
 199         ARDOUR::framepos_t grab_frame () const {
 200                 return _grab_frame;
 201         }
 202
 203         double last_pointer_x () const {
 204                 return _last_pointer_x;
 205         }
 206
 207         double last_pointer_y () const {
 208                 return _last_pointer_y;
 209         }
 210
 211         double last_pointer_frame () const {
 212                 return _last_pointer_frame;
 213         }
 214
 215         void show_verbose_cursor_time (framepos_t);
 216         void show_verbose_cursor_duration (framepos_t, framepos_t, double xoffset = 0);
 217         void show_verbose_cursor_text (std::string const &);
 218
 219         Editor* _editor; ///< our editor
 220         DragManager* _drags;
 221         ArdourCanvas::Item* _item; ///< our item
 222         /** Offset from the mouse's position for the drag to the start of the thing that is being dragged */
 223         ARDOUR::framecnt_t _pointer_frame_offset;
 224         bool _x_constrained; ///< true if x motion is constrained, otherwise false
 225         bool _y_constrained; ///< true if y motion is constrained, otherwise false
 226         bool _was_rolling; ///< true if the session was rolling before the drag started, otherwise false
 227
 228 private:
 229
 230         bool _move_threshold_passed; ///< true if the move threshold has been passed, otherwise false
 231         double _grab_x; ///< trackview x of the grab start position
 232         double _grab_y; ///< trackview y of the grab start position
 233         double _last_pointer_x; ///< trackview x of the pointer last time a motion occurred
 234         double _last_pointer_y; ///< trackview y of the pointer last time a motion occurred
 235         ARDOUR::framepos_t _raw_grab_frame; ///< unsnapped frame that the mouse was at when start_grab was called, or 0
 236         ARDOUR::framepos_t _grab_frame; ///< adjusted_frame that the mouse was at when start_grab was called, or 0
 237         ARDOUR::framepos_t _last_pointer_frame; ///< adjusted_frame the last time a motion occurred
 238 };
 239
 240 class RegionDrag;
 241
 242 /** Container for details about a region being dragged */
 243 struct DraggingView
 244 {
 245         DraggingView (RegionView *, RegionDrag *);
 246
 247         RegionView* view; ///< the view
 248         /** index into RegionDrag::_time_axis_views of the view that this region is currently being displayed on,
 249          *  or -1 if it is not visible.
 250          */
 251         int time_axis_view;
 252         /** layer that this region is currently being displayed on */
 253         ARDOUR::layer_t layer;
 254         double initial_y; ///< the initial y position of the view before any reparenting
 255         framepos_t initial_position; ///< initial position of the region
 256         framepos_t initial_end; ///< initial end position of the region
 257         boost::shared_ptr<ARDOUR::Playlist> initial_playlist;
 258 };
 259
 260 /** Abstract base class for drags that involve region(s) */
 261 class RegionDrag : public Drag, public sigc::trackable
 262 {
 263 public:
 264         RegionDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
 265         virtual ~RegionDrag () {}
 266
 267 protected:
 268
 269         RegionView* _primary; ///< the view that was clicked on (or whatever) to start the drag
 270         std::list<DraggingView> _views; ///< information about all views that are being dragged
 271
 272         /** a list of the non-hidden TimeAxisViews sorted by editor order key */
 273         std::vector<TimeAxisView*> _time_axis_views;
 274         int find_time_axis_view (TimeAxisView *) const;
 275
 276         int _visible_y_low;
 277         int _visible_y_high;
 278
 279         friend class DraggingView;
 280
 281 private:
 282
 283         void region_going_away (RegionView *);
 284         PBD::ScopedConnection death_connection;
 285 };
 286
 287
 288 /** Drags involving region motion from somewhere */
 289 class RegionMotionDrag : public RegionDrag
 290 {
 291 public:
 292
 293         RegionMotionDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &, bool);
 294         virtual ~RegionMotionDrag () {}
 295
 296         virtual void start_grab (GdkEvent *, Gdk::Cursor *);
 297         virtual void motion (GdkEvent *, bool);
 298         virtual void finished (GdkEvent *, bool) = 0;
 299         virtual void aborted (bool);
 300
 301         /** @return true if the regions being `moved' came from somewhere on the canvas;
 302          *  false if they came from outside (e.g. from the region list).
 303          */
 304         virtual bool regions_came_from_canvas () const = 0;
 305
 306 protected:
 307
 308         double compute_x_delta (GdkEvent const *, ARDOUR::framecnt_t *);
 309         bool y_movement_allowed (int, ARDOUR::layer_t) const;
 310
 311         bool _brushing;
 312         ARDOUR::framepos_t _last_frame_position; ///< last position of the thing being dragged
 313         double _total_x_delta;
 314         int _last_pointer_time_axis_view;
 315         ARDOUR::layer_t _last_pointer_layer;
 316 };
 317
 318
 319 /** Drags to move (or copy) regions that are already shown in the GUI to
 320  *  somewhere different.
 321  */
 322 class RegionMoveDrag : public RegionMotionDrag
 323 {
 324 public:
 325         RegionMoveDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &, bool, bool);
 326         virtual ~RegionMoveDrag () {}
 327
 328         void motion (GdkEvent *, bool);
 329         void finished (GdkEvent *, bool);
 330         void aborted (bool);
 331
 332         bool regions_came_from_canvas () const {
 333                 return true;
 334         }
 335
 336         std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
 337                 return std::make_pair (4, 4);
 338         }
 339
 340         void setup_pointer_frame_offset ();
 341
 342 private:
 343         typedef std::set<boost::shared_ptr<ARDOUR::Playlist> > PlaylistSet;
 344
 345         void finished_no_copy (
 346                 bool const,
 347                 bool const,
 348                 ARDOUR::framecnt_t const
 349                 );
 350
 351         void finished_copy (
 352                 bool const,
 353                 bool const,
 354                 ARDOUR::framecnt_t const
 355                 );
 356
 357         RegionView* insert_region_into_playlist (
 358                 boost::shared_ptr<ARDOUR::Region>,
 359                 RouteTimeAxisView*,
 360                 ARDOUR::layer_t,
 361                 ARDOUR::framecnt_t,
 362                 PlaylistSet&
 363                 );
 364
 365         void remove_region_from_playlist (
 366                 boost::shared_ptr<ARDOUR::Region>,
 367                 boost::shared_ptr<ARDOUR::Playlist>,
 368                 PlaylistSet& modified_playlists
 369                 );
 370
 371         void add_stateful_diff_commands_for_playlists (PlaylistSet const &);
 372
 373         void collect_new_region_view (RegionView *);
 374
 375         bool _copy;
 376         RegionView* _new_region_view;
 377 };
 378
 379 /** Drag to insert a region from somewhere */
 380 class RegionInsertDrag : public RegionMotionDrag
 381 {
 382 public:
 383         RegionInsertDrag (Editor *, boost::shared_ptr<ARDOUR::Region>, RouteTimeAxisView*, ARDOUR::framepos_t);
 384
 385         void finished (GdkEvent *, bool);
 386         void aborted (bool);
 387
 388         bool regions_came_from_canvas () const {
 389                 return false;
 390         }
 391 };
 392
 393 /** Region drag in splice mode */
 394 class RegionSpliceDrag : public RegionMoveDrag
 395 {
 396 public:
 397         RegionSpliceDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
 398
 399         void motion (GdkEvent *, bool);
 400         void finished (GdkEvent *, bool);
 401         void aborted (bool);
 402 };
 403
 404 /** Drags to create regions */
 405 class RegionCreateDrag : public Drag
 406 {
 407 public:
 408         RegionCreateDrag (Editor *, ArdourCanvas::Item *, TimeAxisView *);
 409
 410         void motion (GdkEvent *, bool);
 411         void finished (GdkEvent *, bool);
 412         void aborted (bool);
 413
 414 private:
 415         MidiTimeAxisView* _view;
 416         boost::shared_ptr<ARDOUR::Region> _region;
 417         void add_region ();
 418 };
 419
 420 /** Drags to resize MIDI notes */
 421 class NoteResizeDrag : public Drag
 422 {
 423 public:
 424         NoteResizeDrag (Editor *, ArdourCanvas::Item *);
 425
 426         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 427         void motion (GdkEvent *, bool);
 428         void finished (GdkEvent *, bool);
 429         void aborted (bool);
 430
 431 private:
 432         MidiRegionView*     region;
 433         bool                relative;
 434         bool                at_front;
 435 };
 436
 437 /** Drags to move MIDI notes */
 438 class NoteDrag : public Drag
 439 {
 440   public:
 441         NoteDrag (Editor*, ArdourCanvas::Item*);
 442
 443         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 444         void motion (GdkEvent *, bool);
 445         void finished (GdkEvent *, bool);
 446         void aborted (bool);
 447
 448   private:
 449
 450         ARDOUR::frameoffset_t total_dx () const;
 451         int8_t total_dy () const;
 452
 453         MidiRegionView* _region;
 454         Gnome::Canvas::CanvasNoteEvent* _primary;
 455         double _cumulative_dx;
 456         double _cumulative_dy;
 457         bool _was_selected;
 458         double _note_height;
 459 };
 460
 461 /** Drag to move MIDI patch changes */
 462 class PatchChangeDrag : public Drag
 463 {
 464 public:
 465         PatchChangeDrag (Editor *, ArdourCanvas::CanvasPatchChange *, MidiRegionView *);
 466
 467         void motion (GdkEvent *, bool);
 468         void finished (GdkEvent *, bool);
 469         void aborted (bool);
 470
 471         bool y_movement_matters () const {
 472                 return false;
 473         }
 474
 475         void setup_pointer_frame_offset ();
 476
 477 private:
 478         MidiRegionView* _region_view;
 479         ArdourCanvas::CanvasPatchChange* _patch_change;
 480         double _cumulative_dx;
 481 };
 482
 483 /** Drag of region gain */
 484 class RegionGainDrag : public Drag
 485 {
 486 public:
 487         RegionGainDrag (Editor *, ArdourCanvas::Item *);
 488
 489         void motion (GdkEvent *, bool);
 490         void finished (GdkEvent *, bool);
 491         bool active (Editing::MouseMode m) {
 492                 return (m == Editing::MouseGain);
 493         }
 494
 495         void aborted (bool);
 496 };
 497
 498 /** Drag to trim region(s) */
 499 class TrimDrag : public RegionDrag
 500 {
 501 public:
 502         enum Operation {
 503                 StartTrim,
 504                 EndTrim,
 505                 ContentsTrim,
 506         };
 507
 508         TrimDrag (Editor *, ArdourCanvas::Item *, RegionView*, std::list<RegionView*> const &);
 509
 510         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 511         void motion (GdkEvent *, bool);
 512         void finished (GdkEvent *, bool);
 513         void aborted (bool);
 514
 515         bool y_movement_matters () const {
 516                 return false;
 517         }
 518
 519         void setup_pointer_frame_offset ();
 520
 521 private:
 522
 523         Operation _operation;
 524 };
 525
 526 /** Meter marker drag */
 527 class MeterMarkerDrag : public Drag
 528 {
 529 public:
 530         MeterMarkerDrag (Editor *, ArdourCanvas::Item *, bool);
 531
 532         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 533         void motion (GdkEvent *, bool);
 534         void finished (GdkEvent *, bool);
 535         void aborted (bool);
 536
 537         bool allow_vertical_autoscroll () const {
 538                 return false;
 539         }
 540
 541         bool y_movement_matters () const {
 542                 return false;
 543         }
 544
 545         void setup_pointer_frame_offset ();
 546
 547 private:
 548         MeterMarker* _marker;
 549         bool _copy;
 550 };
 551
 552 /** Tempo marker drag */
 553 class TempoMarkerDrag : public Drag
 554 {
 555 public:
 556         TempoMarkerDrag (Editor *, ArdourCanvas::Item *, bool);
 557
 558         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 559         void motion (GdkEvent *, bool);
 560         void finished (GdkEvent *, bool);
 561         void aborted (bool);
 562
 563         bool allow_vertical_autoscroll () const {
 564                 return false;
 565         }
 566
 567         bool y_movement_matters () const {
 568                 return false;
 569         }
 570
 571         void setup_pointer_frame_offset ();
 572
 573 private:
 574         TempoMarker* _marker;
 575         bool _copy;
 576 };
 577
 578
 579 /** Drag of the playhead cursor */
 580 class CursorDrag : public Drag
 581 {
 582 public:
 583         CursorDrag (Editor *, ArdourCanvas::Item *, bool);
 584
 585         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 586         void motion (GdkEvent *, bool);
 587         void finished (GdkEvent *, bool);
 588         void aborted (bool);
 589
 590         bool active (Editing::MouseMode) {
 591                 return true;
 592         }
 593
 594         bool allow_vertical_autoscroll () const {
 595                 return false;
 596         }
 597
 598         bool y_movement_matters () const {
 599                 return true;
 600         }
 601
 602 private:
 603         void fake_locate (framepos_t);
 604
 605         bool _stop; ///< true to stop the transport on starting the drag, otherwise false
 606         double _grab_zoom; ///< editor frames per unit when our grab started
 607 };
 608
 609 /** Region fade-in drag */
 610 class FadeInDrag : public RegionDrag
 611 {
 612 public:
 613         FadeInDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
 614
 615         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 616         void motion (GdkEvent *, bool);
 617         void finished (GdkEvent *, bool);
 618         void aborted (bool);
 619
 620         bool y_movement_matters () const {
 621                 return false;
 622         }
 623
 624         void setup_pointer_frame_offset ();
 625 };
 626
 627 /** Region fade-out drag */
 628 class FadeOutDrag : public RegionDrag
 629 {
 630 public:
 631         FadeOutDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
 632
 633         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 634         void motion (GdkEvent *, bool);
 635         void finished (GdkEvent *, bool);
 636         void aborted (bool);
 637
 638         bool y_movement_matters () const {
 639                 return false;
 640         }
 641
 642         void setup_pointer_frame_offset ();
 643 };
 644
 645 /** Marker drag */
 646 class MarkerDrag : public Drag
 647 {
 648 public:
 649         MarkerDrag (Editor *, ArdourCanvas::Item *);
 650         ~MarkerDrag ();
 651
 652         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 653         void motion (GdkEvent *, bool);
 654         void finished (GdkEvent *, bool);
 655         void aborted (bool);
 656
 657         bool allow_vertical_autoscroll () const {
 658                 return false;
 659         }
 660
 661         bool y_movement_matters () const {
 662                 return false;
 663         }
 664
 665         void setup_pointer_frame_offset ();
 666
 667 private:
 668         void update_item (ARDOUR::Location *);
 669
 670         Marker* _marker; ///< marker being dragged
 671         std::list<ARDOUR::Location*> _copied_locations;
 672         ArdourCanvas::Points _points;
 673 };
 674
 675 /** Control point drag */
 676 class ControlPointDrag : public Drag
 677 {
 678 public:
 679         ControlPointDrag (Editor *, ArdourCanvas::Item *);
 680
 681         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 682         void motion (GdkEvent *, bool);
 683         void finished (GdkEvent *, bool);
 684         void aborted (bool);
 685
 686         bool active (Editing::MouseMode m);
 687
 688 private:
 689
 690         ControlPoint* _point;
 691         double _fixed_grab_x;
 692         double _fixed_grab_y;
 693         double _cumulative_x_drag;
 694         double _cumulative_y_drag;
 695         static double _zero_gain_fraction;
 696 };
 697
 698 /** Gain or automation line drag */
 699 class LineDrag : public Drag
 700 {
 701 public:
 702         LineDrag (Editor *e, ArdourCanvas::Item *i);
 703
 704         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 705         void motion (GdkEvent *, bool);
 706         void finished (GdkEvent *, bool);
 707         void aborted (bool);
 708
 709         bool active (Editing::MouseMode) {
 710                 return true;
 711         }
 712
 713 private:
 714
 715         AutomationLine* _line;
 716         double _fixed_grab_x;
 717         double _fixed_grab_y;
 718         uint32_t _before;
 719         uint32_t _after;
 720         double _cumulative_y_drag;
 721 };
 722
 723 /** Transient feature line drags*/
 724 class FeatureLineDrag : public Drag
 725 {
 726 public:
 727         FeatureLineDrag (Editor *e, ArdourCanvas::Item *i);
 728
 729         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 730         void motion (GdkEvent *, bool);
 731         void finished (GdkEvent *, bool);
 732         void aborted (bool);
 733
 734         bool active (Editing::MouseMode) {
 735                 return true;
 736         }
 737
 738 private:
 739
 740         ArdourCanvas::Line* _line;
 741         AudioRegionView* _arv;
 742
 743         double _region_view_grab_x;
 744         double _cumulative_x_drag;
 745
 746         float _before;
 747         uint32_t _max_x;
 748 };
 749
 750 /** Dragging of a rubberband rectangle for selecting things */
 751 class RubberbandSelectDrag : public Drag
 752 {
 753 public:
 754         RubberbandSelectDrag (Editor *, ArdourCanvas::Item *);
 755
 756         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 757         void motion (GdkEvent *, bool);
 758         void finished (GdkEvent *, bool);
 759         void aborted (bool);
 760
 761         std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
 762                 return std::make_pair (8, 1);
 763         }
 764 };
 765
 766 /** Region drag in time-FX mode */
 767 class TimeFXDrag : public RegionDrag
 768 {
 769 public:
 770         TimeFXDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
 771
 772         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 773         void motion (GdkEvent *, bool);
 774         void finished (GdkEvent *, bool);
 775         void aborted (bool);
 776 };
 777
 778 /** Scrub drag in audition mode */
 779 class ScrubDrag : public Drag
 780 {
 781 public:
 782         ScrubDrag (Editor *, ArdourCanvas::Item *);
 783
 784         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 785         void motion (GdkEvent *, bool);
 786         void finished (GdkEvent *, bool);
 787         void aborted (bool);
 788 };
 789
 790 /** Drag in range select mode */
 791 class SelectionDrag : public Drag
 792 {
 793 public:
 794         enum Operation {
 795                 CreateSelection,
 796                 SelectionStartTrim,
 797                 SelectionEndTrim,
 798                 SelectionMove
 799         };
 800
 801         SelectionDrag (Editor *, ArdourCanvas::Item *, Operation);
 802
 803         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 804         void motion (GdkEvent *, bool);
 805         void finished (GdkEvent *, bool);
 806         void aborted (bool);
 807
 808         void setup_pointer_frame_offset ();
 809
 810 private:
 811         Operation _operation;
 812         bool _copy;
 813         int _original_pointer_time_axis;
 814         int _last_pointer_time_axis;
 815         std::list<TimeAxisView*> _added_time_axes;
 816 };
 817
 818 /** Range marker drag */
 819 class RangeMarkerBarDrag : public Drag
 820 {
 821 public:
 822         enum Operation {
 823                 CreateRangeMarker,
 824                 CreateTransportMarker,
 825                 CreateCDMarker
 826         };
 827
 828         RangeMarkerBarDrag (Editor *, ArdourCanvas::Item *, Operation);
 829
 830         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 831         void motion (GdkEvent *, bool);
 832         void finished (GdkEvent *, bool);
 833         void aborted (bool);
 834
 835         bool allow_vertical_autoscroll () const {
 836                 return false;
 837         }
 838
 839         bool y_movement_matters () const {
 840                 return false;
 841         }
 842
 843 private:
 844         void update_item (ARDOUR::Location *);
 845
 846         Operation _operation;
 847         ArdourCanvas::SimpleRect* _drag_rect;
 848         bool _copy;
 849 };
 850
 851 /** Drag of rectangle to set zoom */
 852 class MouseZoomDrag : public Drag
 853 {
 854 public:
 855         MouseZoomDrag (Editor *, ArdourCanvas::Item *);
 856
 857         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 858         void motion (GdkEvent *, bool);
 859         void finished (GdkEvent *, bool);
 860         void aborted (bool);
 861
 862         std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
 863                 return std::make_pair (4, 4);
 864         }
 865
 866 private:
 867         bool _zoom_out;
 868 };
 869
 870 /** Drag of a range of automation data, changing value but not position */
 871 class AutomationRangeDrag : public Drag
 872 {
 873 public:
 874         AutomationRangeDrag (Editor *, ArdourCanvas::Item *, std::list<ARDOUR::AudioRange> const &);
 875
 876         void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
 877         void motion (GdkEvent *, bool);
 878         void finished (GdkEvent *, bool);
 879         void aborted (bool);
 880
 881         bool x_movement_matters () const {
 882                 return false;
 883         }
 884
 885 private:
 886         std::list<ARDOUR::AudioRange> _ranges;
 887         AutomationTimeAxisView* _atav;
 888
 889         /** A line that is part of the drag */
 890         struct Line {
 891                 boost::shared_ptr<AutomationLine> line; ///< the line
 892                 std::list<ControlPoint*> points; ///< points to drag on the line
 893                 std::pair<ARDOUR::framepos_t, ARDOUR::framepos_t> range; ///< the range of all points on the line, in session frames
 894                 XMLNode* state; ///< the XML state node before the drag
 895         };
 896
 897         std::list<Line> _lines;
 898
 899         bool _nothing_to_drag;
 900 };
 901
 902 #endif /* __gtk2_ardour_editor_drag_h_ */
 903