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     $Id$
  19 */
  20
  21 #ifndef __ardour_editor_h__
  22 #define __ardour_editor_h__
  23
  24 #include <list>
  25 #include <map>
  26 #include <set>
  27 #include <string>
  28 #include <sys/time.h>
  29
  30 #include <libgnomecanvasmm/canvas.h>
  31 #include <libgnomecanvasmm/group.h>
  32 #include <libgnomecanvasmm/line.h>
  33
  34 #include <cmath>
  35
  36 #include <gtkmm/layout.h>
  37 #include <gtkmm/comboboxtext.h>
  38
  39 #include <gtkmm2ext/selector.h>
  40 #include <gtkmm2ext/click_box.h>
  41 #include <gtkmm2ext/dndtreeview.h>
  42
  43 #include <ardour/stateful.h>
  44 #include <ardour/session.h>
  45 #include <ardour/tempo.h>
  46 #include <ardour/location.h>
  47 #include <ardour/region.h>
  48 #include <ardour/externalsource.h>
  49
  50 #include "audio_clock.h"
  51 #include "gtk-custom-ruler.h"
  52 #include "ardour_dialog.h"
  53 #include "public_editor.h"
  54 #include "editing.h"
  55 #include "enums.h"
  56 #include "region_selection.h"
  57 #include "canvas.h"
  58 #include "draginfo.h"
  59
  60 namespace Gtkmm2ext {
  61         class TearOff;
  62 }
  63
  64 namespace LinuxAudioSystems {
  65         class AudioEngine;
  66 }
  67
  68 namespace ARDOUR {
  69         class DiskStream;
  70         class RouteGroup;
  71         class Source;
  72         class Playlist;
  73         class Region;
  74         class Location;
  75         class TempoSection;
  76         class NamedSelection;
  77         class Session;
  78         class AudioFilter;
  79         class Crossfade;
  80 }
  81
  82 namespace LADSPA {
  83         class Plugin;
  84 }
  85
  86 class TimeAxisView;
  87 class AudioTimeAxisView;
  88 class AutomationTimeAxisView;
  89 class AudioRegionView;
  90 class CrossfadeView;
  91 class PluginSelector;
  92 class PlaylistSelector;
  93 class Marker;
  94 class GroupedButtons;
  95 class AutomationLine;
  96 class UIExportSpecification;
  97 class ExportDialog;
  98 class Selection;
  99 class TimeSelection;
 100 class TrackSelection;
 101 class AutomationSelection;
 102 class MixerStrip;
 103 class StreamView;
 104 class ControlPoint;
 105 #ifdef FFT_ANALYSIS
 106 class AnalysisWindow;
 107 #endif
 108
 109 /* <CMT Additions> */
 110 class ImageFrameView;
 111 class ImageFrameTimeAxisView;
 112 class ImageFrameTimeAxis;
 113 class MarkerTimeAxis ;
 114 class MarkerView ;
 115 class ImageFrameSocketHandler ;
 116 class TimeAxisViewItem ;
 117 /* </CMT Additions> */
 118
 119
 120 class Editor : public PublicEditor
 121 {
 122   public:
 123         Editor (ARDOUR::AudioEngine&);
 124         ~Editor ();
 125
 126         void             connect_to_session (ARDOUR::Session *);
 127         ARDOUR::Session* current_session() const { return session; }
 128
 129         jack_nframes_t leftmost_position() const { return leftmost_frame; }
 130         jack_nframes_t current_page_frames() const {
 131                 return (jack_nframes_t) floor (canvas_width * frames_per_unit);
 132         }
 133
 134         void set_snap_to (Editing::SnapType);
 135         void set_snap_mode (Editing::SnapMode);
 136         void set_snap_threshold (double pixel_distance) {snap_threshold = pixel_distance;}
 137
 138         void undo (uint32_t n = 1);
 139         void redo (uint32_t n = 1);
 140
 141         XMLNode& get_state ();
 142         int set_state (const XMLNode& );
 143
 144         void set_mouse_mode (Editing::MouseMode, bool force=true);
 145         void step_mouse_mode (bool next);
 146         Editing::MouseMode current_mouse_mode () { return mouse_mode; }
 147
 148         void add_imageframe_time_axis(const string & track_name, void*) ;
 149         void add_imageframe_marker_time_axis(const string & track_name, TimeAxisView* marked_track, void*) ;
 150         void connect_to_image_compositor() ;
 151         void scroll_timeaxis_to_imageframe_item(const TimeAxisViewItem* item) ;
 152         TimeAxisView* get_named_time_axis(const string & name) ;
 153         /* </CMT Additions> */
 154
 155         void consider_auditioning (ARDOUR::Region&);
 156         void hide_a_region (ARDOUR::Region&);
 157         void remove_a_region (ARDOUR::Region&);
 158
 159         /* option editor-access */
 160
 161         void set_show_waveforms (bool yn);
 162         bool show_waveforms() const { return _show_waveforms; }
 163
 164         void set_show_waveforms_recording (bool yn);
 165         bool show_waveforms_recording() const { return _show_waveforms_recording; }
 166
 167         /* things that need to be public to be used in the main menubar */
 168
 169         void new_region_from_selection ();
 170         void separate_region_from_selection ();
 171         void toggle_playback (bool with_abort);
 172
 173         /* undo related */
 174
 175         void set_edit_menu (Gtk::Menu&);
 176
 177         jack_nframes_t unit_to_frame (double unit) {
 178                 return (jack_nframes_t) rint (unit * frames_per_unit);
 179         }
 180
 181         double frame_to_unit (jack_nframes_t frame) {
 182                 return rint ((double) frame / (double) frames_per_unit);
 183         }
 184
 185         double frame_to_unit (double frame) {
 186                 return rint (frame / frames_per_unit);
 187         }
 188
 189         /* NOTE: these functions assume that the "pixel" coordinate is
 190            the result of using the world->canvas affine transform on a
 191            world coordinate. These coordinates already take into
 192            account any scrolling carried out by adjusting the
 193            xscroll_adjustment.
 194         */
 195
 196         jack_nframes_t pixel_to_frame (double pixel) {
 197
 198                 /* pixel can be less than zero when motion events
 199                    are processed. since we've already run the world->canvas
 200                    affine, that means that the location *really* is "off
 201                    to the right" and thus really is "before the start".
 202                 */
 203
 204                 if (pixel >= 0) {
 205                         return (jack_nframes_t) rint (pixel * frames_per_unit * GNOME_CANVAS(track_canvas.gobj())->pixels_per_unit);
 206                 } else {
 207                         return 0;
 208                 }
 209         }
 210
 211         gulong frame_to_pixel (jack_nframes_t frame) {
 212                 return (gulong) rint ((frame / (frames_per_unit *  GNOME_CANVAS(track_canvas.gobj())->pixels_per_unit)));
 213         }
 214
 215         /* selection */
 216
 217         Selection& get_selection() const { return *selection; }
 218         Selection& get_cut_buffer() const { return *cut_buffer; }
 219
 220         void play_selection ();
 221         void select_all_in_track (Selection::Operation op);
 222         void select_all (Selection::Operation op);
 223         void invert_selection_in_track ();
 224         void invert_selection ();
 225
 226         /* tempo */
 227
 228         void set_show_measures (bool yn);
 229         bool show_measures () const { return _show_measures; }
 230
 231 #ifdef FFT_ANALYSIS
 232         /* analysis window */
 233         void analyze_region_selection();
 234         void analyze_range_selection();
 235 #endif
 236
 237         /* export */
 238
 239         /* these initiate export ... */
 240
 241         void export_session();
 242         void export_selection();
 243
 244         /* this is what actually does it */
 245
 246         void export_audiofile (ARDOUR::AudioExportSpecification&);
 247
 248         /* */
 249
 250         void add_toplevel_controls (Gtk::Container&);
 251
 252         void      set_zoom_focus (Editing::ZoomFocus);
 253         Editing::ZoomFocus get_zoom_focus () const { return zoom_focus; }
 254         gdouble   get_current_zoom () { return frames_per_unit; }
 255
 256         void temporal_zoom_step (bool coarser);
 257
 258         /* stuff that AudioTimeAxisView and related classes use */
 259
 260         PlaylistSelector& playlist_selector() const;
 261         void route_name_changed (TimeAxisView *);
 262         gdouble        frames_per_unit;
 263         jack_nframes_t leftmost_frame;
 264         void clear_playlist (ARDOUR::Playlist&);
 265
 266         void new_playlists ();
 267         void copy_playlists ();
 268         void clear_playlists ();
 269
 270         TrackViewList* get_valid_views (TimeAxisView*, ARDOUR::RouteGroup* grp = 0);
 271
 272         Width editor_mixer_strip_width;
 273         void show_editor_mixer (bool yn);
 274         void set_selected_mixer_strip (TimeAxisView&);
 275         void hide_track_in_display (TimeAxisView& tv);
 276         void show_track_in_display (TimeAxisView& tv);
 277
 278         /* nudge is initiated by transport controls owned by ARDOUR_UI */
 279
 280         void nudge_forward (bool next);
 281         void nudge_backward (bool next);
 282
 283         /* nudge initiated from context menu */
 284
 285         void nudge_forward_capture_offset ();
 286         void nudge_backward_capture_offset ();
 287
 288         /* playhead/screen stuff */
 289
 290         void set_follow_playhead (bool yn);
 291         void toggle_follow_playhead ();
 292         bool follow_playhead() const { return _follow_playhead; }
 293
 294         void toggle_waveform_visibility ();
 295         void toggle_waveforms_while_recording ();
 296         void toggle_measure_visibility ();
 297
 298         void set_meter_falloff (float);
 299         void set_meter_hold (int32_t);
 300
 301         /* xfades */
 302
 303         void toggle_xfades_active();
 304         void toggle_xfade_visibility ();
 305         void set_xfade_visibility (bool yn);
 306         bool xfade_visibility() const { return _xfade_visibility; }
 307
 308         /* redirect shared ops menu. caller must free returned menu */
 309
 310         Gtk::Menu* redirect_menu ();
 311
 312         /* floating windows/transient */
 313
 314         void ensure_float (Gtk::Window&);
 315
 316         void show_window ();
 317
 318         void scroll_tracks_down_line ();
 319         void scroll_tracks_up_line ();
 320
 321         bool new_regionviews_display_gain () { return _new_regionviews_show_envelope; }
 322         void prepare_for_cleanup ();
 323
 324         void reposition_x_origin (jack_nframes_t sample);
 325
 326         void maximise_editing_space();
 327         void restore_editing_space();
 328
 329   protected:
 330         void map_transport_state ();
 331         void map_position_change (jack_nframes_t);
 332
 333         void on_realize();
 334
 335   private:
 336
 337         ARDOUR::Session     *session;
 338         ARDOUR::AudioEngine& engine;
 339         bool                 constructed;
 340
 341         PlaylistSelector* _playlist_selector;
 342
 343         enum ItemType {
 344                 RegionItem,
 345                 StreamItem,
 346                 PlayheadCursorItem,
 347                 EditCursorItem,
 348                 MarkerItem,
 349                 MarkerBarItem,
 350                 RangeMarkerBarItem,
 351                 TransportMarkerBarItem,
 352                 SelectionItem,
 353                 GainControlPointItem,
 354                 GainLineItem,
 355                 GainAutomationControlPointItem,
 356                 GainAutomationLineItem,
 357                 PanAutomationControlPointItem,
 358                 PanAutomationLineItem,
 359                 RedirectAutomationControlPointItem,
 360                 RedirectAutomationLineItem,
 361                 MeterMarkerItem,
 362                 TempoMarkerItem,
 363                 MeterBarItem,
 364                 TempoBarItem,
 365                 AudioRegionViewNameHighlight,
 366                 AudioRegionViewName,
 367                 StartSelectionTrimItem,
 368                 EndSelectionTrimItem,
 369                 AutomationTrackItem,
 370                 FadeInItem,
 371                 FadeInHandleItem,
 372                 FadeOutItem,
 373                 FadeOutHandleItem,
 374
 375                 /* <CMT Additions> */
 376                 MarkerViewItem,
 377                 MarkerTimeAxisItem,
 378                 MarkerViewHandleStartItem,
 379                 MarkerViewHandleEndItem,
 380                 ImageFrameItem,
 381                 ImageFrameTimeAxisItem,
 382                 ImageFrameHandleStartItem,
 383                 ImageFrameHandleEndItem,
 384                 /* </CMT Additions> */
 385
 386                 CrossfadeViewItem,
 387
 388                 /* don't remove this */
 389
 390                 NoItem
 391         };
 392
 393         void          set_frames_per_unit (double);
 394         void          frames_per_unit_modified ();
 395
 396         Editing::MouseMode mouse_mode;
 397         void      mouse_insert (GdkEventButton *);
 398
 399         int  pre_maximal_pane_position;
 400         void pane_allocation_handler (Gtk::Allocation&, Gtk::Paned*);
 401
 402         Gtk::Notebook the_notebook;
 403         Gtk::HPaned   edit_pane;
 404
 405         Gtk::EventBox meter_base;
 406         Gtk::HBox     meter_box;
 407         Gtk::EventBox marker_base;
 408         Gtk::HBox     marker_box;
 409         Gtk::VBox     scrollers_rulers_markers_box;
 410
 411         void location_changed (ARDOUR::Location *);
 412         void location_flags_changed (ARDOUR::Location *, void *);
 413         void refresh_location_display ();
 414         void refresh_location_display_s (ARDOUR::Change);
 415         void refresh_location_display_internal (ARDOUR::Locations::LocationList&);
 416         void add_new_location (ARDOUR::Location *);
 417         void location_gone (ARDOUR::Location *);
 418         void remove_marker (ArdourCanvas::Item&, GdkEvent*);
 419         gint really_remove_marker (ARDOUR::Location* loc);
 420
 421         uint32_t location_marker_color;
 422         uint32_t location_range_color;
 423         uint32_t location_loop_color;
 424         uint32_t location_punch_color;
 425         uint32_t location_cd_marker_color;
 426
 427         struct LocationMarkers {
 428             Marker* start;
 429             Marker* end;
 430
 431             ~LocationMarkers ();
 432
 433             void hide();
 434             void show ();
 435             void set_name (const string&);
 436             void set_position (jack_nframes_t start, jack_nframes_t end = 0);
 437             void set_color_rgba (uint32_t);
 438         };
 439
 440         LocationMarkers  *find_location_markers (ARDOUR::Location *);
 441         ARDOUR::Location* find_location_from_marker (Marker *, bool& is_start);
 442
 443         typedef std::map<ARDOUR::Location*,LocationMarkers *> LocationMarkerMap;
 444         LocationMarkerMap location_markers;
 445
 446         void hide_marker (ArdourCanvas::Item*, GdkEvent*);
 447         void clear_marker_display ();
 448         void mouse_add_new_marker (jack_nframes_t where);
 449
 450         TimeAxisView*      clicked_trackview;
 451         AudioTimeAxisView* clicked_audio_trackview;
 452         AudioRegionView*   clicked_regionview;
 453         AudioRegionView*   latest_regionview;
 454         uint32_t           clicked_selection;
 455         CrossfadeView*     clicked_crossfadeview;
 456         ControlPoint*      clicked_control_point;
 457
 458         void mapover_audio_tracks (sigc::slot<void,AudioTimeAxisView&,uint32_t> sl);
 459
 460         /* functions to be passed to mapover_audio_tracks(), possibly with sigc::bind()-supplied arguments */
 461
 462         void mapped_set_selected_regionview_from_click (AudioTimeAxisView&, uint32_t, AudioRegionView*, vector<AudioRegionView*>*);
 463         void mapped_use_new_playlist (AudioTimeAxisView&, uint32_t);
 464         void mapped_use_copy_playlist (AudioTimeAxisView&, uint32_t);
 465         void mapped_clear_playlist (AudioTimeAxisView&, uint32_t);
 466
 467         /* end */
 468
 469         void catch_vanishing_audio_regionview (AudioRegionView *);
 470         void set_selected_control_point_from_click (Selection::Operation op = Selection::Set, bool with_undo = true, bool no_remove=false);
 471         void set_selected_track_from_click (Selection::Operation op = Selection::Set, bool with_undo = true, bool no_remove=false);
 472         void set_selected_regionview_from_click (Selection::Operation op = Selection::Set, bool no_track_remove=false);
 473         void set_selected_regionview_from_region_list (ARDOUR::Region& region, Selection::Operation op = Selection::Set);
 474         bool set_selected_regionview_from_map_event (GdkEventAny*, StreamView*, ARDOUR::Region*);
 475         void collect_new_region_view (AudioRegionView *);
 476
 477         Gtk::Menu track_context_menu;
 478         Gtk::Menu track_region_context_menu;
 479         Gtk::Menu track_selection_context_menu;
 480         Gtk::Menu track_crossfade_context_menu;
 481
 482         Gtk::MenuItem* region_edit_menu_split_item;
 483         Gtk::MenuItem* region_edit_menu_split_multichannel_item;
 484         Gtk::Menu * track_region_edit_playlist_menu;
 485         Gtk::Menu * track_edit_playlist_submenu;
 486         Gtk::Menu * track_selection_edit_playlist_submenu;
 487
 488         void popup_track_context_menu (int, int, ItemType, bool, jack_nframes_t);
 489         Gtk::Menu* build_track_context_menu (jack_nframes_t);
 490         Gtk::Menu* build_track_bus_context_menu (jack_nframes_t);
 491         Gtk::Menu* build_track_region_context_menu (jack_nframes_t frame);
 492         Gtk::Menu* build_track_crossfade_context_menu (jack_nframes_t);
 493         Gtk::Menu* build_track_selection_context_menu (jack_nframes_t);
 494         void add_dstream_context_items (Gtk::Menu_Helpers::MenuList&);
 495         void add_bus_context_items (Gtk::Menu_Helpers::MenuList&);
 496         void add_region_context_items (StreamView*, ARDOUR::Region*, Gtk::Menu_Helpers::MenuList&);
 497         void add_crossfade_context_items (StreamView*, ARDOUR::Crossfade*, Gtk::Menu_Helpers::MenuList&, bool many);
 498         void add_selection_context_items (Gtk::Menu_Helpers::MenuList&);
 499
 500         void handle_new_route (ARDOUR::Route&);
 501         void handle_new_route_p (ARDOUR::Route*);
 502         void remove_route (TimeAxisView *);
 503         bool route_removal;
 504
 505         Gtk::HBox           global_hpacker;
 506         Gtk::VBox           global_vpacker;
 507         Gtk::VBox           vpacker;
 508
 509         Gdk::Cursor*          current_canvas_cursor;
 510
 511         ArdourCanvas::CanvasAA track_canvas;
 512         ArdourCanvas::CanvasAA time_canvas;
 513
 514         ArdourCanvas::Text* first_action_message;
 515         ArdourCanvas::Text* verbose_canvas_cursor;
 516         bool                 verbose_cursor_visible;
 517
 518         void session_control_changed (ARDOUR::Session::ControlType);
 519         void queue_session_control_changed (ARDOUR::Session::ControlType);
 520
 521
 522         bool track_canvas_motion (GdkEvent*);
 523
 524         void set_verbose_canvas_cursor (const string &, double x, double y);
 525         void set_verbose_canvas_cursor_text (const string &);
 526         void show_verbose_canvas_cursor();
 527         void hide_verbose_canvas_cursor();
 528
 529         bool verbose_cursor_on; // so far unused
 530
 531         void flush_track_canvas ();
 532         void flush_time_canvas ();
 533
 534         Gtk::EventBox      time_canvas_event_box;
 535         Gtk::EventBox      track_canvas_event_box;
 536         Gtk::EventBox      time_button_event_box;
 537
 538         ArdourCanvas::Group      *minsec_group;
 539         ArdourCanvas::Group      *bbt_group;
 540         ArdourCanvas::Group      *smpte_group;
 541         ArdourCanvas::Group      *frame_group;
 542         ArdourCanvas::Group      *tempo_group;
 543         ArdourCanvas::Group      *meter_group;
 544         ArdourCanvas::Group      *marker_group;
 545         ArdourCanvas::Group      *range_marker_group;
 546         ArdourCanvas::Group      *transport_marker_group;
 547
 548         enum {
 549                 ruler_metric_smpte = 0,
 550                 ruler_metric_bbt = 1,
 551                 ruler_metric_frames = 2,
 552                 ruler_metric_minsec = 3,
 553
 554                 ruler_time_tempo = 4,
 555                 ruler_time_meter = 5,
 556                 ruler_time_marker = 6,
 557                 ruler_time_range_marker = 7,
 558                 ruler_time_transport_marker = 8,
 559         };
 560
 561         static GtkCustomMetric ruler_metrics[4];
 562         bool                   ruler_shown[9];
 563         bool                   no_ruler_shown_update;
 564
 565         gint ruler_button_press (GdkEventButton*);
 566         gint ruler_button_release (GdkEventButton*);
 567         gint ruler_mouse_motion (GdkEventMotion*);
 568
 569         gint ruler_pressed_button;
 570         Gtk::Widget * ruler_grabbed_widget;
 571
 572         void initialize_rulers ();
 573         void update_just_smpte ();
 574         void update_fixed_rulers ();
 575         void update_tempo_based_rulers ();
 576         void popup_ruler_menu (jack_nframes_t where = 0, ItemType type = RegionItem);
 577         void update_ruler_visibility ();
 578         void ruler_toggled (int);
 579         gint ruler_label_button_release (GdkEventButton*);
 580         void store_ruler_visibility ();
 581         void restore_ruler_visibility ();
 582
 583         static gint _metric_get_smpte (GtkCustomRulerMark **, gdouble, gdouble, gint);
 584         static gint _metric_get_bbt (GtkCustomRulerMark **, gdouble, gdouble, gint);
 585         static gint _metric_get_frames (GtkCustomRulerMark **, gdouble, gdouble, gint);
 586         static gint _metric_get_minsec (GtkCustomRulerMark **, gdouble, gdouble, gint);
 587
 588         gint metric_get_smpte (GtkCustomRulerMark **, gdouble, gdouble, gint);
 589         gint metric_get_bbt (GtkCustomRulerMark **, gdouble, gdouble, gint);
 590         gint metric_get_frames (GtkCustomRulerMark **, gdouble, gdouble, gint);
 591         gint metric_get_minsec (GtkCustomRulerMark **, gdouble, gdouble, gint);
 592
 593         GtkWidget          *_smpte_ruler;
 594         GtkWidget          *_bbt_ruler;
 595         GtkWidget          *_frames_ruler;
 596         GtkWidget          *_minsec_ruler;
 597         Gtk::Widget        *smpte_ruler;
 598         Gtk::Widget        *bbt_ruler;
 599         Gtk::Widget        *frames_ruler;
 600         Gtk::Widget        *minsec_ruler;
 601         static Editor      *ruler_editor;
 602
 603         static const double timebar_height;
 604         guint32 visible_timebars;
 605         Gtk::Menu          *editor_ruler_menu;
 606
 607         ArdourCanvas::SimpleRect* tempo_bar;
 608         ArdourCanvas::SimpleRect* meter_bar;
 609         ArdourCanvas::SimpleRect* marker_bar;
 610         ArdourCanvas::SimpleRect* range_marker_bar;
 611         ArdourCanvas::SimpleRect* transport_marker_bar;
 612
 613
 614         ArdourCanvas::SimpleLine* tempo_line;
 615         ArdourCanvas::SimpleLine* meter_line;
 616         ArdourCanvas::SimpleLine* marker_line;
 617         ArdourCanvas::SimpleLine* range_marker_line;
 618         ArdourCanvas::SimpleLine* transport_marker_line;
 619
 620         Gtk::Label  minsec_label;
 621         Gtk::Label  bbt_label;
 622         Gtk::Label  smpte_label;
 623         Gtk::Label  frame_label;
 624         Gtk::Label  tempo_label;
 625         Gtk::Label  meter_label;
 626         Gtk::Label  mark_label;
 627         Gtk::Label  range_mark_label;
 628         Gtk::Label  transport_mark_label;
 629
 630
 631         Gtk::VBox          time_button_vbox;
 632         Gtk::HBox          time_button_hbox;
 633
 634         struct Cursor {
 635             Editor&               editor;
 636             ArdourCanvas::Points  points;
 637             ArdourCanvas::Line    canvas_item;
 638             jack_nframes_t        current_frame;
 639             double                length;
 640
 641             Cursor (Editor&, const string& color, bool (Editor::*)(GdkEvent*,ArdourCanvas::Item*));
 642             ~Cursor ();
 643
 644             void set_position (jack_nframes_t);
 645             void set_length (double units);
 646             void set_y_axis (double position);
 647         };
 648
 649         friend struct Cursor; /* it needs access to several private
 650                                  fields. XXX fix me.
 651                               */
 652
 653         Cursor* playhead_cursor;
 654         Cursor* edit_cursor;
 655         ArdourCanvas::Group* cursor_group;
 656
 657         void    cursor_to_next_region_point (Cursor*, ARDOUR::RegionPoint);
 658         void    cursor_to_previous_region_point (Cursor*, ARDOUR::RegionPoint);
 659         void    cursor_to_region_point (Cursor*, ARDOUR::RegionPoint, int32_t dir);
 660         void    cursor_to_selection_start (Cursor *);
 661         void    cursor_to_selection_end   (Cursor *);
 662         void    select_all_selectables_using_cursor (Cursor *, bool);
 663
 664         ARDOUR::Region* find_next_region (jack_nframes_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList&, TimeAxisView ** = 0);
 665
 666         vector<jack_nframes_t> region_boundary_cache;
 667         void build_region_boundary_cache ();
 668
 669         Gtk::VBox           trackview_vpacker;
 670
 671         Gtk::HBox           top_hbox;
 672         Gtk::HBox           bottom_hbox;
 673
 674         Gtk::Table          edit_packer;
 675         Gtk::VScrollbar     edit_vscrollbar;
 676
 677         Gtk::Adjustment     vertical_adjustment;
 678         Gtk::Adjustment     horizontal_adjustment;
 679
 680         Gtk::Layout         controls_layout;
 681         bool control_layout_scroll (GdkEventScroll* ev);
 682         void controls_layout_size_request (Gtk::Requisition*);
 683
 684         Gtk::HScrollbar     edit_hscrollbar;
 685         bool                edit_hscroll_dragging;
 686
 687         bool hscrollbar_button_press (GdkEventButton*);
 688         bool hscrollbar_button_release (GdkEventButton*);
 689         void hscrollbar_allocate (Gtk::Allocation &alloc);
 690
 691         double canvas_width;
 692         double canvas_height;
 693
 694         bool track_canvas_map_handler (GdkEventAny*);
 695         bool time_canvas_map_handler (GdkEventAny*);
 696
 697         gint edit_controls_button_release (GdkEventButton*);
 698         Gtk::Menu *edit_controls_left_menu;
 699         Gtk::Menu *edit_controls_right_menu;
 700
 701         void track_canvas_scroller_realized ();
 702         void time_canvas_scroller_realized ();
 703
 704         Gtk::VBox           track_canvas_vbox;
 705         Gtk::VBox           time_canvas_vbox;
 706         Gtk::VBox           edit_controls_vbox;
 707         Gtk::HBox           edit_controls_hbox;
 708
 709         void tie_vertical_scrolling ();
 710         void canvas_horizontally_scrolled ();
 711         void reposition_and_zoom (jack_nframes_t sample, double fpu);
 712         gint deferred_reposition_and_zoom (jack_nframes_t sample, double fpu);
 713         void end_location_changed (ARDOUR::Location*);
 714         bool repos_zoom_queued;
 715         bool no_zoom_repos_update;
 716         bool no_tempo_map_update;
 717
 718         struct RegionListDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
 719             RegionListDisplayModelColumns() {
 720                     add (name);
 721                     add (region);
 722                     add (color_);
 723             }
 724             Gtk::TreeModelColumn<Glib::ustring> name;
 725             Gtk::TreeModelColumn<ARDOUR::Region*> region;
 726                 Gtk::TreeModelColumn<Gdk::Color> color_;
 727         };
 728
 729         RegionListDisplayModelColumns    region_list_columns;
 730         Gtkmm2ext::DnDTreeView           region_list_display;
 731         Glib::RefPtr<Gtk::TreeStore>     region_list_model;
 732         Glib::RefPtr<Gtk::ToggleAction>  toggle_full_region_list_action;
 733         Glib::RefPtr<Gtk::ToggleAction>  toggle_show_auto_regions_action;
 734
 735         void region_list_selection_changed ();
 736         bool region_list_selection_filter (const Glib::RefPtr<Gtk::TreeModel>& model, const Gtk::TreeModel::Path& path, bool yn);
 737
 738         Gtk::Menu          *region_list_menu;
 739         Gtk::ScrolledWindow region_list_scroller;
 740         Gtk::Frame          region_list_frame;
 741
 742         bool region_list_display_key_press (GdkEventKey *);
 743         bool region_list_display_key_release (GdkEventKey *);
 744         bool region_list_display_button_press (GdkEventButton *);
 745         bool region_list_display_button_release (GdkEventButton *);
 746         void region_list_clear ();
 747         void region_list_selection_mapover (sigc::slot<void,ARDOUR::Region&>);
 748         void build_region_list_menu ();
 749         void show_region_list_display_context_menu (int button, int time);
 750
 751         bool show_automatic_regions_in_region_list;
 752         Editing::RegionListSortType region_list_sort_type;
 753
 754         void reset_region_list_sort_direction (bool);
 755         void reset_region_list_sort_type (Editing::RegionListSortType);
 756
 757         void toggle_full_region_list ();
 758         void toggle_show_auto_regions ();
 759
 760         int region_list_sorter (Gtk::TreeModel::iterator, Gtk::TreeModel::iterator);
 761
 762         /* snapshots */
 763
 764         Gtk::ScrolledWindow      snapshot_display_scroller;
 765         struct SnapshotDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
 766             SnapshotDisplayModelColumns() {
 767                     add (visible_name);
 768                     add (real_name);
 769             }
 770             Gtk::TreeModelColumn<Glib::ustring> visible_name;
 771             Gtk::TreeModelColumn<Glib::ustring> real_name;
 772         };
 773
 774         SnapshotDisplayModelColumns snapshot_display_columns;
 775         Glib::RefPtr<Gtk::ListStore> snapshot_display_model;
 776         Gtk::TreeView snapshot_display;
 777
 778         bool snapshot_display_button_press (GdkEventButton*);
 779         void snapshot_display_selection_changed ();
 780         void redisplay_snapshots();
 781
 782         /* named selections */
 783
 784         struct NamedSelectionDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
 785             NamedSelectionDisplayModelColumns() {
 786                     add (text);
 787                     add (selection);
 788             }
 789             Gtk::TreeModelColumn<Glib::ustring>  text;
 790             Gtk::TreeModelColumn<ARDOUR::NamedSelection*>    selection;
 791         };
 792
 793         NamedSelectionDisplayModelColumns named_selection_columns;
 794         Glib::RefPtr<Gtk::TreeStore>     named_selection_model;
 795
 796         Gtkmm2ext::DnDTreeView named_selection_display;
 797         Gtk::ScrolledWindow    named_selection_scroller;
 798
 799         void name_selection();
 800         void named_selection_name_chosen ();
 801         void create_named_selection (const string &);
 802         void paste_named_selection (float times);
 803
 804         void handle_new_named_selection ();
 805         void add_named_selection_to_named_selection_display (ARDOUR::NamedSelection&);
 806         void redisplay_named_selections ();
 807
 808         gint named_selection_display_button_press (GdkEventButton *ev);
 809         void named_selection_display_selection_changed ();
 810
 811         /* track views */
 812         int track_spacing;
 813         TrackViewList  track_views;
 814         TimeAxisView     *trackview_by_y_position (double ypos);
 815
 816         static Gdk::Cursor* cross_hair_cursor;
 817         static Gdk::Cursor* trimmer_cursor;
 818         static Gdk::Cursor* selector_cursor;
 819         static Gdk::Cursor* grabber_cursor;
 820         static Gdk::Cursor* zoom_cursor;
 821         static Gdk::Cursor* time_fx_cursor;
 822         static Gdk::Cursor* fader_cursor;
 823         static Gdk::Cursor* speaker_cursor;
 824         static Gdk::Cursor* wait_cursor;
 825         static Gdk::Cursor* timebar_cursor;
 826
 827         static void build_cursors ();
 828
 829         sigc::connection scroll_connection;
 830         jack_nframes_t last_update_frame;
 831         void center_screen (jack_nframes_t);
 832         void center_screen_internal (jack_nframes_t, float);
 833
 834         void update_current_screen ();
 835         sigc::connection slower_update_connection;
 836         void update_slower ();
 837
 838         gint show_track_context_menu (GdkEventButton *);
 839         void hide_track_context_menu ();
 840
 841         void session_going_away ();
 842
 843         jack_nframes_t cut_buffer_start;
 844         jack_nframes_t cut_buffer_length;
 845
 846         bool typed_event (ArdourCanvas::Item*, GdkEvent*, ItemType);
 847         bool button_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
 848         bool button_release_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
 849         bool motion_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
 850         bool enter_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
 851         bool leave_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
 852
 853         /* KEYMAP HANDLING */
 854
 855         void register_actions ();
 856
 857         int ensure_cursor (jack_nframes_t* pos);
 858
 859         void fake_handle_new_audio_region (ARDOUR::AudioRegion *);
 860         void handle_new_audio_region (ARDOUR::AudioRegion *);
 861         void fake_handle_audio_region_removed (ARDOUR::AudioRegion *);
 862         void handle_audio_region_removed (ARDOUR::AudioRegion *);
 863         void add_audio_region_to_region_display (ARDOUR::AudioRegion *);
 864         void region_hidden (ARDOUR::Region*);
 865         void redisplay_regions ();
 866         void insert_into_tmp_audio_regionlist(ARDOUR::AudioRegion *);
 867
 868         list<ARDOUR::AudioRegion *> tmp_audio_region_list;
 869
 870         void cut_copy (Editing::CutCopyOp);
 871         void cut_copy_points (Editing::CutCopyOp);
 872         void cut_copy_regions (Editing::CutCopyOp);
 873         void cut_copy_ranges (Editing::CutCopyOp);
 874
 875         void mouse_paste ();
 876         void paste_internal (jack_nframes_t position, float times);
 877
 878         /* EDITING OPERATIONS */
 879
 880         void toggle_region_mute ();
 881         void toggle_region_opaque ();
 882         void raise_region ();
 883         void raise_region_to_top ();
 884         void lower_region ();
 885         void lower_region_to_bottom ();
 886         void split_region ();
 887         void split_region_at (jack_nframes_t);
 888         void split_regions_at (jack_nframes_t, AudioRegionSelection&);
 889         void crop_region_to_selection ();
 890         void set_a_regions_sync_position (ARDOUR::Region&, jack_nframes_t);
 891         void set_region_sync_from_edit_cursor ();
 892         void remove_region_sync();
 893         void align_selection (ARDOUR::RegionPoint, jack_nframes_t position);
 894         void align_selection_relative (ARDOUR::RegionPoint point, jack_nframes_t position);
 895         void align_region (ARDOUR::Region&, ARDOUR::RegionPoint point, jack_nframes_t position);
 896         void align_region_internal (ARDOUR::Region&, ARDOUR::RegionPoint point, jack_nframes_t position);
 897         void remove_some_regions ();
 898         void remove_clicked_region ();
 899         void destroy_clicked_region ();
 900         void edit_region ();
 901         void duplicate_some_regions (AudioRegionSelection&, float times);
 902         void duplicate_selection (float times);
 903         void region_fill_selection ();
 904
 905         void region_fill_track ();
 906         void audition_playlist_region_standalone (ARDOUR::AudioRegion&);
 907         void audition_playlist_region_via_route (ARDOUR::AudioRegion&, ARDOUR::Route&);
 908         void split_multichannel_region();
 909         void reverse_region ();
 910         void normalize_region ();
 911         void denormalize_region ();
 912
 913         void audition_region_from_region_list ();
 914         void hide_region_from_region_list ();
 915         void remove_region_from_region_list ();
 916
 917         void align (ARDOUR::RegionPoint);
 918         void align_relative (ARDOUR::RegionPoint);
 919         void naturalize ();
 920
 921         void cut ();
 922         void copy ();
 923         void paste (float times);
 924
 925         int  get_prefix (float&, bool&);
 926
 927         void keyboard_paste ();
 928         void keyboard_duplicate_region ();
 929         void keyboard_duplicate_selection ();
 930         void keyboard_nudge ();
 931         void keyboard_insert_region_list_selection ();
 932
 933         void region_from_selection ();
 934         void create_region_from_selection (std::vector<ARDOUR::AudioRegion*>&);
 935
 936         bool region_renamed;
 937         void rename_region ();
 938         void rename_region_finished (bool);
 939
 940         void play_from_start ();
 941         void play_from_edit_cursor ();
 942         void play_selected_region ();
 943         void audition_selected_region ();
 944         void toggle_loop_playback ();
 945         void loop_selected_region ();
 946         void play_location (ARDOUR::Location&);
 947         void loop_location (ARDOUR::Location&);
 948
 949         Editing::ZoomFocus zoom_focus;
 950
 951         void temporal_zoom_selection ();
 952         void temporal_zoom_session ();
 953         void temporal_zoom (gdouble scale);
 954         void temporal_zoom_by_frame (jack_nframes_t start, jack_nframes_t end, const string & op);
 955         void temporal_zoom_to_frame (bool coarser, jack_nframes_t frame);
 956
 957         void amplitude_zoom (gdouble scale);
 958         void amplitude_zoom_step (bool in);
 959
 960         void insert_region_list_drag (ARDOUR::AudioRegion&, int x, int y);
 961         void insert_region_list_selection (float times);
 962
 963         void insert_sndfile (bool as_tracks);
 964         void embed_audio ();    // inserts into region list
 965         int  reject_because_rate_differs (const string & path, ARDOUR::SoundFileInfo& finfo, const string & action, bool multiple_pending);
 966
 967         void do_embed_sndfiles (vector<string> paths, bool split);
 968         void embed_sndfile (string path, bool split, bool multiple_files, bool& check_sr);
 969
 970         void do_insert_sndfile (vector<string> path, bool multi, jack_nframes_t frame);
 971         void insert_paths_as_new_tracks (std::vector<std::string> paths, bool multi); // inserts files as new tracks
 972         void insert_sndfile_into (const string & path, bool multi, AudioTimeAxisView* tv, jack_nframes_t& frame, bool prompt=true);
 973         static void* _insert_sndfile_thread (void*);
 974         void*  insert_sndfile_thread (void*);
 975
 976         /* generic interthread progress window */
 977
 978         ArdourDialog* interthread_progress_window;
 979         Gtk::Label interthread_progress_label;
 980         Gtk::VBox interthread_progress_vbox;
 981         Gtk::ProgressBar interthread_progress_bar;
 982         Gtk::Button interthread_cancel_button;
 983         Gtk::Label interthread_cancel_label;
 984         sigc::connection  interthread_progress_connection;
 985         void interthread_cancel_clicked ();
 986         void build_interthread_progress_window ();
 987         ARDOUR::InterThreadInfo* current_interthread_info;
 988
 989 #ifdef FFT_ANALYSIS
 990         AnalysisWindow* analysis_window;
 991 #endif
 992
 993         /* import specific info */
 994
 995         ARDOUR::Session::import_status import_status;
 996         gint import_progress_timeout (void *);
 997         static void *_import_thread (void *);
 998         void* import_thread ();
 999         void catch_new_audio_region (ARDOUR::AudioRegion*);
