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 Range/Region Selection"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), Horizontal)));
3786         }
3787 }
3788
3789 void
3790 Editor::set_zoom_preset (int64_t ms)
3791 {
3792         if ( ms <= 0 ) {
3793                 temporal_zoom_session();
3794                 return;
3795         }
3796
3797         ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
3798         temporal_zoom( (sample_rate * ms / 1000) / _visible_canvas_width );
3799 }
3800
3801 void
3802 Editor::set_visible_track_count (int32_t n)
3803 {
3804         _visible_track_count = n;
3805
3806         /* if the canvas hasn't really been allocated any size yet, just
3807            record the desired number of visible tracks and return. when canvas
3808            allocation happens, we will get called again and then we can do the
3809            real work.
3810         */
3811
3812         if (_visible_canvas_height <= 1) {
3813                 return;
3814         }
3815
3816         int h;
3817         string str;
3818         DisplaySuspender ds;
3819
3820         if (_visible_track_count > 0) {
3821                 h = trackviews_height() / _visible_track_count;
3822                 std::ostringstream s;
3823                 s << _visible_track_count;
3824                 str = s.str();
3825         } else if (_visible_track_count == 0) {
3826                 uint32_t n = 0;
3827                 for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
3828                         if ((*i)->marked_for_display()) {
3829                                 ++n;
3830                                 TimeAxisView::Children cl ((*i)->get_child_list ());
3831                                 for (TimeAxisView::Children::const_iterator j = cl.begin(); j != cl.end(); ++j) {
3832                                         if ((*j)->marked_for_display()) {
3833                                                 ++n;
3834                                         }
3835                                 }
3836                         }
3837                 }
3838                 if (n == 0) {
3839                         visible_tracks_selector.set_text (X_("*"));
3840                         return;
3841                 }
3842                 h = trackviews_height() / n;
3843                 str = _("All");
3844         } else {
3845                 /* negative value means that the visible track count has
3846                    been overridden by explicit track height changes.
3847                 */
3848                 visible_tracks_selector.set_text (X_("*"));
3849                 return;
3850         }
3851
3852         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
3853                 (*i)->set_height (h, TimeAxisView::HeightPerLane);
3854         }
3855
3856         if (str != visible_tracks_selector.get_text()) {
3857                 visible_tracks_selector.set_text (str);
3858         }
3859 }
3860
3861 void
3862 Editor::override_visible_track_count ()
3863 {
3864         _visible_track_count = -1;
3865         visible_tracks_selector.set_text ( _("*") );
3866 }
3867
3868 bool
3869 Editor::edit_controls_button_release (GdkEventButton* ev)
3870 {
3871         if (Keyboard::is_context_menu_event (ev)) {
3872                 ARDOUR_UI::instance()->add_route ();
3873         } else if (ev->button == 1) {
3874                 selection->clear_tracks ();
3875         }
3876
3877         return true;
3878 }
3879
3880 bool
3881 Editor::mouse_select_button_release (GdkEventButton* ev)
3882 {
3883         /* this handles just right-clicks */
3884
3885         if (ev->button != 3) {
3886                 return false;
3887         }
3888
3889         return true;
3890 }
3891
3892 void
3893 Editor::set_zoom_focus (ZoomFocus f)
3894 {
3895         string str = zoom_focus_strings[(int)f];
3896
3897         if (str != zoom_focus_selector.get_text()) {
3898                 zoom_focus_selector.set_text (str);
3899         }
3900
3901         if (zoom_focus != f) {
3902                 zoom_focus = f;
3903                 instant_save ();
3904         }
3905 }
3906
3907 void
3908 Editor::cycle_zoom_focus ()
3909 {
3910         switch (zoom_focus) {
3911         case ZoomFocusLeft:
3912                 set_zoom_focus (ZoomFocusRight);
3913                 break;
3914         case ZoomFocusRight:
3915                 set_zoom_focus (ZoomFocusCenter);
3916                 break;
3917         case ZoomFocusCenter:
3918                 set_zoom_focus (ZoomFocusPlayhead);
3919                 break;
3920         case ZoomFocusPlayhead:
3921                 set_zoom_focus (ZoomFocusMouse);
3922                 break;
3923         case ZoomFocusMouse:
3924                 set_zoom_focus (ZoomFocusEdit);
3925                 break;
3926         case ZoomFocusEdit:
3927                 set_zoom_focus (ZoomFocusLeft);
3928                 break;
3929         }
3930 }
3931
3932 void
3933 Editor::set_show_measures (bool yn)
3934 {
3935         if (_show_measures != yn) {
3936                 hide_measures ();
3937
3938                 if ((_show_measures = yn) == true) {
3939                         if (tempo_lines) {
3940                                 tempo_lines->show();
3941                         }
3942
3943                         std::vector<TempoMap::BBTPoint> grid;
3944                         compute_current_bbt_points (grid, leftmost_frame, leftmost_frame + current_page_samples());
3945                         draw_measures (grid);
3946                 }
3947
3948                 instant_save ();
3949         }
3950 }
3951
3952 void
3953 Editor::toggle_follow_playhead ()
3954 {
3955         RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-follow-playhead"));
3956         if (act) {
3957                 RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
3958                 set_follow_playhead (tact->get_active());
3959         }
3960 }
3961
3962 /** @param yn true to follow playhead, otherwise false.
3963  *  @param catch_up true to reset the editor view to show the playhead (if yn == true), otherwise false.
3964  */
3965 void
3966 Editor::set_follow_playhead (bool yn, bool catch_up)
3967 {
3968         if (_follow_playhead != yn) {
3969                 if ((_follow_playhead = yn) == true && catch_up) {
3970                         /* catch up */
3971                         reset_x_origin_to_follow_playhead ();
3972                 }
3973                 instant_save ();
3974         }
3975 }
3976
3977 void
3978 Editor::toggle_stationary_playhead ()
3979 {
3980         RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-stationary-playhead"));
3981         if (act) {
3982                 RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
3983                 set_stationary_playhead (tact->get_active());
3984         }
3985 }
3986
3987 void
3988 Editor::set_stationary_playhead (bool yn)
3989 {
3990         if (_stationary_playhead != yn) {
3991                 if ((_stationary_playhead = yn) == true) {
3992                         /* catch up */
3993                         // FIXME need a 3.0 equivalent of this 2.X call
3994                         // update_current_screen ();
3995                 }
3996                 instant_save ();
3997         }
3998 }
3999
4000 PlaylistSelector&
4001 Editor::playlist_selector () const
4002 {
4003         return *_playlist_selector;
4004 }
4005
4006 framecnt_t
4007 Editor::get_paste_offset (framepos_t pos, unsigned paste_count, framecnt_t duration)
4008 {
4009         if (paste_count == 0) {
4010                 /* don't bother calculating an offset that will be zero anyway */
4011                 return 0;
4012         }
4013
4014         /* calculate basic unsnapped multi-paste offset */
4015         framecnt_t offset = paste_count * duration;
4016
4017         /* snap offset so pos + offset is aligned to the grid */
4018         MusicFrame offset_pos (pos + offset, 0);
4019         snap_to(offset_pos, RoundUpMaybe);
4020         offset = offset_pos.frame - pos;
4021
4022         return offset;
4023 }
4024
4025 unsigned
4026 Editor::get_grid_beat_divisions(framepos_t position)
4027 {
4028         switch (_snap_type) {
4029         case SnapToBeatDiv128: return 128;
4030         case SnapToBeatDiv64:  return 64;
4031         case SnapToBeatDiv32:  return 32;
4032         case SnapToBeatDiv28:  return 28;
4033         case SnapToBeatDiv24:  return 24;
4034         case SnapToBeatDiv20:  return 20;
4035         case SnapToBeatDiv16:  return 16;
4036         case SnapToBeatDiv14:  return 14;
4037         case SnapToBeatDiv12:  return 12;
4038         case SnapToBeatDiv10:  return 10;
4039         case SnapToBeatDiv8:   return 8;
4040         case SnapToBeatDiv7:   return 7;
4041         case SnapToBeatDiv6:   return 6;
4042         case SnapToBeatDiv5:   return 5;
4043         case SnapToBeatDiv4:   return 4;
4044         case SnapToBeatDiv3:   return 3;
4045         case SnapToBeatDiv2:   return 2;
4046         default:               return 0;
4047         }
4048         return 0;
4049 }
4050
4051 /** returns the current musical grid divisiions using the supplied modifier mask from a GtkEvent.
4052     if the grid is non-musical, returns 0.
4053     if the grid is snapped to bars, returns -1.
4054     @param event_state the current keyboard modifier mask.
4055 */
4056 int32_t
4057 Editor::get_grid_music_divisions (uint32_t event_state)
4058 {
4059         if (snap_mode() == Editing::SnapOff && !ArdourKeyboard::indicates_snap (event_state)) {
4060                 return 0;
4061         }
4062
4063         if (snap_mode() != Editing::SnapOff && ArdourKeyboard::indicates_snap (event_state)) {
4064                 return 0;
4065         }
4066
4067         switch (_snap_type) {
4068         case SnapToBeatDiv128: return 128;
4069         case SnapToBeatDiv64:  return 64;
4070         case SnapToBeatDiv32:  return 32;
4071         case SnapToBeatDiv28:  return 28;
4072         case SnapToBeatDiv24:  return 24;
4073         case SnapToBeatDiv20:  return 20;
4074         case SnapToBeatDiv16:  return 16;
4075         case SnapToBeatDiv14:  return 14;
4076         case SnapToBeatDiv12:  return 12;
4077         case SnapToBeatDiv10:  return 10;
4078         case SnapToBeatDiv8:   return 8;
4079         case SnapToBeatDiv7:   return 7;
4080         case SnapToBeatDiv6:   return 6;
4081         case SnapToBeatDiv5:   return 5;
4082         case SnapToBeatDiv4:   return 4;
4083         case SnapToBeatDiv3:   return 3;
4084         case SnapToBeatDiv2:   return 2;
4085         case SnapToBeat:       return 1;
4086         case SnapToBar :       return -1;
4087         default:               return 0;
4088         }
4089         return 0;
4090 }
4091
4092 Evoral::Beats
4093 Editor::get_grid_type_as_beats (bool& success, framepos_t position)
4094 {
4095         success = true;
4096
4097         const unsigned divisions = get_grid_beat_divisions(position);
4098         if (divisions) {
4099                 return Evoral::Beats(1.0 / (double)get_grid_beat_divisions(position));
4100         }
4101
4102         switch (_snap_type) {
4103         case SnapToBeat:
4104                 return Evoral::Beats(4.0 / _session->tempo_map().meter_at_frame (position).note_divisor());
4105         case SnapToBar:
4106                 if (_session) {
4107                         const Meter& m = _session->tempo_map().meter_at_frame (position);
4108                         return Evoral::Beats((4.0 * m.divisions_per_bar()) / m.note_divisor());
4109                 }
4110                 break;
4111         default:
4112                 success = false;
4113                 break;
4114         }
4115
4116         return Evoral::Beats();
4117 }
4118
4119 framecnt_t
4120 Editor::get_nudge_distance (framepos_t pos, framecnt_t& next)
4121 {
4122         framecnt_t ret;
4123
4124         ret = nudge_clock->current_duration (pos);
4125         next = ret + 1; /* XXXX fix me */
4126
4127         return ret;
4128 }
4129
4130 int
4131 Editor::playlist_deletion_dialog (boost::shared_ptr<Playlist> pl)
4132 {
4133         ArdourDialog dialog (_("Playlist Deletion"));
4134         Label  label (string_compose (_("Playlist %1 is currently unused.\n"
4135                                         "If it is kept, its audio files will not be cleaned.\n"
4136                                         "If it is deleted, audio files used by it alone will be cleaned."),
4137                                       pl->name()));
4138
4139         dialog.set_position (WIN_POS_CENTER);
4140         dialog.get_vbox()->pack_start (label);
4141
4142         label.show ();
4143
4144         dialog.add_button (_("Delete All Unused"), RESPONSE_YES); // needs clarification. this and all remaining ones
4145         dialog.add_button (_("Delete Playlist"), RESPONSE_ACCEPT);
4146         Button* keep = dialog.add_button (_("Keep Playlist"), RESPONSE_REJECT);
4147         dialog.add_button (_("Keep Remaining"), RESPONSE_NO); // ditto
4148         dialog.add_button (_("Cancel"), RESPONSE_CANCEL);
4149
4150         // by default gtk uses the left most button
4151         keep->grab_focus ();
4152
4153         switch (dialog.run ()) {
4154         case RESPONSE_NO:
4155                 /* keep this and all remaining ones */
4156                 return -2;
4157                 break;
4158
4159         case RESPONSE_YES:
4160                 /* delete this and all others */
4161                 return 2;
4162                 break;
4163
4164         case RESPONSE_ACCEPT:
4165                 /* delete the playlist */
4166                 return 1;
4167                 break;
4168
4169         case RESPONSE_REJECT:
4170                 /* keep the playlist */
4171                 return 0;
4172                 break;
4173
4174         default:
4175                 break;
4176         }
4177
4178         return -1;
4179 }
4180
4181 bool
4182 Editor::audio_region_selection_covers (framepos_t where)
4183 {
4184         for (RegionSelection::iterator a = selection->regions.begin(); a != selection->regions.end(); ++a) {
4185                 if ((*a)->region()->covers (where)) {
4186                         return true;
4187                 }
4188         }
4189
4190         return false;
4191 }
4192
4193 void
4194 Editor::prepare_for_cleanup ()
4195 {
4196         cut_buffer->clear_regions ();
4197         cut_buffer->clear_playlists ();
4198
4199         selection->clear_regions ();
4200         selection->clear_playlists ();
4201
4202         _regions->suspend_redisplay ();
4203 }
4204
4205 void
4206 Editor::finish_cleanup ()
4207 {
4208         _regions->resume_redisplay ();
4209 }
4210
4211 Location*
4212 Editor::transport_loop_location()
4213 {
4214         if (_session) {
4215                 return _session->locations()->auto_loop_location();
4216         } else {
4217                 return 0;
4218         }
4219 }
4220
4221 Location*
4222 Editor::transport_punch_location()
4223 {
4224         if (_session) {
4225                 return _session->locations()->auto_punch_location();
4226         } else {
4227                 return 0;
4228         }
4229 }
4230
4231 bool
4232 Editor::control_layout_scroll (GdkEventScroll* ev)
4233 {
4234         /* Just forward to the normal canvas scroll method. The coordinate
4235            systems are different but since the canvas is always larger than the
4236            track headers, and aligned with the trackview area, this will work.
4237
4238            In the not too distant future this layout is going away anyway and
4239            headers will be on the canvas.
4240         */
4241         return canvas_scroll_event (ev, false);
4242 }
4243
4244 void
4245 Editor::session_state_saved (string)
4246 {
4247         update_title ();
4248         _snapshots->redisplay ();
4249 }
4250
4251 void
4252 Editor::maximise_editing_space ()
4253 {
4254         if (_maximised) {
4255                 return;
4256         }
4257
4258         Gtk::Window* toplevel = current_toplevel();
4259
4260         if (toplevel) {
4261                 toplevel->fullscreen ();
4262                 _maximised = true;
4263         }
4264 }
4265
4266 void
4267 Editor::restore_editing_space ()
4268 {
4269         if (!_maximised) {
4270                 return;
4271         }
4272
4273         Gtk::Window* toplevel = current_toplevel();
4274
4275         if (toplevel) {
4276                 toplevel->unfullscreen();
4277                 _maximised = false;
4278         }
4279 }
4280
4281 /**
4282  *  Make new playlists for a given track and also any others that belong
4283  *  to the same active route group with the `select' property.
4284  *  @param v Track.
4285  */
4286
4287 void
4288 Editor::new_playlists (TimeAxisView* v)
4289 {
4290         begin_reversible_command (_("new playlists"));
4291         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4292         _session->playlists->get (playlists);
4293         mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::group_select.property_id);
4294         commit_reversible_command ();
4295 }
4296
4297 /**
4298  *  Use a copy of the current playlist for a given track and also any others that belong
4299  *  to the same active route group with the `select' property.
4300  *  @param v Track.
4301  */
4302
4303 void
4304 Editor::copy_playlists (TimeAxisView* v)
4305 {
4306         begin_reversible_command (_("copy playlists"));
4307         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4308         _session->playlists->get (playlists);
4309         mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::group_select.property_id);
4310         commit_reversible_command ();
4311 }
4312
4313 /** Clear the current playlist for a given track and also any others that belong
4314  *  to the same active route group with the `select' property.
4315  *  @param v Track.
4316  */
4317
4318 void
4319 Editor::clear_playlists (TimeAxisView* v)
4320 {
4321         begin_reversible_command (_("clear playlists"));
4322         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4323         _session->playlists->get (playlists);
4324         mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::group_select.property_id);
4325         commit_reversible_command ();
4326 }
4327
4328 void
4329 Editor::mapped_use_new_playlist (RouteTimeAxisView& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
4330 {
4331         atv.use_new_playlist (sz > 1 ? false : true, playlists, false);
4332 }
4333
4334 void
4335 Editor::mapped_use_copy_playlist (RouteTimeAxisView& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
4336 {
4337         atv.use_new_playlist (sz > 1 ? false : true, playlists, true);
4338 }
4339
4340 void
4341 Editor::mapped_clear_playlist (RouteTimeAxisView& atv, uint32_t /*sz*/)
4342 {
4343         atv.clear_playlist ();
4344 }
4345
4346 double
4347 Editor::get_y_origin () const
4348 {
4349         return vertical_adjustment.get_value ();
4350 }
4351
4352 /** Queue up a change to the viewport x origin.
4353  *  @param frame New x origin.
4354  */
4355 void
4356 Editor::reset_x_origin (framepos_t frame)
4357 {
4358         pending_visual_change.add (VisualChange::TimeOrigin);
4359         pending_visual_change.time_origin = frame;
4360         ensure_visual_change_idle_handler ();
4361 }
4362
4363 void
4364 Editor::reset_y_origin (double y)
4365 {
4366         pending_visual_change.add (VisualChange::YOrigin);
4367         pending_visual_change.y_origin = y;
4368         ensure_visual_change_idle_handler ();
4369 }
4370
4371 void
4372 Editor::reset_zoom (framecnt_t spp)
4373 {
4374         if (spp == samples_per_pixel) {
4375                 return;
4376         }
4377
4378         pending_visual_change.add (VisualChange::ZoomLevel);
4379         pending_visual_change.samples_per_pixel = spp;
4380         ensure_visual_change_idle_handler ();
4381 }
4382
4383 void
4384 Editor::reposition_and_zoom (framepos_t frame, double fpu)
4385 {
4386         reset_x_origin (frame);
4387         reset_zoom (fpu);
4388
4389         if (!no_save_visual) {
4390                 undo_visual_stack.push_back (current_visual_state(false));
4391         }
4392 }
4393
4394 Editor::VisualState::VisualState (bool with_tracks)
4395         : gui_state (with_tracks ? new GUIObjectState : 0)
4396 {
4397 }
4398
4399 Editor::VisualState::~VisualState ()
4400 {
4401         delete gui_state;
4402 }
4403
4404 Editor::VisualState*
4405 Editor::current_visual_state (bool with_tracks)
4406 {
4407         VisualState* vs = new VisualState (with_tracks);
4408         vs->y_position = vertical_adjustment.get_value();
4409         vs->samples_per_pixel = samples_per_pixel;
4410         vs->leftmost_frame = leftmost_frame;
4411         vs->zoom_focus = zoom_focus;
4412
4413         if (with_tracks) {
4414                 vs->gui_state->set_state (ARDOUR_UI::instance()->gui_object_state->get_state());
4415         }
4416
4417         return vs;
4418 }
4419
4420 void
4421 Editor::undo_visual_state ()
4422 {
4423         if (undo_visual_stack.empty()) {
4424                 return;
4425         }
4426
4427         VisualState* vs = undo_visual_stack.back();
4428         undo_visual_stack.pop_back();
4429
4430
4431         redo_visual_stack.push_back (current_visual_state (vs ? vs->gui_state != 0 : false));
4432
4433         if (vs) {
4434                 use_visual_state (*vs);
4435         }
4436 }
4437
4438 void
4439 Editor::redo_visual_state ()
4440 {
4441         if (redo_visual_stack.empty()) {
4442                 return;
4443         }
4444
4445         VisualState* vs = redo_visual_stack.back();
4446         redo_visual_stack.pop_back();
4447
4448         // can 'vs' really be 0? Is there a place that puts NULL pointers onto the stack?
4449         // why do we check here?
4450         undo_visual_stack.push_back (current_visual_state (vs ? (vs->gui_state != 0) : false));
4451
4452         if (vs) {
4453                 use_visual_state (*vs);
4454         }
4455 }
4456
4457 void
4458 Editor::swap_visual_state ()
4459 {
4460         if (undo_visual_stack.empty()) {
4461                 redo_visual_state ();
4462         } else {
4463                 undo_visual_state ();
4464         }
4465 }
4466
4467 void
4468 Editor::use_visual_state (VisualState& vs)
4469 {
4470         PBD::Unwinder<bool> nsv (no_save_visual, true);
4471         DisplaySuspender ds;
4472
4473         vertical_adjustment.set_value (vs.y_position);
4474
4475         set_zoom_focus (vs.zoom_focus);
4476         reposition_and_zoom (vs.leftmost_frame, vs.samples_per_pixel);
4477
4478         if (vs.gui_state) {
4479                 ARDOUR_UI::instance()->gui_object_state->set_state (vs.gui_state->get_state());
4480
4481                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4482                         (*i)->clear_property_cache();
4483                         (*i)->reset_visual_state ();
4484                 }
4485         }
4486
4487         _routes->update_visibility ();
4488 }
4489
4490 /** This is the core function that controls the zoom level of the canvas. It is called
4491  *  whenever one or more calls are made to reset_zoom().  It executes in an idle handler.
4492  *  @param spp new number of samples per pixel
4493  */
4494 void
4495 Editor::set_samples_per_pixel (framecnt_t spp)
4496 {
4497         if (spp < 1) {
4498                 return;
4499         }
4500
4501         const framecnt_t three_days = 3 * 24 * 60 * 60 * (_session ? _session->frame_rate() : 48000);
4502         const framecnt_t lots_of_pixels = 4000;
4503
4504         /* if the zoom level is greater than what you'd get trying to display 3
4505          * days of audio on a really big screen, then it's too big.
4506          */
4507
4508         if (spp * lots_of_pixels > three_days) {
4509                 return;
4510         }
4511
4512         samples_per_pixel = spp;
4513 }
4514
4515 void
4516 Editor::on_samples_per_pixel_changed ()
4517 {
4518         if (tempo_lines) {
4519                 tempo_lines->tempo_map_changed(_session->tempo_map().music_origin());
4520         }
4521
4522         bool const showing_time_selection = selection->time.length() > 0;
4523
4524         if (showing_time_selection && selection->time.start () != selection->time.end_frame ()) {
4525                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4526                         (*i)->reshow_selection (selection->time);
4527                 }
4528         }
4529
4530         ZoomChanged (); /* EMIT_SIGNAL */
4531
4532         ArdourCanvas::GtkCanvasViewport* c;
4533
4534         c = get_track_canvas();
4535         if (c) {
4536                 c->canvas()->zoomed ();
4537         }
4538
4539         if (playhead_cursor) {
4540                 playhead_cursor->set_position (playhead_cursor->current_frame ());
4541         }
4542
4543         refresh_location_display();
4544         _summary->set_overlays_dirty ();
4545
4546         update_marker_labels ();
4547
4548         instant_save ();
4549 }
4550
4551 framepos_t
4552 Editor::playhead_cursor_sample () const
4553 {
4554         return playhead_cursor->current_frame();
4555 }
4556
4557 void
4558 Editor::queue_visual_videotimeline_update ()
4559 {
4560         pending_visual_change.add (VisualChange::VideoTimeline);
4561         ensure_visual_change_idle_handler ();
4562 }
4563
4564 void
4565 Editor::ensure_visual_change_idle_handler ()
4566 {
4567         if (pending_visual_change.idle_handler_id < 0) {
4568                 // see comment in add_to_idle_resize above.
4569                 pending_visual_change.idle_handler_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, _idle_visual_changer, this, NULL);
4570                 pending_visual_change.being_handled = false;
4571         }
4572 }
4573
4574 int
4575 Editor::_idle_visual_changer (void* arg)
4576 {
4577         return static_cast<Editor*>(arg)->idle_visual_changer ();
4578 }
4579
4580 void
4581 Editor::pre_render ()
4582 {
4583         visual_change_queued = false;
4584
4585         if (pending_visual_change.pending != 0) {
4586                 ensure_visual_change_idle_handler();
4587         }
4588 }
4589
4590 int
4591 Editor::idle_visual_changer ()
4592 {
4593         pending_visual_change.idle_handler_id = -1;
4594
4595         if (pending_visual_change.pending == 0) {
4596                 return 0;
4597         }
4598
4599         /* set_horizontal_position() below (and maybe other calls) call
4600            gtk_main_iteration(), so it's possible that a signal will be handled
4601            half-way through this method.  If this signal wants an
4602            idle_visual_changer we must schedule another one after this one, so
4603            mark the idle_handler_id as -1 here to allow that.  Also make a note
4604            that we are doing the visual change, so that changes in response to
4605            super-rapid-screen-update can be dropped if we are still processing
4606            the last one.
4607         */
4608
4609         if (visual_change_queued) {
4610                 return 0;
4611         }
4612
4613         pending_visual_change.being_handled = true;
4614
4615         VisualChange vc = pending_visual_change;
4616
4617         pending_visual_change.pending = (VisualChange::Type) 0;
4618
4619         visual_changer (vc);
4620
4621         pending_visual_change.being_handled = false;
4622
4623         visual_change_queued = true;
4624
4625         return 0; /* this is always a one-shot call */
4626 }
4627
4628 void
4629 Editor::visual_changer (const VisualChange& vc)
4630 {
4631         /**
4632          * Changed first so the correct horizontal canvas position is calculated in
4633          * Editor::set_horizontal_position
4634          */
4635         if (vc.pending & VisualChange::ZoomLevel) {
4636                 set_samples_per_pixel (vc.samples_per_pixel);
4637         }
4638
4639         if (vc.pending & VisualChange::TimeOrigin) {
4640                 double new_time_origin = sample_to_pixel_unrounded (vc.time_origin);
4641                 set_horizontal_position (new_time_origin);
4642         }
4643
4644         if (vc.pending & VisualChange::YOrigin) {
4645                 vertical_adjustment.set_value (vc.y_origin);
4646         }
4647
4648         /**
4649          * Now the canvas is in the final state before render the canvas items that
4650          * support the Item::prepare_for_render interface can calculate the correct
4651          * item to visible canvas intersection.
4652          */
4653         if (vc.pending & VisualChange::ZoomLevel) {
4654                 on_samples_per_pixel_changed ();
4655
4656                 compute_fixed_ruler_scale ();
4657
4658                 compute_bbt_ruler_scale (vc.time_origin, pending_visual_change.time_origin + current_page_samples());
4659                 update_tempo_based_rulers ();
4660         }
4661
4662         if (!(vc.pending & VisualChange::ZoomLevel)) {
4663                 /**
4664                  * If the canvas is not being zoomed then the canvas items will not change
4665                  * and cause Item::prepare_for_render to be called so do it here manually.
4666                  *
4667                  * Not ideal, but I can't think of a better solution atm.
4668                  */
4669                 _track_canvas->prepare_for_render();
4670         }
4671
4672         // If we are only scrolling vertically there is no need to update these
4673         if (vc.pending != VisualChange::YOrigin) {
4674                 update_fixed_rulers ();
4675                 redisplay_tempo (true);
4676
4677                 /* video frames & position need to be updated for zoom, horiz-scroll
4678                  * and (explicitly) VisualChange::VideoTimeline.
4679                  */
4680                 update_video_timeline();
4681         }
4682
4683         _summary->set_overlays_dirty ();
4684 }
4685
4686 struct EditorOrderTimeAxisSorter {
4687     bool operator() (const TimeAxisView* a, const TimeAxisView* b) const {
4688             return a->order () < b->order ();
4689     }
4690 };
4691
4692 void
4693 Editor::sort_track_selection (TrackViewList& sel)
4694 {
4695         EditorOrderTimeAxisSorter cmp;
4696         sel.sort (cmp);
4697 }
4698
4699 framepos_t
4700 Editor::get_preferred_edit_position (EditIgnoreOption ignore, bool from_context_menu, bool from_outside_canvas)
4701 {
4702         bool ignored;
4703         framepos_t where = 0;
4704         EditPoint ep = _edit_point;
4705
4706         if (Profile->get_mixbus()) {
4707                 if (ep == EditAtSelectedMarker) {
4708                         ep = EditAtPlayhead;
4709                 }
4710         }
4711
4712         if (from_outside_canvas && (ep == EditAtMouse)) {
4713                 ep = EditAtPlayhead;
4714         } else if (from_context_menu && (ep == EditAtMouse)) {
4715                 return canvas_event_sample (&context_click_event, 0, 0);
4716         }
4717
4718         if (entered_marker) {
4719                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use entered marker @ %1\n", entered_marker->position()));
4720                 return entered_marker->position();
4721         }
4722
4723         if ( (ignore==EDIT_IGNORE_PHEAD) && ep == EditAtPlayhead) {
4724                 ep = EditAtSelectedMarker;
4725         }
4726
4727         if ( (ignore==EDIT_IGNORE_MOUSE) && ep == EditAtMouse) {
4728                 ep = EditAtPlayhead;
4729         }
4730
4731         MusicFrame snap_mf (0, 0);
4732
4733         switch (ep) {
4734         case EditAtPlayhead:
4735                 if (_dragging_playhead && _control_scroll_target) {
4736                         where = *_control_scroll_target;
4737                 } else {
4738                         where = _session->audible_frame();
4739                 }
4740                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use playhead @ %1\n", where));
4741                 break;
4742
4743         case EditAtSelectedMarker:
4744                 if (!selection->markers.empty()) {
4745                         bool is_start;
4746                         Location* loc = find_location_from_marker (selection->markers.front(), is_start);
4747                         if (loc) {
4748                                 if (is_start) {
4749                                         where =  loc->start();
4750                                 } else {
4751                                         where = loc->end();
4752                                 }
4753                                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use selected marker @ %1\n", where));
4754                                 break;
4755                         }
4756                 }
4757                 /* fallthru */
4758
4759         default:
4760         case EditAtMouse:
4761                 if (!mouse_frame (where, ignored)) {
4762                         /* XXX not right but what can we do ? */
4763                         return 0;
4764                 }
4765                 snap_mf.frame = where;
4766                 snap_to (snap_mf);
4767                 where = snap_mf.frame;
4768                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use mouse @ %1\n", where));
4769                 break;
4770         }
4771
4772         return where;
4773 }
4774
4775 void
4776 Editor::set_loop_range (framepos_t start, framepos_t end, string cmd)
4777 {
4778         if (!_session) return;
4779
4780         begin_reversible_command (cmd);
4781
4782         Location* tll;
4783
4784         if ((tll = transport_loop_location()) == 0) {
4785                 Location* loc = new Location (*_session, start, end, _("Loop"),  Location::IsAutoLoop, get_grid_music_divisions(0));
4786                 XMLNode &before = _session->locations()->get_state();
4787                 _session->locations()->add (loc, true);
4788                 _session->set_auto_loop_location (loc);
4789                 XMLNode &after = _session->locations()->get_state();
4790                 _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
4791         } else {
4792                 XMLNode &before = tll->get_state();
4793                 tll->set_hidden (false, this);
4794                 tll->set (start, end);
4795                 XMLNode &after = tll->get_state();
4796                 _session->add_command (new MementoCommand<Location>(*tll, &before, &after));
4797         }
4798
4799         commit_reversible_command ();
4800 }
4801
4802 void
4803 Editor::set_punch_range (framepos_t start, framepos_t end, string cmd)
4804 {
4805         if (!_session) return;
4806
4807         begin_reversible_command (cmd);
4808
4809         Location* tpl;
4810
4811         if ((tpl = transport_punch_location()) == 0) {
4812                 Location* loc = new Location (*_session, start, end, _("Punch"),  Location::IsAutoPunch, get_grid_music_divisions(0));
4813                 XMLNode &before = _session->locations()->get_state();
4814                 _session->locations()->add (loc, true);
4815                 _session->set_auto_punch_location (loc);
4816                 XMLNode &after = _session->locations()->get_state();
4817                 _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
4818         } else {
4819                 XMLNode &before = tpl->get_state();
4820                 tpl->set_hidden (false, this);
4821                 tpl->set (start, end);
4822                 XMLNode &after = tpl->get_state();
4823                 _session->add_command (new MementoCommand<Location>(*tpl, &before, &after));
4824         }
4825
4826         commit_reversible_command ();
4827 }
4828
4829 /** Find regions which exist at a given time, and optionally on a given list of tracks.
4830  *  @param rs List to which found regions are added.
4831  *  @param where Time to look at.
4832  *  @param ts Tracks to look on; if this is empty, all tracks are examined.
4833  */
4834 void
4835 Editor::get_regions_at (RegionSelection& rs, framepos_t where, const TrackViewList& ts) const
4836 {
4837         const TrackViewList* tracks;
4838
4839         if (ts.empty()) {
4840                 tracks = &track_views;
4841         } else {
4842                 tracks = &ts;
4843         }
4844
4845         for (TrackViewList::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
4846
4847                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*t);
4848
4849                 if (rtv) {
4850                         boost::shared_ptr<Track> tr;
4851                         boost::shared_ptr<Playlist> pl;
4852
4853                         if ((tr = rtv->track()) && ((pl = tr->playlist()))) {
4854
4855                                 boost::shared_ptr<RegionList> regions = pl->regions_at (
4856                                                 (framepos_t) floor ( (double) where * tr->speed()));
4857
4858                                 for (RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
4859                                         RegionView* rv = rtv->view()->find_view (*i);
4860                                         if (rv) {
4861                                                 rs.add (rv);
4862                                         }
4863                                 }
4864                         }
4865                 }
4866         }
4867 }
4868
4869 void
4870 Editor::get_regions_after (RegionSelection& rs, framepos_t where, const TrackViewList& ts) const
4871 {
4872         const TrackViewList* tracks;
4873
4874         if (ts.empty()) {
4875                 tracks = &track_views;
4876         } else {
4877                 tracks = &ts;
4878         }
4879
4880         for (TrackViewList::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
4881                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*t);
4882                 if (rtv) {
4883                         boost::shared_ptr<Track> tr;
4884                         boost::shared_ptr<Playlist> pl;
4885
4886                         if ((tr = rtv->track()) && ((pl = tr->playlist()))) {
4887
4888                                 boost::shared_ptr<RegionList> regions = pl->regions_touched (
4889                                         (framepos_t) floor ( (double)where * tr->speed()), max_framepos);
4890
4891                                 for (RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
4892
4893                                         RegionView* rv = rtv->view()->find_view (*i);
4894
4895                                         if (rv) {
4896                                                 rs.add (rv);
4897                                         }
4898                                 }
4899                         }
4900                 }
4901         }
4902 }
4903
4904 /** Get regions using the following method:
4905  *
4906  *  Make a region list using:
4907  *   (a) any selected regions
4908  *   (b) the intersection of any selected tracks and the edit point(*)
4909  *   (c) if neither exists, and edit_point == mouse, then whatever region is under the mouse
4910  *
4911  *  (*) NOTE: in this case, if 'No Selection = All Tracks' is active, search all tracks
4912  *
4913  *  Note that we have forced the rule that selected regions and selected tracks are mutually exclusive
4914  */
4915
4916 RegionSelection
4917 Editor::get_regions_from_selection_and_edit_point (EditIgnoreOption ignore, bool from_context_menu, bool from_outside_canvas)
4918 {
4919         RegionSelection regions;
4920
4921         if (_edit_point == EditAtMouse && entered_regionview && selection->tracks.empty() && selection->regions.empty() ) {
4922                 regions.add (entered_regionview);
4923         } else {
4924                 regions = selection->regions;
4925         }
4926
4927         if ( regions.empty() ) {
4928                 TrackViewList tracks = selection->tracks;
4929
4930                 if (!tracks.empty()) {
4931                         /* no region selected or entered, but some selected tracks:
4932                          * act on all regions on the selected tracks at the edit point
4933                          */
4934                         framepos_t const where = get_preferred_edit_position (ignore, from_context_menu, from_outside_canvas);
4935                         get_regions_at(regions, where, tracks);
4936                 }
4937         }
4938
4939         return regions;
4940 }
4941
4942 /** Get regions using the following method:
4943  *
4944  *  Make a region list using:
4945  *   (a) any selected regions
4946  *   (b) the intersection of any selected tracks and the edit point(*)
4947  *   (c) if neither exists, then whatever region is under the mouse
4948  *
4949  *  (*) NOTE: in this case, if 'No Selection = All Tracks' is active, search all tracks
4950  *
4951  *  Note that we have forced the rule that selected regions and selected tracks are mutually exclusive
4952  */
4953 RegionSelection
4954 Editor::get_regions_from_selection_and_mouse (framepos_t pos)
4955 {
4956         RegionSelection regions;
4957
4958         if (entered_regionview && selection->tracks.empty() && selection->regions.empty() ) {
4959                 regions.add (entered_regionview);
4960         } else {
4961                 regions = selection->regions;
4962         }
4963
4964         if ( regions.empty() ) {
4965                 TrackViewList tracks = selection->tracks;
4966
4967                 if (!tracks.empty()) {
4968                         /* no region selected or entered, but some selected tracks:
4969                          * act on all regions on the selected tracks at the edit point
4970                          */
4971                         get_regions_at(regions, pos, tracks);
4972                 }
4973         }
4974
4975         return regions;
4976 }
4977
4978 /** Start with regions that are selected, or the entered regionview if none are selected.
4979  *  Then add equivalent regions on tracks in the same active edit-enabled route group as any
4980  *  of the regions that we started with.
4981  */
4982
4983 RegionSelection
4984 Editor::get_regions_from_selection_and_entered () const
4985 {
4986         RegionSelection regions = selection->regions;
4987
4988         if (regions.empty() && entered_regionview) {
4989                 regions.add (entered_regionview);
4990         }
4991
4992         return regions;
4993 }
4994
4995 void
4996 Editor::get_regionviews_by_id (PBD::ID const id, RegionSelection & regions) const
4997 {
4998         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
4999                 RouteTimeAxisView* rtav;
5000
5001                 if ((rtav = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
5002                         boost::shared_ptr<Playlist> pl;
5003                         std::vector<boost::shared_ptr<Region> > results;
5004                         boost::shared_ptr<Track> tr;
5005
5006                         if ((tr = rtav->track()) == 0) {
5007                                 /* bus */
5008                                 continue;
5009                         }
5010
5011                         if ((pl = (tr->playlist())) != 0) {
5012                                 boost::shared_ptr<Region> r = pl->region_by_id (id);
5013                                 if (r) {
5014                                         RegionView* rv = rtav->view()->find_view (r);
5015                                         if (rv) {
5016                                                 regions.push_back (rv);
5017                                         }
5018                                 }
5019                         }
5020                 }
5021         }
5022 }
5023
5024 void
5025 Editor::get_per_region_note_selection (list<pair<PBD::ID, set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > > &selection) const
5026 {
5027
5028         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5029                 MidiTimeAxisView* mtav;
5030
5031                 if ((mtav = dynamic_cast<MidiTimeAxisView*> (*i)) != 0) {
5032
5033                         mtav->get_per_region_note_selection (selection);
5034                 }
5035         }
5036
5037 }
5038
5039 void
5040 Editor::get_regions_corresponding_to (boost::shared_ptr<Region> region, vector<RegionView*>& regions, bool src_comparison)
5041 {
5042         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5043
5044                 RouteTimeAxisView* tatv;
5045
5046                 if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
5047
5048                         boost::shared_ptr<Playlist> pl;
5049                         vector<boost::shared_ptr<Region> > results;
5050                         RegionView* marv;
5051                         boost::shared_ptr<Track> tr;
5052
5053                         if ((tr = tatv->track()) == 0) {
5054                                 /* bus */
5055                                 continue;
5056                         }
5057
5058                         if ((pl = (tr->playlist())) != 0) {
5059                                 if (src_comparison) {
5060                                         pl->get_source_equivalent_regions (region, results);
5061                                 } else {
5062                                         pl->get_region_list_equivalent_regions (region, results);
5063                                 }
5064                         }
5065
5066                         for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
5067                                 if ((marv = tatv->view()->find_view (*ir)) != 0) {
5068                                         regions.push_back (marv);
5069                                 }
5070                         }
5071
5072                 }
5073         }
5074 }
5075
5076 RegionView*
5077 Editor::regionview_from_region (boost::shared_ptr<Region> region) const
5078 {
5079         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5080                 RouteTimeAxisView* tatv;
5081                 if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
5082                         if (!tatv->track()) {
5083                                 continue;
5084                         }
5085                         RegionView* marv = tatv->view()->find_view (region);
5086                         if (marv) {
5087                                 return marv;
5088                         }
5089                 }
5090         }
5091         return NULL;
5092 }
5093
5094 RouteTimeAxisView*
5095 Editor::rtav_from_route (boost::shared_ptr<Route> route) const
5096 {
5097         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5098                 RouteTimeAxisView* rtav;
5099                 if ((rtav = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
5100                         if (rtav->route() == route) {
5101                                 return rtav;
5102                         }
5103                 }
5104         }
5105         return NULL;
5106 }
5107
5108 void
5109 Editor::show_rhythm_ferret ()
5110 {
5111         if (rhythm_ferret == 0) {
5112                 rhythm_ferret = new RhythmFerret(*this);
5113         }
5114
5115         rhythm_ferret->set_session (_session);
5116         rhythm_ferret->show ();
5117         rhythm_ferret->present ();
5118 }
5119
5120 void
5121 Editor::first_idle ()
5122 {
5123         MessageDialog* dialog = 0;
5124
5125         if (track_views.size() > 1) {
5126                 Timers::TimerSuspender t;
5127                 dialog = new MessageDialog (
5128                         string_compose (_("Please wait while %1 loads visual data."), PROGRAM_NAME),
5129                         true
5130                         );
5131                 dialog->present ();
5132                 ARDOUR_UI::instance()->flush_pending (60);
5133         }
5134
5135         for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
5136                 (*t)->first_idle();
5137         }
5138
5139         /* now that all regionviews should exist, setup region selection */
5140
5141         RegionSelection rs;
5142
5143         for (list<PBD::ID>::iterator pr = selection->regions.pending.begin (); pr != selection->regions.pending.end (); ++pr) {
5144                 /* this is cumulative: rs is NOT cleared each time */
5145                 get_regionviews_by_id (*pr, rs);
5146         }
5147
5148         selection->set (rs);
5149
5150         // first idle adds route children (automation tracks), so we need to redisplay here
5151         _routes->redisplay ();
5152
5153         delete dialog;
5154
5155         if (_session->undo_depth() == 0) {
5156                 undo_action->set_sensitive(false);
5157         }
5158         redo_action->set_sensitive(false);
5159         begin_selection_op_history ();
5160
5161         _have_idled = true;
5162 }
5163
5164 gboolean
5165 Editor::_idle_resize (gpointer arg)
5166 {
5167         return ((Editor*)arg)->idle_resize ();
5168 }
5169
5170 void
5171 Editor::add_to_idle_resize (TimeAxisView* view, int32_t h)
5172 {
5173         if (resize_idle_id < 0) {
5174                 /* https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#G-PRIORITY-HIGH-IDLE:CAPS
5175                  * GTK+ uses G_PRIORITY_HIGH_IDLE + 10 for resizing operations, and G_PRIORITY_HIGH_IDLE + 20 for redrawing operations.
5176                  * (This is done to ensure that any pending resizes are processed before any pending redraws, so that widgets are not redrawn twice unnecessarily.)
5177                  */
5178                 resize_idle_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, _idle_resize, this, NULL);
5179                 _pending_resize_amount = 0;
5180         }
5181
5182         /* make a note of the smallest resulting height, so that we can clamp the
5183            lower limit at TimeAxisView::hSmall */
5184
5185         int32_t min_resulting = INT32_MAX;
5186
5187         _pending_resize_amount += h;
5188         _pending_resize_view = view;
5189
5190         min_resulting = min (min_resulting, int32_t (_pending_resize_view->current_height()) + _pending_resize_amount);
5191
5192         if (selection->tracks.contains (_pending_resize_view)) {
5193                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
5194                         min_resulting = min (min_resulting, int32_t ((*i)->current_height()) + _pending_resize_amount);
5195                 }
5196         }
5197
5198         if (min_resulting < 0) {
5199                 min_resulting = 0;
5200         }
5201
5202         /* clamp */
5203         if (uint32_t (min_resulting) < TimeAxisView::preset_height (HeightSmall)) {
5204                 _pending_resize_amount += TimeAxisView::preset_height (HeightSmall) - min_resulting;
5205         }
5206 }
5207
5208 /** Handle pending resizing of tracks */
5209 bool
5210 Editor::idle_resize ()
5211 {
5212         _pending_resize_view->idle_resize (_pending_resize_view->current_height() + _pending_resize_amount);
5213
5214         if (dynamic_cast<AutomationTimeAxisView*> (_pending_resize_view) == 0 &&
5215             selection->tracks.contains (_pending_resize_view)) {
5216
5217                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
5218                         if (*i != _pending_resize_view) {
5219                                 (*i)->idle_resize ((*i)->current_height() + _pending_resize_amount);
5220                         }
5221                 }
5222         }
5223
5224         _pending_resize_amount = 0;
5225         _group_tabs->set_dirty ();
5226         resize_idle_id = -1;
5227
5228         return false;
5229 }
5230
5231 void
5232 Editor::located ()
5233 {
5234         ENSURE_GUI_THREAD (*this, &Editor::located);
5235
5236         if (_session) {
5237                 playhead_cursor->set_position (_session->audible_frame ());
5238                 if (_follow_playhead && !_pending_initial_locate) {
5239                         reset_x_origin_to_follow_playhead ();
5240                 }
5241         }
5242
5243         _pending_locate_request = false;
5244         _pending_initial_locate = false;
5245         _last_update_time = 0;
5246 }
5247
5248 void
5249 Editor::region_view_added (RegionView * rv)
5250 {
5251         MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (rv);
5252         if (mrv) {
5253                 list<pair<PBD::ID const, list<Evoral::event_id_t> > >::iterator rnote;
5254                 for (rnote = selection->pending_midi_note_selection.begin(); rnote != selection->pending_midi_note_selection.end(); ++rnote) {
5255                         if (rv->region()->id () == (*rnote).first) {
5256                                 mrv->select_notes ((*rnote).second);
5257                                 selection->pending_midi_note_selection.erase(rnote);
5258                                 break;
5259                         }
5260                 }
5261         }
5262
5263         _summary->set_background_dirty ();
5264 }
5265
5266 void
5267 Editor::region_view_removed ()
5268 {
5269         _summary->set_background_dirty ();
5270 }
5271
5272 AxisView*
5273 Editor::axis_view_by_stripable (boost::shared_ptr<Stripable> s) const
5274 {
5275         for (TrackViewList::const_iterator j = track_views.begin (); j != track_views.end(); ++j) {
5276                 if ((*j)->stripable() == s) {
5277                         return *j;
5278                 }
5279         }
5280
5281         return 0;
5282 }
5283
5284 AxisView*
5285 Editor::axis_view_by_control (boost::shared_ptr<AutomationControl> c) const
5286 {
5287         for (TrackViewList::const_iterator j = track_views.begin (); j != track_views.end(); ++j) {
5288                 if ((*j)->control() == c) {
5289                         return *j;
5290                 }
5291
5292                 TimeAxisView::Children kids = (*j)->get_child_list ();
5293
5294                 for (TimeAxisView::Children::iterator k = kids.begin(); k != kids.end(); ++k) {
5295                         if ((*k)->control() == c) {
5296                                 return (*k).get();
5297                         }
5298                 }
5299         }
5300
5301         return 0;
5302 }
5303
5304 TrackViewList
5305 Editor::axis_views_from_routes (boost::shared_ptr<RouteList> r) const
5306 {
5307         TrackViewList t;
5308
5309         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5310                 TimeAxisView* tv = time_axis_view_from_stripable (*i);
5311                 if (tv) {
5312                         t.push_back (tv);
5313                 }
5314         }
5315
5316         return t;
5317 }
5318
5319 void
5320 Editor::suspend_route_redisplay ()
5321 {
5322         if (_routes) {
5323                 _routes->suspend_redisplay();
5324         }
5325 }
5326
5327 void
5328 Editor::resume_route_redisplay ()
5329 {
5330         if (_routes) {
5331                 _routes->redisplay(); // queue redisplay
5332                 _routes->resume_redisplay();
5333         }
5334 }
5335
5336 void
5337 Editor::add_vcas (VCAList& vlist)
5338 {
5339         StripableList sl;
5340
5341         for (VCAList::iterator v = vlist.begin(); v != vlist.end(); ++v) {
5342                 sl.push_back (boost::dynamic_pointer_cast<Stripable> (*v));
5343         }
5344
5345         add_stripables (sl);
5346 }
5347
5348 void
5349 Editor::add_routes (RouteList& rlist)
5350 {
5351         StripableList sl;
5352
5353         for (RouteList::iterator r = rlist.begin(); r != rlist.end(); ++r) {
5354                 sl.push_back (*r);
5355         }
5356
5357         add_stripables (sl);
5358 }
5359
5360 void
5361 Editor::add_stripables (StripableList& sl)
5362 {
5363         list<TimeAxisView*> new_views;
5364         boost::shared_ptr<VCA> v;
5365         boost::shared_ptr<Route> r;
5366         TrackViewList new_selection;
5367         bool from_scratch = (track_views.size() == 0);
5368
5369         sl.sort (Stripable::Sorter());
5370
5371         for (StripableList::iterator s = sl.begin(); s != sl.end(); ++s) {
5372
5373                 if ((v = boost::dynamic_pointer_cast<VCA> (*s)) != 0) {
5374
5375                         VCATimeAxisView* vtv = new VCATimeAxisView (*this, _session, *_track_canvas);
5376                         vtv->set_vca (v);
5377                         new_views.push_back (vtv);
5378
5379                 } else if ((r = boost::dynamic_pointer_cast<Route> (*s)) != 0) {
5380
5381                         if (r->is_auditioner() || r->is_monitor()) {
5382                                 continue;
5383                         }
5384
5385                         RouteTimeAxisView* rtv;
5386                         DataType dt = r->input()->default_type();
5387
5388                         if (dt == ARDOUR::DataType::AUDIO) {
5389                                 rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
5390                                 rtv->set_route (r);
5391                         } else if (dt == ARDOUR::DataType::MIDI) {
5392                                 rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
5393                                 rtv->set_route (r);
5394                         } else {
5395                                 throw unknown_type();
5396                         }
5397
5398                         new_views.push_back (rtv);
5399                         track_views.push_back (rtv);
5400                         new_selection.push_back (rtv);
5401
5402                         rtv->effective_gain_display ();
5403
5404                         rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
5405                         rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
5406                 }
5407         }
5408
5409         if (new_views.size() > 0) {
5410                 _routes->time_axis_views_added (new_views);
5411                 //_summary->routes_added (new_selection); /* XXX requires RouteTimeAxisViewList */
5412         }
5413
5414         /* note: !new_selection.empty() means that we got some routes rather
5415          * than just VCAs
5416          */
5417
5418         if (!from_scratch && !new_selection.empty()) {
5419                 selection->set (new_selection);
5420                 begin_selection_op_history();
5421         }
5422
5423         if (show_editor_mixer_when_tracks_arrive && !new_selection.empty()) {
5424                 show_editor_mixer (true);
5425         }
5426
5427         editor_list_button.set_sensitive (true);
5428 }
5429
5430 void
5431 Editor::timeaxisview_deleted (TimeAxisView *tv)
5432 {
5433         if (tv == entered_track) {
5434                 entered_track = 0;
5435         }
5436
5437         if (_session && _session->deletion_in_progress()) {
5438                 /* the situation is under control */
5439                 return;
5440         }
5441
5442         ENSURE_GUI_THREAD (*this, &Editor::timeaxisview_deleted, tv);
5443
5444         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (tv);
5445
5446         _routes->route_removed (tv);
5447
5448         TimeAxisView::Children c = tv->get_child_list ();
5449         for (TimeAxisView::Children::const_iterator i = c.begin(); i != c.end(); ++i) {
5450                 if (entered_track == i->get()) {
5451                         entered_track = 0;
5452                 }
5453         }
5454
5455         /* remove it from the list of track views */
5456
5457         TrackViewList::iterator i;
5458
5459         if ((i = find (track_views.begin(), track_views.end(), tv)) != track_views.end()) {
5460                 i = track_views.erase (i);
5461         }
5462
5463         /* update whatever the current mixer strip is displaying, if revelant */
5464
5465         boost::shared_ptr<Route> route;
5466
5467         if (rtav) {
5468                 route = rtav->route ();
5469         }
5470
5471         if (current_mixer_strip && current_mixer_strip->route() == route) {
5472
5473                 TimeAxisView* next_tv;
5474
5475                 if (track_views.empty()) {
5476                         next_tv = 0;
5477                 } else if (i == track_views.end()) {
5478                         next_tv = track_views.front();
5479                 } else {
5480                         next_tv = (*i);
5481                 }
5482
5483                 // skip VCAs (cannot be selected, n/a in editor-mixer)
5484                 if (dynamic_cast<VCATimeAxisView*> (next_tv)) {
5485                         /* VCAs are sorted last in line -- route_sorter.h, jump to top */
5486                         next_tv = track_views.front();
5487                 }
5488                 if (dynamic_cast<VCATimeAxisView*> (next_tv)) {
5489                         /* just in case: no master, only a VCA remains */
5490                         next_tv = 0;
5491                 }
5492
5493
5494                 if (next_tv) {
5495                         set_selected_mixer_strip (*next_tv);
5496                 } else {
5497                         /* make the editor mixer strip go away setting the
5498                          * button to inactive (which also unticks the menu option)
5499                          */
5500
5501                         ActionManager::uncheck_toggleaction ("<Actions>/Editor/show-editor-mixer");
5502                 }
5503         }
5504 }
5505
5506 void
5507 Editor::hide_track_in_display (TimeAxisView* tv, bool apply_to_selection)
5508 {
5509         if (!tv) {
5510                 return;
5511         }
5512         if (apply_to_selection) {
5513                 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ) {
5514
5515                         TrackSelection::iterator j = i;
5516                         ++j;
5517
5518                         hide_track_in_display (*i, false);
5519
5520                         i = j;
5521                 }
5522         } else {
5523                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
5524
5525                 if (rtv && current_mixer_strip && (rtv->route() == current_mixer_strip->route())) {
5526                         // this will hide the mixer strip
5527                         set_selected_mixer_strip (*tv);
5528                 }
5529
5530                 _routes->hide_track_in_display (*tv);
5531         }
5532 }
5533
5534 void
5535 Editor::show_track_in_display (TimeAxisView* tv, bool move_into_view)
5536 {
5537         if (!tv) {
5538                 return;
5539         }
5540         _routes->show_track_in_display (*tv);
5541         if (move_into_view) {
5542                 ensure_time_axis_view_is_visible (*tv, false);
5543         }
5544 }
5545
5546 bool
5547 Editor::sync_track_view_list_and_routes ()
5548 {
5549         track_views = TrackViewList (_routes->views ());
5550
5551         _summary->set_background_dirty();
5552         _group_tabs->set_dirty ();
5553
5554         return false; // do not call again (until needed)
5555 }
5556
5557 void
5558 Editor::foreach_time_axis_view (sigc::slot<void,TimeAxisView&> theslot)
5559 {
5560         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5561                 theslot (**i);
5562         }
5563 }
5564
5565 /** Find a StripableTimeAxisView by the ID of its stripable */
5566 StripableTimeAxisView*
5567 Editor::get_stripable_time_axis_by_id (const PBD::ID& id) const
5568 {
5569         StripableTimeAxisView* v;
5570
5571         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5572                 if((v = dynamic_cast<StripableTimeAxisView*>(*i)) != 0) {
5573                         if(v->stripable()->id() == id) {
5574                                 return v;
5575                         }
5576                 }
5577         }
5578
5579         return 0;
5580 }
5581
5582 void
5583 Editor::fit_route_group (RouteGroup *g)
5584 {
5585         TrackViewList ts = axis_views_from_routes (g->route_list ());
5586         fit_tracks (ts);
5587 }
5588
5589 void
5590 Editor::consider_auditioning (boost::shared_ptr<Region> region)
5591 {
5592         boost::shared_ptr<AudioRegion> r = boost::dynamic_pointer_cast<AudioRegion> (region);
5593
5594         if (r == 0) {
5595                 _session->cancel_audition ();
5596                 return;
5597         }
5598
5599         if (_session->is_auditioning()) {
5600                 _session->cancel_audition ();
5601                 if (r == last_audition_region) {
5602                         return;
5603                 }
5604         }
5605
5606         _session->audition_region (r);
5607         last_audition_region = r;
5608 }
5609
5610
5611 void
5612 Editor::hide_a_region (boost::shared_ptr<Region> r)
5613 {
5614         r->set_hidden (true);
5615 }
5616
5617 void
5618 Editor::show_a_region (boost::shared_ptr<Region> r)
5619 {
5620         r->set_hidden (false);
5621 }
5622
5623 void
5624 Editor::audition_region_from_region_list ()
5625 {
5626         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::consider_auditioning));
5627 }
5628
5629 void
5630 Editor::hide_region_from_region_list ()
5631 {
5632         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::hide_a_region));
5633 }
5634
5635 void
5636 Editor::show_region_in_region_list ()
5637 {
5638         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::show_a_region));
5639 }
5640
5641 void
5642 Editor::step_edit_status_change (bool yn)
5643 {
5644         if (yn) {
5645                 start_step_editing ();
5646         } else {
5647                 stop_step_editing ();
5648         }
5649 }
5650
5651 void
5652 Editor::start_step_editing ()
5653 {
5654         step_edit_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &Editor::check_step_edit), 20);
5655 }
5656
5657 void
5658 Editor::stop_step_editing ()
5659 {
5660         step_edit_connection.disconnect ();
5661 }
5662
5663 bool
5664 Editor::check_step_edit ()
5665 {
5666         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5667                 MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (*i);
5668                 if (mtv) {
5669                         mtv->check_step_edit ();
5670                 }
5671         }
5672
5673         return true; // do it again, till we stop
5674 }
5675
5676 bool
5677 Editor::scroll_press (Direction dir)
5678 {
5679         ++_scroll_callbacks;
5680
5681         if (_scroll_connection.connected() && _scroll_callbacks < 5) {
5682                 /* delay the first auto-repeat */
5683                 return true;
5684         }
5685
5686         switch (dir) {
5687         case LEFT:
5688                 scroll_backward (1);
5689                 break;
5690
5691         case RIGHT:
5692                 scroll_forward (1);
5693                 break;
5694
5695         case UP:
5696                 scroll_up_one_track ();
5697                 break;
5698
5699         case DOWN:
5700                 scroll_down_one_track ();
5701                 break;
5702         }
5703
5704         /* do hacky auto-repeat */
5705         if (!_scroll_connection.connected ()) {
5706
5707                 _scroll_connection = Glib::signal_timeout().connect (
5708                         sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), dir), 100
5709                         );
5710
5711                 _scroll_callbacks = 0;
5712         }
5713
5714         return true;
5715 }
5716
5717 void
5718 Editor::scroll_release ()
5719 {
5720         _scroll_connection.disconnect ();
5721 }
5722
5723 /** Queue a change for the Editor viewport x origin to follow the playhead */
5724 void
5725 Editor::reset_x_origin_to_follow_playhead ()
5726 {
5727         framepos_t const frame = playhead_cursor->current_frame ();
5728
5729         if (frame < leftmost_frame || frame > leftmost_frame + current_page_samples()) {
5730
5731                 if (_session->transport_speed() < 0) {
5732
5733                         if (frame > (current_page_samples() / 2)) {
5734                                 center_screen (frame-(current_page_samples()/2));
5735                         } else {
5736                                 center_screen (current_page_samples()/2);
5737                         }
5738
5739                 } else {
5740
5741                         framepos_t l = 0;
5742
5743                         if (frame < leftmost_frame) {
5744                                 /* moving left */
5745                                 if (_session->transport_rolling()) {
5746                                         /* rolling; end up with the playhead at the right of the page */
5747                                         l = frame - current_page_samples ();
5748                                 } else {
5749                                         /* not rolling: end up with the playhead 1/4 of the way along the page */
5750                                         l = frame - current_page_samples() / 4;
5751                                 }
5752                         } else {
5753                                 /* moving right */
5754                                 if (_session->transport_rolling()) {
5755                                         /* rolling: end up with the playhead on the left of the page */
5756                                         l = frame;
5757                                 } else {
5758                                         /* not rolling: end up with the playhead 3/4 of the way along the page */
5759                                         l = frame - 3 * current_page_samples() / 4;
5760                                 }
5761                         }
5762
5763                         if (l < 0) {
5764                                 l = 0;
5765                         }
5766
5767                         center_screen_internal (l + (current_page_samples() / 2), current_page_samples ());
5768                 }
5769         }
5770 }
5771
5772 void
5773 Editor::super_rapid_screen_update ()
5774 {
5775         if (!_session || !_session->engine().running()) {
5776                 return;
5777         }
5778
5779         /* METERING / MIXER STRIPS */
5780
5781         /* update track meters, if required */
5782         if (contents().is_mapped() && meters_running) {
5783                 RouteTimeAxisView* rtv;
5784                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5785                         if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
5786                                 rtv->fast_update ();
5787                         }
5788                 }
5789         }
5790
5791         /* and any current mixer strip */
5792         if (current_mixer_strip) {
5793                 current_mixer_strip->fast_update ();
5794         }
5795
5796         /* PLAYHEAD AND VIEWPORT */
5797
5798         /* There are a few reasons why we might not update the playhead / viewport stuff:
5799          *
5800          * 1.  we don't update things when there's a pending locate request, otherwise
5801          *     when the editor requests a locate there is a chance that this method
5802          *     will move the playhead before the locate request is processed, causing
5803          *     a visual glitch.
5804          * 2.  if we're not rolling, there's nothing to do here (locates are handled elsewhere).
5805          * 3.  if we're still at the same frame that we were last time, there's nothing to do.
5806          */
5807         if (_pending_locate_request || !_session->transport_rolling ()) {
5808                 _last_update_time = 0;
5809                 return;
5810         }
5811
5812         if (_dragging_playhead) {
5813                 _last_update_time = 0;
5814                 return;
5815         }
5816
5817         bool latent_locate = false;
5818         framepos_t frame = _session->audible_frame (&latent_locate);
5819         const int64_t now = g_get_monotonic_time ();
5820         double err = 0;
5821
5822         if (_session->exporting ()) {
5823                 /* freewheel/export may be faster or slower than transport_speed() / SR.
5824                  * Also exporting multiple ranges locates/jumps without a _pending_locate_request.
5825                  */
5826                 _last_update_time = 0;
5827         }
5828
5829         if (_last_update_time > 0) {
5830                 /* interpolate and smoothen playhead position */
5831                 const double ds =  (now - _last_update_time) * _session->transport_speed() * _session->nominal_frame_rate () * 1e-6;
5832                 framepos_t guess = playhead_cursor->current_frame () + rint (ds);
5833                 err = frame - guess;
5834
5835                 guess += err * .12 + _err_screen_engine; // time-constant based on 25fps (super_rapid_screen_update)
5836                 _err_screen_engine += .0144 * (err - _err_screen_engine); // tc^2
5837
5838 #if 0 // DEBUG
5839                 printf ("eng: %ld  gui:%ld (%+6.1f)  diff: %6.1f (err: %7.2f)\n",
5840                                 frame, guess, ds,
5841                                 err, _err_screen_engine);
5842 #endif
5843
5844                 frame = guess;
5845         } else {
5846                 _err_screen_engine = 0;
5847         }
5848
5849         if (err > 8192 || latent_locate) {
5850                 // in case of x-runs or freewheeling
5851                 _last_update_time = 0;
5852                 frame = _session->audible_frame ();
5853         } else {
5854                 _last_update_time = now;
5855         }
5856
5857         if (playhead_cursor->current_frame () == frame) {
5858                 return;
5859         }
5860
5861         playhead_cursor->set_position (frame);
5862
5863         if (_session->requested_return_frame() >= 0) {
5864                 _last_update_time = 0;
5865                 return;
5866         }
5867
5868         if (!_follow_playhead || pending_visual_change.being_handled) {
5869                 /* We only do this if we aren't already
5870                  * handling a visual change (ie if
5871                  * pending_visual_change.being_handled is
5872                  * false) so that these requests don't stack
5873                  * up there are too many of them to handle in
5874                  * time.
5875                  */
5876                 return;
5877         }
5878
5879         if (!_stationary_playhead) {
5880                 reset_x_origin_to_follow_playhead ();
5881         } else {
5882                 framepos_t const frame = playhead_cursor->current_frame ();
5883                 double target = ((double)frame - (double)current_page_samples() / 2.0);
5884                 if (target <= 0.0) {
5885                         target = 0.0;
5886                 }
5887                 // compare to EditorCursor::set_position()
5888                 double const old_pos = sample_to_pixel_unrounded (leftmost_frame);
5889                 double const new_pos = sample_to_pixel_unrounded (target);
5890                 if (rint (new_pos) != rint (old_pos)) {
5891                         reset_x_origin (pixel_to_sample (new_pos));
5892                 }
5893         }
5894 }
5895
5896
5897 void
5898 Editor::session_going_away ()
5899 {
5900         _have_idled = false;
5901
5902         _session_connections.drop_connections ();
5903
5904         super_rapid_screen_update_connection.disconnect ();
5905
5906         selection->clear ();
5907         cut_buffer->clear ();
5908
5909         clicked_regionview = 0;
5910         clicked_axisview = 0;
5911         clicked_routeview = 0;
5912         entered_regionview = 0;
5913         entered_track = 0;
5914         _last_update_time = 0;
5915         _drags->abort ();
5916
5917         playhead_cursor->hide ();
5918
5919         /* rip everything out of the list displays */
5920
5921         _regions->clear ();
5922         _routes->clear ();
5923         _route_groups->clear ();
5924
5925         /* do this first so that deleting a track doesn't reset cms to null
5926            and thus cause a leak.
5927         */
5928
5929         if (current_mixer_strip) {
5930                 if (current_mixer_strip->get_parent() != 0) {
5931                         global_hpacker.remove (*current_mixer_strip);
5932                 }
5933                 delete current_mixer_strip;
5934                 current_mixer_strip = 0;
5935         }
5936
5937         /* delete all trackviews */
5938
5939         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5940                 delete *i;
5941         }
5942         track_views.clear ();
5943
5944         nudge_clock->set_session (0);
5945
5946         editor_list_button.set_active(false);
5947         editor_list_button.set_sensitive(false);
5948
5949         /* clear tempo/meter rulers */
5950         remove_metric_marks ();
5951         hide_measures ();
5952         clear_marker_display ();
5953
5954         delete tempo_lines;
5955         tempo_lines = 0;
5956
5957         stop_step_editing ();
5958
5959         if (own_window()) {
5960
5961                 /* get rid of any existing editor mixer strip */
5962
5963                 WindowTitle title(Glib::get_application_name());
5964                 title += _("Editor");
5965
5966                 own_window()->set_title (title.get_string());
5967         }
5968
5969         SessionHandlePtr::session_going_away ();
5970 }
5971
5972 void
5973 Editor::trigger_script (int i)
5974 {
5975         LuaInstance::instance()-> call_action (i);
5976 }
5977
5978 void
5979 Editor::show_editor_list (bool yn)
5980 {
5981         if (yn) {
5982                 _editor_list_vbox.show ();
5983         } else {
5984                 _editor_list_vbox.hide ();
5985         }
5986 }
5987
5988 void
5989 Editor::change_region_layering_order (bool from_context_menu)
5990 {
5991         const framepos_t position = get_preferred_edit_position (EDIT_IGNORE_NONE, from_context_menu);
5992
5993         if (!clicked_routeview) {
5994                 if (layering_order_editor) {
5995                         layering_order_editor->hide ();
5996                 }
5997                 return;
5998         }
5999
6000         boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (clicked_routeview->route());
6001
6002         if (!track) {
6003                 return;
6004         }
6005
6006         boost::shared_ptr<Playlist> pl = track->playlist();
6007
6008         if (!pl) {
6009                 return;
6010         }
6011
6012         if (layering_order_editor == 0) {
6013                 layering_order_editor = new RegionLayeringOrderEditor (*this);
6014         }
6015
6016         layering_order_editor->set_context (clicked_routeview->name(), _session, clicked_routeview, pl, position);
6017         layering_order_editor->maybe_present ();
6018 }
6019
6020 void
6021 Editor::update_region_layering_order_editor ()
6022 {
6023         if (layering_order_editor && layering_order_editor->is_visible ()) {
6024                 change_region_layering_order (true);
6025         }
6026 }
6027
6028 void
6029 Editor::setup_fade_images ()
6030 {
6031         _xfade_in_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("fadein-linear")));
6032         _xfade_in_images[FadeSymmetric] = new Gtk::Image (get_icon_path (X_("fadein-symmetric")));
6033         _xfade_in_images[FadeFast] = new Gtk::Image (get_icon_path (X_("fadein-fast-cut")));
6034         _xfade_in_images[FadeSlow] = new Gtk::Image (get_icon_path (X_("fadein-slow-cut")));
6035         _xfade_in_images[FadeConstantPower] = new Gtk::Image (get_icon_path (X_("fadein-constant-power")));
6036
6037         _xfade_out_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("fadeout-linear")));
6038         _xfade_out_images[FadeSymmetric] = new Gtk::Image (get_icon_path (X_("fadeout-symmetric")));
6039         _xfade_out_images[FadeFast] = new Gtk::Image (get_icon_path (X_("fadeout-fast-cut")));
6040         _xfade_out_images[FadeSlow] = new Gtk::Image (get_icon_path (X_("fadeout-slow-cut")));
6041         _xfade_out_images[FadeConstantPower] = new Gtk::Image (get_icon_path (X_("fadeout-constant-power")));
6042
6043 }
6044
6045 /** @return Gtk::manage()d menu item for a given action from `editor_actions' */
6046 Gtk::MenuItem&
6047 Editor::action_menu_item (std::string const & name)
6048 {
6049         Glib::RefPtr<Action> a = editor_actions->get_action (name);
6050         assert (a);
6051
6052         return *manage (a->create_menu_item ());
6053 }
6054
6055 void
6056 Editor::add_notebook_page (string const & name, Gtk::Widget& widget)
6057 {
6058         EventBox* b = manage (new EventBox);
6059         b->signal_button_press_event().connect (sigc::bind (sigc::mem_fun (*this, &Editor::notebook_tab_clicked), &widget));
6060         Label* l = manage (new Label (name));
6061         l->set_angle (-90);
6062         b->add (*l);
6063         b->show_all ();
6064         _the_notebook.append_page (widget, *b);
6065 }
6066
6067 bool
6068 Editor::notebook_tab_clicked (GdkEventButton* ev, Gtk::Widget* page)
6069 {
6070         if (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_2BUTTON_PRESS) {
6071                 _the_notebook.set_current_page (_the_notebook.page_num (*page));
6072         }
6073
6074         if (ev->type == GDK_2BUTTON_PRESS) {
6075
6076                 /* double-click on a notebook tab shrinks or expands the notebook */
6077
6078                 if (_notebook_shrunk) {
6079                         if (pre_notebook_shrink_pane_width) {
6080                                 edit_pane.set_divider (0, *pre_notebook_shrink_pane_width);
6081                         }
6082                         _notebook_shrunk = false;
6083                 } else {
6084                         pre_notebook_shrink_pane_width = edit_pane.get_divider();
6085
6086                         /* this expands the LHS of the edit pane to cover the notebook
6087                            PAGE but leaves the tabs visible.
6088                          */
6089                         edit_pane.set_divider (0, edit_pane.get_divider() + page->get_width());
6090                         _notebook_shrunk = true;
6091                 }
6092         }
6093
6094         return true;
6095 }
6096
6097 void
6098 Editor::popup_control_point_context_menu (ArdourCanvas::Item* item, GdkEvent* event)
6099 {
6100         using namespace Menu_Helpers;
6101
6102         MenuList& items = _control_point_context_menu.items ();
6103         items.clear ();
6104
6105         items.push_back (MenuElem (_("Edit..."), sigc::bind (sigc::mem_fun (*this, &Editor::edit_control_point), item)));
6106         items.push_back (MenuElem (_("Delete"), sigc::bind (sigc::mem_fun (*this, &Editor::remove_control_point), item)));
6107         if (!can_remove_control_point (item)) {
6108                 items.back().set_sensitive (false);
6109         }
6110
6111         _control_point_context_menu.popup (event->button.button, event->button.time);
6112 }
6113
6114 void
6115 Editor::popup_note_context_menu (ArdourCanvas::Item* item, GdkEvent* event)
6116 {
6117         using namespace Menu_Helpers;
6118
6119         NoteBase* note = reinterpret_cast<NoteBase*>(item->get_data("notebase"));
6120         if (!note) {
6121                 return;
6122         }
6123
6124         /* We need to get the selection here and pass it to the operations, since
6125            popping up the menu will cause a region leave event which clears
6126            entered_regionview. */
6127
6128         MidiRegionView&       mrv = note->region_view();
6129         const RegionSelection rs  = get_regions_from_selection_and_entered ();
6130         const uint32_t sel_size = mrv.selection_size ();
6131
6132         MenuList& items = _note_context_menu.items();
6133         items.clear();
6134
6135         if (sel_size > 0) {
6136                 items.push_back(MenuElem(_("Delete"),
6137                                          sigc::mem_fun(mrv, &MidiRegionView::delete_selection)));
6138         }
6139
6140         items.push_back(MenuElem(_("Edit..."),
6141                                  sigc::bind(sigc::mem_fun(*this, &Editor::edit_notes), &mrv)));
6142         if (sel_size != 1) {
6143                 items.back().set_sensitive (false);
6144         }
6145
6146         items.push_back(MenuElem(_("Transpose..."),
6147                                  sigc::bind(sigc::mem_fun(*this, &Editor::transpose_regions), rs)));
6148
6149
6150         items.push_back(MenuElem(_("Legatize"),
6151                                  sigc::bind(sigc::mem_fun(*this, &Editor::legatize_regions), rs, false)));
6152         if (sel_size < 2) {
6153                 items.back().set_sensitive (false);
6154         }
6155
6156         items.push_back(MenuElem(_("Quantize..."),
6157                                  sigc::bind(sigc::mem_fun(*this, &Editor::quantize_regions), rs)));
6158
6159         items.push_back(MenuElem(_("Remove Overlap"),
6160                                  sigc::bind(sigc::mem_fun(*this, &Editor::legatize_regions), rs, true)));
6161         if (sel_size < 2) {
6162                 items.back().set_sensitive (false);
6163         }
6164
6165         items.push_back(MenuElem(_("Transform..."),
6166                                  sigc::bind(sigc::mem_fun(*this, &Editor::transform_regions), rs)));
6167
6168         _note_context_menu.popup (event->button.button, event->button.time);
6169 }
6170
6171 void
6172 Editor::zoom_vertical_modifier_released()
6173 {
6174         _stepping_axis_view = 0;
6175 }
6176
6177 void
6178 Editor::ui_parameter_changed (string parameter)
6179 {
6180         if (parameter == "icon-set") {
6181                 while (!_cursor_stack.empty()) {
6182                         _cursor_stack.pop_back();
6183                 }
6184                 _cursors->set_cursor_set (UIConfiguration::instance().get_icon_set());
6185                 _cursor_stack.push_back(_cursors->grabber);
6186                 edit_pane.set_drag_cursor (*_cursors->expand_left_right);
6187                 editor_summary_pane.set_drag_cursor (*_cursors->expand_up_down);
6188
6189         } else if (parameter == "draggable-playhead") {
6190                 if (_verbose_cursor) {
6191                         playhead_cursor->set_sensitive (UIConfiguration::instance().get_draggable_playhead());
6192                 }
6193         }
6194 }
6195
6196 Gtk::Window*
6197 Editor::use_own_window (bool and_fill_it)
6198 {
6199         bool new_window = !own_window();
6200
6201         Gtk::Window* win = Tabbable::use_own_window (and_fill_it);
6202
6203         if (win && new_window) {
6204                 win->set_name ("EditorWindow");
6205
6206                 ARDOUR_UI::instance()->setup_toplevel_window (*win, _("Editor"), this);
6207
6208                 // win->signal_realize().connect (*this, &Editor::on_realize);
6209                 win->signal_event().connect (sigc::bind (sigc::ptr_fun (&Keyboard::catch_user_event_for_pre_dialog_focus), win));
6210                 win->signal_event().connect (sigc::mem_fun (*this, &Editor::generic_event_handler));
6211                 win->set_data ("ardour-bindings", bindings);
6212
6213                 update_title ();
6214         }
6215
6216         DisplaySuspender ds;
6217         contents().show_all ();
6218
6219         /* XXX: this is a bit unfortunate; it would probably
6220            be nicer if we could just call show () above rather
6221            than needing the show_all ()
6222         */
6223
6224         /* re-hide stuff if necessary */
6225         editor_list_button_toggled ();
6226         parameter_changed ("show-summary");
6227         parameter_changed ("show-group-tabs");
6228         parameter_changed ("show-zoom-tools");
6229
6230         /* now reset all audio_time_axis heights, because widgets might need
6231            to be re-hidden
6232         */
6233
6234         TimeAxisView *tv;
6235
6236         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
6237                 tv = (static_cast<TimeAxisView*>(*i));
6238                 tv->reset_height ();
6239         }
6240
6241         if (current_mixer_strip) {
6242                 current_mixer_strip->hide_things ();
6243                 current_mixer_strip->parameter_changed ("mixer-element-visibility");
6244         }
6245
6246         return win;
6247 }