-
Notifications
You must be signed in to change notification settings - Fork 716
/
Copy patheditor.h
2388 lines (1851 loc) · 81.3 KB
/
editor.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright (C) 2005-2006 Taybin Rutkin <[email protected]>
* Copyright (C) 2005-2007 Doug McLain <[email protected]>
* Copyright (C) 2005-2018 Paul Davis <[email protected]>
* Copyright (C) 2005 Karsten Wiese <[email protected]>
* Copyright (C) 2006-2009 Sampo Savolainen <[email protected]>
* Copyright (C) 2006-2015 David Robillard <[email protected]>
* Copyright (C) 2006-2017 Tim Mayberry <[email protected]>
* Copyright (C) 2007-2012 Carl Hetherington <[email protected]>
* Copyright (C) 2008-2011 Sakari Bergen <[email protected]>
* Copyright (C) 2008 Hans Baier <[email protected]>
* Copyright (C) 2013-2015 Colin Fletcher <[email protected]>
* Copyright (C) 2013-2019 Robin Gareus <[email protected]>
* Copyright (C) 2014-2017 Nick Mainsbridge <[email protected]>
* Copyright (C) 2014-2019 Ben Loftis <[email protected]>
* Copyright (C) 2015-2019 Damien Zammit <[email protected]>
* Copyright (C) 2015 André Nusser <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ardour_editor_h__
#define __ardour_editor_h__
#include <sys/time.h>
#include <cmath>
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <boost/optional.hpp>
#include <gtkmm/comboboxtext.h>
#include <gtkmm/layout.h>
#include "gtkmm2ext/bindings.h"
#include "gtkmm2ext/dndtreeview.h"
#include "pbd/stateful.h"
#include "pbd/signals.h"
#include "ardour/import_status.h"
#include "ardour/tempo.h"
#include "ardour/location.h"
#include "ardour/types.h"
#include "canvas/fwd.h"
#include "canvas/ruler.h"
#include "widgets/ardour_button.h"
#include "widgets/ardour_dropdown.h"
#include "widgets/pane.h"
#include "ardour_dialog.h"
#include "public_editor.h"
#include "editing.h"
#include "enums.h"
#include "editor_items.h"
#include "region_selection.h"
#include "selection_memento.h"
#include "tempo_curve.h"
#include "ptformat/ptformat.h"
namespace Gtkmm2ext {
class Bindings;
}
namespace Evoral {
class SMF;
}
namespace ARDOUR {
class AudioPlaylist;
class AudioRegion;
class AudioTrack;
class ChanCount;
class Filter;
class Location;
class MidiOperator;
class MidiRegion;
class MidiTrack;
class Playlist;
class Region;
class RouteGroup;
class Session;
class TempoSection;
class Track;
}
namespace LADSPA {
class Plugin;
}
class AnalysisWindow;
class AudioClock;
class AudioRegionView;
class AudioStreamView;
class AudioTimeAxisView;
class AutomationLine;
class AutomationSelection;
class AutomationTimeAxisView;
class BundleManager;
class ControlPoint;
class CursorContext;
class DragManager;
class EditNoteDialog;
class EditorCursor;
class EditorGroupTabs;
class EditorLocations;
class EditorRegions;
class EditorSources;
class EditorRoutes;
class EditorRouteGroups;
class EditorSnapshots;
class EditorSummary;
class GUIObjectState;
class ArdourMarker;
class MidiRegionView;
class MidiExportDialog;
class MixerStrip;
class MouseCursors;
class NoteBase;
class PlaylistSelector;
class PluginSelector;
class ProgressReporter;
class QuantizeDialog;
class RegionPeakCursor;
class RhythmFerret;
class RulerDialog;
class Selection;
class SoundFileOmega;
class StreamView;
class GridLines;
class TempoLines;
class TimeAxisView;
class TimeInfoBox;
class TimeFXDialog;
class TimeSelection;
class RegionLayeringOrderEditor;
class VerboseCursor;
class Editor : public PublicEditor, public PBD::ScopedConnectionList
{
public:
Editor ();
~Editor ();
void set_session (ARDOUR::Session*);
Gtk::Window* use_own_window (bool and_fill_it);
void first_idle ();
virtual bool have_idled () const { return _have_idled; }
bool pending_locate_request() const { return _pending_locate_request; }
samplepos_t leftmost_sample() const { return _leftmost_sample; }
samplecnt_t current_page_samples() const {
return (samplecnt_t) _visible_canvas_width* samples_per_pixel;
}
double visible_canvas_height () const {
return _visible_canvas_height;
}
double trackviews_height () const;
void cycle_snap_mode ();
void next_grid_choice ();
void prev_grid_choice ();
void set_grid_to (Editing::GridType);
void set_snap_mode (Editing::SnapMode);
Editing::SnapMode snap_mode () const;
Editing::GridType grid_type () const;
bool grid_musical () const;
bool grid_nonmusical () const;
void undo (uint32_t n = 1);
void redo (uint32_t n = 1);
XMLNode& get_state ();
int set_state (const XMLNode&, int version);
void set_mouse_mode (Editing::MouseMode, bool force = false);
void step_mouse_mode (bool next);
Editing::MouseMode current_mouse_mode () const { return mouse_mode; }
Editing::MidiEditMode current_midi_edit_mode () const;
void remove_midi_note (ArdourCanvas::Item*, GdkEvent*);
bool internal_editing() const;
void foreach_time_axis_view (sigc::slot<void,TimeAxisView&>);
void add_to_idle_resize (TimeAxisView*, int32_t);
StripableTimeAxisView* get_stripable_time_axis_by_id (const PBD::ID& id) const;
void consider_auditioning (boost::shared_ptr<ARDOUR::Region>);
void hide_a_region (boost::shared_ptr<ARDOUR::Region>);
void show_a_region (boost::shared_ptr<ARDOUR::Region>);
#ifdef USE_RUBBERBAND
std::vector<std::string> rb_opt_strings;
int rb_current_opt;
#endif
/* things that need to be public to be used in the main menubar */
void new_region_from_selection ();
void separate_regions_between (const TimeSelection&);
void separate_region_from_selection ();
void separate_under_selected_regions ();
void separate_region_from_punch ();
void separate_region_from_loop ();
void separate_regions_using_location (ARDOUR::Location&);
void transition_to_rolling (bool forward);
/* NOTE: these functions assume that the "pixel" coordinate is
in canvas coordinates. These coordinates already take into
account any scrolling offsets.
*/
samplepos_t pixel_to_sample_from_event (double pixel) const {
/* pixel can be less than zero when motion events
are processed. since we've already run the world->canvas
affine, that means that the location *really* is "off
to the right" and thus really is "before the start".
*/
if (pixel >= 0) {
return pixel * samples_per_pixel;
} else {
return 0;
}
}
samplepos_t pixel_to_sample (double pixel) const {
return pixel * samples_per_pixel;
}
double sample_to_pixel (samplepos_t sample) const {
return round (sample / (double) samples_per_pixel);
}
double sample_to_pixel_unrounded (samplepos_t sample) const {
return sample / (double) samples_per_pixel;
}
/* selection */
Selection& get_selection() const { return *selection; }
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
Selection& get_cut_buffer() const { return *cut_buffer; }
void set_selection (std::list<Selectable*>, Selection::Operation);
void set_selected_midi_region_view (MidiRegionView&);
bool extend_selection_to_track (TimeAxisView&);
void play_selection ();
void maybe_locate_with_edit_preroll (samplepos_t);
void play_with_preroll ();
void rec_with_preroll ();
void rec_with_count_in ();
void select_all_in_track (Selection::Operation op);
void select_all_objects (Selection::Operation op);
void invert_selection_in_track ();
void invert_selection ();
void deselect_all ();
long select_range (samplepos_t, samplepos_t);
void set_selected_regionview_from_region_list (boost::shared_ptr<ARDOUR::Region> region, Selection::Operation op = Selection::Set);
void remove_tracks ();
/* tempo */
void update_grid ();
/* analysis window */
void loudness_analyze_region_selection();
void loudness_analyze_range_selection();
void spectral_analyze_region_selection();
void spectral_analyze_range_selection();
/* export */
void export_audio ();
void stem_export ();
void export_selection ();
void export_range ();
void export_region ();
/* export for analysis only */
void measure_master_loudness (bool);
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; }
samplecnt_t get_current_zoom () const { return samples_per_pixel; }
void cycle_zoom_focus ();
void temporal_zoom_step (bool zoom_out);
void temporal_zoom_step_scale (bool zoom_out, double scale);
void temporal_zoom_step_mouse_focus (bool zoom_out);
void temporal_zoom_step_mouse_focus_scale (bool zoom_out, double scale);
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);
/* stuff that AudioTimeAxisView and related classes use */
PlaylistSelector& playlist_selector() const;
void clear_playlist (boost::shared_ptr<ARDOUR::Playlist>);
void new_playlists (TimeAxisView* v);
void copy_playlists (TimeAxisView* v);
void clear_playlists (TimeAxisView* v);
void get_onscreen_tracks (TrackViewList&);
Width editor_mixer_strip_width;
void maybe_add_mixer_strip_width (XMLNode&);
void show_editor_mixer (bool yn);
void create_editor_mixer ();
void show_editor_list (bool yn);
void set_selected_mixer_strip (TimeAxisView&);
void mixer_strip_width_changed ();
void hide_track_in_display (TimeAxisView* tv, bool apply_to_selection = false);
void show_track_in_display (TimeAxisView* tv, bool move_into_view = false);
void tempo_curve_selected (ARDOUR::TempoSection* ts, bool yn);
/* nudge is initiated by transport controls owned by ARDOUR_UI */
samplecnt_t get_nudge_distance (samplepos_t pos, samplecnt_t& next);
samplecnt_t get_paste_offset (samplepos_t pos, unsigned paste_count, samplecnt_t duration);
unsigned get_grid_beat_divisions(samplepos_t position);
Temporal::Beats get_grid_type_as_beats (bool& success, samplepos_t position);
int32_t get_grid_music_divisions (uint32_t event_state);
void nudge_forward (bool next, bool force_playhead);
void nudge_backward (bool next, bool force_playhead);
/* nudge initiated from context menu */
void nudge_forward_capture_offset ();
void nudge_backward_capture_offset ();
void sequence_regions ();
/* playhead/screen stuff */
void set_stationary_playhead (bool yn);
void toggle_stationary_playhead ();
bool stationary_playhead() const { return _stationary_playhead; }
void set_follow_playhead (bool yn, bool catch_up = true);
void toggle_follow_playhead ();
bool follow_playhead() const { return _follow_playhead; }
bool dragging_playhead () const { return _dragging_playhead; }
void toggle_zero_line_visibility ();
void set_summary ();
void set_group_tabs ();
/* returns the left-most and right-most time that the gui should allow the user to scroll to */
std::pair <samplepos_t,samplepos_t> session_gui_extents (bool use_extra = true) const;
/* fades */
void toggle_region_fades (int dir);
void update_region_fade_visibility ();
/* floating windows/transient */
void ensure_float (Gtk::Window&);
void scroll_tracks_down_line ();
void scroll_tracks_up_line ();
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 select_topmost_track ();
void cleanup_regions ();
void prepare_for_cleanup ();
void finish_cleanup ();
void maximise_editing_space();
void restore_editing_space();
double get_y_origin () const;
void reset_x_origin (samplepos_t);
void reset_x_origin_to_follow_playhead ();
void reset_y_origin (double);
void reset_zoom (samplecnt_t);
void reposition_and_zoom (samplepos_t, double);
samplepos_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 ();
void toggle_meter_updating();
void show_rhythm_ferret();
void goto_visual_state (uint32_t);
void save_visual_state (uint32_t);
void queue_draw_resize_line (int at);
void start_resize_line_ops ();
void end_resize_line_ops ();
TrackViewList const & get_track_views () const {
return track_views;
}
int get_regionview_count_from_region_list (boost::shared_ptr<ARDOUR::Region>);
void do_ptimport(std::string path, ARDOUR::SrcQuality quality);
void do_import (std::vector<std::string> paths,
Editing::ImportDisposition disposition,
Editing::ImportMode mode,
ARDOUR::SrcQuality quality,
ARDOUR::MidiTrackNameSource mts,
ARDOUR::MidiTempoMapDisposition mtd,
samplepos_t& pos,
boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>());
void do_embed (std::vector<std::string> paths,
Editing::ImportDisposition disposition,
Editing::ImportMode mode,
samplepos_t& pos,
boost::shared_ptr<ARDOUR::PluginInfo> instrument = boost::shared_ptr<ARDOUR::PluginInfo>());
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<Temporal::Beats> > > > >&) const;
void center_screen (samplepos_t);
TrackViewList axis_views_from_routes (boost::shared_ptr<ARDOUR::RouteList>) const;
void snap_to (ARDOUR::MusicSample& first,
ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
ARDOUR::SnapPref pref = ARDOUR::SnapToAny_Visual,
bool ensure_snap = false);
void snap_to_with_modifier (ARDOUR::MusicSample& first,
GdkEvent const* ev,
ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
ARDOUR::SnapPref pref = ARDOUR::SnapToAny_Visual);
void set_snapped_cursor_position (samplepos_t pos);
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 ();
MixerStrip* get_current_mixer_strip () const {
return current_mixer_strip;
}
DragManager* drags () const {
return _drags;
}
bool drag_active () const;
bool preview_video_drag_active () const;
void maybe_autoscroll (bool, bool, bool);
bool autoscroll_active() const;
Gdk::Cursor* get_canvas_cursor () const;
void set_current_trimmable (boost::shared_ptr<ARDOUR::Trimmable>);
void set_current_movable (boost::shared_ptr<ARDOUR::Movable>);
MouseCursors const* cursors () const {
return _cursors;
}
VerboseCursor* verbose_cursor () const {
return _verbose_cursor;
}
double clamp_verbose_cursor_x (double);
double clamp_verbose_cursor_y (double);
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_hvscroll_group () const { return hv_scroll_group; }
ArdourCanvas::ScrollGroup* get_cursor_scroll_group () const { return cursor_scroll_group; }
ArdourCanvas::Container* get_drag_motion_group () const { return _drag_motion_group; }
ArdourCanvas::GtkCanvasViewport* get_track_canvas () const;
void override_visible_track_count ();
/* Ruler metrics methods */
void metric_get_timecode (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint);
void metric_get_bbt (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint);
void metric_get_samples (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint);
void metric_get_minsec (std::vector<ArdourCanvas::Ruler::Mark>&, gdouble, gdouble, gint);
/* editing operations that need to be public */
void mouse_add_new_marker (samplepos_t where, bool is_cd=false);
void split_regions_at (ARDOUR::MusicSample, 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 (samplepos_t);
void mouse_add_new_tempo_event (samplepos_t where);
void mouse_add_new_meter_event (samplepos_t where);
void edit_tempo_section (ARDOUR::TempoSection*);
void edit_meter_section (ARDOUR::MeterSection*);
protected:
void map_transport_state ();
void map_position_change (samplepos_t);
void transport_looped ();
void on_realize();
void suspend_route_redisplay ();
void resume_route_redisplay ();
private:
void color_handler ();
bool constructed;
// to keep track of the playhead position for control_scroll
boost::optional<samplepos_t> _control_scroll_target;
PlaylistSelector* _playlist_selector;
TimeInfoBox* _time_info_box;
typedef std::pair<TimeAxisView*,XMLNode*> TAVState;
struct VisualState {
VisualState (bool with_tracks);
~VisualState ();
double y_position;
samplecnt_t samples_per_pixel;
samplepos_t _leftmost_sample;
Editing::ZoomFocus zoom_focus;
GUIObjectState* gui_state;
};
std::list<VisualState*> undo_visual_stack;
std::list<VisualState*> redo_visual_stack;
VisualState* current_visual_state (bool with_tracks = true);
void undo_visual_state ();
void redo_visual_state ();
void use_visual_state (VisualState&);
bool no_save_visual;
void swap_visual_state ();
std::vector<VisualState*> visual_states;
void start_visual_state_op (uint32_t n);
void cancel_visual_state_op (uint32_t n);
samplepos_t _leftmost_sample;
samplecnt_t samples_per_pixel;
Editing::ZoomFocus zoom_focus;
void set_samples_per_pixel (samplecnt_t);
void on_samples_per_pixel_changed ();
Editing::MouseMode mouse_mode;
Editing::GridType pre_internal_grid_type;
Editing::SnapMode pre_internal_snap_mode;
Editing::GridType internal_grid_type;
Editing::SnapMode internal_snap_mode;
Editing::MouseMode effective_mouse_mode () const;
enum JoinObjectRangeState {
JOIN_OBJECT_RANGE_NONE,
/** `join object/range' mode is active and the mouse is over a place where object mode should happen */
JOIN_OBJECT_RANGE_OBJECT,
/** `join object/range' mode is active and the mouse is over a place where range mode should happen */
JOIN_OBJECT_RANGE_RANGE
};
JoinObjectRangeState _join_object_range_state;
void update_join_object_range_location (double);
boost::optional<float> pre_notebook_shrink_pane_width;
Gtk::VBox _editor_list_vbox;
Gtk::Notebook _the_notebook;
bool _notebook_shrunk;
void add_notebook_page (std::string const&, Gtk::Widget&);
bool notebook_tab_clicked (GdkEventButton*, Gtk::Widget*);
ArdourWidgets::HPane edit_pane;
ArdourWidgets::VPane editor_summary_pane;
Gtk::EventBox meter_base;
Gtk::EventBox marker_base;
Gtk::HBox marker_box;
Gtk::VBox scrollers_rulers_markers_box;
void location_changed (ARDOUR::Location*);
void location_flags_changed (ARDOUR::Location*);
void refresh_location_display ();
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*);
void remove_marker (ArdourCanvas::Item&, GdkEvent*);
gint really_remove_marker (ARDOUR::Location* loc);
void goto_nth_marker (int nth);
void trigger_script (int nth);
void trigger_script_by_name (const std::string script_name);
void toggle_marker_lines ();
void set_marker_line_visibility (bool);
void jump_forward_to_mark ();
void jump_backward_to_mark ();
uint32_t location_marker_color;
uint32_t location_range_color;
uint32_t location_loop_color;
uint32_t location_punch_color;
uint32_t location_cd_marker_color;
struct LocationMarkers {
ArdourMarker* start;
ArdourMarker* end;
bool valid;
LocationMarkers () : start(0), end(0), valid (true) {}
~LocationMarkers ();
void hide ();
void show ();
void set_show_lines (bool);
void set_selected (bool);
void canvas_height_set (double);
void setup_lines ();
void set_name (const std::string&);
void set_position (samplepos_t start, samplepos_t end = 0);
void set_color_rgba (uint32_t);
};
LocationMarkers* find_location_markers (ARDOUR::Location*) const;
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;
LocationMarkerMap location_markers;
void update_marker_labels ();
void update_marker_labels (ArdourCanvas::Container*);
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
* are kept sorted in time order between marker movements, so that after
* 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<ArdourMarker*> > _sorted_marker_lists;
void remove_sorted_marker (ArdourMarker*);
void hide_marker (ArdourCanvas::Item*, GdkEvent*);
void clear_marker_display ();
void mouse_add_new_range (samplepos_t);
void mouse_add_new_loop (samplepos_t);
void mouse_add_new_punch (samplepos_t);
bool choose_new_marker_name(std::string &name, bool is_range=false);
void update_cd_marker_display ();
void ensure_cd_marker_updated (LocationMarkers* lam, ARDOUR::Location* location);
TimeAxisView* clicked_axisview;
RouteTimeAxisView* clicked_routeview;
/** The last RegionView that was clicked on, or 0 if the last click was not
* on a RegionView. This is set up by the canvas event handlers in
* editor_canvas_events.cc
*/
RegionView* clicked_regionview;
RegionSelection latest_regionviews;
uint32_t clicked_selection;
ControlPoint* clicked_control_point;
void sort_track_selection (TrackViewList&);
void get_equivalent_regions (RegionView* rv, std::vector<RegionView*> &, PBD::PropertyID) const;
RegionSelection get_equivalent_regions (RegionSelection &, PBD::PropertyID) const;
RegionView* regionview_from_region (boost::shared_ptr<ARDOUR::Region>) const;
RouteTimeAxisView* rtav_from_route (boost::shared_ptr<ARDOUR::Route>) const;
void mapover_tracks (sigc::slot<void,RouteTimeAxisView&,uint32_t> sl, TimeAxisView*, PBD::PropertyID) const;
void mapover_tracks_with_unique_playlists (sigc::slot<void,RouteTimeAxisView&,uint32_t> sl, TimeAxisView*, PBD::PropertyID) const;
/* functions to be passed to mapover_tracks(), possibly with sigc::bind()-supplied arguments */
void mapped_get_equivalent_regions (RouteTimeAxisView&, uint32_t, RegionView*, std::vector<RegionView*>*) const;
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_visible_lanes ();
void select_all_tracks ();
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 set_selected_track_as_side_effect (Selection::Operation op);
bool selection_contains_isolated_equivalent_region ();
bool set_selected_regionview_from_click (bool press, Selection::Operation op = Selection::Set);
bool set_selected_regionview_from_map_event (GdkEventAny*, StreamView*, boost::weak_ptr<ARDOUR::Region>);
void collect_new_region_view (RegionView*);
void collect_and_select_new_region_view (RegionView*);
Gtk::Menu track_context_menu;
Gtk::Menu track_region_context_menu;
Gtk::Menu track_selection_context_menu;
GdkEvent context_click_event;
void popup_track_context_menu (int, int, ItemType, bool);
Gtk::Menu* build_track_context_menu ();
Gtk::Menu* build_track_bus_context_menu ();
Gtk::Menu* build_track_region_context_menu ();
Gtk::Menu* build_track_selection_context_menu ();
void add_dstream_context_items (Gtk::Menu_Helpers::MenuList&);
void add_bus_context_items (Gtk::Menu_Helpers::MenuList&);
void add_region_context_items (Gtk::Menu_Helpers::MenuList&, boost::shared_ptr<ARDOUR::Track>);
void add_selection_context_items (Gtk::Menu_Helpers::MenuList&);
Gtk::MenuItem* _popup_region_menu_item;
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_stripables (ARDOUR::StripableList&);
void add_routes (ARDOUR::RouteList&);
void timeaxisview_deleted (TimeAxisView*);
void add_vcas (ARDOUR::VCAList&);
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 ();
Gdk::Cursor* which_track_cursor () const;
Gdk::Cursor* which_mode_cursor () const;
Gdk::Cursor* which_trim_cursor (bool left_side) const;
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;
bool within_track_canvas;
friend class VerboseCursor;
VerboseCursor* _verbose_cursor;
RegionPeakCursor* _region_peak_cursor;
void parameter_changed (std::string);
void ui_parameter_changed (std::string);
Gtk::EventBox time_bars_event_box;
Gtk::VBox time_bars_vbox;
ArdourCanvas::Container* tempo_group;
ArdourCanvas::Container* meter_group;
ArdourCanvas::Container* marker_group;
ArdourCanvas::Container* range_marker_group;
ArdourCanvas::Container* transport_marker_group;
ArdourCanvas::Container* cd_marker_group;
/* parent for groups which themselves contain time markers */
ArdourCanvas::Container* _time_markers_group;
/* The group containing all other groups that are scrolled vertically
and horizontally.
*/
ArdourCanvas::ScrollGroup* hv_scroll_group;
/* The group containing all other groups that are scrolled horizontally ONLY
*/
ArdourCanvas::ScrollGroup* h_scroll_group;
/* Scroll group for cursors, scrolled horizontally, above everything else
*/
ArdourCanvas::ScrollGroup* cursor_scroll_group;
/* The group containing all trackviews. */
ArdourCanvas::Container* no_scroll_group;
/* The group containing all trackviews. */
ArdourCanvas::Container* _trackview_group;
/* The group holding things (mostly regions) while dragging so they
* are on top of everything else
*/
ArdourCanvas::Container* _drag_motion_group;
/* 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);
Glib::RefPtr<Gtk::ToggleAction> ruler_timecode_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_bbt_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_samples_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_minsec_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_tempo_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_meter_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_marker_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_range_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_loop_punch_action;
Glib::RefPtr<Gtk::ToggleAction> ruler_cd_marker_action;
bool no_ruler_shown_update;
Gtk::Widget* ruler_grabbed_widget;
RulerDialog* ruler_dialog;
void initialize_rulers ();
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 ();
void popup_ruler_menu (samplepos_t where = 0, ItemType type = RegionItem);
void update_ruler_visibility ();
void toggle_ruler_visibility ();
void ruler_toggled (int);
bool ruler_label_button_release (GdkEventButton*);
void store_ruler_visibility ();
void restore_ruler_visibility ();
void show_rulers_for_grid ();
enum MinsecRulerScale {
minsec_show_msecs,
minsec_show_seconds,
minsec_show_minutes,
minsec_show_hours,
minsec_show_many_hours
};
MinsecRulerScale minsec_ruler_scale;
samplecnt_t minsec_mark_interval;
gint minsec_mark_modulo;
gint minsec_nmarks;
void set_minsec_ruler_scale (samplepos_t, samplepos_t);
enum TimecodeRulerScale {
timecode_show_bits,
timecode_show_samples,
timecode_show_seconds,
timecode_show_minutes,
timecode_show_hours,
timecode_show_many_hours
};
TimecodeRulerScale timecode_ruler_scale;
gint timecode_mark_modulo;
gint timecode_nmarks;
void set_timecode_ruler_scale (samplepos_t, samplepos_t);
samplecnt_t _samples_ruler_interval;
void set_samples_ruler_scale (samplepos_t, samplepos_t);
enum BBTRulerScale {
bbt_show_many,
bbt_show_64,
bbt_show_16,
bbt_show_4,
bbt_show_1,
bbt_show_quarters,
bbt_show_eighths,
bbt_show_sixteenths,
bbt_show_thirtyseconds
};
BBTRulerScale bbt_ruler_scale;
uint32_t bbt_bars;
gint bbt_nmarks;
uint32_t bbt_bar_helper_on;
uint32_t bbt_accent_modulo;
void compute_bbt_ruler_scale (samplepos_t lower, samplepos_t upper);
ArdourCanvas::Ruler* timecode_ruler;
ArdourCanvas::Ruler* bbt_ruler;
ArdourCanvas::Ruler* samples_ruler;
ArdourCanvas::Ruler* minsec_ruler;
static double timebar_height;
guint32 visible_timebars;
Gtk::Menu* editor_ruler_menu;
ArdourCanvas::Rectangle* tempo_bar;
ArdourCanvas::Rectangle* meter_bar;
ArdourCanvas::Rectangle* marker_bar;
ArdourCanvas::Rectangle* range_marker_bar;
ArdourCanvas::Rectangle* transport_marker_bar;
ArdourCanvas::Rectangle* cd_marker_bar;
Gtk::Label minsec_label;