2009-05-30 14:25:59 -04:00
|
|
|
/*
|
2009-10-14 12:10:01 -04:00
|
|
|
Copyright (C) 2009 Paul Davis
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
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"
|
|
|
|
|
2015-01-17 12:01:08 -05:00
|
|
|
#include "canvas/types.h"
|
|
|
|
|
2014-12-20 01:11:28 -05:00
|
|
|
#include "cursor_context.h"
|
2009-05-30 14:25:59 -04:00
|
|
|
#include "editor_items.h"
|
2015-01-24 12:26:58 -05:00
|
|
|
#include "mouse_cursors.h"
|
2015-01-17 12:01:08 -05:00
|
|
|
#include "editing.h"
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
namespace ARDOUR {
|
|
|
|
class Location;
|
|
|
|
}
|
|
|
|
|
2015-01-17 12:01:08 -05:00
|
|
|
namespace ArdourCanvas {
|
|
|
|
class Item;
|
|
|
|
class Line;
|
|
|
|
class Rectangle;
|
|
|
|
}
|
|
|
|
|
2010-08-23 21:02:40 -04:00
|
|
|
namespace PBD {
|
|
|
|
class StatefulDiffCommand;
|
|
|
|
}
|
|
|
|
|
2013-04-04 00:32:52 -04:00
|
|
|
class PatchChange;
|
2009-05-30 14:25:59 -04:00
|
|
|
class Editor;
|
|
|
|
class EditorCursor;
|
|
|
|
class TimeAxisView;
|
2010-08-20 08:01:13 -04:00
|
|
|
class MidiTimeAxisView;
|
2010-01-12 11:14:49 -05:00
|
|
|
class Drag;
|
2013-04-04 00:32:52 -04:00
|
|
|
class NoteBase;
|
2015-01-17 12:01:08 -05:00
|
|
|
class RegionView;
|
|
|
|
class TimeAxisView;
|
|
|
|
class RouteTimeAxisView;
|
|
|
|
class RegionSelection;
|
|
|
|
class MidiRegionView;
|
|
|
|
class MeterMarker;
|
2015-07-23 07:23:47 -04:00
|
|
|
class ArdourMarker;
|
2015-01-17 12:01:08 -05:00
|
|
|
class TempoMarker;
|
|
|
|
class ControlPoint;
|
|
|
|
class AudioRegionView;
|
|
|
|
class AutomationLine;
|
|
|
|
class AutomationTimeAxisView;
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-01-12 11:14:49 -05:00
|
|
|
/** Class to manage current drags */
|
|
|
|
class DragManager
|
2009-05-30 14:25:59 -04:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
2010-01-12 11:14:49 -05:00
|
|
|
DragManager (Editor* e);
|
|
|
|
~DragManager ();
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-01-12 11:14:49 -05:00
|
|
|
bool motion_handler (GdkEvent *, bool);
|
|
|
|
|
|
|
|
void abort ();
|
|
|
|
void add (Drag *);
|
2015-01-24 12:26:58 -05:00
|
|
|
void set (Drag *, GdkEvent *, Gdk::Cursor* c = MouseCursors::invalid_cursor());
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = MouseCursors::invalid_cursor());
|
2010-01-12 11:14:49 -05:00
|
|
|
bool end_grab (GdkEvent *);
|
|
|
|
bool have_item (ArdourCanvas::Item *) const;
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2013-06-21 15:18:54 -04:00
|
|
|
void mark_double_click ();
|
|
|
|
|
2010-05-05 18:09:07 -04:00
|
|
|
/** @return true if an end drag or abort is in progress */
|
2009-05-30 14:25:59 -04:00
|
|
|
bool ending () const {
|
|
|
|
return _ending;
|
|
|
|
}
|
|
|
|
|
2010-01-12 11:14:49 -05:00
|
|
|
bool active () const {
|
|
|
|
return !_drags.empty ();
|
|
|
|
}
|
|
|
|
|
2013-07-10 19:10:06 -04:00
|
|
|
/** @return current pointer x position in canvas coordinates */
|
2009-05-30 14:25:59 -04:00
|
|
|
double current_pointer_x () const {
|
|
|
|
return _current_pointer_x;
|
|
|
|
}
|
|
|
|
|
2013-07-10 19:10:06 -04:00
|
|
|
/** @return current pointer y position in canvas coordinates */
|
2009-05-30 14:25:59 -04:00
|
|
|
double current_pointer_y () const {
|
|
|
|
return _current_pointer_y;
|
|
|
|
}
|
|
|
|
|
2010-01-12 11:14:49 -05:00
|
|
|
/** @return current pointer frame */
|
2010-09-08 21:38:21 -04:00
|
|
|
ARDOUR::framepos_t current_pointer_frame () const {
|
2010-01-12 11:14:49 -05:00
|
|
|
return _current_pointer_frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Editor* _editor;
|
|
|
|
std::list<Drag*> _drags;
|
2010-05-05 18:09:07 -04:00
|
|
|
bool _ending; ///< true if end_grab or abort is in progress, otherwise false
|
2013-07-10 19:10:06 -04:00
|
|
|
double _current_pointer_x; ///< canvas-coordinate space x of the current pointer
|
|
|
|
double _current_pointer_y; ///< canvas-coordinate space y of the current pointer
|
2010-09-08 21:38:21 -04:00
|
|
|
ARDOUR::framepos_t _current_pointer_frame; ///< frame that the pointer is now at
|
2011-01-04 21:28:28 -05:00
|
|
|
bool _old_follow_playhead; ///< state of Editor::follow_playhead() before the drags started
|
2010-01-12 11:14:49 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Abstract base class for dragging of things within the editor */
|
|
|
|
class Drag
|
|
|
|
{
|
|
|
|
public:
|
2014-06-08 11:26:25 -04:00
|
|
|
Drag (Editor *, ArdourCanvas::Item *, bool trackview_only = true);
|
2010-01-12 11:14:49 -05:00
|
|
|
virtual ~Drag () {}
|
|
|
|
|
|
|
|
void set_manager (DragManager* m) {
|
|
|
|
_drags = m;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @return the canvas item being dragged */
|
|
|
|
ArdourCanvas::Item* item () const {
|
|
|
|
return _item;
|
|
|
|
}
|
|
|
|
|
|
|
|
void swap_grab (ArdourCanvas::Item *, Gdk::Cursor *, uint32_t);
|
|
|
|
bool motion_handler (GdkEvent*, bool);
|
2010-05-05 18:09:07 -04:00
|
|
|
void abort ();
|
2010-01-12 11:14:49 -05:00
|
|
|
|
2010-09-08 21:38:21 -04:00
|
|
|
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;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2013-06-21 15:18:54 -04:00
|
|
|
bool was_double_click() const { return _was_double_click; }
|
|
|
|
void set_double_click (bool yn) { _was_double_click = yn; }
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
/** Called to start a grab of an item.
|
|
|
|
* @param e Event that caused the grab to start.
|
|
|
|
* @param c Cursor to use, or 0.
|
|
|
|
*/
|
|
|
|
virtual void start_grab (GdkEvent* e, Gdk::Cursor* c = 0);
|
|
|
|
|
|
|
|
virtual bool end_grab (GdkEvent *);
|
|
|
|
|
|
|
|
/** Called when a drag motion has occurred.
|
|
|
|
* @param e Event describing the motion.
|
2009-06-01 20:39:57 -04:00
|
|
|
* @param f true if this is the first movement, otherwise false.
|
2009-05-30 14:25:59 -04:00
|
|
|
*/
|
2009-06-01 20:39:57 -04:00
|
|
|
virtual void motion (GdkEvent* e, bool f) = 0;
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
/** Called when a drag has finished.
|
|
|
|
* @param e Event describing the finish.
|
2009-06-01 20:39:57 -04:00
|
|
|
* @param m true if some movement occurred, otherwise false.
|
2009-05-30 14:25:59 -04:00
|
|
|
*/
|
2009-06-01 20:39:57 -04:00
|
|
|
virtual void finished (GdkEvent* e, bool m) = 0;
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-01-07 20:28:15 -05:00
|
|
|
/** Called to abort a drag and return things to how
|
|
|
|
* they were before it started.
|
2010-12-28 14:17:37 -05:00
|
|
|
* @param m true if some movement occurred, otherwise false.
|
2010-01-07 20:28:15 -05:00
|
|
|
*/
|
2010-12-28 14:17:37 -05:00
|
|
|
virtual void aborted (bool m) = 0;
|
2010-01-07 20:28:15 -05:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
/** @param m Mouse mode.
|
|
|
|
* @return true if this drag should happen in this mouse mode.
|
|
|
|
*/
|
|
|
|
virtual bool active (Editing::MouseMode m) {
|
2014-12-07 19:53:46 -05:00
|
|
|
return true;
|
2009-05-30 14:25:59 -04:00
|
|
|
}
|
|
|
|
|
2010-01-04 20:10:53 -05:00
|
|
|
/** @return minimum number of frames (in x) and pixels (in y) that should be considered a movement */
|
2010-09-08 21:38:21 -04:00
|
|
|
virtual std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
|
2010-01-04 20:10:53 -05:00
|
|
|
return std::make_pair (1, 1);
|
2009-06-01 20:39:57 -04:00
|
|
|
}
|
|
|
|
|
2009-06-14 09:32:17 -04:00
|
|
|
virtual bool allow_vertical_autoscroll () const {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-01-04 20:10:53 -05:00
|
|
|
/** @return true if x movement matters to this drag */
|
|
|
|
virtual bool x_movement_matters () const {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @return true if y movement matters to this drag */
|
|
|
|
virtual bool y_movement_matters () const {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-02-12 14:28:44 -05:00
|
|
|
bool initially_vertical() const {
|
|
|
|
return _initially_vertical;
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2010-12-19 22:42:59 -05:00
|
|
|
/** Set up the _pointer_frame_offset */
|
|
|
|
virtual void setup_pointer_frame_offset () {
|
|
|
|
_pointer_frame_offset = 0;
|
|
|
|
}
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
protected:
|
2009-12-21 20:12:41 -05:00
|
|
|
|
|
|
|
double grab_x () const {
|
|
|
|
return _grab_x;
|
|
|
|
}
|
|
|
|
|
|
|
|
double grab_y () const {
|
|
|
|
return _grab_y;
|
|
|
|
}
|
|
|
|
|
2010-09-08 21:38:12 -04:00
|
|
|
ARDOUR::framepos_t raw_grab_frame () const {
|
|
|
|
return _raw_grab_frame;
|
|
|
|
}
|
|
|
|
|
2010-08-20 08:01:13 -04:00
|
|
|
ARDOUR::framepos_t grab_frame () const {
|
2009-12-21 20:12:41 -05:00
|
|
|
return _grab_frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
double last_pointer_x () const {
|
|
|
|
return _last_pointer_x;
|
|
|
|
}
|
|
|
|
|
|
|
|
double last_pointer_y () const {
|
|
|
|
return _last_pointer_y;
|
|
|
|
}
|
|
|
|
|
2015-05-15 14:15:52 -04:00
|
|
|
ARDOUR::framepos_t last_pointer_frame () const {
|
2009-12-21 20:12:41 -05:00
|
|
|
return _last_pointer_frame;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2015-05-21 13:09:29 -04:00
|
|
|
ARDOUR::frameoffset_t snap_delta (guint const) const;
|
2015-05-16 10:23:25 -04:00
|
|
|
|
2014-11-24 14:58:56 -05:00
|
|
|
double current_pointer_x () const;
|
2014-06-08 11:26:25 -04:00
|
|
|
double current_pointer_y () const;
|
|
|
|
|
2015-05-16 10:23:25 -04:00
|
|
|
/* sets snap delta from unsnapped pos */
|
|
|
|
void setup_snap_delta (framepos_t pos);
|
|
|
|
|
2012-01-25 14:39:20 -05:00
|
|
|
boost::shared_ptr<ARDOUR::Region> add_midi_region (MidiTimeAxisView*);
|
|
|
|
|
2011-05-02 09:38:16 -04:00
|
|
|
void show_verbose_cursor_time (framepos_t);
|
2011-05-04 10:56:24 -04:00
|
|
|
void show_verbose_cursor_duration (framepos_t, framepos_t, double xoffset = 0);
|
2011-05-02 09:38:16 -04:00
|
|
|
void show_verbose_cursor_text (std::string const &);
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
Editor* _editor; ///< our editor
|
2010-01-12 11:14:49 -05:00
|
|
|
DragManager* _drags;
|
2009-05-30 14:25:59 -04:00
|
|
|
ArdourCanvas::Item* _item; ///< our item
|
2009-12-21 20:12:41 -05:00
|
|
|
/** Offset from the mouse's position for the drag to the start of the thing that is being dragged */
|
2010-09-08 21:38:21 -04:00
|
|
|
ARDOUR::framecnt_t _pointer_frame_offset;
|
2009-05-30 14:25:59 -04:00
|
|
|
bool _x_constrained; ///< true if x motion is constrained, otherwise false
|
|
|
|
bool _y_constrained; ///< true if y motion is constrained, otherwise false
|
|
|
|
bool _was_rolling; ///< true if the session was rolling before the drag started, otherwise false
|
|
|
|
|
|
|
|
private:
|
2014-06-08 11:26:25 -04:00
|
|
|
bool _trackview_only; ///< true if pointer y value should always be relative to the top of the trackview group
|
2009-06-01 20:39:57 -04:00
|
|
|
bool _move_threshold_passed; ///< true if the move threshold has been passed, otherwise false
|
2015-01-23 13:45:21 -05:00
|
|
|
bool _starting_point_passed; ///< true if we called move () with first_move flag, otherwise false
|
2015-02-12 13:37:18 -05:00
|
|
|
bool _initially_vertical; ///< true if after move threshold is passed we appear to be moving vertically; undefined before that
|
2015-02-13 16:42:05 -05:00
|
|
|
bool _was_double_click; ///< true if drag initiated by a double click event
|
2009-12-21 20:12:41 -05:00
|
|
|
double _grab_x; ///< trackview x of the grab start position
|
2014-06-08 11:26:25 -04:00
|
|
|
double _grab_y; ///< y of the grab start position, possibly adjusted if _trackview_only is true
|
2009-12-21 20:12:41 -05:00
|
|
|
double _last_pointer_x; ///< trackview x of the pointer last time a motion occurred
|
|
|
|
double _last_pointer_y; ///< trackview y of the pointer last time a motion occurred
|
2010-09-08 21:38:12 -04:00
|
|
|
ARDOUR::framepos_t _raw_grab_frame; ///< unsnapped frame that the mouse was at when start_grab was called, or 0
|
2010-09-08 21:38:21 -04:00
|
|
|
ARDOUR::framepos_t _grab_frame; ///< adjusted_frame that the mouse was at when start_grab was called, or 0
|
|
|
|
ARDOUR::framepos_t _last_pointer_frame; ///< adjusted_frame the last time a motion occurred
|
2015-05-16 10:23:25 -04:00
|
|
|
|
|
|
|
/* difference between some key position's snapped and unsnapped
|
|
|
|
* framepos. used for relative snap.
|
|
|
|
*/
|
2015-05-16 14:26:05 -04:00
|
|
|
ARDOUR::frameoffset_t _snap_delta;
|
2014-12-20 01:11:28 -05:00
|
|
|
CursorContext::Handle _cursor_ctx; ///< cursor change context
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
2010-09-06 08:34:11 -04:00
|
|
|
class RegionDrag;
|
|
|
|
|
|
|
|
/** Container for details about a region being dragged */
|
2012-05-23 22:54:10 -04:00
|
|
|
class DraggingView
|
2010-04-06 20:17:54 -04:00
|
|
|
{
|
2012-05-23 22:54:10 -04:00
|
|
|
public:
|
2014-06-19 11:16:27 -04:00
|
|
|
DraggingView (RegionView *, RegionDrag *, TimeAxisView* original_tav);
|
2010-04-06 20:17:54 -04:00
|
|
|
|
|
|
|
RegionView* view; ///< the view
|
2011-10-22 14:11:40 -04:00
|
|
|
/** index into RegionDrag::_time_axis_views of the view that this region is currently being displayed on,
|
|
|
|
* or -1 if it is not visible.
|
|
|
|
*/
|
2010-09-06 08:34:11 -04:00
|
|
|
int time_axis_view;
|
2011-12-29 17:14:15 -05:00
|
|
|
/** layer that this region is currently being displayed on. This is a double
|
2011-12-26 20:42:49 -05:00
|
|
|
rather than a layer_t as we use fractional layers during drags to allow the user
|
|
|
|
to indicate a new layer to put a region on.
|
|
|
|
*/
|
|
|
|
double layer;
|
2010-04-06 20:17:54 -04:00
|
|
|
double initial_y; ///< the initial y position of the view before any reparenting
|
2010-11-08 20:58:42 -05:00
|
|
|
framepos_t initial_position; ///< initial position of the region
|
|
|
|
framepos_t initial_end; ///< initial end position of the region
|
2014-05-31 18:40:07 -04:00
|
|
|
framepos_t anchored_fade_length; ///< fade_length when anchored during drag
|
2010-08-23 21:02:40 -04:00
|
|
|
boost::shared_ptr<ARDOUR::Playlist> initial_playlist;
|
2014-06-19 11:16:27 -04:00
|
|
|
TimeAxisView* initial_time_axis_view;
|
2010-04-06 20:17:54 -04:00
|
|
|
};
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
/** Abstract base class for drags that involve region(s) */
|
|
|
|
class RegionDrag : public Drag, public sigc::trackable
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
RegionDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
|
|
|
|
virtual ~RegionDrag () {}
|
|
|
|
|
|
|
|
protected:
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
RegionView* _primary; ///< the view that was clicked on (or whatever) to start the drag
|
2010-04-06 20:17:54 -04:00
|
|
|
std::list<DraggingView> _views; ///< information about all views that are being dragged
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-09-06 08:34:11 -04:00
|
|
|
/** a list of the non-hidden TimeAxisViews sorted by editor order key */
|
|
|
|
std::vector<TimeAxisView*> _time_axis_views;
|
|
|
|
int find_time_axis_view (TimeAxisView *) const;
|
2015-03-25 12:14:48 -04:00
|
|
|
int apply_track_delta (const int start, const int delta, const int skip, const bool distance_only = false) const;
|
2010-09-06 08:34:11 -04:00
|
|
|
|
|
|
|
int _visible_y_low;
|
|
|
|
int _visible_y_high;
|
2015-03-26 16:55:04 -04:00
|
|
|
uint32_t _ntracks;
|
2010-09-06 08:34:11 -04:00
|
|
|
|
|
|
|
friend class DraggingView;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
void region_going_away (RegionView *);
|
2009-12-21 13:23:07 -05:00
|
|
|
PBD::ScopedConnection death_connection;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
/** Drags involving region motion from somewhere */
|
|
|
|
class RegionMotionDrag : public RegionDrag
|
|
|
|
{
|
|
|
|
public:
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
RegionMotionDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &, bool);
|
|
|
|
virtual ~RegionMotionDrag () {}
|
|
|
|
|
|
|
|
virtual void start_grab (GdkEvent *, Gdk::Cursor *);
|
|
|
|
virtual void motion (GdkEvent *, bool);
|
2011-12-26 20:42:49 -05:00
|
|
|
virtual void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
virtual void aborted (bool);
|
2009-06-08 15:28:51 -04:00
|
|
|
|
2010-08-19 19:56:30 -04:00
|
|
|
/** @return true if the regions being `moved' came from somewhere on the canvas;
|
|
|
|
* false if they came from outside (e.g. from the region list).
|
|
|
|
*/
|
|
|
|
virtual bool regions_came_from_canvas () const = 0;
|
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
protected:
|
|
|
|
|
2012-04-14 18:04:51 -04:00
|
|
|
double compute_x_delta (GdkEvent const *, ARDOUR::framepos_t *);
|
2015-03-24 16:59:57 -04:00
|
|
|
virtual bool y_movement_allowed (int, double, int skip_invisible = 0) const;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
bool _brushing;
|
2015-09-07 20:51:58 -04:00
|
|
|
bool _ignore_video_lock;
|
2010-09-08 21:38:21 -04:00
|
|
|
ARDOUR::framepos_t _last_frame_position; ///< last position of the thing being dragged
|
2010-01-07 20:28:15 -05:00
|
|
|
double _total_x_delta;
|
2010-09-06 08:34:11 -04:00
|
|
|
int _last_pointer_time_axis_view;
|
2011-12-26 20:42:49 -05:00
|
|
|
double _last_pointer_layer;
|
2015-03-26 16:55:04 -04:00
|
|
|
private:
|
|
|
|
uint32_t _ndropzone;
|
|
|
|
uint32_t _pdropzone;
|
|
|
|
uint32_t _ddropzone;
|
2009-06-08 15:28:51 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/** Drags to move (or copy) regions that are already shown in the GUI to
|
|
|
|
* somewhere different.
|
|
|
|
*/
|
|
|
|
class RegionMoveDrag : public RegionMotionDrag
|
2009-05-30 14:25:59 -04:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
RegionMoveDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &, bool, bool);
|
|
|
|
virtual ~RegionMoveDrag () {}
|
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-08-19 19:56:30 -04:00
|
|
|
bool regions_came_from_canvas () const {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-09-08 21:38:21 -04:00
|
|
|
std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
|
2010-01-04 20:10:53 -05:00
|
|
|
return std::make_pair (4, 4);
|
2009-06-01 20:39:57 -04:00
|
|
|
}
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-12-19 22:42:59 -05:00
|
|
|
void setup_pointer_frame_offset ();
|
|
|
|
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
protected:
|
2010-08-23 21:02:40 -04:00
|
|
|
typedef std::set<boost::shared_ptr<ARDOUR::Playlist> > PlaylistSet;
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
void add_stateful_diff_commands_for_playlists (PlaylistSet const &);
|
2010-08-23 21:02:40 -04:00
|
|
|
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
private:
|
2010-08-23 21:02:40 -04:00
|
|
|
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 *);
|
2014-06-19 11:16:27 -04:00
|
|
|
RouteTimeAxisView* create_destination_time_axis (boost::shared_ptr<ARDOUR::Region>, TimeAxisView* original);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
bool _copy;
|
2010-08-23 21:02:40 -04:00
|
|
|
RegionView* _new_region_view;
|
2009-06-08 15:28:51 -04:00
|
|
|
};
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
/** Drag to insert a region from somewhere */
|
|
|
|
class RegionInsertDrag : public RegionMotionDrag
|
|
|
|
{
|
|
|
|
public:
|
2010-09-08 21:38:21 -04:00
|
|
|
RegionInsertDrag (Editor *, boost::shared_ptr<ARDOUR::Region>, RouteTimeAxisView*, ARDOUR::framepos_t);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2010-08-19 19:56:30 -04:00
|
|
|
|
|
|
|
bool regions_came_from_canvas () const {
|
|
|
|
return false;
|
|
|
|
}
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Region drag in splice mode */
|
|
|
|
class RegionSpliceDrag : public RegionMoveDrag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
RegionSpliceDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
|
|
|
|
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
/** Region drag in ripple mode */
|
|
|
|
|
|
|
|
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:
|
2015-03-24 16:59:57 -04:00
|
|
|
bool y_movement_allowed (int delta_track, double delta_layer, int skip_invisible = 0) const;
|
2014-05-01 08:23:43 -04:00
|
|
|
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
private:
|
|
|
|
TimeAxisView *prev_tav; // where regions were most recently dragged from
|
|
|
|
TimeAxisView *orig_tav; // where drag started
|
2015-01-17 12:01:08 -05:00
|
|
|
ARDOUR::framecnt_t prev_amount;
|
|
|
|
ARDOUR::framepos_t prev_position;
|
|
|
|
ARDOUR::framecnt_t selection_length;
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
bool allow_moves_across_tracks; // only if all selected regions are on one track
|
|
|
|
ARDOUR::RegionList *exclude;
|
2015-01-17 12:01:08 -05:00
|
|
|
void add_all_after_to_views (TimeAxisView *tav, ARDOUR::framepos_t where, const RegionSelection &exclude, bool drag_in_progress);
|
|
|
|
void remove_unselected_from_views (ARDOUR::framecnt_t amount, bool move_regions);
|
Ripple mode: basic implementation
Add a value for Ripple to EditMode enum.
Add Ripple edit mode to edit mode dropdown, by adding it to the
Editor::build_edit_mode_menu() helper function, and remove the old code that
added items to the (now unused) Editor::edit_mode_strings.
Add the regions that should be affected by the drag to RegionDrag::_views so
that the drag carries them along automatically.
Use a copy of the RegionList in Playlist::core_ripple(), since bad things
happen when iterating over regions and they get moved around in the list.
Handle rippling in removal of regions from playlist.
When dragging in ripple mode, exclude all regions that lie before the
original start position of the selected regions being dragged from
rippling: this is what Mixbus does.
Make editor dragging respect snap-to settings, by using the existing
compute_x_delta() function, which did almost the right thing. Move setting
of _last_frame_position out of that function so all ripple-dragged regions
can move.
Ripple when dragging from region list: even though Mixbus doesn't do this, it
seems like a good idea.
Prevent multi-track selection being dragged across tracks, by making
RegionMotionDrag::y_movement_allowed() virtual, and overriding it in
RegionRippleDrag to forbid dragging of selections containing regions on more
than one track to dofferent tracks in ripple mode.
Remember which TimeAxisView a ripple-mode drag that's allowed cross-track
drags started from, so that the effect of rippling regions after any region
that's dragged off that track can be undone.
2013-10-23 16:50:01 -04:00
|
|
|
|
|
|
|
};
|
|
|
|
|
2014-07-07 07:05:27 -04:00
|
|
|
/** "Drag" to cut a region (action only on button release) */
|
|
|
|
class RegionCutDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2014-07-07 10:13:19 -04:00
|
|
|
RegionCutDrag (Editor*, ArdourCanvas::Item*, framepos_t);
|
2014-07-07 08:26:37 -04:00
|
|
|
~RegionCutDrag ();
|
|
|
|
|
2014-07-07 07:05:27 -04:00
|
|
|
void motion (GdkEvent*, bool);
|
|
|
|
void finished (GdkEvent*, bool);
|
|
|
|
void aborted (bool);
|
2014-07-07 08:26:37 -04:00
|
|
|
|
|
|
|
private:
|
|
|
|
EditorCursor* line;
|
2014-07-07 07:05:27 -04:00
|
|
|
};
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
/** Drags to create regions */
|
|
|
|
class RegionCreateDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2009-07-09 13:58:13 -04:00
|
|
|
RegionCreateDrag (Editor *, ArdourCanvas::Item *, TimeAxisView *);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
private:
|
2010-08-20 08:01:13 -04:00
|
|
|
MidiTimeAxisView* _view;
|
|
|
|
boost::shared_ptr<ARDOUR::Region> _region;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
2009-09-08 17:45:44 -04:00
|
|
|
/** Drags to resize MIDI notes */
|
|
|
|
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);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-09-08 17:45:44 -04:00
|
|
|
|
|
|
|
private:
|
|
|
|
MidiRegionView* region;
|
|
|
|
bool relative;
|
|
|
|
bool at_front;
|
2015-05-15 14:15:52 -04:00
|
|
|
double _snap_delta;
|
2009-09-08 17:45:44 -04:00
|
|
|
};
|
|
|
|
|
2010-08-19 18:01:10 -04:00
|
|
|
/** Drags to move MIDI notes */
|
2009-09-08 17:45:44 -04:00
|
|
|
class NoteDrag : public Drag
|
|
|
|
{
|
2009-10-14 12:10:01 -04:00
|
|
|
public:
|
2009-09-08 17:45:44 -04:00
|
|
|
NoteDrag (Editor*, ArdourCanvas::Item*);
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-09-08 17:45:44 -04:00
|
|
|
|
|
|
|
private:
|
2010-08-19 18:01:10 -04:00
|
|
|
|
2015-05-22 13:09:48 -04:00
|
|
|
ARDOUR::frameoffset_t total_dx (const guint) const;
|
2010-08-19 18:01:10 -04:00
|
|
|
int8_t total_dy () const;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-08-19 18:01:10 -04:00
|
|
|
MidiRegionView* _region;
|
2013-04-04 00:32:52 -04:00
|
|
|
NoteBase* _primary;
|
2010-08-19 18:01:10 -04:00
|
|
|
double _cumulative_dx;
|
|
|
|
double _cumulative_dy;
|
|
|
|
bool _was_selected;
|
|
|
|
double _note_height;
|
2009-09-08 17:45:44 -04:00
|
|
|
};
|
|
|
|
|
2011-12-11 07:54:54 -05:00
|
|
|
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);
|
|
|
|
|
2014-12-07 19:53:46 -05:00
|
|
|
bool active (Editing::MouseMode mode) {
|
2015-05-23 14:04:37 -04:00
|
|
|
return mode == Editing::MouseDraw || mode == Editing::MouseContent;
|
2014-12-07 19:53:46 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-12-11 07:54:54 -05:00
|
|
|
private:
|
|
|
|
double y_to_region (double) const;
|
2015-01-17 12:01:08 -05:00
|
|
|
ARDOUR::framecnt_t grid_frames (framepos_t) const;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-12-11 07:54:54 -05:00
|
|
|
MidiRegionView* _region_view;
|
2013-04-04 00:32:52 -04:00
|
|
|
ArdourCanvas::Rectangle* _drag_rect;
|
2011-12-11 07:54:54 -05:00
|
|
|
framepos_t _note[2];
|
|
|
|
};
|
|
|
|
|
2010-12-28 13:19:40 -05:00
|
|
|
/** Drag to move MIDI patch changes */
|
|
|
|
class PatchChangeDrag : public Drag
|
2010-12-19 22:42:59 -05:00
|
|
|
{
|
|
|
|
public:
|
2013-04-04 00:32:52 -04:00
|
|
|
PatchChangeDrag (Editor *, PatchChange *, MidiRegionView *);
|
2010-12-19 22:42:59 -05:00
|
|
|
|
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2010-12-19 22:42:59 -05:00
|
|
|
|
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void setup_pointer_frame_offset ();
|
|
|
|
|
|
|
|
private:
|
|
|
|
MidiRegionView* _region_view;
|
2013-04-04 00:32:52 -04:00
|
|
|
PatchChange* _patch_change;
|
2010-12-19 22:42:59 -05:00
|
|
|
double _cumulative_dx;
|
|
|
|
};
|
|
|
|
|
2013-03-12 17:00:09 -04:00
|
|
|
/** Container for details about audio regions being dragged along with video */
|
|
|
|
class AVDraggingView
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
AVDraggingView (RegionView *);
|
|
|
|
|
|
|
|
RegionView* view; ///< the view
|
|
|
|
framepos_t initial_position; ///< initial position of the region
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Drag of video offset */
|
|
|
|
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; ///< information about all audio that are being dragged along
|
|
|
|
|
|
|
|
private:
|
|
|
|
ARDOUR::frameoffset_t _startdrag_video_offset;
|
|
|
|
ARDOUR::frameoffset_t _max_backwards_drag;
|
2015-08-19 20:24:27 -04:00
|
|
|
bool _stuck;
|
2013-03-12 17:00:09 -04:00
|
|
|
};
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
/** Drag to trim region(s) */
|
|
|
|
class TrimDrag : public RegionDrag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum Operation {
|
|
|
|
StartTrim,
|
|
|
|
EndTrim,
|
|
|
|
ContentsTrim,
|
|
|
|
};
|
|
|
|
|
2012-12-13 11:42:05 -05:00
|
|
|
TrimDrag (Editor *, ArdourCanvas::Item *, RegionView*, std::list<RegionView*> const &, bool preserve_fade_anchor = false);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-01-04 20:10:53 -05:00
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-12-21 20:06:18 -05:00
|
|
|
void setup_pointer_frame_offset ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
|
|
|
|
Operation _operation;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-13 11:42:05 -05:00
|
|
|
bool _preserve_fade_anchor;
|
2015-05-20 11:30:57 -04:00
|
|
|
bool _jump_position_when_done;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Meter marker drag */
|
|
|
|
class MeterMarkerDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
MeterMarkerDrag (Editor *, ArdourCanvas::Item *, bool);
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-01-01 12:39:28 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
2010-01-04 20:10:53 -05:00
|
|
|
|
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
2010-12-19 22:42:59 -05:00
|
|
|
|
|
|
|
void setup_pointer_frame_offset ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
MeterMarker* _marker;
|
2009-06-08 15:28:51 -04:00
|
|
|
bool _copy;
|
2012-01-04 15:40:06 -05:00
|
|
|
XMLNode* before_state;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Tempo marker drag */
|
|
|
|
class TempoMarkerDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
TempoMarkerDrag (Editor *, ArdourCanvas::Item *, bool);
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-01-01 12:39:28 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-01-04 20:10:53 -05:00
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-12-19 22:42:59 -05:00
|
|
|
void setup_pointer_frame_offset ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
TempoMarker* _marker;
|
2009-06-08 15:28:51 -04:00
|
|
|
bool _copy;
|
2012-01-04 15:40:06 -05:00
|
|
|
XMLNode* before_state;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-12-22 18:16:39 -05:00
|
|
|
/** Drag of the playhead cursor */
|
2009-05-30 14:25:59 -04:00
|
|
|
class CursorDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2013-04-17 15:22:09 -04:00
|
|
|
CursorDrag (Editor *, EditorCursor&, bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2009-06-14 09:32:17 -04:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-01-04 20:10:53 -05:00
|
|
|
bool y_movement_matters () const {
|
2011-05-25 12:38:49 -04:00
|
|
|
return true;
|
2010-01-04 20:10:53 -05:00
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
2010-12-22 18:43:04 -05:00
|
|
|
void fake_locate (framepos_t);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2013-04-17 15:22:09 -04:00
|
|
|
EditorCursor& _cursor;
|
2009-05-30 14:25:59 -04:00
|
|
|
bool _stop; ///< true to stop the transport on starting the drag, otherwise false
|
2011-05-25 12:38:49 -04:00
|
|
|
double _grab_zoom; ///< editor frames per unit when our grab started
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Region fade-in drag */
|
|
|
|
class FadeInDrag : public RegionDrag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
FadeInDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2010-01-04 20:10:53 -05:00
|
|
|
|
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
2010-12-19 22:42:59 -05:00
|
|
|
|
|
|
|
void setup_pointer_frame_offset ();
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Region fade-out drag */
|
|
|
|
class FadeOutDrag : public RegionDrag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
FadeOutDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2010-01-04 20:10:53 -05:00
|
|
|
|
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
2010-12-19 22:42:59 -05:00
|
|
|
|
|
|
|
void setup_pointer_frame_offset ();
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Marker drag */
|
|
|
|
class MarkerDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2013-06-21 15:18:54 -04:00
|
|
|
MarkerDrag (Editor *, ArdourCanvas::Item *);
|
2009-05-30 14:25:59 -04:00
|
|
|
~MarkerDrag ();
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-01-01 12:39:28 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
2010-01-04 20:10:53 -05:00
|
|
|
|
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
2010-12-19 22:42:59 -05:00
|
|
|
|
|
|
|
void setup_pointer_frame_offset ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
void update_item (ARDOUR::Location *);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2015-07-23 07:23:47 -04:00
|
|
|
ArdourMarker* _marker; ///< marker being dragged
|
2013-01-02 18:54:06 -05:00
|
|
|
|
|
|
|
struct CopiedLocationMarkerInfo {
|
|
|
|
ARDOUR::Location* location;
|
2015-07-23 07:23:47 -04:00
|
|
|
std::vector<ArdourMarker*> markers;
|
2013-01-02 18:54:06 -05:00
|
|
|
bool move_both;
|
2015-07-23 07:23:47 -04:00
|
|
|
CopiedLocationMarkerInfo (ARDOUR::Location* l, ArdourMarker* m);
|
2013-01-02 18:54:06 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef std::list<CopiedLocationMarkerInfo> CopiedLocationInfo;
|
|
|
|
CopiedLocationInfo _copied_locations;
|
2009-05-30 14:25:59 -04:00
|
|
|
ArdourCanvas::Points _points;
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Control point drag */
|
|
|
|
class ControlPointDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
ControlPointDrag (Editor *, ArdourCanvas::Item *);
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2009-06-26 08:20:11 -04:00
|
|
|
bool active (Editing::MouseMode m);
|
2009-06-09 21:23:53 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
ControlPoint* _point;
|
2010-08-20 18:43:10 -04:00
|
|
|
double _fixed_grab_x;
|
|
|
|
double _fixed_grab_y;
|
2009-05-30 14:25:59 -04:00
|
|
|
double _cumulative_x_drag;
|
|
|
|
double _cumulative_y_drag;
|
2012-12-19 10:55:06 -05:00
|
|
|
bool _pushing;
|
|
|
|
uint32_t _final_index;
|
2011-06-19 19:02:55 -04:00
|
|
|
static double _zero_gain_fraction;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Gain or automation line drag */
|
|
|
|
class LineDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
LineDrag (Editor *e, ArdourCanvas::Item *i);
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
|
|
|
|
AutomationLine* _line;
|
2010-08-20 18:43:10 -04:00
|
|
|
double _fixed_grab_x;
|
|
|
|
double _fixed_grab_y;
|
2009-05-30 14:25:59 -04:00
|
|
|
double _cumulative_y_drag;
|
2015-06-17 16:27:37 -04:00
|
|
|
uint32_t _before;
|
|
|
|
uint32_t _after;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
2010-07-06 07:33:27 -04:00
|
|
|
/** Transient feature line drags*/
|
|
|
|
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);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2010-07-06 07:33:27 -04:00
|
|
|
|
|
|
|
private:
|
|
|
|
|
2011-02-14 16:49:43 -05:00
|
|
|
ArdourCanvas::Line* _line;
|
2010-07-06 07:33:27 -04:00
|
|
|
AudioRegionView* _arv;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-07-06 07:33:27 -04:00
|
|
|
double _region_view_grab_x;
|
|
|
|
double _cumulative_x_drag;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2011-02-14 16:49:43 -05:00
|
|
|
float _before;
|
2010-07-06 07:33:27 -04:00
|
|
|
uint32_t _max_x;
|
|
|
|
};
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
/** Dragging of a rubberband rectangle for selecting things */
|
|
|
|
class RubberbandSelectDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2010-09-09 17:34:45 -04:00
|
|
|
RubberbandSelectDrag (Editor *, ArdourCanvas::Item *);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2010-01-11 21:12:15 -05:00
|
|
|
|
2010-09-08 21:38:21 -04:00
|
|
|
std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
|
2010-01-11 21:12:15 -05:00
|
|
|
return std::make_pair (8, 1);
|
|
|
|
}
|
2011-11-16 15:11:33 -05:00
|
|
|
|
|
|
|
void do_select_things (GdkEvent *, bool);
|
|
|
|
|
|
|
|
/** Select some things within a rectangle.
|
|
|
|
* @param button_state The button state from the GdkEvent.
|
|
|
|
* @param x1 The left-hand side of the rectangle in session frames.
|
|
|
|
* @param x2 The right-hand side of the rectangle in session frames.
|
|
|
|
* @param y1 The top of the rectangle in trackview coordinates.
|
|
|
|
* @param y2 The bottom of the rectangle in trackview coordinates.
|
|
|
|
* @param drag_in_progress true if the drag is currently happening.
|
|
|
|
*/
|
|
|
|
virtual void select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool drag_in_progress) = 0;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-11-16 15:11:33 -05:00
|
|
|
virtual void deselect_things () = 0;
|
2012-01-19 21:54:23 -05:00
|
|
|
|
|
|
|
protected:
|
|
|
|
bool _vertical_only;
|
2011-11-16 15:11:33 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
/** A general editor RubberbandSelectDrag (for regions, automation points etc.) */
|
|
|
|
class EditorRubberbandSelectDrag : public RubberbandSelectDrag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
EditorRubberbandSelectDrag (Editor *, ArdourCanvas::Item *);
|
|
|
|
|
|
|
|
void select_things (int, framepos_t, framepos_t, double, double, bool);
|
|
|
|
void deselect_things ();
|
|
|
|
};
|
|
|
|
|
|
|
|
/** A RubberbandSelectDrag for selecting MIDI notes */
|
|
|
|
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;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
2012-01-19 21:54:23 -05:00
|
|
|
/** A RubberbandSelectDrag for selecting MIDI notes but with no horizonal component */
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
/** Region drag in time-FX mode */
|
|
|
|
class TimeFXDrag : public RegionDrag
|
|
|
|
{
|
|
|
|
public:
|
2010-09-09 17:34:45 -04:00
|
|
|
TimeFXDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
2009-06-10 09:58:22 -04:00
|
|
|
/** Scrub drag in audition mode */
|
|
|
|
class ScrubDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2010-09-09 17:34:45 -04:00
|
|
|
ScrubDrag (Editor *, ArdourCanvas::Item *);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-06-10 09:58:22 -04:00
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-06-10 09:58:22 -04:00
|
|
|
};
|
|
|
|
|
2010-01-01 17:11:15 -05:00
|
|
|
/** Drag in range select mode */
|
2009-05-30 14:25:59 -04:00
|
|
|
class SelectionDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum Operation {
|
|
|
|
CreateSelection,
|
|
|
|
SelectionStartTrim,
|
|
|
|
SelectionEndTrim,
|
2012-12-13 14:39:36 -05:00
|
|
|
SelectionMove,
|
|
|
|
SelectionExtend
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
SelectionDrag (Editor *, ArdourCanvas::Item *, Operation);
|
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-12-19 22:42:59 -05:00
|
|
|
void setup_pointer_frame_offset ();
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
Operation _operation;
|
2012-12-13 14:39:36 -05:00
|
|
|
bool _add;
|
2010-01-01 17:11:15 -05:00
|
|
|
std::list<TimeAxisView*> _added_time_axes;
|
2012-01-30 17:53:22 -05:00
|
|
|
bool _time_selection_at_start;
|
2012-12-13 14:39:36 -05:00
|
|
|
framepos_t start_at_start;
|
|
|
|
framepos_t end_at_start;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Range marker drag */
|
|
|
|
class RangeMarkerBarDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum Operation {
|
2014-09-17 09:39:29 -04:00
|
|
|
CreateSkipMarker,
|
2009-05-30 14:25:59 -04:00
|
|
|
CreateRangeMarker,
|
|
|
|
CreateTransportMarker,
|
|
|
|
CreateCDMarker
|
|
|
|
};
|
|
|
|
|
|
|
|
RangeMarkerBarDrag (Editor *, ArdourCanvas::Item *, Operation);
|
2015-02-05 18:20:53 -05:00
|
|
|
~RangeMarkerBarDrag ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2010-01-05 10:51:13 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-01-04 20:10:53 -05:00
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
void update_item (ARDOUR::Location *);
|
|
|
|
|
|
|
|
Operation _operation;
|
2013-04-04 00:32:52 -04:00
|
|
|
ArdourCanvas::Rectangle* _drag_rect;
|
2009-06-08 15:28:51 -04:00
|
|
|
bool _copy;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
2010-01-01 17:11:15 -05:00
|
|
|
/** Drag of rectangle to set zoom */
|
2009-05-30 14:25:59 -04:00
|
|
|
class MouseZoomDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2010-09-09 17:34:45 -04:00
|
|
|
MouseZoomDrag (Editor *, ArdourCanvas::Item *);
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
2009-06-01 20:39:57 -04:00
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2010-09-21 10:22:13 -04:00
|
|
|
|
2010-11-06 22:35:00 -04:00
|
|
|
std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
|
|
|
|
return std::make_pair (4, 4);
|
|
|
|
}
|
|
|
|
|
2010-09-21 10:22:13 -04:00
|
|
|
private:
|
|
|
|
bool _zoom_out;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
2012-03-22 12:41:23 -04:00
|
|
|
/** Drag of a range of automation data (either on an automation track or region gain),
|
|
|
|
* changing value but not position.
|
|
|
|
*/
|
2010-01-01 17:11:15 -05:00
|
|
|
class AutomationRangeDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2012-03-22 12:41:23 -04:00
|
|
|
AutomationRangeDrag (Editor *, AutomationTimeAxisView *, std::list<ARDOUR::AudioRange> const &);
|
2015-01-13 23:30:37 -05:00
|
|
|
AutomationRangeDrag (Editor *, RegionView *, std::list<ARDOUR::AudioRange> const &);
|
2010-01-01 17:11:15 -05:00
|
|
|
|
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
|
|
|
void motion (GdkEvent *, bool);
|
|
|
|
void finished (GdkEvent *, bool);
|
2010-12-28 14:17:37 -05:00
|
|
|
void aborted (bool);
|
2010-01-01 17:11:15 -05:00
|
|
|
|
2010-01-04 20:10:53 -05:00
|
|
|
bool x_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-01-01 17:11:15 -05:00
|
|
|
private:
|
2012-03-22 12:41:23 -04:00
|
|
|
void setup (std::list<boost::shared_ptr<AutomationLine> > const &);
|
2015-01-13 23:30:37 -05:00
|
|
|
double y_fraction (boost::shared_ptr<AutomationLine>, double global_y_position) const;
|
|
|
|
double value (boost::shared_ptr<ARDOUR::AutomationList> list, double x) const;
|
2012-07-10 11:58:09 -04:00
|
|
|
|
2010-01-01 17:11:15 -05:00
|
|
|
std::list<ARDOUR::AudioRange> _ranges;
|
2010-09-09 17:35:28 -04:00
|
|
|
|
|
|
|
/** A line that is part of the drag */
|
|
|
|
struct Line {
|
|
|
|
boost::shared_ptr<AutomationLine> line; ///< the line
|
|
|
|
std::list<ControlPoint*> points; ///< points to drag on the line
|
|
|
|
std::pair<ARDOUR::framepos_t, ARDOUR::framepos_t> range; ///< the range of all points on the line, in session frames
|
|
|
|
XMLNode* state; ///< the XML state node before the drag
|
2012-07-10 11:44:56 -04:00
|
|
|
double original_fraction; ///< initial y-fraction before the drag
|
2010-09-09 17:35:28 -04:00
|
|
|
};
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-09-09 17:35:28 -04:00
|
|
|
std::list<Line> _lines;
|
2015-01-13 23:30:37 -05:00
|
|
|
double _y_origin;
|
|
|
|
bool _nothing_to_drag;
|
|
|
|
bool _integral;
|
2010-01-01 17:11:15 -05:00
|
|
|
};
|
|
|
|
|
2012-05-09 19:04:18 -04:00
|
|
|
/** Drag of one edge of an xfade
|
|
|
|
*/
|
|
|
|
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);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-05-09 20:46:22 -04:00
|
|
|
bool y_movement_matters () const {
|
2012-05-09 19:04:18 -04:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-05-09 20:46:22 -04:00
|
|
|
virtual std::pair<ARDOUR::framecnt_t, int> move_threshold () const {
|
2012-05-10 15:14:11 -04:00
|
|
|
return std::make_pair (4, 4);
|
2012-05-09 20:46:22 -04:00
|
|
|
}
|
|
|
|
|
2012-05-09 19:04:18 -04:00
|
|
|
private:
|
|
|
|
AudioRegionView* arv;
|
|
|
|
bool start;
|
|
|
|
};
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
#endif /* __gtk2_ardour_editor_drag_h_ */
|
|
|
|
|