2009-05-30 14:25:59 -04:00
|
|
|
/*
|
2019-08-02 17:26:43 -04:00
|
|
|
* Copyright (C) 2009-2012 Carl Hetherington <carl@carlh.net>
|
|
|
|
* Copyright (C) 2009-2015 David Robillard <d@drobilla.net>
|
|
|
|
* Copyright (C) 2009-2017 Paul Davis <paul@linuxaudiosystems.com>
|
|
|
|
* Copyright (C) 2013-2014 Colin Fletcher <colin.m.fletcher@googlemail.com>
|
|
|
|
* Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
|
|
|
|
* Copyright (C) 2015-2017 Nick Mainsbridge <mainsbridge@gmail.com>
|
|
|
|
* Copyright (C) 2015-2018 Ben Loftis <ben@harrisonconsoles.com>
|
|
|
|
* Copyright (C) 2016 Tim Mayberry <mojofunk@gmail.com>
|
|
|
|
*
|
|
|
|
* 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.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
#ifndef __gtk2_ardour_editor_drag_h_
|
|
|
|
#define __gtk2_ardour_editor_drag_h_
|
|
|
|
|
|
|
|
#include <list>
|
|
|
|
|
|
|
|
#include <gdk/gdk.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
|
2015-12-22 13:58:49 -05:00
|
|
|
#include "ardour/tempo.h"
|
2009-05-30 14:25:59 -04:00
|
|
|
#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"
|
2017-01-25 15:46:24 -05:00
|
|
|
#include "track_selection.h"
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
namespace ARDOUR {
|
|
|
|
class Location;
|
2020-04-14 15:41:57 -04:00
|
|
|
class Region;
|
2016-05-11 15:32:38 -04:00
|
|
|
class TempoSection;
|
2009-05-30 14:25:59 -04:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2017-07-01 12:42:24 -04:00
|
|
|
void mark_double_click ();
|
2013-06-21 15:18:54 -04:00
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
/** @return current pointer sample */
|
|
|
|
ARDOUR::samplepos_t current_pointer_sample () const {
|
2020-10-15 01:09:22 -04:00
|
|
|
return _current_pointer_time.samples();
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @return current pointer time */
|
|
|
|
Temporal::timepos_t current_pointer_time () const {
|
|
|
|
return _current_pointer_time;
|
2010-01-12 11:14:49 -05:00
|
|
|
}
|
|
|
|
|
2019-11-08 23:03:38 -05:00
|
|
|
/** return drag-motion displays video-frame of drag-location */
|
|
|
|
bool preview_video () const;
|
|
|
|
|
2010-01-12 11:14:49 -05:00
|
|
|
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
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t _current_pointer_time; ///< time 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:
|
2021-12-04 20:44:57 -05:00
|
|
|
Drag (Editor *, ArdourCanvas::Item *, Temporal::TimeDomain td, 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;
|
|
|
|
}
|
|
|
|
|
2021-12-04 20:44:57 -05:00
|
|
|
Temporal::TimeDomain time_domain() const { return _time_domain; }
|
|
|
|
|
|
|
|
|
2010-01-12 11:14:49 -05:00
|
|
|
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
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t adjusted_time (Temporal::timepos_t const &, GdkEvent const *, bool snap = true) const;
|
|
|
|
Temporal::timepos_t adjusted_current_time (GdkEvent const *, bool snap = true) const;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2017-07-01 12:42:24 -04:00
|
|
|
bool was_double_click() const { return _was_double_click; }
|
|
|
|
void set_double_click (bool yn) { _was_double_click = yn; }
|
2013-06-21 15:18:54 -04:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2019-11-08 23:03:38 -05:00
|
|
|
bool preview_video () const {
|
|
|
|
return _preview_video;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
/** @return minimum number of samples (in x) and pixels (in y) that should be considered a movement */
|
|
|
|
std::pair<Temporal::timecnt_t,int> move_threshold () const {
|
|
|
|
return std::make_pair (Temporal::timecnt_t (1, Temporal::AudioTime), 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
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
/** Set up the _pointer_offset */
|
|
|
|
virtual void setup_pointer_offset () {
|
|
|
|
_pointer_offset = Temporal::timecnt_t();
|
2010-12-19 22:42:59 -05:00
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
/** Set up the _video_offset - relative to _current_pointer_time */
|
|
|
|
virtual void setup_video_offset () {
|
|
|
|
/* video offset is always in audio time */
|
|
|
|
_video_offset = Temporal::timecnt_t (Temporal::AudioTime);
|
2019-11-08 23:03:38 -05:00
|
|
|
_preview_video = false;
|
|
|
|
}
|
|
|
|
|
2021-01-08 00:55:31 -05:00
|
|
|
int grab_button() const { return _grab_button; }
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2021-12-04 21:38:26 -05:00
|
|
|
Temporal::timepos_t pixel_to_time (double x) const;
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t raw_grab_time () const {
|
|
|
|
return _raw_grab_time;
|
2010-09-08 21:38:12 -04:00
|
|
|
}
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
ARDOUR::samplepos_t grab_sample () const {
|
2020-10-15 01:09:22 -04:00
|
|
|
return _grab_time.samples();
|
|
|
|
}
|
|
|
|
|
|
|
|
Temporal::timepos_t grab_time () const {
|
|
|
|
return _grab_time;
|
2009-12-21 20:12:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
double last_pointer_x () const {
|
|
|
|
return _last_pointer_x;
|
|
|
|
}
|
|
|
|
|
|
|
|
double last_pointer_y () const {
|
|
|
|
return _last_pointer_y;
|
|
|
|
}
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
ARDOUR::samplepos_t last_pointer_sample () const {
|
2020-10-15 01:09:22 -04:00
|
|
|
return _last_pointer_time.samples();
|
2009-12-21 20:12:41 -05:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t last_pointer_time () const {
|
|
|
|
return _last_pointer_time;
|
|
|
|
}
|
|
|
|
|
|
|
|
Temporal::timecnt_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 */
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_snap_delta (Temporal::timepos_t const & pos);
|
2015-05-16 10:23:25 -04:00
|
|
|
|
2017-01-26 08:41:17 -05:00
|
|
|
boost::shared_ptr<ARDOUR::Region> add_midi_region (MidiTimeAxisView*, bool commit);
|
2012-01-25 14:39:20 -05:00
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void show_verbose_cursor_time (Temporal::timepos_t const &);
|
|
|
|
void show_verbose_cursor_duration (Temporal::timepos_t const & , Temporal::timepos_t const & , double xoffset = 0);
|
2011-05-02 09:38:16 -04:00
|
|
|
void show_verbose_cursor_text (std::string const &);
|
2020-10-15 01:09:22 -04:00
|
|
|
void show_view_preview (Temporal::timepos_t const &);
|
2011-05-02 09:38:16 -04:00
|
|
|
|
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 */
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timecnt_t _pointer_offset;
|
|
|
|
Temporal::timecnt_t _video_offset;
|
2019-11-08 23:03:38 -05:00
|
|
|
bool _preview_video;
|
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
|
2021-07-16 16:12:00 -04:00
|
|
|
ARDOUR::timepos_t _earliest_time_limit; ///< time we cannot drag before (defaults to 0, indicating no such limit)
|
2009-05-30 14:25:59 -04:00
|
|
|
|
|
|
|
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
|
2017-07-01 12:42:24 -04: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
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t _raw_grab_time; ///< unsnapped time that the mouse was at when start_grab was called, or 0
|
|
|
|
Temporal::timepos_t _grab_time; ///< adjusted_time that the mouse was at when start_grab was called, or 0
|
|
|
|
Temporal::timepos_t _last_pointer_time; ///< adjusted_time the last time a motion occurred
|
2021-12-04 20:44:57 -05:00
|
|
|
Temporal::TimeDomain _time_domain;
|
2015-05-16 10:23:25 -04:00
|
|
|
|
|
|
|
/* difference between some key position's snapped and unsnapped
|
2017-09-18 12:39:17 -04:00
|
|
|
* samplepos. used for relative snap.
|
2015-05-16 10:23:25 -04:00
|
|
|
*/
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timecnt_t _snap_delta;
|
2014-12-20 01:11:28 -05:00
|
|
|
CursorContext::Handle _cursor_ctx; ///< cursor change context
|
2016-08-13 11:50:51 -04:00
|
|
|
bool _constraint_pressed; ///< if the keyboard indicated constraint modifier was pressed on start_grab()
|
2021-01-08 00:55:31 -05:00
|
|
|
int _grab_button;
|
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
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t initial_position; ///< initial position of the region
|
|
|
|
Temporal::timepos_t initial_end; ///< initial end position of the region
|
2017-09-18 12:39:17 -04:00
|
|
|
samplepos_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
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_video_offset ();
|
2019-11-08 23:03:38 -05:00
|
|
|
|
2010-09-06 08:34:11 -04:00
|
|
|
friend class DraggingView;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2021-06-15 17:09:24 -04:00
|
|
|
protected:
|
|
|
|
typedef std::set<boost::shared_ptr<ARDOUR::Playlist> > PlaylistSet;
|
|
|
|
void add_stateful_diff_commands_for_playlists (PlaylistSet const &);
|
|
|
|
|
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
|
|
|
};
|
|
|
|
|
2021-06-15 10:06:28 -04:00
|
|
|
/** Drag the Contents rather than the bounds of a region (i.e. Slip) */
|
2021-06-15 11:06:39 -04:00
|
|
|
class RegionSlipContentsDrag : public RegionDrag
|
2021-06-15 10:06:28 -04:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
2021-06-15 11:06:39 -04:00
|
|
|
RegionSlipContentsDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
|
|
|
|
virtual ~RegionSlipContentsDrag () {}
|
2021-06-15 10:06:28 -04:00
|
|
|
|
|
|
|
virtual void start_grab (GdkEvent *, Gdk::Cursor *);
|
|
|
|
virtual void motion (GdkEvent *, bool);
|
|
|
|
virtual void finished (GdkEvent *, bool);
|
|
|
|
virtual void aborted (bool);
|
|
|
|
};
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2021-06-15 17:09:24 -04:00
|
|
|
/** Brush on a region to repeat it */
|
|
|
|
class RegionBrushDrag : public RegionDrag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
RegionBrushDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
|
|
|
|
virtual ~RegionBrushDrag () {}
|
|
|
|
|
|
|
|
virtual void start_grab (GdkEvent *, Gdk::Cursor *);
|
|
|
|
virtual void motion (GdkEvent *, bool);
|
|
|
|
virtual void finished (GdkEvent *, bool);
|
|
|
|
virtual void aborted (bool);
|
|
|
|
private:
|
2021-07-04 11:39:29 -04:00
|
|
|
typedef std::set<Temporal::timepos_t> TimePositionSet;
|
|
|
|
TimePositionSet _already_pasted;
|
2021-06-15 17:09:24 -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
|
|
|
|
2021-06-15 17:09:24 -04:00
|
|
|
RegionMotionDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &);
|
2009-06-08 15:28:51 -04:00
|
|
|
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:
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
double compute_x_delta (GdkEvent const *, Temporal::timepos_t &);
|
2015-03-24 16:59:57 -04:00
|
|
|
virtual bool y_movement_allowed (int, double, int skip_invisible = 0) const;
|
2021-06-04 11:22:44 -04:00
|
|
|
void collect_ripple_views ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2015-09-07 20:51:58 -04:00
|
|
|
bool _ignore_video_lock;
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t _last_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;
|
2021-06-21 14:23:52 -04:00
|
|
|
std::vector<ArdourMarker*> ripple_markers;
|
2021-06-04 11:22:44 -04:00
|
|
|
|
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:
|
2021-06-15 17:09:24 -04:00
|
|
|
RegionMoveDrag (Editor *, ArdourCanvas::Item *, RegionView *, std::list<RegionView*> const &, bool);
|
2009-05-30 14:25:59 -04:00
|
|
|
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
|
|
|
|
2021-06-15 13:41:25 -04:00
|
|
|
void clear_draggingview_list ();
|
|
|
|
|
2010-08-19 19:56:30 -04:00
|
|
|
bool regions_came_from_canvas () const {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
std::pair<Temporal::timecnt_t,int> move_threshold () const {
|
|
|
|
return std::make_pair (Temporal::timecnt_t (4, Temporal::AudioTime), 4);
|
2009-06-01 20:39:57 -04:00
|
|
|
}
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2010-12-19 22:42:59 -05: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,
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t const &,
|
2016-06-13 13:21:52 -04:00
|
|
|
int32_t const ev_state
|
2010-08-23 21:02:40 -04:00
|
|
|
);
|
|
|
|
|
|
|
|
void finished_copy (
|
|
|
|
bool const,
|
|
|
|
bool const,
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t const &,
|
2016-06-13 13:21:52 -04:00
|
|
|
int32_t const ev_state
|
2010-08-23 21:02:40 -04:00
|
|
|
);
|
|
|
|
|
|
|
|
RegionView* insert_region_into_playlist (
|
|
|
|
boost::shared_ptr<ARDOUR::Region>,
|
|
|
|
RouteTimeAxisView*,
|
|
|
|
ARDOUR::layer_t,
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t const &,
|
2016-06-16 13:20:37 -04:00
|
|
|
PlaylistSet&,
|
2017-01-26 08:41:17 -05:00
|
|
|
bool for_music = false
|
2010-08-23 21:02:40 -04:00
|
|
|
);
|
|
|
|
|
|
|
|
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:
|
2020-10-15 01:09:22 -04:00
|
|
|
RegionInsertDrag (Editor *, boost::shared_ptr<ARDOUR::Region>, RouteTimeAxisView*, Temporal::timepos_t const &);
|
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
|
|
|
};
|
|
|
|
|
2020-10-15 01:09:22 -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:
|
|
|
|
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
|
|
|
|
Temporal::timecnt_t prev_amount;
|
|
|
|
Temporal::timepos_t prev_position;
|
|
|
|
Temporal::timecnt_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, Temporal::timepos_t const & where, const RegionSelection &exclude, bool drag_in_progress);
|
|
|
|
void remove_unselected_from_views (Temporal::timecnt_t const & amount, bool move_regions);
|
|
|
|
|
|
|
|
std::list<boost::shared_ptr<ARDOUR::Region> > _orig_tav_ripples;
|
|
|
|
};
|
|
|
|
|
|
|
|
/** "Drag" to cut a region (action only on button release) */
|
2014-07-07 07:05:27 -04:00
|
|
|
class RegionCutDrag : public Drag
|
|
|
|
{
|
2017-07-01 15:11:14 -04:00
|
|
|
public:
|
2017-09-18 12:39:17 -04:00
|
|
|
RegionCutDrag (Editor*, ArdourCanvas::Item*, samplepos_t);
|
2014-07-07 08:26:37 -04:00
|
|
|
~RegionCutDrag ();
|
|
|
|
|
2016-11-21 05:45:35 -05:00
|
|
|
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
|
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
|
|
|
|
2017-07-01 15:11:14 -04:00
|
|
|
private:
|
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
|
|
|
|
2020-12-01 20:57:35 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-08 17:45:44 -04:00
|
|
|
private:
|
|
|
|
MidiRegionView* region;
|
|
|
|
bool relative;
|
|
|
|
bool at_front;
|
2015-10-23 10:19:00 -04:00
|
|
|
bool _was_selected;
|
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
|
|
|
|
{
|
2017-07-01 15:11:14 -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
|
|
|
|
2020-12-06 18:33:50 -05:00
|
|
|
void setup_pointer_offset ();
|
2020-12-01 20:57:35 -05:00
|
|
|
|
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-07-01 15:11:14 -04:00
|
|
|
private:
|
2010-08-19 18:01:10 -04:00
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timecnt_t total_dx (GdkEvent * event) const; // total movement in quarter notes
|
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;
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timecnt_t _cumulative_dx;
|
2010-08-19 18:01:10 -04:00
|
|
|
double _cumulative_dy;
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t _earliest; // earliest note in note selection
|
2015-10-23 10:19:00 -04:00
|
|
|
bool _was_selected;
|
2010-08-19 18:01:10 -04:00
|
|
|
double _note_height;
|
2017-01-23 15:57:38 -05:00
|
|
|
bool _copy;
|
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
|
|
|
}
|
|
|
|
|
2020-12-01 20:57:35 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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;
|
2021-11-04 20:27:02 -04:00
|
|
|
Temporal::Beats round_down_to_grid (Temporal::timepos_t const & pos, GdkEvent const * event) const;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
/** @return minimum number of samples (in x) and pixels (in y) that should be considered a movement */
|
|
|
|
std::pair<Temporal::timecnt_t,int> move_threshold () const {
|
|
|
|
return std::make_pair (Temporal::timecnt_t (0, Temporal::AudioTime), 0);
|
2016-11-19 12:55:34 -05:00
|
|
|
}
|
|
|
|
|
2011-12-11 07:54:54 -05:00
|
|
|
MidiRegionView* _region_view;
|
2013-04-04 00:32:52 -04:00
|
|
|
ArdourCanvas::Rectangle* _drag_rect;
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t _note[2];
|
2011-12-11 07:54:54 -05:00
|
|
|
};
|
|
|
|
|
2016-11-20 12:20:27 -05:00
|
|
|
class HitCreateDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
HitCreateDrag (Editor *, ArdourCanvas::Item *, MidiRegionView *);
|
|
|
|
~HitCreateDrag ();
|
|
|
|
|
|
|
|
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 || mode == Editing::MouseContent;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool y_movement_matters () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
double y_to_region (double) const;
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
/** @return minimum number of samples (in x) and pixels (in y) that should be considered a movement */
|
|
|
|
std::pair<Temporal::timecnt_t,int> move_threshold () const {
|
|
|
|
return std::make_pair (Temporal::timecnt_t::zero (Temporal::AudioTime), 0);
|
2016-11-20 12:20:27 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
MidiRegionView* _region_view;
|
2020-12-18 15:12:41 -05:00
|
|
|
Temporal::timepos_t _last_pos;
|
2017-03-04 09:57:10 -05:00
|
|
|
double _y;
|
2016-11-21 10:05:32 -05:00
|
|
|
|
2016-11-20 12:20:27 -05:00
|
|
|
};
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-12-01 20:57:35 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2010-12-19 22:42:59 -05:00
|
|
|
|
|
|
|
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
|
2017-09-18 12:39:17 -04:00
|
|
|
samplepos_t initial_position; ///< initial position of the region
|
2013-03-12 17:00:09 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** 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:
|
2017-09-18 12:39:17 -04:00
|
|
|
ARDOUR::sampleoffset_t _startdrag_video_offset;
|
|
|
|
ARDOUR::sampleoffset_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,
|
2021-06-15 10:22:58 -04:00
|
|
|
EndTrim
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-12-01 20:57:35 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_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
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
MeterMarker* _marker;
|
2016-03-03 08:08:21 -05:00
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
bool _copy;
|
2020-11-24 20:25:34 -05:00
|
|
|
bool _movable;
|
2018-02-09 10:59:39 -05:00
|
|
|
Editing::GridType _old_grid_type;
|
2016-05-27 12:57:53 -04:00
|
|
|
Editing::SnapMode _old_snap_mode;
|
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 {
|
2016-03-25 13:48:29 -04:00
|
|
|
return true;
|
2010-01-04 20:10:53 -05:00
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
TempoMarker* _marker;
|
2020-11-16 13:19:22 -05:00
|
|
|
Temporal::TempoPoint* _real_section;
|
2015-12-22 13:58:49 -05:00
|
|
|
|
2009-06-08 15:28:51 -04:00
|
|
|
bool _copy;
|
2016-03-25 15:16:47 -04:00
|
|
|
bool _movable;
|
2020-11-11 11:31:52 -05:00
|
|
|
Temporal::Tempo _grab_bpm;
|
2020-12-18 15:12:41 -05:00
|
|
|
Temporal::Beats _grab_qn;
|
2017-03-04 13:21:56 -05:00
|
|
|
XMLNode* _before_state;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
2016-05-07 13:03:12 -04:00
|
|
|
/** BBT Ruler drag */
|
|
|
|
class BBTRulerDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
BBTRulerDrag (Editor *, ArdourCanvas::Item *);
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2016-05-07 13:03:12 -04:00
|
|
|
|
|
|
|
private:
|
2020-12-18 15:12:41 -05:00
|
|
|
Temporal::Beats _grab_qn;
|
2020-11-16 13:19:22 -05:00
|
|
|
Temporal::TempoPoint* _tempo;
|
2017-03-04 13:21:56 -05:00
|
|
|
XMLNode* _before_state;
|
2017-06-16 14:59:06 -04:00
|
|
|
bool _drag_valid;
|
2016-05-07 13:03:12 -04:00
|
|
|
};
|
2009-05-30 14:25:59 -04:00
|
|
|
|
2020-11-19 11:03:28 -05:00
|
|
|
#warning NUTEMPO may or may not need this in the new world
|
|
|
|
#if 0
|
2017-02-24 13:09:16 -05:00
|
|
|
/** tempo curve twist drag */
|
|
|
|
class TempoTwistDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
TempoTwistDrag (Editor *, ArdourCanvas::Item *);
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2017-02-24 13:09:16 -05:00
|
|
|
|
|
|
|
private:
|
2020-12-18 15:12:41 -05:00
|
|
|
Temporal::Beats _grab_qn;
|
2020-11-11 11:31:52 -05:00
|
|
|
Temporal::Tempo _grab_tempo;
|
|
|
|
Temporal::TempoPoint* _tempo;
|
|
|
|
Temporal::TempoPoint* _next_tempo;
|
2017-02-26 10:26:08 -05:00
|
|
|
bool _drag_valid;
|
2017-03-04 13:21:56 -05:00
|
|
|
XMLNode* _before_state;
|
2017-02-24 13:09:16 -05:00
|
|
|
};
|
2020-11-19 11:03:28 -05:00
|
|
|
#endif
|
2017-02-24 13:09:16 -05:00
|
|
|
|
|
|
|
/** tempo curve twist drag */
|
|
|
|
class TempoEndDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
TempoEndDrag (Editor *, ArdourCanvas::Item *);
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2017-02-24 13:09:16 -05:00
|
|
|
|
|
|
|
private:
|
2020-12-18 15:12:41 -05:00
|
|
|
Temporal::Beats _grab_qn;
|
2020-11-11 11:31:52 -05:00
|
|
|
Temporal::TempoPoint* _tempo;
|
2017-03-04 13:21:56 -05:00
|
|
|
XMLNode* _before_state;
|
2017-06-16 15:11:38 -04:00
|
|
|
bool _drag_valid;
|
2017-02-24 13:09:16 -05: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:
|
2017-09-18 12:39:17 -04:00
|
|
|
void fake_locate (samplepos_t);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2017-07-01 12:42:24 -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
|
2017-09-18 12:39:17 -04:00
|
|
|
double _grab_zoom; ///< editor samples per unit when our grab started
|
2017-07-20 10:51:26 -04:00
|
|
|
|
|
|
|
//used for zooming
|
|
|
|
int _last_mx;
|
|
|
|
int _last_my;
|
|
|
|
int _last_dx;
|
|
|
|
int _last_y_delta;
|
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
|
|
|
|
2020-12-01 20:57:35 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_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
|
|
|
|
2020-12-01 20:57:35 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** Marker drag */
|
|
|
|
class MarkerDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
2017-07-01 12:42:24 -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
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
|
|
|
void setup_video_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
|
2015-10-24 14:26:44 -04:00
|
|
|
bool _selection_changed;
|
2017-07-01 12:42:24 -04:00
|
|
|
struct CopiedLocationMarkerInfo {
|
|
|
|
ARDOUR::Location* location;
|
|
|
|
std::vector<ArdourMarker*> markers;
|
|
|
|
bool move_both;
|
|
|
|
CopiedLocationMarkerInfo (ARDOUR::Location* l, ArdourMarker* m);
|
2013-01-02 18:54:06 -05:00
|
|
|
};
|
|
|
|
|
2017-07-01 12:42:24 -04:00
|
|
|
typedef std::list<CopiedLocationMarkerInfo> CopiedLocationInfo;
|
|
|
|
CopiedLocationInfo _copied_locations;
|
|
|
|
ArdourCanvas::Points _points;
|
2009-05-30 14:25:59 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/** 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
|
|
|
|
2020-12-01 20:57:35 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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;
|
2017-07-01 12:42:24 -04:00
|
|
|
bool _pushing;
|
2012-12-19 10:55:06 -05:00
|
|
|
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
|
|
|
|
2020-12-01 20:57:35 -05:00
|
|
|
bool allow_vertical_autoscroll () const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
std::pair<Temporal::timecnt_t,int> move_threshold () const {
|
|
|
|
return std::make_pair (Temporal::timecnt_t (8, Temporal::AudioTime), 1);
|
2010-01-11 21:12:15 -05:00
|
|
|
}
|
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.
|
2020-10-15 01:09:22 -04:00
|
|
|
* @param x1 The left-hand side of the rectangle as a timepos_t
|
|
|
|
* @param x2 The right-hand side of the rectangle as a timepos_t.
|
2011-11-16 15:11:33 -05:00
|
|
|
* @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.
|
|
|
|
*/
|
2020-10-15 01:09:22 -04:00
|
|
|
virtual void select_things (int button_state, Temporal::timepos_t const & x1, Temporal::timepos_t const & 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 *);
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void select_things (int, Temporal::timepos_t const &, Temporal::timepos_t const &, double, double, bool);
|
2011-11-16 15:11:33 -05:00
|
|
|
void deselect_things ();
|
|
|
|
};
|
|
|
|
|
|
|
|
/** A RubberbandSelectDrag for selecting MIDI notes */
|
|
|
|
class MidiRubberbandSelectDrag : public RubberbandSelectDrag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
MidiRubberbandSelectDrag (Editor *, MidiRegionView *);
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void select_things (int, Temporal::timepos_t const &, Temporal::timepos_t const &, double, double, bool);
|
2011-11-16 15:11:33 -05:00
|
|
|
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 *);
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void select_things (int, Temporal::timepos_t const &, Temporal::timepos_t const &, double, double, bool);
|
2012-01-19 21:54:23 -05:00
|
|
|
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
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
void setup_pointer_offset ();
|
2010-12-19 22:42:59 -05:00
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
private:
|
|
|
|
Operation _operation;
|
2012-12-13 14:39:36 -05:00
|
|
|
bool _add;
|
2017-01-25 15:46:24 -05:00
|
|
|
TrackSelection _track_selection_at_start;
|
2012-01-30 17:53:22 -05:00
|
|
|
bool _time_selection_at_start;
|
2020-10-15 01:09:22 -04:00
|
|
|
Temporal::timepos_t start_at_start;
|
|
|
|
Temporal::timepos_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
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
std::pair<Temporal::timecnt_t,int> move_threshold () const {
|
|
|
|
return std::make_pair (Temporal::timecnt_t (4, Temporal::AudioTime), 4);
|
2010-11-06 22:35:00 -04:00
|
|
|
}
|
|
|
|
|
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:
|
2020-09-26 11:14:59 -04:00
|
|
|
AutomationRangeDrag (Editor *, AutomationTimeAxisView *, std::list<ARDOUR::TimelineRange> const &);
|
|
|
|
AutomationRangeDrag (Editor *, std::list<RegionView*> const &, std::list<ARDOUR::TimelineRange> const &, double y_origin, double y_height);
|
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 &);
|
2019-03-29 20:19:47 -04:00
|
|
|
double y_fraction (double global_y_position) const;
|
2020-10-15 01:09:22 -04:00
|
|
|
double value (boost::shared_ptr<ARDOUR::AutomationList> list, Temporal::timepos_t const & x) const;
|
2012-07-10 11:58:09 -04:00
|
|
|
|
2020-09-26 11:14:59 -04:00
|
|
|
std::list<ARDOUR::TimelineRange> _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
|
2020-10-15 01:09:22 -04:00
|
|
|
std::pair<Temporal::timepos_t, Temporal::timepos_t> range; ///< the range of all points on the line, in session time
|
2010-09-09 17:35:28 -04:00
|
|
|
XMLNode* state; ///< the XML state node before the drag
|
|
|
|
};
|
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;
|
2019-03-29 20:19:47 -04:00
|
|
|
double _y_height;
|
2015-01-13 23:30:37 -05:00
|
|
|
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
|
|
|
|
{
|
2017-07-01 15:11:14 -04:00
|
|
|
public:
|
2012-05-09 19:04:18 -04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-10-15 01:09:22 -04:00
|
|
|
std::pair<Temporal::timecnt_t,int> move_threshold () const {
|
|
|
|
return std::make_pair (Temporal::timecnt_t (4, Temporal::AudioTime), 4);
|
2012-05-09 20:46:22 -04:00
|
|
|
}
|
|
|
|
|
2017-07-01 15:11:14 -04:00
|
|
|
private:
|
2012-05-09 19:04:18 -04:00
|
|
|
AudioRegionView* arv;
|
|
|
|
bool start;
|
|
|
|
};
|
|
|
|
|
2021-05-24 11:12:19 -04:00
|
|
|
class RegionMarkerDrag : public Drag
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
RegionMarkerDrag (Editor*, RegionView*, ArdourCanvas::Item*);
|
|
|
|
~RegionMarkerDrag ();
|
|
|
|
|
|
|
|
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_sample_offset ();
|
|
|
|
|
|
|
|
private:
|
|
|
|
RegionView* rv;
|
|
|
|
ArdourMarker* view;
|
|
|
|
ARDOUR::CueMarker model;
|
2021-05-24 14:28:19 -04:00
|
|
|
ARDOUR::CueMarker dragging_model;
|
2021-05-24 11:12:19 -04:00
|
|
|
};
|
|
|
|
|
2009-05-30 14:25:59 -04:00
|
|
|
#endif /* __gtk2_ardour_editor_drag_h_ */
|