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