editor_drag.h

Go to the documentation of this file.

/*
    Copyright (C) 2009 Paul Davis

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef __gtk2_ardour_editor_drag_h_
#define __gtk2_ardour_editor_drag_h_

#include <list>

#include <gdk/gdk.h>
#include <stdint.h>

#include "ardour/types.h"

#include "cursor_context.h"
#include "editor_items.h"
#include "mouse_cursors.h"

namespace ARDOUR {
        class Location;
}

namespace PBD {
        class StatefulDiffCommand;
}

class PatchChange;
class Editor;
class EditorCursor;
class TimeAxisView;
class MidiTimeAxisView;
class Drag;
class NoteBase;

class DragManager
{
public:

        DragManager (Editor* e);
        ~DragManager ();

        bool motion_handler (GdkEvent *, bool);

        void abort ();
        void add (Drag *);
        void set (Drag *, GdkEvent *, Gdk::Cursor* c = MouseCursors::invalid_cursor());
        void start_grab (GdkEvent *, Gdk::Cursor* c = MouseCursors::invalid_cursor());
        bool end_grab (GdkEvent *);
        bool have_item (ArdourCanvas::Item *) const;

        void mark_double_click ();

        bool ending () const {
                return _ending;
        }

        bool active () const {
                return !_drags.empty ();
        }

        double current_pointer_x () const {
                return _current_pointer_x;
        }

        double current_pointer_y () const {
                return _current_pointer_y;
        }

        ARDOUR::framepos_t current_pointer_frame () const {
                return _current_pointer_frame;
        }

private:
        Editor* _editor;
        std::list<Drag*> _drags;
        bool _ending; 
        double _current_pointer_x; 
        double _current_pointer_y; 
        ARDOUR::framepos_t _current_pointer_frame; 
        bool _old_follow_playhead; 
};

class Drag
{
public:
        Drag (Editor *, ArdourCanvas::Item *, bool trackview_only = true);
        virtual ~Drag () {}

        void set_manager (DragManager* m) {
                _drags = m;
        }

        ArdourCanvas::Item* item () const {
                return _item;
        }

        void swap_grab (ArdourCanvas::Item *, Gdk::Cursor *, uint32_t);
        bool motion_handler (GdkEvent*, bool);
        void abort ();

        ARDOUR::framepos_t adjusted_frame (ARDOUR::framepos_t, GdkEvent const *, bool snap = true) const;
        ARDOUR::framepos_t adjusted_current_frame (GdkEvent const *, bool snap = true) const;

        bool was_double_click() const { return _was_double_click; }
        void set_double_click (bool yn) { _was_double_click = yn; }

        virtual void start_grab (GdkEvent* e, Gdk::Cursor* c = 0);

        virtual bool end_grab (GdkEvent *);

        virtual void motion (GdkEvent* e, bool f) = 0;

        virtual void finished (GdkEvent* e, bool m) = 0;

        virtual void aborted (bool m) = 0;

        virtual bool active (Editing::MouseMode m) {
                return true;
        }

        virtual std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
                return std::make_pair (1, 1);
        }

        virtual bool allow_vertical_autoscroll () const {
                return true;
        }

        virtual bool x_movement_matters () const {
                return true;
        }

        virtual bool y_movement_matters () const {
                return true;
        }

        bool initially_vertical() const {
                return _initially_vertical;
        }
        
        virtual void setup_pointer_frame_offset () {
                _pointer_frame_offset = 0;
        }

protected:

        double grab_x () const {
                return _grab_x;
        }

        double grab_y () const {
                return _grab_y;
        }

        ARDOUR::framepos_t raw_grab_frame () const {
                return _raw_grab_frame;
        }

        ARDOUR::framepos_t grab_frame () const {
                return _grab_frame;
        }

        double last_pointer_x () const {
                return _last_pointer_x;
        }

        double last_pointer_y () const {
                return _last_pointer_y;
        }

        double last_pointer_frame () const {
                return _last_pointer_frame;
        }

        double current_pointer_x () const;
        double current_pointer_y () const;

        boost::shared_ptr<ARDOUR::Region> add_midi_region (MidiTimeAxisView*);

        void show_verbose_cursor_time (framepos_t);
        void show_verbose_cursor_duration (framepos_t, framepos_t, double xoffset = 0);
        void show_verbose_cursor_text (std::string const &);

        Editor* _editor; 
        DragManager* _drags;
        ArdourCanvas::Item* _item; 

        ARDOUR::framecnt_t _pointer_frame_offset;
        bool _x_constrained; 
        bool _y_constrained; 
        bool _was_rolling; 

private:
        bool _trackview_only; 
        bool _move_threshold_passed; 
        bool _starting_point_passed; 
        bool _initially_vertical; 
        bool _was_double_click; 
        double _grab_x; 
        double _grab_y; 
        double _last_pointer_x; 
        double _last_pointer_y; 
        ARDOUR::framepos_t _raw_grab_frame; 
        ARDOUR::framepos_t _grab_frame; 
        ARDOUR::framepos_t _last_pointer_frame; 
        CursorContext::Handle _cursor_ctx; 
};

class RegionDrag;

class DraggingView
{
public:
        DraggingView (RegionView *, RegionDrag *, TimeAxisView* original_tav);

        RegionView* view; 

        int time_axis_view;
        double layer;
        double initial_y; 
        framepos_t initial_position; 
        framepos_t initial_end; 
        framepos_t anchored_fade_length; 
        boost::shared_ptr<ARDOUR::Playlist> initial_playlist;
        TimeAxisView* initial_time_axis_view;
};

class RegionDrag : public Drag, public sigc::trackable
{
public:
        RegionDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
        virtual ~RegionDrag () {}

protected:

        RegionView* _primary; 
        std::list<DraggingView> _views; 

        std::vector<TimeAxisView*> _time_axis_views;
        int find_time_axis_view (TimeAxisView *) const;
        int apply_track_delta (const int start, const int delta, const int skip, const bool distance_only = false) const;

        int _visible_y_low;
        int _visible_y_high;
        uint32_t _ntracks;

        friend class DraggingView;

private:

        void region_going_away (RegionView *);
        PBD::ScopedConnection death_connection;
};


class RegionMotionDrag : public RegionDrag
{
public:

        RegionMotionDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &, bool);
        virtual ~RegionMotionDrag () {}

        virtual void start_grab (GdkEvent *, Gdk::Cursor *);
        virtual void motion (GdkEvent *, bool);
        virtual void finished (GdkEvent *, bool);
        virtual void aborted (bool);

        virtual bool regions_came_from_canvas () const = 0;

protected:

        double compute_x_delta (GdkEvent const *, ARDOUR::framepos_t *);
        virtual bool y_movement_allowed (int, double, int skip_invisible = 0) const;

        bool _brushing;
        ARDOUR::framepos_t _last_frame_position; 
        double _total_x_delta;
        int _last_pointer_time_axis_view;
        double _last_pointer_layer;
        bool _single_axis;

private:
        uint32_t _ndropzone;
        uint32_t _pdropzone;
        uint32_t _ddropzone;
};


class RegionMoveDrag : public RegionMotionDrag
{
public:
        RegionMoveDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &, bool, bool);
        virtual ~RegionMoveDrag () {}

        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool regions_came_from_canvas () const {
                return true;
        }

        std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
                return std::make_pair (4, 4);
        }

        void setup_pointer_frame_offset ();

protected:
        typedef std::set<boost::shared_ptr<ARDOUR::Playlist> > PlaylistSet;
        void add_stateful_diff_commands_for_playlists (PlaylistSet const &);

private:
        void finished_no_copy (
                bool const,
                bool const,
                ARDOUR::framecnt_t const
                );

        void finished_copy (
                bool const,
                bool const,
                ARDOUR::framecnt_t const
                );

        RegionView* insert_region_into_playlist (
                boost::shared_ptr<ARDOUR::Region>,
                RouteTimeAxisView*,
                ARDOUR::layer_t,
                ARDOUR::framecnt_t,
                PlaylistSet&
                );

        void remove_region_from_playlist (
                boost::shared_ptr<ARDOUR::Region>,
                boost::shared_ptr<ARDOUR::Playlist>,
                PlaylistSet& modified_playlists
                );


        void collect_new_region_view (RegionView *);
        RouteTimeAxisView* create_destination_time_axis (boost::shared_ptr<ARDOUR::Region>, TimeAxisView* original);

        bool _copy;
        RegionView* _new_region_view;
};

class RegionInsertDrag : public RegionMotionDrag
{
public:
        RegionInsertDrag (Editor *, boost::shared_ptr<ARDOUR::Region>, RouteTimeAxisView*, ARDOUR::framepos_t);

        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool regions_came_from_canvas () const {
                return false;
        }
};

class RegionSpliceDrag : public RegionMoveDrag
{
public:
        RegionSpliceDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);

        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);
};

class RegionRippleDrag : public RegionMoveDrag
{
public:
        RegionRippleDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
        ~RegionRippleDrag () { delete exclude; }

        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);
protected:
        bool y_movement_allowed (int delta_track, double delta_layer, int skip_invisible = 0) const;

private:
        TimeAxisView *prev_tav;         // where regions were most recently dragged from
        TimeAxisView *orig_tav;         // where drag started
        framecnt_t prev_amount;
        framepos_t prev_position;
        framecnt_t selection_length;
        bool allow_moves_across_tracks; // only if all selected regions are on one track
        ARDOUR::RegionList *exclude;
        void add_all_after_to_views (TimeAxisView *tav, framepos_t where, const RegionSelection &exclude, bool drag_in_progress);
        void remove_unselected_from_views (framecnt_t amount, bool move_regions);

};

class RegionCutDrag : public Drag
{
    public:
        RegionCutDrag (Editor*, ArdourCanvas::Item*, framepos_t);
        ~RegionCutDrag ();

        void motion (GdkEvent*, bool);
        void finished (GdkEvent*, bool);
        void aborted (bool);

    private:
        EditorCursor* line;
};

class RegionCreateDrag : public Drag
{
public:
        RegionCreateDrag (Editor *, ArdourCanvas::Item *, TimeAxisView *);

        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

private:
        MidiTimeAxisView* _view;
        boost::shared_ptr<ARDOUR::Region> _region;
};

class NoteResizeDrag : public Drag
{
public:
        NoteResizeDrag (Editor *, ArdourCanvas::Item *);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

private:
        MidiRegionView*     region;
        bool                relative;
        bool                at_front;
};

class NoteDrag : public Drag
{
  public:
        NoteDrag (Editor*, ArdourCanvas::Item*);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

  private:

        ARDOUR::frameoffset_t total_dx () const;
        int8_t total_dy () const;

        MidiRegionView* _region;
        NoteBase* _primary;
        double _cumulative_dx;
        double _cumulative_dy;
        bool _was_selected;
        double _note_height;
};

class NoteCreateDrag : public Drag
{
public:
        NoteCreateDrag (Editor *, ArdourCanvas::Item *, MidiRegionView *);
        ~NoteCreateDrag ();

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool active (Editing::MouseMode mode) {
                return mode == Editing::MouseDraw;
        }

        bool y_movement_matters () const {
                return false;
        }

private:
        double y_to_region (double) const;
        framecnt_t grid_frames (framepos_t) const;
        
        MidiRegionView* _region_view;
        ArdourCanvas::Rectangle* _drag_rect;
        framepos_t _note[2];
};

class PatchChangeDrag : public Drag
{
public:
        PatchChangeDrag (Editor *, PatchChange *, MidiRegionView *);

        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool y_movement_matters () const {
                return false;
        }

        void setup_pointer_frame_offset ();

private:
        MidiRegionView* _region_view;
        PatchChange* _patch_change;
        double _cumulative_dx;
};

class AVDraggingView
{
public:
        AVDraggingView (RegionView *);

        RegionView* view; 
        framepos_t initial_position; 
};

class VideoTimeLineDrag : public Drag
{
public:
        VideoTimeLineDrag (Editor *e, ArdourCanvas::Item *i);

        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);

        bool y_movement_matters () const {
                return false;
        }

        bool allow_vertical_autoscroll () const {
                return false;
        }

        void aborted (bool);

protected:
        std::list<AVDraggingView> _views; 

private:
        ARDOUR::frameoffset_t _startdrag_video_offset;
        ARDOUR::frameoffset_t _max_backwards_drag;
};

class TrimDrag : public RegionDrag
{
public:
        enum Operation {
                StartTrim,
                EndTrim,
                ContentsTrim,
        };

        TrimDrag (Editor *, ArdourCanvas::Item *, RegionView*, std::list<RegionView*> const &, bool preserve_fade_anchor = false);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool y_movement_matters () const {
                return false;
        }

        void setup_pointer_frame_offset ();

private:

        Operation _operation;
        
        bool _preserve_fade_anchor;
        bool _jump_position_when_done;
};

class MeterMarkerDrag : public Drag
{
public:
        MeterMarkerDrag (Editor *, ArdourCanvas::Item *, bool);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool allow_vertical_autoscroll () const {
                return false;
        }

        bool y_movement_matters () const {
                return false;
        }

        void setup_pointer_frame_offset ();

private:
        MeterMarker* _marker;
        bool _copy;
        XMLNode* before_state;
};

class TempoMarkerDrag : public Drag
{
public:
        TempoMarkerDrag (Editor *, ArdourCanvas::Item *, bool);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool allow_vertical_autoscroll () const {
                return false;
        }

        bool y_movement_matters () const {
                return false;
        }

        void setup_pointer_frame_offset ();

private:
        TempoMarker* _marker;
        bool _copy;
        XMLNode* before_state;
};


class CursorDrag : public Drag
{
public:
        CursorDrag (Editor *, EditorCursor&, bool);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool allow_vertical_autoscroll () const {
                return false;
        }

        bool y_movement_matters () const {
                return true;
        }

private:
        void fake_locate (framepos_t);

        EditorCursor& _cursor;
        bool _stop; 
        double _grab_zoom; 
};

class FadeInDrag : public RegionDrag
{
public:
        FadeInDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool y_movement_matters () const {
                return false;
        }

        void setup_pointer_frame_offset ();
};

class FadeOutDrag : public RegionDrag
{
public:
        FadeOutDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool y_movement_matters () const {
                return false;
        }

        void setup_pointer_frame_offset ();
};

class MarkerDrag : public Drag
{
public:
        MarkerDrag (Editor *, ArdourCanvas::Item *);
        ~MarkerDrag ();

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool allow_vertical_autoscroll () const {
                return false;
        }

        bool y_movement_matters () const {
                return false;
        }

        void setup_pointer_frame_offset ();

private:
        void update_item (ARDOUR::Location *);

        Marker* _marker; 

        struct CopiedLocationMarkerInfo {
            ARDOUR::Location* location;
            std::vector<Marker*> markers;
            bool    move_both;
            CopiedLocationMarkerInfo (ARDOUR::Location* l, Marker* m);
        };

        typedef std::list<CopiedLocationMarkerInfo> CopiedLocationInfo;
        CopiedLocationInfo _copied_locations;
        ArdourCanvas::Points _points;
};

class ControlPointDrag : public Drag
{
public:
        ControlPointDrag (Editor *, ArdourCanvas::Item *);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool active (Editing::MouseMode m);

private:

        ControlPoint* _point;
        double _fixed_grab_x;
        double _fixed_grab_y;
        double _cumulative_x_drag;
        double _cumulative_y_drag;
        bool     _pushing;
        uint32_t _final_index;
        static double _zero_gain_fraction;
};

class LineDrag : public Drag
{
public:
        LineDrag (Editor *e, ArdourCanvas::Item *i);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

private:

        AutomationLine* _line;
        double _fixed_grab_x;
        double _fixed_grab_y;
        double _cumulative_y_drag;
};

class FeatureLineDrag : public Drag
{
public:
        FeatureLineDrag (Editor *e, ArdourCanvas::Item *i);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

private:

        ArdourCanvas::Line* _line;
        AudioRegionView* _arv;

        double _region_view_grab_x;
        double _cumulative_x_drag;

        float _before;
        uint32_t _max_x;
};

class RubberbandSelectDrag : public Drag
{
public:
        RubberbandSelectDrag (Editor *, ArdourCanvas::Item *);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
                return std::make_pair (8, 1);
        }

        void do_select_things (GdkEvent *, bool);

        virtual void select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool drag_in_progress) = 0;
        
        virtual void deselect_things () = 0;

  protected:
        bool _vertical_only;
};

class EditorRubberbandSelectDrag : public RubberbandSelectDrag
{
public:
        EditorRubberbandSelectDrag (Editor *, ArdourCanvas::Item *);

        void select_things (int, framepos_t, framepos_t, double, double, bool);
        void deselect_things ();
};

class MidiRubberbandSelectDrag : public RubberbandSelectDrag
{
public:
        MidiRubberbandSelectDrag (Editor *, MidiRegionView *);

        void select_things (int, framepos_t, framepos_t, double, double, bool);
        void deselect_things ();

private:
        MidiRegionView* _region_view;
};

class MidiVerticalSelectDrag : public RubberbandSelectDrag
{
public:
        MidiVerticalSelectDrag (Editor *, MidiRegionView *);

        void select_things (int, framepos_t, framepos_t, double, double, bool);
        void deselect_things ();

private:
        MidiRegionView* _region_view;
};

class TimeFXDrag : public RegionDrag
{
public:
        TimeFXDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);
};

class ScrubDrag : public Drag
{
public:
        ScrubDrag (Editor *, ArdourCanvas::Item *);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);
};

class SelectionDrag : public Drag
{
public:
        enum Operation {
                CreateSelection,
                SelectionStartTrim,
                SelectionEndTrim,
                SelectionMove,
                SelectionExtend
        };

        SelectionDrag (Editor *, ArdourCanvas::Item *, Operation);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        void setup_pointer_frame_offset ();

private:
        Operation _operation;
        bool _add;
        std::list<TimeAxisView*> _added_time_axes;
        bool _time_selection_at_start;
        framepos_t start_at_start;
        framepos_t end_at_start;
};

class RangeMarkerBarDrag : public Drag
{
public:
        enum Operation {
                CreateSkipMarker,
                CreateRangeMarker,
                CreateTransportMarker,
                CreateCDMarker
        };

        RangeMarkerBarDrag (Editor *, ArdourCanvas::Item *, Operation);
        ~RangeMarkerBarDrag ();
        
        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool allow_vertical_autoscroll () const {
                return false;
        }

        bool y_movement_matters () const {
                return false;
        }

private:
        void update_item (ARDOUR::Location *);

        Operation _operation;
        ArdourCanvas::Rectangle* _drag_rect;
        bool _copy;
};

class MouseZoomDrag : public Drag
{
public:
        MouseZoomDrag (Editor *, ArdourCanvas::Item *);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
                return std::make_pair (4, 4);
        }

private:
        bool _zoom_out;
};

class AutomationRangeDrag : public Drag
{
public:
        AutomationRangeDrag (Editor *, AutomationTimeAxisView *, std::list<ARDOUR::AudioRange> const &);
        AutomationRangeDrag (Editor *, RegionView *, std::list<ARDOUR::AudioRange> const &);

        void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
        void motion (GdkEvent *, bool);
        void finished (GdkEvent *, bool);
        void aborted (bool);

        bool x_movement_matters () const {
                return false;
        }

private:
        void setup (std::list<boost::shared_ptr<AutomationLine> > const &);
        double y_fraction (boost::shared_ptr<AutomationLine>, double global_y_position) const;
        double value (boost::shared_ptr<ARDOUR::AutomationList> list, double x) const;

        std::list<ARDOUR::AudioRange> _ranges;

        struct Line {
                boost::shared_ptr<AutomationLine> line; 
                std::list<ControlPoint*> points; 
                std::pair<ARDOUR::framepos_t, ARDOUR::framepos_t> range; 
                XMLNode* state; 
                double original_fraction; 
        };

        std::list<Line> _lines;
        double          _y_origin;
        bool            _nothing_to_drag;
        bool            _integral;
};

class CrossfadeEdgeDrag : public Drag
{
  public:
        CrossfadeEdgeDrag (Editor*, AudioRegionView*, ArdourCanvas::Item*, bool start);

        void start_grab (GdkEvent*, Gdk::Cursor* c = 0);
        void motion (GdkEvent*, bool);
        void finished (GdkEvent*, bool);
        void aborted (bool);
        
        bool y_movement_matters () const {
                return false;
        }

        virtual std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
                return std::make_pair (4, 4);
        }

  private:
        AudioRegionView* arv;
        bool start;
};

#endif /* __gtk2_ardour_editor_drag_h_ */