gtk2_ardour/editor.cc

   1 /*
   2     Copyright (C) 2000-2009 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 /* Note: public Editor methods are documented in public_editor.h */
  21
  22 #include <stdint.h>
  23 #include <unistd.h>
  24 #include <cstdlib>
  25 #include <cmath>
  26 #include <string>
  27 #include <algorithm>
  28 #include <map>
  29
  30 #include "ardour_ui.h"
  31 /*
  32  * ardour_ui.h include was moved to the top of the list
  33  * due to a conflicting definition of 'Style' between
  34  * Apple's MacTypes.h and BarController.
  35  */
  36
  37 #include <boost/none.hpp>
  38
  39 #include <sigc++/bind.h>
  40
  41 #include "pbd/convert.h"
  42 #include "pbd/error.h"
  43 #include "pbd/enumwriter.h"
  44 #include "pbd/memento_command.h"
  45 #include "pbd/unknown_type.h"
  46 #include "pbd/unwind.h"
  47 #include "pbd/stacktrace.h"
  48 #include "pbd/timersub.h"
  49
  50 #include <glibmm/miscutils.h>
  51 #include <glibmm/uriutils.h>
  52 #include <gtkmm/image.h>
  53 #include <gdkmm/color.h>
  54 #include <gdkmm/bitmap.h>
  55
  56 #include <gtkmm/menu.h>
  57 #include <gtkmm/menuitem.h>
  58
  59 #include "gtkmm2ext/bindings.h"
  60 #include "gtkmm2ext/gtk_ui.h"
  61 #include "gtkmm2ext/keyboard.h"
  62 #include "gtkmm2ext/utils.h"
  63 #include "gtkmm2ext/window_title.h"
  64 #include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
  65
  66 #include "ardour/analysis_graph.h"
  67 #include "ardour/audio_track.h"
  68 #include "ardour/audioengine.h"
  69 #include "ardour/audioregion.h"
  70 #include "ardour/lmath.h"
  71 #include "ardour/location.h"
  72 #include "ardour/profile.h"
  73 #include "ardour/route.h"
  74 #include "ardour/route_group.h"
  75 #include "ardour/session_playlists.h"
  76 #include "ardour/tempo.h"
  77 #include "ardour/utils.h"
  78 #include "ardour/vca_manager.h"
  79 #include "ardour/vca.h"
  80
  81 #include "canvas/debug.h"
  82 #include "canvas/text.h"
  83
  84 #include "widgets/ardour_spacer.h"
  85 #include "widgets/eventboxext.h"
  86 #include "widgets/tooltips.h"
  87
  88 #include "control_protocol/control_protocol.h"
  89
  90 #include "actions.h"
  91 #include "analysis_window.h"
  92 #include "audio_clock.h"
  93 #include "audio_region_view.h"
  94 #include "audio_streamview.h"
  95 #include "audio_time_axis.h"
  96 #include "automation_time_axis.h"
  97 #include "bundle_manager.h"
  98 #include "crossfade_edit.h"
  99 #include "debug.h"
 100 #include "editing.h"
 101 #include "editing_convert.h"
 102 #include "editor.h"
 103 #include "editor_cursors.h"
 104 #include "editor_drag.h"
 105 #include "editor_group_tabs.h"
 106 #include "editor_locations.h"
 107 #include "editor_regions.h"
 108 #include "editor_route_groups.h"
 109 #include "editor_routes.h"
 110 #include "editor_snapshots.h"
 111 #include "editor_summary.h"
 112 #include "enums_convert.h"
 113 #include "export_report.h"
 114 #include "global_port_matrix.h"
 115 #include "gui_object.h"
 116 #include "gui_thread.h"
 117 #include "keyboard.h"
 118 #include "luainstance.h"
 119 #include "marker.h"
 120 #include "midi_region_view.h"
 121 #include "midi_time_axis.h"
 122 #include "mixer_strip.h"
 123 #include "mixer_ui.h"
 124 #include "mouse_cursors.h"
 125 #include "note_base.h"
 126 #include "playlist_selector.h"
 127 #include "public_editor.h"
 128 #include "quantize_dialog.h"
 129 #include "region_layering_order_editor.h"
 130 #include "rgb_macros.h"
 131 #include "rhythm_ferret.h"
 132 #include "route_sorter.h"
 133 #include "selection.h"
 134 #include "simple_progress_dialog.h"
 135 #include "sfdb_ui.h"
 136 #include "tempo_lines.h"
 137 #include "time_axis_view.h"
 138 #include "time_info_box.h"
 139 #include "timers.h"
 140 #include "ui_config.h"
 141 #include "utils.h"
 142 #include "vca_time_axis.h"
 143 #include "verbose_cursor.h"
 144
 145 #include "pbd/i18n.h"
 146
 147 using namespace std;
 148 using namespace ARDOUR;
 149 using namespace ArdourWidgets;
 150 using namespace ARDOUR_UI_UTILS;
 151 using namespace PBD;
 152 using namespace Gtk;
 153 using namespace Glib;
 154 using namespace Gtkmm2ext;
 155 using namespace Editing;
 156
 157 using PBD::internationalize;
 158 using PBD::atoi;
 159 using Gtkmm2ext::Keyboard;
 160
 161 double Editor::timebar_height = 15.0;
 162
 163 static const gchar *_snap_type_strings[] = {
 164         N_("CD Frames"),
 165         N_("TC Frames"),
 166         N_("TC Seconds"),
 167         N_("TC Minutes"),
 168         N_("Seconds"),
 169         N_("Minutes"),
 170         N_("Beats/128"),
 171         N_("Beats/64"),
 172         N_("Beats/32"),
 173         N_("Beats/28"),
 174         N_("Beats/24"),
 175         N_("Beats/20"),
 176         N_("Beats/16"),
 177         N_("Beats/14"),
 178         N_("Beats/12"),
 179         N_("Beats/10"),
 180         N_("Beats/8"),
 181         N_("Beats/7"),
 182         N_("Beats/6"),
 183         N_("Beats/5"),
 184         N_("Beats/4"),
 185         N_("Beats/3"),
 186         N_("Beats/2"),
 187         N_("Beats"),
 188         N_("Bars"),
 189         N_("Marks"),
 190         N_("Region starts"),
 191         N_("Region ends"),
 192         N_("Region syncs"),
 193         N_("Region bounds"),
 194         0
 195 };
 196
 197 static const gchar *_snap_mode_strings[] = {
 198         N_("No Grid"),
 199         N_("Grid"),
 200         N_("Magnetic"),
 201         0
 202 };
 203
 204 static const gchar *_edit_point_strings[] = {
 205         N_("Playhead"),
 206         N_("Marker"),
 207         N_("Mouse"),
 208         0
 209 };
 210
 211 static const gchar *_edit_mode_strings[] = {
 212         N_("Slide"),
 213         N_("Splice"),
 214         N_("Ripple"),
 215         N_("Lock"),
 216         0
 217 };
 218
 219 static const gchar *_zoom_focus_strings[] = {
 220         N_("Left"),
 221         N_("Right"),
 222         N_("Center"),
 223         N_("Playhead"),
 224         N_("Mouse"),
 225         N_("Edit point"),
 226         0
 227 };
 228
 229 #ifdef USE_RUBBERBAND
 230 static const gchar *_rb_opt_strings[] = {
 231         N_("Mushy"),
 232         N_("Smooth"),
 233         N_("Balanced multitimbral mixture"),
 234         N_("Unpitched percussion with stable notes"),
 235         N_("Crisp monophonic instrumental"),
 236         N_("Unpitched solo percussion"),
 237         N_("Resample without preserving pitch"),
 238         0
 239 };
 240 #endif
 241
 242 #define COMBO_TRIANGLE_WIDTH 25 // ArdourButton _diameter (11) + 2 * arrow-padding (2*2) + 2 * text-padding (2*5)
 243
 244 Editor::Editor ()
 245         : PublicEditor (global_hpacker)
 246         , editor_mixer_strip_width (Wide)
 247         , constructed (false)
 248         , _playlist_selector (0)
 249         , _time_info_box (0)
 250         , no_save_visual (false)
 251         , leftmost_frame (0)
 252         , samples_per_pixel (2048)
 253         , zoom_focus (ZoomFocusPlayhead)
 254         , mouse_mode (MouseObject)
 255         , pre_internal_snap_type (SnapToBeat)
 256         , pre_internal_snap_mode (SnapOff)
 257         , internal_snap_type (SnapToBeat)
 258         , internal_snap_mode (SnapOff)
 259         , _join_object_range_state (JOIN_OBJECT_RANGE_NONE)
 260         , _notebook_shrunk (false)
 261         , location_marker_color (0)
 262         , location_range_color (0)
 263         , location_loop_color (0)
 264         , location_punch_color (0)
 265         , location_cd_marker_color (0)
 266         , entered_marker (0)
 267         , _show_marker_lines (false)
 268         , clicked_axisview (0)
 269         , clicked_routeview (0)
 270         , clicked_regionview (0)
 271         , clicked_selection (0)
 272         , clicked_control_point (0)
 273         , button_release_can_deselect (true)
 274         , _mouse_changed_selection (false)
 275         , region_edit_menu_split_item (0)
 276         , region_edit_menu_split_multichannel_item (0)
 277         , track_region_edit_playlist_menu (0)
 278         , track_edit_playlist_submenu (0)
 279         , track_selection_edit_playlist_submenu (0)
 280         , _popup_region_menu_item (0)
 281         , _track_canvas (0)
 282         , _track_canvas_viewport (0)
 283         , within_track_canvas (false)
 284         , _verbose_cursor (0)
 285         , tempo_group (0)
 286         , meter_group (0)
 287         , marker_group (0)
 288         , range_marker_group (0)
 289         , transport_marker_group (0)
 290         , cd_marker_group (0)
 291         , _time_markers_group (0)
 292         , hv_scroll_group (0)
 293         , h_scroll_group (0)
 294         , cursor_scroll_group (0)
 295         , no_scroll_group (0)
 296         , _trackview_group (0)
 297         , _drag_motion_group (0)
 298         , _canvas_drop_zone (0)
 299         , no_ruler_shown_update (false)
 300         ,  ruler_grabbed_widget (0)
 301         , ruler_dialog (0)
 302         , minsec_mark_interval (0)
 303         , minsec_mark_modulo (0)
 304         , minsec_nmarks (0)
 305         , timecode_ruler_scale (timecode_show_many_hours)
 306         , timecode_mark_modulo (0)
 307         , timecode_nmarks (0)
 308         , _samples_ruler_interval (0)
 309         , bbt_ruler_scale (bbt_show_many)
 310         , bbt_bars (0)
 311         , bbt_nmarks (0)
 312         , bbt_bar_helper_on (0)
 313         , bbt_accent_modulo (0)
 314         , timecode_ruler (0)
 315         , bbt_ruler (0)
 316         , samples_ruler (0)
 317         , minsec_ruler (0)
 318         , visible_timebars (0)
 319         , editor_ruler_menu (0)
 320         , tempo_bar (0)
 321         , meter_bar (0)
 322         , marker_bar (0)
 323         , range_marker_bar (0)
 324         , transport_marker_bar (0)
 325         , cd_marker_bar (0)
 326         , minsec_label (_("Mins:Secs"))
 327         , bbt_label (_("Bars:Beats"))
 328         , timecode_label (_("Timecode"))
 329         , samples_label (_("Samples"))
 330         , tempo_label (_("Tempo"))
 331         , meter_label (_("Meter"))
 332         , mark_label (_("Location Markers"))
 333         , range_mark_label (_("Range Markers"))
 334         , transport_mark_label (_("Loop/Punch Ranges"))
 335         , cd_mark_label (_("CD Markers"))
 336         , videotl_label (_("Video Timeline"))
 337         , videotl_group (0)
 338         , playhead_cursor (0)
 339         , edit_packer (4, 4, true)
 340         , vertical_adjustment (0.0, 0.0, 10.0, 400.0)
 341         , horizontal_adjustment (0.0, 0.0, 1e16)
 342         , unused_adjustment (0.0, 0.0, 10.0, 400.0)
 343         , controls_layout (unused_adjustment, vertical_adjustment)
 344         , _scroll_callbacks (0)
 345         , _visible_canvas_width (0)
 346         , _visible_canvas_height (0)
 347         , _full_canvas_height (0)
 348         , edit_controls_left_menu (0)
 349         , edit_controls_right_menu (0)
 350         , visual_change_queued(false)
 351         , _last_update_time (0)
 352         , _err_screen_engine (0)
 353         , cut_buffer_start (0)
 354         , cut_buffer_length (0)
 355         , button_bindings (0)
 356         , last_paste_pos (-1)
 357         , paste_count (0)
 358         , sfbrowser (0)
 359         , current_interthread_info (0)
 360         , analysis_window (0)
 361         , select_new_marker (false)
 362         , last_scrub_x (0)
 363         , scrubbing_direction (0)
 364         , scrub_reversals (0)
 365         , scrub_reverse_distance (0)
 366         , have_pending_keyboard_selection (false)
 367         , pending_keyboard_selection_start (0)
 368         , _snap_type (SnapToBeat)
 369         , _snap_mode (SnapOff)
 370         , snap_threshold (5.0)
 371         , ignore_gui_changes (false)
 372         , _drags (new DragManager (this))
 373         , lock_dialog (0)
 374           /* , last_event_time { 0, 0 } */ /* this initialization style requires C++11 */
 375         , _dragging_playhead (false)
 376         , _dragging_edit_point (false)
 377         , _show_measures (true)
 378         , _follow_playhead (true)
 379         , _stationary_playhead (false)
 380         , _maximised (false)
 381         , tempo_lines (0)
 382         , global_rect_group (0)
 383         , time_line_group (0)
 384         , tempo_marker_menu (0)
 385         , meter_marker_menu (0)
 386         , marker_menu (0)
 387         , range_marker_menu (0)
 388         , transport_marker_menu (0)
 389         , new_transport_marker_menu (0)
 390         , cd_marker_menu (0)
 391         , marker_menu_item (0)
 392         , bbt_beat_subdivision (4)
 393         , _visible_track_count (-1)
 394         ,  toolbar_selection_clock_table (2,3)
 395         ,  automation_mode_button (_("mode"))
 396         , selection (new Selection (this, true))
 397         , cut_buffer (new Selection (this, false))
 398         , _selection_memento (new SelectionMemento())
 399         , _all_region_actions_sensitized (false)
 400         , _ignore_region_action (false)
 401         , _last_region_menu_was_main (false)
 402         , _track_selection_change_without_scroll (false)
 403         , cd_marker_bar_drag_rect (0)
 404         , range_bar_drag_rect (0)
 405         , transport_bar_drag_rect (0)
 406         , transport_bar_range_rect (0)
 407         , transport_bar_preroll_rect (0)
 408         , transport_bar_postroll_rect (0)
 409         , transport_loop_range_rect (0)
 410         , transport_punch_range_rect (0)
 411         , transport_punchin_line (0)
 412         , transport_punchout_line (0)
 413         , transport_preroll_rect (0)
 414         , transport_postroll_rect (0)
 415         , temp_location (0)
 416         , rubberband_rect (0)
 417         , _route_groups (0)
 418         , _routes (0)
 419         , _regions (0)
 420         , _snapshots (0)
 421         , _locations (0)
 422         , autoscroll_horizontal_allowed (false)
 423         , autoscroll_vertical_allowed (false)
 424         , autoscroll_cnt (0)
 425         , autoscroll_widget (0)
 426         , show_gain_after_trim (false)
 427         , selection_op_cmd_depth (0)
 428         , selection_op_history_it (0)
 429         , no_save_instant (false)
 430         , current_timefx (0)
 431         , current_mixer_strip (0)
 432         , show_editor_mixer_when_tracks_arrive (false)
 433         ,  nudge_clock (new AudioClock (X_("nudge"), false, X_("nudge"), true, false, true))
 434         , current_stepping_trackview (0)
 435         , last_track_height_step_timestamp (0)
 436         , entered_track (0)
 437         , entered_regionview (0)
 438         , clear_entered_track (false)
 439         , _edit_point (EditAtMouse)
 440         , meters_running (false)
 441         , rhythm_ferret (0)
 442         , _have_idled (false)
 443         , resize_idle_id (-1)
 444         , _pending_resize_amount (0)
 445         , _pending_resize_view (0)
 446         , _pending_locate_request (false)
 447         , _pending_initial_locate (false)
 448         , _summary (0)
 449         , _group_tabs (0)
 450         , _last_motion_y (0)
 451         , layering_order_editor (0)
 452         , _last_cut_copy_source_track (0)
 453         , _region_selection_change_updates_region_list (true)
 454         , _cursors (0)
 455         , _following_mixer_selection (false)
 456         , _control_point_toggled_on_press (false)
 457         , _stepping_axis_view (0)
 458         , quantize_dialog (0)
 459         , _main_menu_disabler (0)
 460         , myactions (X_("editor"))
 461 {
 462         /* we are a singleton */
 463
 464         PublicEditor::_instance = this;
 465
 466         _have_idled = false;
 467
 468         last_event_time.tv_sec = 0;
 469         last_event_time.tv_usec = 0;
 470
 471         selection_op_history.clear();
 472         before.clear();
 473
 474         snap_type_strings =  I18N (_snap_type_strings);
 475         snap_mode_strings =  I18N (_snap_mode_strings);
 476         zoom_focus_strings = I18N (_zoom_focus_strings);
 477         edit_mode_strings = I18N (_edit_mode_strings);
 478         edit_point_strings = I18N (_edit_point_strings);
 479 #ifdef USE_RUBBERBAND
 480         rb_opt_strings = I18N (_rb_opt_strings);
 481         rb_current_opt = 4;
 482 #endif
 483
 484         build_edit_mode_menu();
 485         build_zoom_focus_menu();
 486         build_track_count_menu();
 487         build_snap_mode_menu();
 488         build_snap_type_menu();
 489         build_edit_point_menu();
 490
 491         location_marker_color = UIConfiguration::instance().color ("location marker");
 492         location_range_color = UIConfiguration::instance().color ("location range");
 493         location_cd_marker_color = UIConfiguration::instance().color ("location cd marker");
 494         location_loop_color = UIConfiguration::instance().color ("location loop");
 495         location_punch_color = UIConfiguration::instance().color ("location punch");
 496
 497         timebar_height = std::max (12., ceil (15. * UIConfiguration::instance().get_ui_scale()));
 498
 499         TimeAxisView::setup_sizes ();
 500         ArdourMarker::setup_sizes (timebar_height);
 501         TempoCurve::setup_sizes (timebar_height);
 502
 503         bbt_label.set_name ("EditorRulerLabel");
 504         bbt_label.set_size_request (-1, (int)timebar_height);
 505         bbt_label.set_alignment (1.0, 0.5);
 506         bbt_label.set_padding (5,0);
 507         bbt_label.hide ();
 508         bbt_label.set_no_show_all();
 509         minsec_label.set_name ("EditorRulerLabel");
 510         minsec_label.set_size_request (-1, (int)timebar_height);
 511         minsec_label.set_alignment (1.0, 0.5);
 512         minsec_label.set_padding (5,0);
 513         minsec_label.hide ();
 514         minsec_label.set_no_show_all();
 515         timecode_label.set_name ("EditorRulerLabel");
 516         timecode_label.set_size_request (-1, (int)timebar_height);
 517         timecode_label.set_alignment (1.0, 0.5);
 518         timecode_label.set_padding (5,0);
 519         timecode_label.hide ();
 520         timecode_label.set_no_show_all();
 521         samples_label.set_name ("EditorRulerLabel");
 522         samples_label.set_size_request (-1, (int)timebar_height);
 523         samples_label.set_alignment (1.0, 0.5);
 524         samples_label.set_padding (5,0);
 525         samples_label.hide ();
 526         samples_label.set_no_show_all();
 527
 528         tempo_label.set_name ("EditorRulerLabel");
 529         tempo_label.set_size_request (-1, (int)timebar_height);
 530         tempo_label.set_alignment (1.0, 0.5);
 531         tempo_label.set_padding (5,0);
 532         tempo_label.hide();
 533         tempo_label.set_no_show_all();
 534
 535         meter_label.set_name ("EditorRulerLabel");
 536         meter_label.set_size_request (-1, (int)timebar_height);
 537         meter_label.set_alignment (1.0, 0.5);
 538         meter_label.set_padding (5,0);
 539         meter_label.hide();
 540         meter_label.set_no_show_all();
 541
 542         if (Profile->get_trx()) {
 543                 mark_label.set_text (_("Markers"));
 544         }
 545         mark_label.set_name ("EditorRulerLabel");
 546         mark_label.set_size_request (-1, (int)timebar_height);
 547         mark_label.set_alignment (1.0, 0.5);
 548         mark_label.set_padding (5,0);
 549         mark_label.hide();
 550         mark_label.set_no_show_all();
 551
 552         cd_mark_label.set_name ("EditorRulerLabel");
 553         cd_mark_label.set_size_request (-1, (int)timebar_height);
 554         cd_mark_label.set_alignment (1.0, 0.5);
 555         cd_mark_label.set_padding (5,0);
 556         cd_mark_label.hide();
 557         cd_mark_label.set_no_show_all();
 558
 559         videotl_bar_height = 4;
 560         videotl_label.set_name ("EditorRulerLabel");
 561         videotl_label.set_size_request (-1, (int)timebar_height * videotl_bar_height);
 562         videotl_label.set_alignment (1.0, 0.5);
 563         videotl_label.set_padding (5,0);
 564         videotl_label.hide();
 565         videotl_label.set_no_show_all();
 566
 567         range_mark_label.set_name ("EditorRulerLabel");
 568         range_mark_label.set_size_request (-1, (int)timebar_height);
 569         range_mark_label.set_alignment (1.0, 0.5);
 570         range_mark_label.set_padding (5,0);
 571         range_mark_label.hide();
 572         range_mark_label.set_no_show_all();
 573
 574         transport_mark_label.set_name ("EditorRulerLabel");
 575         transport_mark_label.set_size_request (-1, (int)timebar_height);
 576         transport_mark_label.set_alignment (1.0, 0.5);
 577         transport_mark_label.set_padding (5,0);
 578         transport_mark_label.hide();
 579         transport_mark_label.set_no_show_all();
 580
 581         initialize_canvas ();
 582
 583         CairoWidget::set_focus_handler (sigc::mem_fun (ARDOUR_UI::instance(), &ARDOUR_UI::reset_focus));
 584
 585         _summary = new EditorSummary (this);
 586
 587         selection->TimeChanged.connect (sigc::mem_fun(*this, &Editor::time_selection_changed));
 588
 589         editor_regions_selection_changed_connection = selection->RegionsChanged.connect (sigc::mem_fun(*this, &Editor::region_selection_changed));
 590
 591         selection->PointsChanged.connect (sigc::mem_fun(*this, &Editor::point_selection_changed));
 592         selection->MarkersChanged.connect (sigc::mem_fun(*this, &Editor::marker_selection_changed));
 593
 594         edit_controls_vbox.set_spacing (0);
 595         vertical_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &Editor::tie_vertical_scrolling), true);
 596         _track_canvas->signal_map_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_map_handler));
 597
 598         HBox* h = manage (new HBox);
 599         _group_tabs = new EditorGroupTabs (this);
 600         if (!ARDOUR::Profile->get_trx()) {
 601                 h->pack_start (*_group_tabs, PACK_SHRINK);
 602         }
 603         h->pack_start (edit_controls_vbox);
 604         controls_layout.add (*h);
 605
 606         controls_layout.set_name ("EditControlsBase");
 607         controls_layout.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK|Gdk::SCROLL_MASK);
 608         controls_layout.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::edit_controls_button_release));
 609         controls_layout.signal_scroll_event().connect (sigc::mem_fun(*this, &Editor::control_layout_scroll), false);
 610
 611         _cursors = new MouseCursors;
 612         _cursors->set_cursor_set (UIConfiguration::instance().get_icon_set());
 613         cerr << "Set cursor set to " << UIConfiguration::instance().get_icon_set() << endl;
 614
 615         /* Push default cursor to ever-present bottom of cursor stack. */
 616         push_canvas_cursor(_cursors->grabber);
 617
 618         ArdourCanvas::GtkCanvas* time_pad = manage (new ArdourCanvas::GtkCanvas ());
 619
 620         ArdourCanvas::Line* pad_line_1 = new ArdourCanvas::Line (time_pad->root());
 621         pad_line_1->set (ArdourCanvas::Duple (0.0, 1.0), ArdourCanvas::Duple (100.0, 1.0));
 622         pad_line_1->set_outline_color (0xFF0000FF);
 623         pad_line_1->show();
 624
 625         // CAIROCANVAS
 626         time_pad->show();
 627
 628         edit_packer.set_col_spacings (0);
 629         edit_packer.set_row_spacings (0);
 630         edit_packer.set_homogeneous (false);
 631         edit_packer.set_border_width (0);
 632         edit_packer.set_name ("EditorWindow");
 633
 634         time_bars_event_box.add (time_bars_vbox);
 635         time_bars_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 636         time_bars_event_box.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_label_button_release));
 637
 638         /* labels for the time bars */
 639         edit_packer.attach (time_bars_event_box,     0, 1, 0, 1,    FILL,        SHRINK, 0, 0);
 640         /* track controls */
 641         edit_packer.attach (controls_layout,         0, 1, 1, 2,    FILL,        FILL|EXPAND, 0, 0);
 642         /* canvas */
 643         edit_packer.attach (*_track_canvas_viewport,  1, 2, 0, 2,    FILL|EXPAND, FILL|EXPAND, 0, 0);
 644
 645         bottom_hbox.set_border_width (2);
 646         bottom_hbox.set_spacing (3);
 647
 648         PresentationInfo::Change.connect (*this, MISSING_INVALIDATOR, boost::bind (&Editor::presentation_info_changed, this, _1), gui_context());
 649
 650         _route_groups = new EditorRouteGroups (this);
 651         _routes = new EditorRoutes (this);
 652         _regions = new EditorRegions (this);
 653         _snapshots = new EditorSnapshots (this);
 654         _locations = new EditorLocations (this);
 655         _time_info_box = new TimeInfoBox ("EditorTimeInfo", true);
 656
 657         /* these are static location signals */
 658
 659         Location::start_changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 660         Location::end_changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 661         Location::changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 662
 663         add_notebook_page (_("Regions"), _regions->widget ());
 664         add_notebook_page (_("Tracks & Busses"), _routes->widget ());
 665         add_notebook_page (_("Snapshots"), _snapshots->widget ());
 666         add_notebook_page (_("Track & Bus Groups"), _route_groups->widget ());
 667         add_notebook_page (_("Ranges & Marks"), _locations->widget ());
 668
 669         _the_notebook.set_show_tabs (true);
 670         _the_notebook.set_scrollable (true);
 671         _the_notebook.popup_disable ();
 672         _the_notebook.set_tab_pos (Gtk::POS_RIGHT);
 673         _the_notebook.show_all ();
 674
 675         _notebook_shrunk = false;
 676
 677
 678         /* Pick up some settings we need to cache, early */
 679
 680         XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
 681
 682         if (settings) {
 683                 settings->get_property ("notebook-shrunk", _notebook_shrunk);
 684         }
 685
 686         editor_summary_pane.set_check_divider_position (true);
 687         editor_summary_pane.add (edit_packer);
 688
 689         Button* summary_arrow_left = manage (new Button);
 690         summary_arrow_left->add (*manage (new Arrow (ARROW_LEFT, SHADOW_NONE)));
 691         summary_arrow_left->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), LEFT)));
 692         summary_arrow_left->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 693
 694         Button* summary_arrow_right = manage (new Button);
 695         summary_arrow_right->add (*manage (new Arrow (ARROW_RIGHT, SHADOW_NONE)));
 696         summary_arrow_right->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), RIGHT)));
 697         summary_arrow_right->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 698
 699         VBox* summary_arrows_left = manage (new VBox);
 700         summary_arrows_left->pack_start (*summary_arrow_left);
 701
 702         VBox* summary_arrows_right = manage (new VBox);
 703         summary_arrows_right->pack_start (*summary_arrow_right);
 704
 705         Frame* summary_frame = manage (new Frame);
 706         summary_frame->set_shadow_type (Gtk::SHADOW_ETCHED_IN);
 707
 708         summary_frame->add (*_summary);
 709         summary_frame->show ();
 710
 711         _summary_hbox.pack_start (*summary_arrows_left, false, false);
 712         _summary_hbox.pack_start (*summary_frame, true, true);
 713         _summary_hbox.pack_start (*summary_arrows_right, false, false);
 714
 715         if (!ARDOUR::Profile->get_trx()) {
 716                 editor_summary_pane.add (_summary_hbox);
 717         }
 718
 719         edit_pane.set_check_divider_position (true);
 720         edit_pane.add (editor_summary_pane);
 721         if (!ARDOUR::Profile->get_trx()) {
 722                 _editor_list_vbox.pack_start (*_time_info_box, false, false, 0);
 723                 _editor_list_vbox.pack_start (_the_notebook);
 724                 edit_pane.add (_editor_list_vbox);
 725                 edit_pane.set_child_minsize (_editor_list_vbox, 30); /* rough guess at width of notebook tabs */
 726         }
 727
 728         edit_pane.set_drag_cursor (*_cursors->expand_left_right);
 729         editor_summary_pane.set_drag_cursor (*_cursors->expand_up_down);
 730
 731         float fract;
 732         if (!settings || !settings->get_property ("edit-horizontal-pane-pos", fract) || fract > 1.0) {
 733                 /* initial allocation is 90% to canvas, 10% to notebook */
 734                 fract = 0.90;
 735         }
 736         edit_pane.set_divider (0, fract);
 737
 738         if (!settings || !settings->get_property ("edit-vertical-pane-pos", fract) || fract > 1.0) {
 739                 /* initial allocation is 90% to canvas, 10% to summary */
 740                 fract = 0.90;
 741         }
 742         editor_summary_pane.set_divider (0, fract);
 743
 744         global_vpacker.set_spacing (2);
 745         global_vpacker.set_border_width (0);
 746
 747         //the next three EventBoxes provide the ability for their child widgets to have a background color.  That is all.
 748
 749         Gtk::EventBox* ebox = manage (new Gtk::EventBox);  //a themeable box
 750         ebox->set_name("EditorWindow");
 751         ebox->add (toolbar_hbox);
 752
 753         Gtk::EventBox* epane_box = manage (new EventBoxExt);  //a themeable box
 754         epane_box->set_name("EditorWindow");
 755         epane_box->add (edit_pane);
 756
 757         Gtk::EventBox* epane_box2 = manage (new EventBoxExt);  //a themeable box
 758         epane_box2->set_name("EditorWindow");
 759         epane_box2->add (global_vpacker);
 760
 761         global_vpacker.pack_start (*ebox, false, false);
 762         global_vpacker.pack_start (*epane_box, true, true);
 763         global_hpacker.pack_start (*epane_box2, true, true);
 764
 765         /* need to show the "contents" widget so that notebook will show if tab is switched to
 766          */
 767
 768         global_hpacker.show ();
 769
 770         /* register actions now so that set_state() can find them and set toggles/checks etc */
 771
 772         register_actions ();
 773         load_bindings ();
 774
 775         setup_toolbar ();
 776
 777         _playlist_selector = new PlaylistSelector();
 778         _playlist_selector->signal_delete_event().connect (sigc::bind (sigc::ptr_fun (just_hide_it), static_cast<Window *> (_playlist_selector)));
 779
 780         RegionView::RegionViewGoingAway.connect (*this, invalidator (*this),  boost::bind (&Editor::catch_vanishing_regionview, this, _1), gui_context());
 781
 782         /* nudge stuff */
 783
 784         nudge_forward_button.set_name ("nudge button");
 785         nudge_forward_button.set_icon(ArdourIcon::NudgeRight);
 786
 787         nudge_backward_button.set_name ("nudge button");
 788         nudge_backward_button.set_icon(ArdourIcon::NudgeLeft);
 789
 790         fade_context_menu.set_name ("ArdourContextMenu");
 791
 792         Gtkmm2ext::Keyboard::the_keyboard().ZoomVerticalModifierReleased.connect (sigc::mem_fun (*this, &Editor::zoom_vertical_modifier_released));
 793
 794         /* allow external control surfaces/protocols to do various things */
 795
 796         ControlProtocol::ZoomToSession.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_session, this), gui_context());
 797         ControlProtocol::ZoomIn.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_step, this, false), gui_context());
 798         ControlProtocol::ZoomOut.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_step, this, true), gui_context());
 799         ControlProtocol::Undo.connect (*this, invalidator (*this), boost::bind (&Editor::undo, this, true), gui_context());
 800         ControlProtocol::Redo.connect (*this, invalidator (*this), boost::bind (&Editor::redo, this, true), gui_context());
 801         ControlProtocol::ScrollTimeline.connect (*this, invalidator (*this), boost::bind (&Editor::control_scroll, this, _1), gui_context());
 802         ControlProtocol::StepTracksUp.connect (*this, invalidator (*this), boost::bind (&Editor::control_step_tracks_up, this), gui_context());
 803         ControlProtocol::StepTracksDown.connect (*this, invalidator (*this), boost::bind (&Editor::control_step_tracks_down, this), gui_context());
 804         ControlProtocol::GotoView.connect (*this, invalidator (*this), boost::bind (&Editor::control_view, this, _1), gui_context());
 805         ControlProtocol::CloseDialog.connect (*this, invalidator (*this), Keyboard::close_current_dialog, gui_context());
 806         ControlProtocol::VerticalZoomInAll.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_in_all, this), gui_context());
 807         ControlProtocol::VerticalZoomOutAll.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_out_all, this), gui_context());
 808         ControlProtocol::VerticalZoomInSelected.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_in_selected, this), gui_context());
 809         ControlProtocol::VerticalZoomOutSelected.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_out_selected, this), gui_context());
 810
 811         ControlProtocol::AddStripableToSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Add), gui_context());
 812         ControlProtocol::RemoveStripableFromSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Toggle), gui_context());
 813         ControlProtocol::SetStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Set), gui_context());
 814         ControlProtocol::ToggleStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Toggle), gui_context());
 815         ControlProtocol::ClearStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_unselect, this), gui_context());
 816
 817         BasicUI::AccessAction.connect (*this, invalidator (*this), boost::bind (&Editor::access_action, this, _1, _2), gui_context());
 818
 819         /* handle escape */
 820
 821         ARDOUR_UI::instance()->Escape.connect (*this, invalidator (*this), boost::bind (&Editor::escape, this), gui_context());
 822
 823         /* problematic: has to return a value and thus cannot be x-thread */
 824
 825         Session::AskAboutPlaylistDeletion.connect_same_thread (*this, boost::bind (&Editor::playlist_deletion_dialog, this, _1));
 826
 827         Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&Editor::parameter_changed, this, _1), gui_context());
 828         UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &Editor::ui_parameter_changed));
 829
 830         TimeAxisView::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Editor::timeaxisview_deleted, this, _1), gui_context());
 831
 832         _ignore_region_action = false;
 833         _last_region_menu_was_main = false;
 834         _popup_region_menu_item = 0;
 835
 836         _show_marker_lines = false;
 837
 838         /* Button bindings */
 839
 840         button_bindings = new Bindings ("editor-mouse");
 841
 842         XMLNode* node = button_settings();
 843         if (node) {
 844                 for (XMLNodeList::const_iterator i = node->children().begin(); i != node->children().end(); ++i) {
 845                         button_bindings->load_operation (**i);
 846                 }
 847         }
 848
 849         constructed = true;
 850
 851         /* grab current parameter state */
 852         boost::function<void (string)> pc (boost::bind (&Editor::ui_parameter_changed, this, _1));
 853         UIConfiguration::instance().map_parameters (pc);
 854
 855         setup_fade_images ();
 856
 857         instant_save ();
 858 }
 859
 860 Editor::~Editor()
 861 {
 862         delete button_bindings;
 863         delete _routes;
 864         delete _route_groups;
 865         delete _track_canvas_viewport;
 866         delete _drags;
 867         delete nudge_clock;
 868         delete _verbose_cursor;
 869         delete quantize_dialog;
 870         delete _summary;
 871         delete _group_tabs;
 872         delete _regions;
 873         delete _snapshots;
 874         delete _locations;
 875         delete _playlist_selector;
 876         delete _time_info_box;
 877         delete selection;
 878         delete cut_buffer;
 879         delete _cursors;
 880
 881         LuaInstance::destroy_instance ();
 882
 883         for (list<XMLNode *>::iterator i = selection_op_history.begin(); i != selection_op_history.end(); ++i) {
 884                 delete *i;
 885         }
 886         for (std::map<ARDOUR::FadeShape, Gtk::Image*>::const_iterator i = _xfade_in_images.begin(); i != _xfade_in_images.end (); ++i) {
 887                 delete i->second;
 888         }
 889         for (std::map<ARDOUR::FadeShape, Gtk::Image*>::const_iterator i = _xfade_out_images.begin(); i != _xfade_out_images.end (); ++i) {
 890                 delete i->second;
 891         }
 892 }
 893
 894 XMLNode*
 895 Editor::button_settings () const
 896 {
 897         XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
 898         XMLNode* node = find_named_node (*settings, X_("Buttons"));
 899
 900         if (!node) {
 901                 node = new XMLNode (X_("Buttons"));
 902         }
 903
 904         return node;
 905 }
 906
 907 bool
 908 Editor::get_smart_mode () const
 909 {
 910         return ((current_mouse_mode() == Editing::MouseObject) && smart_mode_action->get_active());
 911 }
 912
 913 void
 914 Editor::catch_vanishing_regionview (RegionView *rv)
 915 {
 916         /* note: the selection will take care of the vanishing
 917            audioregionview by itself.
 918         */
 919
 920         if (_drags->active() && _drags->have_item (rv->get_canvas_group()) && !_drags->ending()) {
 921                 _drags->abort ();
 922         }
 923
 924         if (clicked_regionview == rv) {
 925                 clicked_regionview = 0;
 926         }
 927
 928         if (entered_regionview == rv) {
 929                 set_entered_regionview (0);
 930         }
 931
 932         if (!_all_region_actions_sensitized) {
 933                 sensitize_all_region_actions (true);
 934         }
 935 }
 936
 937 void
 938 Editor::set_entered_regionview (RegionView* rv)
 939 {
 940         if (rv == entered_regionview) {
 941                 return;
 942         }
 943
 944         if (entered_regionview) {
 945                 entered_regionview->exited ();
 946         }
 947
 948         entered_regionview = rv;
 949
 950         if (entered_regionview  != 0) {
 951                 entered_regionview->entered ();
 952         }
 953
 954         if (!_all_region_actions_sensitized && _last_region_menu_was_main) {
 955                 /* This RegionView entry might have changed what region actions
 956                    are allowed, so sensitize them all in case a key is pressed.
 957                 */
 958                 sensitize_all_region_actions (true);
 959         }
 960 }
 961
 962 void
 963 Editor::set_entered_track (TimeAxisView* tav)
 964 {
 965         if (entered_track) {
 966                 entered_track->exited ();
 967         }
 968
 969         entered_track = tav;
 970
 971         if (entered_track) {
 972                 entered_track->entered ();
 973         }
 974 }
 975
 976 void
 977 Editor::instant_save ()
 978 {
 979         if (!constructed || !ARDOUR_UI::instance()->session_loaded || no_save_instant) {
 980                 return;
 981         }
 982
 983         if (_session) {
 984                 _session->add_instant_xml(get_state());
 985         } else {
 986                 Config->add_instant_xml(get_state());
 987         }
 988 }
 989
 990 void
 991 Editor::control_vertical_zoom_in_all ()
 992 {
 993         tav_zoom_smooth (false, true);
 994 }
 995
 996 void
 997 Editor::control_vertical_zoom_out_all ()
 998 {
 999         tav_zoom_smooth (true, true);
1000 }
1001
1002 void
1003 Editor::control_vertical_zoom_in_selected ()
1004 {
1005         tav_zoom_smooth (false, false);
1006 }
1007
1008 void
1009 Editor::control_vertical_zoom_out_selected ()
1010 {
1011         tav_zoom_smooth (true, false);
1012 }
1013
1014 void
1015 Editor::control_view (uint32_t view)
1016 {
1017         goto_visual_state (view);
1018 }
1019
1020 void
1021 Editor::control_unselect ()
1022 {
1023         selection->clear_tracks ();
1024 }
1025
1026 void
1027 Editor::control_select (boost::shared_ptr<Stripable> s, Selection::Operation op)
1028 {
1029         TimeAxisView* tav = time_axis_view_from_stripable (s);
1030
1031         if (tav) {
1032                 switch (op) {
1033                 case Selection::Add:
1034                         selection->add (tav);
1035                         break;
1036                 case Selection::Toggle:
1037                         selection->toggle (tav);
1038                         break;
1039                 case Selection::Extend:
1040                         break;
1041                 case Selection::Set:
1042                         selection->set (tav);
1043                         break;
1044                 }
1045         } else {
1046                 selection->clear_tracks ();
1047         }
1048 }
1049
1050 void
1051 Editor::control_step_tracks_up ()
1052 {
1053         scroll_tracks_up_line ();
1054 }
1055
1056 void
1057 Editor::control_step_tracks_down ()
1058 {
1059         scroll_tracks_down_line ();
1060 }
1061
1062 void
1063 Editor::control_scroll (float fraction)
1064 {
1065         ENSURE_GUI_THREAD (*this, &Editor::control_scroll, fraction)
1066
1067         if (!_session) {
1068                 return;
1069         }
1070
1071         double step = fraction * current_page_samples();
1072
1073         /*
1074                 _control_scroll_target is an optional<T>
1075
1076                 it acts like a pointer to an framepos_t, with
1077                 a operator conversion to boolean to check
1078                 that it has a value could possibly use
1079                 playhead_cursor->current_frame to store the
1080                 value and a boolean in the class to know
1081                 when it's out of date
1082         */
1083
1084         if (!_control_scroll_target) {
1085                 _control_scroll_target = _session->transport_frame();
1086                 _dragging_playhead = true;
1087         }
1088
1089         if ((fraction < 0.0f) && (*_control_scroll_target <= (framepos_t) fabs(step))) {
1090                 *_control_scroll_target = 0;
1091         } else if ((fraction > 0.0f) && (max_framepos - *_control_scroll_target < step)) {
1092                 *_control_scroll_target = max_framepos - (current_page_samples()*2); // allow room for slop in where the PH is on the screen
1093         } else {
1094                 *_control_scroll_target += (framepos_t) trunc (step);
1095         }
1096
1097         /* move visuals, we'll catch up with it later */
1098
1099         playhead_cursor->set_position (*_control_scroll_target);
1100         UpdateAllTransportClocks (*_control_scroll_target);
1101
1102         if (*_control_scroll_target > (current_page_samples() / 2)) {
1103                 /* try to center PH in window */
1104                 reset_x_origin (*_control_scroll_target - (current_page_samples()/2));
1105         } else {
1106                 reset_x_origin (0);
1107         }
1108
1109         /*
1110                 Now we do a timeout to actually bring the session to the right place
1111                 according to the playhead. This is to avoid reading disk buffers on every
1112                 call to control_scroll, which is driven by ScrollTimeline and therefore
1113                 probably by a control surface wheel which can generate lots of events.
1114         */
1115         /* cancel the existing timeout */
1116
1117         control_scroll_connection.disconnect ();
1118
1119         /* add the next timeout */
1120
1121         control_scroll_connection = Glib::signal_timeout().connect (sigc::bind (sigc::mem_fun (*this, &Editor::deferred_control_scroll), *_control_scroll_target), 250);
1122 }
1123
1124 bool
1125 Editor::deferred_control_scroll (framepos_t /*target*/)
1126 {
1127         _session->request_locate (*_control_scroll_target, _session->transport_rolling());
1128         // reset for next stream
1129         _control_scroll_target = boost::none;
1130         _dragging_playhead = false;
1131         return false;
1132 }
1133
1134 void
1135 Editor::access_action (const std::string& action_group, const std::string& action_item)
1136 {
1137         if (!_session) {
1138                 return;
1139         }
1140
1141         ENSURE_GUI_THREAD (*this, &Editor::access_action, action_group, action_item)
1142
1143         RefPtr<Action> act;
1144         act = ActionManager::get_action( action_group.c_str(), action_item.c_str() );
1145
1146         if (act) {
1147                 act->activate();
1148         }
1149 }
1150
1151 void
1152 Editor::set_toggleaction (const std::string& action_group, const std::string& action_item, bool s)
1153 {
1154         ActionManager::set_toggleaction_state (action_group.c_str(), action_item.c_str(), s);
1155 }
1156
1157 void
1158 Editor::on_realize ()
1159 {
1160         Realized ();
1161
1162         if (UIConfiguration::instance().get_lock_gui_after_seconds()) {
1163                 start_lock_event_timing ();
1164         }
1165 }
1166
1167 void
1168 Editor::start_lock_event_timing ()
1169 {
1170         /* check if we should lock the GUI every 30 seconds */
1171
1172         Glib::signal_timeout().connect (sigc::mem_fun (*this, &Editor::lock_timeout_callback), 30 * 1000);
1173 }
1174
1175 bool
1176 Editor::generic_event_handler (GdkEvent* ev)
1177 {
1178         switch (ev->type) {
1179         case GDK_BUTTON_PRESS:
1180         case GDK_BUTTON_RELEASE:
1181         case GDK_MOTION_NOTIFY:
1182         case GDK_KEY_PRESS:
1183         case GDK_KEY_RELEASE:
1184                 if (contents().is_mapped()) {
1185                         gettimeofday (&last_event_time, 0);
1186                 }
1187                 break;
1188
1189         case GDK_LEAVE_NOTIFY:
1190                 switch (ev->crossing.detail) {
1191                 case GDK_NOTIFY_UNKNOWN:
1192                 case GDK_NOTIFY_INFERIOR:
1193                 case GDK_NOTIFY_ANCESTOR:
1194                         break;
1195                 case GDK_NOTIFY_VIRTUAL:
1196                 case GDK_NOTIFY_NONLINEAR:
1197                 case GDK_NOTIFY_NONLINEAR_VIRTUAL:
1198                         /* leaving window, so reset focus, thus ending any and
1199                            all text entry operations.
1200                         */
1201                         ARDOUR_UI::instance()->reset_focus (&contents());
1202                         break;
1203                 }
1204                 break;
1205
1206         default:
1207                 break;
1208         }
1209
1210         return false;
1211 }
1212
1213 bool
1214 Editor::lock_timeout_callback ()
1215 {
1216         struct timeval now, delta;
1217
1218         gettimeofday (&now, 0);
1219
1220         timersub (&now, &last_event_time, &delta);
1221
1222         if (delta.tv_sec > (time_t) UIConfiguration::instance().get_lock_gui_after_seconds()) {
1223                 lock ();
1224                 /* don't call again. Returning false will effectively
1225                    disconnect us from the timer callback.
1226
1227                    unlock() will call start_lock_event_timing() to get things
1228                    started again.
1229                 */
1230                 return false;
1231         }
1232
1233         return true;
1234 }
1235
1236 void
1237 Editor::map_position_change (framepos_t frame)
1238 {
1239         ENSURE_GUI_THREAD (*this, &Editor::map_position_change, frame)
1240
1241         if (_session == 0) {
1242                 return;
1243         }
1244
1245         if (_follow_playhead) {
1246                 center_screen (frame);
1247         }
1248
1249         playhead_cursor->set_position (frame);
1250 }
1251
1252 void
1253 Editor::center_screen (framepos_t frame)
1254 {
1255         framecnt_t const page = _visible_canvas_width * samples_per_pixel;
1256
1257         /* if we're off the page, then scroll.
1258          */
1259
1260         if (frame < leftmost_frame || frame >= leftmost_frame + page) {
1261                 center_screen_internal (frame, page);
1262         }
1263 }
1264
1265 void
1266 Editor::center_screen_internal (framepos_t frame, float page)
1267 {
1268         page /= 2;
1269
1270         if (frame > page) {
1271                 frame -= (framepos_t) page;
1272         } else {
1273                 frame = 0;
1274         }
1275
1276         reset_x_origin (frame);
1277 }
1278
1279
1280 void
1281 Editor::update_title ()
1282 {
1283         ENSURE_GUI_THREAD (*this, &Editor::update_title);
1284
1285         if (!own_window()) {
1286                 return;
1287         }
1288
1289         if (_session) {
1290                 bool dirty = _session->dirty();
1291
1292                 string session_name;
1293
1294                 if (_session->snap_name() != _session->name()) {
1295                         session_name = _session->snap_name();
1296                 } else {
1297                         session_name = _session->name();
1298                 }
1299
1300                 if (dirty) {
1301                         session_name = "*" + session_name;
1302                 }
1303
1304                 WindowTitle title(session_name);
1305                 title += S_("Window|Editor");
1306                 title += Glib::get_application_name();
1307                 own_window()->set_title (title.get_string());
1308         } else {
1309                 /* ::session_going_away() will have taken care of it */
1310         }
1311 }
1312
1313 void
1314 Editor::set_session (Session *t)
1315 {
1316         SessionHandlePtr::set_session (t);
1317
1318         if (!_session) {
1319                 return;
1320         }
1321
1322         //initialize leftmost_frame to the extents of the session
1323         //this prevents a bogus setting of leftmost = "0" if the summary view asks for the leftmost frame before the visible state has been loaded from instant.xml
1324         leftmost_frame = session_gui_extents().first;
1325
1326         _playlist_selector->set_session (_session);
1327         nudge_clock->set_session (_session);
1328         _summary->set_session (_session);
1329         _group_tabs->set_session (_session);
1330         _route_groups->set_session (_session);
1331         _regions->set_session (_session);
1332         _snapshots->set_session (_session);
1333         _routes->set_session (_session);
1334         _locations->set_session (_session);
1335         _time_info_box->set_session (_session);
1336
1337         if (rhythm_ferret) {
1338                 rhythm_ferret->set_session (_session);
1339         }
1340
1341         if (analysis_window) {
1342                 analysis_window->set_session (_session);
1343         }
1344
1345         if (sfbrowser) {
1346                 sfbrowser->set_session (_session);
1347         }
1348
1349         compute_fixed_ruler_scale ();
1350
1351         /* Make sure we have auto loop and auto punch ranges */
1352
1353         Location* loc = _session->locations()->auto_loop_location();
1354         if (loc != 0) {
1355                 loc->set_name (_("Loop"));
1356         }
1357
1358         loc = _session->locations()->auto_punch_location();
1359         if (loc != 0) {
1360                 // force name
1361                 loc->set_name (_("Punch"));
1362         }
1363
1364         refresh_location_display ();
1365
1366         /* This must happen after refresh_location_display(), as (amongst other things) we restore
1367            the selected Marker; this needs the LocationMarker list to be available.
1368         */
1369         XMLNode* node = ARDOUR_UI::instance()->editor_settings();
1370         set_state (*node, Stateful::loading_state_version);
1371
1372         /* catch up on selection state, etc. */
1373
1374         PropertyChange sc;
1375         sc.add (Properties::selected);
1376         presentation_info_changed (sc);
1377
1378         /* catch up with the playhead */
1379
1380         _session->request_locate (playhead_cursor->current_frame ());
1381         _pending_initial_locate = true;
1382
1383         update_title ();
1384
1385         /* These signals can all be emitted by a non-GUI thread. Therefore the
1386            handlers for them must not attempt to directly interact with the GUI,
1387            but use PBD::Signal<T>::connect() which accepts an event loop
1388            ("context") where the handler will be asked to run.
1389         */
1390
1391         _session->StepEditStatusChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::step_edit_status_change, this, _1), gui_context());
1392         _session->TransportStateChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_transport_state, this), gui_context());
1393         _session->TransportLooped.connect (_session_connections, invalidator (*this), boost::bind (&Editor::transport_looped, this), gui_context());
1394         _session->PositionChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_position_change, this, _1), gui_context());
1395         _session->vca_manager().VCAAdded.connect (_session_connections, invalidator (*this), boost::bind (&Editor::add_vcas, this, _1), gui_context());
1396         _session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Editor::add_routes, this, _1), gui_context());
1397         _session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::update_title, this), gui_context());
1398         _session->tempo_map().PropertyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::tempo_map_changed, this, _1), gui_context());
1399         _session->tempo_map().MetricPositionChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::tempometric_position_changed, this, _1), gui_context());
1400         _session->Located.connect (_session_connections, invalidator (*this), boost::bind (&Editor::located, this), gui_context());
1401         _session->config.ParameterChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::parameter_changed, this, _1), gui_context());
1402         _session->StateSaved.connect (_session_connections, invalidator (*this), boost::bind (&Editor::session_state_saved, this, _1), gui_context());
1403         _session->locations()->added.connect (_session_connections, invalidator (*this), boost::bind (&Editor::add_new_location, this, _1), gui_context());
1404         _session->locations()->removed.connect (_session_connections, invalidator (*this), boost::bind (&Editor::location_gone, this, _1), gui_context());
1405         _session->locations()->changed.connect (_session_connections, invalidator (*this), boost::bind (&Editor::refresh_location_display, this), gui_context());
1406         _session->history().Changed.connect (_session_connections, invalidator (*this), boost::bind (&Editor::history_changed, this), gui_context());
1407
1408         playhead_cursor->show ();
1409
1410         boost::function<void (string)> pc (boost::bind (&Editor::parameter_changed, this, _1));
1411         Config->map_parameters (pc);
1412         _session->config.map_parameters (pc);
1413
1414         restore_ruler_visibility ();
1415         //tempo_map_changed (PropertyChange (0));
1416         _session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks);
1417
1418         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
1419                 (static_cast<TimeAxisView*>(*i))->set_samples_per_pixel (samples_per_pixel);
1420         }
1421
1422         super_rapid_screen_update_connection = Timers::super_rapid_connect (
1423                 sigc::mem_fun (*this, &Editor::super_rapid_screen_update)
1424                 );
1425
1426         switch (_snap_type) {
1427         case SnapToRegionStart:
1428         case SnapToRegionEnd:
1429         case SnapToRegionSync:
1430         case SnapToRegionBoundary:
1431                 build_region_boundary_cache ();
1432                 break;
1433
1434         default:
1435                 break;
1436         }
1437
1438         /* register for undo history */
1439         _session->register_with_memento_command_factory(id(), this);
1440         _session->register_with_memento_command_factory(_selection_memento->id(), _selection_memento);
1441
1442         LuaInstance::instance()->set_session(_session);
1443
1444         start_updating_meters ();
1445 }
1446
1447 void
1448 Editor::fill_xfade_menu (Menu_Helpers::MenuList& items, bool start)
1449 {
1450         using namespace Menu_Helpers;
1451
1452         void (Editor::*emf)(FadeShape);
1453         std::map<ARDOUR::FadeShape,Gtk::Image*>* images;
1454
1455         if (start) {
1456                 images = &_xfade_in_images;
1457                 emf = &Editor::set_fade_in_shape;
1458         } else {
1459                 images = &_xfade_out_images;
1460                 emf = &Editor::set_fade_out_shape;
1461         }
1462
1463         items.push_back (
1464                 ImageMenuElem (
1465                         _("Linear (for highly correlated material)"),
1466                         *(*images)[FadeLinear],
1467                         sigc::bind (sigc::mem_fun (*this, emf), FadeLinear)
1468                         )
1469                 );
1470
1471         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1472
1473         items.push_back (
1474                 ImageMenuElem (
1475                         _("Constant power"),
1476                         *(*images)[FadeConstantPower],
1477                         sigc::bind (sigc::mem_fun (*this, emf), FadeConstantPower)
1478                         ));
1479
1480         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1481
1482         items.push_back (
1483                 ImageMenuElem (
1484                         _("Symmetric"),
1485                         *(*images)[FadeSymmetric],
1486                         sigc::bind (sigc::mem_fun (*this, emf), FadeSymmetric)
1487                         )
1488                 );
1489
1490         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1491
1492         items.push_back (
1493                 ImageMenuElem (
1494                         _("Slow"),
1495                         *(*images)[FadeSlow],
1496                         sigc::bind (sigc::mem_fun (*this, emf), FadeSlow)
1497                         ));
1498
1499         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1500
1501         items.push_back (
1502                 ImageMenuElem (
1503                         _("Fast"),
1504                         *(*images)[FadeFast],
1505                         sigc::bind (sigc::mem_fun (*this, emf), FadeFast)
1506                         ));
1507
1508         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1509 }
1510
1511 /** Pop up a context menu for when the user clicks on a start crossfade */
1512 void
1513 Editor::popup_xfade_in_context_menu (int button, int32_t time, ArdourCanvas::Item* item, ItemType /*item_type*/)
1514 {
1515         using namespace Menu_Helpers;
1516         AudioRegionView* arv = dynamic_cast<AudioRegionView*> ((RegionView*)item->get_data ("regionview"));
1517         if (!arv) {
1518                 return;
1519         }
1520
1521         MenuList& items (xfade_in_context_menu.items());
1522         items.clear ();
1523
1524         if (arv->audio_region()->fade_in_active()) {
1525                 items.push_back (MenuElem (_("Deactivate"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_active), false)));
1526         } else {
1527                 items.push_back (MenuElem (_("Activate"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_active), true)));
1528         }
1529
1530         items.push_back (SeparatorElem());
1531         fill_xfade_menu (items, true);
1532
1533         xfade_in_context_menu.popup (button, time);
1534 }
1535
1536 /** Pop up a context menu for when the user clicks on an end crossfade */
1537 void
1538 Editor::popup_xfade_out_context_menu (int button, int32_t time, ArdourCanvas::Item* item, ItemType /*item_type*/)
1539 {
1540         using namespace Menu_Helpers;
1541         AudioRegionView* arv = dynamic_cast<AudioRegionView*> ((RegionView*)item->get_data ("regionview"));
1542         if (!arv) {
1543                 return;
1544         }
1545
1546         MenuList& items (xfade_out_context_menu.items());
1547         items.clear ();
1548
1549         if (arv->audio_region()->fade_out_active()) {
1550                 items.push_back (MenuElem (_("Deactivate"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_active), false)));
1551         } else {
1552                 items.push_back (MenuElem (_("Activate"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_active), true)));
1553         }
1554
1555         items.push_back (SeparatorElem());
1556         fill_xfade_menu (items, false);
1557
1558         xfade_out_context_menu.popup (button, time);
1559 }
1560
1561 void
1562 Editor::popup_track_context_menu (int button, int32_t time, ItemType item_type, bool with_selection)
1563 {
1564         using namespace Menu_Helpers;
1565         Menu* (Editor::*build_menu_function)();
1566         Menu *menu;
1567
1568         switch (item_type) {
1569         case RegionItem:
1570         case RegionViewName:
1571         case RegionViewNameHighlight:
1572         case LeftFrameHandle:
1573         case RightFrameHandle:
1574                 if (with_selection) {
1575                         build_menu_function = &Editor::build_track_selection_context_menu;
1576                 } else {
1577                         build_menu_function = &Editor::build_track_region_context_menu;
1578                 }
1579                 break;
1580
1581         case SelectionItem:
1582                 if (with_selection) {
1583                         build_menu_function = &Editor::build_track_selection_context_menu;
1584                 } else {
1585                         build_menu_function = &Editor::build_track_context_menu;
1586                 }
1587                 break;
1588
1589         case StreamItem:
1590                 if (clicked_routeview->track()) {
1591                         build_menu_function = &Editor::build_track_context_menu;
1592                 } else {
1593                         build_menu_function = &Editor::build_track_bus_context_menu;
1594                 }
1595                 break;
1596
1597         default:
1598                 /* probably shouldn't happen but if it does, we don't care */
1599                 return;
1600         }
1601
1602         menu = (this->*build_menu_function)();
1603         menu->set_name ("ArdourContextMenu");
1604
1605         /* now handle specific situations */
1606
1607         switch (item_type) {
1608         case RegionItem:
1609         case RegionViewName:
1610         case RegionViewNameHighlight:
1611         case LeftFrameHandle:
1612         case RightFrameHandle:
1613                 if (!with_selection) {
1614                         if (region_edit_menu_split_item) {
1615                                 if (clicked_regionview && clicked_regionview->region()->covers (get_preferred_edit_position())) {
1616                                         ActionManager::set_sensitive (ActionManager::edit_point_in_region_sensitive_actions, true);
1617                                 } else {
1618                                         ActionManager::set_sensitive (ActionManager::edit_point_in_region_sensitive_actions, false);
1619                                 }
1620                         }
1621                         if (region_edit_menu_split_multichannel_item) {
1622                                 if (clicked_regionview && clicked_regionview->region()->n_channels() > 1) {
1623                                         region_edit_menu_split_multichannel_item->set_sensitive (true);
1624                                 } else {
1625                                         region_edit_menu_split_multichannel_item->set_sensitive (false);
1626                                 }
1627                         }
1628                 }
1629                 break;
1630
1631         case SelectionItem:
1632                 break;
1633
1634         case StreamItem:
1635                 break;
1636
1637         default:
1638                 /* probably shouldn't happen but if it does, we don't care */
1639                 return;
1640         }
1641
1642         if (item_type != SelectionItem && clicked_routeview && clicked_routeview->audio_track()) {
1643
1644                 /* Bounce to disk */
1645
1646                 using namespace Menu_Helpers;
1647                 MenuList& edit_items  = menu->items();
1648
1649                 edit_items.push_back (SeparatorElem());
1650
1651                 switch (clicked_routeview->audio_track()->freeze_state()) {
1652                 case AudioTrack::NoFreeze:
1653                         edit_items.push_back (MenuElem (_("Freeze"), sigc::mem_fun(*this, &Editor::freeze_route)));
1654                         break;
1655
1656                 case AudioTrack::Frozen:
1657                         edit_items.push_back (MenuElem (_("Unfreeze"), sigc::mem_fun(*this, &Editor::unfreeze_route)));
1658                         break;
1659
1660                 case AudioTrack::UnFrozen:
1661                         edit_items.push_back (MenuElem (_("Freeze"), sigc::mem_fun(*this, &Editor::freeze_route)));
1662                         break;
1663                 }
1664
1665         }
1666
1667         if (item_type == StreamItem && clicked_routeview) {
1668                 clicked_routeview->build_underlay_menu(menu);
1669         }
1670
1671         /* When the region menu is opened, we setup the actions so that they look right
1672            in the menu.
1673         */
1674         sensitize_the_right_region_actions (false);
1675         _last_region_menu_was_main = false;
1676
1677         menu->signal_hide().connect (sigc::bind (sigc::mem_fun (*this, &Editor::sensitize_all_region_actions), true));
1678         menu->popup (button, time);
1679 }
1680
1681 Menu*
1682 Editor::build_track_context_menu ()
1683 {
1684         using namespace Menu_Helpers;
1685
1686         MenuList& edit_items = track_context_menu.items();
1687         edit_items.clear();
1688
1689         add_dstream_context_items (edit_items);
1690         return &track_context_menu;
1691 }
1692
1693 Menu*
1694 Editor::build_track_bus_context_menu ()
1695 {
1696         using namespace Menu_Helpers;
1697
1698         MenuList& edit_items = track_context_menu.items();
1699         edit_items.clear();
1700
1701         add_bus_context_items (edit_items);
1702         return &track_context_menu;
1703 }
1704
1705 Menu*
1706 Editor::build_track_region_context_menu ()
1707 {
1708         using namespace Menu_Helpers;
1709         MenuList& edit_items  = track_region_context_menu.items();
1710         edit_items.clear();
1711
1712         /* we've just cleared the track region context menu, so the menu that these
1713            two items were on will have disappeared; stop them dangling.
1714         */
1715         region_edit_menu_split_item = 0;
1716         region_edit_menu_split_multichannel_item = 0;
1717
1718         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (clicked_axisview);
1719
1720         if (rtv) {
1721                 boost::shared_ptr<Track> tr;
1722                 boost::shared_ptr<Playlist> pl;
1723
1724                 if ((tr = rtv->track())) {
1725                         add_region_context_items (edit_items, tr);
1726                 }
1727         }
1728
1729         add_dstream_context_items (edit_items);
1730
1731         return &track_region_context_menu;
1732 }
1733
1734 void
1735 Editor::loudness_analyze_region_selection ()
1736 {
1737         if (!_session) {
1738                 return;
1739         }
1740         Selection& s (PublicEditor::instance ().get_selection ());
1741         RegionSelection ars = s.regions;
1742         ARDOUR::AnalysisGraph ag (_session);
1743         framecnt_t total_work = 0;
1744
1745         for (RegionSelection::iterator j = ars.begin (); j != ars.end (); ++j) {
1746                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*j);
1747                 if (!arv) {
1748                         continue;
1749                 }
1750                 if (!boost::dynamic_pointer_cast<AudioRegion> (arv->region ())) {
1751                         continue;
1752                 }
1753                 assert (dynamic_cast<RouteTimeAxisView *> (&arv->get_time_axis_view ()));
1754                 total_work += arv->region ()->length ();
1755         }
1756
1757         SimpleProgressDialog spd (_("Region Loudness Analysis"), sigc::mem_fun (ag, &AnalysisGraph::cancel));
1758         ScopedConnection c;
1759         ag.set_total_frames (total_work);
1760         ag.Progress.connect_same_thread (c, boost::bind (&SimpleProgressDialog::update_progress, &spd, _1, _2));
1761         spd.show();
1762
1763         for (RegionSelection::iterator j = ars.begin (); j != ars.end (); ++j) {
1764                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*j);
1765                 if (!arv) {
1766                         continue;
1767                 }
1768                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> (arv->region ());
1769                 if (!ar) {
1770                         continue;
1771                 }
1772                 ag.analyze_region (ar);
1773         }
1774         spd.hide();
1775         if (!ag.canceled ()) {
1776                 ExportReport er (_("Audio Report/Analysis"), ag.results ());
1777                 er.run();
1778         }
1779 }
1780
1781 void
1782 Editor::loudness_analyze_range_selection ()
1783 {
1784         if (!_session) {
1785                 return;
1786         }
1787         Selection& s (PublicEditor::instance ().get_selection ());
1788         TimeSelection ts = s.time;
1789         ARDOUR::AnalysisGraph ag (_session);
1790         framecnt_t total_work = 0;
1791
1792         for (TrackSelection::iterator i = s.tracks.begin (); i != s.tracks.end (); ++i) {
1793                 boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist> ((*i)->playlist ());
1794                 if (!pl) {
1795                         continue;
1796                 }
1797                 RouteUI *rui = dynamic_cast<RouteUI *> (*i);
1798                 if (!pl || !rui) {
1799                         continue;
1800                 }
1801                 for (std::list<AudioRange>::iterator j = ts.begin (); j != ts.end (); ++j) {
1802                         total_work += j->length ();
1803                 }
1804         }
1805
1806         SimpleProgressDialog spd (_("Range Loudness Analysis"), sigc::mem_fun (ag, &AnalysisGraph::cancel));
1807         ScopedConnection c;
1808         ag.set_total_frames (total_work);
1809         ag.Progress.connect_same_thread (c, boost::bind (&SimpleProgressDialog::update_progress, &spd, _1, _2));
1810         spd.show();
1811
1812         for (TrackSelection::iterator i = s.tracks.begin (); i != s.tracks.end (); ++i) {
1813                 boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist> ((*i)->playlist ());
1814                 if (!pl) {
1815                         continue;
1816                 }
1817                 RouteUI *rui = dynamic_cast<RouteUI *> (*i);
1818                 if (!pl || !rui) {
1819                         continue;
1820                 }
1821                 ag.analyze_range (rui->route (), pl, ts);
1822         }
1823         spd.hide();
1824         if (!ag.canceled ()) {
1825                 ExportReport er (_("Audio Report/Analysis"), ag.results ());
1826                 er.run();
1827         }
1828 }
1829
1830 void
1831 Editor::spectral_analyze_region_selection ()
1832 {
1833         if (analysis_window == 0) {
1834                 analysis_window = new AnalysisWindow();
1835
1836                 if (_session != 0)
1837                         analysis_window->set_session(_session);
1838
1839                 analysis_window->show_all();
1840         }
1841
1842         analysis_window->set_regionmode();
1843         analysis_window->analyze();
1844
1845         analysis_window->present();
1846 }
1847
1848 void
1849 Editor::spectral_analyze_range_selection()
1850 {
1851         if (analysis_window == 0) {
1852                 analysis_window = new AnalysisWindow();
1853
1854                 if (_session != 0)
1855                         analysis_window->set_session(_session);
1856
1857                 analysis_window->show_all();
1858         }
1859
1860         analysis_window->set_rangemode();
1861         analysis_window->analyze();
1862
1863         analysis_window->present();
1864 }
1865
1866 Menu*
1867 Editor::build_track_selection_context_menu ()
1868 {
1869         using namespace Menu_Helpers;
1870         MenuList& edit_items  = track_selection_context_menu.items();
1871         edit_items.clear ();
1872
1873         add_selection_context_items (edit_items);
1874         // edit_items.push_back (SeparatorElem());
1875         // add_dstream_context_items (edit_items);
1876
1877         return &track_selection_context_menu;
1878 }
1879
1880 void
1881 Editor::add_region_context_items (Menu_Helpers::MenuList& edit_items, boost::shared_ptr<Track> track)
1882 {
1883         using namespace Menu_Helpers;
1884
1885         /* OK, stick the region submenu at the top of the list, and then add
1886            the standard items.
1887         */
1888
1889         RegionSelection rs = get_regions_from_selection_and_entered ();
1890
1891         string menu_item_name = (rs.size() == 1) ? rs.front()->region()->name() : _("Selected Regions");
1892
1893         if (_popup_region_menu_item == 0) {
1894                 _popup_region_menu_item = new MenuItem (menu_item_name, false);
1895                 _popup_region_menu_item->set_submenu (*dynamic_cast<Menu*> (ActionManager::get_widget (X_("/PopupRegionMenu"))));
1896                 _popup_region_menu_item->show ();
1897         } else {
1898                 _popup_region_menu_item->set_label (menu_item_name);
1899         }
1900
1901         /* No layering allowed in later is higher layering model */
1902         RefPtr<Action> act = ActionManager::get_action (X_("EditorMenu"), X_("RegionMenuLayering"));
1903         if (act && Config->get_layer_model() == LaterHigher) {
1904                 act->set_sensitive (false);
1905         } else if (act) {
1906                 act->set_sensitive (true);
1907         }
1908
1909         const framepos_t position = get_preferred_edit_position (EDIT_IGNORE_NONE, true);
1910
1911         edit_items.push_back (*_popup_region_menu_item);
1912         if (Config->get_layer_model() == Manual && track->playlist()->count_regions_at (position) > 1 && (layering_order_editor == 0 || !layering_order_editor->is_visible ())) {
1913                 edit_items.push_back (*manage (_region_actions->get_action ("choose-top-region-context-menu")->create_menu_item ()));
1914         }
1915         edit_items.push_back (SeparatorElem());
1916 }
1917
1918 /** Add context menu items relevant to selection ranges.
1919  * @param edit_items List to add the items to.
1920  */
1921 void
1922 Editor::add_selection_context_items (Menu_Helpers::MenuList& edit_items)
1923 {
1924         using namespace Menu_Helpers;
1925
1926         edit_items.push_back (MenuElem (_("Play Range"), sigc::mem_fun(*this, &Editor::play_selection)));
1927         edit_items.push_back (MenuElem (_("Loop Range"), sigc::bind (sigc::mem_fun(*this, &Editor::set_loop_from_selection), true)));
1928
1929         edit_items.push_back (SeparatorElem());
1930         edit_items.push_back (MenuElem (_("Zoom to Range"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), Horizontal)));
1931
1932         edit_items.push_back (SeparatorElem());
1933         edit_items.push_back (MenuElem (_("Loudness Analysis"), sigc::mem_fun(*this, &Editor::loudness_analyze_range_selection)));
1934         edit_items.push_back (MenuElem (_("Spectral Analysis"), sigc::mem_fun(*this, &Editor::spectral_analyze_range_selection)));
1935
1936         edit_items.push_back (SeparatorElem());
1937
1938         edit_items.push_back (
1939                 MenuElem (
1940                         _("Move Range Start to Previous Region Boundary"),
1941                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), false, false)
1942                         )
1943                 );
1944
1945         edit_items.push_back (
1946                 MenuElem (
1947                         _("Move Range Start to Next Region Boundary"),
1948                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), false, true)
1949                         )
1950                 );
1951
1952         edit_items.push_back (
1953                 MenuElem (
1954                         _("Move Range End to Previous Region Boundary"),
1955                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), true, false)
1956                         )
1957                 );
1958
1959         edit_items.push_back (
1960                 MenuElem (
1961                         _("Move Range End to Next Region Boundary"),
1962                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), true, true)
1963                         )
1964                 );
1965
1966         edit_items.push_back (SeparatorElem());
1967         edit_items.push_back (MenuElem (_("Separate"), mem_fun(*this, &Editor::separate_region_from_selection)));
1968         edit_items.push_back (MenuElem (_("Convert to Region in Region List"), sigc::mem_fun(*this, &Editor::new_region_from_selection)));
1969
1970         edit_items.push_back (SeparatorElem());
1971         edit_items.push_back (MenuElem (_("Select All in Range"), sigc::mem_fun(*this, &Editor::select_all_selectables_using_time_selection)));
1972
1973         edit_items.push_back (SeparatorElem());
1974         edit_items.push_back (MenuElem (_("Set Loop from Selection"), sigc::bind (sigc::mem_fun(*this, &Editor::set_loop_from_selection), false)));
1975         edit_items.push_back (MenuElem (_("Set Punch from Selection"), sigc::mem_fun(*this, &Editor::set_punch_from_selection)));
1976         edit_items.push_back (MenuElem (_("Set Session Start/End from Selection"), sigc::mem_fun(*this, &Editor::set_session_extents_from_selection)));
1977
1978         edit_items.push_back (SeparatorElem());
1979         edit_items.push_back (MenuElem (_("Add Range Markers"), sigc::mem_fun (*this, &Editor::add_location_from_selection)));
1980
1981         edit_items.push_back (SeparatorElem());
1982         edit_items.push_back (MenuElem (_("Crop Region to Range"), sigc::mem_fun(*this, &Editor::crop_region_to_selection)));
1983         edit_items.push_back (MenuElem (_("Duplicate Range"), sigc::bind (sigc::mem_fun(*this, &Editor::duplicate_range), false)));
1984
1985         edit_items.push_back (SeparatorElem());
1986         edit_items.push_back (MenuElem (_("Consolidate Range"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, false)));
1987         edit_items.push_back (MenuElem (_("Consolidate Range with Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, true)));
1988         edit_items.push_back (MenuElem (_("Bounce Range to Region List"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, false)));
1989         edit_items.push_back (MenuElem (_("Bounce Range to Region List with Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, true)));
1990         edit_items.push_back (MenuElem (_("Export Range..."), sigc::mem_fun(*this, &Editor::export_selection)));
1991         if (ARDOUR_UI::instance()->video_timeline->get_duration() > 0) {
1992                 edit_items.push_back (MenuElem (_("Export Video Range..."), sigc::bind (sigc::mem_fun(*(ARDOUR_UI::instance()), &ARDOUR_UI::export_video), true)));
1993         }
1994 }
1995
1996
1997 void
1998 Editor::add_dstream_context_items (Menu_Helpers::MenuList& edit_items)
1999 {
2000         using namespace Menu_Helpers;
2001
2002         /* Playback */
2003
2004         Menu *play_menu = manage (new Menu);
2005         MenuList& play_items = play_menu->items();
2006         play_menu->set_name ("ArdourContextMenu");
2007
2008         play_items.push_back (MenuElem (_("Play from Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
2009         play_items.push_back (MenuElem (_("Play from Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
2010         play_items.push_back (MenuElem (_("Play Region"), sigc::mem_fun(*this, &Editor::play_selected_region)));
2011         play_items.push_back (SeparatorElem());
2012         play_items.push_back (MenuElem (_("Loop Region"), sigc::bind (sigc::mem_fun (*this, &Editor::set_loop_from_region), true)));
2013
2014         edit_items.push_back (MenuElem (_("Play"), *play_menu));
2015
2016         /* Selection */
2017
2018         Menu *select_menu = manage (new Menu);
2019         MenuList& select_items = select_menu->items();
2020         select_menu->set_name ("ArdourContextMenu");
2021
2022         select_items.push_back (MenuElem (_("Select All in Track"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_in_track), Selection::Set)));
2023         select_items.push_back (MenuElem (_("Select All Objects"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_objects), Selection::Set)));
2024         select_items.push_back (MenuElem (_("Invert Selection in Track"), sigc::mem_fun(*this, &Editor::invert_selection_in_track)));
2025         select_items.push_back (MenuElem (_("Invert Selection"), sigc::mem_fun(*this, &Editor::invert_selection)));
2026         select_items.push_back (SeparatorElem());
2027         select_items.push_back (MenuElem (_("Set Range to Loop Range"), sigc::mem_fun(*this, &Editor::set_selection_from_loop)));
2028         select_items.push_back (MenuElem (_("Set Range to Punch Range"), sigc::mem_fun(*this, &Editor::set_selection_from_punch)));
2029         select_items.push_back (MenuElem (_("Set Range to Selected Regions"), sigc::mem_fun(*this, &Editor::set_selection_from_region)));
2030         select_items.push_back (SeparatorElem());
2031         select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true, true)));
2032         select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false, true)));
2033         select_items.push_back (MenuElem (_("Select All After Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
2034         select_items.push_back (MenuElem (_("Select All Before Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
2035         select_items.push_back (MenuElem (_("Select All Between Playhead and Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_between), false)));
2036         select_items.push_back (MenuElem (_("Select All Within Playhead and Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_between), true)));
2037         select_items.push_back (MenuElem (_("Select Range Between Playhead and Edit Point"), sigc::mem_fun(*this, &Editor::select_range_between)));
2038
2039         edit_items.push_back (MenuElem (_("Select"), *select_menu));
2040
2041         /* Cut-n-Paste */
2042
2043         Menu *cutnpaste_menu = manage (new Menu);
2044         MenuList& cutnpaste_items = cutnpaste_menu->items();
2045         cutnpaste_menu->set_name ("ArdourContextMenu");
2046
2047         cutnpaste_items.push_back (MenuElem (_("Cut"), sigc::mem_fun(*this, &Editor::cut)));
2048         cutnpaste_items.push_back (MenuElem (_("Copy"), sigc::mem_fun(*this, &Editor::copy)));
2049         cutnpaste_items.push_back (MenuElem (_("Paste"), sigc::bind (sigc::mem_fun(*this, &Editor::paste), 1.0f, true)));
2050
2051         cutnpaste_items.push_back (SeparatorElem());
2052
2053         cutnpaste_items.push_back (MenuElem (_("Align"), sigc::bind (sigc::mem_fun (*this, &Editor::align_regions), ARDOUR::SyncPoint)));
2054         cutnpaste_items.push_back (MenuElem (_("Align Relative"), sigc::bind (sigc::mem_fun (*this, &Editor::align_regions_relative), ARDOUR::SyncPoint)));
2055
2056         edit_items.push_back (MenuElem (_("Edit"), *cutnpaste_menu));
2057
2058         /* Adding new material */
2059
2060         edit_items.push_back (SeparatorElem());
2061         edit_items.push_back (MenuElem (_("Insert Selected Region"), sigc::bind (sigc::mem_fun(*this, &Editor::insert_region_list_selection), 1.0f)));
2062         edit_items.push_back (MenuElem (_("Insert Existing Media"), sigc::bind (sigc::mem_fun(*this, &Editor::add_external_audio_action), ImportToTrack)));
2063
2064         /* Nudge track */
2065
2066         Menu *nudge_menu = manage (new Menu());
2067         MenuList& nudge_items = nudge_menu->items();
2068         nudge_menu->set_name ("ArdourContextMenu");
2069
2070         edit_items.push_back (SeparatorElem());
2071         nudge_items.push_back (MenuElem (_("Nudge Entire Track Later"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, true))));
2072         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Later"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, true))));
2073         nudge_items.push_back (MenuElem (_("Nudge Entire Track Earlier"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, false))));
2074         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Earlier"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, false))));
2075
2076         edit_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
2077 }
2078
2079 void
2080 Editor::add_bus_context_items (Menu_Helpers::MenuList& edit_items)
2081 {
2082         using namespace Menu_Helpers;
2083
2084         /* Playback */
2085
2086         Menu *play_menu = manage (new Menu);
2087         MenuList& play_items = play_menu->items();
2088         play_menu->set_name ("ArdourContextMenu");
2089
2090         play_items.push_back (MenuElem (_("Play from Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
2091         play_items.push_back (MenuElem (_("Play from Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
2092         edit_items.push_back (MenuElem (_("Play"), *play_menu));
2093
2094         /* Selection */
2095
2096         Menu *select_menu = manage (new Menu);
2097         MenuList& select_items = select_menu->items();
2098         select_menu->set_name ("ArdourContextMenu");
2099
2100         select_items.push_back (MenuElem (_("Select All in Track"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_in_track), Selection::Set)));
2101         select_items.push_back (MenuElem (_("Select All Objects"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_objects), Selection::Set)));
2102         select_items.push_back (MenuElem (_("Invert Selection in Track"), sigc::mem_fun(*this, &Editor::invert_selection_in_track)));
2103         select_items.push_back (MenuElem (_("Invert Selection"), sigc::mem_fun(*this, &Editor::invert_selection)));
2104         select_items.push_back (SeparatorElem());
2105         select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true, true)));
2106         select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false, true)));
2107         select_items.push_back (MenuElem (_("Select All After Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
2108         select_items.push_back (MenuElem (_("Select All Before Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
2109
2110         edit_items.push_back (MenuElem (_("Select"), *select_menu));
2111
2112         /* Cut-n-Paste */
2113
2114         Menu *cutnpaste_menu = manage (new Menu);
2115         MenuList& cutnpaste_items = cutnpaste_menu->items();
2116         cutnpaste_menu->set_name ("ArdourContextMenu");
2117
2118         cutnpaste_items.push_back (MenuElem (_("Cut"), sigc::mem_fun(*this, &Editor::cut)));
2119         cutnpaste_items.push_back (MenuElem (_("Copy"), sigc::mem_fun(*this, &Editor::copy)));
2120         cutnpaste_items.push_back (MenuElem (_("Paste"), sigc::bind (sigc::mem_fun(*this, &Editor::paste), 1.0f, true)));
2121
2122         Menu *nudge_menu = manage (new Menu());
2123         MenuList& nudge_items = nudge_menu->items();
2124         nudge_menu->set_name ("ArdourContextMenu");
2125
2126         edit_items.push_back (SeparatorElem());
2127         nudge_items.push_back (MenuElem (_("Nudge Entire Track Later"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, true))));
2128         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Later"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, true))));
2129         nudge_items.push_back (MenuElem (_("Nudge Entire Track Earlier"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, false))));
2130         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Earlier"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, false))));
2131
2132         edit_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
2133 }
2134
2135 SnapType
2136 Editor::snap_type() const
2137 {
2138         return _snap_type;
2139 }
2140
2141 bool
2142 Editor::snap_musical() const
2143 {
2144         switch (_snap_type) {
2145         case SnapToBeatDiv128:
2146         case SnapToBeatDiv64:
2147         case SnapToBeatDiv32:
2148         case SnapToBeatDiv28:
2149         case SnapToBeatDiv24:
2150         case SnapToBeatDiv20:
2151         case SnapToBeatDiv16:
2152         case SnapToBeatDiv14:
2153         case SnapToBeatDiv12:
2154         case SnapToBeatDiv10:
2155         case SnapToBeatDiv8:
2156         case SnapToBeatDiv7:
2157         case SnapToBeatDiv6:
2158         case SnapToBeatDiv5:
2159         case SnapToBeatDiv4:
2160         case SnapToBeatDiv3:
2161         case SnapToBeatDiv2:
2162         case SnapToBeat:
2163         case SnapToBar:
2164                 return true;
2165         default:
2166                 break;
2167         }
2168
2169         return false;
2170 }
2171
2172 SnapMode
2173 Editor::snap_mode() const
2174 {
2175         return _snap_mode;
2176 }
2177
2178 void
2179 Editor::set_snap_to (SnapType st)
2180 {
2181         unsigned int snap_ind = (unsigned int)st;
2182
2183         if (internal_editing()) {
2184                 internal_snap_type = st;
2185         } else {
2186                 pre_internal_snap_type = st;
2187         }
2188
2189         _snap_type = st;
2190
2191         if (snap_ind > snap_type_strings.size() - 1) {
2192                 snap_ind = 0;
2193                 _snap_type = (SnapType)snap_ind;
2194         }
2195
2196         string str = snap_type_strings[snap_ind];
2197
2198         if (str != snap_type_selector.get_text()) {
2199                 snap_type_selector.set_text (str);
2200         }
2201
2202         instant_save ();
2203
2204         switch (_snap_type) {
2205         case SnapToBeatDiv128:
2206         case SnapToBeatDiv64:
2207         case SnapToBeatDiv32:
2208         case SnapToBeatDiv28:
2209         case SnapToBeatDiv24:
2210         case SnapToBeatDiv20:
2211         case SnapToBeatDiv16:
2212         case SnapToBeatDiv14:
2213         case SnapToBeatDiv12:
2214         case SnapToBeatDiv10:
2215         case SnapToBeatDiv8:
2216         case SnapToBeatDiv7:
2217         case SnapToBeatDiv6:
2218         case SnapToBeatDiv5:
2219         case SnapToBeatDiv4:
2220         case SnapToBeatDiv3:
2221         case SnapToBeatDiv2: {
2222                 compute_bbt_ruler_scale (leftmost_frame, leftmost_frame + current_page_samples());
2223                 update_tempo_based_rulers ();
2224                 break;
2225         }
2226
2227         case SnapToRegionStart:
2228         case SnapToRegionEnd:
2229         case SnapToRegionSync:
2230         case SnapToRegionBoundary:
2231                 build_region_boundary_cache ();
2232                 break;
2233
2234         default:
2235                 /* relax */
2236                 break;
2237         }
2238
2239         redisplay_tempo (false);
2240
2241         SnapChanged (); /* EMIT SIGNAL */
2242 }
2243
2244 void
2245 Editor::set_snap_mode (SnapMode mode)
2246 {
2247         string str = snap_mode_strings[(int)mode];
2248
2249         if (internal_editing()) {
2250                 internal_snap_mode = mode;
2251         } else {
2252                 pre_internal_snap_mode = mode;
2253         }
2254
2255         _snap_mode = mode;
2256
2257         if (str != snap_mode_selector.get_text ()) {
2258                 snap_mode_selector.set_text (str);
2259         }
2260
2261         instant_save ();
2262 }
2263
2264 void
2265 Editor::set_edit_point_preference (EditPoint ep, bool force)
2266 {
2267         bool changed = (_edit_point != ep);
2268
2269         _edit_point = ep;
2270         if (Profile->get_mixbus())
2271                 if (ep == EditAtSelectedMarker)
2272                         ep = EditAtPlayhead;
2273
2274         string str = edit_point_strings[(int)ep];
2275         if (str != edit_point_selector.get_text ()) {
2276                 edit_point_selector.set_text (str);
2277         }
2278
2279         update_all_enter_cursors();
2280
2281         if (!force && !changed) {
2282                 return;
2283         }
2284
2285         const char* action=NULL;
2286
2287         switch (_edit_point) {
2288         case EditAtPlayhead:
2289                 action = "edit-at-playhead";
2290                 break;
2291         case EditAtSelectedMarker:
2292                 action = "edit-at-marker";
2293                 break;
2294         case EditAtMouse:
2295                 action = "edit-at-mouse";
2296                 break;
2297         }
2298
2299         Glib::RefPtr<Action> act = ActionManager::get_action ("Editor", action);
2300         if (act) {
2301                 Glib::RefPtr<RadioAction>::cast_dynamic(act)->set_active (true);
2302         }
2303
2304         framepos_t foo;
2305         bool in_track_canvas;
2306
2307         if (!mouse_frame (foo, in_track_canvas)) {
2308                 in_track_canvas = false;
2309         }
2310
2311         reset_canvas_action_sensitivity (in_track_canvas);
2312         sensitize_the_right_region_actions (false);
2313
2314         instant_save ();
2315 }
2316
2317 int
2318 Editor::set_state (const XMLNode& node, int version)
2319 {
2320         set_id (node);
2321         PBD::Unwinder<bool> nsi (no_save_instant, true);
2322         bool yn;
2323
2324         Tabbable::set_state (node, version);
2325
2326         framepos_t ph_pos;
2327         if (_session && node.get_property ("playhead", ph_pos)) {
2328                 if (ph_pos >= 0) {
2329                         playhead_cursor->set_position (ph_pos);
2330                 } else {
2331                         warning << _("Playhead position stored with a negative value - ignored (use zero instead)") << endmsg;
2332                         playhead_cursor->set_position (0);
2333                 }
2334         } else {
2335                 playhead_cursor->set_position (0);
2336         }
2337
2338         node.get_property ("mixer-width", editor_mixer_strip_width);
2339
2340         node.get_property ("zoom-focus", zoom_focus);
2341         zoom_focus_selection_done (zoom_focus);
2342
2343         double z;
2344         if (node.get_property ("zoom", z)) {
2345                 /* older versions of ardour used floating point samples_per_pixel */
2346                 reset_zoom (llrintf (z));
2347         } else {
2348                 reset_zoom (samples_per_pixel);
2349         }
2350
2351         int32_t cnt;
2352         if (node.get_property ("visible-track-count", cnt)) {
2353                 set_visible_track_count (cnt);
2354         }
2355
2356         SnapType snap_type;
2357         if (!node.get_property ("snap-to", snap_type)) {
2358                 snap_type = _snap_type;
2359         }
2360         set_snap_to (snap_type);
2361
2362         SnapMode sm;
2363         if (node.get_property ("snap-mode", sm)) {
2364                 snap_mode_selection_done(sm);
2365                 /* set text of Dropdown. in case _snap_mode == SnapOff (default)
2366                  * snap_mode_selection_done() will only mark an already active item as active
2367                  * which does not trigger set_text().
2368                  */
2369                 set_snap_mode (sm);
2370         } else {
2371                 set_snap_mode (_snap_mode);
2372         }
2373
2374         node.get_property ("internal-snap-to", internal_snap_type);
2375         node.get_property ("internal-snap-mode", internal_snap_mode);
2376         node.get_property ("pre-internal-snap-to", pre_internal_snap_type);
2377         node.get_property ("pre-internal-snap-mode", pre_internal_snap_mode);
2378
2379         std::string mm_str;
2380         if (node.get_property ("mouse-mode", mm_str)) {
2381                 MouseMode m = str2mousemode(mm_str);
2382                 set_mouse_mode (m, true);
2383         } else {
2384                 set_mouse_mode (MouseObject, true);
2385         }
2386
2387         framepos_t lf_pos;
2388         if (node.get_property ("left-frame", lf_pos)) {
2389                 if (lf_pos < 0) {
2390                         lf_pos = 0;
2391                 }
2392                 reset_x_origin (lf_pos);
2393         }
2394
2395         double y_origin;
2396         if (node.get_property ("y-origin", y_origin)) {
2397                 reset_y_origin (y_origin);
2398         }
2399
2400         if (node.get_property ("join-object-range", yn)) {
2401                 RefPtr<Action> act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object-range"));
2402                 if (act) {
2403                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2404                         tact->set_active (!yn);
2405                         tact->set_active (yn);
2406                 }
2407                 set_mouse_mode(mouse_mode, true);
2408         }
2409
2410         EditPoint ep;
2411         if (node.get_property ("edit-point", ep)) {
2412                 set_edit_point_preference (ep, true);
2413         } else {
2414                 set_edit_point_preference (_edit_point);
2415         }
2416
2417         node.get_property ("show-measures", _show_measures);
2418
2419         if (node.get_property ("follow-playhead", yn)) {
2420                 set_follow_playhead (yn);
2421         }
2422
2423         if (node.get_property ("stationary-playhead", yn)) {
2424                 set_stationary_playhead (yn);
2425         }
2426
2427         RegionListSortType sort_type;
2428         if (node.get_property ("region-list-sort-type", sort_type)) {
2429                 _regions->reset_sort_type (sort_type, true);
2430         }
2431
2432         if (node.get_property ("show-editor-mixer", yn)) {
2433
2434                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
2435                 assert (act);
2436
2437                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2438
2439                 /* do it twice to force the change */
2440
2441                 tact->set_active (!yn);
2442                 tact->set_active (yn);
2443         }
2444
2445         if (node.get_property ("show-editor-list", yn)) {
2446
2447                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-list"));
2448                 assert (act);
2449
2450                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2451
2452                 /* do it twice to force the change */
2453
2454                 tact->set_active (!yn);
2455                 tact->set_active (yn);
2456         }
2457
2458         int32_t el_page;
2459         if (node.get_property (X_("editor-list-page"), el_page)) {
2460                 _the_notebook.set_current_page (el_page);
2461         }
2462
2463         if (node.get_property (X_("show-marker-lines"), yn)) {
2464                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-marker-lines"));
2465                 assert (act);
2466                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
2467
2468                 tact->set_active (!yn);
2469                 tact->set_active (yn);
2470         }
2471
2472         XMLNodeList children = node.children ();
2473         for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
2474                 selection->set_state (**i, Stateful::current_state_version);
2475                 _regions->set_state (**i);
2476                 _locations->set_state (**i);
2477         }
2478
2479         if (node.get_property ("maximised", yn)) {
2480                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleMaximalEditor"));
2481                 assert (act);
2482                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2483                 bool fs = tact && tact->get_active();
2484                 if (yn ^ fs) {
2485                         ActionManager::do_action ("Common", "ToggleMaximalEditor");
2486                 }
2487         }
2488
2489         framepos_t nudge_clock_value;
2490         if (node.get_property ("nudge-clock-value", nudge_clock_value)) {
2491                 nudge_clock->set (nudge_clock_value);
2492         } else {
2493                 nudge_clock->set_mode (AudioClock::Timecode);
2494                 nudge_clock->set (_session->frame_rate() * 5, true);
2495         }
2496
2497         {
2498                 /* apply state
2499                  * Not all properties may have been in XML, but
2500                  * those that are linked to a private variable may need changing
2501                  */
2502                 RefPtr<Action> act;
2503
2504                 act = ActionManager::get_action (X_("Editor"), X_("ToggleMeasureVisibility"));
2505                 if (act) {
2506                         yn = _show_measures;
2507                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2508                         /* do it twice to force the change */
2509                         tact->set_active (!yn);
2510                         tact->set_active (yn);
2511                 }
2512
2513                 act = ActionManager::get_action (X_("Editor"), X_("toggle-follow-playhead"));
2514                 yn = _follow_playhead;
2515                 if (act) {
2516                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2517                         if (tact->get_active() != yn) {
2518                                 tact->set_active (yn);
2519                         }
2520                 }
2521
2522                 act = ActionManager::get_action (X_("Editor"), X_("toggle-stationary-playhead"));
2523                 yn = _stationary_playhead;
2524                 if (act) {
2525                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2526                         if (tact->get_active() != yn) {
2527                                 tact->set_active (yn);
2528                         }
2529                 }
2530         }
2531
2532         return LuaInstance::instance()->set_state(node);
2533 }
2534
2535 XMLNode&
2536 Editor::get_state ()
2537 {
2538         XMLNode* node = new XMLNode (X_("Editor"));
2539
2540         node->set_property ("id", id().to_s ());
2541
2542         node->add_child_nocopy (Tabbable::get_state());
2543
2544         node->set_property("edit-horizontal-pane-pos", edit_pane.get_divider ());
2545         node->set_property("notebook-shrunk", _notebook_shrunk);
2546         node->set_property("edit-vertical-pane-pos", editor_summary_pane.get_divider());
2547
2548         maybe_add_mixer_strip_width (*node);
2549
2550         node->set_property ("zoom-focus", zoom_focus);
2551
2552         node->set_property ("zoom", samples_per_pixel);
2553         node->set_property ("snap-to", _snap_type);
2554         node->set_property ("snap-mode", _snap_mode);
2555         node->set_property ("internal-snap-to", internal_snap_type);
2556         node->set_property ("internal-snap-mode", internal_snap_mode);
2557         node->set_property ("pre-internal-snap-to", pre_internal_snap_type);
2558         node->set_property ("pre-internal-snap-mode", pre_internal_snap_mode);
2559         node->set_property ("edit-point", _edit_point);
2560         node->set_property ("visible-track-count", _visible_track_count);
2561
2562         node->set_property ("playhead", playhead_cursor->current_frame ());
2563         node->set_property ("left-frame", leftmost_frame);
2564         node->set_property ("y-origin", vertical_adjustment.get_value ());
2565
2566         node->set_property ("show-measures", _show_measures);
2567         node->set_property ("maximised", _maximised);
2568         node->set_property ("follow-playhead", _follow_playhead);
2569         node->set_property ("stationary-playhead", _stationary_playhead);
2570         node->set_property ("region-list-sort-type", _regions->sort_type ());
2571         node->set_property ("mouse-mode", mouse_mode);
2572         node->set_property ("join-object-range", smart_mode_action->get_active ());
2573
2574         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
2575         if (act) {
2576                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2577                 node->set_property (X_("show-editor-mixer"), tact->get_active());
2578         }
2579
2580         act = ActionManager::get_action (X_("Editor"), X_("show-editor-list"));
2581         if (act) {
2582                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2583                 node->set_property (X_("show-editor-list"), tact->get_active());
2584         }
2585
2586         node->set_property (X_("editor-list-page"), _the_notebook.get_current_page ());
2587
2588         if (button_bindings) {
2589                 XMLNode* bb = new XMLNode (X_("Buttons"));
2590                 button_bindings->save (*bb);
2591                 node->add_child_nocopy (*bb);
2592         }
2593
2594         node->set_property (X_("show-marker-lines"), _show_marker_lines);
2595
2596         node->add_child_nocopy (selection->get_state ());
2597         node->add_child_nocopy (_regions->get_state ());
2598
2599         node->set_property ("nudge-clock-value", nudge_clock->current_duration());
2600
2601         node->add_child_nocopy (LuaInstance::instance()->get_action_state());
2602         node->add_child_nocopy (LuaInstance::instance()->get_hook_state());
2603         node->add_child_nocopy (_locations->get_state ());
2604
2605         return *node;
2606 }
2607
2608 /** if @param trackview_relative_offset is true, @param y y is an offset into the trackview area, in pixel units
2609  *  if @param trackview_relative_offset is false, @param y y is a global canvas *  coordinate, in pixel units
2610  *
2611  *  @return pair: TimeAxisView that y is over, layer index.
2612  *
2613  *  TimeAxisView may be 0.  Layer index is the layer number if the TimeAxisView is valid and is
2614  *  in stacked or expanded region display mode, otherwise 0.
2615  */
2616 std::pair<TimeAxisView *, double>
2617 Editor::trackview_by_y_position (double y, bool trackview_relative_offset) const
2618 {
2619         if (!trackview_relative_offset) {
2620                 y -= _trackview_group->canvas_origin().y;
2621         }
2622
2623         if (y < 0) {
2624                 return std::make_pair ( (TimeAxisView *) 0, 0);
2625         }
2626
2627         for (TrackViewList::const_iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
2628
2629                 std::pair<TimeAxisView*, double> const r = (*iter)->covers_y_position (y);
2630
2631                 if (r.first) {
2632                         return r;
2633                 }
2634         }
2635
2636         return std::make_pair ( (TimeAxisView *) 0, 0);
2637 }
2638
2639 /** Snap a position to the grid, if appropriate, taking into account current
2640  *  grid settings and also the state of any snap modifier keys that may be pressed.
2641  *  @param start Position to snap.
2642  *  @param event Event to get current key modifier information from, or 0.
2643  */
2644 void
2645 Editor::snap_to_with_modifier (MusicFrame& start, GdkEvent const * event, RoundMode direction, bool for_mark)
2646 {
2647         if (!_session || !event) {
2648                 return;
2649         }
2650
2651         if (ArdourKeyboard::indicates_snap (event->button.state)) {
2652                 if (_snap_mode == SnapOff) {
2653                         snap_to_internal (start, direction, for_mark);
2654                 } else {
2655                         start.set (start.frame, 0);
2656                 }
2657         } else {
2658                 if (_snap_mode != SnapOff) {
2659                         snap_to_internal (start, direction, for_mark);
2660                 } else if (ArdourKeyboard::indicates_snap_delta (event->button.state)) {
2661                         /* SnapOff, but we pressed the snap_delta modifier */
2662                         snap_to_internal (start, direction, for_mark);
2663                 } else {
2664                         start.set (start.frame, 0);
2665                 }
2666         }
2667 }
2668
2669 void
2670 Editor::snap_to (MusicFrame& start, RoundMode direction, bool for_mark, bool ensure_snap)
2671 {
2672         if (!_session || (_snap_mode == SnapOff && !ensure_snap)) {
2673                 start.set (start.frame, 0);
2674                 return;
2675         }
2676
2677         snap_to_internal (start, direction, for_mark, ensure_snap);
2678 }
2679
2680 void
2681 Editor::timecode_snap_to_internal (MusicFrame& pos, RoundMode direction, bool /*for_mark*/)
2682 {
2683         framepos_t start = pos.frame;
2684         const framepos_t one_timecode_second = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->samples_per_timecode_frame());
2685         framepos_t one_timecode_minute = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->samples_per_timecode_frame() * 60);
2686
2687         switch (_snap_type) {
2688         case SnapToTimecodeFrame:
2689                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2690                     fmod((double)start, (double)_session->samples_per_timecode_frame()) == 0) {
2691                         /* start is already on a whole timecode frame, do nothing */
2692                 } else if (((direction == 0) && (fmod((double)start, (double)_session->samples_per_timecode_frame()) > (_session->samples_per_timecode_frame() / 2))) || (direction > 0)) {
2693                         start = (framepos_t) (ceil ((double) start / _session->samples_per_timecode_frame()) * _session->samples_per_timecode_frame());
2694                 } else {
2695                         start = (framepos_t) (floor ((double) start / _session->samples_per_timecode_frame()) *  _session->samples_per_timecode_frame());
2696                 }
2697                 break;
2698
2699         case SnapToTimecodeSeconds:
2700                 if (_session->config.get_timecode_offset_negative()) {
2701                         start += _session->config.get_timecode_offset ();
2702                 } else {
2703                         start -= _session->config.get_timecode_offset ();
2704                 }
2705                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2706                     (start % one_timecode_second == 0)) {
2707                         /* start is already on a whole second, do nothing */
2708                 } else if (((direction == 0) && (start % one_timecode_second > one_timecode_second / 2)) || direction > 0) {
2709                         start = (framepos_t) ceil ((double) start / one_timecode_second) * one_timecode_second;
2710                 } else {
2711                         start = (framepos_t) floor ((double) start / one_timecode_second) * one_timecode_second;
2712                 }
2713
2714                 if (_session->config.get_timecode_offset_negative()) {
2715                         start -= _session->config.get_timecode_offset ();
2716                 } else {
2717                         start += _session->config.get_timecode_offset ();
2718                 }
2719                 break;
2720
2721         case SnapToTimecodeMinutes:
2722                 if (_session->config.get_timecode_offset_negative()) {
2723                         start += _session->config.get_timecode_offset ();
2724                 } else {
2725                         start -= _session->config.get_timecode_offset ();
2726                 }
2727                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2728                     (start % one_timecode_minute == 0)) {
2729                         /* start is already on a whole minute, do nothing */
2730                 } else if (((direction == 0) && (start % one_timecode_minute > one_timecode_minute / 2)) || direction > 0) {
2731                         start = (framepos_t) ceil ((double) start / one_timecode_minute) * one_timecode_minute;
2732                 } else {
2733                         start = (framepos_t) floor ((double) start / one_timecode_minute) * one_timecode_minute;
2734                 }
2735                 if (_session->config.get_timecode_offset_negative()) {
2736                         start -= _session->config.get_timecode_offset ();
2737                 } else {
2738                         start += _session->config.get_timecode_offset ();
2739                 }
2740                 break;
2741         default:
2742                 fatal << "Editor::smpte_snap_to_internal() called with non-timecode snap type!" << endmsg;
2743                 abort(); /*NOTREACHED*/
2744         }
2745
2746         pos.set (start, 0);
2747 }
2748
2749 void
2750 Editor::snap_to_internal (MusicFrame& start, RoundMode direction, bool for_mark, bool ensure_snap)
2751 {
2752         const framepos_t one_second = _session->frame_rate();
2753         const framepos_t one_minute = _session->frame_rate() * 60;
2754         framepos_t presnap = start.frame;
2755         framepos_t before;
2756         framepos_t after;
2757
2758         switch (_snap_type) {
2759         case SnapToTimecodeFrame:
2760         case SnapToTimecodeSeconds:
2761         case SnapToTimecodeMinutes:
2762                 return timecode_snap_to_internal (start, direction, for_mark);
2763
2764         case SnapToCDFrame:
2765                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2766                     start.frame % (one_second/75) == 0) {
2767                         /* start is already on a whole CD frame, do nothing */
2768                 } else if (((direction == 0) && (start.frame % (one_second/75) > (one_second/75) / 2)) || (direction > 0)) {
2769                         start.frame = (framepos_t) ceil ((double) start.frame / (one_second / 75)) * (one_second / 75);
2770                 } else {
2771                         start.frame = (framepos_t) floor ((double) start.frame / (one_second / 75)) * (one_second / 75);
2772                 }
2773
2774                 start.set (start.frame, 0);
2775
2776                 break;
2777
2778         case SnapToSeconds:
2779                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2780                     start.frame % one_second == 0) {
2781                         /* start is already on a whole second, do nothing */
2782                 } else if (((direction == 0) && (start.frame % one_second > one_second / 2)) || (direction > 0)) {
2783                         start.frame = (framepos_t) ceil ((double) start.frame / one_second) * one_second;
2784                 } else {
2785                         start.frame = (framepos_t) floor ((double) start.frame / one_second) * one_second;
2786                 }
2787
2788                 start.set (start.frame, 0);
2789
2790                 break;
2791
2792         case SnapToMinutes:
2793                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2794                     start.frame % one_minute == 0) {
2795                         /* start is already on a whole minute, do nothing */
2796                 } else if (((direction == 0) && (start.frame % one_minute > one_minute / 2)) || (direction > 0)) {
2797                         start.frame = (framepos_t) ceil ((double) start.frame / one_minute) * one_minute;
2798                 } else {
2799                         start.frame = (framepos_t) floor ((double) start.frame / one_minute) * one_minute;
2800                 }
2801
2802                 start.set (start.frame, 0);
2803
2804                 break;
2805
2806         case SnapToBar:
2807                 start = _session->tempo_map().round_to_bar (start.frame, direction);
2808                 break;
2809
2810         case SnapToBeat:
2811                 start = _session->tempo_map().round_to_beat (start.frame, direction);
2812                 break;
2813
2814         case SnapToBeatDiv128:
2815                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 128, direction);
2816                 break;
2817         case SnapToBeatDiv64:
2818                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 64, direction);
2819                 break;
2820         case SnapToBeatDiv32:
2821                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 32, direction);
2822                 break;
2823         case SnapToBeatDiv28:
2824                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 28, direction);
2825                 break;
2826         case SnapToBeatDiv24:
2827                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 24, direction);
2828                 break;
2829         case SnapToBeatDiv20:
2830                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 20, direction);
2831                 break;
2832         case SnapToBeatDiv16:
2833                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 16, direction);
2834                 break;
2835         case SnapToBeatDiv14:
2836                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 14, direction);
2837                 break;
2838         case SnapToBeatDiv12:
2839                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 12, direction);
2840                 break;
2841         case SnapToBeatDiv10:
2842                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 10, direction);
2843                 break;
2844         case SnapToBeatDiv8:
2845                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 8, direction);
2846                 break;
2847         case SnapToBeatDiv7:
2848                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 7, direction);
2849                 break;
2850         case SnapToBeatDiv6:
2851                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 6, direction);
2852                 break;
2853         case SnapToBeatDiv5:
2854                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 5, direction);
2855                 break;
2856         case SnapToBeatDiv4:
2857                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 4, direction);
2858                 break;
2859         case SnapToBeatDiv3:
2860                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 3, direction);
2861                 break;
2862         case SnapToBeatDiv2:
2863                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 2, direction);
2864                 break;
2865
2866         case SnapToMark:
2867                 if (for_mark) {
2868                         return;
2869                 }
2870
2871                 _session->locations()->marks_either_side (start.frame, before, after);
2872
2873                 if (before == max_framepos && after == max_framepos) {
2874                         /* No marks to snap to, so just don't snap */
2875                         return;
2876                 } else if (before == max_framepos) {
2877                         start.frame = after;
2878                 } else if (after == max_framepos) {
2879                         start.frame = before;
2880                 } else if (before != max_framepos && after != max_framepos) {
2881                         if ((direction == RoundUpMaybe || direction == RoundUpAlways))
2882                                 start.frame = after;
2883                         else if ((direction == RoundDownMaybe || direction == RoundDownAlways))
2884                                 start.frame = before;
2885                         else if (direction ==  0 ) {
2886                                 if ((start.frame - before) < (after - start.frame)) {
2887                                         start.frame = before;
2888                                 } else {
2889                                         start.frame = after;
2890                                 }
2891                         }
2892                 }
2893
2894                 start.set (start.frame, 0);
2895
2896                 break;
2897
2898         case SnapToRegionStart:
2899         case SnapToRegionEnd:
2900         case SnapToRegionSync:
2901         case SnapToRegionBoundary:
2902                 if (!region_boundary_cache.empty()) {
2903
2904                         vector<framepos_t>::iterator prev = region_boundary_cache.end ();
2905                         vector<framepos_t>::iterator next = region_boundary_cache.end ();
2906
2907                         if (direction > 0) {
2908                                 next = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start.frame);
2909                         } else {
2910                                 next = std::lower_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start.frame);
2911                         }
2912
2913                         if (next != region_boundary_cache.begin ()) {
2914                                 prev = next;
2915                                 prev--;
2916                         }
2917
2918                         framepos_t const p = (prev == region_boundary_cache.end()) ? region_boundary_cache.front () : *prev;
2919                         framepos_t const n = (next == region_boundary_cache.end()) ? region_boundary_cache.back () : *next;
2920
2921                         if (start.frame > (p + n) / 2) {
2922                                 start.frame = n;
2923                         } else {
2924                                 start.frame = p;
2925                         }
2926                 }
2927
2928                 start.set (start.frame, 0);
2929
2930                 break;
2931         }
2932
2933         switch (_snap_mode) {
2934         case SnapNormal:
2935                 return;
2936
2937         case SnapMagnetic:
2938
2939                 if (ensure_snap) {
2940                         return;
2941                 }
2942
2943                 if (presnap > start.frame) {
2944                         if (presnap > (start.frame + pixel_to_sample(snap_threshold))) {
2945                                 start.set (presnap, 0);
2946                         }
2947
2948                 } else if (presnap < start.frame) {
2949                         if (presnap < (start.frame - pixel_to_sample(snap_threshold))) {
2950                                 start.set (presnap, 0);
2951                         }
2952                 }
2953
2954         default:
2955                 /* handled at entry */
2956                 return;
2957         }
2958 }
2959
2960
2961 void
2962 Editor::setup_toolbar ()
2963 {
2964         HBox* mode_box = manage(new HBox);
2965         mode_box->set_border_width (2);
2966         mode_box->set_spacing(2);
2967
2968         HBox* mouse_mode_box = manage (new HBox);
2969         HBox* mouse_mode_hbox = manage (new HBox);
2970         VBox* mouse_mode_vbox = manage (new VBox);
2971         Alignment* mouse_mode_align = manage (new Alignment);
2972
2973         Glib::RefPtr<SizeGroup> mouse_mode_size_group = SizeGroup::create (SIZE_GROUP_VERTICAL);
2974         mouse_mode_size_group->add_widget (smart_mode_button);
2975         mouse_mode_size_group->add_widget (mouse_move_button);
2976         mouse_mode_size_group->add_widget (mouse_cut_button);
2977         mouse_mode_size_group->add_widget (mouse_select_button);
2978         mouse_mode_size_group->add_widget (mouse_timefx_button);
2979         mouse_mode_size_group->add_widget (mouse_audition_button);
2980         mouse_mode_size_group->add_widget (mouse_draw_button);
2981         mouse_mode_size_group->add_widget (mouse_content_button);
2982
2983         if (!Profile->get_mixbus()) {
2984                 mouse_mode_size_group->add_widget (zoom_in_button);
2985                 mouse_mode_size_group->add_widget (zoom_out_button);
2986                 mouse_mode_size_group->add_widget (zoom_out_full_button);
2987                 mouse_mode_size_group->add_widget (zoom_focus_selector);
2988                 mouse_mode_size_group->add_widget (tav_shrink_button);
2989                 mouse_mode_size_group->add_widget (tav_expand_button);
2990         } else {
2991                 mouse_mode_size_group->add_widget (zoom_preset_selector);
2992                 mouse_mode_size_group->add_widget (visible_tracks_selector);
2993         }
2994
2995         mouse_mode_size_group->add_widget (snap_type_selector);
2996         mouse_mode_size_group->add_widget (snap_mode_selector);
2997
2998         mouse_mode_size_group->add_widget (edit_point_selector);
2999         mouse_mode_size_group->add_widget (edit_mode_selector);
3000
3001         mouse_mode_size_group->add_widget (*nudge_clock);
3002         mouse_mode_size_group->add_widget (nudge_forward_button);
3003         mouse_mode_size_group->add_widget (nudge_backward_button);
3004
3005         mouse_mode_hbox->set_spacing (2);
3006
3007         if (!ARDOUR::Profile->get_trx()) {
3008                 mouse_mode_hbox->pack_start (smart_mode_button, false, false);
3009         }
3010
3011         mouse_mode_hbox->pack_start (mouse_move_button, false, false);
3012         mouse_mode_hbox->pack_start (mouse_select_button, false, false);
3013
3014         if (!ARDOUR::Profile->get_mixbus()) {
3015                 mouse_mode_hbox->pack_start (mouse_cut_button, false, false);
3016         }
3017
3018         if (!ARDOUR::Profile->get_trx()) {
3019                 mouse_mode_hbox->pack_start (mouse_timefx_button, false, false);
3020                 mouse_mode_hbox->pack_start (mouse_audition_button, false, false);
3021                 mouse_mode_hbox->pack_start (mouse_draw_button, false, false);
3022                 mouse_mode_hbox->pack_start (mouse_content_button, false, false);
3023         }
3024
3025         mouse_mode_vbox->pack_start (*mouse_mode_hbox);
3026
3027         mouse_mode_align->add (*mouse_mode_vbox);
3028         mouse_mode_align->set (0.5, 1.0, 0.0, 0.0);
3029
3030         mouse_mode_box->pack_start (*mouse_mode_align, false, false);
3031
3032         edit_mode_selector.set_name ("mouse mode button");
3033
3034         if (!ARDOUR::Profile->get_trx()) {
3035                 mode_box->pack_start (edit_mode_selector, false, false);
3036         }
3037
3038         mode_box->pack_start (*mouse_mode_box, false, false);
3039
3040         /* Zoom */
3041
3042         _zoom_box.set_spacing (2);
3043         _zoom_box.set_border_width (2);
3044
3045         RefPtr<Action> act;
3046
3047         zoom_preset_selector.set_name ("zoom button");
3048         zoom_preset_selector.set_icon (ArdourIcon::ZoomExpand);
3049
3050         zoom_in_button.set_name ("zoom button");
3051         zoom_in_button.set_icon (ArdourIcon::ZoomIn);
3052         act = ActionManager::get_action (X_("Editor"), X_("temporal-zoom-in"));
3053         zoom_in_button.set_related_action (act);
3054
3055         zoom_out_button.set_name ("zoom button");
3056         zoom_out_button.set_icon (ArdourIcon::ZoomOut);
3057         act = ActionManager::get_action (X_("Editor"), X_("temporal-zoom-out"));
3058         zoom_out_button.set_related_action (act);
3059
3060         zoom_out_full_button.set_name ("zoom button");
3061         zoom_out_full_button.set_icon (ArdourIcon::ZoomFull);
3062         act = ActionManager::get_action (X_("Editor"), X_("zoom-to-session"));
3063         zoom_out_full_button.set_related_action (act);
3064
3065         zoom_focus_selector.set_name ("zoom button");
3066
3067         if (ARDOUR::Profile->get_mixbus()) {
3068                 _zoom_box.pack_start (zoom_preset_selector, false, false);
3069         } else if (ARDOUR::Profile->get_trx()) {
3070                 mode_box->pack_start (zoom_out_button, false, false);
3071                 mode_box->pack_start (zoom_in_button, false, false);
3072         } else {
3073                 _zoom_box.pack_start (zoom_out_button, false, false);
3074                 _zoom_box.pack_start (zoom_in_button, false, false);
3075                 _zoom_box.pack_start (zoom_out_full_button, false, false);
3076                 _zoom_box.pack_start (zoom_focus_selector, false, false);
3077         }
3078
3079         /* Track zoom buttons */
3080         _track_box.set_spacing (2);
3081         _track_box.set_border_width (2);
3082
3083         visible_tracks_selector.set_name ("zoom button");
3084         if (Profile->get_mixbus()) {
3085                 visible_tracks_selector.set_icon (ArdourIcon::TimeAxisExpand);
3086         } else {
3087                 set_size_request_to_display_given_text (visible_tracks_selector, _("All"), 30, 2);
3088         }
3089
3090         tav_expand_button.set_name ("zoom button");
3091         tav_expand_button.set_icon (ArdourIcon::TimeAxisExpand);
3092         act = ActionManager::get_action (X_("Editor"), X_("expand-tracks"));
3093         tav_expand_button.set_related_action (act);
3094
3095         tav_shrink_button.set_name ("zoom button");
3096         tav_shrink_button.set_icon (ArdourIcon::TimeAxisShrink);
3097         act = ActionManager::get_action (X_("Editor"), X_("shrink-tracks"));
3098         tav_shrink_button.set_related_action (act);
3099
3100         if (ARDOUR::Profile->get_mixbus()) {
3101                 _track_box.pack_start (visible_tracks_selector);
3102         } else if (ARDOUR::Profile->get_trx()) {
3103                 _track_box.pack_start (tav_shrink_button);
3104                 _track_box.pack_start (tav_expand_button);
3105         } else {
3106                 _track_box.pack_start (visible_tracks_selector);
3107                 _track_box.pack_start (tav_shrink_button);
3108                 _track_box.pack_start (tav_expand_button);
3109         }
3110
3111         snap_box.set_spacing (2);
3112         snap_box.set_border_width (2);
3113
3114         snap_type_selector.set_name ("mouse mode button");
3115
3116         snap_mode_selector.set_name ("mouse mode button");
3117
3118         edit_point_selector.set_name ("mouse mode button");
3119
3120         snap_box.pack_start (snap_mode_selector, false, false);
3121         snap_box.pack_start (snap_type_selector, false, false);
3122
3123         /* Edit Point*/
3124         HBox *ep_box = manage (new HBox);
3125         ep_box->set_spacing (2);
3126         ep_box->set_border_width (2);
3127
3128         ep_box->pack_start (edit_point_selector, false, false);
3129
3130         /* Nudge */
3131
3132         HBox *nudge_box = manage (new HBox);
3133         nudge_box->set_spacing (2);
3134         nudge_box->set_border_width (2);
3135
3136         nudge_forward_button.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::nudge_forward_release), false);
3137         nudge_backward_button.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::nudge_backward_release), false);
3138
3139         nudge_box->pack_start (nudge_backward_button, false, false);
3140         nudge_box->pack_start (nudge_forward_button, false, false);
3141         nudge_box->pack_start (*nudge_clock, false, false);
3142
3143
3144         /* Pack everything in... */
3145
3146         toolbar_hbox.set_spacing (2);
3147         toolbar_hbox.set_border_width (2);
3148
3149         toolbar_hbox.pack_start (*mode_box, false, false);
3150
3151         if (!ARDOUR::Profile->get_trx()) {
3152
3153                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3154
3155                 toolbar_hbox.pack_start (_zoom_box, false, false);
3156
3157                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3158
3159                 toolbar_hbox.pack_start (_track_box, false, false);
3160
3161                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3162
3163                 toolbar_hbox.pack_start (snap_box, false, false);
3164
3165                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3166
3167                 toolbar_hbox.pack_start (*ep_box, false, false);
3168
3169                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3170
3171                 toolbar_hbox.pack_start (*nudge_box, false, false);
3172         }
3173
3174         toolbar_hbox.show_all ();
3175 }
3176
3177 void
3178 Editor::build_edit_point_menu ()
3179 {
3180         using namespace Menu_Helpers;
3181
3182         edit_point_selector.AddMenuElem (MenuElem ( edit_point_strings[(int)EditAtPlayhead], sigc::bind (sigc::mem_fun(*this, &Editor::edit_point_selection_done), (EditPoint) EditAtPlayhead)));
3183         if(!Profile->get_mixbus())
3184                 edit_point_selector.AddMenuElem (MenuElem ( edit_point_strings[(int)EditAtSelectedMarker], sigc::bind (sigc::mem_fun(*this, &Editor::edit_point_selection_done), (EditPoint) EditAtSelectedMarker)));
3185         edit_point_selector.AddMenuElem (MenuElem ( edit_point_strings[(int)EditAtMouse], sigc::bind (sigc::mem_fun(*this, &Editor::edit_point_selection_done), (EditPoint) EditAtMouse)));
3186
3187         set_size_request_to_display_given_text (edit_point_selector, edit_point_strings, COMBO_TRIANGLE_WIDTH, 2);
3188 }
3189
3190 void
3191 Editor::build_edit_mode_menu ()
3192 {
3193         using namespace Menu_Helpers;
3194
3195         edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Slide], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Slide)));
3196 //      edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Splice], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Splice)));
3197         edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Ripple], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Ripple)));
3198         edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Lock], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode)  Lock)));
3199
3200         set_size_request_to_display_given_text (edit_mode_selector, edit_mode_strings, COMBO_TRIANGLE_WIDTH, 2);
3201 }
3202
3203 void
3204 Editor::build_snap_mode_menu ()
3205 {
3206         using namespace Menu_Helpers;
3207
3208         snap_mode_selector.AddMenuElem (MenuElem ( snap_mode_strings[(int)SnapOff], sigc::bind (sigc::mem_fun(*this, &Editor::snap_mode_selection_done), (SnapMode) SnapOff)));
3209         snap_mode_selector.AddMenuElem (MenuElem ( snap_mode_strings[(int)SnapNormal], sigc::bind (sigc::mem_fun(*this, &Editor::snap_mode_selection_done), (SnapMode) SnapNormal)));
3210         snap_mode_selector.AddMenuElem (MenuElem ( snap_mode_strings[(int)SnapMagnetic], sigc::bind (sigc::mem_fun(*this, &Editor::snap_mode_selection_done), (SnapMode) SnapMagnetic)));
3211
3212         set_size_request_to_display_given_text (snap_mode_selector, snap_mode_strings, COMBO_TRIANGLE_WIDTH, 2);
3213 }
3214
3215 void
3216 Editor::build_snap_type_menu ()
3217 {
3218         using namespace Menu_Helpers;
3219
3220         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToCDFrame], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToCDFrame)));
3221         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToTimecodeFrame], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToTimecodeFrame)));
3222         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToTimecodeSeconds], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToTimecodeSeconds)));
3223         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToTimecodeMinutes], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToTimecodeMinutes)));
3224         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToSeconds], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToSeconds)));
3225         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToMinutes], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToMinutes)));
3226         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv128], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv128)));
3227         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv64], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv64)));
3228         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv32], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv32)));
3229         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv28], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv28)));
3230         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv24], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv24)));
3231         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv20], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv20)));
3232         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv16], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv16)));
3233         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv14], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv14)));
3234         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv12], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv12)));
3235         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv10], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv10)));
3236         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv8], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv8)));
3237         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv7], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv7)));
3238         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv6], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv6)));
3239         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv5], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv5)));
3240         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv4], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv4)));
3241         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv3], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv3)));
3242         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv2], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv2)));
3243         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeat], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeat)));
3244         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBar], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBar)));
3245         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToMark], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToMark)));
3246         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToRegionStart], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToRegionStart)));
3247         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToRegionEnd], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToRegionEnd)));
3248         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToRegionSync], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToRegionSync)));
3249         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToRegionBoundary], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToRegionBoundary)));
3250
3251         set_size_request_to_display_given_text (snap_type_selector, snap_type_strings, COMBO_TRIANGLE_WIDTH, 2);
3252
3253 }
3254
3255 void
3256 Editor::setup_tooltips ()
3257 {
3258         set_tooltip (smart_mode_button, _("Smart Mode (add range functions to Grab Mode)"));
3259         set_tooltip (mouse_move_button, _("Grab Mode (select/move objects)"));
3260         set_tooltip (mouse_cut_button, _("Cut Mode (split regions)"));
3261         set_tooltip (mouse_select_button, _("Range Mode (select time ranges)"));
3262         set_tooltip (mouse_draw_button, _("Draw Mode (draw and edit gain/notes/automation)"));
3263         set_tooltip (mouse_timefx_button, _("Stretch Mode (time-stretch audio and midi regions, preserving pitch)"));
3264         set_tooltip (mouse_audition_button, _("Audition Mode (listen to regions)"));
3265         set_tooltip (mouse_content_button, _("Internal Edit Mode (edit notes and automation points)"));
3266         set_tooltip (*_group_tabs, _("Groups: click to (de)activate\nContext-click for other operations"));
3267         set_tooltip (nudge_forward_button, _("Nudge Region/Selection Later"));
3268         set_tooltip (nudge_backward_button, _("Nudge Region/Selection Earlier"));
3269         set_tooltip (zoom_in_button, _("Zoom In"));
3270         set_tooltip (zoom_out_button, _("Zoom Out"));
3271         set_tooltip (zoom_preset_selector, _("Zoom to Time Scale"));
3272         set_tooltip (zoom_out_full_button, _("Zoom to Session"));
3273         set_tooltip (zoom_focus_selector, _("Zoom Focus"));
3274         set_tooltip (tav_expand_button, _("Expand Tracks"));
3275         set_tooltip (tav_shrink_button, _("Shrink Tracks"));
3276         set_tooltip (visible_tracks_selector, _("Number of visible tracks"));
3277         set_tooltip (snap_type_selector, _("Snap/Grid Units"));
3278         set_tooltip (snap_mode_selector, _("Snap/Grid Mode"));
3279         set_tooltip (edit_point_selector, _("Edit Point"));
3280         set_tooltip (edit_mode_selector, _("Edit Mode"));
3281         set_tooltip (nudge_clock, _("Nudge Clock\n(controls distance used to nudge regions and selections)"));
3282 }
3283
3284 int
3285 Editor::convert_drop_to_paths (
3286                 vector<string>&                paths,
3287                 const RefPtr<Gdk::DragContext>& /*context*/,
3288                 gint                            /*x*/,
3289                 gint                            /*y*/,
3290                 const SelectionData&            data,
3291                 guint                           /*info*/,
3292                 guint                           /*time*/)
3293 {
3294         if (_session == 0) {
3295                 return -1;
3296         }
3297
3298         vector<string> uris = data.get_uris();
3299
3300         if (uris.empty()) {
3301
3302                 /* This is seriously fucked up. Nautilus doesn't say that its URI lists
3303                    are actually URI lists. So do it by hand.
3304                 */
3305
3306                 if (data.get_target() != "text/plain") {
3307                         return -1;
3308                 }
3309
3310                 /* Parse the "uri-list" format that Nautilus provides,
3311                    where each pathname is delimited by \r\n.
3312
3313                    THERE MAY BE NO NULL TERMINATING CHAR!!!
3314                 */
3315
3316                 string txt = data.get_text();
3317                 char* p;
3318                 const char* q;
3319
3320                 p = (char *) malloc (txt.length() + 1);
3321                 txt.copy (p, txt.length(), 0);
3322                 p[txt.length()] = '\0';
3323
3324                 while (p)
3325                 {
3326                         if (*p != '#')
3327                         {
3328                                 while (g_ascii_isspace (*p))
3329                                         p++;
3330
3331                                 q = p;
3332                                 while (*q && (*q != '\n') && (*q != '\r')) {
3333                                         q++;
3334                                 }
3335
3336                                 if (q > p)
3337                                 {
3338                                         q--;
3339                                         while (q > p && g_ascii_isspace (*q))
3340                                                 q--;
3341
3342                                         if (q > p)
3343                                         {
3344                                                 uris.push_back (string (p, q - p + 1));
3345                                         }
3346                                 }
3347                         }
3348                         p = strchr (p, '\n');
3349                         if (p)
3350                                 p++;
3351                 }
3352
3353                 free ((void*)p);
3354
3355                 if (uris.empty()) {
3356                         return -1;
3357                 }
3358         }
3359
3360         for (vector<string>::iterator i = uris.begin(); i != uris.end(); ++i) {
3361                 if ((*i).substr (0,7) == "file://") {
3362                         paths.push_back (Glib::filename_from_uri (*i));
3363                 }
3364         }
3365
3366         return 0;
3367 }
3368
3369 void
3370 Editor::new_tempo_section ()
3371 {
3372 }
3373
3374 void
3375 Editor::map_transport_state ()
3376 {
3377         ENSURE_GUI_THREAD (*this, &Editor::map_transport_state);
3378
3379         if (_session && _session->transport_stopped()) {
3380                 have_pending_keyboard_selection = false;
3381         }
3382
3383         update_loop_range_view ();
3384 }
3385
3386 void
3387 Editor::transport_looped ()
3388 {
3389         /* reset Playhead position interpolation.
3390          * see Editor::super_rapid_screen_update
3391          */
3392         _last_update_time = 0;
3393 }
3394
3395 /* UNDO/REDO */
3396
3397 void
3398 Editor::begin_selection_op_history ()
3399 {
3400         selection_op_cmd_depth = 0;
3401         selection_op_history_it = 0;
3402
3403         while(!selection_op_history.empty()) {
3404                 delete selection_op_history.front();
3405                 selection_op_history.pop_front();
3406         }
3407
3408         selection_undo_action->set_sensitive (false);
3409         selection_redo_action->set_sensitive (false);
3410         selection_op_history.push_front (&_selection_memento->get_state ());
3411 }
3412
3413 void
3414 Editor::begin_reversible_selection_op (string name)
3415 {
3416         if (_session) {
3417                 //cerr << name << endl;
3418                 /* begin/commit pairs can be nested */
3419                 selection_op_cmd_depth++;
3420         }
3421 }
3422
3423 void
3424 Editor::commit_reversible_selection_op ()
3425 {
3426         if (_session) {
3427                 if (selection_op_cmd_depth == 1) {
3428
3429                         if (selection_op_history_it > 0 && selection_op_history_it < selection_op_history.size()) {
3430                                 /**
3431                                     The user has undone some selection ops and then made a new one,
3432                                     making anything earlier in the list invalid.
3433                                 */
3434
3435                                 list<XMLNode *>::iterator it = selection_op_history.begin();
3436                                 list<XMLNode *>::iterator e_it = it;
3437                                 advance (e_it, selection_op_history_it);
3438
3439                                 for ( ; it != e_it; ++it) {
3440                                         delete *it;
3441                                 }
3442                                 selection_op_history.erase (selection_op_history.begin(), e_it);
3443                         }
3444
3445                         selection_op_history.push_front (&_selection_memento->get_state ());
3446                         selection_op_history_it = 0;
3447
3448                         selection_undo_action->set_sensitive (true);
3449                         selection_redo_action->set_sensitive (false);
3450                 }
3451
3452                 if (selection_op_cmd_depth > 0) {
3453                         selection_op_cmd_depth--;
3454                 }
3455         }
3456 }
3457
3458 void
3459 Editor::undo_selection_op ()
3460 {
3461         if (_session) {
3462                 selection_op_history_it++;
3463                 uint32_t n = 0;
3464                 for (std::list<XMLNode *>::iterator i = selection_op_history.begin(); i != selection_op_history.end(); ++i) {
3465                         if (n == selection_op_history_it) {
3466                                 _selection_memento->set_state (*(*i), Stateful::current_state_version);
3467                                 selection_redo_action->set_sensitive (true);
3468                         }
3469                         ++n;
3470                 }
3471                 /* is there an earlier entry? */
3472                 if ((selection_op_history_it + 1) >= selection_op_history.size()) {
3473                         selection_undo_action->set_sensitive (false);
3474                 }
3475         }
3476 }
3477
3478 void
3479 Editor::redo_selection_op ()
3480 {
3481         if (_session) {
3482                 if (selection_op_history_it > 0) {
3483                         selection_op_history_it--;
3484                 }
3485                 uint32_t n = 0;
3486                 for (std::list<XMLNode *>::iterator i = selection_op_history.begin(); i != selection_op_history.end(); ++i) {
3487                         if (n == selection_op_history_it) {
3488                                 _selection_memento->set_state (*(*i), Stateful::current_state_version);
3489                                 selection_undo_action->set_sensitive (true);
3490                         }
3491                         ++n;
3492                 }
3493
3494                 if (selection_op_history_it == 0) {
3495                         selection_redo_action->set_sensitive (false);
3496                 }
3497         }
3498 }
3499
3500 void
3501 Editor::begin_reversible_command (string name)
3502 {
3503         if (_session) {
3504                 before.push_back (&_selection_memento->get_state ());
3505                 _session->begin_reversible_command (name);
3506         }
3507 }
3508
3509 void
3510 Editor::begin_reversible_command (GQuark q)
3511 {
3512         if (_session) {
3513                 before.push_back (&_selection_memento->get_state ());
3514                 _session->begin_reversible_command (q);
3515         }
3516 }
3517
3518 void
3519 Editor::abort_reversible_command ()
3520 {
3521         if (_session) {
3522                 while(!before.empty()) {
3523                         delete before.front();
3524                         before.pop_front();
3525                 }
3526                 _session->abort_reversible_command ();
3527         }
3528 }
3529
3530 void
3531 Editor::commit_reversible_command ()
3532 {
3533         if (_session) {
3534                 if (before.size() == 1) {
3535                         _session->add_command (new MementoCommand<SelectionMemento>(*(_selection_memento), before.front(), &_selection_memento->get_state ()));
3536                         redo_action->set_sensitive(false);
3537                         undo_action->set_sensitive(true);
3538                         begin_selection_op_history ();
3539                 }
3540
3541                 if (before.empty()) {
3542                         cerr << "Please call begin_reversible_command() before commit_reversible_command()." << endl;
3543                 } else {
3544                         before.pop_back();
3545                 }
3546
3547                 _session->commit_reversible_command ();
3548         }
3549 }
3550
3551 void
3552 Editor::history_changed ()
3553 {
3554         string label;
3555
3556         if (undo_action && _session) {
3557                 if (_session->undo_depth() == 0) {
3558                         label = S_("Command|Undo");
3559                 } else {
3560                         label = string_compose(S_("Command|Undo (%1)"), _session->next_undo());
3561                 }
3562                 undo_action->property_label() = label;
3563         }
3564
3565         if (redo_action && _session) {
3566                 if (_session->redo_depth() == 0) {
3567                         label = _("Redo");
3568                         redo_action->set_sensitive (false);
3569                 } else {
3570                         label = string_compose(_("Redo (%1)"), _session->next_redo());
3571                         redo_action->set_sensitive (true);
3572                 }
3573                 redo_action->property_label() = label;
3574         }
3575 }
3576
3577 void
3578 Editor::duplicate_range (bool with_dialog)
3579 {
3580         float times = 1.0f;
3581
3582         RegionSelection rs = get_regions_from_selection_and_entered ();
3583
3584         if ( selection->time.length() == 0 && rs.empty()) {
3585                 return;
3586         }
3587
3588         if (with_dialog) {
3589
3590                 ArdourDialog win (_("Duplicate"));
3591                 Label label (_("Number of duplications:"));
3592                 Adjustment adjustment (1.0, 1.0, 1000000.0, 1.0, 5.0);
3593                 SpinButton spinner (adjustment, 0.0, 1);
3594                 HBox hbox;
3595
3596                 win.get_vbox()->set_spacing (12);
3597                 win.get_vbox()->pack_start (hbox);
3598                 hbox.set_border_width (6);
3599                 hbox.pack_start (label, PACK_EXPAND_PADDING, 12);
3600
3601                 /* dialogs have ::add_action_widget() but that puts the spinner in the wrong
3602                    place, visually. so do this by hand.
3603                 */
3604
3605                 hbox.pack_start (spinner, PACK_EXPAND_PADDING, 12);
3606                 spinner.signal_activate().connect (sigc::bind (sigc::mem_fun (win, &ArdourDialog::response), RESPONSE_ACCEPT));
3607                 spinner.grab_focus();
3608
3609                 hbox.show ();
3610                 label.show ();
3611                 spinner.show ();
3612
3613                 win.add_button (Stock::CANCEL, RESPONSE_CANCEL);
3614                 win.add_button (_("Duplicate"), RESPONSE_ACCEPT);
3615                 win.set_default_response (RESPONSE_ACCEPT);
3616
3617                 spinner.grab_focus ();
3618
3619                 switch (win.run ()) {
3620                 case RESPONSE_ACCEPT:
3621                         break;
3622                 default:
3623                         return;
3624                 }
3625
3626                 times = adjustment.get_value();
3627         }
3628
3629         if ((current_mouse_mode() == Editing::MouseRange)) {
3630                 if (selection->time.length()) {
3631                         duplicate_selection (times);
3632                 }
3633         } else if (get_smart_mode()) {
3634                 if (selection->time.length()) {
3635                         duplicate_selection (times);
3636                 } else
3637                         duplicate_some_regions (rs, times);
3638         } else {
3639                 duplicate_some_regions (rs, times);
3640         }
3641 }
3642
3643 void
3644 Editor::set_edit_mode (EditMode m)
3645 {
3646         Config->set_edit_mode (m);
3647 }
3648
3649 void
3650 Editor::cycle_edit_mode ()
3651 {
3652         switch (Config->get_edit_mode()) {
3653         case Slide:
3654                 Config->set_edit_mode (Ripple);
3655                 break;
3656         case Splice:
3657         case Ripple:
3658                 Config->set_edit_mode (Lock);
3659                 break;
3660         case Lock:
3661                 Config->set_edit_mode (Slide);
3662                 break;
3663         }
3664 }
3665
3666 void
3667 Editor::edit_mode_selection_done ( EditMode m )
3668 {
3669         Config->set_edit_mode ( m );
3670 }
3671
3672 void
3673 Editor::snap_type_selection_done (SnapType snaptype)
3674 {
3675         RefPtr<RadioAction> ract = snap_type_action (snaptype);
3676         if (ract) {
3677                 ract->set_active ();
3678         }
3679 }
3680
3681 void
3682 Editor::snap_mode_selection_done (SnapMode mode)
3683 {
3684         RefPtr<RadioAction> ract = snap_mode_action (mode);
3685
3686         if (ract) {
3687                 ract->set_active (true);
3688         }
3689 }
3690
3691 void
3692 Editor::cycle_edit_point (bool with_marker)
3693 {
3694         if(Profile->get_mixbus())
3695                 with_marker = false;
3696
3697         switch (_edit_point) {
3698         case EditAtMouse:
3699                 set_edit_point_preference (EditAtPlayhead);
3700                 break;
3701         case EditAtPlayhead:
3702                 if (with_marker) {
3703                         set_edit_point_preference (EditAtSelectedMarker);
3704                 } else {
3705                         set_edit_point_preference (EditAtMouse);
3706                 }
3707                 break;
3708         case EditAtSelectedMarker:
3709                 set_edit_point_preference (EditAtMouse);
3710                 break;
3711         }
3712 }
3713
3714 void
3715 Editor::edit_point_selection_done (EditPoint ep)
3716 {
3717         set_edit_point_preference ( ep );
3718 }
3719
3720 void
3721 Editor::build_zoom_focus_menu ()
3722 {
3723         using namespace Menu_Helpers;
3724
3725         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusLeft], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusLeft)));
3726         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusRight], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusRight)));
3727         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusCenter], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusCenter)));
3728         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusPlayhead], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusPlayhead)));
3729         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusMouse], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusMouse)));
3730         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusEdit], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusEdit)));
3731
3732         set_size_request_to_display_given_text (zoom_focus_selector, zoom_focus_strings, COMBO_TRIANGLE_WIDTH, 2);
3733 }
3734
3735 void
3736 Editor::zoom_focus_selection_done ( ZoomFocus f )
3737 {
3738         RefPtr<RadioAction> ract = zoom_focus_action (f);
3739         if (ract) {
3740                 ract->set_active ();
3741         }
3742 }
3743
3744 void
3745 Editor::build_track_count_menu ()
3746 {
3747         using namespace Menu_Helpers;
3748
3749         if (!Profile->get_mixbus()) {
3750                 visible_tracks_selector.AddMenuElem (MenuElem (X_("1"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 1)));
3751                 visible_tracks_selector.AddMenuElem (MenuElem (X_("2"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 2)));
3752                 visible_tracks_selector.AddMenuElem (MenuElem (X_("3"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 3)));
3753                 visible_tracks_selector.AddMenuElem (MenuElem (X_("4"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 4)));
3754                 visible_tracks_selector.AddMenuElem (MenuElem (X_("8"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 8)));
3755                 visible_tracks_selector.AddMenuElem (MenuElem (X_("12"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 12)));
3756                 visible_tracks_selector.AddMenuElem (MenuElem (X_("16"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 16)));
3757                 visible_tracks_selector.AddMenuElem (MenuElem (X_("20"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 20)));
3758                 visible_tracks_selector.AddMenuElem (MenuElem (X_("24"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 24)));
3759                 visible_tracks_selector.AddMenuElem (MenuElem (X_("32"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 32)));
3760                 visible_tracks_selector.AddMenuElem (MenuElem (X_("64"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 64)));
3761                 visible_tracks_selector.AddMenuElem (MenuElem (_("Selection"), sigc::mem_fun(*this, &Editor::fit_selection)));
3762                 visible_tracks_selector.AddMenuElem (MenuElem (_("All"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 0)));
3763         } else {
3764                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 1 track"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 1)));
3765                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 2 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 2)));
3766                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 4 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 4)));
3767                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 8 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 8)));
3768                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 16 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 16)));
3769                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 24 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 24)));
3770                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 32 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 32)));
3771                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 48 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 48)));
3772                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit All tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 0)));
3773                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit Selection"), sigc::mem_fun(*this, &Editor::fit_selection)));
3774
3775                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 10 ms"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 10)));
3776                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 100 ms"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 100)));
3777                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 1 sec"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 1 * 1000)));
3778                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 10 sec"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 10 * 1000)));
3779                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 1 min"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 60 * 1000)));
3780                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 10 min"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 10 * 60 * 1000)));
3781                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 1 hour"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 60 * 60 * 1000)));
3782                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 8 hours"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 8 * 60 * 60 * 1000)));
3783                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 24 hours"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 24 * 60 * 60 * 1000)));
3784                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to Session"), sigc::mem_fun(*this, &Editor::temporal_zoom_session)));
3785                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to Extents"), sigc::mem_fun(*this, &Editor::temporal_zoom_extents)));
3786                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to Range/Region Selection"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), Horizontal)));
3787         }
3788 }
3789
3790 void
3791 Editor::set_zoom_preset (int64_t ms)
3792 {
3793         if ( ms <= 0 ) {
3794                 temporal_zoom_session();
3795                 return;
3796         }
3797
3798         ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
3799         temporal_zoom( (sample_rate * ms / 1000) / _visible_canvas_width );
3800 }
3801
3802 void
3803 Editor::set_visible_track_count (int32_t n)
3804 {
3805         _visible_track_count = n;
3806
3807         /* if the canvas hasn't really been allocated any size yet, just
3808            record the desired number of visible tracks and return. when canvas
3809            allocation happens, we will get called again and then we can do the
3810            real work.
3811         */
3812
3813         if (_visible_canvas_height <= 1) {
3814                 return;
3815         }
3816
3817         int h;
3818         string str;
3819         DisplaySuspender ds;
3820
3821         if (_visible_track_count > 0) {
3822                 h = trackviews_height() / _visible_track_count;
3823                 std::ostringstream s;
3824                 s << _visible_track_count;
3825                 str = s.str();
3826         } else if (_visible_track_count == 0) {
3827                 uint32_t n = 0;
3828                 for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
3829                         if ((*i)->marked_for_display()) {
3830                                 ++n;
3831                                 TimeAxisView::Children cl ((*i)->get_child_list ());
3832                                 for (TimeAxisView::Children::const_iterator j = cl.begin(); j != cl.end(); ++j) {
3833                                         if ((*j)->marked_for_display()) {
3834                                                 ++n;
3835                                         }
3836                                 }
3837                         }
3838                 }
3839                 if (n == 0) {
3840                         visible_tracks_selector.set_text (X_("*"));
3841                         return;
3842                 }
3843                 h = trackviews_height() / n;
3844                 str = _("All");
3845         } else {
3846                 /* negative value means that the visible track count has
3847                    been overridden by explicit track height changes.
3848                 */
3849                 visible_tracks_selector.set_text (X_("*"));
3850                 return;
3851         }
3852
3853         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
3854                 (*i)->set_height (h, TimeAxisView::HeightPerLane);
3855         }
3856
3857         if (str != visible_tracks_selector.get_text()) {
3858                 visible_tracks_selector.set_text (str);
3859         }
3860 }
3861
3862 void
3863 Editor::override_visible_track_count ()
3864 {
3865         _visible_track_count = -1;
3866         visible_tracks_selector.set_text ( _("*") );
3867 }
3868
3869 bool
3870 Editor::edit_controls_button_release (GdkEventButton* ev)
3871 {
3872         if (Keyboard::is_context_menu_event (ev)) {
3873                 ARDOUR_UI::instance()->add_route ();
3874         } else if (ev->button == 1) {
3875                 selection->clear_tracks ();
3876         }
3877
3878         return true;
3879 }
3880
3881 bool
3882 Editor::mouse_select_button_release (GdkEventButton* ev)
3883 {
3884         /* this handles just right-clicks */
3885
3886         if (ev->button != 3) {
3887                 return false;
3888         }
3889
3890         return true;
3891 }
3892
3893 void
3894 Editor::set_zoom_focus (ZoomFocus f)
3895 {
3896         string str = zoom_focus_strings[(int)f];
3897
3898         if (str != zoom_focus_selector.get_text()) {
3899                 zoom_focus_selector.set_text (str);
3900         }
3901
3902         if (zoom_focus != f) {
3903                 zoom_focus = f;
3904                 instant_save ();
3905         }
3906 }
3907
3908 void
3909 Editor::cycle_zoom_focus ()
3910 {
3911         switch (zoom_focus) {
3912         case ZoomFocusLeft:
3913                 set_zoom_focus (ZoomFocusRight);
3914                 break;
3915         case ZoomFocusRight:
3916                 set_zoom_focus (ZoomFocusCenter);
3917                 break;
3918         case ZoomFocusCenter:
3919                 set_zoom_focus (ZoomFocusPlayhead);
3920                 break;
3921         case ZoomFocusPlayhead:
3922                 set_zoom_focus (ZoomFocusMouse);
3923                 break;
3924         case ZoomFocusMouse:
3925                 set_zoom_focus (ZoomFocusEdit);
3926                 break;
3927         case ZoomFocusEdit:
3928                 set_zoom_focus (ZoomFocusLeft);
3929                 break;
3930         }
3931 }
3932
3933 void
3934 Editor::set_show_measures (bool yn)
3935 {
3936         if (_show_measures != yn) {
3937                 hide_measures ();
3938
3939                 if ((_show_measures = yn) == true) {
3940                         if (tempo_lines) {
3941                                 tempo_lines->show();
3942                         }
3943
3944                         std::vector<TempoMap::BBTPoint> grid;
3945                         compute_current_bbt_points (grid, leftmost_frame, leftmost_frame + current_page_samples());
3946                         draw_measures (grid);
3947                 }
3948
3949                 instant_save ();
3950         }
3951 }
3952
3953 void
3954 Editor::toggle_follow_playhead ()
3955 {
3956         RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-follow-playhead"));
3957         if (act) {
3958                 RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
3959                 set_follow_playhead (tact->get_active());
3960         }
3961 }
3962
3963 /** @param yn true to follow playhead, otherwise false.
3964  *  @param catch_up true to reset the editor view to show the playhead (if yn == true), otherwise false.
3965  */
3966 void
3967 Editor::set_follow_playhead (bool yn, bool catch_up)
3968 {
3969         if (_follow_playhead != yn) {
3970                 if ((_follow_playhead = yn) == true && catch_up) {
3971                         /* catch up */
3972                         reset_x_origin_to_follow_playhead ();
3973                 }
3974                 instant_save ();
3975         }
3976 }
3977
3978 void
3979 Editor::toggle_stationary_playhead ()
3980 {
3981         RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-stationary-playhead"));
3982         if (act) {
3983                 RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
3984                 set_stationary_playhead (tact->get_active());
3985         }
3986 }
3987
3988 void
3989 Editor::set_stationary_playhead (bool yn)
3990 {
3991         if (_stationary_playhead != yn) {
3992                 if ((_stationary_playhead = yn) == true) {
3993                         /* catch up */
3994                         // FIXME need a 3.0 equivalent of this 2.X call
3995                         // update_current_screen ();
3996                 }
3997                 instant_save ();
3998         }
3999 }
4000
4001 PlaylistSelector&
4002 Editor::playlist_selector () const
4003 {
4004         return *_playlist_selector;
4005 }
4006
4007 framecnt_t
4008 Editor::get_paste_offset (framepos_t pos, unsigned paste_count, framecnt_t duration)
4009 {
4010         if (paste_count == 0) {
4011                 /* don't bother calculating an offset that will be zero anyway */
4012                 return 0;
4013         }
4014
4015         /* calculate basic unsnapped multi-paste offset */
4016         framecnt_t offset = paste_count * duration;
4017
4018         /* snap offset so pos + offset is aligned to the grid */
4019         MusicFrame offset_pos (pos + offset, 0);
4020         snap_to(offset_pos, RoundUpMaybe);
4021         offset = offset_pos.frame - pos;
4022
4023         return offset;
4024 }
4025
4026 unsigned
4027 Editor::get_grid_beat_divisions(framepos_t position)
4028 {
4029         switch (_snap_type) {
4030         case SnapToBeatDiv128: return 128;
4031         case SnapToBeatDiv64:  return 64;
4032         case SnapToBeatDiv32:  return 32;
4033         case SnapToBeatDiv28:  return 28;
4034         case SnapToBeatDiv24:  return 24;
4035         case SnapToBeatDiv20:  return 20;
4036         case SnapToBeatDiv16:  return 16;
4037         case SnapToBeatDiv14:  return 14;
4038         case SnapToBeatDiv12:  return 12;
4039         case SnapToBeatDiv10:  return 10;
4040         case SnapToBeatDiv8:   return 8;
4041         case SnapToBeatDiv7:   return 7;
4042         case SnapToBeatDiv6:   return 6;
4043         case SnapToBeatDiv5:   return 5;
4044         case SnapToBeatDiv4:   return 4;
4045         case SnapToBeatDiv3:   return 3;
4046         case SnapToBeatDiv2:   return 2;
4047         default:               return 0;
4048         }
4049         return 0;
4050 }
4051
4052 /** returns the current musical grid divisiions using the supplied modifier mask from a GtkEvent.
4053     if the grid is non-musical, returns 0.
4054     if the grid is snapped to bars, returns -1.
4055     @param event_state the current keyboard modifier mask.
4056 */
4057 int32_t
4058 Editor::get_grid_music_divisions (uint32_t event_state)
4059 {
4060         if (snap_mode() == Editing::SnapOff && !ArdourKeyboard::indicates_snap (event_state)) {
4061                 return 0;
4062         }
4063
4064         if (snap_mode() != Editing::SnapOff && ArdourKeyboard::indicates_snap (event_state)) {
4065                 return 0;
4066         }
4067
4068         switch (_snap_type) {
4069         case SnapToBeatDiv128: return 128;
4070         case SnapToBeatDiv64:  return 64;
4071         case SnapToBeatDiv32:  return 32;
4072         case SnapToBeatDiv28:  return 28;
4073         case SnapToBeatDiv24:  return 24;
4074         case SnapToBeatDiv20:  return 20;
4075         case SnapToBeatDiv16:  return 16;
4076         case SnapToBeatDiv14:  return 14;
4077         case SnapToBeatDiv12:  return 12;
4078         case SnapToBeatDiv10:  return 10;
4079         case SnapToBeatDiv8:   return 8;
4080         case SnapToBeatDiv7:   return 7;
4081         case SnapToBeatDiv6:   return 6;
4082         case SnapToBeatDiv5:   return 5;
4083         case SnapToBeatDiv4:   return 4;
4084         case SnapToBeatDiv3:   return 3;
4085         case SnapToBeatDiv2:   return 2;
4086         case SnapToBeat:       return 1;
4087         case SnapToBar :       return -1;
4088         default:               return 0;
4089         }
4090         return 0;
4091 }
4092
4093 Evoral::Beats
4094 Editor::get_grid_type_as_beats (bool& success, framepos_t position)
4095 {
4096         success = true;
4097
4098         const unsigned divisions = get_grid_beat_divisions(position);
4099         if (divisions) {
4100                 return Evoral::Beats(1.0 / (double)get_grid_beat_divisions(position));
4101         }
4102
4103         switch (_snap_type) {
4104         case SnapToBeat:
4105                 return Evoral::Beats(4.0 / _session->tempo_map().meter_at_frame (position).note_divisor());
4106         case SnapToBar:
4107                 if (_session) {
4108                         const Meter& m = _session->tempo_map().meter_at_frame (position);
4109                         return Evoral::Beats((4.0 * m.divisions_per_bar()) / m.note_divisor());
4110                 }
4111                 break;
4112         default:
4113                 success = false;
4114                 break;
4115         }
4116
4117         return Evoral::Beats();
4118 }
4119
4120 framecnt_t
4121 Editor::get_nudge_distance (framepos_t pos, framecnt_t& next)
4122 {
4123         framecnt_t ret;
4124
4125         ret = nudge_clock->current_duration (pos);
4126         next = ret + 1; /* XXXX fix me */
4127
4128         return ret;
4129 }
4130
4131 int
4132 Editor::playlist_deletion_dialog (boost::shared_ptr<Playlist> pl)
4133 {
4134         ArdourDialog dialog (_("Playlist Deletion"));
4135         Label  label (string_compose (_("Playlist %1 is currently unused.\n"
4136                                         "If it is kept, its audio files will not be cleaned.\n"
4137                                         "If it is deleted, audio files used by it alone will be cleaned."),
4138                                       pl->name()));
4139
4140         dialog.set_position (WIN_POS_CENTER);
4141         dialog.get_vbox()->pack_start (label);
4142
4143         label.show ();
4144
4145         dialog.add_button (_("Delete All Unused"), RESPONSE_YES); // needs clarification. this and all remaining ones
4146         dialog.add_button (_("Delete Playlist"), RESPONSE_ACCEPT);
4147         Button* keep = dialog.add_button (_("Keep Playlist"), RESPONSE_REJECT);
4148         dialog.add_button (_("Keep Remaining"), RESPONSE_NO); // ditto
4149         dialog.add_button (_("Cancel"), RESPONSE_CANCEL);
4150
4151         // by default gtk uses the left most button
4152         keep->grab_focus ();
4153
4154         switch (dialog.run ()) {
4155         case RESPONSE_NO:
4156                 /* keep this and all remaining ones */
4157                 return -2;
4158                 break;
4159
4160         case RESPONSE_YES:
4161                 /* delete this and all others */
4162                 return 2;
4163                 break;
4164
4165         case RESPONSE_ACCEPT:
4166                 /* delete the playlist */
4167                 return 1;
4168                 break;
4169
4170         case RESPONSE_REJECT:
4171                 /* keep the playlist */
4172                 return 0;
4173                 break;
4174
4175         default:
4176                 break;
4177         }
4178
4179         return -1;
4180 }
4181
4182 bool
4183 Editor::audio_region_selection_covers (framepos_t where)
4184 {
4185         for (RegionSelection::iterator a = selection->regions.begin(); a != selection->regions.end(); ++a) {
4186                 if ((*a)->region()->covers (where)) {
4187                         return true;
4188                 }
4189         }
4190
4191         return false;
4192 }
4193
4194 void
4195 Editor::prepare_for_cleanup ()
4196 {
4197         cut_buffer->clear_regions ();
4198         cut_buffer->clear_playlists ();
4199
4200         selection->clear_regions ();
4201         selection->clear_playlists ();
4202
4203         _regions->suspend_redisplay ();
4204 }
4205
4206 void
4207 Editor::finish_cleanup ()
4208 {
4209         _regions->resume_redisplay ();
4210 }
4211
4212 Location*
4213 Editor::transport_loop_location()
4214 {
4215         if (_session) {
4216                 return _session->locations()->auto_loop_location();
4217         } else {
4218                 return 0;
4219         }
4220 }
4221
4222 Location*
4223 Editor::transport_punch_location()
4224 {
4225         if (_session) {
4226                 return _session->locations()->auto_punch_location();
4227         } else {
4228                 return 0;
4229         }
4230 }
4231
4232 bool
4233 Editor::control_layout_scroll (GdkEventScroll* ev)
4234 {
4235         /* Just forward to the normal canvas scroll method. The coordinate
4236            systems are different but since the canvas is always larger than the
4237            track headers, and aligned with the trackview area, this will work.
4238
4239            In the not too distant future this layout is going away anyway and
4240            headers will be on the canvas.
4241         */
4242         return canvas_scroll_event (ev, false);
4243 }
4244
4245 void
4246 Editor::session_state_saved (string)
4247 {
4248         update_title ();
4249         _snapshots->redisplay ();
4250 }
4251
4252 void
4253 Editor::maximise_editing_space ()
4254 {
4255         if (_maximised) {
4256                 return;
4257         }
4258
4259         Gtk::Window* toplevel = current_toplevel();
4260
4261         if (toplevel) {
4262                 toplevel->fullscreen ();
4263                 _maximised = true;
4264         }
4265 }
4266
4267 void
4268 Editor::restore_editing_space ()
4269 {
4270         if (!_maximised) {
4271                 return;
4272         }
4273
4274         Gtk::Window* toplevel = current_toplevel();
4275
4276         if (toplevel) {
4277                 toplevel->unfullscreen();
4278                 _maximised = false;
4279         }
4280 }
4281
4282 /**
4283  *  Make new playlists for a given track and also any others that belong
4284  *  to the same active route group with the `select' property.
4285  *  @param v Track.
4286  */
4287
4288 void
4289 Editor::new_playlists (TimeAxisView* v)
4290 {
4291         begin_reversible_command (_("new playlists"));
4292         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4293         _session->playlists->get (playlists);
4294         mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::group_select.property_id);
4295         commit_reversible_command ();
4296 }
4297
4298 /**
4299  *  Use a copy of the current playlist for a given track and also any others that belong
4300  *  to the same active route group with the `select' property.
4301  *  @param v Track.
4302  */
4303
4304 void
4305 Editor::copy_playlists (TimeAxisView* v)
4306 {
4307         begin_reversible_command (_("copy playlists"));
4308         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4309         _session->playlists->get (playlists);
4310         mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::group_select.property_id);
4311         commit_reversible_command ();
4312 }
4313
4314 /** Clear the current playlist for a given track and also any others that belong
4315  *  to the same active route group with the `select' property.
4316  *  @param v Track.
4317  */
4318
4319 void
4320 Editor::clear_playlists (TimeAxisView* v)
4321 {
4322         begin_reversible_command (_("clear playlists"));
4323         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4324         _session->playlists->get (playlists);
4325         mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::group_select.property_id);
4326         commit_reversible_command ();
4327 }
4328
4329 void
4330 Editor::mapped_use_new_playlist (RouteTimeAxisView& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
4331 {
4332         atv.use_new_playlist (sz > 1 ? false : true, playlists, false);
4333 }
4334
4335 void
4336 Editor::mapped_use_copy_playlist (RouteTimeAxisView& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
4337 {
4338         atv.use_new_playlist (sz > 1 ? false : true, playlists, true);
4339 }
4340
4341 void
4342 Editor::mapped_clear_playlist (RouteTimeAxisView& atv, uint32_t /*sz*/)
4343 {
4344         atv.clear_playlist ();
4345 }
4346
4347 double
4348 Editor::get_y_origin () const
4349 {
4350         return vertical_adjustment.get_value ();
4351 }
4352
4353 /** Queue up a change to the viewport x origin.
4354  *  @param frame New x origin.
4355  */
4356 void
4357 Editor::reset_x_origin (framepos_t frame)
4358 {
4359         pending_visual_change.add (VisualChange::TimeOrigin);
4360         pending_visual_change.time_origin = frame;
4361         ensure_visual_change_idle_handler ();
4362 }
4363
4364 void
4365 Editor::reset_y_origin (double y)
4366 {
4367         pending_visual_change.add (VisualChange::YOrigin);
4368         pending_visual_change.y_origin = y;
4369         ensure_visual_change_idle_handler ();
4370 }
4371
4372 void
4373 Editor::reset_zoom (framecnt_t spp)
4374 {
4375         if (spp == samples_per_pixel) {
4376                 return;
4377         }
4378
4379         pending_visual_change.add (VisualChange::ZoomLevel);
4380         pending_visual_change.samples_per_pixel = spp;
4381         ensure_visual_change_idle_handler ();
4382 }
4383
4384 void
4385 Editor::reposition_and_zoom (framepos_t frame, double fpu)
4386 {
4387         reset_x_origin (frame);
4388         reset_zoom (fpu);
4389
4390         if (!no_save_visual) {
4391                 undo_visual_stack.push_back (current_visual_state(false));
4392         }
4393 }
4394
4395 Editor::VisualState::VisualState (bool with_tracks)
4396         : gui_state (with_tracks ? new GUIObjectState : 0)
4397 {
4398 }
4399
4400 Editor::VisualState::~VisualState ()
4401 {
4402         delete gui_state;
4403 }
4404
4405 Editor::VisualState*
4406 Editor::current_visual_state (bool with_tracks)
4407 {
4408         VisualState* vs = new VisualState (with_tracks);
4409         vs->y_position = vertical_adjustment.get_value();
4410         vs->samples_per_pixel = samples_per_pixel;
4411         vs->leftmost_frame = leftmost_frame;
4412         vs->zoom_focus = zoom_focus;
4413
4414         if (with_tracks) {
4415                 vs->gui_state->set_state (ARDOUR_UI::instance()->gui_object_state->get_state());
4416         }
4417
4418         return vs;
4419 }
4420
4421 void
4422 Editor::undo_visual_state ()
4423 {
4424         if (undo_visual_stack.empty()) {
4425                 return;
4426         }
4427
4428         VisualState* vs = undo_visual_stack.back();
4429         undo_visual_stack.pop_back();
4430
4431
4432         redo_visual_stack.push_back (current_visual_state (vs ? vs->gui_state != 0 : false));
4433
4434         if (vs) {
4435                 use_visual_state (*vs);
4436         }
4437 }
4438
4439 void
4440 Editor::redo_visual_state ()
4441 {
4442         if (redo_visual_stack.empty()) {
4443                 return;
4444         }
4445
4446         VisualState* vs = redo_visual_stack.back();
4447         redo_visual_stack.pop_back();
4448
4449         // can 'vs' really be 0? Is there a place that puts NULL pointers onto the stack?
4450         // why do we check here?
4451         undo_visual_stack.push_back (current_visual_state (vs ? (vs->gui_state != 0) : false));
4452
4453         if (vs) {
4454                 use_visual_state (*vs);
4455         }
4456 }
4457
4458 void
4459 Editor::swap_visual_state ()
4460 {
4461         if (undo_visual_stack.empty()) {
4462                 redo_visual_state ();
4463         } else {
4464                 undo_visual_state ();
4465         }
4466 }
4467
4468 void
4469 Editor::use_visual_state (VisualState& vs)
4470 {
4471         PBD::Unwinder<bool> nsv (no_save_visual, true);
4472         DisplaySuspender ds;
4473
4474         vertical_adjustment.set_value (vs.y_position);
4475
4476         set_zoom_focus (vs.zoom_focus);
4477         reposition_and_zoom (vs.leftmost_frame, vs.samples_per_pixel);
4478
4479         if (vs.gui_state) {
4480                 ARDOUR_UI::instance()->gui_object_state->set_state (vs.gui_state->get_state());
4481
4482                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4483                         (*i)->clear_property_cache();
4484                         (*i)->reset_visual_state ();
4485                 }
4486         }
4487
4488         _routes->update_visibility ();
4489 }
4490
4491 /** This is the core function that controls the zoom level of the canvas. It is called
4492  *  whenever one or more calls are made to reset_zoom().  It executes in an idle handler.
4493  *  @param spp new number of samples per pixel
4494  */
4495 void
4496 Editor::set_samples_per_pixel (framecnt_t spp)
4497 {
4498         if (spp < 1) {
4499                 return;
4500         }
4501
4502         const framecnt_t three_days = 3 * 24 * 60 * 60 * (_session ? _session->frame_rate() : 48000);
4503         const framecnt_t lots_of_pixels = 4000;
4504
4505         /* if the zoom level is greater than what you'd get trying to display 3
4506          * days of audio on a really big screen, then it's too big.
4507          */
4508
4509         if (spp * lots_of_pixels > three_days) {
4510                 return;
4511         }
4512
4513         samples_per_pixel = spp;
4514 }
4515
4516 void
4517 Editor::on_samples_per_pixel_changed ()
4518 {
4519         if (tempo_lines) {
4520                 tempo_lines->tempo_map_changed(_session->tempo_map().music_origin());
4521         }
4522
4523         bool const showing_time_selection = selection->time.length() > 0;
4524
4525         if (showing_time_selection && selection->time.start () != selection->time.end_frame ()) {
4526                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4527                         (*i)->reshow_selection (selection->time);
4528                 }
4529         }
4530
4531         ZoomChanged (); /* EMIT_SIGNAL */
4532
4533         ArdourCanvas::GtkCanvasViewport* c;
4534
4535         c = get_track_canvas();
4536         if (c) {
4537                 c->canvas()->zoomed ();
4538         }
4539
4540         if (playhead_cursor) {
4541                 playhead_cursor->set_position (playhead_cursor->current_frame ());
4542         }
4543
4544         refresh_location_display();
4545         _summary->set_overlays_dirty ();
4546
4547         update_marker_labels ();
4548
4549         instant_save ();
4550 }
4551
4552 framepos_t
4553 Editor::playhead_cursor_sample () const
4554 {
4555         return playhead_cursor->current_frame();
4556 }
4557
4558 void
4559 Editor::queue_visual_videotimeline_update ()
4560 {
4561         pending_visual_change.add (VisualChange::VideoTimeline);
4562         ensure_visual_change_idle_handler ();
4563 }
4564
4565 void
4566 Editor::ensure_visual_change_idle_handler ()
4567 {
4568         if (pending_visual_change.idle_handler_id < 0) {
4569                 // see comment in add_to_idle_resize above.
4570                 pending_visual_change.idle_handler_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, _idle_visual_changer, this, NULL);
4571                 pending_visual_change.being_handled = false;
4572         }
4573 }
4574
4575 int
4576 Editor::_idle_visual_changer (void* arg)
4577 {
4578         return static_cast<Editor*>(arg)->idle_visual_changer ();
4579 }
4580
4581 void
4582 Editor::pre_render ()
4583 {
4584         visual_change_queued = false;
4585
4586         if (pending_visual_change.pending != 0) {
4587                 ensure_visual_change_idle_handler();
4588         }
4589 }
4590
4591 int
4592 Editor::idle_visual_changer ()
4593 {
4594         pending_visual_change.idle_handler_id = -1;
4595
4596         if (pending_visual_change.pending == 0) {
4597                 return 0;
4598         }
4599
4600         /* set_horizontal_position() below (and maybe other calls) call
4601            gtk_main_iteration(), so it's possible that a signal will be handled
4602            half-way through this method.  If this signal wants an
4603            idle_visual_changer we must schedule another one after this one, so
4604            mark the idle_handler_id as -1 here to allow that.  Also make a note
4605            that we are doing the visual change, so that changes in response to
4606            super-rapid-screen-update can be dropped if we are still processing
4607            the last one.
4608         */
4609
4610         if (visual_change_queued) {
4611                 return 0;
4612         }
4613
4614         pending_visual_change.being_handled = true;
4615
4616         VisualChange vc = pending_visual_change;
4617
4618         pending_visual_change.pending = (VisualChange::Type) 0;
4619
4620         visual_changer (vc);
4621
4622         pending_visual_change.being_handled = false;
4623
4624         visual_change_queued = true;
4625
4626         return 0; /* this is always a one-shot call */
4627 }
4628
4629 void
4630 Editor::visual_changer (const VisualChange& vc)
4631 {
4632         /**
4633          * Changed first so the correct horizontal canvas position is calculated in
4634          * Editor::set_horizontal_position
4635          */
4636         if (vc.pending & VisualChange::ZoomLevel) {
4637                 set_samples_per_pixel (vc.samples_per_pixel);
4638         }
4639
4640         if (vc.pending & VisualChange::TimeOrigin) {
4641                 double new_time_origin = sample_to_pixel_unrounded (vc.time_origin);
4642                 set_horizontal_position (new_time_origin);
4643         }
4644
4645         if (vc.pending & VisualChange::YOrigin) {
4646                 vertical_adjustment.set_value (vc.y_origin);
4647         }
4648
4649         /**
4650          * Now the canvas is in the final state before render the canvas items that
4651          * support the Item::prepare_for_render interface can calculate the correct
4652          * item to visible canvas intersection.
4653          */
4654         if (vc.pending & VisualChange::ZoomLevel) {
4655                 on_samples_per_pixel_changed ();
4656
4657                 compute_fixed_ruler_scale ();
4658
4659                 compute_bbt_ruler_scale (vc.time_origin, pending_visual_change.time_origin + current_page_samples());
4660                 update_tempo_based_rulers ();
4661         }
4662
4663         if (!(vc.pending & VisualChange::ZoomLevel)) {
4664                 /**
4665                  * If the canvas is not being zoomed then the canvas items will not change
4666                  * and cause Item::prepare_for_render to be called so do it here manually.
4667                  *
4668                  * Not ideal, but I can't think of a better solution atm.
4669                  */
4670                 _track_canvas->prepare_for_render();
4671         }
4672
4673         // If we are only scrolling vertically there is no need to update these
4674         if (vc.pending != VisualChange::YOrigin) {
4675                 update_fixed_rulers ();
4676                 redisplay_tempo (true);
4677
4678                 /* video frames & position need to be updated for zoom, horiz-scroll
4679                  * and (explicitly) VisualChange::VideoTimeline.
4680                  */
4681                 update_video_timeline();
4682         }
4683
4684         _summary->set_overlays_dirty ();
4685 }
4686
4687 struct EditorOrderTimeAxisSorter {
4688     bool operator() (const TimeAxisView* a, const TimeAxisView* b) const {
4689             return a->order () < b->order ();
4690     }
4691 };
4692
4693 void
4694 Editor::sort_track_selection (TrackViewList& sel)
4695 {
4696         EditorOrderTimeAxisSorter cmp;
4697         sel.sort (cmp);
4698 }
4699
4700 framepos_t
4701 Editor::get_preferred_edit_position (EditIgnoreOption ignore, bool from_context_menu, bool from_outside_canvas)
4702 {
4703         bool ignored;
4704         framepos_t where = 0;
4705         EditPoint ep = _edit_point;
4706
4707         if (Profile->get_mixbus()) {
4708                 if (ep == EditAtSelectedMarker) {
4709                         ep = EditAtPlayhead;
4710                 }
4711         }
4712
4713         if (from_outside_canvas && (ep == EditAtMouse)) {
4714                 ep = EditAtPlayhead;
4715         } else if (from_context_menu && (ep == EditAtMouse)) {
4716                 return canvas_event_sample (&context_click_event, 0, 0);
4717         }
4718
4719         if (entered_marker) {
4720                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use entered marker @ %1\n", entered_marker->position()));
4721                 return entered_marker->position();
4722         }
4723
4724         if ( (ignore==EDIT_IGNORE_PHEAD) && ep == EditAtPlayhead) {
4725                 ep = EditAtSelectedMarker;
4726         }
4727
4728         if ( (ignore==EDIT_IGNORE_MOUSE) && ep == EditAtMouse) {
4729                 ep = EditAtPlayhead;
4730         }
4731
4732         MusicFrame snap_mf (0, 0);
4733
4734         switch (ep) {
4735         case EditAtPlayhead:
4736                 if (_dragging_playhead && _control_scroll_target) {
4737                         where = *_control_scroll_target;
4738                 } else {
4739                         where = _session->audible_frame();
4740                 }
4741                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use playhead @ %1\n", where));
4742                 break;
4743
4744         case EditAtSelectedMarker:
4745                 if (!selection->markers.empty()) {
4746                         bool is_start;
4747                         Location* loc = find_location_from_marker (selection->markers.front(), is_start);
4748                         if (loc) {
4749                                 if (is_start) {
4750                                         where =  loc->start();
4751                                 } else {
4752                                         where = loc->end();
4753                                 }
4754                                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use selected marker @ %1\n", where));
4755                                 break;
4756                         }
4757                 }
4758                 /* fallthru */
4759
4760         default:
4761         case EditAtMouse:
4762                 if (!mouse_frame (where, ignored)) {
4763                         /* XXX not right but what can we do ? */
4764                         return 0;
4765                 }
4766                 snap_mf.frame = where;
4767                 snap_to (snap_mf);
4768                 where = snap_mf.frame;
4769                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use mouse @ %1\n", where));
4770                 break;
4771         }
4772
4773         return where;
4774 }
4775
4776 void
4777 Editor::set_loop_range (framepos_t start, framepos_t end, string cmd)
4778 {
4779         if (!_session) return;
4780
4781         begin_reversible_command (cmd);
4782
4783         Location* tll;
4784
4785         if ((tll = transport_loop_location()) == 0) {
4786                 Location* loc = new Location (*_session, start, end, _("Loop"),  Location::IsAutoLoop, get_grid_music_divisions(0));
4787                 XMLNode &before = _session->locations()->get_state();
4788                 _session->locations()->add (loc, true);
4789                 _session->set_auto_loop_location (loc);
4790                 XMLNode &after = _session->locations()->get_state();
4791                 _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
4792         } else {
4793                 XMLNode &before = tll->get_state();
4794                 tll->set_hidden (false, this);
4795                 tll->set (start, end);
4796                 XMLNode &after = tll->get_state();
4797                 _session->add_command (new MementoCommand<Location>(*tll, &before, &after));
4798         }
4799
4800         commit_reversible_command ();
4801 }
4802
4803 void
4804 Editor::set_punch_range (framepos_t start, framepos_t end, string cmd)
4805 {
4806         if (!_session) return;
4807
4808         begin_reversible_command (cmd);
4809
4810         Location* tpl;
4811
4812         if ((tpl = transport_punch_location()) == 0) {
4813                 Location* loc = new Location (*_session, start, end, _("Punch"),  Location::IsAutoPunch, get_grid_music_divisions(0));
4814                 XMLNode &before = _session->locations()->get_state();
4815                 _session->locations()->add (loc, true);
4816                 _session->set_auto_punch_location (loc);
4817                 XMLNode &after = _session->locations()->get_state();
4818                 _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
4819         } else {
4820                 XMLNode &before = tpl->get_state();
4821                 tpl->set_hidden (false, this);
4822                 tpl->set (start, end);
4823                 XMLNode &after = tpl->get_state();
4824                 _session->add_command (new MementoCommand<Location>(*tpl, &before, &after));
4825         }
4826
4827         commit_reversible_command ();
4828 }
4829
4830 /** Find regions which exist at a given time, and optionally on a given list of tracks.
4831  *  @param rs List to which found regions are added.
4832  *  @param where Time to look at.
4833  *  @param ts Tracks to look on; if this is empty, all tracks are examined.
4834  */
4835 void
4836 Editor::get_regions_at (RegionSelection& rs, framepos_t where, const TrackViewList& ts) const
4837 {
4838         const TrackViewList* tracks;
4839
4840         if (ts.empty()) {
4841                 tracks = &track_views;
4842         } else {
4843                 tracks = &ts;
4844         }
4845
4846         for (TrackViewList::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
4847
4848                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*t);
4849
4850                 if (rtv) {
4851                         boost::shared_ptr<Track> tr;
4852                         boost::shared_ptr<Playlist> pl;
4853
4854                         if ((tr = rtv->track()) && ((pl = tr->playlist()))) {
4855
4856                                 boost::shared_ptr<RegionList> regions = pl->regions_at (
4857                                                 (framepos_t) floor ( (double) where * tr->speed()));
4858
4859                                 for (RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
4860                                         RegionView* rv = rtv->view()->find_view (*i);
4861                                         if (rv) {
4862                                                 rs.add (rv);
4863                                         }
4864                                 }
4865                         }
4866                 }
4867         }
4868 }
4869
4870 void
4871 Editor::get_regions_after (RegionSelection& rs, framepos_t where, const TrackViewList& ts) const
4872 {
4873         const TrackViewList* tracks;
4874
4875         if (ts.empty()) {
4876                 tracks = &track_views;
4877         } else {
4878                 tracks = &ts;
4879         }
4880
4881         for (TrackViewList::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
4882                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*t);
4883                 if (rtv) {
4884                         boost::shared_ptr<Track> tr;
4885                         boost::shared_ptr<Playlist> pl;
4886
4887                         if ((tr = rtv->track()) && ((pl = tr->playlist()))) {
4888
4889                                 boost::shared_ptr<RegionList> regions = pl->regions_touched (
4890                                         (framepos_t) floor ( (double)where * tr->speed()), max_framepos);
4891
4892                                 for (RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
4893
4894                                         RegionView* rv = rtv->view()->find_view (*i);
4895
4896                                         if (rv) {
4897                                                 rs.add (rv);
4898                                         }
4899                                 }
4900                         }
4901                 }
4902         }
4903 }
4904
4905 /** Get regions using the following method:
4906  *
4907  *  Make a region list using:
4908  *   (a) any selected regions
4909  *   (b) the intersection of any selected tracks and the edit point(*)
4910  *   (c) if neither exists, and edit_point == mouse, then whatever region is under the mouse
4911  *
4912  *  (*) NOTE: in this case, if 'No Selection = All Tracks' is active, search all tracks
4913  *
4914  *  Note that we have forced the rule that selected regions and selected tracks are mutually exclusive
4915  */
4916
4917 RegionSelection
4918 Editor::get_regions_from_selection_and_edit_point (EditIgnoreOption ignore, bool from_context_menu, bool from_outside_canvas)
4919 {
4920         RegionSelection regions;
4921
4922         if (_edit_point == EditAtMouse && entered_regionview && selection->tracks.empty() && selection->regions.empty() ) {
4923                 regions.add (entered_regionview);
4924         } else {
4925                 regions = selection->regions;
4926         }
4927
4928         if ( regions.empty() ) {
4929                 TrackViewList tracks = selection->tracks;
4930
4931                 if (!tracks.empty()) {
4932                         /* no region selected or entered, but some selected tracks:
4933                          * act on all regions on the selected tracks at the edit point
4934                          */
4935                         framepos_t const where = get_preferred_edit_position (ignore, from_context_menu, from_outside_canvas);
4936                         get_regions_at(regions, where, tracks);
4937                 }
4938         }
4939
4940         return regions;
4941 }
4942
4943 /** Get regions using the following method:
4944  *
4945  *  Make a region list using:
4946  *   (a) any selected regions
4947  *   (b) the intersection of any selected tracks and the edit point(*)
4948  *   (c) if neither exists, then whatever region is under the mouse
4949  *
4950  *  (*) NOTE: in this case, if 'No Selection = All Tracks' is active, search all tracks
4951  *
4952  *  Note that we have forced the rule that selected regions and selected tracks are mutually exclusive
4953  */
4954 RegionSelection
4955 Editor::get_regions_from_selection_and_mouse (framepos_t pos)
4956 {
4957         RegionSelection regions;
4958
4959         if (entered_regionview && selection->tracks.empty() && selection->regions.empty() ) {
4960                 regions.add (entered_regionview);
4961         } else {
4962                 regions = selection->regions;
4963         }
4964
4965         if ( regions.empty() ) {
4966                 TrackViewList tracks = selection->tracks;
4967
4968                 if (!tracks.empty()) {
4969                         /* no region selected or entered, but some selected tracks:
4970                          * act on all regions on the selected tracks at the edit point
4971                          */
4972                         get_regions_at(regions, pos, tracks);
4973                 }
4974         }
4975
4976         return regions;
4977 }
4978
4979 /** Start with regions that are selected, or the entered regionview if none are selected.
4980  *  Then add equivalent regions on tracks in the same active edit-enabled route group as any
4981  *  of the regions that we started with.
4982  */
4983
4984 RegionSelection
4985 Editor::get_regions_from_selection_and_entered () const
4986 {
4987         RegionSelection regions = selection->regions;
4988
4989         if (regions.empty() && entered_regionview) {
4990                 regions.add (entered_regionview);
4991         }
4992
4993         return regions;
4994 }
4995
4996 void
4997 Editor::get_regionviews_by_id (PBD::ID const id, RegionSelection & regions) const
4998 {
4999         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5000                 RouteTimeAxisView* rtav;
5001
5002                 if ((rtav = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
5003                         boost::shared_ptr<Playlist> pl;
5004                         std::vector<boost::shared_ptr<Region> > results;
5005                         boost::shared_ptr<Track> tr;
5006
5007                         if ((tr = rtav->track()) == 0) {
5008                                 /* bus */
5009                                 continue;
5010                         }
5011
5012                         if ((pl = (tr->playlist())) != 0) {
5013                                 boost::shared_ptr<Region> r = pl->region_by_id (id);
5014                                 if (r) {
5015                                         RegionView* rv = rtav->view()->find_view (r);
5016                                         if (rv) {
5017                                                 regions.push_back (rv);
5018                                         }
5019                                 }
5020                         }
5021                 }
5022         }
5023 }
5024
5025 void
5026 Editor::get_per_region_note_selection (list<pair<PBD::ID, set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > > &selection) const
5027 {
5028
5029         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5030                 MidiTimeAxisView* mtav;
5031
5032                 if ((mtav = dynamic_cast<MidiTimeAxisView*> (*i)) != 0) {
5033
5034                         mtav->get_per_region_note_selection (selection);
5035                 }
5036         }
5037
5038 }
5039
5040 void
5041 Editor::get_regions_corresponding_to (boost::shared_ptr<Region> region, vector<RegionView*>& regions, bool src_comparison)
5042 {
5043         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5044
5045                 RouteTimeAxisView* tatv;
5046
5047                 if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
5048
5049                         boost::shared_ptr<Playlist> pl;
5050                         vector<boost::shared_ptr<Region> > results;
5051                         RegionView* marv;
5052                         boost::shared_ptr<Track> tr;
5053
5054                         if ((tr = tatv->track()) == 0) {
5055                                 /* bus */
5056                                 continue;
5057                         }
5058
5059                         if ((pl = (tr->playlist())) != 0) {
5060                                 if (src_comparison) {
5061                                         pl->get_source_equivalent_regions (region, results);
5062                                 } else {
5063                                         pl->get_region_list_equivalent_regions (region, results);
5064                                 }
5065                         }
5066
5067                         for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
5068                                 if ((marv = tatv->view()->find_view (*ir)) != 0) {
5069                                         regions.push_back (marv);
5070                                 }
5071                         }
5072
5073                 }
5074         }
5075 }
5076
5077 RegionView*
5078 Editor::regionview_from_region (boost::shared_ptr<Region> region) const
5079 {
5080         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5081                 RouteTimeAxisView* tatv;
5082                 if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
5083                         if (!tatv->track()) {
5084                                 continue;
5085                         }
5086                         RegionView* marv = tatv->view()->find_view (region);
5087                         if (marv) {
5088                                 return marv;
5089                         }
5090                 }
5091         }
5092         return NULL;
5093 }
5094
5095 RouteTimeAxisView*
5096 Editor::rtav_from_route (boost::shared_ptr<Route> route) const
5097 {
5098         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5099                 RouteTimeAxisView* rtav;
5100                 if ((rtav = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
5101                         if (rtav->route() == route) {
5102                                 return rtav;
5103                         }
5104                 }
5105         }
5106         return NULL;
5107 }
5108
5109 void
5110 Editor::show_rhythm_ferret ()
5111 {
5112         if (rhythm_ferret == 0) {
5113                 rhythm_ferret = new RhythmFerret(*this);
5114         }
5115
5116         rhythm_ferret->set_session (_session);
5117         rhythm_ferret->show ();
5118         rhythm_ferret->present ();
5119 }
5120
5121 void
5122 Editor::first_idle ()
5123 {
5124         MessageDialog* dialog = 0;
5125
5126         if (track_views.size() > 1) {
5127                 Timers::TimerSuspender t;
5128                 dialog = new MessageDialog (
5129                         string_compose (_("Please wait while %1 loads visual data."), PROGRAM_NAME),
5130                         true
5131                         );
5132                 dialog->present ();
5133                 ARDOUR_UI::instance()->flush_pending (60);
5134         }
5135
5136         for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
5137                 (*t)->first_idle();
5138         }
5139
5140         /* now that all regionviews should exist, setup region selection */
5141
5142         RegionSelection rs;
5143
5144         for (list<PBD::ID>::iterator pr = selection->regions.pending.begin (); pr != selection->regions.pending.end (); ++pr) {
5145                 /* this is cumulative: rs is NOT cleared each time */
5146                 get_regionviews_by_id (*pr, rs);
5147         }
5148
5149         selection->set (rs);
5150
5151         // first idle adds route children (automation tracks), so we need to redisplay here
5152         _routes->redisplay ();
5153
5154         delete dialog;
5155
5156         if (_session->undo_depth() == 0) {
5157                 undo_action->set_sensitive(false);
5158         }
5159         redo_action->set_sensitive(false);
5160         begin_selection_op_history ();
5161
5162         _have_idled = true;
5163 }
5164
5165 gboolean
5166 Editor::_idle_resize (gpointer arg)
5167 {
5168         return ((Editor*)arg)->idle_resize ();
5169 }
5170
5171 void
5172 Editor::add_to_idle_resize (TimeAxisView* view, int32_t h)
5173 {
5174         if (resize_idle_id < 0) {
5175                 /* https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#G-PRIORITY-HIGH-IDLE:CAPS
5176                  * GTK+ uses G_PRIORITY_HIGH_IDLE + 10 for resizing operations, and G_PRIORITY_HIGH_IDLE + 20 for redrawing operations.
5177                  * (This is done to ensure that any pending resizes are processed before any pending redraws, so that widgets are not redrawn twice unnecessarily.)
5178                  */
5179                 resize_idle_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, _idle_resize, this, NULL);
5180                 _pending_resize_amount = 0;
5181         }
5182
5183         /* make a note of the smallest resulting height, so that we can clamp the
5184            lower limit at TimeAxisView::hSmall */
5185
5186         int32_t min_resulting = INT32_MAX;
5187
5188         _pending_resize_amount += h;
5189         _pending_resize_view = view;
5190
5191         min_resulting = min (min_resulting, int32_t (_pending_resize_view->current_height()) + _pending_resize_amount);
5192
5193         if (selection->tracks.contains (_pending_resize_view)) {
5194                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
5195                         min_resulting = min (min_resulting, int32_t ((*i)->current_height()) + _pending_resize_amount);
5196                 }
5197         }
5198
5199         if (min_resulting < 0) {
5200                 min_resulting = 0;
5201         }
5202
5203         /* clamp */
5204         if (uint32_t (min_resulting) < TimeAxisView::preset_height (HeightSmall)) {
5205                 _pending_resize_amount += TimeAxisView::preset_height (HeightSmall) - min_resulting;
5206         }
5207 }
5208
5209 /** Handle pending resizing of tracks */
5210 bool
5211 Editor::idle_resize ()
5212 {
5213         _pending_resize_view->idle_resize (_pending_resize_view->current_height() + _pending_resize_amount);
5214
5215         if (dynamic_cast<AutomationTimeAxisView*> (_pending_resize_view) == 0 &&
5216             selection->tracks.contains (_pending_resize_view)) {
5217
5218                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
5219                         if (*i != _pending_resize_view) {
5220                                 (*i)->idle_resize ((*i)->current_height() + _pending_resize_amount);
5221                         }
5222                 }
5223         }
5224
5225         _pending_resize_amount = 0;
5226         _group_tabs->set_dirty ();
5227         resize_idle_id = -1;
5228
5229         return false;
5230 }
5231
5232 void
5233 Editor::located ()
5234 {
5235         ENSURE_GUI_THREAD (*this, &Editor::located);
5236
5237         if (_session) {
5238                 playhead_cursor->set_position (_session->audible_frame ());
5239                 if (_follow_playhead && !_pending_initial_locate) {
5240                         reset_x_origin_to_follow_playhead ();
5241                 }
5242         }
5243
5244         _pending_locate_request = false;
5245         _pending_initial_locate = false;
5246         _last_update_time = 0;
5247 }
5248
5249 void
5250 Editor::region_view_added (RegionView * rv)
5251 {
5252         MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (rv);
5253         if (mrv) {
5254                 list<pair<PBD::ID const, list<Evoral::event_id_t> > >::iterator rnote;
5255                 for (rnote = selection->pending_midi_note_selection.begin(); rnote != selection->pending_midi_note_selection.end(); ++rnote) {
5256                         if (rv->region()->id () == (*rnote).first) {
5257                                 mrv->select_notes ((*rnote).second);
5258                                 selection->pending_midi_note_selection.erase(rnote);
5259                                 break;
5260                         }
5261                 }
5262         }
5263
5264         _summary->set_background_dirty ();
5265 }
5266
5267 void
5268 Editor::region_view_removed ()
5269 {
5270         _summary->set_background_dirty ();
5271 }
5272
5273 AxisView*
5274 Editor::axis_view_by_stripable (boost::shared_ptr<Stripable> s) const
5275 {
5276         for (TrackViewList::const_iterator j = track_views.begin (); j != track_views.end(); ++j) {
5277                 if ((*j)->stripable() == s) {
5278                         return *j;
5279                 }
5280         }
5281
5282         return 0;
5283 }
5284
5285 AxisView*
5286 Editor::axis_view_by_control (boost::shared_ptr<AutomationControl> c) const
5287 {
5288         for (TrackViewList::const_iterator j = track_views.begin (); j != track_views.end(); ++j) {
5289                 if ((*j)->control() == c) {
5290                         return *j;
5291                 }
5292
5293                 TimeAxisView::Children kids = (*j)->get_child_list ();
5294
5295                 for (TimeAxisView::Children::iterator k = kids.begin(); k != kids.end(); ++k) {
5296                         if ((*k)->control() == c) {
5297                                 return (*k).get();
5298                         }
5299                 }
5300         }
5301
5302         return 0;
5303 }
5304
5305 TrackViewList
5306 Editor::axis_views_from_routes (boost::shared_ptr<RouteList> r) const
5307 {
5308         TrackViewList t;
5309
5310         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5311                 TimeAxisView* tv = time_axis_view_from_stripable (*i);
5312                 if (tv) {
5313                         t.push_back (tv);
5314                 }
5315         }
5316
5317         return t;
5318 }
5319
5320 void
5321 Editor::suspend_route_redisplay ()
5322 {
5323         if (_routes) {
5324                 _routes->suspend_redisplay();
5325         }
5326 }
5327
5328 void
5329 Editor::resume_route_redisplay ()
5330 {
5331         if (_routes) {
5332                 _routes->redisplay(); // queue redisplay
5333                 _routes->resume_redisplay();
5334         }
5335 }
5336
5337 void
5338 Editor::add_vcas (VCAList& vlist)
5339 {
5340         StripableList sl;
5341
5342         for (VCAList::iterator v = vlist.begin(); v != vlist.end(); ++v) {
5343                 sl.push_back (boost::dynamic_pointer_cast<Stripable> (*v));
5344         }
5345
5346         add_stripables (sl);
5347 }
5348
5349 void
5350 Editor::add_routes (RouteList& rlist)
5351 {
5352         StripableList sl;
5353
5354         for (RouteList::iterator r = rlist.begin(); r != rlist.end(); ++r) {
5355                 sl.push_back (*r);
5356         }
5357
5358         add_stripables (sl);
5359 }
5360
5361 void
5362 Editor::add_stripables (StripableList& sl)
5363 {
5364         list<TimeAxisView*> new_views;
5365         boost::shared_ptr<VCA> v;
5366         boost::shared_ptr<Route> r;
5367         TrackViewList new_selection;
5368         bool from_scratch = (track_views.size() == 0);
5369
5370         sl.sort (Stripable::Sorter());
5371
5372         for (StripableList::iterator s = sl.begin(); s != sl.end(); ++s) {
5373
5374                 if ((v = boost::dynamic_pointer_cast<VCA> (*s)) != 0) {
5375
5376                         VCATimeAxisView* vtv = new VCATimeAxisView (*this, _session, *_track_canvas);
5377                         vtv->set_vca (v);
5378                         new_views.push_back (vtv);
5379
5380                 } else if ((r = boost::dynamic_pointer_cast<Route> (*s)) != 0) {
5381
5382                         if (r->is_auditioner() || r->is_monitor()) {
5383                                 continue;
5384                         }
5385
5386                         RouteTimeAxisView* rtv;
5387                         DataType dt = r->input()->default_type();
5388
5389                         if (dt == ARDOUR::DataType::AUDIO) {
5390                                 rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
5391                                 rtv->set_route (r);
5392                         } else if (dt == ARDOUR::DataType::MIDI) {
5393                                 rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
5394                                 rtv->set_route (r);
5395                         } else {
5396                                 throw unknown_type();
5397                         }
5398
5399                         new_views.push_back (rtv);
5400                         track_views.push_back (rtv);
5401                         new_selection.push_back (rtv);
5402
5403                         rtv->effective_gain_display ();
5404
5405                         rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
5406                         rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
5407                 }
5408         }
5409
5410         if (new_views.size() > 0) {
5411                 _routes->time_axis_views_added (new_views);
5412                 //_summary->routes_added (new_selection); /* XXX requires RouteTimeAxisViewList */
5413         }
5414
5415         /* note: !new_selection.empty() means that we got some routes rather
5416          * than just VCAs
5417          */
5418
5419         if (!from_scratch && !new_selection.empty()) {
5420                 selection->set (new_selection);
5421                 begin_selection_op_history();
5422         }
5423
5424         if (show_editor_mixer_when_tracks_arrive && !new_selection.empty()) {
5425                 show_editor_mixer (true);
5426         }
5427
5428         editor_list_button.set_sensitive (true);
5429 }
5430
5431 void
5432 Editor::timeaxisview_deleted (TimeAxisView *tv)
5433 {
5434         if (tv == entered_track) {
5435                 entered_track = 0;
5436         }
5437
5438         if (_session && _session->deletion_in_progress()) {
5439                 /* the situation is under control */
5440                 return;
5441         }
5442
5443         ENSURE_GUI_THREAD (*this, &Editor::timeaxisview_deleted, tv);
5444
5445         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (tv);
5446
5447         _routes->route_removed (tv);
5448
5449         TimeAxisView::Children c = tv->get_child_list ();
5450         for (TimeAxisView::Children::const_iterator i = c.begin(); i != c.end(); ++i) {
5451                 if (entered_track == i->get()) {
5452                         entered_track = 0;
5453                 }
5454         }
5455
5456         /* remove it from the list of track views */
5457
5458         TrackViewList::iterator i;
5459
5460         if ((i = find (track_views.begin(), track_views.end(), tv)) != track_views.end()) {
5461                 i = track_views.erase (i);
5462         }
5463
5464         /* update whatever the current mixer strip is displaying, if revelant */
5465
5466         boost::shared_ptr<Route> route;
5467
5468         if (rtav) {
5469                 route = rtav->route ();
5470         }
5471
5472         if (current_mixer_strip && current_mixer_strip->route() == route) {
5473
5474                 TimeAxisView* next_tv;
5475
5476                 if (track_views.empty()) {
5477                         next_tv = 0;
5478                 } else if (i == track_views.end()) {
5479                         next_tv = track_views.front();
5480                 } else {
5481                         next_tv = (*i);
5482                 }
5483
5484                 // skip VCAs (cannot be selected, n/a in editor-mixer)
5485                 if (dynamic_cast<VCATimeAxisView*> (next_tv)) {
5486                         /* VCAs are sorted last in line -- route_sorter.h, jump to top */
5487                         next_tv = track_views.front();
5488                 }
5489                 if (dynamic_cast<VCATimeAxisView*> (next_tv)) {
5490                         /* just in case: no master, only a VCA remains */
5491                         next_tv = 0;
5492                 }
5493
5494
5495                 if (next_tv) {
5496                         set_selected_mixer_strip (*next_tv);
5497                 } else {
5498                         /* make the editor mixer strip go away setting the
5499                          * button to inactive (which also unticks the menu option)
5500                          */
5501
5502                         ActionManager::uncheck_toggleaction ("<Actions>/Editor/show-editor-mixer");
5503                 }
5504         }
5505 }
5506
5507 void
5508 Editor::hide_track_in_display (TimeAxisView* tv, bool apply_to_selection)
5509 {
5510         if (!tv) {
5511                 return;
5512         }
5513         if (apply_to_selection) {
5514                 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ) {
5515
5516                         TrackSelection::iterator j = i;
5517                         ++j;
5518
5519                         hide_track_in_display (*i, false);
5520
5521                         i = j;
5522                 }
5523         } else {
5524                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
5525
5526                 if (rtv && current_mixer_strip && (rtv->route() == current_mixer_strip->route())) {
5527                         // this will hide the mixer strip
5528                         set_selected_mixer_strip (*tv);
5529                 }
5530
5531                 _routes->hide_track_in_display (*tv);
5532         }
5533 }
5534
5535 void
5536 Editor::show_track_in_display (TimeAxisView* tv, bool move_into_view)
5537 {
5538         if (!tv) {
5539                 return;
5540         }
5541         _routes->show_track_in_display (*tv);
5542         if (move_into_view) {
5543                 ensure_time_axis_view_is_visible (*tv, false);
5544         }
5545 }
5546
5547 bool
5548 Editor::sync_track_view_list_and_routes ()
5549 {
5550         track_views = TrackViewList (_routes->views ());
5551
5552         _summary->set_background_dirty();
5553         _group_tabs->set_dirty ();
5554
5555         return false; // do not call again (until needed)
5556 }
5557
5558 void
5559 Editor::foreach_time_axis_view (sigc::slot<void,TimeAxisView&> theslot)
5560 {
5561         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5562                 theslot (**i);
5563         }
5564 }
5565
5566 /** Find a StripableTimeAxisView by the ID of its stripable */
5567 StripableTimeAxisView*
5568 Editor::get_stripable_time_axis_by_id (const PBD::ID& id) const
5569 {
5570         StripableTimeAxisView* v;
5571
5572         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5573                 if((v = dynamic_cast<StripableTimeAxisView*>(*i)) != 0) {
5574                         if(v->stripable()->id() == id) {
5575                                 return v;
5576                         }
5577                 }
5578         }
5579
5580         return 0;
5581 }
5582
5583 void
5584 Editor::fit_route_group (RouteGroup *g)
5585 {
5586         TrackViewList ts = axis_views_from_routes (g->route_list ());
5587         fit_tracks (ts);
5588 }
5589
5590 void
5591 Editor::consider_auditioning (boost::shared_ptr<Region> region)
5592 {
5593         boost::shared_ptr<AudioRegion> r = boost::dynamic_pointer_cast<AudioRegion> (region);
5594
5595         if (r == 0) {
5596                 _session->cancel_audition ();
5597                 return;
5598         }
5599
5600         if (_session->is_auditioning()) {
5601                 _session->cancel_audition ();
5602                 if (r == last_audition_region) {
5603                         return;
5604                 }
5605         }
5606
5607         _session->audition_region (r);
5608         last_audition_region = r;
5609 }
5610
5611
5612 void
5613 Editor::hide_a_region (boost::shared_ptr<Region> r)
5614 {
5615         r->set_hidden (true);
5616 }
5617
5618 void
5619 Editor::show_a_region (boost::shared_ptr<Region> r)
5620 {
5621         r->set_hidden (false);
5622 }
5623
5624 void
5625 Editor::audition_region_from_region_list ()
5626 {
5627         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::consider_auditioning));
5628 }
5629
5630 void
5631 Editor::hide_region_from_region_list ()
5632 {
5633         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::hide_a_region));
5634 }
5635
5636 void
5637 Editor::show_region_in_region_list ()
5638 {
5639         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::show_a_region));
5640 }
5641
5642 void
5643 Editor::step_edit_status_change (bool yn)
5644 {
5645         if (yn) {
5646                 start_step_editing ();
5647         } else {
5648                 stop_step_editing ();
5649         }
5650 }
5651
5652 void
5653 Editor::start_step_editing ()
5654 {
5655         step_edit_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &Editor::check_step_edit), 20);
5656 }
5657
5658 void
5659 Editor::stop_step_editing ()
5660 {
5661         step_edit_connection.disconnect ();
5662 }
5663
5664 bool
5665 Editor::check_step_edit ()
5666 {
5667         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5668                 MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (*i);
5669                 if (mtv) {
5670                         mtv->check_step_edit ();
5671                 }
5672         }
5673
5674         return true; // do it again, till we stop
5675 }
5676
5677 bool
5678 Editor::scroll_press (Direction dir)
5679 {
5680         ++_scroll_callbacks;
5681
5682         if (_scroll_connection.connected() && _scroll_callbacks < 5) {
5683                 /* delay the first auto-repeat */
5684                 return true;
5685         }
5686
5687         switch (dir) {
5688         case LEFT:
5689                 scroll_backward (1);
5690                 break;
5691
5692         case RIGHT:
5693                 scroll_forward (1);
5694                 break;
5695
5696         case UP:
5697                 scroll_up_one_track ();
5698                 break;
5699
5700         case DOWN:
5701                 scroll_down_one_track ();
5702                 break;
5703         }
5704
5705         /* do hacky auto-repeat */
5706         if (!_scroll_connection.connected ()) {
5707
5708                 _scroll_connection = Glib::signal_timeout().connect (
5709                         sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), dir), 100
5710                         );
5711
5712                 _scroll_callbacks = 0;
5713         }
5714
5715         return true;
5716 }
5717
5718 void
5719 Editor::scroll_release ()
5720 {
5721         _scroll_connection.disconnect ();
5722 }
5723
5724 /** Queue a change for the Editor viewport x origin to follow the playhead */
5725 void
5726 Editor::reset_x_origin_to_follow_playhead ()
5727 {
5728         framepos_t const frame = playhead_cursor->current_frame ();
5729
5730         if (frame < leftmost_frame || frame > leftmost_frame + current_page_samples()) {
5731
5732                 if (_session->transport_speed() < 0) {
5733
5734                         if (frame > (current_page_samples() / 2)) {
5735                                 center_screen (frame-(current_page_samples()/2));
5736                         } else {
5737                                 center_screen (current_page_samples()/2);
5738                         }
5739
5740                 } else {
5741
5742                         framepos_t l = 0;
5743
5744                         if (frame < leftmost_frame) {
5745                                 /* moving left */
5746                                 if (_session->transport_rolling()) {
5747                                         /* rolling; end up with the playhead at the right of the page */
5748                                         l = frame - current_page_samples ();
5749                                 } else {
5750                                         /* not rolling: end up with the playhead 1/4 of the way along the page */
5751                                         l = frame - current_page_samples() / 4;
5752                                 }
5753                         } else {
5754                                 /* moving right */
5755                                 if (_session->transport_rolling()) {
5756                                         /* rolling: end up with the playhead on the left of the page */
5757                                         l = frame;
5758                                 } else {
5759                                         /* not rolling: end up with the playhead 3/4 of the way along the page */
5760                                         l = frame - 3 * current_page_samples() / 4;
5761                                 }
5762                         }
5763
5764                         if (l < 0) {
5765                                 l = 0;
5766                         }
5767
5768                         center_screen_internal (l + (current_page_samples() / 2), current_page_samples ());
5769                 }
5770         }
5771 }
5772
5773 void
5774 Editor::super_rapid_screen_update ()
5775 {
5776         if (!_session || !_session->engine().running()) {
5777                 return;
5778         }
5779
5780         /* METERING / MIXER STRIPS */
5781
5782         /* update track meters, if required */
5783         if (contents().is_mapped() && meters_running) {
5784                 RouteTimeAxisView* rtv;
5785                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5786                         if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
5787                                 rtv->fast_update ();
5788                         }
5789                 }
5790         }
5791
5792         /* and any current mixer strip */
5793         if (current_mixer_strip) {
5794                 current_mixer_strip->fast_update ();
5795         }
5796
5797         /* PLAYHEAD AND VIEWPORT */
5798
5799         /* There are a few reasons why we might not update the playhead / viewport stuff:
5800          *
5801          * 1.  we don't update things when there's a pending locate request, otherwise
5802          *     when the editor requests a locate there is a chance that this method
5803          *     will move the playhead before the locate request is processed, causing
5804          *     a visual glitch.
5805          * 2.  if we're not rolling, there's nothing to do here (locates are handled elsewhere).
5806          * 3.  if we're still at the same frame that we were last time, there's nothing to do.
5807          */
5808         if (_pending_locate_request || !_session->transport_rolling ()) {
5809                 _last_update_time = 0;
5810                 return;
5811         }
5812
5813         if (_dragging_playhead) {
5814                 _last_update_time = 0;
5815                 return;
5816         }
5817
5818         bool latent_locate = false;
5819         framepos_t frame = _session->audible_frame (&latent_locate);
5820         const int64_t now = g_get_monotonic_time ();
5821         double err = 0;
5822
5823         if (_session->exporting ()) {
5824                 /* freewheel/export may be faster or slower than transport_speed() / SR.
5825                  * Also exporting multiple ranges locates/jumps without a _pending_locate_request.
5826                  */
5827                 _last_update_time = 0;
5828         }
5829
5830         if (_last_update_time > 0) {
5831                 /* interpolate and smoothen playhead position */
5832                 const double ds =  (now - _last_update_time) * _session->transport_speed() * _session->nominal_frame_rate () * 1e-6;
5833                 framepos_t guess = playhead_cursor->current_frame () + rint (ds);
5834                 err = frame - guess;
5835
5836                 guess += err * .12 + _err_screen_engine; // time-constant based on 25fps (super_rapid_screen_update)
5837                 _err_screen_engine += .0144 * (err - _err_screen_engine); // tc^2
5838
5839 #if 0 // DEBUG
5840                 printf ("eng: %ld  gui:%ld (%+6.1f)  diff: %6.1f (err: %7.2f)\n",
5841                                 frame, guess, ds,
5842                                 err, _err_screen_engine);
5843 #endif
5844
5845                 frame = guess;
5846         } else {
5847                 _err_screen_engine = 0;
5848         }
5849
5850         if (err > 8192 || latent_locate) {
5851                 // in case of x-runs or freewheeling
5852                 _last_update_time = 0;
5853                 frame = _session->audible_frame ();
5854         } else {
5855                 _last_update_time = now;
5856         }
5857
5858         if (playhead_cursor->current_frame () == frame) {
5859                 return;
5860         }
5861
5862         playhead_cursor->set_position (frame);
5863
5864         if (_session->requested_return_frame() >= 0) {
5865                 _last_update_time = 0;
5866                 return;
5867         }
5868
5869         if (!_follow_playhead || pending_visual_change.being_handled) {
5870                 /* We only do this if we aren't already
5871                  * handling a visual change (ie if
5872                  * pending_visual_change.being_handled is
5873                  * false) so that these requests don't stack
5874                  * up there are too many of them to handle in
5875                  * time.
5876                  */
5877                 return;
5878         }
5879
5880         if (!_stationary_playhead) {
5881                 reset_x_origin_to_follow_playhead ();
5882         } else {
5883                 framepos_t const frame = playhead_cursor->current_frame ();
5884                 double target = ((double)frame - (double)current_page_samples() / 2.0);
5885                 if (target <= 0.0) {
5886                         target = 0.0;
5887                 }
5888                 // compare to EditorCursor::set_position()
5889                 double const old_pos = sample_to_pixel_unrounded (leftmost_frame);
5890                 double const new_pos = sample_to_pixel_unrounded (target);
5891                 if (rint (new_pos) != rint (old_pos)) {
5892                         reset_x_origin (pixel_to_sample (new_pos));
5893                 }
5894         }
5895 }
5896
5897
5898 void
5899 Editor::session_going_away ()
5900 {
5901         _have_idled = false;
5902
5903         _session_connections.drop_connections ();
5904
5905         super_rapid_screen_update_connection.disconnect ();
5906
5907         selection->clear ();
5908         cut_buffer->clear ();
5909
5910         clicked_regionview = 0;
5911         clicked_axisview = 0;
5912         clicked_routeview = 0;
5913         entered_regionview = 0;
5914         entered_track = 0;
5915         _last_update_time = 0;
5916         _drags->abort ();
5917
5918         playhead_cursor->hide ();
5919
5920         /* rip everything out of the list displays */
5921
5922         _regions->clear ();
5923         _routes->clear ();
5924         _route_groups->clear ();
5925
5926         /* do this first so that deleting a track doesn't reset cms to null
5927            and thus cause a leak.
5928         */
5929
5930         if (current_mixer_strip) {
5931                 if (current_mixer_strip->get_parent() != 0) {
5932                         global_hpacker.remove (*current_mixer_strip);
5933                 }
5934                 delete current_mixer_strip;
5935                 current_mixer_strip = 0;
5936         }
5937
5938         /* delete all trackviews */
5939
5940         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5941                 delete *i;
5942         }
5943         track_views.clear ();
5944
5945         nudge_clock->set_session (0);
5946
5947         editor_list_button.set_active(false);
5948         editor_list_button.set_sensitive(false);
5949
5950         /* clear tempo/meter rulers */
5951         remove_metric_marks ();
5952         hide_measures ();
5953         clear_marker_display ();
5954
5955         delete tempo_lines;
5956         tempo_lines = 0;
5957
5958         stop_step_editing ();
5959
5960         if (own_window()) {
5961
5962                 /* get rid of any existing editor mixer strip */
5963
5964                 WindowTitle title(Glib::get_application_name());
5965                 title += _("Editor");
5966
5967                 own_window()->set_title (title.get_string());
5968         }
5969
5970         SessionHandlePtr::session_going_away ();
5971 }
5972
5973 void
5974 Editor::trigger_script (int i)
5975 {
5976         LuaInstance::instance()-> call_action (i);
5977 }
5978
5979 void
5980 Editor::show_editor_list (bool yn)
5981 {
5982         if (yn) {
5983                 _editor_list_vbox.show ();
5984         } else {
5985                 _editor_list_vbox.hide ();
5986         }
5987 }
5988
5989 void
5990 Editor::change_region_layering_order (bool from_context_menu)
5991 {
5992         const framepos_t position = get_preferred_edit_position (EDIT_IGNORE_NONE, from_context_menu);
5993
5994         if (!clicked_routeview) {
5995                 if (layering_order_editor) {
5996                         layering_order_editor->hide ();
5997                 }
5998                 return;
5999         }
6000
6001         boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (clicked_routeview->route());
6002
6003         if (!track) {
6004                 return;
6005         }
6006
6007         boost::shared_ptr<Playlist> pl = track->playlist();
6008
6009         if (!pl) {
6010                 return;
6011         }
6012
6013         if (layering_order_editor == 0) {
6014                 layering_order_editor = new RegionLayeringOrderEditor (*this);
6015         }
6016
6017         layering_order_editor->set_context (clicked_routeview->name(), _session, clicked_routeview, pl, position);
6018         layering_order_editor->maybe_present ();
6019 }
6020
6021 void
6022 Editor::update_region_layering_order_editor ()
6023 {
6024         if (layering_order_editor && layering_order_editor->is_visible ()) {
6025                 change_region_layering_order (true);
6026         }
6027 }
6028
6029 void
6030 Editor::setup_fade_images ()
6031 {
6032         _xfade_in_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("fadein-linear")));
6033         _xfade_in_images[FadeSymmetric] = new Gtk::Image (get_icon_path (X_("fadein-symmetric")));
6034         _xfade_in_images[FadeFast] = new Gtk::Image (get_icon_path (X_("fadein-fast-cut")));
6035         _xfade_in_images[FadeSlow] = new Gtk::Image (get_icon_path (X_("fadein-slow-cut")));
6036         _xfade_in_images[FadeConstantPower] = new Gtk::Image (get_icon_path (X_("fadein-constant-power")));
6037
6038         _xfade_out_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("fadeout-linear")));
6039         _xfade_out_images[FadeSymmetric] = new Gtk::Image (get_icon_path (X_("fadeout-symmetric")));
6040         _xfade_out_images[FadeFast] = new Gtk::Image (get_icon_path (X_("fadeout-fast-cut")));
6041         _xfade_out_images[FadeSlow] = new Gtk::Image (get_icon_path (X_("fadeout-slow-cut")));
6042         _xfade_out_images[FadeConstantPower] = new Gtk::Image (get_icon_path (X_("fadeout-constant-power")));
6043
6044 }
6045
6046 /** @return Gtk::manage()d menu item for a given action from `editor_actions' */
6047 Gtk::MenuItem&
6048 Editor::action_menu_item (std::string const & name)
6049 {
6050         Glib::RefPtr<Action> a = editor_actions->get_action (name);
6051         assert (a);
6052
6053         return *manage (a->create_menu_item ());
6054 }
6055
6056 void
6057 Editor::add_notebook_page (string const & name, Gtk::Widget& widget)
6058 {
6059         EventBox* b = manage (new EventBox);
6060         b->signal_button_press_event().connect (sigc::bind (sigc::mem_fun (*this, &Editor::notebook_tab_clicked), &widget));
6061         Label* l = manage (new Label (name));
6062         l->set_angle (-90);
6063         b->add (*l);
6064         b->show_all ();
6065         _the_notebook.append_page (widget, *b);
6066 }
6067
6068 bool
6069 Editor::notebook_tab_clicked (GdkEventButton* ev, Gtk::Widget* page)
6070 {
6071         if (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_2BUTTON_PRESS) {
6072                 _the_notebook.set_current_page (_the_notebook.page_num (*page));
6073         }
6074
6075         if (ev->type == GDK_2BUTTON_PRESS) {
6076
6077                 /* double-click on a notebook tab shrinks or expands the notebook */
6078
6079                 if (_notebook_shrunk) {
6080                         if (pre_notebook_shrink_pane_width) {
6081                                 edit_pane.set_divider (0, *pre_notebook_shrink_pane_width);
6082                         }
6083                         _notebook_shrunk = false;
6084                 } else {
6085                         pre_notebook_shrink_pane_width = edit_pane.get_divider();
6086
6087                         /* this expands the LHS of the edit pane to cover the notebook
6088                            PAGE but leaves the tabs visible.
6089                          */
6090                         edit_pane.set_divider (0, edit_pane.get_divider() + page->get_width());
6091                         _notebook_shrunk = true;
6092                 }
6093         }
6094
6095         return true;
6096 }
6097
6098 void
6099 Editor::popup_control_point_context_menu (ArdourCanvas::Item* item, GdkEvent* event)
6100 {
6101         using namespace Menu_Helpers;
6102
6103         MenuList& items = _control_point_context_menu.items ();
6104         items.clear ();
6105
6106         items.push_back (MenuElem (_("Edit..."), sigc::bind (sigc::mem_fun (*this, &Editor::edit_control_point), item)));
6107         items.push_back (MenuElem (_("Delete"), sigc::bind (sigc::mem_fun (*this, &Editor::remove_control_point), item)));
6108         if (!can_remove_control_point (item)) {
6109                 items.back().set_sensitive (false);
6110         }
6111
6112         _control_point_context_menu.popup (event->button.button, event->button.time);
6113 }
6114
6115 void
6116 Editor::popup_note_context_menu (ArdourCanvas::Item* item, GdkEvent* event)
6117 {
6118         using namespace Menu_Helpers;
6119
6120         NoteBase* note = reinterpret_cast<NoteBase*>(item->get_data("notebase"));
6121         if (!note) {
6122                 return;
6123         }
6124
6125         /* We need to get the selection here and pass it to the operations, since
6126            popping up the menu will cause a region leave event which clears
6127            entered_regionview. */
6128
6129         MidiRegionView&       mrv = note->region_view();
6130         const RegionSelection rs  = get_regions_from_selection_and_entered ();
6131         const uint32_t sel_size = mrv.selection_size ();
6132
6133         MenuList& items = _note_context_menu.items();
6134         items.clear();
6135
6136         if (sel_size > 0) {
6137                 items.push_back(MenuElem(_("Delete"),
6138                                          sigc::mem_fun(mrv, &MidiRegionView::delete_selection)));
6139         }
6140
6141         items.push_back(MenuElem(_("Edit..."),
6142                                  sigc::bind(sigc::mem_fun(*this, &Editor::edit_notes), &mrv)));
6143         if (sel_size != 1) {
6144                 items.back().set_sensitive (false);
6145         }
6146
6147         items.push_back(MenuElem(_("Transpose..."),
6148                                  sigc::bind(sigc::mem_fun(*this, &Editor::transpose_regions), rs)));
6149
6150
6151         items.push_back(MenuElem(_("Legatize"),
6152                                  sigc::bind(sigc::mem_fun(*this, &Editor::legatize_regions), rs, false)));
6153         if (sel_size < 2) {
6154                 items.back().set_sensitive (false);
6155         }
6156
6157         items.push_back(MenuElem(_("Quantize..."),
6158                                  sigc::bind(sigc::mem_fun(*this, &Editor::quantize_regions), rs)));
6159
6160         items.push_back(MenuElem(_("Remove Overlap"),
6161                                  sigc::bind(sigc::mem_fun(*this, &Editor::legatize_regions), rs, true)));
6162         if (sel_size < 2) {
6163                 items.back().set_sensitive (false);
6164         }
6165
6166         items.push_back(MenuElem(_("Transform..."),
6167                                  sigc::bind(sigc::mem_fun(*this, &Editor::transform_regions), rs)));
6168
6169         _note_context_menu.popup (event->button.button, event->button.time);
6170 }
6171
6172 void
6173 Editor::zoom_vertical_modifier_released()
6174 {
6175         _stepping_axis_view = 0;
6176 }
6177
6178 void
6179 Editor::ui_parameter_changed (string parameter)
6180 {
6181         if (parameter == "icon-set") {
6182                 while (!_cursor_stack.empty()) {
6183                         _cursor_stack.pop_back();
6184                 }
6185                 _cursors->set_cursor_set (UIConfiguration::instance().get_icon_set());
6186                 _cursor_stack.push_back(_cursors->grabber);
6187                 edit_pane.set_drag_cursor (*_cursors->expand_left_right);
6188                 editor_summary_pane.set_drag_cursor (*_cursors->expand_up_down);
6189
6190         } else if (parameter == "draggable-playhead") {
6191                 if (_verbose_cursor) {
6192                         playhead_cursor->set_sensitive (UIConfiguration::instance().get_draggable_playhead());
6193                 }
6194         }
6195 }
6196
6197 Gtk::Window*
6198 Editor::use_own_window (bool and_fill_it)
6199 {
6200         bool new_window = !own_window();
6201
6202         Gtk::Window* win = Tabbable::use_own_window (and_fill_it);
6203
6204         if (win && new_window) {
6205                 win->set_name ("EditorWindow");
6206
6207                 ARDOUR_UI::instance()->setup_toplevel_window (*win, _("Editor"), this);
6208
6209                 // win->signal_realize().connect (*this, &Editor::on_realize);
6210                 win->signal_event().connect (sigc::bind (sigc::ptr_fun (&Keyboard::catch_user_event_for_pre_dialog_focus), win));
6211                 win->signal_event().connect (sigc::mem_fun (*this, &Editor::generic_event_handler));
6212                 win->set_data ("ardour-bindings", bindings);
6213
6214                 update_title ();
6215         }
6216
6217         DisplaySuspender ds;
6218         contents().show_all ();
6219
6220         /* XXX: this is a bit unfortunate; it would probably
6221            be nicer if we could just call show () above rather
6222            than needing the show_all ()
6223         */
6224
6225         /* re-hide stuff if necessary */
6226         editor_list_button_toggled ();
6227         parameter_changed ("show-summary");
6228         parameter_changed ("show-group-tabs");
6229         parameter_changed ("show-zoom-tools");
6230
6231         /* now reset all audio_time_axis heights, because widgets might need
6232            to be re-hidden
6233         */
6234
6235         TimeAxisView *tv;
6236
6237         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
6238                 tv = (static_cast<TimeAxisView*>(*i));
6239                 tv->reset_height ();
6240         }
6241
6242         if (current_mixer_strip) {
6243                 current_mixer_strip->hide_things ();
6244                 current_mixer_strip->parameter_changed ("mixer-element-visibility");
6245         }
6246
6247         return win;
6248 }