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