gtk2_ardour/editor.h

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