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