gtk2_ardour/editor.h

   1 /*
   2     Copyright (C) 2000-2003 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_editor_h__
  21 #define __ardour_editor_h__
  22
  23 #include <list>
  24 #include <map>
  25 #include <set>
  26 #include <string>
  27 #include <sys/time.h>
  28 #include <bitset>
  29
  30 #include <glibmm/ustring.h>
  31
  32 #include <boost/optional.hpp>
  33
  34 #include <libgnomecanvasmm/canvas.h>
  35 #include <libgnomecanvasmm/group.h>
  36 #include <libgnomecanvasmm/line.h>
  37 #include <libgnomecanvasmm/pixbuf.h>
  38
  39 #include <cmath>
  40
  41 #include <gtkmm/layout.h>
  42 #include <gtkmm/comboboxtext.h>
  43
  44 #include <gtkmm2ext/selector.h>
  45 #include <gtkmm2ext/click_box.h>
  46 #include <gtkmm2ext/dndtreeview.h>
  47
  48 #include "pbd/stateful.h"
  49 #include "ardour/session.h"
  50 #include "ardour/tempo.h"
  51 #include "ardour/stretch.h"
  52 #include "ardour/location.h"
  53 #include "ardour/audioregion.h"
  54 #include "ardour/track.h"
  55 #include "ardour/types.h"
  56
  57 #include "audio_clock.h"
  58 #include "gtk-custom-ruler.h"
  59 #include "ardour_dialog.h"
  60 #include "public_editor.h"
  61 #include "editing.h"
  62 #include "enums.h"
  63 #include "editor_items.h"
  64 #include "region_selection.h"
  65 #include "canvas.h"
  66 #include "editor_summary.h"
  67
  68 namespace Gtkmm2ext {
  69         class TearOff;
  70 }
  71
  72 namespace ARDOUR {
  73         class AudioDiskstream;
  74         class RouteGroup;
  75         class Playlist;
  76         class AudioPlaylist;
  77         class Region;
  78         class Location;
  79         class TempoSection;
  80         class NamedSelection;
  81         class Session;
  82         class Filter;
  83         class Crossfade;
  84         class ChanCount;
  85 }
  86
  87 namespace LADSPA {
  88         class Plugin;
  89 }
  90
  91 class AnalysisWindow;
  92 class AudioRegionView;
  93 class AudioStreamView;
  94 class AudioTimeAxisView;
  95 class AutomationLine;
  96 class AutomationSelection;
  97 class AutomationTimeAxisView;
  98 class BundleManager;
  99 class ControlPoint;
 100 class CrossfadeView;
 101 class Drag;
 102 class GlobalPortMatrixWindow;
 103 class GroupedButtons;
 104 class Marker;
 105 class MixerStrip;
 106 class PlaylistSelector;
 107 class PluginSelector;
 108 class RhythmFerret;
 109 class Selection;
 110 class SoundFileOmega;
 111 class StreamView;
 112 class TempoLines;
 113 class TimeAxisView;
 114 class TimeFXDialog;
 115 class TimeSelection;
 116 class TrackSelection;
 117
 118 /* <CMT Additions> */
 119 class ImageFrameView;
 120 class ImageFrameTimeAxisView;
 121 class ImageFrameTimeAxis;
 122 class MarkerTimeAxis ;
 123 class MarkerView ;
 124 class ImageFrameSocketHandler ;
 125 class TimeAxisViewItem ;
 126 /* </CMT Additions> */
 127
 128 struct EditorCursor {
 129         Editor&               editor;
 130         ArdourCanvas::Points  points;
 131         ArdourCanvas::Line    canvas_item;
 132         nframes64_t           current_frame;
 133         double            length;
 134
 135         EditorCursor (Editor&, bool (Editor::*)(GdkEvent*,ArdourCanvas::Item*));
 136         ~EditorCursor ();
 137
 138         void set_position (nframes64_t);
 139         void set_length (double units);
 140         void set_y_axis (double position);
 141
 142         sigc::signal<void, nframes64_t> PositionChanged;
 143 };
 144
 145 class Editor : public PublicEditor
 146 {
 147   public:
 148         Editor ();
 149         ~Editor ();
 150
 151         void             connect_to_session (ARDOUR::Session *);
 152         ARDOUR::Session* current_session() const { return session; }
 153         void             first_idle ();
 154         virtual bool     have_idled () const { return _have_idled; }
 155
 156         nframes64_t leftmost_position() const { return leftmost_frame; }
 157
 158         nframes64_t current_page_frames() const {
 159                 return (nframes64_t) floor (_canvas_width * frames_per_unit);
 160         }
 161
 162         double canvas_height () const {
 163                 return _canvas_height;
 164         }
 165
 166         void cycle_snap_mode ();
 167         void cycle_snap_choice ();
 168         void set_snap_to (Editing::SnapType);
 169         void set_snap_mode (Editing::SnapMode);
 170         void set_snap_threshold (double pixel_distance) {snap_threshold = pixel_distance;}
 171
 172         void undo (uint32_t n = 1);
 173         void redo (uint32_t n = 1);
 174
 175         XMLNode& get_state ();
 176         int set_state (const XMLNode& );
 177
 178         void set_mouse_mode (Editing::MouseMode, bool force=true);
 179         void step_mouse_mode (bool next);
 180         Editing::MouseMode current_mouse_mode () const { return mouse_mode; }
 181
 182         void set_midi_edit_cursor (Editing::MidiEditMode);
 183         void set_midi_edit_mode (Editing::MidiEditMode, bool force=true);
 184         Editing::MidiEditMode current_midi_edit_mode () const { return midi_edit_mode; }
 185
 186 #ifdef WITH_CMT
 187         void add_imageframe_time_axis(const std::string & track_name, void*) ;
 188         void add_imageframe_marker_time_axis(const std::string & track_name, TimeAxisView* marked_track, void*) ;
 189         void connect_to_image_compositor() ;
 190         void scroll_timeaxis_to_imageframe_item(const TimeAxisViewItem* item) ;
 191 #endif
 192
 193         TimeAxisView* get_named_time_axis(const std::string & name) ;
 194         void foreach_time_axis_view (sigc::slot<void,TimeAxisView&>);
 195         void add_to_idle_resize (TimeAxisView*, uint32_t);
 196
 197         RouteTimeAxisView* get_route_view_by_id (PBD::ID& id);
 198
 199         void consider_auditioning (boost::shared_ptr<ARDOUR::Region>);
 200         void hide_a_region (boost::shared_ptr<ARDOUR::Region>);
 201         void remove_a_region (boost::shared_ptr<ARDOUR::Region>);
 202
 203 #ifdef USE_RUBBERBAND
 204         std::vector<std::string> rb_opt_strings;
 205 #endif
 206
 207         /* option editor-access */
 208
 209         void set_show_waveforms_recording (bool yn);
 210         bool show_waveforms_recording() const { return _show_waveforms_recording; }
 211
 212         /* things that need to be public to be used in the main menubar */
 213
 214         void new_region_from_selection ();
 215         void separate_regions_between (const TimeSelection&);
 216         void separate_region_from_selection ();
 217         void separate_region_from_punch ();
 218         void separate_region_from_loop ();
 219         void separate_regions_using_location (ARDOUR::Location&);
 220         void toggle_playback (bool with_abort);
 221         void transition_to_rolling (bool forward);
 222
 223         /* undo related */
 224
 225         nframes64_t unit_to_frame (double unit) const {
 226                 return (nframes64_t) rint (unit * frames_per_unit);
 227         }
 228
 229         double frame_to_unit (nframes64_t frame) const {
 230                 return rint ((double) frame / (double) frames_per_unit);
 231         }
 232
 233         double frame_to_unit (double frame) const {
 234                 return rint (frame / frames_per_unit);
 235         }
 236
 237         /* NOTE: these functions assume that the "pixel" coordinate is
 238            the result of using the world->canvas affine transform on a
 239            world coordinate. These coordinates already take into
 240            account any scrolling carried out by adjusting the
 241            xscroll_adjustment.
 242         */
 243
 244         nframes64_t pixel_to_frame (double pixel) const {
 245
 246                 /* pixel can be less than zero when motion events
 247                    are processed. since we've already run the world->canvas
 248                    affine, that means that the location *really* is "off
 249                    to the right" and thus really is "before the start".
 250                 */
 251
 252                 if (pixel >= 0) {
 253                         return (nframes64_t) rint (pixel * frames_per_unit * GNOME_CANVAS(track_canvas->gobj())->pixels_per_unit);
 254                 } else {
 255                         return 0;
 256                 }
 257         }
 258
 259         gulong frame_to_pixel (nframes64_t frame) const {
 260                 return (gulong) rint ((frame / (frames_per_unit * GNOME_CANVAS(track_canvas->gobj())->pixels_per_unit)));
 261         }
 262
 263         void flush_canvas ();
 264
 265         /* selection */
 266
 267         Selection& get_selection() const { return *selection; }
 268         Selection& get_cut_buffer() const { return *cut_buffer; }
 269
 270         bool extend_selection_to_track (TimeAxisView&);
 271
 272         void play_selection ();
 273         void select_all_in_track (Selection::Operation op);
 274         void select_all (Selection::Operation op);
 275         void invert_selection_in_track ();
 276         void invert_selection ();
 277         void deselect_all ();
 278
 279         /* tempo */
 280
 281         void set_show_measures (bool yn);
 282         bool show_measures () const { return _show_measures; }
 283
 284         /* analysis window */
 285
 286         void analyze_region_selection();
 287         void analyze_range_selection();
 288
 289         /* export */
 290
 291         void export_audio ();
 292         void export_selection ();
 293         void export_range ();
 294         void export_region ();
 295
 296         void add_toplevel_controls (Gtk::Container&);
 297         Gtk::HBox& get_status_bar_packer()  { return status_bar_hpacker; }
 298
 299         void               set_zoom_focus (Editing::ZoomFocus);
 300         Editing::ZoomFocus get_zoom_focus () const { return zoom_focus; }
 301         double             get_current_zoom () const { return frames_per_unit; }
 302
 303         void temporal_zoom_step (bool coarser);
 304
 305         /* stuff that AudioTimeAxisView and related classes use */
 306
 307         PlaylistSelector& playlist_selector() const;
 308         void route_name_changed (TimeAxisView *);
 309         void clear_playlist (boost::shared_ptr<ARDOUR::Playlist>);
 310
 311         void new_playlists (TimeAxisView* v);
 312         void copy_playlists (TimeAxisView* v);
 313         void clear_playlists (TimeAxisView* v);
 314
 315         TrackViewList* get_valid_views (TimeAxisView*, ARDOUR::RouteGroup* grp = 0);
 316         void get_onscreen_tracks (TrackViewList&);
 317
 318         Width editor_mixer_strip_width;
 319         void maybe_add_mixer_strip_width (XMLNode&);
 320         void show_editor_mixer (bool yn);
 321         void create_editor_mixer ();
 322         void show_editor_list (bool yn);
 323         void set_selected_mixer_strip (TimeAxisView&);
 324         void hide_track_in_display (TimeAxisView& tv, bool temporary = false);
 325         void show_track_in_display (TimeAxisView& tv);
 326
 327         /* nudge is initiated by transport controls owned by ARDOUR_UI */
 328
 329         void nudge_forward (bool next, bool force_playhead);
 330         void nudge_backward (bool next, bool force_playhead);
 331
 332         /* nudge initiated from context menu */
 333
 334         void nudge_forward_capture_offset ();
 335         void nudge_backward_capture_offset ();
 336
 337         /* playhead/screen stuff */
 338
 339         void set_follow_playhead (bool yn);
 340         void toggle_follow_playhead ();
 341         bool follow_playhead() const { return _follow_playhead; }
 342         bool dragging_playhead () const { return _dragging_playhead; }
 343
 344         void toggle_zero_line_visibility ();
 345         void toggle_waveforms_while_recording ();
 346         void set_summary ();
 347         void toggle_measure_visibility ();
 348         void toggle_logo_visibility ();
 349
 350         double get_physical_screen_width () const { return physical_screen_width; };
 351         double physical_screen_width;
 352         double physical_screen_height;
 353
 354         /* fades/xfades */
 355
 356         void toggle_selected_region_fades (int dir);
 357         void update_region_fade_visibility ();
 358         bool xfade_visibility() const { return _xfade_visibility; }
 359         void update_xfade_visibility ();
 360
 361         /* redirect shared ops menu. caller must free returned menu */
 362
 363         Gtk::Menu* redirect_menu ();
 364
 365         /* floating windows/transient */
 366
 367         void ensure_float (Gtk::Window&);
 368
 369         void show_window ();
 370
 371         void scroll_tracks_down_line ();
 372         void scroll_tracks_up_line ();
 373
 374         void move_selected_tracks (bool up);
 375
 376         bool new_regionviews_display_gain () { return _new_regionviews_show_envelope; }
 377         void prepare_for_cleanup ();
 378         void finish_cleanup ();
 379
 380         void maximise_editing_space();
 381         void restore_editing_space();
 382
 383         void reset_x_origin (nframes64_t);
 384         void reset_y_origin (double);
 385         void reset_zoom (double);
 386         void reposition_and_zoom (nframes64_t, double);
 387
 388         nframes64_t get_preferred_edit_position (bool ignore_playhead = false);
 389
 390         bool update_mouse_speed ();
 391         bool decelerate_mouse_speed ();
 392
 393         void toggle_meter_updating();
 394
 395         void show_rhythm_ferret();
 396         void show_bundle_manager ();
 397         void show_global_port_matrix (ARDOUR::DataType);
 398
 399         void goto_visual_state (uint32_t);
 400         void save_visual_state (uint32_t);
 401
 402         void queue_draw_resize_line (int at);
 403         void start_resize_line_ops ();
 404         void end_resize_line_ops ();
 405
 406   protected:
 407         void map_transport_state ();
 408         void map_position_change (nframes64_t);
 409
 410         void on_realize();
 411         bool on_expose_event (GdkEventExpose*);
 412
 413   private:
 414
 415         /// The session that we are editing, or 0
 416         void color_handler ();
 417         ARDOUR::Session     *session;
 418         bool                 constructed;
 419
 420         // to keep track of the playhead position for control_scroll
 421         boost::optional<nframes64_t> _control_scroll_target;
 422
 423         PlaylistSelector* _playlist_selector;
 424
 425         typedef std::pair<TimeAxisView*,XMLNode*> TAVState;
 426
 427         struct VisualState {
 428             double              y_position;
 429             double              frames_per_unit;
 430             nframes64_t         leftmost_frame;
 431             Editing::ZoomFocus  zoom_focus;
 432             bool                zoomed_to_region;
 433             std::list<TAVState> track_states;
 434         };
 435
 436         std::list<VisualState*> undo_visual_stack;
 437         std::list<VisualState*> redo_visual_stack;
 438         VisualState* current_visual_state (bool with_tracks = true);
 439         void undo_visual_state ();
 440         void redo_visual_state ();
 441         void use_visual_state (VisualState&);
 442         bool no_save_visual;
 443         void swap_visual_state ();
 444
 445         std::vector<VisualState*> visual_states;
 446         sigc::connection visual_state_op_connection;
 447         void start_visual_state_op (uint32_t n);
 448         void cancel_visual_state_op (uint32_t n);
 449         bool end_visual_state_op (uint32_t n);
 450
 451         nframes64_t leftmost_frame;
 452         double      frames_per_unit;
 453         Editing::ZoomFocus zoom_focus;
 454
 455         void set_frames_per_unit (double);
 456         void post_zoom ();
 457
 458         Editing::MouseMode mouse_mode;
 459         Editing::MidiEditMode midi_edit_mode;
 460
 461         int  post_maximal_editor_width;
 462         int  post_maximal_pane_position;
 463         int  pre_maximal_pane_position;
 464         int  pre_maximal_editor_width;
 465         void pane_allocation_handler (Gtk::Allocation&, Gtk::Paned*);
 466
 467         Gtk::Notebook the_notebook;
 468         Gtk::HPaned   edit_pane;
 469
 470         Gtk::EventBox meter_base;
 471         Gtk::HBox     meter_box;
 472         Gtk::EventBox marker_base;
 473         Gtk::HBox     marker_box;
 474         Gtk::VBox     scrollers_rulers_markers_box;
 475
 476         void location_changed (ARDOUR::Location *);
 477         void location_flags_changed (ARDOUR::Location *, void *);
 478         void refresh_location_display ();
 479         void refresh_location_display_s (ARDOUR::Change);
 480         void refresh_location_display_internal (ARDOUR::Locations::LocationList&);
 481         void add_new_location (ARDOUR::Location *);
 482         void location_gone (ARDOUR::Location *);
 483         void remove_marker (ArdourCanvas::Item&, GdkEvent*);
 484         gint really_remove_marker (ARDOUR::Location* loc);
 485         void goto_nth_marker (int nth);
 486
 487         uint32_t location_marker_color;
 488         uint32_t location_range_color;
 489         uint32_t location_loop_color;
 490         uint32_t location_punch_color;
 491         uint32_t location_cd_marker_color;
 492
 493         struct LocationMarkers {
 494             Marker* start;
 495             Marker* end;
 496             bool    valid;
 497
 498             LocationMarkers () : start(0), end(0), valid (true) {}
 499
 500             ~LocationMarkers ();
 501
 502             void hide();
 503             void show ();
 504             void set_name (const std::string&);
 505             void set_position (nframes64_t start, nframes64_t end = 0);
 506             void set_color_rgba (uint32_t);
 507         };
 508
 509         LocationMarkers  *find_location_markers (ARDOUR::Location *) const;
 510         ARDOUR::Location* find_location_from_marker (Marker *, bool& is_start) const;
 511         Marker* entered_marker;
 512
 513         typedef std::map<ARDOUR::Location*,LocationMarkers *> LocationMarkerMap;
 514         LocationMarkerMap location_markers;
 515
 516         void hide_marker (ArdourCanvas::Item*, GdkEvent*);
 517         void clear_marker_display ();
 518         void mouse_add_new_marker (nframes64_t where, bool is_cd=false, bool is_xrun=false);
 519         bool choose_new_marker_name(std::string &name);
 520         void update_cd_marker_display ();
 521         void ensure_cd_marker_updated (LocationMarkers * lam, ARDOUR::Location * location);
 522
 523         TimeAxisView*      clicked_axisview;
 524         RouteTimeAxisView* clicked_routeview;
 525         /** The last RegionView that was clicked on, or 0 if the last click was not
 526          * on a RegionView.  This is set up by the canvas event handlers in
 527          * editor_canvas_events.cc
 528          */
 529         RegionView*        clicked_regionview;
 530         RegionSelection    latest_regionviews;
 531         uint32_t           clicked_selection;
 532         CrossfadeView*     clicked_crossfadeview;
 533         ControlPoint*      clicked_control_point;
 534
 535         void sort_track_selection (TrackSelection* sel = 0);
 536
 537         void get_relevant_tracks (std::set<RouteTimeAxisView*>& relevant_tracks);
 538         void get_equivalent_regions (RegionView* rv, std::vector<RegionView*>&) const;
 539         void mapover_tracks (sigc::slot<void,RouteTimeAxisView&,uint32_t> sl, TimeAxisView*) const;
 540
 541         /* functions to be passed to mapover_tracks(), possibly with sigc::bind()-supplied arguments */
 542
 543         void mapped_get_equivalent_regions (RouteTimeAxisView&, uint32_t, RegionView*, std::vector<RegionView*>*) const;
 544         void mapped_use_new_playlist (RouteTimeAxisView&, uint32_t, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
 545         void mapped_use_copy_playlist (RouteTimeAxisView&, uint32_t, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
 546         void mapped_clear_playlist (RouteTimeAxisView&, uint32_t);
 547
 548         /* end */
 549
 550         void button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type);
 551         bool button_release_can_deselect;
 552
 553         void catch_vanishing_regionview (RegionView *);
 554
 555         void set_selected_track (TimeAxisView&, Selection::Operation op = Selection::Set, bool no_remove=false);
 556         void select_all_tracks ();
 557
 558         int get_regionview_count_from_region_list (boost::shared_ptr<ARDOUR::Region> region);
 559
 560         bool set_selected_control_point_from_click (Selection::Operation op = Selection::Set, bool no_remove=false);
 561         void set_selected_track_from_click (bool press, Selection::Operation op = Selection::Set, bool no_remove=false);
 562         void set_selected_track_as_side_effect (bool force = false);
 563         bool set_selected_regionview_from_click (bool press, Selection::Operation op = Selection::Set, bool no_track_remove=false);
 564
 565         void set_selected_regionview_from_region_list (boost::shared_ptr<ARDOUR::Region> region, Selection::Operation op = Selection::Set);
 566         bool set_selected_regionview_from_map_event (GdkEventAny*, StreamView*, boost::weak_ptr<ARDOUR::Region>);
 567         void collect_new_region_view (RegionView *);
 568         void collect_and_select_new_region_view (RegionView *);
 569
 570         Gtk::Menu track_context_menu;
 571         Gtk::Menu track_region_context_menu;
 572         Gtk::Menu track_selection_context_menu;
 573         Gtk::Menu track_crossfade_context_menu;
 574
 575         Gtk::MenuItem* region_edit_menu_split_item;
 576         Gtk::MenuItem* region_edit_menu_split_multichannel_item;
 577         Gtk::Menu * track_region_edit_playlist_menu;
 578         Gtk::Menu * track_edit_playlist_submenu;
 579         Gtk::Menu * track_selection_edit_playlist_submenu;
 580
 581         void popup_track_context_menu (int, int, ItemType, bool, nframes64_t);
 582         Gtk::Menu* build_track_context_menu (nframes64_t);
 583         Gtk::Menu* build_track_bus_context_menu (nframes64_t);
 584         Gtk::Menu* build_track_region_context_menu (nframes64_t frame);
 585         Gtk::Menu* build_track_crossfade_context_menu (nframes64_t);
 586         Gtk::Menu* build_track_selection_context_menu (nframes64_t);
 587         void add_dstream_context_items (Gtk::Menu_Helpers::MenuList&);
 588         void add_bus_context_items (Gtk::Menu_Helpers::MenuList&);
 589         void add_region_context_items (StreamView*, boost::shared_ptr<ARDOUR::Region>, Gtk::Menu_Helpers::MenuList&);
 590         void add_crossfade_context_items (AudioStreamView*, boost::shared_ptr<ARDOUR::Crossfade>, Gtk::Menu_Helpers::MenuList&, bool many);
 591         void add_selection_context_items (Gtk::Menu_Helpers::MenuList&);
 592
 593         void add_item_with_sensitivity (Gtk::Menu_Helpers::MenuList&, Gtk::Menu_Helpers::MenuElem, bool) const;
 594
 595         void handle_new_route (ARDOUR::RouteList&);
 596         void remove_route (TimeAxisView *);
 597         bool route_removal;
 598
 599         Gtk::HBox           global_hpacker;
 600         Gtk::VBox           global_vpacker;
 601         Gtk::VBox           vpacker;
 602
 603         bool need_resize_line;
 604         int  resize_line_y;
 605         int  old_resize_line_y;
 606
 607         Gdk::Cursor*          current_canvas_cursor;
 608         void set_canvas_cursor ();
 609         Gdk::Cursor* which_grabber_cursor ();
 610
 611         ArdourCanvas::Canvas* track_canvas;
 612
 613         ArdourCanvas::Text* verbose_canvas_cursor;
 614         bool                 verbose_cursor_visible;
 615
 616         void parameter_changed (std::string);
 617
 618         bool track_canvas_motion (GdkEvent*);
 619
 620         void set_verbose_canvas_cursor (const std::string &, double x, double y);
 621         void set_verbose_canvas_cursor_text (const std::string &);
 622         void show_verbose_canvas_cursor();
 623         void hide_verbose_canvas_cursor();
 624
 625         bool verbose_cursor_on; // so far unused
 626
 627         Gtk::EventBox             time_canvas_event_box;
 628         Gtk::EventBox             track_canvas_event_box;
 629         Gtk::EventBox             time_button_event_box;
 630         Gtk::EventBox             ruler_label_event_box;
 631
 632         ArdourCanvas::Group      *minsec_group;
 633         ArdourCanvas::Pixbuf     *logo_item;
 634         ArdourCanvas::Group      *bbt_group;
 635         ArdourCanvas::Group      *smpte_group;
 636         ArdourCanvas::Group      *frame_group;
 637         ArdourCanvas::Group      *tempo_group;
 638         ArdourCanvas::Group      *meter_group;
 639         ArdourCanvas::Group      *marker_group;
 640         ArdourCanvas::Group      *range_marker_group;
 641         ArdourCanvas::Group      *transport_marker_group;
 642         ArdourCanvas::Group*      cd_marker_group;
 643
 644         ArdourCanvas::Group*      timebar_group;
 645
 646         /* These bars never need to be scrolled */
 647         ArdourCanvas::Group*      meter_bar_group;
 648         ArdourCanvas::Group*      tempo_bar_group;
 649         ArdourCanvas::Group*      marker_bar_group;
 650         ArdourCanvas::Group*      range_marker_bar_group;
 651         ArdourCanvas::Group*      transport_marker_bar_group;
 652         ArdourCanvas::Group*      cd_marker_bar_group;
 653
 654         /** The group containing all items that require horizontal scrolling. */
 655         ArdourCanvas::Group* _background_group;
 656         /*
 657            The _master_group is the group containing all items
 658            that require horizontal scrolling..
 659            It is primarily used to separate canvas items
 660            that require horizontal scrolling from those that do not.
 661         */
 662         ArdourCanvas::Group* _master_group;
 663
 664         /* The group containing all trackviews.  Only scrolled vertically. */
 665         ArdourCanvas::Group* _trackview_group;
 666
 667         /* The group used for region motion.  Sits on top of _trackview_group */
 668         ArdourCanvas::Group* _region_motion_group;
 669
 670         enum RulerType {
 671                 ruler_metric_smpte = 0,
 672                 ruler_metric_bbt = 1,
 673                 ruler_metric_frames = 2,
 674                 ruler_metric_minsec = 3,
 675
 676                 ruler_time_tempo = 4,
 677                 ruler_time_meter = 5,
 678                 ruler_time_marker = 6,
 679                 ruler_time_range_marker = 7,
 680                 ruler_time_transport_marker = 8,
 681                 ruler_time_cd_marker = 9,
 682         };
 683
 684         static GtkCustomMetric ruler_metrics[4];
 685         Glib::RefPtr<Gtk::ToggleAction> ruler_timecode_action;
 686         Glib::RefPtr<Gtk::ToggleAction> ruler_bbt_action;
 687         Glib::RefPtr<Gtk::ToggleAction> ruler_samples_action;
 688         Glib::RefPtr<Gtk::ToggleAction> ruler_minsec_action;
 689         Glib::RefPtr<Gtk::ToggleAction> ruler_tempo_action;
 690         Glib::RefPtr<Gtk::ToggleAction> ruler_meter_action;
 691         Glib::RefPtr<Gtk::ToggleAction> ruler_marker_action;
 692         Glib::RefPtr<Gtk::ToggleAction> ruler_range_action;
 693         Glib::RefPtr<Gtk::ToggleAction> ruler_loop_punch_action;
 694         Glib::RefPtr<Gtk::ToggleAction> ruler_cd_marker_action;
 695         bool                            no_ruler_shown_update;
 696
 697         gint ruler_button_press (GdkEventButton*);
 698         gint ruler_button_release (GdkEventButton*);
 699         gint ruler_mouse_motion (GdkEventMotion*);
 700         bool ruler_scroll (GdkEventScroll* event);
 701
 702         Gtk::Widget * ruler_grabbed_widget;
 703
 704         void initialize_rulers ();
 705         void update_just_smpte ();
 706         void compute_fixed_ruler_scale (); //calculates the RulerScale of the fixed rulers
 707         void update_fixed_rulers ();
 708         void update_tempo_based_rulers ();
 709         void popup_ruler_menu (nframes64_t where = 0, ItemType type = RegionItem);
 710         void update_ruler_visibility ();
 711         void set_ruler_visible (RulerType, bool);
 712         void toggle_ruler_visibility (RulerType rt);
 713         void ruler_toggled (int);
 714         gint ruler_label_button_release (GdkEventButton*);
 715         void store_ruler_visibility ();
 716         void restore_ruler_visibility ();
 717
 718         static gint _metric_get_smpte (GtkCustomRulerMark **, gdouble, gdouble, gint);
 719         static gint _metric_get_bbt (GtkCustomRulerMark **, gdouble, gdouble, gint);
 720         static gint _metric_get_frames (GtkCustomRulerMark **, gdouble, gdouble, gint);
 721         static gint _metric_get_minsec (GtkCustomRulerMark **, gdouble, gdouble, gint);
 722
 723         enum MinsecRulerScale {
 724                 minsec_show_seconds,
 725                 minsec_show_minutes,
 726                 minsec_show_hours,
 727                 minsec_show_frames
 728         };
 729
 730         MinsecRulerScale minsec_ruler_scale;
 731
 732         nframes_t minsec_mark_interval;
 733         gint minsec_mark_modulo;
 734         gint minsec_nmarks;
 735         void set_minsec_ruler_scale (gdouble lower, gdouble upper);
 736
 737         enum SMPTERulerScale {
 738                 smpte_show_bits,
 739                 smpte_show_frames,
 740                 smpte_show_seconds,
 741                 smpte_show_minutes,
 742                 smpte_show_hours
 743         };
 744
 745         SMPTERulerScale smpte_ruler_scale;
 746
 747         nframes_t smpte_mark_interval;
 748         gint smpte_mark_modulo;
 749         gint smpte_nmarks;
 750         void set_smpte_ruler_scale (gdouble lower, gdouble upper);
 751
 752         enum BBTRulerScale {
 753                 bbt_over,
 754                 bbt_show_64,
 755                 bbt_show_16,
 756                 bbt_show_4,
 757                 bbt_show_1,
 758                 bbt_show_beats,
 759                 bbt_show_ticks,
 760                 bbt_show_ticks_detail,
 761                 bbt_show_ticks_super_detail
 762         };
 763
 764         BBTRulerScale bbt_ruler_scale;
 765
 766         uint32_t bbt_bars;
 767         gint bbt_nmarks;
 768         uint32_t bbt_bar_helper_on;
 769         uint32_t bbt_accent_modulo;
 770         void compute_bbt_ruler_scale (nframes64_t lower, nframes64_t upper);
 771
 772         gint metric_get_smpte (GtkCustomRulerMark **, gdouble, gdouble, gint);
 773         gint metric_get_bbt (GtkCustomRulerMark **, gdouble, gdouble, gint);
 774         gint metric_get_frames (GtkCustomRulerMark **, gdouble, gdouble, gint);
 775         gint metric_get_minsec (GtkCustomRulerMark **, gdouble, gdouble, gint);
 776
 777         Gtk::Widget        *_ruler_separator;
 778         GtkWidget          *_smpte_ruler;
 779         GtkWidget          *_bbt_ruler;
 780         GtkWidget          *_frames_ruler;
 781         GtkWidget          *_minsec_ruler;
 782         Gtk::Widget        *smpte_ruler;
 783         Gtk::Widget        *bbt_ruler;
 784         Gtk::Widget        *frames_ruler;
 785         Gtk::Widget        *minsec_ruler;
 786         static Editor      *ruler_editor;
 787
 788         static const double timebar_height;
 789         guint32 visible_timebars;
 790         gdouble canvas_timebars_vsize;
 791         gdouble get_canvas_timebars_vsize () const { return canvas_timebars_vsize; }
 792         Gtk::Menu          *editor_ruler_menu;
 793
 794         ArdourCanvas::SimpleRect* tempo_bar;
 795         ArdourCanvas::SimpleRect* meter_bar;
 796         ArdourCanvas::SimpleRect* marker_bar;
 797         ArdourCanvas::SimpleRect* range_marker_bar;
 798         ArdourCanvas::SimpleRect* transport_marker_bar;
 799         ArdourCanvas::SimpleRect* cd_marker_bar;
 800
 801         Gtk::Label  minsec_label;
 802         Gtk::Label  bbt_label;
 803         Gtk::Label  smpte_label;
 804         Gtk::Label  frame_label;
 805         Gtk::Label  tempo_label;
 806         Gtk::Label  meter_label;
 807         Gtk::Label  mark_label;
 808         Gtk::Label  range_mark_label;
 809         Gtk::Label  transport_mark_label;
 810         Gtk::Label  cd_mark_label;
 811
 812         Gtk::VBox          time_button_vbox;
 813         Gtk::HBox          time_button_hbox;
 814
 815         friend class EditorCursor;
 816
 817         EditorCursor*        playhead_cursor;
 818         ArdourCanvas::Group* cursor_group;
 819
 820         nframes64_t get_region_boundary (nframes64_t pos, int32_t dir, bool with_selection, bool only_onscreen);
 821
 822         void    cursor_to_region_boundary (bool with_selection, int32_t dir);
 823         void    cursor_to_next_region_boundary (bool with_selection);
 824         void    cursor_to_previous_region_boundary (bool with_selection);
 825         void    cursor_to_next_region_point (EditorCursor*, ARDOUR::RegionPoint);
 826         void    cursor_to_previous_region_point (EditorCursor*, ARDOUR::RegionPoint);
 827         void    cursor_to_region_point (EditorCursor*, ARDOUR::RegionPoint, int32_t dir);
 828         void    cursor_to_selection_start (EditorCursor *);
 829         void    cursor_to_selection_end   (EditorCursor *);
 830
 831         void    selected_marker_to_region_boundary (bool with_selection, int32_t dir);
 832         void    selected_marker_to_next_region_boundary (bool with_selection);
 833         void    selected_marker_to_previous_region_boundary (bool with_selection);
 834         void    selected_marker_to_next_region_point (ARDOUR::RegionPoint);
 835         void    selected_marker_to_previous_region_point (ARDOUR::RegionPoint);
 836         void    selected_marker_to_region_point (ARDOUR::RegionPoint, int32_t dir);
 837         void    selected_marker_to_selection_start ();
 838         void    selected_marker_to_selection_end   ();
 839
 840         void    select_all_selectables_using_cursor (EditorCursor *, bool);
 841         void    select_all_selectables_using_edit (bool);
 842         void    select_all_selectables_between (bool within);
 843         void    select_range_between ();
 844
 845         boost::shared_ptr<ARDOUR::Region> find_next_region (nframes64_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList&, TimeAxisView ** = 0);
 846         nframes64_t find_next_region_boundary (nframes64_t, int32_t dir, const TrackViewList&);
 847
 848         std::vector<nframes64_t> region_boundary_cache;
 849         void build_region_boundary_cache ();
 850
 851         Gtk::HBox           top_hbox;
 852         Gtk::HBox           bottom_hbox;
 853
 854         Gtk::Table          edit_packer;
 855         Gtk::VScrollbar     edit_vscrollbar;
 856
 857         Gtk::Adjustment     vertical_adjustment;
 858         Gtk::Adjustment     horizontal_adjustment;
 859
 860         Gtk::Layout         controls_layout;
 861         bool control_layout_scroll (GdkEventScroll* ev);
 862         void controls_layout_size_request (Gtk::Requisition*);
 863         sigc::connection controls_layout_size_request_connection;
 864
 865         Gtk::HScrollbar     edit_hscrollbar;
 866         bool                _dragging_hscrollbar;
 867
 868         void reset_hscrollbar_stepping ();
 869
 870         bool hscrollbar_button_press (GdkEventButton*);
 871         bool hscrollbar_button_release (GdkEventButton*);
 872         void hscrollbar_allocate (Gtk::Allocation &alloc);
 873
 874         double _canvas_width;
 875         double _canvas_height;
 876         double full_canvas_height;
 877
 878         bool track_canvas_map_handler (GdkEventAny*);
 879
 880         gint edit_controls_button_release (GdkEventButton*);
 881         Gtk::Menu *edit_controls_left_menu;
 882         Gtk::Menu *edit_controls_right_menu;
 883
 884         Gtk::VBox           ruler_label_vbox;
 885         Gtk::VBox           track_canvas_vbox;
 886         Gtk::VBox           time_canvas_vbox;
 887         Gtk::VBox           edit_controls_vbox;
 888         Gtk::HBox           edit_controls_hbox;
 889
 890         void control_scroll (float);
 891         void access_action (std::string,std::string);
 892         bool deferred_control_scroll (nframes64_t);
 893         sigc::connection control_scroll_connection;
 894
 895         gdouble get_trackview_group_vertical_offset () const { return vertical_adjustment.get_value () - canvas_timebars_vsize;}
 896
 897         ArdourCanvas::Group* get_background_group () const { return _background_group; }
 898         ArdourCanvas::Group* get_trackview_group () const { return _trackview_group; }
 899         double last_trackview_group_vertical_offset;
 900         void tie_vertical_scrolling ();
 901         void scroll_canvas_horizontally ();
 902         void scroll_canvas_vertically ();
 903
 904         struct VisualChange {
 905                 enum Type {
 906                         TimeOrigin = 0x1,
 907                         ZoomLevel = 0x2,
 908                         YOrigin = 0x4
 909                 };
 910
 911                 Type pending;
 912                 nframes64_t time_origin;
 913                 double frames_per_unit;
 914                 double y_origin;
 915
 916                 int idle_handler_id;
 917
 918                 VisualChange() : pending ((VisualChange::Type) 0), time_origin (0), frames_per_unit (0), idle_handler_id (-1) {}
 919                 void add (Type t) {
 920                         pending = Type (pending | t);
 921                 }
 922         };
 923
 924
 925         VisualChange pending_visual_change;
 926
 927         static int _idle_visual_changer (void *arg);
 928         int idle_visual_changer ();
 929
 930         void queue_visual_change (nframes64_t);
 931         void queue_visual_change (double);
 932         void queue_visual_change_y (double);
 933         void ensure_visual_change_idle_handler ();
 934
 935         void end_location_changed (ARDOUR::Location*);
 936
 937         struct RegionListDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
 938             RegionListDisplayModelColumns() {
 939                         add (name);
 940                     add (region);
 941                     add (color_);
 942                     add (start);
 943                     add (end);
 944                     add (length);
 945                         add (sync);
 946                         add (fadein);
 947                         add (fadeout);
 948                         add (locked);
 949                         add (glued);
 950                         add (muted);
 951                         add (opaque);
 952                         add (used);
 953                     add (path);
 954             }
 955             Gtk::TreeModelColumn<Glib::ustring> name;
 956             Gtk::TreeModelColumn<boost::shared_ptr<ARDOUR::Region> > region;
 957             Gtk::TreeModelColumn<Gdk::Color> color_;
 958             Gtk::TreeModelColumn<Glib::ustring> start;
 959             Gtk::TreeModelColumn<Glib::ustring> end;
 960             Gtk::TreeModelColumn<Glib::ustring> length;
 961             Gtk::TreeModelColumn<Glib::ustring> sync;
 962             Gtk::TreeModelColumn<Glib::ustring> fadein;
 963             Gtk::TreeModelColumn<Glib::ustring> fadeout;
 964             Gtk::TreeModelColumn<bool> locked;
 965             Gtk::TreeModelColumn<bool> glued;
 966             Gtk::TreeModelColumn<bool> muted;
 967             Gtk::TreeModelColumn<bool> opaque;
 968             Gtk::TreeModelColumn<Glib::ustring> used;
 969             Gtk::TreeModelColumn<Glib::ustring> path;
 970         };
 971
 972         RegionListDisplayModelColumns          region_list_columns;
 973         Gtkmm2ext::DnDTreeView<boost::shared_ptr<ARDOUR::Region> > region_list_display;
 974
 975         Glib::RefPtr<Gtk::TreeStore>           region_list_model;
 976         Glib::RefPtr<Gtk::ToggleAction>        toggle_full_region_list_action;
 977         Glib::RefPtr<Gtk::ToggleAction>        toggle_show_auto_regions_action;
 978
 979         void region_list_region_changed (ARDOUR::Change, boost::weak_ptr<ARDOUR::Region>);
 980         void region_list_selection_changed ();
 981         sigc::connection region_list_change_connection;
 982         void set_selected_in_region_list(RegionSelection&);
 983         bool set_selected_in_region_list_subrow(boost::shared_ptr<ARDOUR::Region>, Gtk::TreeModel::Row const &, int);
 984         bool region_list_selection_filter (const Glib::RefPtr<Gtk::TreeModel>& model, const Gtk::TreeModel::Path& path, bool yn);
 985         void region_name_edit (const Glib::ustring&, const Glib::ustring&);
 986         void get_regions_corresponding_to (boost::shared_ptr<ARDOUR::Region> region, std::vector<RegionView*>& regions);
 987
 988         Gtk::Menu          *region_list_menu;
 989         Gtk::ScrolledWindow region_list_scroller;
 990         Gtk::Frame          region_list_frame;
 991
 992         bool region_list_display_key_press (GdkEventKey *);
 993         bool region_list_display_key_release (GdkEventKey *);
 994         bool region_list_display_button_press (GdkEventButton *);
 995         bool region_list_display_button_release (GdkEventButton *);
 996         void region_list_clear ();
 997         void region_list_selection_mapover (sigc::slot<void,boost::shared_ptr<ARDOUR::Region> >);
 998         void build_region_list_menu ();
 999         void show_region_list_display_context_menu (int button, int time);
1000
1001         bool show_automatic_regions_in_region_list;
1002         Editing::RegionListSortType region_list_sort_type;
1003
1004         void reset_region_list_sort_direction (bool);
1005         void reset_region_list_sort_type (Editing::RegionListSortType);
1006
1007         void toggle_full_region_list ();
1008         void toggle_show_auto_regions ();
1009
1010         int region_list_sorter (Gtk::TreeModel::iterator, Gtk::TreeModel::iterator);
1011
1012         /* snapshots */
1013
1014         Gtk::ScrolledWindow snapshot_display_scroller;
1015         struct SnapshotDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
1016             SnapshotDisplayModelColumns() {
1017                     add (visible_name);
1018                     add (real_name);
1019             }
1020             Gtk::TreeModelColumn<Glib::ustring> visible_name;
1021             Gtk::TreeModelColumn<Glib::ustring> real_name;
1022         };
1023
1024         SnapshotDisplayModelColumns snapshot_display_columns;
1025         Glib::RefPtr<Gtk::ListStore> snapshot_display_model;
1026         Gtk::TreeView snapshot_display;
1027         Gtk::Menu snapshot_context_menu;
1028
1029         bool snapshot_display_button_press (GdkEventButton*);
1030         void snapshot_display_selection_changed ();
1031         void redisplay_snapshots();
1032         void popup_snapshot_context_menu (int, int32_t, Glib::ustring);
1033
1034         /* named selections */
1035
1036         struct NamedSelectionDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
1037             NamedSelectionDisplayModelColumns() {
1038                     add (text);
1039                     add (selection);
1040             }
1041             Gtk::TreeModelColumn<Glib::ustring>  text;
1042             Gtk::TreeModelColumn<ARDOUR::NamedSelection*>    selection;
1043         };
1044
1045         NamedSelectionDisplayModelColumns named_selection_columns;
1046         Glib::RefPtr<Gtk::TreeStore>     named_selection_model;
1047
1048         Gtkmm2ext::DnDTreeView<ARDOUR::NamedSelection*> named_selection_display;
1049         Gtk::ScrolledWindow    named_selection_scroller;
1050
1051         void create_named_selection ();
1052         void paste_named_selection (float times);
1053         void remove_selected_named_selections ();
1054         void remove_snapshot (Glib::ustring);
1055         void rename_snapshot (Glib::ustring);
1056
1057         void handle_new_named_selection ();
1058         void add_named_selection_to_named_selection_display (ARDOUR::NamedSelection&);
1059         void redisplay_named_selections ();
1060
1061         bool named_selection_display_button_release (GdkEventButton *ev);
1062         bool named_selection_display_key_release (GdkEventKey *ev);
1063         void named_selection_display_selection_changed ();
1064
1065         /* track views */
1066         TrackViewList track_views;
1067         std::pair<TimeAxisView*, ARDOUR::layer_t> trackview_by_y_position (double);
1068
1069         static Gdk::Cursor* cross_hair_cursor;
1070         static Gdk::Cursor* trimmer_cursor;
1071         static Gdk::Cursor* selector_cursor;
1072         static Gdk::Cursor* grabber_cursor;
1073         static Gdk::Cursor* grabber_edit_point_cursor;
1074         static Gdk::Cursor* zoom_cursor;
1075         static Gdk::Cursor* time_fx_cursor;
1076         static Gdk::Cursor* fader_cursor;
1077         static Gdk::Cursor* speaker_cursor;
1078         static Gdk::Cursor* midi_pencil_cursor;
1079         static Gdk::Cursor* midi_select_cursor;
1080         static Gdk::Cursor* midi_resize_cursor;
1081         static Gdk::Cursor* midi_erase_cursor;
1082         static Gdk::Cursor* wait_cursor;
1083         static Gdk::Cursor* timebar_cursor;
1084         static Gdk::Cursor* transparent_cursor;
1085
1086         static void build_cursors ();
1087
1088         sigc::connection scroll_connection;
1089         nframes64_t last_update_frame;
1090         void center_screen (nframes64_t);
1091         void center_screen_internal (nframes64_t, float);
1092
1093         void update_current_screen ();
1094
1095         void session_going_away ();
1096
1097         nframes64_t cut_buffer_start;
1098         nframes64_t cut_buffer_length;
1099
1100         bool typed_event (ArdourCanvas::Item*, GdkEvent*, ItemType);
1101         bool button_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
1102         bool button_release_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
1103         bool motion_handler (ArdourCanvas::Item*, GdkEvent*, bool from_autoscroll = false);
1104         bool enter_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
1105         bool leave_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
1106
1107         /* KEYMAP HANDLING */
1108
1109         void register_actions ();
1110
1111         int ensure_cursor (nframes64_t* pos);
1112
1113         void handle_new_region (boost::weak_ptr<ARDOUR::Region>);
1114         void handle_new_regions (std::vector<boost::weak_ptr<ARDOUR::Region> >& );
1115         void handle_region_removed (boost::weak_ptr<ARDOUR::Region>);
1116         void add_region_to_region_display (boost::shared_ptr<ARDOUR::Region>);
1117         void add_regions_to_region_display (std::vector<boost::weak_ptr<ARDOUR::Region> > & );
1118         void region_hidden (boost::shared_ptr<ARDOUR::Region>);
1119         void redisplay_regions ();
1120         void populate_row (boost::shared_ptr<ARDOUR::Region>, Gtk::TreeModel::Row const &);
1121         void update_region_row (boost::shared_ptr<ARDOUR::Region>);
1122         bool update_region_subrows (boost::shared_ptr<ARDOUR::Region>, Gtk::TreeModel::Row const &, int);
1123         void update_all_region_rows ();
1124         void update_all_region_subrows (Gtk::TreeModel::Row const &, int);
1125         bool no_region_list_redisplay;
1126         void insert_into_tmp_regionlist(boost::shared_ptr<ARDOUR::Region>);
1127
1128         std::list<boost::shared_ptr<ARDOUR::Region> > tmp_region_list;
1129
1130         void cut_copy (Editing::CutCopyOp);
1131         bool can_cut_copy () const;
1132         void cut_copy_points (Editing::CutCopyOp);
1133         void cut_copy_regions (Editing::CutCopyOp, RegionSelection&);
1134         void cut_copy_ranges (Editing::CutCopyOp);
1135
1136         void mouse_paste ();
1137         void paste_internal (nframes64_t position, float times);
1138
1139         /* EDITING OPERATIONS */
1140
1141         void reset_point_selection ();
1142         void toggle_region_mute ();
1143         void toggle_region_lock ();
1144         void toggle_region_opaque ();
1145         void toggle_record_enable ();
1146         void set_region_lock_style (ARDOUR::Region::PositionLockStyle);
1147         void raise_region ();
1148         void raise_region_to_top ();
1149         void lower_region ();
1150         void lower_region_to_bottom ();
1151         void split_region ();
1152         void split_region_at (nframes64_t);
1153         void split_regions_at (nframes64_t, RegionSelection&);
1154         void split_region_at_transients ();
1155         void split_region_at_points (boost::shared_ptr<ARDOUR::Region>, ARDOUR::AnalysisFeatureList&, bool can_ferret);
1156         void crop_region_to_selection ();
1157         void crop_region_to (nframes64_t start, nframes64_t end);
1158         void set_sync_point (nframes64_t, const RegionSelection&);
1159         void set_region_sync_from_edit_point ();
1160         void remove_region_sync();
1161         void align_selection (ARDOUR::RegionPoint, nframes64_t position, const RegionSelection&);
1162         void align_selection_relative (ARDOUR::RegionPoint point, nframes64_t position, const RegionSelection&);
1163         void align_region (boost::shared_ptr<ARDOUR::Region>, ARDOUR::RegionPoint point, nframes64_t position);
1164         void align_region_internal (boost::shared_ptr<ARDOUR::Region>, ARDOUR::RegionPoint point, nframes64_t position);
1165         void remove_selected_regions ();
1166         void remove_clicked_region ();
1167         void edit_region ();
1168         void rename_region ();
1169         void duplicate_some_regions (RegionSelection&, float times);
1170         void duplicate_selection (float times);
1171         void region_fill_selection ();
1172
1173         void region_fill_track ();
1174         void audition_playlist_region_standalone (boost::shared_ptr<ARDOUR::Region>);
1175         void audition_playlist_region_via_route (boost::shared_ptr<ARDOUR::Region>, ARDOUR::Route&);
1176         void split_multichannel_region();
1177         void reverse_region ();
1178         void strip_region_silence ();
1179         void normalize_region ();
1180         void denormalize_region ();
1181         void adjust_region_scale_amplitude (bool up);
1182         void quantize_region ();
1183
1184         void do_insert_time ();
1185         void insert_time (nframes64_t, nframes64_t, Editing::InsertTimeOption, bool, bool, bool);
1186
1187         void tab_to_transient (bool forward);
1188
1189         void use_region_as_bar ();
1190         void use_range_as_bar ();
1191
1192         void define_one_bar (nframes64_t start, nframes64_t end);
1193
1194         void audition_region_from_region_list ();
1195         void hide_region_from_region_list ();
1196         void remove_region_from_region_list ();
1197
1198         void align (ARDOUR::RegionPoint);
1199         void align_relative (ARDOUR::RegionPoint);
1200         void naturalize ();
1201
1202         void reset_focus ();
1203
1204         void split ();
1205
1206         void cut ();
1207         void copy ();
1208         void paste (float times);
1209
1210         int  get_prefix (float&, bool&);
1211
1212         void keyboard_paste ();
1213         void keyboard_insert_region_list_selection ();
1214
1215         void region_from_selection ();
1216         void create_region_from_selection (std::vector<boost::shared_ptr<ARDOUR::Region> >&);
1217
1218         void play_from_start ();
1219         void play_from_edit_point ();
1220         void play_from_edit_point_and_return ();
1221         void play_selected_region ();
1222         void play_edit_range ();
1223         void loop_selected_region ();
1224         void play_location (ARDOUR::Location&);
1225         void loop_location (ARDOUR::Location&);
1226
1227         void temporal_zoom_selection ();
1228         void temporal_zoom_region (bool both_axes);
1229         void toggle_zoom_region (bool both_axes);
1230         bool zoomed_to_region;
1231         void temporal_zoom_session ();
1232         void temporal_zoom (gdouble scale);
1233         void temporal_zoom_by_frame (nframes64_t start, nframes64_t end, const std::string & op);
1234         void temporal_zoom_to_frame (bool coarser, nframes64_t frame);
1235
1236         void amplitude_zoom (gdouble scale);
1237         void amplitude_zoom_step (bool in);
1238
1239         void insert_region_list_drag (boost::shared_ptr<ARDOUR::Region>, int x, int y);
1240         void insert_region_list_selection (float times);
1241
1242         void insert_route_list_drag (boost::shared_ptr<ARDOUR::Route>, int x, int y);
1243
1244         /* import & embed */
1245
1246         void add_external_audio_action (Editing::ImportMode);
1247         void external_audio_dialog ();
1248         void session_import_dialog ();
1249
1250         int  check_whether_and_how_to_import(std::string, bool all_or_nothing = true);
1251         bool check_multichannel_status (const std::vector<Glib::ustring>& paths);
1252
1253         SoundFileOmega* sfbrowser;
1254
1255         void bring_in_external_audio (Editing::ImportMode mode,  nframes64_t& pos);
1256
1257         bool  idle_drop_paths  (std::vector<Glib::ustring> paths, nframes64_t frame, double ypos);
1258         void  drop_paths_part_two  (const std::vector<Glib::ustring>& paths, nframes64_t frame, double ypos);
1259
1260         void do_import (std::vector<Glib::ustring> paths, Editing::ImportDisposition, Editing::ImportMode mode, ARDOUR::SrcQuality, nframes64_t&);
1261         void do_embed (std::vector<Glib::ustring> paths, Editing::ImportDisposition, Editing::ImportMode mode,  nframes64_t&);
1262
1263         int  import_sndfiles (std::vector<Glib::ustring> paths, Editing::ImportMode mode,  ARDOUR::SrcQuality, nframes64_t& pos,
1264                               int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>, bool, uint32_t total);
1265         int  embed_sndfiles (std::vector<Glib::ustring> paths, bool multiple_files, bool& check_sample_rate, Editing::ImportMode mode,
1266                              nframes64_t& pos, int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&);
1267
1268         int add_sources (std::vector<Glib::ustring> paths, ARDOUR::SourceList& sources, nframes64_t& pos, Editing::ImportMode,
1269                          int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&, bool add_channel_suffix);
1270         int finish_bringing_in_material (boost::shared_ptr<ARDOUR::Region> region, uint32_t, uint32_t,  nframes64_t& pos, Editing::ImportMode mode,
1271                                       boost::shared_ptr<ARDOUR::Track>& existing_track);
1272
1273         boost::shared_ptr<ARDOUR::AudioTrack> get_nth_selected_audio_track (int nth) const;
1274         boost::shared_ptr<ARDOUR::MidiTrack> get_nth_selected_midi_track (int nth) const;
1275
1276         /* generic interthread progress window */
1277
1278         ArdourDialog* interthread_progress_window;
1279         Gtk::Label interthread_progress_label;
1280         Gtk::VBox interthread_progress_vbox;
1281         Gtk::ProgressBar interthread_progress_bar;
1282         Gtk::Button interthread_cancel_button;
1283         Gtk::Label interthread_cancel_label;
1284         sigc::connection  interthread_progress_connection;
1285         void interthread_cancel_clicked ();
1286         void build_interthread_progress_window ();
1287         ARDOUR::InterThreadInfo* current_interthread_info;
1288
1289         AnalysisWindow* analysis_window;
1290
1291         /* import specific info */
1292
1293         struct EditorImportStatus : public ARDOUR::Session::ImportStatus {
1294             Editing::ImportMode mode;
1295             nframes64_t pos;
1296             int target_tracks;
1297             int target_regions;
1298             boost::shared_ptr<ARDOUR::Track> track;
1299             bool replace;
1300         };
1301
1302         EditorImportStatus import_status;
1303         gint import_progress_timeout (void *);
1304         static void *_import_thread (void *);
1305         void* import_thread ();
1306         void finish_import ();
1307
1308         /* to support this ... */
1309
1310         void import_audio (bool as_tracks);
1311         void do_import (std::vector<Glib::ustring> paths, bool split, bool as_tracks);
1312
1313         void move_to_start ();
1314         void move_to_end ();
1315         void goto_frame ();
1316         void center_playhead ();
1317         void center_edit_point ();
1318         void edit_cursor_backward ();
1319         void edit_cursor_forward ();
1320         void playhead_forward_to_grid ();
1321         void playhead_backward_to_grid ();
1322         void playhead_backward ();
1323         void playhead_forward ();
1324         void scroll_playhead (bool forward);
1325         void scroll_backward (float pages=0.8f);
1326         void scroll_forward (float pages=0.8f);
1327         void scroll_tracks_down ();
1328         void scroll_tracks_up ();
1329         void delete_sample_forward ();
1330         void delete_sample_backward ();
1331         void delete_screen ();
1332         void search_backwards ();
1333         void search_forwards ();
1334         void set_mark ();
1335         void clear_markers ();
1336         void clear_ranges ();
1337         void clear_locations ();
1338         void unhide_markers ();
1339         void unhide_ranges ();
1340         void jump_forward_to_mark ();
1341         void jump_backward_to_mark ();
1342         void cursor_align (bool playhead_to_edit);
1343
1344         void remove_last_capture ();
1345         void select_all_selectables_using_time_selection ();
1346         void select_all_selectables_using_loop();
1347         void select_all_selectables_using_punch();
1348         void set_selection_from_range (ARDOUR::Location&);
1349         void set_selection_from_punch ();
1350         void set_selection_from_loop ();
1351         void set_selection_from_region ();
1352
1353         void add_location_mark (nframes64_t where);
1354         void add_location_from_audio_region ();
1355         void add_locations_from_audio_region ();
1356         void add_location_from_selection ();
1357         void set_loop_from_selection (bool play);
1358         void set_punch_from_selection ();
1359         void set_punch_from_region ();
1360
1361         void set_loop_from_edit_range (bool play);
1362         void set_loop_from_region (bool play);
1363         void set_punch_from_edit_range ();
1364
1365         void set_loop_range (nframes64_t start, nframes64_t end, std::string cmd);
1366         void set_punch_range (nframes64_t start, nframes64_t end, std::string cmd);
1367
1368         void add_location_from_playhead_cursor ();
1369         bool select_new_marker;
1370
1371         void reverse_selection ();
1372         void edit_envelope ();
1373
1374         void start_scrolling ();
1375         void stop_scrolling ();
1376
1377         double last_scrub_x;
1378         int scrubbing_direction;
1379         int scrub_reversals;
1380         int scrub_reverse_distance;
1381         void scrub ();
1382
1383         void keyboard_selection_begin ();
1384         void keyboard_selection_finish (bool add);
1385         bool have_pending_keyboard_selection;
1386         nframes64_t pending_keyboard_selection_start;
1387
1388         boost::shared_ptr<ARDOUR::Region> select_region_for_operation (int dir, TimeAxisView **tv);
1389         void extend_selection_to_end_of_region (bool next);
1390         void extend_selection_to_start_of_region (bool previous);
1391
1392         Editing::SnapType snap_type;
1393         Editing::SnapMode snap_mode;
1394
1395         /// Snap threshold in pixels
1396         double snap_threshold;
1397
1398         void handle_gui_changes (const std::string &, void *);
1399         bool ignore_gui_changes;
1400
1401         void    hide_all_tracks (bool with_select);
1402
1403         Drag* _drag;
1404
1405         void break_drag ();
1406
1407         Gtk::Menu fade_context_menu;
1408         void popup_fade_context_menu (int, int, ArdourCanvas::Item*, ItemType);
1409
1410         void set_fade_in_shape (ARDOUR::AudioRegion::FadeShape);
1411         void set_fade_out_shape (ARDOUR::AudioRegion::FadeShape);
1412
1413         void set_fade_length (bool in);
1414         void toggle_fade_active (bool in);
1415         void set_fade_in_active (bool);
1416         void set_fade_out_active (bool);
1417
1418         std::set<boost::shared_ptr<ARDOUR::Playlist> > motion_frozen_playlists;
1419         RegionSelection pre_drag_region_selection;
1420
1421         bool _dragging_playhead;
1422         bool _dragging_edit_point;
1423
1424         void marker_drag_motion_callback (GdkEvent*);
1425         void marker_drag_finished_callback (GdkEvent*);
1426
1427         gint mouse_rename_region (ArdourCanvas::Item*, GdkEvent*);
1428
1429         void start_region_grab (ArdourCanvas::Item*, GdkEvent*, RegionView*);
1430         void start_create_region_grab (ArdourCanvas::Item*, GdkEvent*);
1431         void start_region_copy_grab (ArdourCanvas::Item*, GdkEvent*, RegionView*);
1432         void start_region_brush_grab (ArdourCanvas::Item*, GdkEvent*, RegionView*);
1433         void start_selection_grab (ArdourCanvas::Item*, GdkEvent*);
1434
1435         void region_view_item_click (AudioRegionView&, GdkEventButton*);
1436
1437         void remove_gain_control_point (ArdourCanvas::Item*, GdkEvent*);
1438         void remove_control_point (ArdourCanvas::Item*, GdkEvent*);
1439
1440         void mouse_brush_insert_region (RegionView*, nframes64_t pos);
1441         void brush (nframes64_t);
1442
1443         void show_verbose_time_cursor (nframes64_t frame, double offset = 0, double xpos=-1, double ypos=-1);
1444         void show_verbose_duration_cursor (nframes64_t start, nframes64_t end, double offset = 0, double xpos=-1, double ypos=-1);
1445         double clamp_verbose_cursor_x (double);
1446         double clamp_verbose_cursor_y (double);
1447
1448         /* Canvas event handlers */
1449
1450         bool canvas_control_point_event (GdkEvent* event,ArdourCanvas::Item*, ControlPoint*);
1451         bool canvas_line_event (GdkEvent* event,ArdourCanvas::Item*, AutomationLine*);
1452         bool canvas_selection_rect_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*);
1453         bool canvas_selection_start_trim_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*);
1454         bool canvas_selection_end_trim_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*);
1455         bool canvas_crossfade_view_event (GdkEvent* event,ArdourCanvas::Item*, CrossfadeView*);
1456         bool canvas_fade_in_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1457         bool canvas_fade_in_handle_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1458         bool canvas_fade_out_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1459         bool canvas_fade_out_handle_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1460
1461
1462         // These variables are used to detect a feedback loop and break it to avoid a gui hang
1463 private:
1464         ArdourCanvas::Item *last_item_entered;
1465         int last_item_entered_n;
1466 public:
1467
1468         bool canvas_region_view_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*);
1469         bool canvas_region_view_name_highlight_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*);
1470         bool canvas_region_view_name_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*);
1471         bool canvas_stream_view_event (GdkEvent* event,ArdourCanvas::Item*, RouteTimeAxisView*);
1472         bool canvas_marker_event (GdkEvent* event,ArdourCanvas::Item*, Marker*);
1473         bool canvas_zoom_rect_event (GdkEvent* event,ArdourCanvas::Item*);
1474         bool canvas_tempo_marker_event (GdkEvent* event,ArdourCanvas::Item*, TempoMarker*);
1475         bool canvas_meter_marker_event (GdkEvent* event,ArdourCanvas::Item*, MeterMarker*);
1476         bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, AutomationTimeAxisView*) ;
1477
1478         bool canvas_tempo_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1479         bool canvas_meter_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1480         bool canvas_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1481         bool canvas_range_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1482         bool canvas_transport_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1483         bool canvas_cd_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1484
1485         bool canvas_imageframe_item_view_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameView*);
1486         bool canvas_imageframe_view_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameTimeAxis*);
1487         bool canvas_imageframe_start_handle_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameView*);
1488         bool canvas_imageframe_end_handle_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameView*);
1489         bool canvas_marker_time_axis_view_event(GdkEvent* event, ArdourCanvas::Item*,MarkerTimeAxis*);
1490         bool canvas_markerview_item_view_event(GdkEvent* event, ArdourCanvas::Item*,MarkerView*);
1491         bool canvas_markerview_start_handle_event(GdkEvent* event, ArdourCanvas::Item*,MarkerView*);
1492         bool canvas_markerview_end_handle_event(GdkEvent* event, ArdourCanvas::Item*,MarkerView*);
1493
1494         /* non-public event handlers */
1495
1496         bool canvas_playhead_cursor_event (GdkEvent* event, ArdourCanvas::Item*);
1497         bool track_canvas_scroll (GdkEventScroll* event);
1498
1499         bool track_canvas_scroll_event (GdkEventScroll* event);
1500         bool track_canvas_button_press_event (GdkEventButton* event);
1501         bool track_canvas_button_release_event (GdkEventButton* event);
1502         bool track_canvas_motion_notify_event (GdkEventMotion* event);
1503
1504         Gtk::Allocation canvas_allocation;
1505         void track_canvas_allocate (Gtk::Allocation alloc);
1506         bool track_canvas_size_allocated ();
1507         bool track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const &, int, int, guint);
1508
1509         void set_playhead_cursor ();
1510
1511         void kbd_driver (sigc::slot<void,GdkEvent*>, bool use_track_canvas = true, bool use_time_canvas = true, bool can_select = true);
1512         void kbd_mute_unmute_region ();
1513         void kbd_brush ();
1514
1515         void kbd_do_brush (GdkEvent*);
1516         void kbd_do_audition (GdkEvent*);
1517
1518         void handle_new_duration ();
1519         void initialize_canvas ();
1520
1521         /* display control */
1522
1523         bool _show_measures;
1524         /// true if the editor should follow the playhead, otherwise false
1525         bool _follow_playhead;
1526         /// true if waveforms should be shown while recording audio tracks, otherwise false
1527         bool _show_waveforms_recording;
1528
1529         ARDOUR::TempoMap::BBTPointList *current_bbt_points;
1530
1531         TempoLines* tempo_lines;
1532
1533         ArdourCanvas::Group* time_line_group;
1534
1535         void hide_measures ();
1536         void draw_measures ();
1537         bool redraw_measures ();
1538
1539         void new_tempo_section ();
1540
1541         void mouse_add_new_tempo_event (nframes64_t where);
1542         void mouse_add_new_meter_event (nframes64_t where);
1543
1544         void remove_tempo_marker (ArdourCanvas::Item*);
1545         void remove_meter_marker (ArdourCanvas::Item*);
1546         gint real_remove_tempo_marker (ARDOUR::TempoSection*);
1547         gint real_remove_meter_marker (ARDOUR::MeterSection*);
1548
1549         void edit_tempo_section (ARDOUR::TempoSection*);
1550         void edit_meter_section (ARDOUR::MeterSection*);
1551         void edit_tempo_marker (ArdourCanvas::Item*);
1552         void edit_meter_marker (ArdourCanvas::Item*);
1553         void edit_control_point (ArdourCanvas::Item*);
1554
1555         void marker_menu_edit ();
1556         void marker_menu_remove ();
1557         void marker_menu_rename ();
1558         void marker_menu_lock (bool yn);
1559         void marker_menu_hide ();
1560         void marker_menu_loop_range ();
1561         void marker_menu_select_all_selectables_using_range ();
1562         void marker_menu_select_using_range ();
1563         void marker_menu_separate_regions_using_location ();
1564         void marker_menu_play_from ();
1565         void marker_menu_play_range ();
1566         void marker_menu_set_playhead ();
1567         void marker_menu_set_from_playhead ();
1568         void marker_menu_set_from_selection ();
1569         void marker_menu_range_to_next ();
1570         void new_transport_marker_menu_set_loop ();
1571         void new_transport_marker_menu_set_punch ();
1572         void update_loop_range_view (bool visibility=false);
1573         void update_punch_range_view (bool visibility=false);
1574         void new_transport_marker_menu_popdown ();
1575         void marker_context_menu (GdkEventButton*, ArdourCanvas::Item*);
1576         void tm_marker_context_menu (GdkEventButton*, ArdourCanvas::Item*);
1577         void transport_marker_context_menu (GdkEventButton*, ArdourCanvas::Item*);
1578         void new_transport_marker_context_menu (GdkEventButton*, ArdourCanvas::Item*);
1579         void build_range_marker_menu (bool loop_or_punch);
1580         void build_marker_menu (bool start_or_end);
1581         void build_tm_marker_menu ();
1582         void build_new_transport_marker_menu ();
1583
1584         Gtk::Menu* tm_marker_menu;
1585         Gtk::Menu* marker_menu;
1586         Gtk::Menu* start_end_marker_menu;
1587         Gtk::Menu* range_marker_menu;
1588         Gtk::Menu* transport_marker_menu;
1589         Gtk::Menu* new_transport_marker_menu;
1590         Gtk::Menu* cd_marker_menu;
1591         ArdourCanvas::Item* marker_menu_item;
1592
1593         typedef std::list<Marker*> Marks;
1594         Marks metric_marks;
1595
1596         void remove_metric_marks ();
1597         void draw_metric_marks (const ARDOUR::Metrics& metrics);
1598
1599         void compute_current_bbt_points (nframes_t left, nframes_t right);
1600         void tempo_map_changed (ARDOUR::Change);
1601         void redisplay_tempo (bool immediate_redraw);
1602
1603         void snap_to (nframes64_t& first, int32_t direction = 0, bool for_mark = false);
1604
1605         double snap_length_beats (nframes64_t start);
1606
1607         uint32_t bbt_beat_subdivision;
1608
1609         /* toolbar */
1610
1611         Gtk::ToggleButton editor_mixer_button;
1612         Gtk::ToggleButton editor_list_button;
1613         void editor_mixer_button_toggled ();
1614         void editor_list_button_toggled ();
1615
1616         AudioClock               edit_point_clock;
1617         AudioClock               zoom_range_clock;
1618         Gtk::Button              zoom_in_button;
1619         Gtk::Button              zoom_out_button;
1620         Gtk::Button              zoom_out_full_button;
1621         Gtk::Button              zoom_onetoone_button;
1622
1623         Gtk::VBox                toolbar_clock_vbox;
1624         Gtk::VBox                toolbar_selection_clock_vbox;
1625         Gtk::Table               toolbar_selection_clock_table;
1626         Gtk::Label               toolbar_selection_cursor_label;
1627
1628         Gtk::HBox                mouse_mode_button_box;
1629         Gtkmm2ext::TearOff*      mouse_mode_tearoff;
1630         Gtk::ToggleButton        mouse_select_button;
1631         Gtk::ToggleButton        mouse_move_button;
1632         Gtk::ToggleButton        mouse_gain_button;
1633         Gtk::ToggleButton        mouse_zoom_button;
1634         Gtk::ToggleButton        mouse_timefx_button;
1635         Gtk::ToggleButton        mouse_audition_button;
1636         Gtk::ToggleButton        mouse_note_button;
1637         GroupedButtons          *mouse_mode_button_set;
1638         void                     mouse_mode_toggled (Editing::MouseMode m);
1639         bool                     ignore_mouse_mode_toggle;
1640
1641         gint                     mouse_select_button_release (GdkEventButton*);
1642
1643         Gtk::VBox                automation_box;
1644         Gtk::Button              automation_mode_button;
1645         Gtk::ToggleButton        global_automation_button;
1646
1647         Gtk::ComboBoxText edit_mode_selector;
1648         Gtk::VBox         edit_mode_box;
1649
1650         void set_edit_mode (ARDOUR::EditMode);
1651         void cycle_edit_mode ();
1652         void edit_mode_selection_done ();
1653
1654         Gtk::ComboBoxText snap_type_selector;
1655         Gtk::ComboBoxText snap_mode_selector;
1656         Gtk::HBox         snap_box;
1657
1658         std::vector<std::string> snap_type_strings;
1659         std::vector<std::string> snap_mode_strings;
1660
1661         void snap_type_selection_done ();
1662         void snap_mode_selection_done ();
1663         void snap_mode_chosen (Editing::SnapMode);
1664         void snap_type_chosen (Editing::SnapType);
1665
1666         Glib::RefPtr<Gtk::RadioAction> snap_type_action (Editing::SnapType);
1667         Glib::RefPtr<Gtk::RadioAction> snap_mode_action (Editing::SnapMode);
1668
1669         Gtk::ComboBoxText zoom_focus_selector;
1670         Gtk::VBox         zoom_focus_box;
1671
1672         std::vector<std::string> zoom_focus_strings;
1673
1674         void zoom_focus_selection_done ();
1675         void zoom_focus_chosen (Editing::ZoomFocus);
1676
1677         Glib::RefPtr<Gtk::RadioAction> zoom_focus_action (Editing::ZoomFocus);
1678
1679         Gtk::HBox           zoom_box;
1680         Gtk::VBox           zoom_vbox;
1681
1682         void                zoom_adjustment_changed();
1683
1684         void                edit_point_clock_changed();
1685
1686         void setup_toolbar ();
1687
1688         Gtkmm2ext::TearOff*      tools_tearoff;
1689         Gtk::HBox                toolbar_hbox;
1690         Gtk::EventBox            toolbar_base;
1691         Gtk::Frame               toolbar_frame;
1692
1693         /* midi toolbar */
1694
1695         Gtk::HBox                midi_tool_button_box;
1696         Gtk::ToggleButton        midi_tool_pencil_button;
1697         Gtk::ToggleButton        midi_tool_select_button;
1698         Gtk::ToggleButton        midi_tool_resize_button;
1699         Gtk::ToggleButton        midi_tool_erase_button;
1700         Gtk::Button              midi_panic_button;
1701         Gtk::ToggleButton        midi_sound_notes;
1702         GroupedButtons          *midi_tool_button_set;
1703         void                     midi_edit_mode_toggled (Editing::MidiEditMode m);
1704         void                     midi_panic_button_pressed ();
1705         bool                     sound_notes () const { return midi_sound_notes.get_active(); }
1706
1707         bool                     ignore_midi_edit_mode_toggle;
1708
1709         Gtkmm2ext::TearOff* midi_tools_tearoff;
1710         Gtk::HBox           midi_toolbar_hbox;
1711         Gtk::EventBox       midi_toolbar_base;
1712         Gtk::Frame          midi_toolbar_frame;
1713
1714         void setup_midi_toolbar ();
1715
1716         /* selection process */
1717
1718         Selection* selection;
1719         Selection* cut_buffer;
1720
1721         void time_selection_changed ();
1722         void track_selection_changed ();
1723         void region_selection_changed ();
1724         sigc::connection editor_regions_selection_changed_connection;
1725         void sensitize_the_right_region_actions (bool have_selected_regions);
1726         void point_selection_changed ();
1727         void marker_selection_changed ();
1728
1729         void cancel_selection ();
1730
1731         void region_selection_op (void (ARDOUR::Region::*pmf)(void));
1732         void region_selection_op (void (ARDOUR::Region::*pmf)(void*), void*);
1733         void region_selection_op (void (ARDOUR::Region::*pmf)(bool), bool);
1734
1735         bool audio_region_selection_covers (nframes64_t where);
1736
1737         /* transport range select process */
1738
1739         ArdourCanvas::SimpleRect*  cd_marker_bar_drag_rect;
1740         ArdourCanvas::SimpleRect*  range_bar_drag_rect;
1741         ArdourCanvas::SimpleRect*  transport_bar_drag_rect;
1742
1743 #ifdef GTKOSX
1744         ArdourCanvas::SimpleRect     *bogus_background_rect;
1745 #endif
1746         ArdourCanvas::SimpleRect     *transport_bar_range_rect;
1747         ArdourCanvas::SimpleRect     *transport_bar_preroll_rect;
1748         ArdourCanvas::SimpleRect     *transport_bar_postroll_rect;
1749         ArdourCanvas::SimpleRect     *transport_loop_range_rect;
1750         ArdourCanvas::SimpleRect     *transport_punch_range_rect;
1751         ArdourCanvas::SimpleLine     *transport_punchin_line;
1752         ArdourCanvas::SimpleLine     *transport_punchout_line;
1753         ArdourCanvas::SimpleRect     *transport_preroll_rect;
1754         ArdourCanvas::SimpleRect     *transport_postroll_rect;
1755
1756         ARDOUR::Location*  transport_loop_location();
1757         ARDOUR::Location*  transport_punch_location();
1758
1759         ARDOUR::Location   *temp_location;
1760
1761         /* object rubberband select process */
1762
1763         bool select_all_within (nframes64_t start, nframes64_t end, gdouble topy, gdouble boty, const TrackViewList&, Selection::Operation op);
1764
1765         ArdourCanvas::SimpleRect   *rubberband_rect;
1766
1767         /* mouse zoom process */
1768
1769         ArdourCanvas::SimpleRect   *zoom_rect;
1770         void reposition_zoom_rect (nframes64_t start, nframes64_t end);
1771
1772         /* diskstream/route display management */
1773
1774         struct RouteDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
1775             RouteDisplayModelColumns() {
1776                     add (text);
1777                     add (visible);
1778                     add (temporary_visible);
1779                     add (tv);
1780                     add (route);
1781             }
1782             Gtk::TreeModelColumn<Glib::ustring>  text;
1783             Gtk::TreeModelColumn<bool>           visible;
1784             Gtk::TreeModelColumn<bool>           temporary_visible;
1785             Gtk::TreeModelColumn<TimeAxisView*>  tv;
1786             Gtk::TreeModelColumn<boost::shared_ptr<ARDOUR::Route> >  route;
1787         };
1788
1789         RouteDisplayModelColumns         route_display_columns;
1790         Glib::RefPtr<Gtk::ListStore>     route_display_model;
1791         Glib::RefPtr<Gtk::TreeSelection> route_display_selection;
1792
1793         Gtkmm2ext::DnDTreeView<boost::shared_ptr<ARDOUR::Route> > route_list_display;
1794         Gtk::ScrolledWindow                   route_list_scroller;
1795         Gtk::Menu*                            route_list_menu;
1796
1797         void update_route_visibility ();
1798
1799         void sync_order_keys (const char*);
1800         bool route_redisplay_does_not_sync_order_keys;
1801         bool route_redisplay_does_not_reset_order_keys;
1802
1803         bool route_list_display_button_press (GdkEventButton*);
1804         void route_list_display_drag_data_received  (const Glib::RefPtr<Gdk::DragContext>& context,
1805                                                      gint                x,
1806                                                      gint                y,
1807                                                      const Gtk::SelectionData& data,
1808                                                      guint               info,
1809                                                      guint               time);
1810
1811         bool route_list_selection_filter (const Glib::RefPtr<Gtk::TreeModel>& model, const Gtk::TreeModel::Path& path, bool yn);
1812
1813         void route_list_change (const Gtk::TreeModel::Path&,const Gtk::TreeModel::iterator&);
1814         void route_list_delete (const Gtk::TreeModel::Path&);
1815         void track_list_reorder (const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter, int* new_order);
1816
1817         void initial_route_list_display ();
1818         void redisplay_route_list();
1819         void route_list_reordered (const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter, int* what);
1820         bool ignore_route_list_reorder;
1821         bool no_route_list_redisplay;
1822         bool sync_track_view_list_and_route_list ();
1823
1824         void build_route_list_menu ();
1825         void show_route_list_menu ();
1826
1827         void show_all_routes ();
1828         void hide_all_routes ();
1829         void show_all_audiotracks ();
1830         void hide_all_audiotracks ();
1831         void show_all_audiobus ();
1832         void hide_all_audiobus ();
1833
1834         void set_all_tracks_visibility (bool yn);
1835         void set_all_audio_visibility (int type, bool yn);
1836
1837         /* edit group management */
1838
1839         struct GroupListModelColumns : public Gtk::TreeModel::ColumnRecord {
1840                 GroupListModelColumns () {
1841                        add (is_active);
1842                        add (is_visible);
1843                        add (text);
1844                        add (routegroup);
1845                 }
1846                 Gtk::TreeModelColumn<bool> is_active;
1847                 Gtk::TreeModelColumn<bool> is_visible;
1848                 Gtk::TreeModelColumn<std::string> text;
1849                 Gtk::TreeModelColumn<ARDOUR::RouteGroup*>   routegroup;
1850         };
1851
1852         GroupListModelColumns group_columns;
1853         Glib::RefPtr<Gtk::ListStore> group_model;
1854         Glib::RefPtr<Gtk::TreeSelection> group_selection;
1855
1856         Gtk::TreeView          edit_group_display;
1857         Gtk::ScrolledWindow    edit_group_display_scroller;
1858         Gtk::Menu*             edit_group_list_menu;
1859
1860         void build_edit_group_list_menu ();
1861         void activate_all_edit_groups ();
1862         void disable_all_edit_groups ();
1863
1864         bool in_edit_group_row_change;
1865         void edit_group_row_change (const Gtk::TreeModel::Path&,const Gtk::TreeModel::iterator&);
1866         void edit_group_name_edit (const Glib::ustring&, const Glib::ustring&);
1867         void new_edit_group ();
1868         void edit_group_list_button_clicked ();
1869         gint edit_group_list_button_press_event (GdkEventButton* ev);
1870         void add_edit_group (ARDOUR::RouteGroup* group);
1871         void remove_selected_edit_group ();
1872         void edit_groups_changed ();
1873         void group_flags_changed (void*, ARDOUR::RouteGroup*);
1874
1875         Gtk::VBox           list_vpacker;
1876
1877         /* autoscrolling */
1878
1879         bool autoscroll_active;
1880         int autoscroll_timeout_tag;
1881         int autoscroll_x;
1882         int autoscroll_y;
1883         int last_autoscroll_x;
1884         int last_autoscroll_y;
1885         uint32_t autoscroll_cnt;
1886         nframes64_t autoscroll_x_distance;
1887         double autoscroll_y_distance;
1888
1889         static gint _autoscroll_canvas (void *);
1890         bool autoscroll_canvas ();
1891         void start_canvas_autoscroll (int x, int y);
1892         void stop_canvas_autoscroll ();
1893         void maybe_autoscroll (GdkEventMotion*, bool);
1894         bool allow_vertical_scroll;
1895
1896         /* trimming */
1897         void point_trim (GdkEvent*);
1898         void single_contents_trim (RegionView&, nframes64_t, bool, bool, bool);
1899         void single_start_trim (RegionView&, nframes64_t, bool, bool, bool);
1900         void single_end_trim (RegionView&, nframes64_t, bool, bool, bool);
1901
1902         void thaw_region_after_trim (RegionView& rv);
1903
1904         void trim_region_front();
1905         void trim_region_back();
1906         void trim_region (bool front);
1907
1908         void trim_region_to_edit_point ();
1909         void trim_region_from_edit_point ();
1910         void trim_region_to_loop ();
1911         void trim_region_to_punch ();
1912         void trim_region_to_location (const ARDOUR::Location&, const char* cmd);
1913
1914         void trim_to_region(bool forward);
1915         void trim_region_to_previous_region_end();
1916         void trim_region_to_next_region_start();
1917
1918         bool show_gain_after_trim;
1919
1920         /* Drag-n-Drop */
1921
1922         int convert_drop_to_paths (
1923                         std::vector<Glib::ustring>&           paths,
1924                         const Glib::RefPtr<Gdk::DragContext>& context,
1925                         gint                                  x,
1926                         gint                                  y,
1927                         const Gtk::SelectionData&             data,
1928                         guint                                 info,
1929                         guint                                 time);
1930
1931         void track_canvas_drag_data_received (
1932                         const Glib::RefPtr<Gdk::DragContext>& context,
1933                         gint                                  x,
1934                         gint                                  y,
1935                         const Gtk::SelectionData&             data,
1936                         guint                                 info,
1937                         guint                                 time);
1938
1939         void region_list_display_drag_data_received (
1940                         const Glib::RefPtr<Gdk::DragContext>& context,
1941                         gint                                  x,
1942                         gint                                  y,
1943                         const Gtk::SelectionData&             data,
1944                         guint                                 info,
1945                         guint                                 time);
1946
1947         void drop_paths (
1948                         const Glib::RefPtr<Gdk::DragContext>& context,
1949                         gint                                  x,
1950                         gint                                  y,
1951                         const Gtk::SelectionData&             data,
1952                         guint                                 info,
1953                         guint                                 time);
1954
1955         void drop_regions (
1956                         const Glib::RefPtr<Gdk::DragContext>& context,
1957                         gint                                  x,
1958                         gint                                  y,
1959                         const Gtk::SelectionData&             data,
1960                         guint                                 info,
1961                         guint                                 time);
1962
1963         void drop_routes (
1964                         const Glib::RefPtr<Gdk::DragContext>& context,
1965                         gint                x,
1966                         gint                y,
1967                         const Gtk::SelectionData& data,
1968                         guint               info,
1969                         guint               time);
1970
1971         /* audio export */
1972
1973         int  write_region_selection(RegionSelection&);
1974         bool write_region (std::string path, boost::shared_ptr<ARDOUR::AudioRegion>);
1975         void bounce_region_selection ();
1976         void bounce_range_selection (bool replace, bool enable_processing);
1977         void external_edit_region ();
1978
1979         int write_audio_selection (TimeSelection&);
1980         bool write_audio_range (ARDOUR::AudioPlaylist&, const ARDOUR::ChanCount& channels, std::list<ARDOUR::AudioRange>&);
1981
1982         void write_selection ();
1983
1984         XMLNode *before; /* used in *_reversible_command */
1985
1986         void begin_reversible_command (std::string cmd_name);
1987         void commit_reversible_command ();
1988
1989         void update_title ();
1990         void update_title_s (const std::string & snapshot_name);
1991
1992         struct State {
1993             Selection* selection;
1994             double frames_per_unit;
1995
1996             State (PublicEditor const * e);
1997             ~State ();
1998         };
1999
2000         void store_state (State&) const;
2001         void restore_state (State *);
2002
2003         void instant_save ();
2004
2005         boost::shared_ptr<ARDOUR::AudioRegion> last_audition_region;
2006
2007         /* freeze operations */
2008
2009         ARDOUR::InterThreadInfo freeze_status;
2010         gint freeze_progress_timeout (void *);
2011         static void* _freeze_thread (void*);
2012         void* freeze_thread ();
2013
2014         void freeze_route ();
2015         void unfreeze_route ();
2016
2017         /* edit-group solo + mute */
2018
2019         void set_edit_group_solo (ARDOUR::Route&, bool);
2020         void set_edit_group_mute (ARDOUR::Route&, bool);
2021
2022         /* duplication */
2023
2024         void duplicate_dialog (bool with_dialog);
2025
2026         nframes64_t event_frame (GdkEvent const *, double* px = 0, double* py = 0) const;
2027
2028         /* returns false if mouse pointer is not in track or marker canvas
2029          */
2030         bool mouse_frame (nframes64_t&, bool& in_track_canvas) const;
2031
2032         /* "whats mine is yours" */
2033
2034         TimeFXDialog* current_timefx;
2035
2036         static void* timefx_thread (void *arg);
2037         void do_timefx (TimeFXDialog&);
2038
2039         int time_stretch (RegionSelection&, float fraction);
2040         int pitch_shift (RegionSelection&, float cents);
2041         void pitch_shift_regions ();
2042         int time_fx (RegionSelection&, float val, bool pitching);
2043
2044         /* editor-mixer strip */
2045
2046         MixerStrip *current_mixer_strip;
2047         bool show_editor_mixer_when_tracks_arrive;
2048         Gtk::VBox current_mixer_strip_vbox;
2049         void cms_new (boost::shared_ptr<ARDOUR::Route>);
2050         void cms_deleted ();
2051         void current_mixer_strip_hidden ();
2052         void current_mixer_strip_removed ();
2053
2054         void detach_tearoff (Gtk::Box* b, Gtk::Window* w);
2055         void reattach_tearoff (Gtk::Box* b, Gtk::Window* w, int32_t n);
2056 #ifdef GTKOSX
2057         void ensure_all_elements_drawn ();
2058 #endif
2059         /* nudging tracks */
2060
2061         void nudge_track (bool use_edit_point, bool forwards);
2062
2063         /* xfades */
2064
2065         bool _xfade_visibility;
2066
2067 #ifdef WITH_CMT
2068         void handle_new_imageframe_time_axis_view(const std::string & track_name, void* src) ;
2069         void handle_new_imageframe_marker_time_axis_view(const std::string & track_name, TimeAxisView* marked_track) ;
2070
2071         void start_imageframe_grab(ArdourCanvas::Item*, GdkEvent*) ;
2072         void start_markerview_grab(ArdourCanvas::Item*, GdkEvent*) ;
2073
2074         void imageframe_drag_motion_callback(ArdourCanvas::Item*, GdkEvent*) ;
2075         void markerview_drag_motion_callback(ArdourCanvas::Item*, GdkEvent*) ;
2076         void timeaxis_item_drag_finished_callback(ArdourCanvas::Item*, GdkEvent*) ;
2077
2078         gint canvas_imageframe_item_view_event(ArdourCanvas::Item* item, GdkEvent* event, ImageFrameView* ifv);
2079         gint canvas_imageframe_view_event(ArdourCanvas::Item* item, GdkEvent* event, ImageFrameTimeAxis* ifta);
2080         gint canvas_imageframe_start_handle_event(ArdourCanvas::Item* item, GdkEvent* event, ImageFrameView* ifv);
2081         gint canvas_imageframe_end_handle_event(ArdourCanvas::Item* item, GdkEvent* event, ImageFrameView* ifv);
2082
2083         gint canvas_marker_time_axis_view_event(ArdourCanvas::Item* item, GdkEvent* event, MarkerTimeAxis* mta);
2084         gint canvas_markerview_item_view_event(ArdourCanvas::Item* item, GdkEvent* event, MarkerView* mv);
2085         gint canvas_markerview_start_handle_event(ArdourCanvas::Item* item, GdkEvent* event, MarkerView* mv);
2086         gint canvas_markerview_end_handle_event(ArdourCanvas::Item* item, GdkEvent* event, MarkerView* mv);
2087
2088         void imageframe_start_handle_op(ArdourCanvas::Item* item, GdkEvent* event) ;
2089         void imageframe_end_handle_op(ArdourCanvas::Item* item, GdkEvent* event) ;
2090         void imageframe_start_handle_trim_motion(ArdourCanvas::Item* item, GdkEvent* event) ;
2091         void imageframe_start_handle_end_trim(ArdourCanvas::Item* item, GdkEvent* event) ;
2092         void imageframe_end_handle_trim_motion(ArdourCanvas::Item* item, GdkEvent* event) ;
2093         void imageframe_end_handle_end_trim(ArdourCanvas::Item* item, GdkEvent* event) ;
2094
2095         void markerview_item_start_handle_op(ArdourCanvas::Item* item, GdkEvent* event) ;
2096         void markerview_item_end_handle_op(ArdourCanvas::Item* item, GdkEvent* event) ;
2097         void markerview_start_handle_trim_motion(ArdourCanvas::Item* item, GdkEvent* event) ;
2098         void markerview_start_handle_end_trim(ArdourCanvas::Item* item, GdkEvent* event) ;
2099         void markerview_end_handle_trim_motion(ArdourCanvas::Item* item, GdkEvent* event) ;
2100         void markerview_end_handle_end_trim(ArdourCanvas::Item* item, GdkEvent* event) ;
2101
2102         void popup_imageframe_edit_menu(int button, int32_t time, ArdourCanvas::Item* ifv, bool with_frame) ;
2103         void popup_marker_time_axis_edit_menu(int button, int32_t time, ArdourCanvas::Item* ifv, bool with_frame) ;
2104
2105         ImageFrameSocketHandler* image_socket_listener ;
2106 #endif
2107
2108         void toggle_xfade_active (boost::weak_ptr<ARDOUR::Crossfade>);
2109         void toggle_xfade_length (boost::weak_ptr<ARDOUR::Crossfade>);
2110         void edit_xfade (boost::weak_ptr<ARDOUR::Crossfade>);
2111         void xfade_edit_left_region ();
2112         void xfade_edit_right_region ();
2113
2114         static const int32_t default_width = 995;
2115         static const int32_t default_height = 765;
2116
2117         /* nudge */
2118
2119         Gtk::Button      nudge_forward_button;
2120         Gtk::Button      nudge_backward_button;
2121         Gtk::HBox        nudge_hbox;
2122         Gtk::VBox        nudge_vbox;
2123         AudioClock       nudge_clock;
2124
2125         nframes64_t get_nudge_distance (nframes64_t pos, nframes64_t& next);
2126
2127         bool nudge_forward_release (GdkEventButton*);
2128         bool nudge_backward_release (GdkEventButton*);
2129
2130         /* audio filters */
2131
2132         void apply_filter (ARDOUR::Filter&, std::string cmd);
2133
2134         /* handling cleanup */
2135
2136         int playlist_deletion_dialog (boost::shared_ptr<ARDOUR::Playlist>);
2137
2138         std::vector<sigc::connection> session_connections;
2139
2140         /* tracking step changes of track height */
2141
2142         TimeAxisView* current_stepping_trackview;
2143         ARDOUR::microseconds_t last_track_height_step_timestamp;
2144         gint track_height_step_timeout();
2145         sigc::connection step_timeout;
2146
2147         TimeAxisView* entered_track;
2148         RegionView*   entered_regionview;
2149
2150
2151         void ensure_entered_track_selected (bool op_acts_on_objects = false);
2152         bool clear_entered_track;
2153         bool left_track_canvas (GdkEventCrossing*);
2154         bool entered_track_canvas (GdkEventCrossing*);
2155         void set_entered_track (TimeAxisView*);
2156         void set_entered_regionview (RegionView*);
2157         void ensure_track_visible (TimeAxisView*);
2158         gint left_automation_track ();
2159
2160         bool _new_regionviews_show_envelope;
2161
2162         void reset_canvas_action_sensitivity (bool);
2163         void toggle_gain_envelope_visibility ();
2164         void toggle_gain_envelope_active ();
2165         void reset_region_gain_envelopes ();
2166
2167         bool on_key_press_event (GdkEventKey*);
2168         bool on_key_release_event (GdkEventKey*);
2169
2170         void session_state_saved (std::string);
2171
2172         Glib::RefPtr<Gtk::Action>              undo_action;
2173         Glib::RefPtr<Gtk::Action>              redo_action;
2174
2175         void history_changed ();
2176
2177         Gtk::HBox      status_bar_hpacker;
2178
2179         Editing::EditPoint _edit_point;
2180
2181         Gtk::ComboBoxText edit_point_selector;
2182
2183         void set_edit_point_preference (Editing::EditPoint ep, bool force = false);
2184         void cycle_edit_point (bool with_marker);
2185         void set_edit_point ();
2186         void edit_point_selection_done ();
2187         void edit_point_chosen (Editing::EditPoint);
2188         Glib::RefPtr<Gtk::RadioAction> edit_point_action (Editing::EditPoint);
2189         std::vector<std::string> edit_point_strings;
2190
2191         void selected_marker_moved (ARDOUR::Location*);
2192         sigc::connection edit_point_clock_connection_a;
2193         sigc::connection edit_point_clock_connection_b;
2194
2195         bool get_edit_op_range (nframes64_t& start, nframes64_t& end) const;
2196
2197         void get_regions_at (RegionSelection&, nframes64_t where, const TrackSelection& ts) const;
2198         void get_regions_after (RegionSelection&, nframes64_t where, const TrackSelection& ts) const;
2199
2200         void get_regions_for_action (RegionSelection&, bool allowed_entered_regionview = false);
2201
2202         sigc::connection fast_screen_update_connection;
2203         gint start_updating ();
2204         gint stop_updating ();
2205         void fast_update_strips ();
2206         bool meters_running;
2207
2208         void select_next_route ();
2209         void select_prev_route ();
2210
2211         void snap_to_internal (nframes64_t& first, int32_t direction = 0, bool for_mark = false);
2212
2213         RhythmFerret* rhythm_ferret;
2214         BundleManager* _bundle_manager;
2215         GlobalPortMatrixWindow* _global_port_matrix[ARDOUR::DataType::num_types];
2216
2217         void fit_tracks ();
2218         void set_track_height (uint32_t h);
2219
2220         void remove_tracks ();
2221         void toggle_tracks_active ();
2222
2223         bool _have_idled;
2224         int resize_idle_id;
2225         int32_t resize_idle_target;
2226         bool idle_resize();
2227         friend gboolean _idle_resize (gpointer);
2228         std::vector<TimeAxisView*> pending_resizes;
2229
2230         void visible_order_range (int*, int*) const;
2231
2232         void located ();
2233         bool _pending_locate_request;
2234
2235         EditorSummary* _summary;
2236         void region_view_added (RegionView *);
2237
2238         void update_canvas_now ();
2239         void streamview_height_changed ();
2240
2241         friend class Drag;
2242         friend class RegionDrag;
2243         friend class RegionMoveDrag;
2244         friend class RegionSpliceDrag;
2245         friend class TrimDrag;
2246         friend class MeterMarkerDrag;
2247         friend class TempoMarkerDrag;
2248         friend class CursorDrag;
2249         friend class FadeInDrag;
2250         friend class FadeOutDrag;
2251         friend class MarkerDrag;
2252         friend class RegionGainDrag;
2253         friend class ControlPointDrag;
2254         friend class LineDrag;
2255         friend class RubberbandSelectDrag;
2256         friend class TimeFXDrag;
2257         friend class ScrubDrag;
2258         friend class SelectionDrag;
2259         friend class RangeMarkerBarDrag;
2260         friend class MouseZoomDrag;
2261         friend class RegionCreateDrag;
2262         friend class RegionMotionDrag;
2263         friend class RegionInsertDrag;
2264
2265         friend class EditorSummary;
2266 };
2267
2268 #endif /* __ardour_editor_h__ */