#ifndef __ardour_editor_h__
#define __ardour_editor_h__
+#include <sys/time.h>
+
+#include <cmath>
#include <list>
#include <map>
#include <set>
-#include <stack>
#include <string>
-#include <sys/time.h>
-#include <cmath>
+#include <vector>
#include <boost/optional.hpp>
#include "enums.h"
#include "editor_items.h"
#include "region_selection.h"
+#include "selection_memento.h"
namespace Gtkmm2ext {
- class TearOff;
class Bindings;
}
namespace ARDOUR {
- class RouteGroup;
- class Playlist;
class AudioPlaylist;
class AudioRegion;
- class Region;
- class Location;
- class TempoSection;
- class Session;
- class Filter;
+ class AudioTrack;
class ChanCount;
+ class Filter;
+ class Location;
class MidiOperator;
- class Track;
+ class MidiRegion;
class MidiTrack;
- class AudioTrack;
+ class Playlist;
+ class Region;
+ class RouteGroup;
+ class Session;
+ class TempoSection;
+ class Track;
}
namespace LADSPA {
class BundleManager;
class ButtonJoiner;
class ControlPoint;
+class CursorContext;
class DragManager;
class EditNoteDialog;
class EditorCursor;
class EditorSummary;
class GroupedButtons;
class GUIObjectState;
-class Marker;
+class ArdourMarker;
class MidiRegionView;
+class MidiExportDialog;
class MixerStrip;
class MouseCursors;
class NoteBase;
class PlaylistSelector;
class PluginSelector;
class ProgressReporter;
+class QuantizeDialog;
class RhythmFerret;
class RulerDialog;
class Selection;
void set_session (ARDOUR::Session *);
ARDOUR::Session* session() const { return _session; }
+ Gtk::Window* use_own_window (bool and_fill_it);
+
void first_idle ();
virtual bool have_idled () const { return _have_idled; }
double visible_canvas_height () const {
return _visible_canvas_height;
}
- double trackviews_height() const;
+ double trackviews_height () const;
void cycle_snap_mode ();
void next_snap_choice ();
Editing::MidiEditMode current_midi_edit_mode () const;
void remove_midi_note (ArdourCanvas::Item *, GdkEvent *);
- bool internal_editing() const { return _internal_editing ; }
- void set_internal_edit (bool yn);
- bool toggle_internal_editing_from_double_click (GdkEvent*);
+ bool internal_editing() const;
void foreach_time_axis_view (sigc::slot<void,TimeAxisView&>);
void add_to_idle_resize (TimeAxisView*, int32_t);
}
double sample_to_pixel (framepos_t sample) const {
- return sample / samples_per_pixel;
+ return round (sample / (double) samples_per_pixel);
}
double sample_to_pixel_unrounded (framepos_t sample) const {
/* selection */
Selection& get_selection() const { return *selection; }
+ bool get_selection_extents ( framepos_t &start, framepos_t &end ); // the time extents of the current selection, whether Range, Region(s), Control Points, or Notes
Selection& get_cut_buffer() const { return *cut_buffer; }
void track_mixer_selection ();
void set_selected_regionview_from_region_list (boost::shared_ptr<ARDOUR::Region> region, Selection::Operation op = Selection::Set);
+ void remove_tracks ();
+
/* tempo */
void set_show_measures (bool yn);
void export_range ();
void export_region ();
- void add_toplevel_controls (Gtk::Container&);
- Gtk::HBox& get_status_bar_packer() { return status_bar_hpacker; }
+ bool process_midi_export_dialog (MidiExportDialog& dialog, boost::shared_ptr<ARDOUR::MidiRegion> midi_region);
void set_zoom_focus (Editing::ZoomFocus);
Editing::ZoomFocus get_zoom_focus () const { return zoom_focus; }
framecnt_t get_current_zoom () const { return samples_per_pixel; }
- void cycle_zoom_focus ();
+ void cycle_zoom_focus ();
void temporal_zoom_step (bool coarser);
- void ensure_time_axis_view_is_visible (TimeAxisView const & tav, bool at_top);
+ void temporal_zoom_step_mouse_focus (bool coarser);
+ void ensure_time_axis_view_is_visible (TimeAxisView const & tav, bool at_top);
void tav_zoom_step (bool coarser);
void tav_zoom_smooth (bool coarser, bool force_all);
/* nudge is initiated by transport controls owned by ARDOUR_UI */
framecnt_t get_nudge_distance (framepos_t pos, framecnt_t& next);
- Evoral::MusicalTime get_grid_type_as_beats (bool& success, framepos_t position);
+ framecnt_t get_paste_offset (framepos_t pos, unsigned paste_count, framecnt_t duration);
+ unsigned get_grid_beat_divisions(framepos_t position);
+ Evoral::Beats get_grid_type_as_beats (bool& success, framepos_t position);
void nudge_forward (bool next, bool force_playhead);
void nudge_backward (bool next, bool force_playhead);
void ensure_float (Gtk::Window&);
- void show_window ();
-
void scroll_tracks_down_line ();
void scroll_tracks_up_line ();
- bool scroll_up_one_track ();
- bool scroll_down_one_track ();
+
+ bool scroll_up_one_track (bool skip_child_views = false);
+ bool scroll_down_one_track (bool skip_child_views = false);
+
+ void scroll_left_step ();
+ void scroll_right_step ();
+
+ void scroll_left_half_page ();
+ void scroll_right_half_page ();
void prepare_for_cleanup ();
void finish_cleanup ();
void maximise_editing_space();
void restore_editing_space();
- void update_tearoff_visibility();
-
+ double get_y_origin () const;
void reset_x_origin (framepos_t);
void reset_x_origin_to_follow_playhead ();
void reset_y_origin (double);
void reset_zoom (framecnt_t);
void reposition_and_zoom (framepos_t, double);
- framepos_t get_preferred_edit_position (bool ignore_playhead = false, bool use_context_click = false);
+ framepos_t get_preferred_edit_position (Editing::EditIgnoreOption = Editing::EDIT_IGNORE_NONE,
+ bool use_context_click = false,
+ bool from_outside_canvas = false);
bool update_mouse_speed ();
bool decelerate_mouse_speed ();
int get_regionview_count_from_region_list (boost::shared_ptr<ARDOUR::Region>);
- void do_import (std::vector<std::string> paths, Editing::ImportDisposition, Editing::ImportMode mode, ARDOUR::SrcQuality, framepos_t&);
- void do_embed (std::vector<std::string> paths, Editing::ImportDisposition, Editing::ImportMode mode, framepos_t&);
+ void do_ptimport(std::string path, ARDOUR::SrcQuality quality);
- void get_regions_corresponding_to (boost::shared_ptr<ARDOUR::Region> region, std::vector<RegionView*>& regions, bool src_comparison);
+ void do_import (std::vector<std::string> paths,
+ Editing::ImportDisposition disposition,
+ Editing::ImportMode mode,
+ ARDOUR::SrcQuality quality,
+ framepos_t& pos,
+ boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>());
- void center_screen (framepos_t);
+ void do_embed (std::vector<std::string> paths,
+ Editing::ImportDisposition disposition,
+ Editing::ImportMode mode,
+ framepos_t& pos,
+ boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>());
- TrackViewList axis_views_from_routes (boost::shared_ptr<ARDOUR::RouteList>) const;
+ void get_regions_corresponding_to (boost::shared_ptr<ARDOUR::Region> region, std::vector<RegionView*>& regions, bool src_comparison);
+
+ void get_regionviews_by_id (PBD::ID const id, RegionSelection & regions) const;
+ void get_per_region_note_selection (std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >&) const;
- Gtkmm2ext::TearOff* mouse_mode_tearoff () const { return _mouse_mode_tearoff; }
- Gtkmm2ext::TearOff* tools_tearoff () const { return _tools_tearoff; }
+ void center_screen (framepos_t);
- void snap_to (framepos_t& first, int32_t direction = 0, bool for_mark = false);
- void snap_to_with_modifier (framepos_t& first, GdkEvent const *, int32_t direction = 0, bool for_mark = false);
- void snap_to (framepos_t& first, framepos_t& last, int32_t direction = 0, bool for_mark = false);
+ TrackViewList axis_views_from_routes (boost::shared_ptr<ARDOUR::RouteList>) const;
+ void snap_to (framepos_t& first,
+ ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
+ bool for_mark = false,
+ bool ensure_snap = false);
+
+ void snap_to_with_modifier (framepos_t& first,
+ GdkEvent const * ev,
+ ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
+ bool for_mark = false);
+
+ void snap_to (framepos_t& first,
+ framepos_t& last,
+ ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
+ bool for_mark = false);
+
+ void begin_selection_op_history ();
+ void begin_reversible_selection_op (std::string cmd_name);
+ void commit_reversible_selection_op ();
+ void undo_selection_op ();
+ void redo_selection_op ();
void begin_reversible_command (std::string cmd_name);
void begin_reversible_command (GQuark);
+ void abort_reversible_command ();
void commit_reversible_command ();
DragManager* drags () const {
return _drags;
}
- void maybe_autoscroll (bool, bool, bool);
- bool autoscroll_active() const;
+ void maybe_autoscroll (bool, bool, bool);
+ bool autoscroll_active() const;
- Gdk::Cursor* get_canvas_cursor () const { return current_canvas_cursor; }
- void set_canvas_cursor (Gdk::Cursor*, bool save=false);
-
- void push_canvas_cursor (Gdk::Cursor*);
- void pop_canvas_cursor ();
+ Gdk::Cursor* get_canvas_cursor () const;
void set_current_trimmable (boost::shared_ptr<ARDOUR::Trimmable>);
void set_current_movable (boost::shared_ptr<ARDOUR::Movable>);
void get_pointer_position (double &, double &) const;
+ /** Context for mouse entry (stored in a stack). */
+ struct EnterContext {
+ ItemType item_type;
+ boost::shared_ptr<CursorContext> cursor_ctx;
+ };
+
+ /** Get the topmost enter context for the given item type.
+ *
+ * This is used to change the cursor associated with a given enter context,
+ * which may not be on the top of the stack.
+ */
+ EnterContext* get_enter_context(ItemType type);
+
TimeAxisView* stepping_axis_view () {
return _stepping_axis_view;
}
-
+
void set_stepping_axis_view (TimeAxisView* v) {
_stepping_axis_view = v;
}
- ArdourCanvas::Container* get_trackview_group () const { return _trackview_group; }
- ArdourCanvas::Container* get_noscroll_group () const { return no_scroll_group; }
- ArdourCanvas::ScrollGroup* get_hscroll_group () const { return h_scroll_group; }
- ArdourCanvas::ScrollGroup* get_vscroll_group () const { return v_scroll_group; }
- ArdourCanvas::ScrollGroup* get_hvscroll_group () const { return hv_scroll_group; }
+ ArdourCanvas::Container* get_trackview_group () const { return _trackview_group; }
+ ArdourCanvas::Container* get_noscroll_group () const { return no_scroll_group; }
+ ArdourCanvas::ScrollGroup* get_hscroll_group () const { return h_scroll_group; }
+ ArdourCanvas::ScrollGroup* get_hvscroll_group () const { return hv_scroll_group; }
+ ArdourCanvas::ScrollGroup* get_cursor_scroll_group () const { return cursor_scroll_group; }
- ArdourCanvas::GtkCanvasViewport* get_track_canvas () const;
+ ArdourCanvas::GtkCanvasViewport* get_track_canvas () const;
- void override_visible_track_count ();
+ void override_visible_track_count ();
/* Ruler metrics methods */
void metric_get_minsec (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint);
/* editing operations that need to be public */
- void mouse_add_new_marker (framepos_t where, bool is_cd=false, bool is_xrun=false);
+ void mouse_add_new_marker (framepos_t where, bool is_cd=false);
void split_regions_at (framepos_t, RegionSelection&);
void split_region_at_points (boost::shared_ptr<ARDOUR::Region>, ARDOUR::AnalysisFeatureList&, bool can_ferret, bool select_new = false);
RegionSelection get_regions_from_selection_and_mouse (framepos_t);
-
+
+ void mouse_add_new_tempo_event (framepos_t where);
+ void mouse_add_new_meter_event (framepos_t where);
+ void edit_tempo_section (ARDOUR::TempoSection*);
+ void edit_meter_section (ARDOUR::MeterSection*);
+
protected:
void map_transport_state ();
void map_position_change (framepos_t);
void cancel_visual_state_op (uint32_t n);
framepos_t leftmost_frame;
- framecnt_t samples_per_pixel;
+ framecnt_t samples_per_pixel;
Editing::ZoomFocus zoom_focus;
void set_samples_per_pixel (framecnt_t);
Editing::MouseMode mouse_mode;
- Editing::MouseMode pre_internal_mouse_mode;
Editing::SnapType pre_internal_snap_type;
Editing::SnapMode pre_internal_snap_mode;
Editing::SnapType internal_snap_type;
Editing::SnapMode internal_snap_mode;
- bool _internal_editing;
Editing::MouseMode effective_mouse_mode () const;
enum JoinObjectRangeState {
Gtk::VBox scrollers_rulers_markers_box;
void location_changed (ARDOUR::Location *);
- void location_flags_changed (ARDOUR::Location *, void *);
+ void location_flags_changed (ARDOUR::Location *);
void refresh_location_display ();
- void refresh_location_display_internal (ARDOUR::Locations::LocationList&);
+ void refresh_location_display_internal (const ARDOUR::Locations::LocationList&);
void add_new_location (ARDOUR::Location *);
ArdourCanvas::Container* add_new_location_internal (ARDOUR::Location *);
void location_gone (ARDOUR::Location *);
uint32_t location_cd_marker_color;
struct LocationMarkers {
- Marker* start;
- Marker* end;
+ ArdourMarker* start;
+ ArdourMarker* end;
bool valid;
LocationMarkers () : start(0), end(0), valid (true) {}
};
LocationMarkers *find_location_markers (ARDOUR::Location *) const;
- ARDOUR::Location* find_location_from_marker (Marker *, bool& is_start) const;
- Marker* find_marker_from_location_id (PBD::ID const &, bool) const;
- Marker* entered_marker;
+ ARDOUR::Location* find_location_from_marker (ArdourMarker *, bool& is_start) const;
+ ArdourMarker* find_marker_from_location_id (PBD::ID const &, bool) const;
+ ArdourMarker* entered_marker;
bool _show_marker_lines;
typedef std::map<ARDOUR::Location*,LocationMarkers *> LocationMarkerMap;
void update_marker_labels ();
void update_marker_labels (ArdourCanvas::Container *);
- void check_marker_label (Marker *);
+ void check_marker_label (ArdourMarker *);
/** A set of lists of Markers that are in each of the canvas groups
* for the marker sections at the top of the editor. These lists
* a marker has moved we can decide whether we need to update the labels
* for all markers or for just a few.
*/
- std::map<ArdourCanvas::Container *, std::list<Marker *> > _sorted_marker_lists;
- void remove_sorted_marker (Marker *);
+ std::map<ArdourCanvas::Container *, std::list<ArdourMarker *> > _sorted_marker_lists;
+ void remove_sorted_marker (ArdourMarker *);
void hide_marker (ArdourCanvas::Item*, GdkEvent*);
void clear_marker_display ();
void mouse_add_new_range (framepos_t);
+ void mouse_add_new_loop (framepos_t);
+ void mouse_add_new_punch (framepos_t);
bool choose_new_marker_name(std::string &name);
void update_cd_marker_display ();
void ensure_cd_marker_updated (LocationMarkers * lam, ARDOUR::Location * location);
void mapped_use_new_playlist (RouteTimeAxisView&, uint32_t, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
void mapped_use_copy_playlist (RouteTimeAxisView&, uint32_t, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
void mapped_clear_playlist (RouteTimeAxisView&, uint32_t);
-
+
void button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type);
bool button_release_can_deselect;
+ bool _mouse_changed_selection;
void catch_vanishing_regionview (RegionView *);
void set_selected_track (TimeAxisView&, Selection::Operation op = Selection::Set, bool no_remove=false);
void select_all_tracks ();
- void select_all_internal_edit (Selection::Operation);
+ bool select_all_internal_edit (Selection::Operation);
bool set_selected_control_point_from_click (bool press, Selection::Operation op = Selection::Set);
void set_selected_track_from_click (bool press, Selection::Operation op = Selection::Set, bool no_remove=false);
void popup_control_point_context_menu (ArdourCanvas::Item *, GdkEvent *);
Gtk::Menu _control_point_context_menu;
+ void popup_note_context_menu (ArdourCanvas::Item *, GdkEvent *);
+ Gtk::Menu _note_context_menu;
+
void add_routes (ARDOUR::RouteList&);
void timeaxisview_deleted (TimeAxisView *);
- Gtk::HBox global_hpacker;
- Gtk::VBox global_vpacker;
- Gtk::VBox vpacker;
+ Gtk::HBox global_hpacker;
+ Gtk::VBox global_vpacker;
+
+ /* Cursor stuff. Do not use directly, use via CursorContext. */
+ friend class CursorContext;
+ std::vector<Gdk::Cursor*> _cursor_stack;
+ void set_canvas_cursor (Gdk::Cursor*);
+ size_t push_canvas_cursor (Gdk::Cursor*);
+ void pop_canvas_cursor ();
- std::stack<Gdk::Cursor*> _cursor_stack;
- Gdk::Cursor* current_canvas_cursor;
Gdk::Cursor* which_grabber_cursor () const;
Gdk::Cursor* which_track_cursor () const;
Gdk::Cursor* which_mode_cursor () const;
Gdk::Cursor* which_trim_cursor (bool left_side) const;
- bool reset_canvas_cursor ();
- void choose_canvas_cursor_on_entry (GdkEventCrossing*, ItemType);
+ Gdk::Cursor* which_canvas_cursor (ItemType type) const;
+
+ /** Push the appropriate enter/cursor context on item entry. */
+ void choose_canvas_cursor_on_entry (ItemType);
+
+ /** Update all enter cursors based on current settings. */
+ void update_all_enter_cursors ();
ArdourCanvas::GtkCanvas* _track_canvas;
ArdourCanvas::GtkCanvasViewport* _track_canvas_viewport;
Gtk::VBox time_bars_vbox;
ArdourCanvas::Pixbuf *logo_item;
-#if 0
- /* these will be needed when we have canvas rulers */
- ArdourCanvas::Container *minsec_group;
- ArdourCanvas::Container *bbt_group;
- ArdourCanvas::Container *timecode_group;
- ArdourCanvas::Container *frame_group;
-#endif
ArdourCanvas::Container *tempo_group;
ArdourCanvas::Container *meter_group;
/* The group containing all other groups that are scrolled vertically
and horizontally.
*/
- ArdourCanvas::ScrollGroup* hv_scroll_group;
+ ArdourCanvas::ScrollGroup* hv_scroll_group;
- /* The group containing all other groups that are scrolled vertically ONLY
+ /* The group containing all other groups that are scrolled horizontally ONLY
*/
- ArdourCanvas::ScrollGroup* v_scroll_group;
+ ArdourCanvas::ScrollGroup* h_scroll_group;
- /* The group containing all other groups that are scrolled horizontally ONLY
+ /* Scroll group for cursors, scrolled horizontally, above everything else
*/
- ArdourCanvas::ScrollGroup* h_scroll_group;
+ ArdourCanvas::ScrollGroup* cursor_scroll_group;
/* The group containing all trackviews. */
ArdourCanvas::Container* no_scroll_group;
*/
ArdourCanvas::Container* _drag_motion_group;
- /* a rect that sits at the bottom of all tracks to act as a drag-no-drop/clickable
+ /* a rect that sits at the bottom of all tracks to act as a drag-no-drop/clickable
* target area.
*/
- ArdourCanvas::Rectangle* _canvas_drop_zone;
- bool canvas_drop_zone_event (GdkEvent* event);
+ ArdourCanvas::Rectangle* _canvas_drop_zone;
+ bool canvas_drop_zone_event (GdkEvent* event);
enum RulerType {
ruler_metric_timecode = 0,
void update_just_timecode ();
void compute_fixed_ruler_scale (); //calculates the RulerScale of the fixed rulers
void update_fixed_rulers ();
- void update_tempo_based_rulers (ARDOUR::TempoMap::BBTPointList::const_iterator& begin,
+ void update_tempo_based_rulers (ARDOUR::TempoMap::BBTPointList::const_iterator& begin,
ARDOUR::TempoMap::BBTPointList::const_iterator& end);
void popup_ruler_menu (framepos_t where = 0, ItemType type = RegionItem);
void update_ruler_visibility ();
void store_ruler_visibility ();
void restore_ruler_visibility ();
- enum MinsecRulerScale {
+
+
+ enum MinsecRulerScale {
+ minsec_show_msecs,
minsec_show_seconds,
minsec_show_minutes,
minsec_show_hours,
- minsec_show_frames
+ minsec_show_many_hours
};
MinsecRulerScale minsec_ruler_scale;
timecode_show_frames,
timecode_show_seconds,
timecode_show_minutes,
- timecode_show_hours
+ timecode_show_hours,
+ timecode_show_many_hours
};
TimecodeRulerScale timecode_ruler_scale;
void set_samples_ruler_scale (framepos_t, framepos_t);
enum BBTRulerScale {
- bbt_over,
+ bbt_show_many,
bbt_show_64,
bbt_show_16,
bbt_show_4,
gint bbt_nmarks;
uint32_t bbt_bar_helper_on;
uint32_t bbt_accent_modulo;
- void compute_bbt_ruler_scale (framepos_t lower, framepos_t upper,
+ void compute_bbt_ruler_scale (framepos_t lower, framepos_t upper,
ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_begin,
ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_end);
ArdourCanvas::Ruler* samples_ruler;
ArdourCanvas::Ruler* minsec_ruler;
- static const double timebar_height;
+ static double timebar_height;
guint32 visible_timebars;
Gtk::Menu *editor_ruler_menu;
void toggle_ruler_video (bool onoff) {ruler_video_action->set_active(onoff);}
int videotl_bar_height; /* in units of timebar_height; default: 4 */
int get_videotl_bar_height () const { return videotl_bar_height; }
- void export_video (bool range = false);
void toggle_region_video_lock ();
friend class EditorCursor;
void selected_marker_to_selection_end ();
void select_all_selectables_using_cursor (EditorCursor *, bool);
- void select_all_selectables_using_edit (bool);
+ void select_all_selectables_using_edit (bool, bool);
void select_all_selectables_between (bool within);
void select_range_between ();
std::vector<ARDOUR::framepos_t> region_boundary_cache;
void build_region_boundary_cache ();
+ Gtk::HBox toplevel_hpacker;
+
Gtk::HBox top_hbox;
Gtk::HBox bottom_hbox;
/** the adjustment that controls the overall editor vertical scroll position */
Gtk::Adjustment vertical_adjustment;
- Gtk::Adjustment horizontal_adjustment;
+ Gtk::Adjustment horizontal_adjustment;
- Gtk::Adjustment unused_adjustment; // yes, really; Gtk::Layout constructor requires refs
+ Gtk::Adjustment unused_adjustment; // yes, really; Gtk::Layout constructor requires refs
Gtk::Layout controls_layout;
bool control_layout_scroll (GdkEventScroll* ev);
void reset_controls_layout_width ();
static int _idle_visual_changer (void *arg);
int idle_visual_changer ();
- void visual_changer (const VisualChange&);
+ void visual_changer (const VisualChange&);
void ensure_visual_change_idle_handler ();
/* track views */
framepos_t cut_buffer_start;
framecnt_t cut_buffer_length;
- Gdk::Cursor* pre_press_cursor;
+ boost::shared_ptr<CursorContext> _press_cursor_ctx; ///< Button press cursor context
+
boost::weak_ptr<ARDOUR::Trimmable> _trimmable;
boost::weak_ptr<ARDOUR::Movable> _movable;
void register_actions ();
void register_region_actions ();
- void load_bindings ();
- Gtkmm2ext::ActionMap editor_action_map;
- Gtkmm2ext::Bindings key_bindings;
+ void load_bindings ();
+
+ /* CUT/COPY/PASTE */
+
+ framepos_t last_paste_pos;
+ unsigned paste_count;
void cut_copy (Editing::CutCopyOp);
bool can_cut_copy () const;
- void cut_copy_points (Editing::CutCopyOp);
+ void cut_copy_points (Editing::CutCopyOp, Evoral::Beats earliest=Evoral::Beats(), bool midi=false);
void cut_copy_regions (Editing::CutCopyOp, RegionSelection&);
void cut_copy_ranges (Editing::CutCopyOp);
void cut_copy_midi (Editing::CutCopyOp);
void region_fill_track ();
void audition_playlist_region_standalone (boost::shared_ptr<ARDOUR::Region>);
- void audition_playlist_region_via_route (boost::shared_ptr<ARDOUR::Region>, ARDOUR::Route&);
void split_multichannel_region();
void reverse_region ();
void strip_region_silence ();
void reset_region_scale_amplitude ();
void adjust_region_gain (bool up);
void quantize_region ();
+ void quantize_regions (const RegionSelection& rs);
+ void legatize_region (bool shrink_only);
+ void legatize_regions (const RegionSelection& rs, bool shrink_only);
+ void transform_region ();
+ void transform_regions (const RegionSelection& rs);
+ void transpose_region ();
+ void transpose_regions (const RegionSelection& rs);
void insert_patch_change (bool from_context);
void fork_region ();
void do_insert_time ();
void insert_time (framepos_t, framecnt_t, Editing::InsertTimeOption, bool, bool, bool, bool, bool, bool);
+ void do_remove_time ();
+ void remove_time (framepos_t pos, framecnt_t distance, Editing::InsertTimeOption opt, bool ignore_music_glue, bool markers_too,
+ bool glued_markers_too, bool locked_markers_too, bool tempo_too);
+
void tab_to_transient (bool forward);
void set_tempo_from_region ();
void calc_extra_zoom_edges(framepos_t &start, framepos_t &end);
void temporal_zoom_selection (bool both_axes = false);
void temporal_zoom_region (bool both_axes);
- void zoom_to_region (bool both_axes);
void temporal_zoom_session ();
void temporal_zoom (framecnt_t samples_per_pixel);
void temporal_zoom_by_frame (framepos_t start, framepos_t end);
void insert_region_list_selection (float times);
+ /* PT import */
+ void external_pt_dialog ();
+ typedef struct ptflookup {
+ uint16_t index1;
+ uint16_t index2;
+ PBD::ID id;
+
+ bool operator ==(const struct ptflookup& other) {
+ return (this->index1 == other.index1);
+ }
+ } ptflookup_t;
+
/* import & embed */
void add_external_audio_action (Editing::ImportMode);
bool idle_drop_paths (std::vector<std::string> paths, framepos_t frame, double ypos, bool copy);
void drop_paths_part_two (const std::vector<std::string>& paths, framepos_t frame, double ypos, bool copy);
- int import_sndfiles (std::vector<std::string> paths, Editing::ImportDisposition, Editing::ImportMode mode,
- ARDOUR::SrcQuality, framepos_t& pos,
- int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&, bool);
- int embed_sndfiles (std::vector<std::string> paths, bool multiple_files, bool& check_sample_rate,
- Editing::ImportDisposition disposition, Editing::ImportMode mode,
- framepos_t& pos, int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&);
-
- int add_sources (std::vector<std::string> paths, ARDOUR::SourceList& sources, framepos_t& pos,
- Editing::ImportDisposition, Editing::ImportMode,
- int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&, bool add_channel_suffix);
-
- int finish_bringing_in_material (boost::shared_ptr<ARDOUR::Region> region, uint32_t, uint32_t, framepos_t& pos, Editing::ImportMode mode,
- boost::shared_ptr<ARDOUR::Track>& existing_track, const std::string& new_track_name);
+ int import_sndfiles (std::vector<std::string> paths,
+ Editing::ImportDisposition disposition,
+ Editing::ImportMode mode,
+ ARDOUR::SrcQuality quality,
+ framepos_t& pos,
+ int target_regions,
+ int target_tracks,
+ boost::shared_ptr<ARDOUR::Track>& track,
+ bool replace,
+ boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>());
+
+ int embed_sndfiles (std::vector<std::string> paths,
+ bool multiple_files,
+ bool& check_sample_rate,
+ Editing::ImportDisposition disposition,
+ Editing::ImportMode mode,
+ framepos_t& pos,
+ int target_regions,
+ int target_tracks,
+ boost::shared_ptr<ARDOUR::Track>& track,
+ boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>());
+
+ int add_sources (std::vector<std::string> paths,
+ ARDOUR::SourceList& sources,
+ framepos_t& pos,
+ Editing::ImportDisposition disposition,
+ Editing::ImportMode mode,
+ int target_regions,
+ int target_tracks,
+ boost::shared_ptr<ARDOUR::Track>& track,
+ bool add_channel_suffix,
+ boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>());
+
+ int finish_bringing_in_material (boost::shared_ptr<ARDOUR::Region> region,
+ uint32_t in_chans,
+ uint32_t out_chans,
+ framepos_t& pos,
+ Editing::ImportMode mode,
+ boost::shared_ptr<ARDOUR::Track>& existing_track,
+ const std::string& new_track_name,
+ boost::shared_ptr<ARDOUR::PluginInfo> instrument);
boost::shared_ptr<ARDOUR::AudioTrack> get_nth_selected_audio_track (int nth) const;
boost::shared_ptr<ARDOUR::MidiTrack> get_nth_selected_midi_track (int nth) const;
- void toggle_midi_input_active (bool flip_others);
+ void toggle_midi_input_active (bool flip_others);
ARDOUR::InterThreadInfo* current_interthread_info;
void jump_forward_to_mark ();
void jump_backward_to_mark ();
void cursor_align (bool playhead_to_edit);
+ void toggle_skip_playback ();
void remove_last_capture ();
void select_all_selectables_using_time_selection ();
void set_punch_from_selection ();
void set_punch_from_region ();
- void set_loop_from_edit_range (bool play);
+ void set_session_start_from_playhead ();
+ void set_session_end_from_playhead ();
+ void set_session_extents_from_selection ();
+
void set_loop_from_region (bool play);
- void set_punch_from_edit_range ();
void set_loop_range (framepos_t start, framepos_t end, std::string cmd);
void set_punch_range (framepos_t start, framepos_t end, std::string cmd);
int scrub_reverse_distance;
void scrub (framepos_t, double);
- void keyboard_selection_begin ();
- void keyboard_selection_finish (bool add);
+ void set_punch_start_from_edit_point ();
+ void set_punch_end_from_edit_point ();
+ void set_loop_start_from_edit_point ();
+ void set_loop_end_from_edit_point ();
+
+ void keyboard_selection_begin ( Editing::EditIgnoreOption = Editing::EDIT_IGNORE_NONE );
+ void keyboard_selection_finish (bool add, Editing::EditIgnoreOption = Editing::EDIT_IGNORE_NONE);
bool have_pending_keyboard_selection;
framepos_t pending_keyboard_selection_start;
bool canvas_region_view_name_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*);
bool canvas_feature_line_event (GdkEvent* event, ArdourCanvas::Item*, RegionView*);
bool canvas_stream_view_event (GdkEvent* event,ArdourCanvas::Item*, RouteTimeAxisView*);
- bool canvas_marker_event (GdkEvent* event,ArdourCanvas::Item*, Marker*);
- bool canvas_zoom_rect_event (GdkEvent* event,ArdourCanvas::Item*);
+ bool canvas_marker_event (GdkEvent* event,ArdourCanvas::Item*, ArdourMarker*);
bool canvas_tempo_marker_event (GdkEvent* event,ArdourCanvas::Item*, TempoMarker*);
bool canvas_meter_marker_event (GdkEvent* event,ArdourCanvas::Item*, MeterMarker*);
bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, AutomationTimeAxisView*);
ArdourCanvas::Container* time_line_group;
void hide_measures ();
- void draw_measures (ARDOUR::TempoMap::BBTPointList::const_iterator& begin,
+ void draw_measures (ARDOUR::TempoMap::BBTPointList::const_iterator& begin,
ARDOUR::TempoMap::BBTPointList::const_iterator& end);
void new_tempo_section ();
- void mouse_add_new_tempo_event (framepos_t where);
- void mouse_add_new_meter_event (framepos_t where);
void remove_tempo_marker (ArdourCanvas::Item*);
void remove_meter_marker (ArdourCanvas::Item*);
gint real_remove_tempo_marker (ARDOUR::TempoSection*);
gint real_remove_meter_marker (ARDOUR::MeterSection*);
- void edit_tempo_section (ARDOUR::TempoSection*);
- void edit_meter_section (ARDOUR::MeterSection*);
void edit_tempo_marker (TempoMarker&);
void edit_meter_marker (MeterMarker&);
void edit_control_point (ArdourCanvas::Item*);
- void edit_notes (TimeAxisViewItem&);
+ void edit_notes (MidiRegionView*);
void marker_menu_edit ();
void marker_menu_remove ();
void marker_menu_rename ();
- void rename_marker (Marker *marker);
+ void rename_marker (ArdourMarker *marker);
void toggle_marker_menu_lock ();
void toggle_marker_menu_glue ();
void marker_menu_hide ();
Gtk::Menu* cd_marker_menu;
ArdourCanvas::Item* marker_menu_item;
- typedef std::list<Marker*> Marks;
+ typedef std::list<ArdourMarker*> Marks;
Marks metric_marks;
void remove_metric_marks ();
void draw_metric_marks (const ARDOUR::Metrics& metrics);
- void compute_current_bbt_points (framepos_t left, framepos_t right,
+ void compute_current_bbt_points (framepos_t left, framepos_t right,
ARDOUR::TempoMap::BBTPointList::const_iterator& begin,
ARDOUR::TempoMap::BBTPointList::const_iterator& end);
ArdourDropdown visible_tracks_selector;
ArdourDropdown zoom_preset_selector;
- int32_t _visible_track_count;
- void build_track_count_menu ();
- void set_visible_track_count (int32_t);
-
- void set_zoom_preset(int64_t);
+ int32_t _visible_track_count;
+ void build_track_count_menu ();
+ void set_visible_track_count (int32_t);
+
+ void set_zoom_preset(int64_t);
Gtk::VBox toolbar_clock_vbox;
Gtk::VBox toolbar_selection_clock_vbox;
Gtk::Table toolbar_selection_clock_table;
Gtk::Label toolbar_selection_cursor_label;
- Gtkmm2ext::TearOff* _mouse_mode_tearoff;
ArdourButton mouse_select_button;
ArdourButton mouse_draw_button;
ArdourButton mouse_move_button;
- ArdourButton mouse_gain_button;
- ArdourButton mouse_zoom_button;
ArdourButton mouse_timefx_button;
+ ArdourButton mouse_content_button;
ArdourButton mouse_audition_button;
ArdourButton mouse_cut_button;
void mouse_mode_object_range_toggled ();
bool ignore_mouse_mode_toggle;
- ArdourButton internal_edit_button;
- void toggle_internal_editing ();
-
bool mouse_select_button_release (GdkEventButton*);
Gtk::VBox automation_box;
Glib::RefPtr<Gtk::RadioAction> zoom_focus_action (Editing::ZoomFocus);
Gtk::HBox _zoom_box;
- Gtkmm2ext::TearOff* _zoom_tearoff;
void zoom_adjustment_changed();
void setup_toolbar ();
void setup_tooltips ();
- Gtkmm2ext::TearOff* _tools_tearoff;
Gtk::HBox toolbar_hbox;
Gtk::EventBox toolbar_base;
Gtk::Frame toolbar_frame;
Gtk::Viewport _toolbar_viewport;
- /* midi toolbar */
-
- Gtk::HBox panic_box;
-
void setup_midi_toolbar ();
/* selection process */
Selection* selection;
Selection* cut_buffer;
+ SelectionMemento* _selection_memento;
void time_selection_changed ();
- void update_time_selection_display ();
+ void update_time_selection_display ();
void track_selection_changed ();
void region_selection_changed ();
sigc::connection editor_regions_selection_changed_connection;
ArdourCanvas::Rectangle* cd_marker_bar_drag_rect;
ArdourCanvas::Rectangle* range_bar_drag_rect;
ArdourCanvas::Rectangle* transport_bar_drag_rect;
-
-#ifdef GTKOSX
- ArdourCanvas::Rectangle *bogus_background_rect;
-#endif
ArdourCanvas::Rectangle *transport_bar_range_rect;
ArdourCanvas::Rectangle *transport_bar_preroll_rect;
ArdourCanvas::Rectangle *transport_bar_postroll_rect;
ArdourCanvas::Rectangle *rubberband_rect;
- /* mouse zoom process */
-
- ArdourCanvas::Rectangle *zoom_rect;
- void reposition_zoom_rect (framepos_t start, framepos_t end);
-
EditorRouteGroups* _route_groups;
EditorRoutes* _routes;
EditorRegions* _regions;
/* autoscrolling */
- sigc::connection autoscroll_connection;
- bool autoscroll_horizontal_allowed;
- bool autoscroll_vertical_allowed;
- uint32_t autoscroll_cnt;
- Gtk::Widget* autoscroll_widget;
- ArdourCanvas::Rect autoscroll_boundary;
+ sigc::connection autoscroll_connection;
+ bool autoscroll_horizontal_allowed;
+ bool autoscroll_vertical_allowed;
+ uint32_t autoscroll_cnt;
+ Gtk::Widget* autoscroll_widget;
+ ArdourCanvas::Rect autoscroll_boundary;
bool autoscroll_canvas ();
- void start_canvas_autoscroll (bool allow_horiz, bool allow_vert, const ArdourCanvas::Rect& boundary);
+ void start_canvas_autoscroll (bool allow_horiz, bool allow_vert, const ArdourCanvas::Rect& boundary);
void stop_canvas_autoscroll ();
/* trimming */
/* Drag-n-Drop */
int convert_drop_to_paths (
- std::vector<std::string>& paths,
- const Glib::RefPtr<Gdk::DragContext>& context,
- gint x,
- gint y,
- const Gtk::SelectionData& data,
- guint info,
- guint time);
+ std::vector<std::string>& paths,
+ const Glib::RefPtr<Gdk::DragContext>& context,
+ gint x,
+ gint y,
+ const Gtk::SelectionData& data,
+ guint info,
+ guint time);
void track_canvas_drag_data_received (
- const Glib::RefPtr<Gdk::DragContext>& context,
- gint x,
- gint y,
- const Gtk::SelectionData& data,
- guint info,
- guint time);
+ const Glib::RefPtr<Gdk::DragContext>& context,
+ gint x,
+ gint y,
+ const Gtk::SelectionData& data,
+ guint info,
+ guint time);
void drop_paths (
- const Glib::RefPtr<Gdk::DragContext>& context,
- gint x,
- gint y,
- const Gtk::SelectionData& data,
- guint info,
- guint time);
+ const Glib::RefPtr<Gdk::DragContext>& context,
+ gint x,
+ gint y,
+ const Gtk::SelectionData& data,
+ guint info,
+ guint time);
void drop_regions (
- const Glib::RefPtr<Gdk::DragContext>& context,
- gint x,
- gint y,
- const Gtk::SelectionData& data,
- guint info,
- guint time);
+ const Glib::RefPtr<Gdk::DragContext>& context,
+ gint x,
+ gint y,
+ const Gtk::SelectionData& data,
+ guint info,
+ guint time);
void drop_routes (
- const Glib::RefPtr<Gdk::DragContext>& context,
- gint x,
- gint y,
- const Gtk::SelectionData& data,
- guint info,
- guint time);
+ const Glib::RefPtr<Gdk::DragContext>& context,
+ gint x,
+ gint y,
+ const Gtk::SelectionData& data,
+ guint info,
+ guint time);
/* audio export */
void write_selection ();
- XMLNode *before; /* used in *_reversible_command */
+ uint32_t selection_op_cmd_depth;
+ uint32_t selection_op_history_it;
+
+ std::list<XMLNode *> selection_op_history; /* used in *_reversible_selection_op */
+ std::list<XMLNode *> before; /* used in *_reversible_command */
void update_title ();
void update_title_s (const std::string & snapshot_name);
void duplicate_range (bool with_dialog);
- /** computes the timeline frame (sample) of an event whose coordinates
+ /** computes the timeline frame (sample) of an event whose coordinates
* are in canvas units (pixels, scroll offset included).
*/
framepos_t canvas_event_sample (GdkEvent const *, double* px = 0, double* py = 0) const;
- /** computes the timeline frame (sample) of an event whose coordinates
+ /** computes the timeline frame (sample) of an event whose coordinates
* are in window units (pixels, no scroll offset).
*/
framepos_t window_event_sample (GdkEvent const *, double* px = 0, double* py = 0) const;
int pitch_shift (RegionSelection&, float cents);
void pitch_shift_region ();
- void transpose_region ();
-
/* editor-mixer strip */
MixerStrip *current_mixer_strip;
void cms_new (boost::shared_ptr<ARDOUR::Route>);
void current_mixer_strip_hidden ();
- void detach_tearoff (Gtk::Box* b, Gtk::Window* w);
- void reattach_tearoff (Gtk::Box* b, Gtk::Window* w, int32_t n);
#ifdef GTKOSX
void ensure_all_elements_drawn ();
#endif
void apply_filter (ARDOUR::Filter&, std::string cmd, ProgressReporter* progress = 0);
Command* apply_midi_note_edit_op_to_region (ARDOUR::MidiOperator& op, MidiRegionView& mrv);
- void apply_midi_note_edit_op (ARDOUR::MidiOperator& op);
+ void apply_midi_note_edit_op (ARDOUR::MidiOperator& op, const RegionSelection& rs);
/* handling cleanup */
*/
RegionView* entered_regionview;
+ std::vector<EnterContext> _enter_stack;
+
bool clear_entered_track;
bool left_track_canvas (GdkEventCrossing*);
bool entered_track_canvas (GdkEventCrossing*);
void toggle_gain_envelope_active ();
void reset_region_gain_envelopes ();
- bool on_key_press_event (GdkEventKey*);
- bool on_key_release_event (GdkEventKey*);
-
void session_state_saved (std::string);
Glib::RefPtr<Gtk::Action> undo_action;
Glib::RefPtr<Gtk::Action> redo_action;
+ Glib::RefPtr<Gtk::Action> alternate_redo_action;
+ Glib::RefPtr<Gtk::Action> alternate_alternate_redo_action;
+ Glib::RefPtr<Gtk::Action> selection_undo_action;
+ Glib::RefPtr<Gtk::Action> selection_redo_action;
void history_changed ();
- Gtk::HBox status_bar_hpacker;
-
Editing::EditPoint _edit_point;
ArdourDropdown edit_point_selector;
void select_next_route ();
void select_prev_route ();
- void snap_to_internal (framepos_t& first, int32_t direction = 0, bool for_mark = false);
- void timecode_snap_to_internal (framepos_t& first, int32_t direction = 0, bool for_mark = false);
+ void snap_to_internal (framepos_t& first,
+ ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
+ bool for_mark = false,
+ bool ensure_snap = false);
+
+ void timecode_snap_to_internal (framepos_t& first,
+ ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
+ bool for_mark = false);
RhythmFerret* rhythm_ferret;
void fit_tracks (TrackViewList &);
- void fit_selected_tracks ();
+ void fit_selection ();
void set_track_height (Height);
- void remove_tracks ();
+ void _remove_tracks ();
+ bool idle_remove_tracks ();
void toggle_tracks_active ();
bool _have_idled;
bool _following_mixer_selection;
int time_fx (ARDOUR::RegionList&, float val, bool pitching);
- void note_edit_done (int, EditNoteDialog*);
+ void note_edit_done (int, EditNoteDialog*);
void toggle_sound_midi_notes ();
/** Flag for a bit of a hack wrt control point selection; see set_selected_control_point_from_click */
void update_bring_in_message (Gtk::Label* label, uint32_t n, uint32_t total, std::string name);
void bring_all_sources_into_session ();
+ QuantizeDialog* quantize_dialog;
+ MainMenuDisabler* _main_menu_disabler;
+
+ /* private helper functions to help with registering axis */
+
+ Glib::RefPtr<Gtk::Action> reg_sens (Glib::RefPtr<Gtk::ActionGroup> group, char const * name, char const * label, sigc::slot<void> slot);
+ void toggle_reg_sens (Glib::RefPtr<Gtk::ActionGroup> group, char const * name, char const * label, sigc::slot<void> slot);
+ void radio_reg_sens (Glib::RefPtr<Gtk::ActionGroup> action_group, Gtk::RadioAction::Group& radio_group, char const * name, char const * label, sigc::slot<void> slot);
+
friend class Drag;
friend class RegionDrag;
friend class RegionMoveDrag;
projects / ardour.git / blobdiff