1000         ARDOUR::AudioRegion* last_audio_region;
1001
1002         /* to support this ... */
1003
1004         void import_audio (bool as_tracks);
1005         void do_import (vector<string> paths, bool split, bool as_tracks);
1006
1007         void move_to_start ();
1008         void move_to_end ();
1009         void goto_frame ();
1010         void center_playhead ();
1011         void center_edit_cursor ();
1012         void edit_cursor_backward ();
1013         void edit_cursor_forward ();
1014         void playhead_backward ();
1015         void playhead_forward ();
1016         void scroll_backward (float pages=0.8f);
1017         void scroll_forward (float pages=0.8f);
1018         void scroll_tracks_down ();
1019         void scroll_tracks_up ();
1020         void delete_sample_forward ();
1021         void delete_sample_backward ();
1022         void delete_screen ();
1023         void search_backwards ();
1024         void search_forwards ();
1025         void set_mark ();
1026         void clear_markers ();
1027         void clear_ranges ();
1028         void clear_locations ();
1029         void jump_forward_to_mark ();
1030         void jump_backward_to_mark ();
1031         void cursor_align (bool playhead_to_edit);
1032
1033         void remove_last_capture ();
1034         void select_all_selectables_using_time_selection ();
1035         void select_all_selectables_using_loop();
1036         void select_all_selectables_using_punch();
1037         void set_selection_from_range (ARDOUR::Location&);
1038         void set_selection_from_punch ();
1039         void set_selection_from_loop ();
1040
1041         void add_location_from_selection ();
1042         void set_route_loop_selection ();
1043
1044         void add_location_from_playhead_cursor ();
1045
1046         void reverse_selection ();
1047         void edit_envelope ();
1048
1049         void start_scrolling ();
1050         void stop_scrolling ();
1051
1052         void keyboard_selection_begin ();
1053         void keyboard_selection_finish (bool add);
1054         bool have_pending_keyboard_selection;
1055         jack_nframes_t pending_keyboard_selection_start;
1056
1057         ARDOUR::AudioRegion* select_region_for_operation (int dir, TimeAxisView **tv);
1058         void extend_selection_to_end_of_region (bool next);
1059         void extend_selection_to_start_of_region (bool previous);
1060
1061         Editing::SnapType snap_type;
1062         Editing::SnapMode snap_mode;
1063         double snap_threshold;
1064
1065         void soundfile_chosen_for_insert (const string & selection, bool split_channels);
1066         void soundfile_chosen_for_embed (const string & selection, bool split_channels);
1067         void soundfile_chosen_for_import (const string & selection, bool split_channels);
1068
1069         void handle_gui_changes (const string &, void *);
1070
1071         void    hide_all_tracks (bool with_select);
1072
1073         DragInfo drag_info;
1074         LineDragInfo current_line_drag_info;
1075
1076         void start_grab (GdkEvent*, Gdk::Cursor* cursor = 0);
1077         bool end_grab (ArdourCanvas::Item*, GdkEvent*);
1078
1079         Gtk::Menu fade_context_menu;
1080         void popup_fade_context_menu (int, int, ArdourCanvas::Item*, ItemType);
1081
1082         void start_fade_in_grab (ArdourCanvas::Item*, GdkEvent*);
1083         void start_fade_out_grab (ArdourCanvas::Item*, GdkEvent*);
1084         void fade_in_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1085         void fade_out_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1086         void fade_in_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1087         void fade_out_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1088
1089         std::set<ARDOUR::Playlist*> motion_frozen_playlists;
1090         void region_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1091         void region_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1092         void region_copy_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1093
1094         void cursor_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1095         void cursor_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1096         void marker_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1097         void marker_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1098         void control_point_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1099         void control_point_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1100         void line_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1101         void line_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1102
1103         void tempo_marker_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1104         void tempo_marker_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1105         void meter_marker_drag_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1106         void meter_marker_drag_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1107
1108         gint mouse_rename_region (ArdourCanvas::Item*, GdkEvent*);
1109
1110         void start_region_grab (ArdourCanvas::Item*, GdkEvent*);
1111         void start_region_copy_grab (ArdourCanvas::Item*, GdkEvent*);
1112         void start_region_brush_grab (ArdourCanvas::Item*, GdkEvent*);
1113         void start_selection_grab (ArdourCanvas::Item*, GdkEvent*);
1114         void start_cursor_grab (ArdourCanvas::Item*, GdkEvent*);
1115         void start_marker_grab (ArdourCanvas::Item*, GdkEvent*);
1116         void start_control_point_grab (ArdourCanvas::Item*, GdkEvent*);
1117         void start_line_grab_from_regionview (ArdourCanvas::Item*, GdkEvent*);
1118         void start_line_grab_from_line (ArdourCanvas::Item*, GdkEvent*);
1119         void start_line_grab (AutomationLine *, GdkEvent*);
1120         void start_tempo_marker_grab (ArdourCanvas::Item*, GdkEvent*);
1121         void start_tempo_marker_copy_grab (ArdourCanvas::Item*, GdkEvent*);
1122         void start_meter_marker_grab (ArdourCanvas::Item*, GdkEvent*);
1123         void start_meter_marker_copy_grab (ArdourCanvas::Item*, GdkEvent*);
1124
1125         void region_view_item_click (AudioRegionView&, GdkEventButton*);
1126
1127         void remove_gain_control_point (ArdourCanvas::Item*, GdkEvent*);
1128         void remove_control_point (ArdourCanvas::Item*, GdkEvent*);
1129
1130         void mouse_brush_insert_region (AudioRegionView*, jack_nframes_t pos);
1131         void brush (jack_nframes_t);
1132
1133         void show_verbose_time_cursor (jack_nframes_t frame, double offset = 0, double xpos=-1, double ypos=-1);
1134         void show_verbose_duration_cursor (jack_nframes_t start, jack_nframes_t end, double offset = 0, double xpos=-1, double ypos=-1);
1135
1136         /* Canvas event handlers */
1137
1138         bool canvas_control_point_event (GdkEvent* event,ArdourCanvas::Item*, ControlPoint*);
1139         bool canvas_line_event (GdkEvent* event,ArdourCanvas::Item*, AutomationLine*);
1140         bool canvas_selection_rect_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*);
1141         bool canvas_selection_start_trim_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*);
1142         bool canvas_selection_end_trim_event (GdkEvent* event,ArdourCanvas::Item*, SelectionRect*);
1143         bool canvas_crossfade_view_event (GdkEvent* event,ArdourCanvas::Item*, CrossfadeView*);
1144         bool canvas_fade_in_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1145         bool canvas_fade_in_handle_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1146         bool canvas_fade_out_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1147         bool canvas_fade_out_handle_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1148         bool canvas_region_view_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1149         bool canvas_region_view_name_highlight_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1150         bool canvas_region_view_name_event (GdkEvent* event,ArdourCanvas::Item*, AudioRegionView*);
1151         bool canvas_stream_view_event (GdkEvent* event,ArdourCanvas::Item*, AudioTimeAxisView*);
1152         bool canvas_marker_event (GdkEvent* event,ArdourCanvas::Item*, Marker*);
1153         bool canvas_zoom_rect_event (GdkEvent* event,ArdourCanvas::Item*);
1154         bool canvas_tempo_marker_event (GdkEvent* event,ArdourCanvas::Item*, TempoMarker*);
1155         bool canvas_meter_marker_event (GdkEvent* event,ArdourCanvas::Item*, MeterMarker*);
1156         bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, AutomationTimeAxisView*) ;
1157
1158         bool canvas_tempo_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1159         bool canvas_meter_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1160         bool canvas_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1161         bool canvas_range_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1162         bool canvas_transport_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*);
1163
1164         bool canvas_imageframe_item_view_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameView*);
1165         bool canvas_imageframe_view_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameTimeAxis*);
1166         bool canvas_imageframe_start_handle_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameView*);
1167         bool canvas_imageframe_end_handle_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameView*);
1168         bool canvas_marker_time_axis_view_event(GdkEvent* event, ArdourCanvas::Item*,MarkerTimeAxis*);
1169         bool canvas_markerview_item_view_event(GdkEvent* event, ArdourCanvas::Item*,MarkerView*);
1170         bool canvas_markerview_start_handle_event(GdkEvent* event, ArdourCanvas::Item*,MarkerView*);
1171         bool canvas_markerview_end_handle_event(GdkEvent* event, ArdourCanvas::Item*,MarkerView*);
1172
1173         /* non-public event handlers */
1174
1175         bool canvas_playhead_cursor_event (GdkEvent* event, ArdourCanvas::Item*);
1176         bool canvas_edit_cursor_event (GdkEvent* event, ArdourCanvas::Item*);
1177         bool track_canvas_event (GdkEvent* event, ArdourCanvas::Item*);
1178         bool track_canvas_scroll (GdkEventScroll* event);
1179
1180         bool track_canvas_button_press_event (GdkEventButton *);
1181         bool track_canvas_button_release_event (GdkEventButton *);
1182
1183         void track_canvas_allocate (Gtk::Allocation alloc);
1184         void time_canvas_allocate (Gtk::Allocation alloc);
1185
1186         void set_edit_cursor (GdkEvent* event);
1187         void set_playhead_cursor (GdkEvent* event);
1188
1189         void kbd_driver (sigc::slot<void,GdkEvent*>, bool use_track_canvas = true, bool use_time_canvas = true, bool can_select = true);
1190         void kbd_set_playhead_cursor ();
1191         void kbd_set_edit_cursor ();
1192         void kbd_mute_unmute_region ();
1193         void kbd_split ();
1194         void kbd_set_sync_position ();
1195         void kbd_align (ARDOUR::RegionPoint);
1196         void kbd_align_relative (ARDOUR::RegionPoint);
1197         void kbd_brush ();
1198         void kbd_audition ();
1199
1200         void kbd_do_split (GdkEvent*);
1201         void kbd_do_set_sync_position (GdkEvent* ev);
1202         void kbd_do_align (GdkEvent*, ARDOUR::RegionPoint);
1203         void kbd_do_align_relative (GdkEvent*, ARDOUR::RegionPoint);
1204         void kbd_do_brush (GdkEvent*);
1205         void kbd_do_audition (GdkEvent*);
1206
1207         void fake_handle_new_duration ();
1208         void handle_new_duration ();
1209         void initialize_canvas ();
1210         void reset_scrolling_region (Gtk::Allocation* alloc = 0);
1211         void scroll_canvas ();
1212
1213         /* display control */
1214
1215         bool _show_measures;
1216         bool _show_waveforms;
1217         bool _follow_playhead;
1218         bool _show_waveforms_recording;
1219
1220         void add_bbt_marks (ARDOUR::TempoMap::BBTPointList&);
1221
1222         ARDOUR::TempoMap::BBTPointList *current_bbt_points;
1223
1224         typedef vector<ArdourCanvas::SimpleLine*> TimeLineList;
1225         TimeLineList free_measure_lines;
1226         TimeLineList used_measure_lines;
1227
1228         ArdourCanvas::Group* time_line_group;
1229         ArdourCanvas::SimpleLine* get_time_line ();
1230         void hide_measures ();
1231         void draw_measures ();
1232         void draw_time_bars ();
1233
1234         void new_tempo_section ();
1235
1236         void mouse_add_new_tempo_event (jack_nframes_t where);
1237         void mouse_add_new_meter_event (jack_nframes_t where);
1238
1239         void remove_tempo_marker (ArdourCanvas::Item*);
1240         void remove_meter_marker (ArdourCanvas::Item*);
1241         gint real_remove_tempo_marker (ARDOUR::TempoSection*);
1242         gint real_remove_meter_marker (ARDOUR::MeterSection*);
1243
1244         void edit_tempo_section (ARDOUR::TempoSection*);
1245         void edit_meter_section (ARDOUR::MeterSection*);
1246         void edit_tempo_marker (ArdourCanvas::Item*);
1247         void edit_meter_marker (ArdourCanvas::Item*);
1248
1249         void marker_menu_edit ();
1250         void marker_menu_remove ();
1251         void marker_menu_rename ();
1252         void marker_menu_hide ();
1253         void marker_menu_loop_range ();
1254         void marker_menu_select_all_selectables_using_range ();
1255         void marker_menu_play_from ();
1256         void marker_menu_set_playhead ();
1257         void marker_menu_set_from_playhead ();
1258         void marker_menu_set_from_selection ();
1259         void new_transport_marker_menu_set_loop ();
1260         void new_transport_marker_menu_set_punch ();
1261         void update_loop_range_view (bool visibility=false);
1262         void update_punch_range_view (bool visibility=false);
1263         gint new_transport_marker_menu_popdown (GdkEventAny*);
1264         void marker_context_menu (GdkEventButton*, ArdourCanvas::Item*);
1265         void tm_marker_context_menu (GdkEventButton*, ArdourCanvas::Item*);
1266         void transport_marker_context_menu (GdkEventButton*, ArdourCanvas::Item*);
1267         void new_transport_marker_context_menu (GdkEventButton*, ArdourCanvas::Item*);
1268         void build_range_marker_menu ();
1269         void build_marker_menu ();
1270         void build_tm_marker_menu ();
1271         void build_transport_marker_menu ();
1272         void build_new_transport_marker_menu ();
1273
1274         Gtk::Menu* tm_marker_menu;
1275         Gtk::Menu* marker_menu;
1276         Gtk::Menu* transport_marker_menu;
1277         Gtk::Menu* new_transport_marker_menu;
1278         ArdourCanvas::Item* marker_menu_item;
1279
1280         typedef list<Marker*> Marks;
1281         Marks metric_marks;
1282
1283         void remove_metric_marks ();
1284         void draw_metric_marks (const ARDOUR::Metrics& metrics);
1285
1286         void tempo_map_changed (ARDOUR::Change);
1287         void redisplay_tempo ();
1288
1289         void snap_to (jack_nframes_t& first, int32_t direction = 0, bool for_mark = false);
1290         uint32_t bbt_beat_subdivision;
1291
1292         /* toolbar */
1293
1294         Gtk::ToggleButton        editor_mixer_button;
1295
1296         void editor_mixer_button_toggled ();
1297
1298         AudioClock               selection_start_clock;
1299         Gtk::Label               selection_start_clock_label;
1300         AudioClock               selection_end_clock;
1301         Gtk::Label               selection_end_clock_label;
1302         AudioClock               edit_cursor_clock;
1303         Gtk::Label               edit_cursor_clock_label;
1304         AudioClock               zoom_range_clock;
1305         Gtk::Button              zoom_in_button;
1306         Gtk::Button              zoom_out_button;
1307         Gtk::Button              zoom_out_full_button;
1308         Gtk::Button              zoom_onetoone_button;
1309
1310         Gtk::VBox                toolbar_clock_vbox;
1311         Gtk::VBox                toolbar_selection_clock_vbox;
1312         Gtk::Table               toolbar_selection_clock_table;
1313         Gtk::Label               toolbar_selection_cursor_label;
1314
1315         Gtk::Table               mouse_mode_button_table;
1316         Gtkmm2ext::TearOff*       mouse_mode_tearoff;
1317         Gtk::ToggleButton        mouse_select_button;
1318         Gtk::ToggleButton        mouse_move_button;
1319         Gtk::ToggleButton        mouse_gain_button;
1320         Gtk::ToggleButton        mouse_zoom_button;
1321         Gtk::ToggleButton        mouse_timefx_button;
1322         Gtk::ToggleButton        mouse_audition_button;
1323         GroupedButtons          *mouse_mode_button_set;
1324         void                     mouse_mode_toggled (Editing::MouseMode m);
1325         bool                     ignore_mouse_mode_toggle;
1326
1327         gint                     mouse_select_button_release (GdkEventButton*);
1328
1329         Gtk::VBox                automation_box;
1330         Gtk::Button              automation_mode_button;
1331         Gtk::ToggleButton        global_automation_button;
1332
1333         Gtk::ComboBoxText edit_mode_selector;
1334         Gtk::Label               edit_mode_label;
1335         Gtk::VBox                edit_mode_box;
1336
1337         void edit_mode_selection_done ();
1338
1339         Gtk::ComboBoxText snap_type_selector;
1340         Gtk::Label               snap_type_label;
1341         Gtk::VBox                snap_type_box;
1342
1343         void snap_type_selection_done ();
1344
1345         Gtk::ComboBoxText               snap_mode_selector;
1346         Gtk::Label               snap_mode_label;
1347         Gtk::VBox                snap_mode_box;
1348
1349         void snap_mode_selection_done ();
1350
1351         Gtk::ComboBoxText zoom_focus_selector;
1352         Gtk::Label               zoom_focus_label;
1353         Gtk::VBox                zoom_focus_box;
1354
1355         void zoom_focus_selection_done ();
1356
1357         Gtk::Label          zoom_indicator_label;
1358         Gtk::HBox           zoom_indicator_box;
1359         Gtk::VBox           zoom_indicator_vbox;
1360
1361         void                update_zoom_indicator ();
1362         void                zoom_adjustment_changed();
1363
1364         void                edit_cursor_clock_changed();
1365
1366         void setup_toolbar ();
1367
1368         Gtkmm2ext::TearOff*       tools_tearoff;
1369         Gtk::HBox                toolbar_hbox;
1370         Gtk::EventBox            toolbar_base;
1371         Gtk::Frame               toolbar_frame;
1372
1373         /* selection process */
1374
1375         Selection* selection;
1376         Selection* cut_buffer;
1377
1378         void time_selection_changed ();
1379         void track_selection_changed ();
1380         void region_selection_changed ();
1381         void point_selection_changed ();
1382         void audio_track_selection_changed ();
1383         void line_selection_changed ();
1384
1385         enum SelectionOp {
1386                 CreateSelection,
1387                 SelectionStartTrim,
1388                 SelectionEndTrim,
1389                 SelectionMove
1390         } selection_op;
1391
1392         void start_selection_op (ArdourCanvas::Item* item, GdkEvent* event, SelectionOp);
1393         void drag_selection (ArdourCanvas::Item* item, GdkEvent* event);
1394         void end_selection_op (ArdourCanvas::Item* item, GdkEvent* event);
1395         void cancel_selection ();
1396
1397         void region_selection_op (void (ARDOUR::Region::*pmf)(void));
1398         void region_selection_op (void (ARDOUR::Region::*pmf)(void*), void*);
1399         void region_selection_op (void (ARDOUR::Region::*pmf)(bool), bool);
1400
1401         bool audio_region_selection_covers (jack_nframes_t where);
1402
1403         /* transport range select process */
1404         enum RangeMarkerOp {
1405                 CreateRangeMarker,
1406                 CreateTransportMarker
1407         } range_marker_op;
1408
1409         void start_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event, RangeMarkerOp);
1410         void drag_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event);
1411         void end_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event);
1412
1413         ArdourCanvas::SimpleRect*  range_bar_drag_rect;
1414         ArdourCanvas::SimpleRect*  transport_bar_drag_rect;
1415         ArdourCanvas::Line*        marker_drag_line;
1416         ArdourCanvas::Points       marker_drag_line_points;
1417         ArdourCanvas::SimpleRect*  range_marker_drag_rect;
1418
1419         void update_marker_drag_item (ARDOUR::Location *);
1420
1421         ArdourCanvas::SimpleRect     *transport_bar_range_rect;
1422         ArdourCanvas::SimpleRect     *transport_bar_preroll_rect;
1423         ArdourCanvas::SimpleRect     *transport_bar_postroll_rect;
1424         ArdourCanvas::SimpleRect     *transport_loop_range_rect;
1425         ArdourCanvas::SimpleRect     *transport_punch_range_rect;
1426         ArdourCanvas::SimpleLine     *transport_punchin_line;
1427         ArdourCanvas::SimpleLine     *transport_punchout_line;
1428         ArdourCanvas::SimpleRect     *transport_preroll_rect;
1429         ArdourCanvas::SimpleRect     *transport_postroll_rect;
1430
1431         ARDOUR::Location*  transport_loop_location();
1432         ARDOUR::Location*  transport_punch_location();
1433
1434         ARDOUR::Location   *temp_location;
1435
1436         /* object rubberband select process */
1437
1438         void start_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event);
1439         void drag_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event);
1440         void end_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event);
1441
1442         bool select_all_within (jack_nframes_t start, jack_nframes_t end, gdouble topy, gdouble boty, Selection::Operation op);
1443
1444         ArdourCanvas::SimpleRect   *rubberband_rect;
1445
1446         /* mouse zoom process */
1447
1448         void start_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event);
1449         void drag_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event);
1450         void end_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event);
1451
1452         ArdourCanvas::SimpleRect   *zoom_rect;
1453         void reposition_zoom_rect (jack_nframes_t start, jack_nframes_t end);
1454
1455         /* diskstream/route display management */
1456
1457         struct RouteDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
1458             RouteDisplayModelColumns() {
1459                     add (text);
1460                     add (visible);
1461                     add (tv);
1462             }
1463             Gtk::TreeModelColumn<Glib::ustring>  text;
1464             Gtk::TreeModelColumn<bool>           visible;
1465             Gtk::TreeModelColumn<TimeAxisView*>  tv;
1466         };
1467
1468         RouteDisplayModelColumns         route_display_columns;
1469         Glib::RefPtr<Gtk::ListStore>     route_display_model;
1470         Glib::RefPtr<Gtk::TreeSelection> route_display_selection;
1471
1472         gint route_list_compare_func (Gtk::TreeModel::iterator, Gtk::TreeModel::iterator);
1473         Gtkmm2ext::DnDTreeView   route_list_display;
1474         Gtk::ScrolledWindow      route_list_scroller;
1475         Gtk::Menu*               route_list_menu;
1476
1477         bool route_list_display_button_press (GdkEventButton*);
1478         bool route_list_selection_filter (const Glib::RefPtr<Gtk::TreeModel>& model, const Gtk::TreeModel::Path& path, bool yn);
1479
1480         void route_list_change (const Gtk::TreeModel::Path&,const Gtk::TreeModel::iterator&);
1481         void route_list_delete (const Gtk::TreeModel::Path&);
1482         void initial_route_list_display ();
1483         void redisplay_route_list();
1484         void route_list_reordered (const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter, int* what);
1485         bool ignore_route_list_reorder;
1486         bool no_route_list_redisplay;
1487         void queue_route_list_reordered ();
1488
1489         void build_route_list_menu ();
1490         void show_route_list_menu ();
1491
1492         void show_all_routes ();
1493         void hide_all_routes ();
1494         void show_all_audiotracks ();
1495         void hide_all_audiotracks ();
1496         void show_all_audiobus ();
1497         void hide_all_audiobus ();
1498
1499         void set_all_tracks_visibility (bool yn);
1500         void set_all_audio_visibility (int type, bool yn);
1501
1502         /* edit group management */
1503
1504         struct GroupListModelColumns : public Gtk::TreeModel::ColumnRecord {
1505                 GroupListModelColumns () {
1506                        add (is_active);
1507                        add (is_visible);
1508                        add (text);
1509                        add (routegroup);
1510                 }
1511                 Gtk::TreeModelColumn<bool> is_active;
1512                 Gtk::TreeModelColumn<bool> is_visible;
1513                 Gtk::TreeModelColumn<std::string> text;
1514                 Gtk::TreeModelColumn<ARDOUR::RouteGroup*>   routegroup;
1515         };
1516
1517         GroupListModelColumns group_columns;
1518         Glib::RefPtr<Gtk::ListStore> group_model;
1519         Glib::RefPtr<Gtk::TreeSelection> group_selection;
1520
1521         Gtk::TreeView          edit_group_display;
1522         Gtk::ScrolledWindow    edit_group_display_scroller;
1523         Gtk::Menu*             edit_group_list_menu;
1524
1525         void build_edit_group_list_menu ();
1526         void activate_all_edit_groups ();
1527         void disable_all_edit_groups ();
1528
1529         bool in_edit_group_row_change;
1530         void edit_group_row_change (const Gtk::TreeModel::Path&,const Gtk::TreeModel::iterator&);
1531         void edit_group_name_edit (const Glib::ustring&, const Glib::ustring&);
1532         void new_edit_group ();
1533         void edit_group_list_button_clicked ();
1534         gint edit_group_list_button_press_event (GdkEventButton* ev);
1535         void edit_group_selection_changed ();
1536         void fake_add_edit_group (ARDOUR::RouteGroup* group);
1537         void fake_remove_edit_group (ARDOUR::RouteGroup* group);
1538         void add_edit_group (ARDOUR::RouteGroup* group);
1539         void remove_selected_edit_group ();
1540         void edit_groups_changed ();
1541         void group_flags_changed (void*, ARDOUR::RouteGroup*);
1542
1543         Gtk::VBox           list_vpacker;
1544
1545         /* autoscrolling */
1546
1547         int autoscroll_timeout_tag;
1548         int autoscroll_direction;
1549         uint32_t autoscroll_cnt;
1550         jack_nframes_t autoscroll_distance;
1551
1552         static gint _autoscroll_canvas (void *);
1553         gint autoscroll_canvas ();
1554         void start_canvas_autoscroll (int direction);
1555         void stop_canvas_autoscroll ();
1556         void maybe_autoscroll (GdkEvent*);
1557
1558         /* trimming */
1559         enum TrimOp {
1560                 StartTrim,
1561                 EndTrim,
1562                 ContentsTrim,
1563         } trim_op;
1564
1565         void start_trim (ArdourCanvas::Item*, GdkEvent*);
1566         void point_trim (GdkEvent*);
1567         void trim_motion_callback (ArdourCanvas::Item*, GdkEvent*);
1568         void single_contents_trim (AudioRegionView&, jack_nframes_t, bool, bool, bool);
1569         void single_start_trim (AudioRegionView&, jack_nframes_t, bool, bool);
1570         void single_end_trim (AudioRegionView&, jack_nframes_t, bool, bool);
1571
1572         void trim_finished_callback (ArdourCanvas::Item*, GdkEvent*);
1573         void thaw_region_after_trim (AudioRegionView& rv);
1574
1575         void trim_region_to_edit_cursor ();
1576         void trim_region_from_edit_cursor ();
1577
1578         bool show_gain_after_trim;
1579
1580         /* Drag-n-Drop */
1581
1582         int convert_drop_to_paths (std::vector<std::string>& paths,
1583                                    const Glib::RefPtr<Gdk::DragContext>& context,
1584                                    gint                x,
1585                                    gint                y,
1586                                    const Gtk::SelectionData& data,
1587                                    guint               info,
1588                                    guint               time);
1589
1590         void  track_canvas_drag_data_received  (const Glib::RefPtr<Gdk::DragContext>& context,
1591                                                 gint                x,
1592                                                 gint                y,
1593                                                 const Gtk::SelectionData& data,
1594                                                 guint               info,
1595                                                 guint               time);
1596
1597         void  region_list_display_drag_data_received  (const Glib::RefPtr<Gdk::DragContext>& context,
1598                                                        gint                x,
1599                                                        gint                y,
1600                                                        const Gtk::SelectionData& data,
1601                                                        guint               info,
1602                                                        guint               time);
1603
1604
1605         void  drop_paths  (const Glib::RefPtr<Gdk::DragContext>& context,
1606                            gint                x,
1607                            gint                y,
1608                            const Gtk::SelectionData& data,
1609                            guint               info,
1610                            guint               time);
1611
1612         void  drop_regions  (const Glib::RefPtr<Gdk::DragContext>& context,
1613                              gint                x,
1614                              gint                y,
1615                              const Gtk::SelectionData& data,
1616                              guint               info,
1617                              guint               time);
1618
1619         /* audio export */
1620
1621         ExportDialog *export_dialog;
1622         ExportDialog *export_range_markers_dialog;
1623
1624         void export_range (jack_nframes_t start, jack_nframes_t end);
1625         void export_range_markers ();
1626
1627         int  write_region_selection(AudioRegionSelection&);
1628         bool write_region (string path, ARDOUR::AudioRegion&);
1629         void export_region ();
1630         void bounce_region_selection ();
1631         void bounce_range_selection ();
1632         void external_edit_region ();
1633
1634         int write_audio_selection (TimeSelection&);
1635         bool write_audio_range (ARDOUR::Playlist&, uint32_t channels, list<ARDOUR::AudioRange>&);
1636
1637         void write_selection ();
1638
1639         /* history */
1640
1641         UndoAction get_memento() const;
1642
1643         void begin_reversible_command (string cmd_name);
1644         void commit_reversible_command ();
1645
1646         /* visual history */
1647
1648         UndoHistory visual_history;
1649         UndoCommand current_visual_command;
1650
1651         void begin_reversible_visual_command (const string & cmd_name);
1652         void commit_reversible_visual_command ();
1653
1654         void update_title ();
1655         void update_title_s (const string & snapshot_name);
1656
1657         struct State {
1658             Selection* selection;
1659             double     frames_per_unit;
1660
1661             State();
1662             ~State();
1663         };
1664
1665         void store_state (State&) const;
1666         void restore_state (State *);
1667
1668         void instant_save ();
1669
1670         ARDOUR::AudioRegion* last_audition_region;
1671
1672         /* freeze operations */
1673
1674         ARDOUR::InterThreadInfo freeze_status;
1675         gint freeze_progress_timeout (void *);
1676         static void* _freeze_thread (void*);
1677         void* freeze_thread ();
1678
1679         void freeze_route ();
1680         void unfreeze_route ();
1681
1682         /* edit-group solo + mute */
1683
1684         void set_edit_group_solo (ARDOUR::Route&, bool);
1685         void set_edit_group_mute (ARDOUR::Route&, bool);
1686
1687         /* duplication */
1688
1689         void duplicate_dialog (bool for_region);
1690
1691         /* edit menu */
1692
1693         Gtk::Menu* edit_menu;
1694         bool edit_menu_map_handler (GdkEventAny*);
1695
1696         jack_nframes_t event_frame (GdkEvent*, double* px = 0, double* py = 0);
1697
1698         void time_fx_motion (ArdourCanvas::Item*, GdkEvent*);
1699         void start_time_fx (ArdourCanvas::Item*, GdkEvent*);
1700         void end_time_fx (ArdourCanvas::Item*, GdkEvent*);
1701
1702         struct TimeStretchDialog : public ArdourDialog {
1703             ARDOUR::Session::TimeStretchRequest request;
1704             Editor&               editor;
1705             AudioRegionSelection  regions;
1706             Gtk::ProgressBar      progress_bar;
1707             Gtk::ToggleButton     quick_button;
1708             Gtk::ToggleButton     antialias_button;
1709             Gtk::Button           cancel_button;
1710             Gtk::Button           action_button;
1711             Gtk::HBox             lower_button_box;
1712             Gtk::HBox             upper_button_box;
1713             Gtk::VBox             packer;
1714             int                   status;
1715
1716             TimeStretchDialog (Editor& e);
1717
1718             gint update_progress ();
1719             sigc::connection first_cancel;
1720             sigc::connection first_delete;
1721             void cancel_timestretch_in_progress ();
1722             gint delete_timestretch_in_progress (GdkEventAny*);
1723         };
1724
1725         /* "whats mine is yours" */
1726
1727         friend class TimeStretchDialog;
1728
1729         TimeStretchDialog* current_timestretch;
1730
1731         static void* timestretch_thread (void *arg);
1732         int run_timestretch (AudioRegionSelection&, float fraction);
1733         void do_timestretch (TimeStretchDialog&);
1734
1735         /* editor-mixer strip */
1736
1737         MixerStrip *current_mixer_strip;
1738         Gtk::VBox current_mixer_strip_vbox;
1739         void cms_deleted ();
1740         void current_mixer_strip_hidden ();
1741         void current_mixer_strip_removed ();
1742
1743         void detach_tearoff (Gtk::Box* b, Gtk::Window* w);
1744         void reattach_tearoff (Gtk::Box* b, Gtk::Window* w, int32_t n);
1745
1746         /* nudging tracks */
1747
1748         void nudge_track (bool use_edit_cursor, bool forwards);
1749
1750         /* xfades */
1751
1752         bool _xfade_visibility;
1753
1754         /* <CMT Additions> */
1755         void handle_new_imageframe_time_axis_view(const string & track_name, void* src) ;
1756         void handle_new_imageframe_marker_time_axis_view(const string & track_name, TimeAxisView* marked_track) ;
1757
1758         void start_imageframe_grab(ArdourCanvas::Item*, GdkEvent*) ;
1759         void start_markerview_grab(ArdourCanvas::Item*, GdkEvent*) ;
1760
1761         void imageframe_drag_motion_callback(ArdourCanvas::Item*, GdkEvent*) ;
1762         void markerview_drag_motion_callback(ArdourCanvas::Item*, GdkEvent*) ;
1763         void timeaxis_item_drag_finished_callback(ArdourCanvas::Item*, GdkEvent*) ;
1764
1765         gint canvas_imageframe_item_view_event(ArdourCanvas::Item* item, GdkEvent* event, ImageFrameView* ifv);
1766         gint canvas_imageframe_view_event(ArdourCanvas::Item* item, GdkEvent* event, ImageFrameTimeAxis* ifta);
1767         gint canvas_imageframe_start_handle_event(ArdourCanvas::Item* item, GdkEvent* event, ImageFrameView* ifv);
1768         gint canvas_imageframe_end_handle_event(ArdourCanvas::Item* item, GdkEvent* event, ImageFrameView* ifv);
1769
1770         gint canvas_marker_time_axis_view_event(ArdourCanvas::Item* item, GdkEvent* event, MarkerTimeAxis* mta);
1771         gint canvas_markerview_item_view_event(ArdourCanvas::Item* item, GdkEvent* event, MarkerView* mv);
1772         gint canvas_markerview_start_handle_event(ArdourCanvas::Item* item, GdkEvent* event, MarkerView* mv);
1773         gint canvas_markerview_end_handle_event(ArdourCanvas::Item* item, GdkEvent* event, MarkerView* mv);
1774
1775         void imageframe_start_handle_op(ArdourCanvas::Item* item, GdkEvent* event) ;
1776         void imageframe_end_handle_op(ArdourCanvas::Item* item, GdkEvent* event) ;
1777         void imageframe_start_handle_trim_motion(ArdourCanvas::Item* item, GdkEvent* event) ;
1778         void imageframe_start_handle_end_trim(ArdourCanvas::Item* item, GdkEvent* event) ;
1779         void imageframe_end_handle_trim_motion(ArdourCanvas::Item* item, GdkEvent* event) ;
1780         void imageframe_end_handle_end_trim(ArdourCanvas::Item* item, GdkEvent* event) ;
1781
1782         void markerview_item_start_handle_op(ArdourCanvas::Item* item, GdkEvent* event) ;
1783         void markerview_item_end_handle_op(ArdourCanvas::Item* item, GdkEvent* event) ;
1784         void markerview_start_handle_trim_motion(ArdourCanvas::Item* item, GdkEvent* event) ;
1785         void markerview_start_handle_end_trim(ArdourCanvas::Item* item, GdkEvent* event) ;
1786         void markerview_end_handle_trim_motion(ArdourCanvas::Item* item, GdkEvent* event) ;
1787         void markerview_end_handle_end_trim(ArdourCanvas::Item* item, GdkEvent* event) ;
1788
1789         void popup_imageframe_edit_menu(int button, int32_t time, ArdourCanvas::Item* ifv, bool with_frame) ;
1790         void popup_marker_time_axis_edit_menu(int button, int32_t time, ArdourCanvas::Item* ifv, bool with_frame) ;
1791
1792         ImageFrameSocketHandler* image_socket_listener ;
1793         /* </CMT Additions> */
1794
1795         void toggle_xfade_active (ARDOUR::Crossfade*);
1796         void toggle_xfade_length (ARDOUR::Crossfade*);
1797         void edit_xfade (ARDOUR::Crossfade*);
1798         void remove_xfade ();
1799         void xfade_edit_left_region ();
1800         void xfade_edit_right_region ();
1801
1802         static const int32_t default_width = 995;
1803         static const int32_t default_height = 765;
1804
1805         /* nudge */
1806
1807         Gtk::Button      nudge_forward_button;
1808         Gtk::Button      nudge_backward_button;
1809         Gtk::HBox        nudge_hbox;
1810         Gtk::VBox        nudge_vbox;
1811         Gtk::Label       nudge_label;
1812         AudioClock       nudge_clock;
1813
1814         jack_nframes_t get_nudge_distance (jack_nframes_t pos, jack_nframes_t& next);
1815
1816         /* audio filters */
1817
1818         void apply_filter (ARDOUR::AudioFilter&, string cmd);
1819
1820         /* handling cleanup */
1821
1822         int playlist_deletion_dialog (ARDOUR::Playlist*);
1823
1824         vector<sigc::connection> session_connections;
1825
1826         /* tracking step changes of track height */
1827
1828         TimeAxisView* current_stepping_trackview;
1829         struct timeval last_track_height_step_timestamp;
1830         gint track_height_step_timeout();
1831         sigc::connection step_timeout;
1832
1833         TimeAxisView* entered_track;
1834         AudioRegionView* entered_regionview;
1835         bool clear_entered_track;
1836         gint left_track_canvas (GdkEventCrossing*);
1837         void set_entered_track (TimeAxisView*);
1838         void set_entered_regionview (AudioRegionView*);
1839         gint left_automation_track ();
1840
1841         bool _new_regionviews_show_envelope;
1842
1843         void toggle_gain_envelope_visibility ();
1844         void toggle_gain_envelope_active ();
1845
1846         bool on_key_press_event (GdkEventKey*);
1847
1848         void session_state_saved (string);
1849 };
1850
1851 #endif /* __ardour_editor_h__ */