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