1 /* 2 * Copyright (C) 2005-2006 Taybin Rutkin <taybin@taybin.com> 3 * Copyright (C) 2005-2007 Doug McLain <doug@nostar.net> 4 * Copyright (C) 2005-2018 Paul Davis <paul@linuxaudiosystems.com> 5 * Copyright (C) 2005 Karsten Wiese <fzuuzf@googlemail.com> 6 * Copyright (C) 2006-2009 Sampo Savolainen <v2@iki.fi> 7 * Copyright (C) 2006-2015 David Robillard <d@drobilla.net> 8 * Copyright (C) 2006-2017 Tim Mayberry <mojofunk@gmail.com> 9 * Copyright (C) 2007-2012 Carl Hetherington <carl@carlh.net> 10 * Copyright (C) 2008-2011 Sakari Bergen <sakari.bergen@beatwaves.net> 11 * Copyright (C) 2008 Hans Baier <hansfbaier@googlemail.com> 12 * Copyright (C) 2013-2015 Colin Fletcher <colin.m.fletcher@googlemail.com> 13 * Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org> 14 * Copyright (C) 2014-2017 Nick Mainsbridge <mainsbridge@gmail.com> 15 * Copyright (C) 2014-2019 Ben Loftis <ben@harrisonconsoles.com> 16 * Copyright (C) 2015-2019 Damien Zammit <damien@zamaudio.com> 17 * Copyright (C) 2015 André Nusser <andre.nusser@googlemail.com> 18 * 19 * This program is free software; you can redistribute it and/or modify 20 * it under the terms of the GNU General Public License as published by 21 * the Free Software Foundation; either version 2 of the License, or 22 * (at your option) any later version. 23 * 24 * This program is distributed in the hope that it will be useful, 25 * but WITHOUT ANY WARRANTY; without even the implied warranty of 26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 27 * GNU General Public License for more details. 28 * 29 * You should have received a copy of the GNU General Public License along 30 * with this program; if not, write to the Free Software Foundation, Inc., 31 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 32 */ 33 34 #ifndef __ardour_editor_h__ 35 #define __ardour_editor_h__ 36 37 #include <sys/time.h> 38 39 #include <cmath> 40 #include <list> 41 #include <map> 42 #include <set> 43 #include <string> 44 #include <vector> 45 46 #include <boost/optional.hpp> 47 48 #include <gtkmm/comboboxtext.h> 49 #include <gtkmm/layout.h> 50 51 #include "gtkmm2ext/bindings.h" 52 #include "gtkmm2ext/dndtreeview.h" 53 54 #include "pbd/stateful.h" 55 #include "pbd/signals.h" 56 57 #include "ardour/import_status.h" 58 #include "ardour/tempo.h" 59 #include "ardour/location.h" 60 #include "ardour/types.h" 61 62 #include "canvas/fwd.h" 63 #include "canvas/ruler.h" 64 65 #include "widgets/ardour_button.h" 66 #include "widgets/ardour_dropdown.h" 67 #include "widgets/pane.h" 68 69 #include "ardour_dialog.h" 70 #include "public_editor.h" 71 #include "editing.h" 72 #include "enums.h" 73 #include "editor_items.h" 74 #include "region_selection.h" 75 #include "selection_memento.h" 76 #include "tempo_curve.h" 77 78 #include "ptformat/ptformat.h" 79 80 namespace Gtkmm2ext { 81 class Bindings; 82 } 83 84 namespace Evoral { 85 class SMF; 86 } 87 88 namespace ARDOUR { 89 class AudioPlaylist; 90 class AudioRegion; 91 class AudioTrack; 92 class ChanCount; 93 class Filter; 94 class Location; 95 class MidiOperator; 96 class MidiRegion; 97 class MidiTrack; 98 class Playlist; 99 class Region; 100 class RouteGroup; 101 class Session; 102 class TempoSection; 103 class Track; 104 } 105 106 namespace LADSPA { 107 class Plugin; 108 } 109 110 class AnalysisWindow; 111 class AudioClock; 112 class AudioRegionView; 113 class AudioStreamView; 114 class AudioTimeAxisView; 115 class AutomationLine; 116 class AutomationSelection; 117 class AutomationTimeAxisView; 118 class BundleManager; 119 class ControlPoint; 120 class CursorContext; 121 class DragManager; 122 class EditNoteDialog; 123 class EditorCursor; 124 class EditorGroupTabs; 125 class EditorLocations; 126 class EditorRegions; 127 class EditorSources; 128 class EditorRoutes; 129 class EditorRouteGroups; 130 class EditorSnapshots; 131 class EditorSummary; 132 class GUIObjectState; 133 class ArdourMarker; 134 class MidiRegionView; 135 class MidiExportDialog; 136 class MixerStrip; 137 class MouseCursors; 138 class NoteBase; 139 class PluginSelector; 140 class ProgressReporter; 141 class QuantizeDialog; 142 class RegionPeakCursor; 143 class RhythmFerret; 144 class RulerDialog; 145 class Selection; 146 class SoundFileOmega; 147 class StreamView; 148 class GridLines; 149 class TempoLines; 150 class TimeAxisView; 151 class TimeInfoBox; 152 class TimeFXDialog; 153 class TimeSelection; 154 class RegionLayeringOrderEditor; 155 class VerboseCursor; 156 157 class Editor : public PublicEditor, public PBD::ScopedConnectionList 158 { 159 public: 160 Editor (); 161 ~Editor (); 162 163 void set_session (ARDOUR::Session*); 164 165 Gtk::Window* use_own_window (bool and_fill_it); 166 167 void first_idle (); have_idled()168 virtual bool have_idled () const { return _have_idled; } 169 pending_locate_request()170 bool pending_locate_request() const { return _pending_locate_request; } 171 leftmost_sample()172 samplepos_t leftmost_sample() const { return _leftmost_sample; } 173 current_page_samples()174 samplecnt_t current_page_samples() const { 175 return (samplecnt_t) _visible_canvas_width* samples_per_pixel; 176 } 177 visible_canvas_height()178 double visible_canvas_height () const { 179 return _visible_canvas_height; 180 } 181 double trackviews_height () const; 182 183 void cycle_snap_mode (); 184 void next_grid_choice (); 185 void prev_grid_choice (); 186 void set_grid_to (Editing::GridType); 187 void set_snap_mode (Editing::SnapMode); 188 189 Editing::SnapMode snap_mode () const; 190 Editing::GridType grid_type () const; 191 bool grid_type_is_musical (Editing::GridType) const; 192 bool grid_musical () const; 193 194 void undo (uint32_t n = 1); 195 void redo (uint32_t n = 1); 196 197 XMLNode& get_state (); 198 int set_state (const XMLNode&, int version); 199 200 void set_mouse_mode (Editing::MouseMode, bool force = false); 201 void step_mouse_mode (bool next); current_mouse_mode()202 Editing::MouseMode current_mouse_mode () const { return mouse_mode; } 203 Editing::MidiEditMode current_midi_edit_mode () const; 204 void remove_midi_note (ArdourCanvas::Item*, GdkEvent*); 205 206 bool internal_editing() const; 207 208 void foreach_time_axis_view (sigc::slot<void,TimeAxisView&>); 209 void add_to_idle_resize (TimeAxisView*, int32_t); 210 211 StripableTimeAxisView* get_stripable_time_axis_by_id (const PBD::ID& id) const; 212 213 void consider_auditioning (boost::shared_ptr<ARDOUR::Region>); 214 void hide_a_region (boost::shared_ptr<ARDOUR::Region>); 215 void show_a_region (boost::shared_ptr<ARDOUR::Region>); 216 217 #ifdef USE_RUBBERBAND 218 std::vector<std::string> rb_opt_strings; 219 int rb_current_opt; 220 #endif 221 222 /* things that need to be public to be used in the main menubar */ 223 224 void new_region_from_selection (); 225 void separate_regions_between (const TimeSelection&); 226 void separate_region_from_selection (); 227 void separate_under_selected_regions (); 228 void separate_region_from_punch (); 229 void separate_region_from_loop (); 230 void separate_regions_using_location (ARDOUR::Location&); 231 void transition_to_rolling (bool forward); 232 233 /* NOTE: these functions assume that the "pixel" coordinate is 234 in canvas coordinates. These coordinates already take into 235 account any scrolling offsets. 236 */ 237 pixel_to_sample_from_event(double pixel)238 samplepos_t pixel_to_sample_from_event (double pixel) const { 239 240 /* pixel can be less than zero when motion events 241 are processed. since we've already run the world->canvas 242 affine, that means that the location *really* is "off 243 to the right" and thus really is "before the start". 244 */ 245 246 if (pixel >= 0) { 247 return pixel * samples_per_pixel; 248 } else { 249 return 0; 250 } 251 } 252 pixel_to_sample(double pixel)253 samplepos_t pixel_to_sample (double pixel) const { 254 return pixel * samples_per_pixel; 255 } 256 sample_to_pixel(samplepos_t sample)257 double sample_to_pixel (samplepos_t sample) const { 258 return round (sample / (double) samples_per_pixel); 259 } 260 sample_to_pixel_unrounded(samplepos_t sample)261 double sample_to_pixel_unrounded (samplepos_t sample) const { 262 return sample / (double) samples_per_pixel; 263 } 264 265 /* selection */ 266 get_selection()267 Selection& get_selection() const { return *selection; } 268 bool get_selection_extents (samplepos_t &start, samplepos_t &end) const; // the time extents of the current selection, whether Range, Region(s), Control Points, or Notes get_cut_buffer()269 Selection& get_cut_buffer() const { return *cut_buffer; } 270 271 void set_selection (std::list<Selectable*>, Selection::Operation); 272 void set_selected_midi_region_view (MidiRegionView&); 273 274 bool extend_selection_to_track (TimeAxisView&); 275 276 void play_selection (); 277 void maybe_locate_with_edit_preroll (samplepos_t); 278 void play_with_preroll (); 279 void rec_with_preroll (); 280 void rec_with_count_in (); 281 void select_all_in_track (Selection::Operation op); 282 void select_all_objects (Selection::Operation op); 283 void invert_selection_in_track (); 284 void invert_selection (); 285 void deselect_all (); 286 long select_range (samplepos_t, samplepos_t); 287 288 void set_selected_regionview_from_region_list (boost::shared_ptr<ARDOUR::Region> region, Selection::Operation op = Selection::Set); 289 290 void remove_tracks (); 291 292 /* tempo */ 293 294 void update_grid (); 295 296 /* analysis window */ 297 298 void loudness_analyze_region_selection(); 299 void loudness_analyze_range_selection(); 300 301 void spectral_analyze_region_selection(); 302 void spectral_analyze_range_selection(); 303 304 /* export */ 305 306 void export_audio (); 307 void stem_export (); 308 void export_selection (); 309 void export_range (); 310 void export_region (); 311 312 /* export for analysis only */ 313 void loudness_assistant (bool); 314 void loudness_assistant_marker (); 315 void measure_master_loudness (samplepos_t start, samplepos_t end, bool); 316 317 bool process_midi_export_dialog (MidiExportDialog& dialog, boost::shared_ptr<ARDOUR::MidiRegion> midi_region); 318 319 void set_zoom_focus (Editing::ZoomFocus); get_zoom_focus()320 Editing::ZoomFocus get_zoom_focus () const { return zoom_focus; } get_current_zoom()321 samplecnt_t get_current_zoom () const { return samples_per_pixel; } 322 void cycle_zoom_focus (); 323 void temporal_zoom_step (bool zoom_out); 324 void temporal_zoom_step_scale (bool zoom_out, double scale); 325 void temporal_zoom_step_mouse_focus (bool zoom_out); 326 void temporal_zoom_step_mouse_focus_scale (bool zoom_out, double scale); 327 void ensure_time_axis_view_is_visible (TimeAxisView const & tav, bool at_top); 328 void tav_zoom_step (bool coarser); 329 void tav_zoom_smooth (bool coarser, bool force_all); 330 331 /* stuff that AudioTimeAxisView and related classes use */ 332 333 void clear_playlist (boost::shared_ptr<ARDOUR::Playlist>); 334 335 void clear_grouped_playlists (RouteUI* v); 336 337 void get_onscreen_tracks (TrackViewList&); 338 339 Width editor_mixer_strip_width; 340 void maybe_add_mixer_strip_width (XMLNode&); 341 void show_editor_mixer (bool yn); 342 void create_editor_mixer (); 343 void show_editor_list (bool yn); 344 void set_selected_mixer_strip (TimeAxisView&); 345 void mixer_strip_width_changed (); 346 void hide_track_in_display (TimeAxisView* tv, bool apply_to_selection = false); 347 void show_track_in_display (TimeAxisView* tv, bool move_into_view = false); 348 void tempo_curve_selected (ARDOUR::TempoSection* ts, bool yn); 349 350 /* nudge is initiated by transport controls owned by ARDOUR_UI */ 351 352 samplecnt_t get_nudge_distance (samplepos_t pos, samplecnt_t& next); 353 samplecnt_t get_paste_offset (samplepos_t pos, unsigned paste_count, samplecnt_t duration); 354 unsigned get_grid_beat_divisions(samplepos_t position); 355 Temporal::Beats get_grid_type_as_beats (bool& success, samplepos_t position); 356 357 int32_t get_grid_music_divisions (uint32_t event_state); 358 359 void nudge_forward (bool next, bool force_playhead); 360 void nudge_backward (bool next, bool force_playhead); 361 362 /* nudge initiated from context menu */ 363 364 void nudge_forward_capture_offset (); 365 void nudge_backward_capture_offset (); 366 367 void sequence_regions (); 368 369 /* playhead/screen stuff */ 370 371 void set_stationary_playhead (bool yn); 372 void toggle_stationary_playhead (); stationary_playhead()373 bool stationary_playhead() const { return _stationary_playhead; } 374 375 void set_follow_playhead (bool yn, bool catch_up = true); 376 void toggle_follow_playhead (); follow_playhead()377 bool follow_playhead() const { return _follow_playhead; } dragging_playhead()378 bool dragging_playhead () const { return _dragging_playhead; } 379 380 void toggle_zero_line_visibility (); 381 void set_summary (); 382 void set_group_tabs (); 383 384 /* returns the left-most and right-most time that the gui should allow the user to scroll to */ 385 std::pair <samplepos_t,samplepos_t> session_gui_extents (bool use_extra = true) const; 386 387 /* RTAV Automation display option */ 388 bool show_touched_automation () const; 389 390 /* fades */ 391 392 void toggle_region_fades (int dir); 393 void update_region_fade_visibility (); 394 395 /* floating windows/transient */ 396 397 void ensure_float (Gtk::Window&); 398 399 void scroll_tracks_down_line (); 400 void scroll_tracks_up_line (); 401 402 bool scroll_up_one_track (bool skip_child_views = false); 403 bool scroll_down_one_track (bool skip_child_views = false); 404 405 void scroll_left_step (); 406 void scroll_right_step (); 407 408 void scroll_left_half_page (); 409 void scroll_right_half_page (); 410 411 void select_topmost_track (); 412 413 void cleanup_regions (); 414 415 void prepare_for_cleanup (); 416 void finish_cleanup (); 417 418 void maximise_editing_space(); 419 void restore_editing_space(); 420 421 double get_y_origin () const; 422 void reset_x_origin (samplepos_t); 423 void reset_x_origin_to_follow_playhead (); 424 void reset_y_origin (double); 425 void reset_zoom (samplecnt_t); 426 void reposition_and_zoom (samplepos_t, double); 427 428 samplepos_t get_preferred_edit_position (Editing::EditIgnoreOption = Editing::EDIT_IGNORE_NONE, 429 bool use_context_click = false, 430 bool from_outside_canvas = false); 431 432 bool update_mouse_speed (); 433 bool decelerate_mouse_speed (); 434 435 void toggle_meter_updating(); 436 437 void show_rhythm_ferret(); 438 439 void goto_visual_state (uint32_t); 440 void save_visual_state (uint32_t); 441 442 void queue_draw_resize_line (int at); 443 void start_resize_line_ops (); 444 void end_resize_line_ops (); 445 get_track_views()446 TrackViewList const & get_track_views () const { 447 return track_views; 448 } 449 450 void do_ptimport(std::string path, ARDOUR::SrcQuality quality); 451 452 void do_import (std::vector<std::string> paths, 453 Editing::ImportDisposition disposition, 454 Editing::ImportMode mode, 455 ARDOUR::SrcQuality quality, 456 ARDOUR::MidiTrackNameSource mts, 457 ARDOUR::MidiTempoMapDisposition mtd, 458 samplepos_t& pos, 459 boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>(), 460 bool with_markers = false 461 ); 462 463 void do_embed (std::vector<std::string> paths, 464 Editing::ImportDisposition disposition, 465 Editing::ImportMode mode, 466 samplepos_t& pos, 467 boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>()); 468 469 void get_regionview_corresponding_to (boost::shared_ptr<ARDOUR::Region> region, std::vector<RegionView*>& regions); 470 471 void get_regionviews_by_id (PBD::ID const id, RegionSelection & regions) const; 472 void get_per_region_note_selection (std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > >&) const; 473 474 void center_screen (samplepos_t); 475 476 TrackViewList axis_views_from_routes (boost::shared_ptr<ARDOUR::RouteList>) const; 477 478 void snap_to (ARDOUR::MusicSample& first, 479 ARDOUR::RoundMode direction = ARDOUR::RoundNearest, 480 ARDOUR::SnapPref pref = ARDOUR::SnapToAny_Visual, 481 bool ensure_snap = false); 482 483 void snap_to_with_modifier (ARDOUR::MusicSample& first, 484 GdkEvent const* ev, 485 ARDOUR::RoundMode direction = ARDOUR::RoundNearest, 486 ARDOUR::SnapPref pref = ARDOUR::SnapToAny_Visual); 487 488 void set_snapped_cursor_position (samplepos_t pos); 489 490 void begin_selection_op_history (); 491 void begin_reversible_selection_op (std::string cmd_name); 492 void commit_reversible_selection_op (); 493 void undo_selection_op (); 494 void redo_selection_op (); 495 void begin_reversible_command (std::string cmd_name); 496 void begin_reversible_command (GQuark); 497 void abort_reversible_command (); 498 void commit_reversible_command (); 499 get_current_mixer_strip()500 MixerStrip* get_current_mixer_strip () const { 501 return current_mixer_strip; 502 } 503 drags()504 DragManager* drags () const { 505 return _drags; 506 } 507 508 bool drag_active () const; 509 bool preview_video_drag_active () const; 510 511 void maybe_autoscroll (bool, bool, bool); 512 bool autoscroll_active() const; 513 514 Gdk::Cursor* get_canvas_cursor () const; 515 516 void set_current_trimmable (boost::shared_ptr<ARDOUR::Trimmable>); 517 void set_current_movable (boost::shared_ptr<ARDOUR::Movable>); 518 cursors()519 MouseCursors const* cursors () const { 520 return _cursors; 521 } 522 verbose_cursor()523 VerboseCursor* verbose_cursor () const { 524 return _verbose_cursor; 525 } 526 527 double clamp_verbose_cursor_x (double); 528 double clamp_verbose_cursor_y (double); 529 530 void get_pointer_position (double &, double &) const; 531 532 /** Context for mouse entry (stored in a stack). */ 533 struct EnterContext { 534 ItemType item_type; 535 boost::shared_ptr<CursorContext> cursor_ctx; 536 }; 537 538 /** Get the topmost enter context for the given item type. 539 * 540 * This is used to change the cursor associated with a given enter context, 541 * which may not be on the top of the stack. 542 */ 543 EnterContext* get_enter_context(ItemType type); 544 stepping_axis_view()545 TimeAxisView* stepping_axis_view () { 546 return _stepping_axis_view; 547 } 548 set_stepping_axis_view(TimeAxisView * v)549 void set_stepping_axis_view (TimeAxisView* v) { 550 _stepping_axis_view = v; 551 } 552 get_trackview_group()553 ArdourCanvas::Container* get_trackview_group () const { return _trackview_group; } get_noscroll_group()554 ArdourCanvas::Container* get_noscroll_group () const { return no_scroll_group; } get_hscroll_group()555 ArdourCanvas::ScrollGroup* get_hscroll_group () const { return h_scroll_group; } get_hvscroll_group()556 ArdourCanvas::ScrollGroup* get_hvscroll_group () const { return hv_scroll_group; } get_cursor_scroll_group()557 ArdourCanvas::ScrollGroup* get_cursor_scroll_group () const { return cursor_scroll_group; } get_drag_motion_group()558 ArdourCanvas::Container* get_drag_motion_group () const { return _drag_motion_group; } 559 560 ArdourCanvas::GtkCanvasViewport* get_track_canvas () const; 561 562 void override_visible_track_count (); 563 564 /* Ruler metrics methods */ 565 566 void metric_get_timecode (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint); 567 void metric_get_bbt (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint); 568 void metric_get_samples (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint); 569 void metric_get_minsec (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint); 570 571 /* editing operations that need to be public */ 572 void mouse_add_new_marker (samplepos_t where, bool is_cd=false); 573 void split_regions_at (ARDOUR::MusicSample, RegionSelection&); 574 void split_region_at_points (boost::shared_ptr<ARDOUR::Region>, ARDOUR::AnalysisFeatureList&, bool can_ferret, bool select_new = false); 575 RegionSelection get_regions_from_selection_and_mouse (samplepos_t); 576 void do_remove_gaps (); 577 void remove_gaps (samplecnt_t threshold, samplecnt_t leave, bool markers_too); 578 579 void mouse_brush_insert_region (RegionView*, samplepos_t pos); 580 581 void mouse_add_new_tempo_event (samplepos_t where); 582 void mouse_add_new_meter_event (samplepos_t where); 583 void edit_tempo_section (ARDOUR::TempoSection*); 584 void edit_meter_section (ARDOUR::MeterSection*); 585 586 void add_region_marker (); 587 void clear_region_markers (); 588 void remove_region_marker (ARDOUR::CueMarker&); 589 void make_region_markers_global (bool as_cd_markers); 590 591 protected: 592 void map_transport_state (); 593 void map_position_change (samplepos_t); 594 void transport_looped (); 595 596 void on_realize(); 597 598 void suspend_route_redisplay (); 599 void resume_route_redisplay (); 600 601 private: 602 603 void color_handler (); 604 605 bool constructed; 606 607 // to keep track of the playhead position for control_scroll 608 boost::optional<samplepos_t> _control_scroll_target; 609 610 TimeInfoBox* _time_info_box; 611 612 typedef std::pair<TimeAxisView*,XMLNode*> TAVState; 613 614 struct VisualState { 615 VisualState (bool with_tracks); 616 ~VisualState (); 617 double y_position; 618 samplecnt_t samples_per_pixel; 619 samplepos_t _leftmost_sample; 620 Editing::ZoomFocus zoom_focus; 621 GUIObjectState* gui_state; 622 }; 623 624 std::list<VisualState*> undo_visual_stack; 625 std::list<VisualState*> redo_visual_stack; 626 VisualState* current_visual_state (bool with_tracks = true); 627 void undo_visual_state (); 628 void redo_visual_state (); 629 void use_visual_state (VisualState&); 630 bool no_save_visual; 631 void swap_visual_state (); 632 633 std::vector<VisualState*> visual_states; 634 void start_visual_state_op (uint32_t n); 635 void cancel_visual_state_op (uint32_t n); 636 637 samplepos_t _leftmost_sample; 638 samplecnt_t samples_per_pixel; 639 Editing::ZoomFocus zoom_focus; 640 641 void set_samples_per_pixel (samplecnt_t); 642 void on_samples_per_pixel_changed (); 643 644 Editing::MouseMode mouse_mode; 645 Editing::GridType pre_internal_grid_type; 646 Editing::SnapMode pre_internal_snap_mode; 647 Editing::GridType internal_grid_type; 648 Editing::SnapMode internal_snap_mode; 649 Editing::MouseMode effective_mouse_mode () const; 650 651 enum JoinObjectRangeState { 652 JOIN_OBJECT_RANGE_NONE, 653 /** `join object/range' mode is active and the mouse is over a place where object mode should happen */ 654 JOIN_OBJECT_RANGE_OBJECT, 655 /** `join object/range' mode is active and the mouse is over a place where range mode should happen */ 656 JOIN_OBJECT_RANGE_RANGE 657 }; 658 659 JoinObjectRangeState _join_object_range_state; 660 661 void update_join_object_range_location (double); 662 663 boost::optional<float> pre_notebook_shrink_pane_width; 664 665 Gtk::VBox _editor_list_vbox; 666 Gtk::Notebook _the_notebook; 667 bool _notebook_shrunk; 668 void add_notebook_page (std::string const&, Gtk::Widget&); 669 bool notebook_tab_clicked (GdkEventButton*, Gtk::Widget*); 670 671 ArdourWidgets::HPane edit_pane; 672 ArdourWidgets::VPane editor_summary_pane; 673 674 Gtk::EventBox meter_base; 675 Gtk::EventBox marker_base; 676 Gtk::HBox marker_box; 677 Gtk::VBox scrollers_rulers_markers_box; 678 679 void location_changed (ARDOUR::Location*); 680 void location_flags_changed (ARDOUR::Location*); 681 void refresh_location_display (); 682 void refresh_location_display_internal (const ARDOUR::Locations::LocationList&); 683 void add_new_location (ARDOUR::Location*); 684 ArdourCanvas::Container* add_new_location_internal (ARDOUR::Location*); 685 void location_gone (ARDOUR::Location*); 686 void remove_marker (ArdourCanvas::Item&); 687 void remove_marker (ArdourMarker*); 688 gint really_remove_global_marker (ARDOUR::Location* loc); 689 gint really_remove_region_marker (ArdourMarker*); 690 void goto_nth_marker (int nth); 691 void trigger_script (int nth); 692 void trigger_script_by_name (const std::string script_name); 693 void toggle_marker_lines (); 694 void set_marker_line_visibility (bool); 695 696 void jump_forward_to_mark (); 697 void jump_backward_to_mark (); 698 699 uint32_t location_marker_color; 700 uint32_t location_range_color; 701 uint32_t location_loop_color; 702 uint32_t location_punch_color; 703 uint32_t location_cd_marker_color; 704 705 struct LocationMarkers { 706 ArdourMarker* start; 707 ArdourMarker* end; 708 bool valid; 709 LocationMarkersLocationMarkers710 LocationMarkers () : start(0), end(0), valid (true) {} 711 712 ~LocationMarkers (); 713 714 void hide (); 715 void show (); 716 717 void set_show_lines (bool); 718 void set_selected (bool); 719 void set_entered (bool); 720 void setup_lines (); 721 722 void set_name (const std::string&); 723 void set_position (samplepos_t start, samplepos_t end = 0); 724 void set_color_rgba (uint32_t); 725 }; 726 727 LocationMarkers* find_location_markers (ARDOUR::Location*) const; 728 ARDOUR::Location* find_location_from_marker (ArdourMarker*, bool& is_start) const; 729 ArdourMarker* find_marker_from_location_id (PBD::ID const&, bool) const; 730 ArdourMarker* entered_marker; 731 bool _show_marker_lines; 732 733 typedef std::map<ARDOUR::Location*,LocationMarkers*> LocationMarkerMap; 734 LocationMarkerMap location_markers; 735 736 void update_marker_labels (); 737 void update_marker_labels (ArdourCanvas::Container*); 738 void check_marker_label (ArdourMarker*); 739 740 /** A set of lists of Markers that are in each of the canvas groups 741 * for the marker sections at the top of the editor. These lists 742 * are kept sorted in time order between marker movements, so that after 743 * a marker has moved we can decide whether we need to update the labels 744 * for all markers or for just a few. 745 */ 746 std::map<ArdourCanvas::Container*, std::list<ArdourMarker*> > _sorted_marker_lists; 747 void remove_sorted_marker (ArdourMarker*); 748 749 void hide_marker (ArdourCanvas::Item*, GdkEvent*); 750 void clear_marker_display (); 751 void mouse_add_new_range (samplepos_t); 752 void mouse_add_new_loop (samplepos_t); 753 void mouse_add_new_punch (samplepos_t); 754 bool choose_new_marker_name(std::string &name, bool is_range=false); 755 void update_cd_marker_display (); 756 void ensure_cd_marker_updated (LocationMarkers* lam, ARDOUR::Location* location); 757 758 TimeAxisView* clicked_axisview; 759 RouteTimeAxisView* clicked_routeview; 760 /** The last RegionView that was clicked on, or 0 if the last click was not 761 * on a RegionView. This is set up by the canvas event handlers in 762 * editor_canvas_events.cc 763 */ 764 RegionView* clicked_regionview; 765 RegionSelection latest_regionviews; 766 uint32_t clicked_selection; 767 ControlPoint* clicked_control_point; 768 769 void sort_track_selection (TrackViewList&); 770 771 void get_equivalent_regions (RegionView* rv, std::vector<RegionView*> &, PBD::PropertyID) const; 772 RegionSelection get_equivalent_regions (RegionSelection &, PBD::PropertyID) const; 773 RegionView* regionview_from_region (boost::shared_ptr<ARDOUR::Region>) const; 774 RouteTimeAxisView* rtav_from_route (boost::shared_ptr<ARDOUR::Route>) const; 775 776 void mapover_tracks_with_unique_playlists (sigc::slot<void,RouteTimeAxisView&,uint32_t> sl, TimeAxisView*, PBD::PropertyID) const; 777 void mapped_get_equivalent_regions (RouteTimeAxisView&, uint32_t, RegionView*, std::vector<RegionView*>*) const; 778 779 void mapover_grouped_routes (sigc::slot<void, RouteUI&> sl, RouteUI*, PBD::PropertyID) const; 780 void mapover_armed_routes (sigc::slot<void, RouteUI&> sl) const; 781 void mapover_selected_routes (sigc::slot<void, RouteUI&> sl) const; 782 void mapover_all_routes (sigc::slot<void, RouteUI&> sl) const; 783 784 void mapped_use_new_playlist (RouteUI&, std::string name, std::string gid, bool copy, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &); 785 void mapped_clear_playlist (RouteUI&); 786 787 void new_playlists_for_all_tracks(bool copy); 788 void new_playlists_for_grouped_tracks(RouteUI* v, bool copy); 789 void new_playlists_for_selected_tracks(bool copy); 790 void new_playlists_for_armed_tracks(bool copy); 791 792 void button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type); 793 bool button_release_can_deselect; 794 bool _mouse_changed_selection; 795 796 void catch_vanishing_regionview (RegionView*); 797 798 void set_selected_track (TimeAxisView&, Selection::Operation op = Selection::Set, bool no_remove=false); 799 void select_all_visible_lanes (); 800 void select_all_tracks (); 801 bool select_all_internal_edit (Selection::Operation); 802 803 bool set_selected_control_point_from_click (bool press, Selection::Operation op = Selection::Set); 804 void set_selected_track_from_click (bool press, Selection::Operation op = Selection::Set, bool no_remove=false); 805 void set_selected_track_as_side_effect (Selection::Operation op); 806 bool set_selected_regionview_from_click (bool press, Selection::Operation op = Selection::Set); 807 808 bool set_selected_regionview_from_map_event (GdkEventAny*, StreamView*, boost::weak_ptr<ARDOUR::Region>); 809 void collect_new_region_view (RegionView*); 810 void collect_and_select_new_region_view (RegionView*); 811 812 Gtk::Menu track_context_menu; 813 Gtk::Menu track_region_context_menu; 814 Gtk::Menu track_selection_context_menu; 815 816 GdkEvent context_click_event; 817 818 void popup_track_context_menu (int, int, ItemType, bool); 819 Gtk::Menu* build_track_context_menu (); 820 Gtk::Menu* build_track_bus_context_menu (); 821 Gtk::Menu* build_track_region_context_menu (); 822 Gtk::Menu* build_track_selection_context_menu (); 823 void add_dstream_context_items (Gtk::Menu_Helpers::MenuList&); 824 void add_bus_context_items (Gtk::Menu_Helpers::MenuList&); 825 void add_region_context_items (Gtk::Menu_Helpers::MenuList&, boost::shared_ptr<ARDOUR::Track>); 826 void add_selection_context_items (Gtk::Menu_Helpers::MenuList&); 827 Gtk::MenuItem* _popup_region_menu_item; 828 829 void popup_control_point_context_menu (ArdourCanvas::Item*, GdkEvent*); 830 Gtk::Menu _control_point_context_menu; 831 832 void popup_note_context_menu (ArdourCanvas::Item*, GdkEvent*); 833 Gtk::Menu _note_context_menu; 834 835 void add_stripables (ARDOUR::StripableList&); 836 void add_routes (ARDOUR::RouteList&); 837 void timeaxisview_deleted (TimeAxisView*); 838 void add_vcas (ARDOUR::VCAList&); 839 840 Gtk::HBox global_hpacker; 841 Gtk::VBox global_vpacker; 842 843 /* Cursor stuff. Do not use directly, use via CursorContext. */ 844 friend class CursorContext; 845 std::vector<Gdk::Cursor*> _cursor_stack; 846 void set_canvas_cursor (Gdk::Cursor*); 847 size_t push_canvas_cursor (Gdk::Cursor*); 848 void pop_canvas_cursor (); 849 850 Gdk::Cursor* which_track_cursor () const; 851 Gdk::Cursor* which_mode_cursor () const; 852 Gdk::Cursor* which_trim_cursor (bool left_side) const; 853 Gdk::Cursor* which_canvas_cursor (ItemType type) const; 854 855 /** Push the appropriate enter/cursor context on item entry. */ 856 void choose_canvas_cursor_on_entry (ItemType); 857 858 /** Update all enter cursors based on current settings. */ 859 void update_all_enter_cursors (); 860 861 ArdourCanvas::GtkCanvas* _track_canvas; 862 ArdourCanvas::GtkCanvasViewport* _track_canvas_viewport; 863 864 bool within_track_canvas; 865 866 friend class VerboseCursor; 867 VerboseCursor* _verbose_cursor; 868 869 RegionPeakCursor* _region_peak_cursor; 870 871 void parameter_changed (std::string); 872 void ui_parameter_changed (std::string); 873 874 Gtk::EventBox time_bars_event_box; 875 Gtk::VBox time_bars_vbox; 876 877 ArdourCanvas::Container* tempo_group; 878 ArdourCanvas::Container* meter_group; 879 ArdourCanvas::Container* marker_group; 880 ArdourCanvas::Container* range_marker_group; 881 ArdourCanvas::Container* transport_marker_group; 882 ArdourCanvas::Container* cd_marker_group; 883 884 /* parent for groups which themselves contain time markers */ 885 ArdourCanvas::Container* _time_markers_group; 886 887 /* The group containing all other groups that are scrolled vertically 888 and horizontally. 889 */ 890 ArdourCanvas::ScrollGroup* hv_scroll_group; 891 892 /* The group containing all other groups that are scrolled horizontally ONLY 893 */ 894 ArdourCanvas::ScrollGroup* h_scroll_group; 895 896 /* Scroll group for cursors, scrolled horizontally, above everything else 897 */ 898 ArdourCanvas::ScrollGroup* cursor_scroll_group; 899 900 /* The group containing all trackviews. */ 901 ArdourCanvas::Container* no_scroll_group; 902 903 /* The group containing all trackviews. */ 904 ArdourCanvas::Container* _trackview_group; 905 906 /* The group holding things (mostly regions) while dragging so they 907 * are on top of everything else 908 */ 909 ArdourCanvas::Container* _drag_motion_group; 910 911 /* a rect that sits at the bottom of all tracks to act as a drag-no-drop/clickable 912 * target area. 913 */ 914 ArdourCanvas::Rectangle* _canvas_drop_zone; 915 bool canvas_drop_zone_event (GdkEvent* event); 916 917 Glib::RefPtr<Gtk::ToggleAction> ruler_timecode_action; 918 Glib::RefPtr<Gtk::ToggleAction> ruler_bbt_action; 919 Glib::RefPtr<Gtk::ToggleAction> ruler_samples_action; 920 Glib::RefPtr<Gtk::ToggleAction> ruler_minsec_action; 921 Glib::RefPtr<Gtk::ToggleAction> ruler_tempo_action; 922 Glib::RefPtr<Gtk::ToggleAction> ruler_meter_action; 923 Glib::RefPtr<Gtk::ToggleAction> ruler_marker_action; 924 Glib::RefPtr<Gtk::ToggleAction> ruler_range_action; 925 Glib::RefPtr<Gtk::ToggleAction> ruler_loop_punch_action; 926 Glib::RefPtr<Gtk::ToggleAction> ruler_cd_marker_action; 927 bool no_ruler_shown_update; 928 929 Gtk::Widget* ruler_grabbed_widget; 930 931 RulerDialog* ruler_dialog; 932 933 void initialize_rulers (); 934 void update_just_timecode (); 935 void compute_fixed_ruler_scale (); //calculates the RulerScale of the fixed rulers 936 void update_fixed_rulers (); 937 void update_tempo_based_rulers (); 938 void popup_ruler_menu (samplepos_t where = 0, ItemType type = RegionItem); 939 void update_ruler_visibility (); 940 void toggle_ruler_visibility (); 941 void ruler_toggled (int); 942 bool ruler_label_button_release (GdkEventButton*); 943 void store_ruler_visibility (); 944 void restore_ruler_visibility (); 945 void show_rulers_for_grid (); 946 947 enum MinsecRulerScale { 948 minsec_show_msecs, 949 minsec_show_seconds, 950 minsec_show_minutes, 951 minsec_show_hours, 952 minsec_show_many_hours 953 }; 954 955 MinsecRulerScale minsec_ruler_scale; 956 957 samplecnt_t minsec_mark_interval; 958 gint minsec_mark_modulo; 959 gint minsec_nmarks; 960 void set_minsec_ruler_scale (samplepos_t, samplepos_t); 961 962 enum TimecodeRulerScale { 963 timecode_show_bits, 964 timecode_show_samples, 965 timecode_show_seconds, 966 timecode_show_minutes, 967 timecode_show_hours, 968 timecode_show_many_hours 969 }; 970 971 TimecodeRulerScale timecode_ruler_scale; 972 973 gint timecode_mark_modulo; 974 gint timecode_nmarks; 975 void set_timecode_ruler_scale (samplepos_t, samplepos_t); 976 977 samplecnt_t _samples_ruler_interval; 978 void set_samples_ruler_scale (samplepos_t, samplepos_t); 979 980 enum BBTRulerScale { 981 bbt_show_many, 982 bbt_show_64, 983 bbt_show_16, 984 bbt_show_4, 985 bbt_show_1, 986 bbt_show_quarters, 987 bbt_show_eighths, 988 bbt_show_sixteenths, 989 bbt_show_thirtyseconds, 990 bbt_show_sixtyfourths, 991 bbt_show_onetwentyeighths 992 }; 993 994 BBTRulerScale bbt_ruler_scale; 995 996 uint32_t bbt_bars; 997 gint bbt_nmarks; 998 uint32_t bbt_bar_helper_on; 999 void compute_bbt_ruler_scale (samplepos_t lower, samplepos_t upper); 1000 1001 ArdourCanvas::Ruler* timecode_ruler; 1002 ArdourCanvas::Ruler* bbt_ruler; 1003 ArdourCanvas::Ruler* samples_ruler; 1004 ArdourCanvas::Ruler* minsec_ruler; 1005 1006 static double timebar_height; 1007 guint32 visible_timebars; 1008 Gtk::Menu* editor_ruler_menu; 1009 1010 ArdourCanvas::Rectangle* tempo_bar; 1011 ArdourCanvas::Rectangle* meter_bar; 1012 ArdourCanvas::Rectangle* marker_bar; 1013 ArdourCanvas::Rectangle* range_marker_bar; 1014 ArdourCanvas::Rectangle* transport_marker_bar; 1015 ArdourCanvas::Rectangle* cd_marker_bar; 1016 1017 Gtk::Label minsec_label; 1018 Gtk::Label bbt_label; 1019 Gtk::Label timecode_label; 1020 Gtk::Label samples_label; 1021 Gtk::Label tempo_label; 1022 Gtk::Label meter_label; 1023 Gtk::Label mark_label; 1024 Gtk::Label range_mark_label; 1025 Gtk::Label transport_mark_label; 1026 Gtk::Label cd_mark_label; 1027 1028 /* videtimline related actions */ 1029 Gtk::Label videotl_label; 1030 ArdourCanvas::Container* videotl_group; 1031 Glib::RefPtr<Gtk::ToggleAction> ruler_video_action; 1032 Glib::RefPtr<Gtk::ToggleAction> xjadeo_proc_action; 1033 Glib::RefPtr<Gtk::ToggleAction> xjadeo_ontop_action; 1034 Glib::RefPtr<Gtk::ToggleAction> xjadeo_timecode_action; 1035 Glib::RefPtr<Gtk::ToggleAction> xjadeo_frame_action; 1036 Glib::RefPtr<Gtk::ToggleAction> xjadeo_osdbg_action; 1037 Glib::RefPtr<Gtk::ToggleAction> xjadeo_fullscreen_action; 1038 Glib::RefPtr<Gtk::ToggleAction> xjadeo_letterbox_action; 1039 Glib::RefPtr<Gtk::Action> xjadeo_zoom_100; 1040 void set_xjadeo_proc (); 1041 void toggle_xjadeo_proc (int state=-1); 1042 void set_close_video_sensitive (bool onoff); 1043 void set_xjadeo_sensitive (bool onoff); 1044 void set_xjadeo_viewoption (int); 1045 void toggle_xjadeo_viewoption (int what, int state=-1); toggle_ruler_video(bool onoff)1046 void toggle_ruler_video (bool onoff) {ruler_video_action->set_active(onoff);} 1047 int videotl_bar_height; /* in units of timebar_height; default: 4 */ get_videotl_bar_height()1048 int get_videotl_bar_height () const { return videotl_bar_height; } 1049 void toggle_region_video_lock (); 1050 playhead_cursor()1051 EditorCursor* playhead_cursor () const { return _playhead_cursor; } snapped_cursor()1052 EditorCursor* snapped_cursor () const { return _snapped_cursor; } 1053 1054 samplepos_t playhead_cursor_sample () const; 1055 1056 samplepos_t get_region_boundary (samplepos_t pos, int32_t dir, bool with_selection, bool only_onscreen); 1057 1058 void cursor_to_region_boundary (bool with_selection, int32_t dir); 1059 void cursor_to_next_region_boundary (bool with_selection); 1060 void cursor_to_previous_region_boundary (bool with_selection); 1061 void cursor_to_next_region_point (EditorCursor*, ARDOUR::RegionPoint); 1062 void cursor_to_previous_region_point (EditorCursor*, ARDOUR::RegionPoint); 1063 void cursor_to_region_point (EditorCursor*, ARDOUR::RegionPoint, int32_t dir); 1064 void cursor_to_selection_start (EditorCursor*); 1065 void cursor_to_selection_end (EditorCursor*); 1066 1067 void selected_marker_to_region_boundary (bool with_selection, int32_t dir); 1068 void selected_marker_to_next_region_boundary (bool with_selection); 1069 void selected_marker_to_previous_region_boundary (bool with_selection); 1070 void selected_marker_to_next_region_point (ARDOUR::RegionPoint); 1071 void selected_marker_to_previous_region_point (ARDOUR::RegionPoint); 1072 void selected_marker_to_region_point (ARDOUR::RegionPoint, int32_t dir); 1073 void selected_marker_to_selection_start (); 1074 void selected_marker_to_selection_end (); 1075 1076 void select_all_selectables_using_cursor (EditorCursor*, bool); 1077 void select_all_selectables_using_edit (bool, bool); 1078 void select_all_selectables_between (bool within); 1079 void select_range_between (); 1080 1081 boost::shared_ptr<ARDOUR::Region> find_next_region (ARDOUR::samplepos_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList&, TimeAxisView** = 0); 1082 ARDOUR::samplepos_t find_next_region_boundary (ARDOUR::samplepos_t, int32_t dir, const TrackViewList&); 1083 1084 std::vector<ARDOUR::samplepos_t> region_boundary_cache; mark_region_boundary_cache_dirty()1085 void mark_region_boundary_cache_dirty () { _region_boundary_cache_dirty = true; } 1086 void build_region_boundary_cache (); 1087 bool _region_boundary_cache_dirty; 1088 1089 Gtk::HBox toplevel_hpacker; 1090 1091 Gtk::HBox bottom_hbox; 1092 1093 Gtk::Table edit_packer; 1094 1095 /** the adjustment that controls the overall editor vertical scroll position */ 1096 Gtk::Adjustment vertical_adjustment; 1097 Gtk::Adjustment horizontal_adjustment; 1098 1099 Gtk::Adjustment unused_adjustment; // yes, really; Gtk::Layout constructor requires refs 1100 Gtk::Layout controls_layout; 1101 bool control_layout_scroll (GdkEventScroll* ev); 1102 void reset_controls_layout_width (); 1103 void reset_controls_layout_height (int32_t height); 1104 1105 enum Direction { 1106 LEFT, 1107 RIGHT, 1108 UP, 1109 DOWN 1110 }; 1111 1112 bool scroll_press (Direction); 1113 void scroll_release (); 1114 sigc::connection _scroll_connection; 1115 int _scroll_callbacks; 1116 1117 double _visible_canvas_width; 1118 double _visible_canvas_height; ///< height of the visible area of the track canvas 1119 double _full_canvas_height; ///< full height of the canvas 1120 1121 bool track_canvas_map_handler (GdkEventAny*); 1122 1123 bool edit_controls_button_event (GdkEventButton*); 1124 Gtk::Menu* edit_controls_left_menu; 1125 Gtk::Menu* edit_controls_right_menu; 1126 1127 Gtk::VBox track_canvas_vbox; 1128 Gtk::VBox edit_controls_vbox; 1129 Gtk::HBox edit_controls_hbox; 1130 1131 void control_vertical_zoom_in_all (); 1132 void control_vertical_zoom_out_all (); 1133 void control_vertical_zoom_in_selected (); 1134 void control_vertical_zoom_out_selected (); 1135 void control_step_tracks_up (); 1136 void control_step_tracks_down (); 1137 void control_view (uint32_t); 1138 void control_scroll (float); 1139 void access_action (const std::string&, const std::string&); 1140 void set_toggleaction (const std::string&, const std::string&, bool); 1141 bool deferred_control_scroll (samplepos_t); 1142 sigc::connection control_scroll_connection; 1143 1144 void tie_vertical_scrolling (); 1145 void set_horizontal_position (double); 1146 double horizontal_position () const; 1147 1148 struct VisualChange { 1149 enum Type { 1150 TimeOrigin = 0x1, 1151 ZoomLevel = 0x2, 1152 YOrigin = 0x4, 1153 VideoTimeline = 0x8 1154 }; 1155 1156 Type pending; 1157 samplepos_t time_origin; 1158 samplecnt_t samples_per_pixel; 1159 double y_origin; 1160 1161 int idle_handler_id; 1162 /** true if we are currently in the idle handler */ 1163 bool being_handled; 1164 VisualChangeVisualChange1165 VisualChange() : pending ((VisualChange::Type) 0), time_origin (0), samples_per_pixel (0), idle_handler_id (-1), being_handled (false) {} addVisualChange1166 void add (Type t) { 1167 pending = Type (pending | t); 1168 } 1169 }; 1170 1171 VisualChange pending_visual_change; 1172 bool visual_change_queued; 1173 1174 void pre_render (); 1175 1176 static int _idle_visual_changer (void* arg); 1177 int idle_visual_changer (); 1178 void visual_changer (const VisualChange&); 1179 void ensure_visual_change_idle_handler (); 1180 1181 /* track views */ 1182 TrackViewList track_views; 1183 std::pair<TimeAxisView*, double> trackview_by_y_position (double, bool trackview_relative_offset = true) const; 1184 1185 AxisView* axis_view_by_stripable (boost::shared_ptr<ARDOUR::Stripable>) const; 1186 AxisView* axis_view_by_control (boost::shared_ptr<ARDOUR::AutomationControl>) const; 1187 time_axis_view_from_stripable(boost::shared_ptr<ARDOUR::Stripable> s)1188 TimeAxisView* time_axis_view_from_stripable (boost::shared_ptr<ARDOUR::Stripable> s) const { 1189 return dynamic_cast<TimeAxisView*> (axis_view_by_stripable (s)); 1190 } 1191 1192 TrackViewList get_tracks_for_range_action () const; 1193 1194 sigc::connection super_rapid_screen_update_connection; 1195 void center_screen_internal (samplepos_t, float); 1196 1197 void super_rapid_screen_update (); 1198 1199 int64_t _last_update_time; 1200 double _err_screen_engine; 1201 1202 void session_going_away (); 1203 1204 samplepos_t cut_buffer_start; 1205 samplecnt_t cut_buffer_length; 1206 1207 boost::shared_ptr<CursorContext> _press_cursor_ctx; ///< Button press cursor context 1208 1209 boost::weak_ptr<ARDOUR::Trimmable> _trimmable; 1210 boost::weak_ptr<ARDOUR::Movable> _movable; 1211 1212 bool typed_event (ArdourCanvas::Item*, GdkEvent*, ItemType); 1213 bool button_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType); 1214 bool button_press_handler_1 (ArdourCanvas::Item*, GdkEvent*, ItemType); 1215 bool button_press_handler_2 (ArdourCanvas::Item*, GdkEvent*, ItemType); 1216 bool button_release_handler (ArdourCanvas::Item*, GdkEvent*, ItemType); 1217 bool button_double_click_handler (ArdourCanvas::Item*, GdkEvent*, ItemType); 1218 bool button_press_dispatch (GdkEventButton*); 1219 bool button_release_dispatch (GdkEventButton*); 1220 bool motion_handler (ArdourCanvas::Item*, GdkEvent*, bool from_autoscroll = false); 1221 bool enter_handler (ArdourCanvas::Item*, GdkEvent*, ItemType); 1222 bool leave_handler (ArdourCanvas::Item*, GdkEvent*, ItemType); 1223 bool key_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType); 1224 bool key_release_handler (ArdourCanvas::Item*, GdkEvent*, ItemType); 1225 1226 Gtkmm2ext::Bindings* button_bindings; 1227 XMLNode* button_settings () const; 1228 1229 /* KEYMAP HANDLING */ 1230 1231 void register_actions (); 1232 void register_region_actions (); 1233 void register_midi_actions (Gtkmm2ext::Bindings*); 1234 1235 void load_bindings (); 1236 1237 /* CUT/COPY/PASTE */ 1238 1239 samplepos_t last_paste_pos; 1240 unsigned paste_count; 1241 1242 void cut_copy (Editing::CutCopyOp); 1243 bool can_cut_copy () const; 1244 void cut_copy_points (Editing::CutCopyOp, Temporal::Beats earliest=Temporal::Beats(), bool midi=false); 1245 void cut_copy_regions (Editing::CutCopyOp, RegionSelection&); 1246 void cut_copy_ranges (Editing::CutCopyOp); 1247 void cut_copy_midi (Editing::CutCopyOp); 1248 1249 void mouse_paste (); 1250 void paste_internal (samplepos_t position, float times, const int32_t sub_num); 1251 1252 /* EDITING OPERATIONS */ 1253 1254 void reset_point_selection (); 1255 void toggle_region_lock (); 1256 void toggle_opaque_region (); 1257 void toggle_record_enable (); 1258 void toggle_solo (); 1259 void toggle_solo_isolate (); 1260 void toggle_mute (); 1261 void toggle_region_lock_style (); 1262 1263 void play_solo_selection (bool restart); 1264 1265 enum LayerOperation { 1266 Raise, 1267 RaiseToTop, 1268 Lower, 1269 LowerToBottom 1270 }; 1271 1272 void do_layer_operation (LayerOperation); 1273 void raise_region (); 1274 void raise_region_to_top (); 1275 void change_region_layering_order (bool from_context_menu); 1276 void lower_region (); 1277 void lower_region_to_bottom (); 1278 void split_region_at_transients (); 1279 void crop_region_to_selection (); 1280 void crop_region_to (samplepos_t start, samplepos_t end); 1281 void set_sync_point (samplepos_t, const RegionSelection&); 1282 void set_region_sync_position (); 1283 void remove_region_sync(); 1284 void align_regions (ARDOUR::RegionPoint); 1285 void align_regions_relative (ARDOUR::RegionPoint point); 1286 void align_region (boost::shared_ptr<ARDOUR::Region>, ARDOUR::RegionPoint point, samplepos_t position); 1287 void align_region_internal (boost::shared_ptr<ARDOUR::Region>, ARDOUR::RegionPoint point, samplepos_t position); 1288 void recover_regions (ARDOUR::RegionList); 1289 void remove_selected_regions (); 1290 void remove_clicked_region (); 1291 void show_region_properties (); 1292 void show_midi_list_editor (); 1293 void rename_region (); 1294 void duplicate_some_regions (RegionSelection&, float times); 1295 void duplicate_selection (float times); 1296 void region_fill_selection (); 1297 void combine_regions (); 1298 void uncombine_regions (); 1299 1300 void region_fill_track (); 1301 void audition_playlist_region_standalone (boost::shared_ptr<ARDOUR::Region>); 1302 void split_multichannel_region(); 1303 void reverse_region (); 1304 void strip_region_silence (); 1305 void normalize_region (); 1306 void reset_region_scale_amplitude (); 1307 void adjust_region_gain (bool up); 1308 void reset_region_gain (); 1309 void quantize_region (); 1310 void quantize_regions (const RegionSelection& rs); 1311 void legatize_region (bool shrink_only); 1312 void legatize_regions (const RegionSelection& rs, bool shrink_only); 1313 void transform_region (); 1314 void transform_regions (const RegionSelection& rs); 1315 void transpose_region (); 1316 void transpose_regions (const RegionSelection& rs); 1317 void insert_patch_change (bool from_context); 1318 void fork_region (); 1319 1320 void do_insert_time (); 1321 void insert_time (samplepos_t, samplecnt_t, Editing::InsertTimeOption, bool, bool, bool, bool, bool, bool); 1322 1323 void do_remove_time (); 1324 void remove_time (samplepos_t pos, samplecnt_t distance, Editing::InsertTimeOption opt, bool ignore_music_glue, bool markers_too, 1325 bool glued_markers_too, bool locked_markers_too, bool tempo_too); 1326 1327 void tab_to_transient (bool forward); 1328 1329 void set_tempo_from_region (); 1330 void use_range_as_bar (); 1331 1332 void define_one_bar (samplepos_t start, samplepos_t end); 1333 1334 void audition_region_from_region_list (); 1335 1336 void naturalize_region (); 1337 1338 void split_region (); 1339 1340 void delete_ (); 1341 void cut (); 1342 void copy (); 1343 void paste (float times, bool from_context_menu); 1344 1345 void place_transient (); 1346 void remove_transient (ArdourCanvas::Item* item); 1347 void snap_regions_to_grid (); 1348 void close_region_gaps (); 1349 1350 void keyboard_paste (); 1351 1352 void region_from_selection (); 1353 void create_region_from_selection (std::vector<boost::shared_ptr<ARDOUR::Region> >&); 1354 1355 void play_from_start (); 1356 void play_from_edit_point (); 1357 void play_from_edit_point_and_return (); 1358 void play_selected_region (); 1359 void play_edit_range (); 1360 void play_location (ARDOUR::Location&); 1361 void loop_location (ARDOUR::Location&); 1362 1363 void calc_extra_zoom_edges(samplepos_t &start, samplepos_t &end); 1364 void temporal_zoom_selection (Editing::ZoomAxis); 1365 void temporal_zoom_session (); 1366 void temporal_zoom_extents (); 1367 void temporal_zoom (samplecnt_t samples_per_pixel); 1368 void temporal_zoom_by_sample (samplepos_t start, samplepos_t end); 1369 void temporal_zoom_to_sample (bool coarser, samplepos_t sample); 1370 1371 void insert_source_list_selection (float times); 1372 1373 /* import & embed */ 1374 1375 void add_external_audio_action (Editing::ImportMode); 1376 1377 int check_whether_and_how_to_import(std::string, bool all_or_nothing = true); 1378 bool check_multichannel_status (const std::vector<std::string>& paths); 1379 1380 SoundFileOmega* sfbrowser; 1381 1382 void bring_in_external_audio (Editing::ImportMode mode, samplepos_t& pos); 1383 1384 bool idle_drop_paths (std::vector<std::string> paths, samplepos_t sample, double ypos, bool copy); 1385 void drop_paths_part_two (const std::vector<std::string>& paths, samplepos_t sample, double ypos, bool copy); 1386 1387 int import_sndfiles (std::vector<std::string> paths, 1388 Editing::ImportDisposition disposition, 1389 Editing::ImportMode mode, 1390 ARDOUR::SrcQuality quality, 1391 samplepos_t& pos, 1392 int target_regions, 1393 int target_tracks, 1394 boost::shared_ptr<ARDOUR::Track>& track, 1395 bool replace, 1396 boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>()); 1397 1398 int embed_sndfiles (std::vector<std::string> paths, 1399 bool multiple_files, 1400 bool& check_sample_rate, 1401 Editing::ImportDisposition disposition, 1402 Editing::ImportMode mode, 1403 samplepos_t& pos, 1404 int target_regions, 1405 int target_tracks, 1406 boost::shared_ptr<ARDOUR::Track>& track, 1407 boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>()); 1408 1409 int add_sources (std::vector<std::string> paths, 1410 ARDOUR::SourceList& sources, 1411 samplepos_t& pos, 1412 Editing::ImportDisposition disposition, 1413 Editing::ImportMode mode, 1414 int target_regions, 1415 int target_tracks, 1416 boost::shared_ptr<ARDOUR::Track>& track, 1417 bool add_channel_suffix, 1418 boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>()); 1419 1420 int finish_bringing_in_material (boost::shared_ptr<ARDOUR::Region> region, 1421 uint32_t in_chans, 1422 uint32_t out_chans, 1423 samplepos_t& pos, 1424 Editing::ImportMode mode, 1425 boost::shared_ptr<ARDOUR::Track>& existing_track, 1426 const std::string& new_track_name, 1427 boost::shared_ptr<ARDOUR::PluginInfo> instrument); 1428 1429 boost::shared_ptr<ARDOUR::AudioTrack> get_nth_selected_audio_track (int nth) const; 1430 boost::shared_ptr<ARDOUR::MidiTrack> get_nth_selected_midi_track (int nth) const; 1431 1432 void toggle_midi_input_active (bool flip_others); 1433 1434 ARDOUR::InterThreadInfo* current_interthread_info; 1435 1436 AnalysisWindow* analysis_window; 1437 1438 /* import & embed */ 1439 void external_audio_dialog (); 1440 void session_import_dialog (); 1441 1442 /* PT import specific */ 1443 void external_pt_dialog (); 1444 ARDOUR::ImportStatus import_pt_status; 1445 static void*_import_pt_thread (void*); 1446 void* import_pt_thread (); 1447 PTFFormat import_ptf; 1448 1449 /* import specific info */ 1450 1451 struct EditorImportStatus : public ARDOUR::ImportStatus { clearEditorImportStatus1452 void clear () { 1453 ARDOUR::ImportStatus::clear (); 1454 track.reset (); 1455 } 1456 1457 Editing::ImportMode mode; 1458 samplepos_t pos; 1459 int target_tracks; 1460 int target_regions; 1461 boost::shared_ptr<ARDOUR::Track> track; 1462 bool replace; 1463 }; 1464 1465 EditorImportStatus import_status; 1466 static void*_import_thread (void*); 1467 void* import_thread (); 1468 void finish_import (); 1469 1470 /* to support this ... */ 1471 1472 void import_audio (bool as_tracks); 1473 void do_import (std::vector<std::string> paths, bool split, bool as_tracks); 1474 void import_smf_tempo_map (Evoral::SMF const &, samplepos_t pos); 1475 void import_smf_markers (Evoral::SMF &, samplepos_t pos); 1476 void move_to_start (); 1477 void move_to_end (); 1478 void center_playhead (); 1479 void center_edit_point (); 1480 void playhead_forward_to_grid (); 1481 void playhead_backward_to_grid (); 1482 void scroll_playhead (bool forward); 1483 void scroll_backward (float pages=0.8f); 1484 void scroll_forward (float pages=0.8f); 1485 void scroll_tracks_down (); 1486 void scroll_tracks_up (); 1487 void set_mark (); 1488 void clear_markers (); 1489 void clear_xrun_markers (); 1490 void clear_ranges (); 1491 void clear_locations (); 1492 void unhide_markers (); 1493 void unhide_ranges (); 1494 void cursor_align (bool playhead_to_edit); 1495 void toggle_skip_playback (); 1496 1497 void remove_last_capture (); 1498 1499 void tag_last_capture (); 1500 void tag_selected_region (); 1501 void tag_regions (ARDOUR::RegionList); 1502 1503 void select_all_selectables_using_time_selection (); 1504 void select_all_selectables_using_loop(); 1505 void select_all_selectables_using_punch(); 1506 void set_selection_from_range (ARDOUR::Location&); 1507 void set_selection_from_punch (); 1508 void set_selection_from_loop (); 1509 void set_selection_from_region (); 1510 1511 void add_location_mark (samplepos_t where); 1512 void add_location_from_region (); 1513 void add_locations_from_region (); 1514 void add_location_from_selection (); 1515 void set_loop_from_selection (bool play); 1516 void set_punch_from_selection (); 1517 void set_punch_from_region (); 1518 void set_auto_punch_range(); 1519 1520 void set_session_start_from_playhead (); 1521 void set_session_end_from_playhead (); 1522 void set_session_extents_from_selection (); 1523 1524 void set_loop_from_region (bool play); 1525 1526 void set_loop_range (samplepos_t start, samplepos_t end, std::string cmd); 1527 void set_punch_range (samplepos_t start, samplepos_t end, std::string cmd); 1528 1529 void toggle_location_at_playhead_cursor (); 1530 void add_location_from_playhead_cursor (); 1531 bool do_remove_location_at_playhead_cursor (); 1532 void remove_location_at_playhead_cursor (); 1533 bool select_new_marker; 1534 1535 void toggle_all_existing_automation (); 1536 void toggle_layer_display (); 1537 1538 void reverse_selection (); 1539 void edit_envelope (); 1540 1541 double last_scrub_x; 1542 int scrubbing_direction; 1543 int scrub_reversals; 1544 int scrub_reverse_distance; 1545 void scrub (samplepos_t, double); 1546 1547 void set_punch_start_from_edit_point (); 1548 void set_punch_end_from_edit_point (); 1549 void set_loop_start_from_edit_point (); 1550 void set_loop_end_from_edit_point (); 1551 1552 void keyboard_selection_begin (Editing::EditIgnoreOption = Editing::EDIT_IGNORE_NONE); 1553 void keyboard_selection_finish (bool add, Editing::EditIgnoreOption = Editing::EDIT_IGNORE_NONE); 1554 bool have_pending_keyboard_selection; 1555 samplepos_t pending_keyboard_selection_start; 1556 1557 void move_range_selection_start_or_end_to_region_boundary (bool, bool); 1558 1559 Editing::GridType _grid_type; 1560 Editing::SnapMode _snap_mode; 1561 1562 bool ignore_gui_changes; 1563 1564 DragManager* _drags; 1565 1566 void escape (); 1567 void lock (); 1568 void unlock (); 1569 Gtk::Dialog* lock_dialog; 1570 1571 struct timeval last_event_time; 1572 bool generic_event_handler (GdkEvent*); 1573 bool lock_timeout_callback (); 1574 void start_lock_event_timing (); 1575 1576 Gtk::Menu fade_context_menu; 1577 1578 Gtk::Menu xfade_in_context_menu; 1579 Gtk::Menu xfade_out_context_menu; 1580 void popup_xfade_in_context_menu (int, int, ArdourCanvas::Item*, ItemType); 1581 void popup_xfade_out_context_menu (int, int, ArdourCanvas::Item*, ItemType); 1582 void fill_xfade_menu (Gtk::Menu_Helpers::MenuList& items, bool start); 1583 1584 void set_fade_in_shape (ARDOUR::FadeShape); 1585 void set_fade_out_shape (ARDOUR::FadeShape); 1586 1587 void set_fade_length (bool in); 1588 void set_fade_in_active (bool); 1589 void set_fade_out_active (bool); 1590 1591 void fade_range (); 1592 1593 std::set<boost::shared_ptr<ARDOUR::Playlist> > motion_frozen_playlists; 1594 1595 bool _dragging_playhead; 1596 1597 void marker_drag_motion_callback (GdkEvent*); 1598 void marker_drag_finished_callback (GdkEvent*); 1599 1600 gint mouse_rename_region (ArdourCanvas::Item*, GdkEvent*); 1601 1602 void add_region_drag (ArdourCanvas::Item*, GdkEvent*, RegionView*); 1603 void start_create_region_grab (ArdourCanvas::Item*, GdkEvent*); 1604 void add_region_copy_drag (ArdourCanvas::Item*, GdkEvent*, RegionView*); 1605 void add_region_brush_drag (ArdourCanvas::Item*, GdkEvent*, RegionView*); 1606 void start_selection_grab (ArdourCanvas::Item*, GdkEvent*); 1607 1608 void region_view_item_click (AudioRegionView&, GdkEventButton*); 1609 1610 bool can_remove_control_point (ArdourCanvas::Item*); 1611 void remove_control_point (ArdourCanvas::Item*); 1612 1613 /* Canvas event handlers */ 1614 1615 bool canvas_scroll_event (GdkEventScroll* event, bool from_canvas); 1616 bool canvas_control_point_event (GdkEvent* event,ArdourCanvas::Item*, ControlPoint*); 1617 bool canvas_line_event (GdkEvent* event,ArdourCanvas::Item*, AutomationLine*); 1618 bool canvas_selection_rect_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*); 1619 bool canvas_selection_start_trim_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*); 1620 bool canvas_selection_end_trim_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*); 1621 bool canvas_start_xfade_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*); 1622 bool canvas_end_xfade_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*); 1623 bool canvas_fade_in_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*); 1624 bool canvas_fade_in_handle_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*, bool trim = false); 1625 bool canvas_fade_out_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*); 1626 bool canvas_fade_out_handle_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*, bool trim = false); 1627 bool canvas_region_view_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*); 1628 bool canvas_wave_view_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*); 1629 bool canvas_frame_handle_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*); 1630 bool canvas_region_view_name_highlight_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*); 1631 bool canvas_region_view_name_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*); 1632 bool canvas_feature_line_event (GdkEvent* event, ArdourCanvas::Item*, RegionView*); 1633 bool canvas_stream_view_event (GdkEvent* event,ArdourCanvas::Item*, RouteTimeAxisView*); 1634 bool canvas_marker_event (GdkEvent* event,ArdourCanvas::Item*, ArdourMarker*); 1635 bool canvas_tempo_marker_event (GdkEvent* event,ArdourCanvas::Item*, TempoMarker*); 1636 bool canvas_tempo_curve_event (GdkEvent* event,ArdourCanvas::Item*, TempoCurve*); 1637 bool canvas_meter_marker_event (GdkEvent* event,ArdourCanvas::Item*, MeterMarker*); 1638 bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, AutomationTimeAxisView*); 1639 bool canvas_note_event (GdkEvent* event, ArdourCanvas::Item*); 1640 1641 bool canvas_ruler_event (GdkEvent* event, ArdourCanvas::Item*, ItemType); 1642 bool canvas_tempo_bar_event (GdkEvent* event, ArdourCanvas::Item*); 1643 bool canvas_meter_bar_event (GdkEvent* event, ArdourCanvas::Item*); 1644 bool canvas_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*); 1645 bool canvas_range_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*); 1646 bool canvas_transport_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*); 1647 bool canvas_cd_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*); 1648 1649 bool canvas_videotl_bar_event (GdkEvent* event, ArdourCanvas::Item*); 1650 void update_video_timeline (bool flush = false); 1651 void set_video_timeline_height (const int); 1652 bool is_video_timeline_locked (); 1653 void toggle_video_timeline_locked (); 1654 void set_video_timeline_locked (const bool); 1655 void queue_visual_videotimeline_update (); 1656 void embed_audio_from_video (std::string, samplepos_t n = 0, bool lock_position_to_video = true); 1657 track_selection_change_without_scroll()1658 bool track_selection_change_without_scroll () const { 1659 return _track_selection_change_without_scroll; 1660 } 1661 1662 PBD::Signal0<void> EditorFreeze; 1663 PBD::Signal0<void> EditorThaw; 1664 1665 private: 1666 friend class DragManager; 1667 friend class EditorRouteGroups; 1668 friend class EditorRegions; 1669 friend class EditorSources; 1670 1671 /* non-public event handlers */ 1672 1673 bool canvas_playhead_cursor_event (GdkEvent* event, ArdourCanvas::Item*); 1674 bool track_canvas_scroll (GdkEventScroll* event); 1675 1676 bool track_canvas_button_press_event (GdkEventButton* event); 1677 bool track_canvas_button_release_event (GdkEventButton* event); 1678 bool track_canvas_motion_notify_event (GdkEventMotion* event); 1679 1680 Gtk::Allocation _canvas_viewport_allocation; 1681 void track_canvas_viewport_allocate (Gtk::Allocation alloc); 1682 void track_canvas_viewport_size_allocated (); 1683 bool track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const &, int, int, guint); 1684 bool track_canvas_key_press (GdkEventKey*); 1685 bool track_canvas_key_release (GdkEventKey*); 1686 1687 void set_playhead_cursor (); 1688 1689 void toggle_region_mute (); 1690 1691 void initialize_canvas (); 1692 1693 /* playlist internal ops */ 1694 1695 bool stamp_new_playlist (std::string &name, std::string &pgroup, bool copy); 1696 1697 /* display control */ 1698 1699 /// true if the editor should follow the playhead, otherwise false 1700 bool _follow_playhead; 1701 /// true if we scroll the tracks rather than the playhead 1702 bool _stationary_playhead; 1703 /// true if we are in fullscreen mode 1704 bool _maximised; 1705 1706 std::vector<ArdourCanvas::Ruler::Mark> grid_marks; 1707 GridLines* grid_lines; 1708 1709 ArdourCanvas::Container* global_rect_group; 1710 ArdourCanvas::Container* time_line_group; 1711 1712 void hide_grid_lines (); 1713 void maybe_draw_grid_lines (); 1714 1715 void new_tempo_section (); 1716 1717 void remove_tempo_marker (ArdourCanvas::Item*); 1718 void remove_meter_marker (ArdourCanvas::Item*); 1719 gint real_remove_tempo_marker (ARDOUR::TempoSection*); 1720 gint real_remove_meter_marker (ARDOUR::MeterSection*); 1721 1722 void edit_tempo_marker (TempoMarker&); 1723 void edit_meter_marker (MeterMarker&); 1724 void edit_control_point (ArdourCanvas::Item*); 1725 void edit_notes (MidiRegionView*); 1726 void edit_region (RegionView*); 1727 1728 void edit_current_meter (); 1729 void edit_current_tempo (); 1730 1731 void marker_menu_edit (); 1732 void marker_menu_remove (); 1733 void marker_menu_rename (); 1734 void rename_marker (ArdourMarker* marker); 1735 void toggle_marker_lock_style (); 1736 void toggle_tempo_clamped (); 1737 void toggle_tempo_type (); 1738 void ramp_to_next_tempo (); 1739 void toggle_marker_menu_lock (); 1740 void toggle_marker_menu_glue (); 1741 void marker_menu_hide (); 1742 void marker_menu_set_origin (); 1743 void marker_menu_loop_range (); 1744 void marker_menu_select_all_selectables_using_range (); 1745 void marker_menu_select_using_range (); 1746 void marker_menu_separate_regions_using_location (); 1747 void marker_menu_play_from (); 1748 void marker_menu_play_range (); 1749 void marker_menu_set_playhead (); 1750 void marker_menu_set_from_playhead (); 1751 void marker_menu_set_from_selection (bool force_regions); 1752 void marker_menu_range_to_next (); 1753 void marker_menu_zoom_to_range (); 1754 void new_transport_marker_menu_set_loop (); 1755 void new_transport_marker_menu_set_punch (); 1756 void update_loop_range_view (); 1757 void update_punch_range_view (); 1758 void new_transport_marker_menu_popdown (); 1759 void marker_context_menu (GdkEventButton*, ArdourCanvas::Item*); 1760 void tempo_or_meter_marker_context_menu (GdkEventButton*, ArdourCanvas::Item*); 1761 void new_transport_marker_context_menu (GdkEventButton*, ArdourCanvas::Item*); 1762 void build_range_marker_menu (ARDOUR::Location*, bool, bool); 1763 void build_marker_menu (ARDOUR::Location*); 1764 void build_tempo_marker_menu (TempoMarker*, bool); 1765 void build_meter_marker_menu (MeterMarker*, bool); 1766 void build_new_transport_marker_menu (); 1767 1768 void dynamic_cast_marker_object (void*, MeterMarker**, TempoMarker**) const; 1769 1770 Gtk::Menu* tempo_marker_menu; 1771 Gtk::Menu* meter_marker_menu; 1772 Gtk::Menu* marker_menu; 1773 Gtk::Menu* range_marker_menu; 1774 Gtk::Menu* new_transport_marker_menu; 1775 ArdourCanvas::Item* marker_menu_item; 1776 1777 typedef std::list<ArdourMarker*> Marks; 1778 Marks metric_marks; 1779 1780 typedef std::list<TempoCurve*> Curves; 1781 Curves tempo_curves; 1782 1783 void remove_metric_marks (); 1784 void draw_metric_marks (const ARDOUR::Metrics& metrics); 1785 1786 void compute_current_bbt_points (std::vector<ARDOUR::TempoMap::BBTPoint>& grid, samplepos_t left, samplepos_t right); 1787 1788 void tempo_map_changed (const PBD::PropertyChange&); 1789 void tempometric_position_changed (const PBD::PropertyChange&); 1790 1791 void redisplay_grid (bool immediate_redraw); 1792 1793 /* toolbar */ 1794 1795 Gtk::ToggleButton editor_mixer_button; 1796 Gtk::ToggleButton editor_list_button; 1797 void editor_mixer_button_toggled (); 1798 void editor_list_button_toggled (); 1799 1800 ArdourWidgets::ArdourButton zoom_in_button; 1801 ArdourWidgets::ArdourButton zoom_out_button; 1802 ArdourWidgets::ArdourButton zoom_out_full_button; 1803 1804 ArdourWidgets::ArdourButton tav_expand_button; 1805 ArdourWidgets::ArdourButton tav_shrink_button; 1806 ArdourWidgets::ArdourDropdown visible_tracks_selector; 1807 ArdourWidgets::ArdourDropdown zoom_preset_selector; 1808 1809 int32_t _visible_track_count; 1810 void build_track_count_menu (); 1811 void set_visible_track_count (int32_t); 1812 1813 void set_zoom_preset(int64_t); 1814 1815 Gtk::VBox toolbar_clock_vbox; 1816 Gtk::VBox toolbar_selection_clock_vbox; 1817 Gtk::Table toolbar_selection_clock_table; 1818 Gtk::Label toolbar_selection_cursor_label; 1819 1820 ArdourWidgets::ArdourButton mouse_select_button; 1821 ArdourWidgets::ArdourButton mouse_draw_button; 1822 ArdourWidgets::ArdourButton mouse_move_button; 1823 ArdourWidgets::ArdourButton mouse_timefx_button; 1824 ArdourWidgets::ArdourButton mouse_content_button; 1825 ArdourWidgets::ArdourButton mouse_audition_button; 1826 ArdourWidgets::ArdourButton mouse_cut_button; 1827 1828 ArdourWidgets::ArdourButton smart_mode_button; 1829 Glib::RefPtr<Gtk::ToggleAction> smart_mode_action; 1830 1831 void mouse_mode_toggled (Editing::MouseMode m); 1832 void mouse_mode_object_range_toggled (); 1833 bool ignore_mouse_mode_toggle; 1834 1835 bool mouse_select_button_release (GdkEventButton*); 1836 1837 Glib::RefPtr<Gtk::Action> get_mouse_mode_action (Editing::MouseMode m) const; 1838 1839 Gtk::VBox automation_box; 1840 Gtk::Button automation_mode_button; 1841 1842 //edit mode menu stuff 1843 ArdourWidgets::ArdourDropdown edit_mode_selector; 1844 void edit_mode_selection_done (ARDOUR::EditMode); 1845 void build_edit_mode_menu (); 1846 Gtk::VBox edit_mode_box; 1847 1848 void set_edit_mode (ARDOUR::EditMode); 1849 void cycle_edit_mode (); 1850 1851 ArdourWidgets::ArdourDropdown grid_type_selector; 1852 void build_grid_type_menu (); 1853 1854 ArdourWidgets::ArdourButton snap_mode_button; 1855 bool snap_mode_button_clicked (GdkEventButton*); 1856 1857 Gtk::HBox snap_box; 1858 1859 Gtk::HBox ebox_hpacker; 1860 Gtk::VBox ebox_vpacker; 1861 1862 Gtk::HBox _box; 1863 1864 std::vector<std::string> grid_type_strings; 1865 std::vector<std::string> snap_mode_strings; 1866 1867 void grid_type_selection_done (Editing::GridType); 1868 void snap_mode_selection_done (Editing::SnapMode); 1869 void snap_mode_chosen (Editing::SnapMode); 1870 void grid_type_chosen (Editing::GridType); 1871 1872 Glib::RefPtr<Gtk::RadioAction> grid_type_action (Editing::GridType); 1873 Glib::RefPtr<Gtk::RadioAction> snap_mode_action (Editing::SnapMode); 1874 1875 //zoom focus meu stuff 1876 ArdourWidgets::ArdourDropdown zoom_focus_selector; 1877 void zoom_focus_selection_done (Editing::ZoomFocus); 1878 void build_zoom_focus_menu (); 1879 std::vector<std::string> zoom_focus_strings; 1880 1881 void zoom_focus_chosen (Editing::ZoomFocus); 1882 1883 Glib::RefPtr<Gtk::RadioAction> zoom_focus_action (Editing::ZoomFocus); 1884 1885 Gtk::HBox _track_box; 1886 1887 Gtk::HBox _zoom_box; 1888 void zoom_adjustment_changed(); 1889 1890 void setup_toolbar (); 1891 1892 void setup_tooltips (); 1893 1894 Gtk::HBox toolbar_hbox; 1895 1896 void setup_midi_toolbar (); 1897 1898 /* selection process */ 1899 1900 Selection* selection; 1901 Selection* cut_buffer; 1902 SelectionMemento* _selection_memento; 1903 1904 void time_selection_changed (); 1905 void track_selection_changed (); 1906 void update_time_selection_display (); 1907 void presentation_info_changed (PBD::PropertyChange const &); 1908 void region_selection_changed (); 1909 void catch_up_on_midi_selection (); 1910 sigc::connection editor_regions_selection_changed_connection; 1911 void sensitize_all_region_actions (bool); 1912 void sensitize_the_right_region_actions (bool because_canvas_crossing); 1913 bool _all_region_actions_sensitized; 1914 /** Flag to block region action handlers from doing what they normally do; 1915 * I tried Gtk::Action::block_activate() but this doesn't work (ie it doesn't 1916 * block) when setting a ToggleAction's active state. 1917 */ 1918 bool _ignore_region_action; 1919 bool _last_region_menu_was_main; 1920 void point_selection_changed (); 1921 void marker_selection_changed (); 1922 1923 bool _track_selection_change_without_scroll; 1924 bool _editor_track_selection_change_without_scroll; 1925 1926 void cancel_selection (); 1927 void cancel_time_selection (); 1928 1929 bool get_smart_mode() const; 1930 1931 bool audio_region_selection_covers (samplepos_t where); 1932 1933 /* playhead and edit cursor */ 1934 1935 EditorCursor* _playhead_cursor; 1936 EditorCursor* _snapped_cursor; 1937 1938 /* transport range select process */ 1939 1940 ArdourCanvas::Rectangle* cd_marker_bar_drag_rect; 1941 ArdourCanvas::Rectangle* range_bar_drag_rect; 1942 ArdourCanvas::Rectangle* transport_bar_drag_rect; 1943 ArdourCanvas::Rectangle* transport_bar_range_rect; 1944 ArdourCanvas::Rectangle* transport_bar_preroll_rect; 1945 ArdourCanvas::Rectangle* transport_bar_postroll_rect; 1946 ArdourCanvas::Rectangle* transport_loop_range_rect; 1947 ArdourCanvas::Rectangle* transport_punch_range_rect; 1948 ArdourCanvas::Line* transport_punchin_line; 1949 ArdourCanvas::Line* transport_punchout_line; 1950 ArdourCanvas::Rectangle* transport_preroll_rect; 1951 ArdourCanvas::Rectangle* transport_postroll_rect; 1952 1953 ARDOUR::Location* transport_loop_location(); 1954 ARDOUR::Location* transport_punch_location(); 1955 1956 ARDOUR::Location* temp_location; 1957 1958 /* object rubberband select process */ 1959 1960 void select_all_within (samplepos_t, samplepos_t, double, double, TrackViewList const &, Selection::Operation, bool); 1961 1962 ArdourCanvas::Rectangle* rubberband_rect; 1963 1964 EditorRouteGroups* _route_groups; 1965 EditorRoutes* _routes; 1966 EditorRegions* _regions; 1967 EditorSources* _sources; 1968 EditorSnapshots* _snapshots; 1969 EditorLocations* _locations; 1970 1971 /* diskstream/route display management */ 1972 Glib::RefPtr<Gdk::Pixbuf> rec_enabled_icon; 1973 Glib::RefPtr<Gdk::Pixbuf> rec_disabled_icon; 1974 1975 Glib::RefPtr<Gtk::TreeSelection> route_display_selection; 1976 1977 bool sync_track_view_list_and_routes (); 1978 1979 Gtk::VBox list_vpacker; 1980 1981 /* autoscrolling */ 1982 1983 sigc::connection autoscroll_connection; 1984 bool autoscroll_horizontal_allowed; 1985 bool autoscroll_vertical_allowed; 1986 uint32_t autoscroll_cnt; 1987 Gtk::Widget* autoscroll_widget; 1988 ArdourCanvas::Rect autoscroll_boundary; 1989 1990 bool autoscroll_canvas (); 1991 void start_canvas_autoscroll (bool allow_horiz, bool allow_vert, const ArdourCanvas::Rect& boundary); 1992 void stop_canvas_autoscroll (); 1993 1994 /* trimming */ 1995 void point_trim (GdkEvent*, samplepos_t); 1996 1997 void trim_region_front(); 1998 void trim_region_back(); 1999 void trim_region (bool front); 2000 2001 void trim_region_to_loop (); 2002 void trim_region_to_punch (); 2003 void trim_region_to_location (const ARDOUR::Location&, const char* cmd); 2004 2005 void trim_to_region(bool forward); 2006 void trim_region_to_previous_region_end(); 2007 void trim_region_to_next_region_start(); 2008 2009 bool show_gain_after_trim; 2010 2011 /* Drag-n-Drop */ 2012 2013 int convert_drop_to_paths ( 2014 std::vector<std::string>& paths, 2015 const Glib::RefPtr<Gdk::DragContext>& context, 2016 gint x, 2017 gint y, 2018 const Gtk::SelectionData& data, 2019 guint info, 2020 guint time); 2021 2022 void track_canvas_drag_data_received ( 2023 const Glib::RefPtr<Gdk::DragContext>& context, 2024 gint x, 2025 gint y, 2026 const Gtk::SelectionData& data, 2027 guint info, 2028 guint time); 2029 2030 void drop_paths ( 2031 const Glib::RefPtr<Gdk::DragContext>& context, 2032 gint x, 2033 gint y, 2034 const Gtk::SelectionData& data, 2035 guint info, 2036 guint time); 2037 2038 void drop_regions ( 2039 const Glib::RefPtr<Gdk::DragContext>& context, 2040 gint x, 2041 gint y, 2042 const Gtk::SelectionData& data, 2043 guint info, 2044 guint time, 2045 bool from_region_list); 2046 2047 void drop_routes ( 2048 const Glib::RefPtr<Gdk::DragContext>& context, 2049 gint x, 2050 gint y, 2051 const Gtk::SelectionData& data, 2052 guint info, 2053 guint time); 2054 2055 /* audio export */ 2056 2057 int write_region_selection(RegionSelection&); 2058 bool write_region (std::string path, boost::shared_ptr<ARDOUR::AudioRegion>); 2059 void bounce_region_selection (bool with_processing); 2060 void bounce_range_selection (bool replace, bool enable_processing); 2061 void external_edit_region (); 2062 2063 int write_audio_selection (TimeSelection&); 2064 bool write_audio_range (ARDOUR::AudioPlaylist&, const ARDOUR::ChanCount& channels, std::list<ARDOUR::AudioRange>&); 2065 2066 void write_selection (); 2067 2068 uint32_t selection_op_cmd_depth; 2069 uint32_t selection_op_history_it; 2070 2071 std::list<XMLNode*> selection_op_history; /* used in *_reversible_selection_op */ 2072 std::list<XMLNode*> before; /* used in *_reversible_command */ 2073 2074 void update_title (); 2075 void update_title_s (const std::string & snapshot_name); 2076 2077 void instant_save (); 2078 bool no_save_instant; 2079 2080 boost::shared_ptr<ARDOUR::AudioRegion> last_audition_region; 2081 2082 /* freeze operations */ 2083 2084 ARDOUR::InterThreadInfo freeze_status; 2085 static void* _freeze_thread (void*); 2086 void* freeze_thread (); 2087 2088 void freeze_route (); 2089 void unfreeze_route (); 2090 2091 /* duplication */ 2092 2093 void duplicate_range (bool with_dialog); 2094 void duplicate_regions (float times); 2095 2096 /** computes the timeline sample (sample) of an event whose coordinates 2097 * are in canvas units (pixels, scroll offset included). 2098 */ 2099 samplepos_t canvas_event_sample (GdkEvent const*, double* px = 0, double* py = 0) const; 2100 2101 /** computes the timeline sample (sample) of an event whose coordinates 2102 * are in window units (pixels, no scroll offset). 2103 */ 2104 samplepos_t window_event_sample (GdkEvent const*, double* px = 0, double* py = 0) const; 2105 2106 /* returns false if mouse pointer is not in track or marker canvas 2107 */ 2108 bool mouse_sample (samplepos_t&, bool& in_track_canvas) const; 2109 2110 TimeFXDialog* current_timefx; 2111 static void* timefx_thread (void* arg); 2112 void do_timefx (); 2113 2114 int time_stretch (RegionSelection&, float fraction); 2115 int pitch_shift (RegionSelection&, float cents); 2116 void pitch_shift_region (); 2117 2118 /* editor-mixer strip */ 2119 2120 MixerStrip *current_mixer_strip; 2121 bool show_editor_mixer_when_tracks_arrive; 2122 Gtk::VBox current_mixer_strip_vbox; 2123 void cms_new (boost::shared_ptr<ARDOUR::Route>); 2124 void current_mixer_strip_hidden (); 2125 2126 #ifdef __APPLE__ 2127 void ensure_all_elements_drawn (); 2128 #endif 2129 /* nudging tracks */ 2130 2131 void nudge_track (bool use_edit_point, bool forwards); 2132 2133 static const int32_t default_width = 995; 2134 static const int32_t default_height = 765; 2135 2136 /* nudge */ 2137 2138 ArdourWidgets::ArdourButton nudge_forward_button; 2139 ArdourWidgets::ArdourButton nudge_backward_button; 2140 Gtk::HBox nudge_hbox; 2141 Gtk::VBox nudge_vbox; 2142 AudioClock* nudge_clock; 2143 2144 bool nudge_forward_release (GdkEventButton*); 2145 bool nudge_backward_release (GdkEventButton*); 2146 2147 /* audio filters */ 2148 2149 void apply_filter (ARDOUR::Filter&, std::string cmd, ProgressReporter* progress = 0); 2150 2151 Command* apply_midi_note_edit_op_to_region (ARDOUR::MidiOperator& op, MidiRegionView& mrv); 2152 void apply_midi_note_edit_op (ARDOUR::MidiOperator& op, const RegionSelection& rs); 2153 2154 /* handling cleanup */ 2155 2156 int playlist_deletion_dialog (boost::shared_ptr<ARDOUR::Playlist>); 2157 2158 PBD::ScopedConnectionList session_connections; 2159 2160 /* tracking step changes of track height */ 2161 2162 TimeAxisView* current_stepping_trackview; 2163 PBD::microseconds_t last_track_height_step_timestamp; 2164 gint track_height_step_timeout(); 2165 sigc::connection step_timeout; 2166 2167 TimeAxisView* entered_track; 2168 /** If the mouse is over a RegionView or one of its child canvas items, this is set up 2169 to point to the RegionView. Otherwise it is 0. 2170 */ 2171 RegionView* entered_regionview; 2172 2173 std::vector<EnterContext> _enter_stack; 2174 2175 bool clear_entered_track; 2176 bool left_track_canvas (GdkEventCrossing*); 2177 bool entered_track_canvas (GdkEventCrossing*); 2178 void set_entered_track (TimeAxisView*); 2179 void set_entered_regionview (RegionView*); 2180 gint left_automation_track (); 2181 2182 void reset_canvas_action_sensitivity (bool); 2183 void set_gain_envelope_visibility (); 2184 void set_region_gain_visibility (RegionView*); 2185 void toggle_gain_envelope_active (); 2186 void reset_region_gain_envelopes (); 2187 2188 void session_state_saved (std::string); 2189 2190 Glib::RefPtr<Gtk::Action> undo_action; 2191 Glib::RefPtr<Gtk::Action> redo_action; 2192 Glib::RefPtr<Gtk::Action> alternate_redo_action; 2193 Glib::RefPtr<Gtk::Action> alternate_alternate_redo_action; 2194 Glib::RefPtr<Gtk::Action> selection_undo_action; 2195 Glib::RefPtr<Gtk::Action> selection_redo_action; 2196 2197 void history_changed (); 2198 2199 Editing::EditPoint _edit_point; 2200 2201 ArdourWidgets::ArdourDropdown edit_point_selector; 2202 void build_edit_point_menu(); 2203 2204 void set_edit_point_preference (Editing::EditPoint ep, bool force = false); 2205 void cycle_edit_point (bool with_marker); 2206 void set_edit_point (); 2207 void edit_point_selection_done (Editing::EditPoint); 2208 void edit_point_chosen (Editing::EditPoint); 2209 Glib::RefPtr<Gtk::RadioAction> edit_point_action (Editing::EditPoint); 2210 std::vector<std::string> edit_point_strings; 2211 std::vector<std::string> edit_mode_strings; 2212 2213 void selected_marker_moved (ARDOUR::Location*); 2214 2215 bool get_edit_op_range (samplepos_t& start, samplepos_t& end) const; 2216 2217 void get_regions_at (RegionSelection&, samplepos_t where, const TrackViewList& ts) const; 2218 void get_regions_after (RegionSelection&, samplepos_t where, const TrackViewList& ts) const; 2219 2220 RegionSelection get_regions_from_selection_and_edit_point (Editing::EditIgnoreOption = Editing::EDIT_IGNORE_NONE, 2221 bool use_context_click = false, 2222 bool from_outside_canvas = false); 2223 RegionSelection get_regions_from_selection_and_entered () const; 2224 2225 void start_updating_meters (); 2226 void stop_updating_meters (); 2227 bool meters_running; 2228 2229 void select_next_stripable (bool routes_only = true); 2230 void select_prev_stripable (bool routes_only = true); 2231 2232 ARDOUR::MusicSample snap_to_minsec (ARDOUR::MusicSample start, 2233 ARDOUR::RoundMode direction, 2234 ARDOUR::SnapPref gpref); 2235 2236 ARDOUR::MusicSample snap_to_cd_frames (ARDOUR::MusicSample start, 2237 ARDOUR::RoundMode direction, 2238 ARDOUR::SnapPref gpref); 2239 2240 ARDOUR::MusicSample snap_to_bbt (ARDOUR::MusicSample start, 2241 ARDOUR::RoundMode direction, 2242 ARDOUR::SnapPref gpref); 2243 2244 ARDOUR::MusicSample snap_to_timecode (ARDOUR::MusicSample start, 2245 ARDOUR::RoundMode direction, 2246 ARDOUR::SnapPref gpref); 2247 2248 ARDOUR::MusicSample snap_to_grid (ARDOUR::MusicSample start, 2249 ARDOUR::RoundMode direction, 2250 ARDOUR::SnapPref gpref); 2251 2252 void snap_to_internal (ARDOUR::MusicSample& first, 2253 ARDOUR::RoundMode direction = ARDOUR::RoundNearest, 2254 ARDOUR::SnapPref gpref = ARDOUR::SnapToAny_Visual, 2255 bool ensure_snap = false); 2256 2257 samplepos_t snap_to_marker (samplepos_t presnap, 2258 ARDOUR::RoundMode direction = ARDOUR::RoundNearest); 2259 2260 RhythmFerret* rhythm_ferret; 2261 2262 void fit_tracks (TrackViewList &); 2263 void fit_selection (); 2264 void set_track_height (Height); 2265 2266 void _remove_tracks (); 2267 bool idle_remove_tracks (); 2268 void toggle_tracks_active (); 2269 2270 bool _have_idled; 2271 int resize_idle_id; 2272 static gboolean _idle_resize (gpointer); 2273 bool idle_resize(); 2274 int32_t _pending_resize_amount; 2275 TimeAxisView* _pending_resize_view; 2276 2277 void visible_order_range (int*, int*) const; 2278 2279 void located (); 2280 2281 /** true if we've made a locate request that hasn't yet been processed */ 2282 bool _pending_locate_request; 2283 2284 /** if true, there is a pending Session locate which is the initial one when loading a session; 2285 we need to know this so that we don't (necessarily) set the viewport to show the playhead 2286 initially. 2287 */ 2288 bool _pending_initial_locate; 2289 2290 Gtk::HBox _summary_hbox; 2291 EditorSummary* _summary; 2292 2293 void region_view_added (RegionView*); 2294 void region_view_removed (); 2295 2296 EditorGroupTabs* _group_tabs; 2297 void fit_route_group (ARDOUR::RouteGroup*); 2298 2299 void step_edit_status_change (bool); 2300 void start_step_editing (); 2301 void stop_step_editing (); 2302 bool check_step_edit (); 2303 sigc::connection step_edit_connection; 2304 2305 double _last_motion_y; 2306 2307 RegionLayeringOrderEditor* layering_order_editor; 2308 void update_region_layering_order_editor (); 2309 2310 /** Track that was the source for the last cut/copy operation. Used as a place 2311 to paste things iff there is no selected track. 2312 */ 2313 TimeAxisView* _last_cut_copy_source_track; 2314 2315 /** true if a change in Selection->regions should change the selection in the region list. 2316 See EditorRegions::selection_changed. 2317 */ 2318 bool _region_selection_change_updates_region_list; 2319 2320 void setup_fade_images (); 2321 std::map<ARDOUR::FadeShape, Gtk::Image*> _xfade_in_images; 2322 std::map<ARDOUR::FadeShape, Gtk::Image*> _xfade_out_images; 2323 2324 Gtk::MenuItem& action_menu_item (std::string const &); 2325 void action_pre_activated (Glib::RefPtr<Gtk::Action> const &); 2326 2327 MouseCursors* _cursors; 2328 2329 void follow_mixer_selection (); 2330 bool _following_mixer_selection; 2331 2332 /* RTAV Automation display option */ 2333 void toggle_show_touched_automation (); 2334 void set_show_touched_automation (bool); 2335 bool _show_touched_automation; 2336 2337 int time_fx (ARDOUR::RegionList&, float val, bool pitching); 2338 void note_edit_done (int, EditNoteDialog*); 2339 void toggle_sound_midi_notes (); 2340 2341 /** Flag for a bit of a hack wrt control point selection; see set_selected_control_point_from_click */ 2342 bool _control_point_toggled_on_press; 2343 2344 /** This is used by TimeAxisView to keep a track of the TimeAxisView that is currently being 2345 stepped in height using ScrollZoomVerticalModifier+Scrollwheel. When a scroll event 2346 occurs, we do the step on this _stepping_axis_view if it is non-0 (and we set up this 2347 _stepping_axis_view with the TimeAxisView underneath the mouse if it is 0). Then Editor 2348 resets _stepping_axis_view when the modifier key is released. In this (hacky) way, 2349 pushing the modifier key and moving the scroll wheel will operate on the same track 2350 until the key is released (rather than skipping about to whatever happens to be 2351 underneath the mouse at the time). 2352 */ 2353 TimeAxisView* _stepping_axis_view; 2354 void zoom_vertical_modifier_released(); 2355 2356 void bring_in_callback (Gtk::Label*, uint32_t n, uint32_t total, std::string name); 2357 void update_bring_in_message (Gtk::Label* label, uint32_t n, uint32_t total, std::string name); 2358 void bring_all_sources_into_session (); 2359 2360 QuantizeDialog* quantize_dialog; 2361 MainMenuDisabler* _main_menu_disabler; 2362 2363 /* MIDI actions, proxied to selected MidiRegionView(s) */ 2364 void midi_action (void (MidiRegionView::*method)()); 2365 std::vector<MidiRegionView*> filter_to_unique_midi_region_views (RegionSelection const & ms) const; 2366 2367 /* private helper functions to help with registering region actions */ 2368 2369 Glib::RefPtr<Gtk::Action> register_region_action (Glib::RefPtr<Gtk::ActionGroup> group, Editing::RegionActionTarget, char const* name, char const* label, sigc::slot<void> slot); 2370 void register_toggle_region_action (Glib::RefPtr<Gtk::ActionGroup> group, Editing::RegionActionTarget, char const* name, char const* label, sigc::slot<void> slot); 2371 2372 Glib::RefPtr<Gtk::Action> reg_sens (Glib::RefPtr<Gtk::ActionGroup> group, char const* name, char const* label, sigc::slot<void> slot); 2373 void toggle_reg_sens (Glib::RefPtr<Gtk::ActionGroup> group, char const* name, char const* label, sigc::slot<void> slot); 2374 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); 2375 2376 void remove_gap_marker_callback (samplepos_t at, samplecnt_t distance); 2377 2378 friend class Drag; 2379 friend class RegionCutDrag; 2380 friend class RegionDrag; 2381 friend class RegionMoveDrag; 2382 friend class RegionSpliceDrag; 2383 friend class RegionRippleDrag; 2384 friend class TrimDrag; 2385 friend class BBTRulerDrag; 2386 friend class MeterMarkerDrag; 2387 friend class TempoMarkerDrag; 2388 friend class CursorDrag; 2389 friend class FadeInDrag; 2390 friend class FadeOutDrag; 2391 friend class MarkerDrag; 2392 friend class RegionGainDrag; 2393 friend class ControlPointDrag; 2394 friend class LineDrag; 2395 friend class RubberbandSelectDrag; 2396 friend class EditorRubberbandSelectDrag; 2397 friend class TimeFXDrag; 2398 friend class ScrubDrag; 2399 friend class SelectionDrag; 2400 friend class RangeMarkerBarDrag; 2401 friend class MouseZoomDrag; 2402 friend class RegionCreateDrag; 2403 friend class RegionMotionDrag; 2404 friend class RegionInsertDrag; 2405 friend class VideoTimeLineDrag; 2406 2407 friend class EditorSummary; 2408 friend class EditorGroupTabs; 2409 2410 friend class EditorRoutes; 2411 friend class RhythmFerret; 2412 }; 2413 2414 #endif /* __ardour_editor_h__ */ 2415