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