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