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