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/eventboxext.h"
  61 #include "gtkmm2ext/grouped_buttons.h"
  62 #include "gtkmm2ext/gtk_ui.h"
  63 #include <gtkmm2ext/keyboard.h>
  64 #include "gtkmm2ext/utils.h"
  65 #include "gtkmm2ext/window_title.h"
  66 #include "gtkmm2ext/choice.h"
  67 #include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
  68
  69 #include "ardour/analysis_graph.h"
  70 #include "ardour/audio_track.h"
  71 #include "ardour/audioengine.h"
  72 #include "ardour/audioregion.h"
  73 #include "ardour/lmath.h"
  74 #include "ardour/location.h"
  75 #include "ardour/profile.h"
  76 #include "ardour/route.h"
  77 #include "ardour/route_group.h"
  78 #include "ardour/session_playlists.h"
  79 #include "ardour/tempo.h"
  80 #include "ardour/utils.h"
  81 #include "ardour/vca_manager.h"
  82 #include "ardour/vca.h"
  83
  84 #include "canvas/debug.h"
  85 #include "canvas/text.h"
  86
  87 #include "control_protocol/control_protocol.h"
  88
  89 #include "actions.h"
  90 #include "analysis_window.h"
  91 #include "ardour_spacer.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 "tooltips.h"
 141 #include "ui_config.h"
 142 #include "utils.h"
 143 #include "vca_time_axis.h"
 144 #include "verbose_cursor.h"
 145
 146 #include "pbd/i18n.h"
 147
 148 using namespace std;
 149 using namespace ARDOUR;
 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_mark_modulo (0)
 306         , timecode_nmarks (0)
 307         , _samples_ruler_interval (0)
 308         , bbt_bars (0)
 309         , bbt_nmarks (0)
 310         , bbt_bar_helper_on (0)
 311         , bbt_accent_modulo (0)
 312         , timecode_ruler (0)
 313         , bbt_ruler (0)
 314         , samples_ruler (0)
 315         , minsec_ruler (0)
 316         , visible_timebars (0)
 317         , editor_ruler_menu (0)
 318         , tempo_bar (0)
 319         , meter_bar (0)
 320         , marker_bar (0)
 321         , range_marker_bar (0)
 322         , transport_marker_bar (0)
 323         , cd_marker_bar (0)
 324         , minsec_label (_("Mins:Secs"))
 325         , bbt_label (_("Bars:Beats"))
 326         , timecode_label (_("Timecode"))
 327         , samples_label (_("Samples"))
 328         , tempo_label (_("Tempo"))
 329         , meter_label (_("Meter"))
 330         , mark_label (_("Location Markers"))
 331         , range_mark_label (_("Range Markers"))
 332         , transport_mark_label (_("Loop/Punch Ranges"))
 333         , cd_mark_label (_("CD Markers"))
 334         , videotl_label (_("Video Timeline"))
 335         , videotl_group (0)
 336         , playhead_cursor (0)
 337         , edit_packer (4, 4, true)
 338         , vertical_adjustment (0.0, 0.0, 10.0, 400.0)
 339         , horizontal_adjustment (0.0, 0.0, 1e16)
 340         , unused_adjustment (0.0, 0.0, 10.0, 400.0)
 341         , controls_layout (unused_adjustment, vertical_adjustment)
 342         , _scroll_callbacks (0)
 343         , _visible_canvas_width (0)
 344         , _visible_canvas_height (0)
 345         , _full_canvas_height (0)
 346         , edit_controls_left_menu (0)
 347         , edit_controls_right_menu (0)
 348         , visual_change_queued(false)
 349         , _last_update_time (0)
 350         , _err_screen_engine (0)
 351         , cut_buffer_start (0)
 352         , cut_buffer_length (0)
 353         , button_bindings (0)
 354         , last_paste_pos (0)
 355         , paste_count (0)
 356         , sfbrowser (0)
 357         , current_interthread_info (0)
 358         , analysis_window (0)
 359         , select_new_marker (false)
 360         , last_scrub_x (0)
 361         , scrubbing_direction (0)
 362         , scrub_reversals (0)
 363         , scrub_reverse_distance (0)
 364         , have_pending_keyboard_selection (false)
 365         , pending_keyboard_selection_start (0)
 366         , _snap_type (SnapToBeat)
 367         , _snap_mode (SnapOff)
 368         , snap_threshold (5.0)
 369         , ignore_gui_changes (false)
 370         , _drags (new DragManager (this))
 371         , lock_dialog (0)
 372           /* , last_event_time { 0, 0 } */ /* this initialization style requires C++11 */
 373         , _dragging_playhead (false)
 374         , _dragging_edit_point (false)
 375         , _show_measures (true)
 376         , _follow_playhead (true)
 377         , _stationary_playhead (false)
 378         , _maximised (false)
 379         , tempo_lines (0)
 380         , global_rect_group (0)
 381         , time_line_group (0)
 382         , tempo_marker_menu (0)
 383         , meter_marker_menu (0)
 384         , marker_menu (0)
 385         , range_marker_menu (0)
 386         , transport_marker_menu (0)
 387         , new_transport_marker_menu (0)
 388         , cd_marker_menu (0)
 389         , marker_menu_item (0)
 390         , bbt_beat_subdivision (4)
 391         , _visible_track_count (-1)
 392         ,  toolbar_selection_clock_table (2,3)
 393         ,  automation_mode_button (_("mode"))
 394         , selection (new Selection (this, true))
 395         , cut_buffer (new Selection (this, false))
 396         , _selection_memento (new SelectionMemento())
 397         , _all_region_actions_sensitized (false)
 398         , _ignore_region_action (false)
 399         , _last_region_menu_was_main (false)
 400         , _track_selection_change_without_scroll (false)
 401         , cd_marker_bar_drag_rect (0)
 402         , range_bar_drag_rect (0)
 403         , transport_bar_drag_rect (0)
 404         , transport_bar_range_rect (0)
 405         , transport_bar_preroll_rect (0)
 406         , transport_bar_postroll_rect (0)
 407         , transport_loop_range_rect (0)
 408         , transport_punch_range_rect (0)
 409         , transport_punchin_line (0)
 410         , transport_punchout_line (0)
 411         , transport_preroll_rect (0)
 412         , transport_postroll_rect (0)
 413         , temp_location (0)
 414         , rubberband_rect (0)
 415         , _route_groups (0)
 416         , _routes (0)
 417         , _regions (0)
 418         , _snapshots (0)
 419         , _locations (0)
 420         , autoscroll_horizontal_allowed (false)
 421         , autoscroll_vertical_allowed (false)
 422         , autoscroll_cnt (0)
 423         , autoscroll_widget (0)
 424         , show_gain_after_trim (false)
 425         , selection_op_cmd_depth (0)
 426         , selection_op_history_it (0)
 427         , no_save_instant (false)
 428         , current_timefx (0)
 429         , current_mixer_strip (0)
 430         , show_editor_mixer_when_tracks_arrive (false)
 431         ,  nudge_clock (new AudioClock (X_("nudge"), false, X_("nudge"), true, false, true))
 432         , current_stepping_trackview (0)
 433         , last_track_height_step_timestamp (0)
 434         , entered_track (0)
 435         , entered_regionview (0)
 436         , clear_entered_track (false)
 437         , _edit_point (EditAtMouse)
 438         , meters_running (false)
 439         , rhythm_ferret (0)
 440         , _have_idled (false)
 441         , resize_idle_id (-1)
 442         , _pending_resize_amount (0)
 443         , _pending_resize_view (0)
 444         , _pending_locate_request (false)
 445         , _pending_initial_locate (false)
 446         , _summary (0)
 447         , _group_tabs (0)
 448         , _last_motion_y (0)
 449         , layering_order_editor (0)
 450         , _last_cut_copy_source_track (0)
 451         , _region_selection_change_updates_region_list (true)
 452         , _cursors (0)
 453         , _following_mixer_selection (false)
 454         , _control_point_toggled_on_press (false)
 455         , _stepping_axis_view (0)
 456         , quantize_dialog (0)
 457         , _main_menu_disabler (0)
 458         , myactions (X_("editor"))
 459 {
 460         /* we are a singleton */
 461
 462         PublicEditor::_instance = this;
 463
 464         _have_idled = false;
 465
 466         last_event_time.tv_sec = 0;
 467         last_event_time.tv_usec = 0;
 468
 469         selection_op_history.clear();
 470         before.clear();
 471
 472         snap_type_strings =  I18N (_snap_type_strings);
 473         snap_mode_strings =  I18N (_snap_mode_strings);
 474         zoom_focus_strings = I18N (_zoom_focus_strings);
 475         edit_mode_strings = I18N (_edit_mode_strings);
 476         edit_point_strings = I18N (_edit_point_strings);
 477 #ifdef USE_RUBBERBAND
 478         rb_opt_strings = I18N (_rb_opt_strings);
 479         rb_current_opt = 4;
 480 #endif
 481
 482         build_edit_mode_menu();
 483         build_zoom_focus_menu();
 484         build_track_count_menu();
 485         build_snap_mode_menu();
 486         build_snap_type_menu();
 487         build_edit_point_menu();
 488
 489         location_marker_color = UIConfiguration::instance().color ("location marker");
 490         location_range_color = UIConfiguration::instance().color ("location range");
 491         location_cd_marker_color = UIConfiguration::instance().color ("location cd marker");
 492         location_loop_color = UIConfiguration::instance().color ("location loop");
 493         location_punch_color = UIConfiguration::instance().color ("location punch");
 494
 495         timebar_height = std::max (12., ceil (15. * UIConfiguration::instance().get_ui_scale()));
 496
 497         TimeAxisView::setup_sizes ();
 498         ArdourMarker::setup_sizes (timebar_height);
 499         TempoCurve::setup_sizes (timebar_height);
 500
 501         bbt_label.set_name ("EditorRulerLabel");
 502         bbt_label.set_size_request (-1, (int)timebar_height);
 503         bbt_label.set_alignment (1.0, 0.5);
 504         bbt_label.set_padding (5,0);
 505         bbt_label.hide ();
 506         bbt_label.set_no_show_all();
 507         minsec_label.set_name ("EditorRulerLabel");
 508         minsec_label.set_size_request (-1, (int)timebar_height);
 509         minsec_label.set_alignment (1.0, 0.5);
 510         minsec_label.set_padding (5,0);
 511         minsec_label.hide ();
 512         minsec_label.set_no_show_all();
 513         timecode_label.set_name ("EditorRulerLabel");
 514         timecode_label.set_size_request (-1, (int)timebar_height);
 515         timecode_label.set_alignment (1.0, 0.5);
 516         timecode_label.set_padding (5,0);
 517         timecode_label.hide ();
 518         timecode_label.set_no_show_all();
 519         samples_label.set_name ("EditorRulerLabel");
 520         samples_label.set_size_request (-1, (int)timebar_height);
 521         samples_label.set_alignment (1.0, 0.5);
 522         samples_label.set_padding (5,0);
 523         samples_label.hide ();
 524         samples_label.set_no_show_all();
 525
 526         tempo_label.set_name ("EditorRulerLabel");
 527         tempo_label.set_size_request (-1, (int)timebar_height);
 528         tempo_label.set_alignment (1.0, 0.5);
 529         tempo_label.set_padding (5,0);
 530         tempo_label.hide();
 531         tempo_label.set_no_show_all();
 532
 533         meter_label.set_name ("EditorRulerLabel");
 534         meter_label.set_size_request (-1, (int)timebar_height);
 535         meter_label.set_alignment (1.0, 0.5);
 536         meter_label.set_padding (5,0);
 537         meter_label.hide();
 538         meter_label.set_no_show_all();
 539
 540         if (Profile->get_trx()) {
 541                 mark_label.set_text (_("Markers"));
 542         }
 543         mark_label.set_name ("EditorRulerLabel");
 544         mark_label.set_size_request (-1, (int)timebar_height);
 545         mark_label.set_alignment (1.0, 0.5);
 546         mark_label.set_padding (5,0);
 547         mark_label.hide();
 548         mark_label.set_no_show_all();
 549
 550         cd_mark_label.set_name ("EditorRulerLabel");
 551         cd_mark_label.set_size_request (-1, (int)timebar_height);
 552         cd_mark_label.set_alignment (1.0, 0.5);
 553         cd_mark_label.set_padding (5,0);
 554         cd_mark_label.hide();
 555         cd_mark_label.set_no_show_all();
 556
 557         videotl_bar_height = 4;
 558         videotl_label.set_name ("EditorRulerLabel");
 559         videotl_label.set_size_request (-1, (int)timebar_height * videotl_bar_height);
 560         videotl_label.set_alignment (1.0, 0.5);
 561         videotl_label.set_padding (5,0);
 562         videotl_label.hide();
 563         videotl_label.set_no_show_all();
 564
 565         range_mark_label.set_name ("EditorRulerLabel");
 566         range_mark_label.set_size_request (-1, (int)timebar_height);
 567         range_mark_label.set_alignment (1.0, 0.5);
 568         range_mark_label.set_padding (5,0);
 569         range_mark_label.hide();
 570         range_mark_label.set_no_show_all();
 571
 572         transport_mark_label.set_name ("EditorRulerLabel");
 573         transport_mark_label.set_size_request (-1, (int)timebar_height);
 574         transport_mark_label.set_alignment (1.0, 0.5);
 575         transport_mark_label.set_padding (5,0);
 576         transport_mark_label.hide();
 577         transport_mark_label.set_no_show_all();
 578
 579         initialize_canvas ();
 580
 581         CairoWidget::set_focus_handler (sigc::mem_fun (ARDOUR_UI::instance(), &ARDOUR_UI::reset_focus));
 582
 583         _summary = new EditorSummary (this);
 584
 585         selection->TimeChanged.connect (sigc::mem_fun(*this, &Editor::time_selection_changed));
 586
 587         editor_regions_selection_changed_connection = selection->RegionsChanged.connect (sigc::mem_fun(*this, &Editor::region_selection_changed));
 588
 589         selection->PointsChanged.connect (sigc::mem_fun(*this, &Editor::point_selection_changed));
 590         selection->MarkersChanged.connect (sigc::mem_fun(*this, &Editor::marker_selection_changed));
 591
 592         edit_controls_vbox.set_spacing (0);
 593         vertical_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &Editor::tie_vertical_scrolling), true);
 594         _track_canvas->signal_map_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_map_handler));
 595
 596         HBox* h = manage (new HBox);
 597         _group_tabs = new EditorGroupTabs (this);
 598         if (!ARDOUR::Profile->get_trx()) {
 599                 h->pack_start (*_group_tabs, PACK_SHRINK);
 600         }
 601         h->pack_start (edit_controls_vbox);
 602         controls_layout.add (*h);
 603
 604         controls_layout.set_name ("EditControlsBase");
 605         controls_layout.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK|Gdk::SCROLL_MASK);
 606         controls_layout.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::edit_controls_button_release));
 607         controls_layout.signal_scroll_event().connect (sigc::mem_fun(*this, &Editor::control_layout_scroll), false);
 608
 609         _cursors = new MouseCursors;
 610         _cursors->set_cursor_set (UIConfiguration::instance().get_icon_set());
 611         cerr << "Set cursor set to " << UIConfiguration::instance().get_icon_set() << endl;
 612
 613         /* Push default cursor to ever-present bottom of cursor stack. */
 614         push_canvas_cursor(_cursors->grabber);
 615
 616         ArdourCanvas::GtkCanvas* time_pad = manage (new ArdourCanvas::GtkCanvas ());
 617
 618         ArdourCanvas::Line* pad_line_1 = new ArdourCanvas::Line (time_pad->root());
 619         pad_line_1->set (ArdourCanvas::Duple (0.0, 1.0), ArdourCanvas::Duple (100.0, 1.0));
 620         pad_line_1->set_outline_color (0xFF0000FF);
 621         pad_line_1->show();
 622
 623         // CAIROCANVAS
 624         time_pad->show();
 625
 626         edit_packer.set_col_spacings (0);
 627         edit_packer.set_row_spacings (0);
 628         edit_packer.set_homogeneous (false);
 629         edit_packer.set_border_width (0);
 630         edit_packer.set_name ("EditorWindow");
 631
 632         time_bars_event_box.add (time_bars_vbox);
 633         time_bars_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 634         time_bars_event_box.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_label_button_release));
 635
 636         /* labels for the time bars */
 637         edit_packer.attach (time_bars_event_box,     0, 1, 0, 1,    FILL,        SHRINK, 0, 0);
 638         /* track controls */
 639         edit_packer.attach (controls_layout,         0, 1, 1, 2,    FILL,        FILL|EXPAND, 0, 0);
 640         /* canvas */
 641         edit_packer.attach (*_track_canvas_viewport,  1, 2, 0, 2,    FILL|EXPAND, FILL|EXPAND, 0, 0);
 642
 643         bottom_hbox.set_border_width (2);
 644         bottom_hbox.set_spacing (3);
 645
 646         PresentationInfo::Change.connect (*this, MISSING_INVALIDATOR, boost::bind (&Editor::presentation_info_changed, this, _1), gui_context());
 647
 648         _route_groups = new EditorRouteGroups (this);
 649         _routes = new EditorRoutes (this);
 650         _regions = new EditorRegions (this);
 651         _snapshots = new EditorSnapshots (this);
 652         _locations = new EditorLocations (this);
 653         _time_info_box = new TimeInfoBox ("EditorTimeInfo", true);
 654
 655         /* these are static location signals */
 656
 657         Location::start_changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 658         Location::end_changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 659         Location::changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 660
 661         add_notebook_page (_("Regions"), _regions->widget ());
 662         add_notebook_page (_("Tracks & Busses"), _routes->widget ());
 663         add_notebook_page (_("Snapshots"), _snapshots->widget ());
 664         add_notebook_page (_("Track & Bus Groups"), _route_groups->widget ());
 665         add_notebook_page (_("Ranges & Marks"), _locations->widget ());
 666
 667         _the_notebook.set_show_tabs (true);
 668         _the_notebook.set_scrollable (true);
 669         _the_notebook.popup_disable ();
 670         _the_notebook.set_tab_pos (Gtk::POS_RIGHT);
 671         _the_notebook.show_all ();
 672
 673         _notebook_shrunk = false;
 674
 675
 676         /* Pick up some settings we need to cache, early */
 677
 678         XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
 679
 680         if (settings) {
 681                 settings->get_property ("notebook-shrunk", _notebook_shrunk);
 682         }
 683
 684         editor_summary_pane.set_check_divider_position (true);
 685         editor_summary_pane.add (edit_packer);
 686
 687         Button* summary_arrows_left_left = manage (new Button);
 688         summary_arrows_left_left->add (*manage (new Arrow (ARROW_LEFT, SHADOW_NONE)));
 689         summary_arrows_left_left->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), LEFT)));
 690         summary_arrows_left_left->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 691
 692         Button* summary_arrows_left_right = manage (new Button);
 693         summary_arrows_left_right->add (*manage (new Arrow (ARROW_RIGHT, SHADOW_NONE)));
 694         summary_arrows_left_right->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), RIGHT)));
 695         summary_arrows_left_right->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 696
 697         VBox* summary_arrows_left = manage (new VBox);
 698         summary_arrows_left->pack_start (*summary_arrows_left_left);
 699         summary_arrows_left->pack_start (*summary_arrows_left_right);
 700
 701         Button* summary_arrows_right_up = manage (new Button);
 702         summary_arrows_right_up->add (*manage (new Arrow (ARROW_UP, SHADOW_NONE)));
 703         summary_arrows_right_up->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), UP)));
 704         summary_arrows_right_up->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 705
 706         Button* summary_arrows_right_down = manage (new Button);
 707         summary_arrows_right_down->add (*manage (new Arrow (ARROW_DOWN, SHADOW_NONE)));
 708         summary_arrows_right_down->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), DOWN)));
 709         summary_arrows_right_down->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 710
 711         VBox* summary_arrows_right = manage (new VBox);
 712         summary_arrows_right->pack_start (*summary_arrows_right_up);
 713         summary_arrows_right->pack_start (*summary_arrows_right_down);
 714
 715         Frame* summary_frame = manage (new Frame);
 716         summary_frame->set_shadow_type (Gtk::SHADOW_ETCHED_IN);
 717
 718         summary_frame->add (*_summary);
 719         summary_frame->show ();
 720
 721         _summary_hbox.pack_start (*summary_arrows_left, false, false);
 722         _summary_hbox.pack_start (*summary_frame, true, true);
 723         _summary_hbox.pack_start (*summary_arrows_right, false, false);
 724
 725         if (!ARDOUR::Profile->get_trx()) {
 726                 editor_summary_pane.add (_summary_hbox);
 727         }
 728
 729         edit_pane.set_check_divider_position (true);
 730         edit_pane.add (editor_summary_pane);
 731         if (!ARDOUR::Profile->get_trx()) {
 732                 _editor_list_vbox.pack_start (*_time_info_box, false, false, 0);
 733                 _editor_list_vbox.pack_start (_the_notebook);
 734                 edit_pane.add (_editor_list_vbox);
 735                 edit_pane.set_child_minsize (_editor_list_vbox, 30); /* rough guess at width of notebook tabs */
 736         }
 737
 738         edit_pane.set_drag_cursor (*_cursors->expand_left_right);
 739         editor_summary_pane.set_drag_cursor (*_cursors->expand_up_down);
 740
 741         float fract;
 742         if (!settings || !settings->get_property ("edit-horizontal-pane-pos", fract) || fract > 1.0) {
 743                 /* initial allocation is 90% to canvas, 10% to notebook */
 744                 fract = 0.90;
 745         }
 746         edit_pane.set_divider (0, fract);
 747
 748         if (!settings || !settings->get_property ("edit-vertical-pane-pos", fract) || fract > 1.0) {
 749                 /* initial allocation is 90% to canvas, 10% to summary */
 750                 fract = 0.90;
 751         }
 752         editor_summary_pane.set_divider (0, fract);
 753
 754         global_vpacker.set_spacing (2);
 755         global_vpacker.set_border_width (0);
 756
 757         //the next three EventBoxes provide the ability for their child widgets to have a background color.  That is all.
 758
 759         Gtk::EventBox* ebox = manage (new Gtk::EventBox);  //a themeable box
 760         ebox->set_name("EditorWindow");
 761         ebox->add (toolbar_hbox);
 762
 763         Gtk::EventBox* epane_box = manage (new Gtkmm2ext::EventBoxExt);  //a themeable box
 764         epane_box->set_name("EditorWindow");
 765         epane_box->add (edit_pane);
 766
 767         Gtk::EventBox* epane_box2 = manage (new Gtkmm2ext::EventBoxExt);  //a themeable box
 768         epane_box2->set_name("EditorWindow");
 769         epane_box2->add (global_vpacker);
 770
 771         global_vpacker.pack_start (*ebox, false, false);
 772         global_vpacker.pack_start (*epane_box, true, true);
 773         global_hpacker.pack_start (*epane_box2, true, true);
 774
 775         /* need to show the "contents" widget so that notebook will show if tab is switched to
 776          */
 777
 778         global_hpacker.show ();
 779
 780         /* register actions now so that set_state() can find them and set toggles/checks etc */
 781
 782         register_actions ();
 783         load_bindings ();
 784
 785         setup_toolbar ();
 786
 787         _playlist_selector = new PlaylistSelector();
 788         _playlist_selector->signal_delete_event().connect (sigc::bind (sigc::ptr_fun (just_hide_it), static_cast<Window *> (_playlist_selector)));
 789
 790         RegionView::RegionViewGoingAway.connect (*this, invalidator (*this),  boost::bind (&Editor::catch_vanishing_regionview, this, _1), gui_context());
 791
 792         /* nudge stuff */
 793
 794         nudge_forward_button.set_name ("nudge button");
 795         nudge_forward_button.set_icon(ArdourIcon::NudgeRight);
 796
 797         nudge_backward_button.set_name ("nudge button");
 798         nudge_backward_button.set_icon(ArdourIcon::NudgeLeft);
 799
 800         fade_context_menu.set_name ("ArdourContextMenu");
 801
 802         Gtkmm2ext::Keyboard::the_keyboard().ZoomVerticalModifierReleased.connect (sigc::mem_fun (*this, &Editor::zoom_vertical_modifier_released));
 803
 804         /* allow external control surfaces/protocols to do various things */
 805
 806         ControlProtocol::ZoomToSession.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_session, this), gui_context());
 807         ControlProtocol::ZoomIn.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_step, this, false), gui_context());
 808         ControlProtocol::ZoomOut.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_step, this, true), gui_context());
 809         ControlProtocol::Undo.connect (*this, invalidator (*this), boost::bind (&Editor::undo, this, true), gui_context());
 810         ControlProtocol::Redo.connect (*this, invalidator (*this), boost::bind (&Editor::redo, this, true), gui_context());
 811         ControlProtocol::ScrollTimeline.connect (*this, invalidator (*this), boost::bind (&Editor::control_scroll, this, _1), gui_context());
 812         ControlProtocol::StepTracksUp.connect (*this, invalidator (*this), boost::bind (&Editor::control_step_tracks_up, this), gui_context());
 813         ControlProtocol::StepTracksDown.connect (*this, invalidator (*this), boost::bind (&Editor::control_step_tracks_down, this), gui_context());
 814         ControlProtocol::GotoView.connect (*this, invalidator (*this), boost::bind (&Editor::control_view, this, _1), gui_context());
 815         ControlProtocol::CloseDialog.connect (*this, invalidator (*this), Keyboard::close_current_dialog, gui_context());
 816         ControlProtocol::VerticalZoomInAll.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_in_all, this), gui_context());
 817         ControlProtocol::VerticalZoomOutAll.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_out_all, this), gui_context());
 818         ControlProtocol::VerticalZoomInSelected.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_in_selected, this), gui_context());
 819         ControlProtocol::VerticalZoomOutSelected.connect (*this, invalidator (*this), boost::bind (&Editor::control_vertical_zoom_out_selected, this), gui_context());
 820
 821         ControlProtocol::AddStripableToSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Add), gui_context());
 822         ControlProtocol::RemoveStripableFromSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Toggle), gui_context());
 823         ControlProtocol::SetStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Set), gui_context());
 824         ControlProtocol::ToggleStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_select, this, _1, Selection::Toggle), gui_context());
 825         ControlProtocol::ClearStripableSelection.connect (*this, invalidator (*this), boost::bind (&Editor::control_unselect, this), gui_context());
 826
 827         BasicUI::AccessAction.connect (*this, invalidator (*this), boost::bind (&Editor::access_action, this, _1, _2), gui_context());
 828
 829         /* handle escape */
 830
 831         ARDOUR_UI::instance()->Escape.connect (*this, invalidator (*this), boost::bind (&Editor::escape, this), gui_context());
 832
 833         /* problematic: has to return a value and thus cannot be x-thread */
 834
 835         Session::AskAboutPlaylistDeletion.connect_same_thread (*this, boost::bind (&Editor::playlist_deletion_dialog, this, _1));
 836
 837         Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&Editor::parameter_changed, this, _1), gui_context());
 838         UIConfiguration::instance().ParameterChanged.connect (sigc::mem_fun (*this, &Editor::ui_parameter_changed));
 839
 840         TimeAxisView::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&Editor::timeaxisview_deleted, this, _1), gui_context());
 841
 842         _ignore_region_action = false;
 843         _last_region_menu_was_main = false;
 844         _popup_region_menu_item = 0;
 845
 846         _show_marker_lines = false;
 847
 848         /* Button bindings */
 849
 850         button_bindings = new Bindings ("editor-mouse");
 851
 852         XMLNode* node = button_settings();
 853         if (node) {
 854                 for (XMLNodeList::const_iterator i = node->children().begin(); i != node->children().end(); ++i) {
 855                         button_bindings->load_operation (**i);
 856                 }
 857         }
 858
 859         constructed = true;
 860
 861         /* grab current parameter state */
 862         boost::function<void (string)> pc (boost::bind (&Editor::ui_parameter_changed, this, _1));
 863         UIConfiguration::instance().map_parameters (pc);
 864
 865         setup_fade_images ();
 866
 867         instant_save ();
 868 }
 869
 870 Editor::~Editor()
 871 {
 872         delete button_bindings;
 873         delete _routes;
 874         delete _route_groups;
 875         delete _track_canvas_viewport;
 876         delete _drags;
 877         delete nudge_clock;
 878         delete _verbose_cursor;
 879         delete quantize_dialog;
 880         delete _summary;
 881         delete _group_tabs;
 882         delete _regions;
 883         delete _snapshots;
 884         delete _locations;
 885         delete _playlist_selector;
 886         delete _time_info_box;
 887         delete selection;
 888         delete cut_buffer;
 889         delete _cursors;
 890
 891         LuaInstance::destroy_instance ();
 892
 893         for (list<XMLNode *>::iterator i = selection_op_history.begin(); i != selection_op_history.end(); ++i) {
 894                 delete *i;
 895         }
 896         for (std::map<ARDOUR::FadeShape, Gtk::Image*>::const_iterator i = _xfade_in_images.begin(); i != _xfade_in_images.end (); ++i) {
 897                 delete i->second;
 898         }
 899         for (std::map<ARDOUR::FadeShape, Gtk::Image*>::const_iterator i = _xfade_out_images.begin(); i != _xfade_out_images.end (); ++i) {
 900                 delete i->second;
 901         }
 902 }
 903
 904 XMLNode*
 905 Editor::button_settings () const
 906 {
 907         XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
 908         XMLNode* node = find_named_node (*settings, X_("Buttons"));
 909
 910         if (!node) {
 911                 node = new XMLNode (X_("Buttons"));
 912         }
 913
 914         return node;
 915 }
 916
 917 bool
 918 Editor::get_smart_mode () const
 919 {
 920         return ((current_mouse_mode() == Editing::MouseObject) && smart_mode_action->get_active());
 921 }
 922
 923 void
 924 Editor::catch_vanishing_regionview (RegionView *rv)
 925 {
 926         /* note: the selection will take care of the vanishing
 927            audioregionview by itself.
 928         */
 929
 930         if (_drags->active() && _drags->have_item (rv->get_canvas_group()) && !_drags->ending()) {
 931                 _drags->abort ();
 932         }
 933
 934         if (clicked_regionview == rv) {
 935                 clicked_regionview = 0;
 936         }
 937
 938         if (entered_regionview == rv) {
 939                 set_entered_regionview (0);
 940         }
 941
 942         if (!_all_region_actions_sensitized) {
 943                 sensitize_all_region_actions (true);
 944         }
 945 }
 946
 947 void
 948 Editor::set_entered_regionview (RegionView* rv)
 949 {
 950         if (rv == entered_regionview) {
 951                 return;
 952         }
 953
 954         if (entered_regionview) {
 955                 entered_regionview->exited ();
 956         }
 957
 958         entered_regionview = rv;
 959
 960         if (entered_regionview  != 0) {
 961                 entered_regionview->entered ();
 962         }
 963
 964         if (!_all_region_actions_sensitized && _last_region_menu_was_main) {
 965                 /* This RegionView entry might have changed what region actions
 966                    are allowed, so sensitize them all in case a key is pressed.
 967                 */
 968                 sensitize_all_region_actions (true);
 969         }
 970 }
 971
 972 void
 973 Editor::set_entered_track (TimeAxisView* tav)
 974 {
 975         if (entered_track) {
 976                 entered_track->exited ();
 977         }
 978
 979         entered_track = tav;
 980
 981         if (entered_track) {
 982                 entered_track->entered ();
 983         }
 984 }
 985
 986 void
 987 Editor::instant_save ()
 988 {
 989         if (!constructed || !ARDOUR_UI::instance()->session_loaded || no_save_instant) {
 990                 return;
 991         }
 992
 993         if (_session) {
 994                 _session->add_instant_xml(get_state());
 995         } else {
 996                 Config->add_instant_xml(get_state());
 997         }
 998 }
 999
1000 void
1001 Editor::control_vertical_zoom_in_all ()
1002 {
1003         tav_zoom_smooth (false, true);
1004 }
1005
1006 void
1007 Editor::control_vertical_zoom_out_all ()
1008 {
1009         tav_zoom_smooth (true, true);
1010 }
1011
1012 void
1013 Editor::control_vertical_zoom_in_selected ()
1014 {
1015         tav_zoom_smooth (false, false);
1016 }
1017
1018 void
1019 Editor::control_vertical_zoom_out_selected ()
1020 {
1021         tav_zoom_smooth (true, false);
1022 }
1023
1024 void
1025 Editor::control_view (uint32_t view)
1026 {
1027         goto_visual_state (view);
1028 }
1029
1030 void
1031 Editor::control_unselect ()
1032 {
1033         selection->clear_tracks ();
1034 }
1035
1036 void
1037 Editor::control_select (boost::shared_ptr<Stripable> s, Selection::Operation op)
1038 {
1039         TimeAxisView* tav = time_axis_view_from_stripable (s);
1040
1041         if (tav) {
1042                 switch (op) {
1043                 case Selection::Add:
1044                         selection->add (tav);
1045                         break;
1046                 case Selection::Toggle:
1047                         selection->toggle (tav);
1048                         break;
1049                 case Selection::Extend:
1050                         break;
1051                 case Selection::Set:
1052                         selection->set (tav);
1053                         break;
1054                 }
1055         } else {
1056                 selection->clear_tracks ();
1057         }
1058 }
1059
1060 void
1061 Editor::control_step_tracks_up ()
1062 {
1063         scroll_tracks_up_line ();
1064 }
1065
1066 void
1067 Editor::control_step_tracks_down ()
1068 {
1069         scroll_tracks_down_line ();
1070 }
1071
1072 void
1073 Editor::control_scroll (float fraction)
1074 {
1075         ENSURE_GUI_THREAD (*this, &Editor::control_scroll, fraction)
1076
1077         if (!_session) {
1078                 return;
1079         }
1080
1081         double step = fraction * current_page_samples();
1082
1083         /*
1084                 _control_scroll_target is an optional<T>
1085
1086                 it acts like a pointer to an framepos_t, with
1087                 a operator conversion to boolean to check
1088                 that it has a value could possibly use
1089                 playhead_cursor->current_frame to store the
1090                 value and a boolean in the class to know
1091                 when it's out of date
1092         */
1093
1094         if (!_control_scroll_target) {
1095                 _control_scroll_target = _session->transport_frame();
1096                 _dragging_playhead = true;
1097         }
1098
1099         if ((fraction < 0.0f) && (*_control_scroll_target <= (framepos_t) fabs(step))) {
1100                 *_control_scroll_target = 0;
1101         } else if ((fraction > 0.0f) && (max_framepos - *_control_scroll_target < step)) {
1102                 *_control_scroll_target = max_framepos - (current_page_samples()*2); // allow room for slop in where the PH is on the screen
1103         } else {
1104                 *_control_scroll_target += (framepos_t) trunc (step);
1105         }
1106
1107         /* move visuals, we'll catch up with it later */
1108
1109         playhead_cursor->set_position (*_control_scroll_target);
1110         UpdateAllTransportClocks (*_control_scroll_target);
1111
1112         if (*_control_scroll_target > (current_page_samples() / 2)) {
1113                 /* try to center PH in window */
1114                 reset_x_origin (*_control_scroll_target - (current_page_samples()/2));
1115         } else {
1116                 reset_x_origin (0);
1117         }
1118
1119         /*
1120                 Now we do a timeout to actually bring the session to the right place
1121                 according to the playhead. This is to avoid reading disk buffers on every
1122                 call to control_scroll, which is driven by ScrollTimeline and therefore
1123                 probably by a control surface wheel which can generate lots of events.
1124         */
1125         /* cancel the existing timeout */
1126
1127         control_scroll_connection.disconnect ();
1128
1129         /* add the next timeout */
1130
1131         control_scroll_connection = Glib::signal_timeout().connect (sigc::bind (sigc::mem_fun (*this, &Editor::deferred_control_scroll), *_control_scroll_target), 250);
1132 }
1133
1134 bool
1135 Editor::deferred_control_scroll (framepos_t /*target*/)
1136 {
1137         _session->request_locate (*_control_scroll_target, _session->transport_rolling());
1138         // reset for next stream
1139         _control_scroll_target = boost::none;
1140         _dragging_playhead = false;
1141         return false;
1142 }
1143
1144 void
1145 Editor::access_action (std::string action_group, std::string action_item)
1146 {
1147         if (!_session) {
1148                 return;
1149         }
1150
1151         ENSURE_GUI_THREAD (*this, &Editor::access_action, action_group, action_item)
1152
1153         RefPtr<Action> act;
1154         act = ActionManager::get_action( action_group.c_str(), action_item.c_str() );
1155
1156         if (act) {
1157                 act->activate();
1158         }
1159 }
1160
1161 void
1162 Editor::on_realize ()
1163 {
1164         Realized ();
1165
1166         if (UIConfiguration::instance().get_lock_gui_after_seconds()) {
1167                 start_lock_event_timing ();
1168         }
1169 }
1170
1171 void
1172 Editor::start_lock_event_timing ()
1173 {
1174         /* check if we should lock the GUI every 30 seconds */
1175
1176         Glib::signal_timeout().connect (sigc::mem_fun (*this, &Editor::lock_timeout_callback), 30 * 1000);
1177 }
1178
1179 bool
1180 Editor::generic_event_handler (GdkEvent* ev)
1181 {
1182         switch (ev->type) {
1183         case GDK_BUTTON_PRESS:
1184         case GDK_BUTTON_RELEASE:
1185         case GDK_MOTION_NOTIFY:
1186         case GDK_KEY_PRESS:
1187         case GDK_KEY_RELEASE:
1188                 if (contents().is_mapped()) {
1189                         gettimeofday (&last_event_time, 0);
1190                 }
1191                 break;
1192
1193         case GDK_LEAVE_NOTIFY:
1194                 switch (ev->crossing.detail) {
1195                 case GDK_NOTIFY_UNKNOWN:
1196                 case GDK_NOTIFY_INFERIOR:
1197                 case GDK_NOTIFY_ANCESTOR:
1198                         break;
1199                 case GDK_NOTIFY_VIRTUAL:
1200                 case GDK_NOTIFY_NONLINEAR:
1201                 case GDK_NOTIFY_NONLINEAR_VIRTUAL:
1202                         /* leaving window, so reset focus, thus ending any and
1203                            all text entry operations.
1204                         */
1205                         ARDOUR_UI::instance()->reset_focus (&contents());
1206                         break;
1207                 }
1208                 break;
1209
1210         default:
1211                 break;
1212         }
1213
1214         return false;
1215 }
1216
1217 bool
1218 Editor::lock_timeout_callback ()
1219 {
1220         struct timeval now, delta;
1221
1222         gettimeofday (&now, 0);
1223
1224         timersub (&now, &last_event_time, &delta);
1225
1226         if (delta.tv_sec > (time_t) UIConfiguration::instance().get_lock_gui_after_seconds()) {
1227                 lock ();
1228                 /* don't call again. Returning false will effectively
1229                    disconnect us from the timer callback.
1230
1231                    unlock() will call start_lock_event_timing() to get things
1232                    started again.
1233                 */
1234                 return false;
1235         }
1236
1237         return true;
1238 }
1239
1240 void
1241 Editor::map_position_change (framepos_t frame)
1242 {
1243         ENSURE_GUI_THREAD (*this, &Editor::map_position_change, frame)
1244
1245         if (_session == 0) {
1246                 return;
1247         }
1248
1249         if (_follow_playhead) {
1250                 center_screen (frame);
1251         }
1252
1253         playhead_cursor->set_position (frame);
1254 }
1255
1256 void
1257 Editor::center_screen (framepos_t frame)
1258 {
1259         framecnt_t const page = _visible_canvas_width * samples_per_pixel;
1260
1261         /* if we're off the page, then scroll.
1262          */
1263
1264         if (frame < leftmost_frame || frame >= leftmost_frame + page) {
1265                 center_screen_internal (frame, page);
1266         }
1267 }
1268
1269 void
1270 Editor::center_screen_internal (framepos_t frame, float page)
1271 {
1272         page /= 2;
1273
1274         if (frame > page) {
1275                 frame -= (framepos_t) page;
1276         } else {
1277                 frame = 0;
1278         }
1279
1280         reset_x_origin (frame);
1281 }
1282
1283
1284 void
1285 Editor::update_title ()
1286 {
1287         ENSURE_GUI_THREAD (*this, &Editor::update_title);
1288
1289         if (!own_window()) {
1290                 return;
1291         }
1292
1293         if (_session) {
1294                 bool dirty = _session->dirty();
1295
1296                 string session_name;
1297
1298                 if (_session->snap_name() != _session->name()) {
1299                         session_name = _session->snap_name();
1300                 } else {
1301                         session_name = _session->name();
1302                 }
1303
1304                 if (dirty) {
1305                         session_name = "*" + session_name;
1306                 }
1307
1308                 WindowTitle title(session_name);
1309                 title += S_("Window|Editor");
1310                 title += Glib::get_application_name();
1311                 own_window()->set_title (title.get_string());
1312         } else {
1313                 /* ::session_going_away() will have taken care of it */
1314         }
1315 }
1316
1317 void
1318 Editor::set_session (Session *t)
1319 {
1320         SessionHandlePtr::set_session (t);
1321
1322         if (!_session) {
1323                 return;
1324         }
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::size_type pos = 0;
1892         string menu_item_name = (rs.size() == 1) ? rs.front()->region()->name() : _("Selected Regions");
1893
1894         /* we have to hack up the region name because "_" has a special
1895            meaning for menu titles.
1896         */
1897
1898         while ((pos = menu_item_name.find ("_", pos)) != string::npos) {
1899                 menu_item_name.replace (pos, 1, "__");
1900                 pos += 2;
1901         }
1902
1903         if (_popup_region_menu_item == 0) {
1904                 _popup_region_menu_item = new MenuItem (menu_item_name);
1905                 _popup_region_menu_item->set_submenu (*dynamic_cast<Menu*> (ActionManager::get_widget (X_("/PopupRegionMenu"))));
1906                 _popup_region_menu_item->show ();
1907         } else {
1908                 _popup_region_menu_item->set_label (menu_item_name);
1909         }
1910
1911         /* No layering allowed in later is higher layering model */
1912         RefPtr<Action> act = ActionManager::get_action (X_("EditorMenu"), X_("RegionMenuLayering"));
1913         if (act && Config->get_layer_model() == LaterHigher) {
1914                 act->set_sensitive (false);
1915         } else if (act) {
1916                 act->set_sensitive (true);
1917         }
1918
1919         const framepos_t position = get_preferred_edit_position (EDIT_IGNORE_NONE, true);
1920
1921         edit_items.push_back (*_popup_region_menu_item);
1922         if (Config->get_layer_model() == Manual && track->playlist()->count_regions_at (position) > 1 && (layering_order_editor == 0 || !layering_order_editor->is_visible ())) {
1923                 edit_items.push_back (*manage (_region_actions->get_action ("choose-top-region-context-menu")->create_menu_item ()));
1924         }
1925         edit_items.push_back (SeparatorElem());
1926 }
1927
1928 /** Add context menu items relevant to selection ranges.
1929  * @param edit_items List to add the items to.
1930  */
1931 void
1932 Editor::add_selection_context_items (Menu_Helpers::MenuList& edit_items)
1933 {
1934         using namespace Menu_Helpers;
1935
1936         edit_items.push_back (MenuElem (_("Play Range"), sigc::mem_fun(*this, &Editor::play_selection)));
1937         edit_items.push_back (MenuElem (_("Loop Range"), sigc::bind (sigc::mem_fun(*this, &Editor::set_loop_from_selection), true)));
1938
1939         edit_items.push_back (SeparatorElem());
1940         edit_items.push_back (MenuElem (_("Zoom to Range"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), Horizontal)));
1941
1942         edit_items.push_back (SeparatorElem());
1943         edit_items.push_back (MenuElem (_("Loudness Analysis"), sigc::mem_fun(*this, &Editor::loudness_analyze_range_selection)));
1944         edit_items.push_back (MenuElem (_("Spectral Analysis"), sigc::mem_fun(*this, &Editor::spectral_analyze_range_selection)));
1945
1946         edit_items.push_back (SeparatorElem());
1947
1948         edit_items.push_back (
1949                 MenuElem (
1950                         _("Move Range Start to Previous Region Boundary"),
1951                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), false, false)
1952                         )
1953                 );
1954
1955         edit_items.push_back (
1956                 MenuElem (
1957                         _("Move Range Start to Next Region Boundary"),
1958                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), false, true)
1959                         )
1960                 );
1961
1962         edit_items.push_back (
1963                 MenuElem (
1964                         _("Move Range End to Previous Region Boundary"),
1965                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), true, false)
1966                         )
1967                 );
1968
1969         edit_items.push_back (
1970                 MenuElem (
1971                         _("Move Range End to Next Region Boundary"),
1972                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), true, true)
1973                         )
1974                 );
1975
1976         edit_items.push_back (SeparatorElem());
1977         edit_items.push_back (MenuElem (_("Separate"), mem_fun(*this, &Editor::separate_region_from_selection)));
1978         edit_items.push_back (MenuElem (_("Convert to Region in Region List"), sigc::mem_fun(*this, &Editor::new_region_from_selection)));
1979
1980         edit_items.push_back (SeparatorElem());
1981         edit_items.push_back (MenuElem (_("Select All in Range"), sigc::mem_fun(*this, &Editor::select_all_selectables_using_time_selection)));
1982
1983         edit_items.push_back (SeparatorElem());
1984         edit_items.push_back (MenuElem (_("Set Loop from Selection"), sigc::bind (sigc::mem_fun(*this, &Editor::set_loop_from_selection), false)));
1985         edit_items.push_back (MenuElem (_("Set Punch from Selection"), sigc::mem_fun(*this, &Editor::set_punch_from_selection)));
1986         edit_items.push_back (MenuElem (_("Set Session Start/End from Selection"), sigc::mem_fun(*this, &Editor::set_session_extents_from_selection)));
1987
1988         edit_items.push_back (SeparatorElem());
1989         edit_items.push_back (MenuElem (_("Add Range Markers"), sigc::mem_fun (*this, &Editor::add_location_from_selection)));
1990
1991         edit_items.push_back (SeparatorElem());
1992         edit_items.push_back (MenuElem (_("Crop Region to Range"), sigc::mem_fun(*this, &Editor::crop_region_to_selection)));
1993         edit_items.push_back (MenuElem (_("Duplicate Range"), sigc::bind (sigc::mem_fun(*this, &Editor::duplicate_range), false)));
1994
1995         edit_items.push_back (SeparatorElem());
1996         edit_items.push_back (MenuElem (_("Consolidate Range"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, false)));
1997         edit_items.push_back (MenuElem (_("Consolidate Range with Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, true)));
1998         edit_items.push_back (MenuElem (_("Bounce Range to Region List"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, false)));
1999         edit_items.push_back (MenuElem (_("Bounce Range to Region List with Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, true)));
2000         edit_items.push_back (MenuElem (_("Export Range..."), sigc::mem_fun(*this, &Editor::export_selection)));
2001         if (ARDOUR_UI::instance()->video_timeline->get_duration() > 0) {
2002                 edit_items.push_back (MenuElem (_("Export Video Range..."), sigc::bind (sigc::mem_fun(*(ARDOUR_UI::instance()), &ARDOUR_UI::export_video), true)));
2003         }
2004 }
2005
2006
2007 void
2008 Editor::add_dstream_context_items (Menu_Helpers::MenuList& edit_items)
2009 {
2010         using namespace Menu_Helpers;
2011
2012         /* Playback */
2013
2014         Menu *play_menu = manage (new Menu);
2015         MenuList& play_items = play_menu->items();
2016         play_menu->set_name ("ArdourContextMenu");
2017
2018         play_items.push_back (MenuElem (_("Play from Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
2019         play_items.push_back (MenuElem (_("Play from Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
2020         play_items.push_back (MenuElem (_("Play Region"), sigc::mem_fun(*this, &Editor::play_selected_region)));
2021         play_items.push_back (SeparatorElem());
2022         play_items.push_back (MenuElem (_("Loop Region"), sigc::bind (sigc::mem_fun (*this, &Editor::set_loop_from_region), true)));
2023
2024         edit_items.push_back (MenuElem (_("Play"), *play_menu));
2025
2026         /* Selection */
2027
2028         Menu *select_menu = manage (new Menu);
2029         MenuList& select_items = select_menu->items();
2030         select_menu->set_name ("ArdourContextMenu");
2031
2032         select_items.push_back (MenuElem (_("Select All in Track"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_in_track), Selection::Set)));
2033         select_items.push_back (MenuElem (_("Select All Objects"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_objects), Selection::Set)));
2034         select_items.push_back (MenuElem (_("Invert Selection in Track"), sigc::mem_fun(*this, &Editor::invert_selection_in_track)));
2035         select_items.push_back (MenuElem (_("Invert Selection"), sigc::mem_fun(*this, &Editor::invert_selection)));
2036         select_items.push_back (SeparatorElem());
2037         select_items.push_back (MenuElem (_("Set Range to Loop Range"), sigc::mem_fun(*this, &Editor::set_selection_from_loop)));
2038         select_items.push_back (MenuElem (_("Set Range to Punch Range"), sigc::mem_fun(*this, &Editor::set_selection_from_punch)));
2039         select_items.push_back (MenuElem (_("Set Range to Selected Regions"), sigc::mem_fun(*this, &Editor::set_selection_from_region)));
2040         select_items.push_back (SeparatorElem());
2041         select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true, true)));
2042         select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false, true)));
2043         select_items.push_back (MenuElem (_("Select All After Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
2044         select_items.push_back (MenuElem (_("Select All Before Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
2045         select_items.push_back (MenuElem (_("Select All Between Playhead and Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_between), false)));
2046         select_items.push_back (MenuElem (_("Select All Within Playhead and Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_between), true)));
2047         select_items.push_back (MenuElem (_("Select Range Between Playhead and Edit Point"), sigc::mem_fun(*this, &Editor::select_range_between)));
2048
2049         edit_items.push_back (MenuElem (_("Select"), *select_menu));
2050
2051         /* Cut-n-Paste */
2052
2053         Menu *cutnpaste_menu = manage (new Menu);
2054         MenuList& cutnpaste_items = cutnpaste_menu->items();
2055         cutnpaste_menu->set_name ("ArdourContextMenu");
2056
2057         cutnpaste_items.push_back (MenuElem (_("Cut"), sigc::mem_fun(*this, &Editor::cut)));
2058         cutnpaste_items.push_back (MenuElem (_("Copy"), sigc::mem_fun(*this, &Editor::copy)));
2059         cutnpaste_items.push_back (MenuElem (_("Paste"), sigc::bind (sigc::mem_fun(*this, &Editor::paste), 1.0f, true)));
2060
2061         cutnpaste_items.push_back (SeparatorElem());
2062
2063         cutnpaste_items.push_back (MenuElem (_("Align"), sigc::bind (sigc::mem_fun (*this, &Editor::align_regions), ARDOUR::SyncPoint)));
2064         cutnpaste_items.push_back (MenuElem (_("Align Relative"), sigc::bind (sigc::mem_fun (*this, &Editor::align_regions_relative), ARDOUR::SyncPoint)));
2065
2066         edit_items.push_back (MenuElem (_("Edit"), *cutnpaste_menu));
2067
2068         /* Adding new material */
2069
2070         edit_items.push_back (SeparatorElem());
2071         edit_items.push_back (MenuElem (_("Insert Selected Region"), sigc::bind (sigc::mem_fun(*this, &Editor::insert_region_list_selection), 1.0f)));
2072         edit_items.push_back (MenuElem (_("Insert Existing Media"), sigc::bind (sigc::mem_fun(*this, &Editor::add_external_audio_action), ImportToTrack)));
2073
2074         /* Nudge track */
2075
2076         Menu *nudge_menu = manage (new Menu());
2077         MenuList& nudge_items = nudge_menu->items();
2078         nudge_menu->set_name ("ArdourContextMenu");
2079
2080         edit_items.push_back (SeparatorElem());
2081         nudge_items.push_back (MenuElem (_("Nudge Entire Track Later"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, true))));
2082         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Later"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, true))));
2083         nudge_items.push_back (MenuElem (_("Nudge Entire Track Earlier"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, false))));
2084         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Earlier"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, false))));
2085
2086         edit_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
2087 }
2088
2089 void
2090 Editor::add_bus_context_items (Menu_Helpers::MenuList& edit_items)
2091 {
2092         using namespace Menu_Helpers;
2093
2094         /* Playback */
2095
2096         Menu *play_menu = manage (new Menu);
2097         MenuList& play_items = play_menu->items();
2098         play_menu->set_name ("ArdourContextMenu");
2099
2100         play_items.push_back (MenuElem (_("Play from Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
2101         play_items.push_back (MenuElem (_("Play from Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
2102         edit_items.push_back (MenuElem (_("Play"), *play_menu));
2103
2104         /* Selection */
2105
2106         Menu *select_menu = manage (new Menu);
2107         MenuList& select_items = select_menu->items();
2108         select_menu->set_name ("ArdourContextMenu");
2109
2110         select_items.push_back (MenuElem (_("Select All in Track"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_in_track), Selection::Set)));
2111         select_items.push_back (MenuElem (_("Select All Objects"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_objects), Selection::Set)));
2112         select_items.push_back (MenuElem (_("Invert Selection in Track"), sigc::mem_fun(*this, &Editor::invert_selection_in_track)));
2113         select_items.push_back (MenuElem (_("Invert Selection"), sigc::mem_fun(*this, &Editor::invert_selection)));
2114         select_items.push_back (SeparatorElem());
2115         select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true, true)));
2116         select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false, true)));
2117         select_items.push_back (MenuElem (_("Select All After Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
2118         select_items.push_back (MenuElem (_("Select All Before Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
2119
2120         edit_items.push_back (MenuElem (_("Select"), *select_menu));
2121
2122         /* Cut-n-Paste */
2123
2124         Menu *cutnpaste_menu = manage (new Menu);
2125         MenuList& cutnpaste_items = cutnpaste_menu->items();
2126         cutnpaste_menu->set_name ("ArdourContextMenu");
2127
2128         cutnpaste_items.push_back (MenuElem (_("Cut"), sigc::mem_fun(*this, &Editor::cut)));
2129         cutnpaste_items.push_back (MenuElem (_("Copy"), sigc::mem_fun(*this, &Editor::copy)));
2130         cutnpaste_items.push_back (MenuElem (_("Paste"), sigc::bind (sigc::mem_fun(*this, &Editor::paste), 1.0f, true)));
2131
2132         Menu *nudge_menu = manage (new Menu());
2133         MenuList& nudge_items = nudge_menu->items();
2134         nudge_menu->set_name ("ArdourContextMenu");
2135
2136         edit_items.push_back (SeparatorElem());
2137         nudge_items.push_back (MenuElem (_("Nudge Entire Track Later"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, true))));
2138         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Later"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, true))));
2139         nudge_items.push_back (MenuElem (_("Nudge Entire Track Earlier"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, false))));
2140         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Earlier"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, false))));
2141
2142         edit_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
2143 }
2144
2145 SnapType
2146 Editor::snap_type() const
2147 {
2148         return _snap_type;
2149 }
2150
2151 bool
2152 Editor::snap_musical() const
2153 {
2154         switch (_snap_type) {
2155         case SnapToBeatDiv128:
2156         case SnapToBeatDiv64:
2157         case SnapToBeatDiv32:
2158         case SnapToBeatDiv28:
2159         case SnapToBeatDiv24:
2160         case SnapToBeatDiv20:
2161         case SnapToBeatDiv16:
2162         case SnapToBeatDiv14:
2163         case SnapToBeatDiv12:
2164         case SnapToBeatDiv10:
2165         case SnapToBeatDiv8:
2166         case SnapToBeatDiv7:
2167         case SnapToBeatDiv6:
2168         case SnapToBeatDiv5:
2169         case SnapToBeatDiv4:
2170         case SnapToBeatDiv3:
2171         case SnapToBeatDiv2:
2172         case SnapToBeat:
2173         case SnapToBar:
2174                 return true;
2175         default:
2176                 break;
2177         }
2178
2179         return false;
2180 }
2181
2182 SnapMode
2183 Editor::snap_mode() const
2184 {
2185         return _snap_mode;
2186 }
2187
2188 void
2189 Editor::set_snap_to (SnapType st)
2190 {
2191         unsigned int snap_ind = (unsigned int)st;
2192
2193         if (internal_editing()) {
2194                 internal_snap_type = st;
2195         } else {
2196                 pre_internal_snap_type = st;
2197         }
2198
2199         _snap_type = st;
2200
2201         if (snap_ind > snap_type_strings.size() - 1) {
2202                 snap_ind = 0;
2203                 _snap_type = (SnapType)snap_ind;
2204         }
2205
2206         string str = snap_type_strings[snap_ind];
2207
2208         if (str != snap_type_selector.get_text()) {
2209                 snap_type_selector.set_text (str);
2210         }
2211
2212         instant_save ();
2213
2214         switch (_snap_type) {
2215         case SnapToBeatDiv128:
2216         case SnapToBeatDiv64:
2217         case SnapToBeatDiv32:
2218         case SnapToBeatDiv28:
2219         case SnapToBeatDiv24:
2220         case SnapToBeatDiv20:
2221         case SnapToBeatDiv16:
2222         case SnapToBeatDiv14:
2223         case SnapToBeatDiv12:
2224         case SnapToBeatDiv10:
2225         case SnapToBeatDiv8:
2226         case SnapToBeatDiv7:
2227         case SnapToBeatDiv6:
2228         case SnapToBeatDiv5:
2229         case SnapToBeatDiv4:
2230         case SnapToBeatDiv3:
2231         case SnapToBeatDiv2: {
2232                 compute_bbt_ruler_scale (leftmost_frame, leftmost_frame + current_page_samples());
2233                 update_tempo_based_rulers ();
2234                 break;
2235         }
2236
2237         case SnapToRegionStart:
2238         case SnapToRegionEnd:
2239         case SnapToRegionSync:
2240         case SnapToRegionBoundary:
2241                 build_region_boundary_cache ();
2242                 break;
2243
2244         default:
2245                 /* relax */
2246                 break;
2247         }
2248
2249         redisplay_tempo (false);
2250
2251         SnapChanged (); /* EMIT SIGNAL */
2252 }
2253
2254 void
2255 Editor::set_snap_mode (SnapMode mode)
2256 {
2257         string str = snap_mode_strings[(int)mode];
2258
2259         if (internal_editing()) {
2260                 internal_snap_mode = mode;
2261         } else {
2262                 pre_internal_snap_mode = mode;
2263         }
2264
2265         _snap_mode = mode;
2266
2267         if (str != snap_mode_selector.get_text ()) {
2268                 snap_mode_selector.set_text (str);
2269         }
2270
2271         instant_save ();
2272 }
2273
2274 void
2275 Editor::set_edit_point_preference (EditPoint ep, bool force)
2276 {
2277         bool changed = (_edit_point != ep);
2278
2279         _edit_point = ep;
2280         if (Profile->get_mixbus())
2281                 if (ep == EditAtSelectedMarker)
2282                         ep = EditAtPlayhead;
2283
2284         string str = edit_point_strings[(int)ep];
2285         if (str != edit_point_selector.get_text ()) {
2286                 edit_point_selector.set_text (str);
2287         }
2288
2289         update_all_enter_cursors();
2290
2291         if (!force && !changed) {
2292                 return;
2293         }
2294
2295         const char* action=NULL;
2296
2297         switch (_edit_point) {
2298         case EditAtPlayhead:
2299                 action = "edit-at-playhead";
2300                 break;
2301         case EditAtSelectedMarker:
2302                 action = "edit-at-marker";
2303                 break;
2304         case EditAtMouse:
2305                 action = "edit-at-mouse";
2306                 break;
2307         }
2308
2309         Glib::RefPtr<Action> act = ActionManager::get_action ("Editor", action);
2310         if (act) {
2311                 Glib::RefPtr<RadioAction>::cast_dynamic(act)->set_active (true);
2312         }
2313
2314         framepos_t foo;
2315         bool in_track_canvas;
2316
2317         if (!mouse_frame (foo, in_track_canvas)) {
2318                 in_track_canvas = false;
2319         }
2320
2321         reset_canvas_action_sensitivity (in_track_canvas);
2322         sensitize_the_right_region_actions (false);
2323
2324         instant_save ();
2325 }
2326
2327 int
2328 Editor::set_state (const XMLNode& node, int version)
2329 {
2330         set_id (node);
2331         PBD::Unwinder<bool> nsi (no_save_instant, true);
2332         bool yn;
2333
2334         Tabbable::set_state (node, version);
2335
2336         framepos_t ph_pos;
2337         if (_session && node.get_property ("playhead", ph_pos)) {
2338                 if (ph_pos >= 0) {
2339                         playhead_cursor->set_position (ph_pos);
2340                 } else {
2341                         warning << _("Playhead position stored with a negative value - ignored (use zero instead)") << endmsg;
2342                         playhead_cursor->set_position (0);
2343                 }
2344         } else {
2345                 playhead_cursor->set_position (0);
2346         }
2347
2348         node.get_property ("mixer-width", editor_mixer_strip_width);
2349
2350         node.get_property ("zoom-focus", zoom_focus);
2351         zoom_focus_selection_done (zoom_focus);
2352
2353         double z;
2354         if (node.get_property ("zoom", z)) {
2355                 /* older versions of ardour used floating point samples_per_pixel */
2356                 reset_zoom (llrintf (z));
2357         } else {
2358                 reset_zoom (samples_per_pixel);
2359         }
2360
2361         int32_t cnt;
2362         if (node.get_property ("visible-track-count", cnt)) {
2363                 set_visible_track_count (cnt);
2364         }
2365
2366         SnapType snap_type;
2367         if (!node.get_property ("snap-to", snap_type)) {
2368                 snap_type = _snap_type;
2369         }
2370         set_snap_to (snap_type);
2371
2372         SnapMode sm;
2373         if (node.get_property ("snap-mode", sm)) {
2374                 snap_mode_selection_done(sm);
2375                 /* set text of Dropdown. in case _snap_mode == SnapOff (default)
2376                  * snap_mode_selection_done() will only mark an already active item as active
2377                  * which does not trigger set_text().
2378                  */
2379                 set_snap_mode (sm);
2380         } else {
2381                 set_snap_mode (_snap_mode);
2382         }
2383
2384         node.get_property ("internal-snap-to", internal_snap_type);
2385         node.get_property ("internal-snap-mode", internal_snap_mode);
2386         node.get_property ("pre-internal-snap-to", pre_internal_snap_type);
2387         node.get_property ("pre-internal-snap-mode", pre_internal_snap_mode);
2388
2389         std::string mm_str;
2390         if (node.get_property ("mouse-mode", mm_str)) {
2391                 MouseMode m = str2mousemode(mm_str);
2392                 set_mouse_mode (m, true);
2393         } else {
2394                 set_mouse_mode (MouseObject, true);
2395         }
2396
2397         framepos_t lf_pos;
2398         if (node.get_property ("left-frame", lf_pos)) {
2399                 if (lf_pos < 0) {
2400                         lf_pos = 0;
2401                 }
2402                 reset_x_origin (lf_pos);
2403         }
2404
2405         double y_origin;
2406         if (node.get_property ("y-origin", y_origin)) {
2407                 reset_y_origin (y_origin);
2408         }
2409
2410         if (node.get_property ("join-object-range", yn)) {
2411                 RefPtr<Action> act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object-range"));
2412                 if (act) {
2413                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2414                         tact->set_active (!yn);
2415                         tact->set_active (yn);
2416                 }
2417                 set_mouse_mode(mouse_mode, true);
2418         }
2419
2420         EditPoint ep;
2421         if (node.get_property ("edit-point", ep)) {
2422                 set_edit_point_preference (ep, true);
2423         } else {
2424                 set_edit_point_preference (_edit_point);
2425         }
2426
2427         node.get_property ("show-measures", _show_measures);
2428
2429         if (node.get_property ("follow-playhead", yn)) {
2430                 set_follow_playhead (yn);
2431         }
2432
2433         if (node.get_property ("stationary-playhead", yn)) {
2434                 set_stationary_playhead (yn);
2435         }
2436
2437         RegionListSortType sort_type;
2438         if (node.get_property ("region-list-sort-type", sort_type)) {
2439                 _regions->reset_sort_type (sort_type, true);
2440         }
2441
2442         if (node.get_property ("show-editor-mixer", yn)) {
2443
2444                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
2445                 assert (act);
2446
2447                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2448
2449                 /* do it twice to force the change */
2450
2451                 tact->set_active (!yn);
2452                 tact->set_active (yn);
2453         }
2454
2455         if (node.get_property ("show-editor-list", yn)) {
2456
2457                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-list"));
2458                 assert (act);
2459
2460                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2461
2462                 /* do it twice to force the change */
2463
2464                 tact->set_active (!yn);
2465                 tact->set_active (yn);
2466         }
2467
2468         int32_t el_page;
2469         if (node.get_property (X_("editor-list-page"), el_page)) {
2470                 _the_notebook.set_current_page (el_page);
2471         }
2472
2473         if (node.get_property (X_("show-marker-lines"), yn)) {
2474                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-marker-lines"));
2475                 assert (act);
2476                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
2477
2478                 tact->set_active (!yn);
2479                 tact->set_active (yn);
2480         }
2481
2482         XMLNodeList children = node.children ();
2483         for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
2484                 selection->set_state (**i, Stateful::current_state_version);
2485                 _regions->set_state (**i);
2486                 _locations->set_state (**i);
2487         }
2488
2489         if (node.get_property ("maximised", yn)) {
2490                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("ToggleMaximalEditor"));
2491                 assert (act);
2492                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2493                 bool fs = tact && tact->get_active();
2494                 if (yn ^ fs) {
2495                         ActionManager::do_action ("Common", "ToggleMaximalEditor");
2496                 }
2497         }
2498
2499         framepos_t nudge_clock_value;
2500         if (node.get_property ("nudge-clock-value", nudge_clock_value)) {
2501                 nudge_clock->set (nudge_clock_value);
2502         } else {
2503                 nudge_clock->set_mode (AudioClock::Timecode);
2504                 nudge_clock->set (_session->frame_rate() * 5, true);
2505         }
2506
2507         {
2508                 /* apply state
2509                  * Not all properties may have been in XML, but
2510                  * those that are linked to a private variable may need changing
2511                  */
2512                 RefPtr<Action> act;
2513
2514                 act = ActionManager::get_action (X_("Editor"), X_("ToggleMeasureVisibility"));
2515                 if (act) {
2516                         yn = _show_measures;
2517                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2518                         /* do it twice to force the change */
2519                         tact->set_active (!yn);
2520                         tact->set_active (yn);
2521                 }
2522
2523                 act = ActionManager::get_action (X_("Editor"), X_("toggle-follow-playhead"));
2524                 yn = _follow_playhead;
2525                 if (act) {
2526                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2527                         if (tact->get_active() != yn) {
2528                                 tact->set_active (yn);
2529                         }
2530                 }
2531
2532                 act = ActionManager::get_action (X_("Editor"), X_("toggle-stationary-playhead"));
2533                 yn = _stationary_playhead;
2534                 if (act) {
2535                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2536                         if (tact->get_active() != yn) {
2537                                 tact->set_active (yn);
2538                         }
2539                 }
2540         }
2541
2542         return LuaInstance::instance()->set_state(node);
2543 }
2544
2545 XMLNode&
2546 Editor::get_state ()
2547 {
2548         XMLNode* node = new XMLNode (X_("Editor"));
2549
2550         node->set_property ("id", id().to_s ());
2551
2552         node->add_child_nocopy (Tabbable::get_state());
2553
2554         node->set_property("edit-horizontal-pane-pos", edit_pane.get_divider ());
2555         node->set_property("notebook-shrunk", _notebook_shrunk);
2556         node->set_property("edit-vertical-pane-pos", editor_summary_pane.get_divider());
2557
2558         maybe_add_mixer_strip_width (*node);
2559
2560         node->set_property ("zoom-focus", zoom_focus);
2561
2562         node->set_property ("zoom", samples_per_pixel);
2563         node->set_property ("snap-to", _snap_type);
2564         node->set_property ("snap-mode", _snap_mode);
2565         node->set_property ("internal-snap-to", internal_snap_type);
2566         node->set_property ("internal-snap-mode", internal_snap_mode);
2567         node->set_property ("pre-internal-snap-to", pre_internal_snap_type);
2568         node->set_property ("pre-internal-snap-mode", pre_internal_snap_mode);
2569         node->set_property ("edit-point", _edit_point);
2570         node->set_property ("visible-track-count", _visible_track_count);
2571
2572         node->set_property ("playhead", playhead_cursor->current_frame ());
2573         node->set_property ("left-frame", leftmost_frame);
2574         node->set_property ("y-origin", vertical_adjustment.get_value ());
2575
2576         node->set_property ("show-measures", _show_measures);
2577         node->set_property ("maximised", _maximised);
2578         node->set_property ("follow-playhead", _follow_playhead);
2579         node->set_property ("stationary-playhead", _stationary_playhead);
2580         node->set_property ("region-list-sort-type", _regions->sort_type ());
2581         node->set_property ("mouse-mode", mouse_mode);
2582         node->set_property ("join-object-range", smart_mode_action->get_active ());
2583
2584         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
2585         if (act) {
2586                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2587                 node->set_property (X_("show-editor-mixer"), tact->get_active());
2588         }
2589
2590         act = ActionManager::get_action (X_("Editor"), X_("show-editor-list"));
2591         if (act) {
2592                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2593                 node->set_property (X_("show-editor-list"), tact->get_active());
2594         }
2595
2596         node->set_property (X_("editor-list-page"), _the_notebook.get_current_page ());
2597
2598         if (button_bindings) {
2599                 XMLNode* bb = new XMLNode (X_("Buttons"));
2600                 button_bindings->save (*bb);
2601                 node->add_child_nocopy (*bb);
2602         }
2603
2604         node->set_property (X_("show-marker-lines"), _show_marker_lines);
2605
2606         node->add_child_nocopy (selection->get_state ());
2607         node->add_child_nocopy (_regions->get_state ());
2608
2609         node->set_property ("nudge-clock-value", nudge_clock->current_duration());
2610
2611         node->add_child_nocopy (LuaInstance::instance()->get_action_state());
2612         node->add_child_nocopy (LuaInstance::instance()->get_hook_state());
2613         node->add_child_nocopy (_locations->get_state ());
2614
2615         return *node;
2616 }
2617
2618 /** if @param trackview_relative_offset is true, @param y y is an offset into the trackview area, in pixel units
2619  *  if @param trackview_relative_offset is false, @param y y is a global canvas *  coordinate, in pixel units
2620  *
2621  *  @return pair: TimeAxisView that y is over, layer index.
2622  *
2623  *  TimeAxisView may be 0.  Layer index is the layer number if the TimeAxisView is valid and is
2624  *  in stacked or expanded region display mode, otherwise 0.
2625  */
2626 std::pair<TimeAxisView *, double>
2627 Editor::trackview_by_y_position (double y, bool trackview_relative_offset) const
2628 {
2629         if (!trackview_relative_offset) {
2630                 y -= _trackview_group->canvas_origin().y;
2631         }
2632
2633         if (y < 0) {
2634                 return std::make_pair ( (TimeAxisView *) 0, 0);
2635         }
2636
2637         for (TrackViewList::const_iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
2638
2639                 std::pair<TimeAxisView*, double> const r = (*iter)->covers_y_position (y);
2640
2641                 if (r.first) {
2642                         return r;
2643                 }
2644         }
2645
2646         return std::make_pair ( (TimeAxisView *) 0, 0);
2647 }
2648
2649 /** Snap a position to the grid, if appropriate, taking into account current
2650  *  grid settings and also the state of any snap modifier keys that may be pressed.
2651  *  @param start Position to snap.
2652  *  @param event Event to get current key modifier information from, or 0.
2653  */
2654 void
2655 Editor::snap_to_with_modifier (MusicFrame& start, GdkEvent const * event, RoundMode direction, bool for_mark)
2656 {
2657         if (!_session || !event) {
2658                 return;
2659         }
2660
2661         if (ArdourKeyboard::indicates_snap (event->button.state)) {
2662                 if (_snap_mode == SnapOff) {
2663                         snap_to_internal (start, direction, for_mark);
2664                 } else {
2665                         start.set (start.frame, 0);
2666                 }
2667         } else {
2668                 if (_snap_mode != SnapOff) {
2669                         snap_to_internal (start, direction, for_mark);
2670                 } else if (ArdourKeyboard::indicates_snap_delta (event->button.state)) {
2671                         /* SnapOff, but we pressed the snap_delta modifier */
2672                         snap_to_internal (start, direction, for_mark);
2673                 } else {
2674                         start.set (start.frame, 0);
2675                 }
2676         }
2677 }
2678
2679 void
2680 Editor::snap_to (MusicFrame& start, RoundMode direction, bool for_mark, bool ensure_snap)
2681 {
2682         if (!_session || (_snap_mode == SnapOff && !ensure_snap)) {
2683                 start.set (start.frame, 0);
2684                 return;
2685         }
2686
2687         snap_to_internal (start, direction, for_mark, ensure_snap);
2688 }
2689
2690 void
2691 Editor::timecode_snap_to_internal (MusicFrame& pos, RoundMode direction, bool /*for_mark*/)
2692 {
2693         framepos_t start = pos.frame;
2694         const framepos_t one_timecode_second = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->samples_per_timecode_frame());
2695         framepos_t one_timecode_minute = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->samples_per_timecode_frame() * 60);
2696
2697         switch (_snap_type) {
2698         case SnapToTimecodeFrame:
2699                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2700                     fmod((double)start, (double)_session->samples_per_timecode_frame()) == 0) {
2701                         /* start is already on a whole timecode frame, do nothing */
2702                 } else if (((direction == 0) && (fmod((double)start, (double)_session->samples_per_timecode_frame()) > (_session->samples_per_timecode_frame() / 2))) || (direction > 0)) {
2703                         start = (framepos_t) (ceil ((double) start / _session->samples_per_timecode_frame()) * _session->samples_per_timecode_frame());
2704                 } else {
2705                         start = (framepos_t) (floor ((double) start / _session->samples_per_timecode_frame()) *  _session->samples_per_timecode_frame());
2706                 }
2707                 break;
2708
2709         case SnapToTimecodeSeconds:
2710                 if (_session->config.get_timecode_offset_negative()) {
2711                         start += _session->config.get_timecode_offset ();
2712                 } else {
2713                         start -= _session->config.get_timecode_offset ();
2714                 }
2715                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2716                     (start % one_timecode_second == 0)) {
2717                         /* start is already on a whole second, do nothing */
2718                 } else if (((direction == 0) && (start % one_timecode_second > one_timecode_second / 2)) || direction > 0) {
2719                         start = (framepos_t) ceil ((double) start / one_timecode_second) * one_timecode_second;
2720                 } else {
2721                         start = (framepos_t) floor ((double) start / one_timecode_second) * one_timecode_second;
2722                 }
2723
2724                 if (_session->config.get_timecode_offset_negative()) {
2725                         start -= _session->config.get_timecode_offset ();
2726                 } else {
2727                         start += _session->config.get_timecode_offset ();
2728                 }
2729                 break;
2730
2731         case SnapToTimecodeMinutes:
2732                 if (_session->config.get_timecode_offset_negative()) {
2733                         start += _session->config.get_timecode_offset ();
2734                 } else {
2735                         start -= _session->config.get_timecode_offset ();
2736                 }
2737                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2738                     (start % one_timecode_minute == 0)) {
2739                         /* start is already on a whole minute, do nothing */
2740                 } else if (((direction == 0) && (start % one_timecode_minute > one_timecode_minute / 2)) || direction > 0) {
2741                         start = (framepos_t) ceil ((double) start / one_timecode_minute) * one_timecode_minute;
2742                 } else {
2743                         start = (framepos_t) floor ((double) start / one_timecode_minute) * one_timecode_minute;
2744                 }
2745                 if (_session->config.get_timecode_offset_negative()) {
2746                         start -= _session->config.get_timecode_offset ();
2747                 } else {
2748                         start += _session->config.get_timecode_offset ();
2749                 }
2750                 break;
2751         default:
2752                 fatal << "Editor::smpte_snap_to_internal() called with non-timecode snap type!" << endmsg;
2753                 abort(); /*NOTREACHED*/
2754         }
2755
2756         pos.set (start, 0);
2757 }
2758
2759 void
2760 Editor::snap_to_internal (MusicFrame& start, RoundMode direction, bool for_mark, bool ensure_snap)
2761 {
2762         const framepos_t one_second = _session->frame_rate();
2763         const framepos_t one_minute = _session->frame_rate() * 60;
2764         framepos_t presnap = start.frame;
2765         framepos_t before;
2766         framepos_t after;
2767
2768         switch (_snap_type) {
2769         case SnapToTimecodeFrame:
2770         case SnapToTimecodeSeconds:
2771         case SnapToTimecodeMinutes:
2772                 return timecode_snap_to_internal (start, direction, for_mark);
2773
2774         case SnapToCDFrame:
2775                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2776                     start.frame % (one_second/75) == 0) {
2777                         /* start is already on a whole CD frame, do nothing */
2778                 } else if (((direction == 0) && (start.frame % (one_second/75) > (one_second/75) / 2)) || (direction > 0)) {
2779                         start.frame = (framepos_t) ceil ((double) start.frame / (one_second / 75)) * (one_second / 75);
2780                 } else {
2781                         start.frame = (framepos_t) floor ((double) start.frame / (one_second / 75)) * (one_second / 75);
2782                 }
2783
2784                 start.set (start.frame, 0);
2785
2786                 break;
2787
2788         case SnapToSeconds:
2789                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2790                     start.frame % one_second == 0) {
2791                         /* start is already on a whole second, do nothing */
2792                 } else if (((direction == 0) && (start.frame % one_second > one_second / 2)) || (direction > 0)) {
2793                         start.frame = (framepos_t) ceil ((double) start.frame / one_second) * one_second;
2794                 } else {
2795                         start.frame = (framepos_t) floor ((double) start.frame / one_second) * one_second;
2796                 }
2797
2798                 start.set (start.frame, 0);
2799
2800                 break;
2801
2802         case SnapToMinutes:
2803                 if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
2804                     start.frame % one_minute == 0) {
2805                         /* start is already on a whole minute, do nothing */
2806                 } else if (((direction == 0) && (start.frame % one_minute > one_minute / 2)) || (direction > 0)) {
2807                         start.frame = (framepos_t) ceil ((double) start.frame / one_minute) * one_minute;
2808                 } else {
2809                         start.frame = (framepos_t) floor ((double) start.frame / one_minute) * one_minute;
2810                 }
2811
2812                 start.set (start.frame, 0);
2813
2814                 break;
2815
2816         case SnapToBar:
2817                 start = _session->tempo_map().round_to_bar (start.frame, direction);
2818                 break;
2819
2820         case SnapToBeat:
2821                 start = _session->tempo_map().round_to_beat (start.frame, direction);
2822                 break;
2823
2824         case SnapToBeatDiv128:
2825                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 128, direction);
2826                 break;
2827         case SnapToBeatDiv64:
2828                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 64, direction);
2829                 break;
2830         case SnapToBeatDiv32:
2831                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 32, direction);
2832                 break;
2833         case SnapToBeatDiv28:
2834                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 28, direction);
2835                 break;
2836         case SnapToBeatDiv24:
2837                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 24, direction);
2838                 break;
2839         case SnapToBeatDiv20:
2840                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 20, direction);
2841                 break;
2842         case SnapToBeatDiv16:
2843                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 16, direction);
2844                 break;
2845         case SnapToBeatDiv14:
2846                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 14, direction);
2847                 break;
2848         case SnapToBeatDiv12:
2849                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 12, direction);
2850                 break;
2851         case SnapToBeatDiv10:
2852                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 10, direction);
2853                 break;
2854         case SnapToBeatDiv8:
2855                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 8, direction);
2856                 break;
2857         case SnapToBeatDiv7:
2858                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 7, direction);
2859                 break;
2860         case SnapToBeatDiv6:
2861                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 6, direction);
2862                 break;
2863         case SnapToBeatDiv5:
2864                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 5, direction);
2865                 break;
2866         case SnapToBeatDiv4:
2867                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 4, direction);
2868                 break;
2869         case SnapToBeatDiv3:
2870                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 3, direction);
2871                 break;
2872         case SnapToBeatDiv2:
2873                 start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 2, direction);
2874                 break;
2875
2876         case SnapToMark:
2877                 if (for_mark) {
2878                         return;
2879                 }
2880
2881                 _session->locations()->marks_either_side (start.frame, before, after);
2882
2883                 if (before == max_framepos && after == max_framepos) {
2884                         /* No marks to snap to, so just don't snap */
2885                         return;
2886                 } else if (before == max_framepos) {
2887                         start.frame = after;
2888                 } else if (after == max_framepos) {
2889                         start.frame = before;
2890                 } else if (before != max_framepos && after != max_framepos) {
2891                         if ((direction == RoundUpMaybe || direction == RoundUpAlways))
2892                                 start.frame = after;
2893                         else if ((direction == RoundDownMaybe || direction == RoundDownAlways))
2894                                 start.frame = before;
2895                         else if (direction ==  0 ) {
2896                                 if ((start.frame - before) < (after - start.frame)) {
2897                                         start.frame = before;
2898                                 } else {
2899                                         start.frame = after;
2900                                 }
2901                         }
2902                 }
2903
2904                 start.set (start.frame, 0);
2905
2906                 break;
2907
2908         case SnapToRegionStart:
2909         case SnapToRegionEnd:
2910         case SnapToRegionSync:
2911         case SnapToRegionBoundary:
2912                 if (!region_boundary_cache.empty()) {
2913
2914                         vector<framepos_t>::iterator prev = region_boundary_cache.end ();
2915                         vector<framepos_t>::iterator next = region_boundary_cache.end ();
2916
2917                         if (direction > 0) {
2918                                 next = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start.frame);
2919                         } else {
2920                                 next = std::lower_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start.frame);
2921                         }
2922
2923                         if (next != region_boundary_cache.begin ()) {
2924                                 prev = next;
2925                                 prev--;
2926                         }
2927
2928                         framepos_t const p = (prev == region_boundary_cache.end()) ? region_boundary_cache.front () : *prev;
2929                         framepos_t const n = (next == region_boundary_cache.end()) ? region_boundary_cache.back () : *next;
2930
2931                         if (start.frame > (p + n) / 2) {
2932                                 start.frame = n;
2933                         } else {
2934                                 start.frame = p;
2935                         }
2936                 }
2937
2938                 start.set (start.frame, 0);
2939
2940                 break;
2941         }
2942
2943         switch (_snap_mode) {
2944         case SnapNormal:
2945                 return;
2946
2947         case SnapMagnetic:
2948
2949                 if (ensure_snap) {
2950                         return;
2951                 }
2952
2953                 if (presnap > start.frame) {
2954                         if (presnap > (start.frame + pixel_to_sample(snap_threshold))) {
2955                                 start.set (presnap, 0);
2956                         }
2957
2958                 } else if (presnap < start.frame) {
2959                         if (presnap < (start.frame - pixel_to_sample(snap_threshold))) {
2960                                 start.set (presnap, 0);
2961                         }
2962                 }
2963
2964         default:
2965                 /* handled at entry */
2966                 return;
2967         }
2968 }
2969
2970
2971 void
2972 Editor::setup_toolbar ()
2973 {
2974         HBox* mode_box = manage(new HBox);
2975         mode_box->set_border_width (2);
2976         mode_box->set_spacing(2);
2977
2978         HBox* mouse_mode_box = manage (new HBox);
2979         HBox* mouse_mode_hbox = manage (new HBox);
2980         VBox* mouse_mode_vbox = manage (new VBox);
2981         Alignment* mouse_mode_align = manage (new Alignment);
2982
2983         Glib::RefPtr<SizeGroup> mouse_mode_size_group = SizeGroup::create (SIZE_GROUP_VERTICAL);
2984         mouse_mode_size_group->add_widget (smart_mode_button);
2985         mouse_mode_size_group->add_widget (mouse_move_button);
2986         mouse_mode_size_group->add_widget (mouse_cut_button);
2987         mouse_mode_size_group->add_widget (mouse_select_button);
2988         mouse_mode_size_group->add_widget (mouse_timefx_button);
2989         mouse_mode_size_group->add_widget (mouse_audition_button);
2990         mouse_mode_size_group->add_widget (mouse_draw_button);
2991         mouse_mode_size_group->add_widget (mouse_content_button);
2992
2993         if (!Profile->get_mixbus()) {
2994                 mouse_mode_size_group->add_widget (zoom_in_button);
2995                 mouse_mode_size_group->add_widget (zoom_out_button);
2996                 mouse_mode_size_group->add_widget (zoom_out_full_button);
2997                 mouse_mode_size_group->add_widget (zoom_focus_selector);
2998                 mouse_mode_size_group->add_widget (tav_shrink_button);
2999                 mouse_mode_size_group->add_widget (tav_expand_button);
3000         } else {
3001                 mouse_mode_size_group->add_widget (zoom_preset_selector);
3002                 mouse_mode_size_group->add_widget (visible_tracks_selector);
3003         }
3004
3005         mouse_mode_size_group->add_widget (snap_type_selector);
3006         mouse_mode_size_group->add_widget (snap_mode_selector);
3007
3008         mouse_mode_size_group->add_widget (edit_point_selector);
3009         mouse_mode_size_group->add_widget (edit_mode_selector);
3010
3011         mouse_mode_size_group->add_widget (*nudge_clock);
3012         mouse_mode_size_group->add_widget (nudge_forward_button);
3013         mouse_mode_size_group->add_widget (nudge_backward_button);
3014
3015         mouse_mode_hbox->set_spacing (2);
3016
3017         if (!ARDOUR::Profile->get_trx()) {
3018                 mouse_mode_hbox->pack_start (smart_mode_button, false, false);
3019         }
3020
3021         mouse_mode_hbox->pack_start (mouse_move_button, false, false);
3022         mouse_mode_hbox->pack_start (mouse_select_button, false, false);
3023
3024         if (!ARDOUR::Profile->get_mixbus()) {
3025                 mouse_mode_hbox->pack_start (mouse_cut_button, false, false);
3026         }
3027
3028         if (!ARDOUR::Profile->get_trx()) {
3029                 mouse_mode_hbox->pack_start (mouse_timefx_button, false, false);
3030                 mouse_mode_hbox->pack_start (mouse_audition_button, false, false);
3031                 mouse_mode_hbox->pack_start (mouse_draw_button, false, false);
3032                 mouse_mode_hbox->pack_start (mouse_content_button, false, false);
3033         }
3034
3035         mouse_mode_vbox->pack_start (*mouse_mode_hbox);
3036
3037         mouse_mode_align->add (*mouse_mode_vbox);
3038         mouse_mode_align->set (0.5, 1.0, 0.0, 0.0);
3039
3040         mouse_mode_box->pack_start (*mouse_mode_align, false, false);
3041
3042         edit_mode_selector.set_name ("mouse mode button");
3043
3044         if (!ARDOUR::Profile->get_trx()) {
3045                 mode_box->pack_start (edit_mode_selector, false, false);
3046         }
3047
3048         mode_box->pack_start (*mouse_mode_box, false, false);
3049
3050         /* Zoom */
3051
3052         _zoom_box.set_spacing (2);
3053         _zoom_box.set_border_width (2);
3054
3055         RefPtr<Action> act;
3056
3057         zoom_preset_selector.set_name ("zoom button");
3058         zoom_preset_selector.set_icon (ArdourIcon::ZoomExpand);
3059
3060         zoom_in_button.set_name ("zoom button");
3061         zoom_in_button.set_icon (ArdourIcon::ZoomIn);
3062         act = ActionManager::get_action (X_("Editor"), X_("temporal-zoom-in"));
3063         zoom_in_button.set_related_action (act);
3064
3065         zoom_out_button.set_name ("zoom button");
3066         zoom_out_button.set_icon (ArdourIcon::ZoomOut);
3067         act = ActionManager::get_action (X_("Editor"), X_("temporal-zoom-out"));
3068         zoom_out_button.set_related_action (act);
3069
3070         zoom_out_full_button.set_name ("zoom button");
3071         zoom_out_full_button.set_icon (ArdourIcon::ZoomFull);
3072         act = ActionManager::get_action (X_("Editor"), X_("zoom-to-session"));
3073         zoom_out_full_button.set_related_action (act);
3074
3075         zoom_focus_selector.set_name ("zoom button");
3076
3077         if (ARDOUR::Profile->get_mixbus()) {
3078                 _zoom_box.pack_start (zoom_preset_selector, false, false);
3079         } else if (ARDOUR::Profile->get_trx()) {
3080                 mode_box->pack_start (zoom_out_button, false, false);
3081                 mode_box->pack_start (zoom_in_button, false, false);
3082         } else {
3083                 _zoom_box.pack_start (zoom_out_button, false, false);
3084                 _zoom_box.pack_start (zoom_in_button, false, false);
3085                 _zoom_box.pack_start (zoom_out_full_button, false, false);
3086                 _zoom_box.pack_start (zoom_focus_selector, false, false);
3087         }
3088
3089         /* Track zoom buttons */
3090         _track_box.set_spacing (2);
3091         _track_box.set_border_width (2);
3092
3093         visible_tracks_selector.set_name ("zoom button");
3094         if (Profile->get_mixbus()) {
3095                 visible_tracks_selector.set_icon (ArdourIcon::TimeAxisExpand);
3096         } else {
3097                 set_size_request_to_display_given_text (visible_tracks_selector, _("All"), 30, 2);
3098         }
3099
3100         tav_expand_button.set_name ("zoom button");
3101         tav_expand_button.set_icon (ArdourIcon::TimeAxisExpand);
3102         act = ActionManager::get_action (X_("Editor"), X_("expand-tracks"));
3103         tav_expand_button.set_related_action (act);
3104
3105         tav_shrink_button.set_name ("zoom button");
3106         tav_shrink_button.set_icon (ArdourIcon::TimeAxisShrink);
3107         act = ActionManager::get_action (X_("Editor"), X_("shrink-tracks"));
3108         tav_shrink_button.set_related_action (act);
3109
3110         if (ARDOUR::Profile->get_mixbus()) {
3111                 _track_box.pack_start (visible_tracks_selector);
3112         } else if (ARDOUR::Profile->get_trx()) {
3113                 _track_box.pack_start (tav_shrink_button);
3114                 _track_box.pack_start (tav_expand_button);
3115         } else {
3116                 _track_box.pack_start (visible_tracks_selector);
3117                 _track_box.pack_start (tav_shrink_button);
3118                 _track_box.pack_start (tav_expand_button);
3119         }
3120
3121         snap_box.set_spacing (2);
3122         snap_box.set_border_width (2);
3123
3124         snap_type_selector.set_name ("mouse mode button");
3125
3126         snap_mode_selector.set_name ("mouse mode button");
3127
3128         edit_point_selector.set_name ("mouse mode button");
3129
3130         snap_box.pack_start (snap_mode_selector, false, false);
3131         snap_box.pack_start (snap_type_selector, false, false);
3132
3133         /* Edit Point*/
3134         HBox *ep_box = manage (new HBox);
3135         ep_box->set_spacing (2);
3136         ep_box->set_border_width (2);
3137
3138         ep_box->pack_start (edit_point_selector, false, false);
3139
3140         /* Nudge */
3141
3142         HBox *nudge_box = manage (new HBox);
3143         nudge_box->set_spacing (2);
3144         nudge_box->set_border_width (2);
3145
3146         nudge_forward_button.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::nudge_forward_release), false);
3147         nudge_backward_button.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::nudge_backward_release), false);
3148
3149         nudge_box->pack_start (nudge_backward_button, false, false);
3150         nudge_box->pack_start (nudge_forward_button, false, false);
3151         nudge_box->pack_start (*nudge_clock, false, false);
3152
3153
3154         /* Pack everything in... */
3155
3156         toolbar_hbox.set_spacing (2);
3157         toolbar_hbox.set_border_width (2);
3158
3159         toolbar_hbox.pack_start (*mode_box, false, false);
3160
3161         if (!ARDOUR::Profile->get_trx()) {
3162
3163                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3164
3165                 toolbar_hbox.pack_start (_zoom_box, false, false);
3166
3167                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3168
3169                 toolbar_hbox.pack_start (_track_box, false, false);
3170
3171                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3172
3173                 toolbar_hbox.pack_start (snap_box, false, false);
3174
3175                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3176
3177                 toolbar_hbox.pack_start (*ep_box, false, false);
3178
3179                 toolbar_hbox.pack_start (*(manage (new ArdourVSpacer ())), false, false, 3);
3180
3181                 toolbar_hbox.pack_start (*nudge_box, false, false);
3182         }
3183
3184         toolbar_hbox.show_all ();
3185 }
3186
3187 void
3188 Editor::build_edit_point_menu ()
3189 {
3190         using namespace Menu_Helpers;
3191
3192         edit_point_selector.AddMenuElem (MenuElem ( edit_point_strings[(int)EditAtPlayhead], sigc::bind (sigc::mem_fun(*this, &Editor::edit_point_selection_done), (EditPoint) EditAtPlayhead)));
3193         if(!Profile->get_mixbus())
3194                 edit_point_selector.AddMenuElem (MenuElem ( edit_point_strings[(int)EditAtSelectedMarker], sigc::bind (sigc::mem_fun(*this, &Editor::edit_point_selection_done), (EditPoint) EditAtSelectedMarker)));
3195         edit_point_selector.AddMenuElem (MenuElem ( edit_point_strings[(int)EditAtMouse], sigc::bind (sigc::mem_fun(*this, &Editor::edit_point_selection_done), (EditPoint) EditAtMouse)));
3196
3197         set_size_request_to_display_given_text (edit_point_selector, edit_point_strings, COMBO_TRIANGLE_WIDTH, 2);
3198 }
3199
3200 void
3201 Editor::build_edit_mode_menu ()
3202 {
3203         using namespace Menu_Helpers;
3204
3205         edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Slide], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Slide)));
3206 //      edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Splice], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Splice)));
3207         edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Ripple], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode) Ripple)));
3208         edit_mode_selector.AddMenuElem (MenuElem ( edit_mode_strings[(int)Lock], sigc::bind (sigc::mem_fun(*this, &Editor::edit_mode_selection_done), (EditMode)  Lock)));
3209
3210         set_size_request_to_display_given_text (edit_mode_selector, edit_mode_strings, COMBO_TRIANGLE_WIDTH, 2);
3211 }
3212
3213 void
3214 Editor::build_snap_mode_menu ()
3215 {
3216         using namespace Menu_Helpers;
3217
3218         snap_mode_selector.AddMenuElem (MenuElem ( snap_mode_strings[(int)SnapOff], sigc::bind (sigc::mem_fun(*this, &Editor::snap_mode_selection_done), (SnapMode) SnapOff)));
3219         snap_mode_selector.AddMenuElem (MenuElem ( snap_mode_strings[(int)SnapNormal], sigc::bind (sigc::mem_fun(*this, &Editor::snap_mode_selection_done), (SnapMode) SnapNormal)));
3220         snap_mode_selector.AddMenuElem (MenuElem ( snap_mode_strings[(int)SnapMagnetic], sigc::bind (sigc::mem_fun(*this, &Editor::snap_mode_selection_done), (SnapMode) SnapMagnetic)));
3221
3222         set_size_request_to_display_given_text (snap_mode_selector, snap_mode_strings, COMBO_TRIANGLE_WIDTH, 2);
3223 }
3224
3225 void
3226 Editor::build_snap_type_menu ()
3227 {
3228         using namespace Menu_Helpers;
3229
3230         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToCDFrame], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToCDFrame)));
3231         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToTimecodeFrame], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToTimecodeFrame)));
3232         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToTimecodeSeconds], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToTimecodeSeconds)));
3233         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToTimecodeMinutes], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToTimecodeMinutes)));
3234         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToSeconds], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToSeconds)));
3235         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToMinutes], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToMinutes)));
3236         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv128], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv128)));
3237         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv64], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv64)));
3238         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv32], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv32)));
3239         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv28], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv28)));
3240         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv24], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv24)));
3241         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv20], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv20)));
3242         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv16], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv16)));
3243         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv14], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv14)));
3244         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv12], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv12)));
3245         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv10], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv10)));
3246         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv8], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv8)));
3247         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv7], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv7)));
3248         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv6], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv6)));
3249         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv5], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv5)));
3250         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv4], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv4)));
3251         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv3], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv3)));
3252         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeatDiv2], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeatDiv2)));
3253         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBeat], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBeat)));
3254         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToBar], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToBar)));
3255         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToMark], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToMark)));
3256         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToRegionStart], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToRegionStart)));
3257         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToRegionEnd], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToRegionEnd)));
3258         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToRegionSync], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToRegionSync)));
3259         snap_type_selector.AddMenuElem (MenuElem ( snap_type_strings[(int)SnapToRegionBoundary], sigc::bind (sigc::mem_fun(*this, &Editor::snap_type_selection_done), (SnapType) SnapToRegionBoundary)));
3260
3261         set_size_request_to_display_given_text (snap_type_selector, snap_type_strings, COMBO_TRIANGLE_WIDTH, 2);
3262
3263 }
3264
3265 void
3266 Editor::setup_tooltips ()
3267 {
3268         set_tooltip (smart_mode_button, _("Smart Mode (add range functions to Grab Mode)"));
3269         set_tooltip (mouse_move_button, _("Grab Mode (select/move objects)"));
3270         set_tooltip (mouse_cut_button, _("Cut Mode (split regions)"));
3271         set_tooltip (mouse_select_button, _("Range Mode (select time ranges)"));
3272         set_tooltip (mouse_draw_button, _("Draw Mode (draw and edit gain/notes/automation)"));
3273         set_tooltip (mouse_timefx_button, _("Stretch Mode (time-stretch audio and midi regions, preserving pitch)"));
3274         set_tooltip (mouse_audition_button, _("Audition Mode (listen to regions)"));
3275         set_tooltip (mouse_content_button, _("Internal Edit Mode (edit notes and automation points)"));
3276         set_tooltip (*_group_tabs, _("Groups: click to (de)activate\nContext-click for other operations"));
3277         set_tooltip (nudge_forward_button, _("Nudge Region/Selection Later"));
3278         set_tooltip (nudge_backward_button, _("Nudge Region/Selection Earlier"));
3279         set_tooltip (zoom_in_button, _("Zoom In"));
3280         set_tooltip (zoom_out_button, _("Zoom Out"));
3281         set_tooltip (zoom_preset_selector, _("Zoom to Time Scale"));
3282         set_tooltip (zoom_out_full_button, _("Zoom to Session"));
3283         set_tooltip (zoom_focus_selector, _("Zoom Focus"));
3284         set_tooltip (tav_expand_button, _("Expand Tracks"));
3285         set_tooltip (tav_shrink_button, _("Shrink Tracks"));
3286         set_tooltip (visible_tracks_selector, _("Number of visible tracks"));
3287         set_tooltip (snap_type_selector, _("Snap/Grid Units"));
3288         set_tooltip (snap_mode_selector, _("Snap/Grid Mode"));
3289         set_tooltip (edit_point_selector, _("Edit Point"));
3290         set_tooltip (edit_mode_selector, _("Edit Mode"));
3291         set_tooltip (nudge_clock, _("Nudge Clock\n(controls distance used to nudge regions and selections)"));
3292 }
3293
3294 int
3295 Editor::convert_drop_to_paths (
3296                 vector<string>&                paths,
3297                 const RefPtr<Gdk::DragContext>& /*context*/,
3298                 gint                            /*x*/,
3299                 gint                            /*y*/,
3300                 const SelectionData&            data,
3301                 guint                           /*info*/,
3302                 guint                           /*time*/)
3303 {
3304         if (_session == 0) {
3305                 return -1;
3306         }
3307
3308         vector<string> uris = data.get_uris();
3309
3310         if (uris.empty()) {
3311
3312                 /* This is seriously fucked up. Nautilus doesn't say that its URI lists
3313                    are actually URI lists. So do it by hand.
3314                 */
3315
3316                 if (data.get_target() != "text/plain") {
3317                         return -1;
3318                 }
3319
3320                 /* Parse the "uri-list" format that Nautilus provides,
3321                    where each pathname is delimited by \r\n.
3322
3323                    THERE MAY BE NO NULL TERMINATING CHAR!!!
3324                 */
3325
3326                 string txt = data.get_text();
3327                 char* p;
3328                 const char* q;
3329
3330                 p = (char *) malloc (txt.length() + 1);
3331                 txt.copy (p, txt.length(), 0);
3332                 p[txt.length()] = '\0';
3333
3334                 while (p)
3335                 {
3336                         if (*p != '#')
3337                         {
3338                                 while (g_ascii_isspace (*p))
3339                                         p++;
3340
3341                                 q = p;
3342                                 while (*q && (*q != '\n') && (*q != '\r')) {
3343                                         q++;
3344                                 }
3345
3346                                 if (q > p)
3347                                 {
3348                                         q--;
3349                                         while (q > p && g_ascii_isspace (*q))
3350                                                 q--;
3351
3352                                         if (q > p)
3353                                         {
3354                                                 uris.push_back (string (p, q - p + 1));
3355                                         }
3356                                 }
3357                         }
3358                         p = strchr (p, '\n');
3359                         if (p)
3360                                 p++;
3361                 }
3362
3363                 free ((void*)p);
3364
3365                 if (uris.empty()) {
3366                         return -1;
3367                 }
3368         }
3369
3370         for (vector<string>::iterator i = uris.begin(); i != uris.end(); ++i) {
3371                 if ((*i).substr (0,7) == "file://") {
3372                         paths.push_back (Glib::filename_from_uri (*i));
3373                 }
3374         }
3375
3376         return 0;
3377 }
3378
3379 void
3380 Editor::new_tempo_section ()
3381 {
3382 }
3383
3384 void
3385 Editor::map_transport_state ()
3386 {
3387         ENSURE_GUI_THREAD (*this, &Editor::map_transport_state);
3388
3389         if (_session && _session->transport_stopped()) {
3390                 have_pending_keyboard_selection = false;
3391         }
3392
3393         update_loop_range_view ();
3394 }
3395
3396 void
3397 Editor::transport_looped ()
3398 {
3399         /* reset Playhead position interpolation.
3400          * see Editor::super_rapid_screen_update
3401          */
3402         _last_update_time = 0;
3403 }
3404
3405 /* UNDO/REDO */
3406
3407 void
3408 Editor::begin_selection_op_history ()
3409 {
3410         selection_op_cmd_depth = 0;
3411         selection_op_history_it = 0;
3412
3413         while(!selection_op_history.empty()) {
3414                 delete selection_op_history.front();
3415                 selection_op_history.pop_front();
3416         }
3417
3418         selection_undo_action->set_sensitive (false);
3419         selection_redo_action->set_sensitive (false);
3420         selection_op_history.push_front (&_selection_memento->get_state ());
3421 }
3422
3423 void
3424 Editor::begin_reversible_selection_op (string name)
3425 {
3426         if (_session) {
3427                 //cerr << name << endl;
3428                 /* begin/commit pairs can be nested */
3429                 selection_op_cmd_depth++;
3430         }
3431 }
3432
3433 void
3434 Editor::commit_reversible_selection_op ()
3435 {
3436         if (_session) {
3437                 if (selection_op_cmd_depth == 1) {
3438
3439                         if (selection_op_history_it > 0 && selection_op_history_it < selection_op_history.size()) {
3440                                 /**
3441                                     The user has undone some selection ops and then made a new one,
3442                                     making anything earlier in the list invalid.
3443                                 */
3444
3445                                 list<XMLNode *>::iterator it = selection_op_history.begin();
3446                                 list<XMLNode *>::iterator e_it = it;
3447                                 advance (e_it, selection_op_history_it);
3448
3449                                 for ( ; it != e_it; ++it) {
3450                                         delete *it;
3451                                 }
3452                                 selection_op_history.erase (selection_op_history.begin(), e_it);
3453                         }
3454
3455                         selection_op_history.push_front (&_selection_memento->get_state ());
3456                         selection_op_history_it = 0;
3457
3458                         selection_undo_action->set_sensitive (true);
3459                         selection_redo_action->set_sensitive (false);
3460                 }
3461
3462                 if (selection_op_cmd_depth > 0) {
3463                         selection_op_cmd_depth--;
3464                 }
3465         }
3466 }
3467
3468 void
3469 Editor::undo_selection_op ()
3470 {
3471         if (_session) {
3472                 selection_op_history_it++;
3473                 uint32_t n = 0;
3474                 for (std::list<XMLNode *>::iterator i = selection_op_history.begin(); i != selection_op_history.end(); ++i) {
3475                         if (n == selection_op_history_it) {
3476                                 _selection_memento->set_state (*(*i), Stateful::current_state_version);
3477                                 selection_redo_action->set_sensitive (true);
3478                         }
3479                         ++n;
3480                 }
3481                 /* is there an earlier entry? */
3482                 if ((selection_op_history_it + 1) >= selection_op_history.size()) {
3483                         selection_undo_action->set_sensitive (false);
3484                 }
3485         }
3486 }
3487
3488 void
3489 Editor::redo_selection_op ()
3490 {
3491         if (_session) {
3492                 if (selection_op_history_it > 0) {
3493                         selection_op_history_it--;
3494                 }
3495                 uint32_t n = 0;
3496                 for (std::list<XMLNode *>::iterator i = selection_op_history.begin(); i != selection_op_history.end(); ++i) {
3497                         if (n == selection_op_history_it) {
3498                                 _selection_memento->set_state (*(*i), Stateful::current_state_version);
3499                                 selection_undo_action->set_sensitive (true);
3500                         }
3501                         ++n;
3502                 }
3503
3504                 if (selection_op_history_it == 0) {
3505                         selection_redo_action->set_sensitive (false);
3506                 }
3507         }
3508 }
3509
3510 void
3511 Editor::begin_reversible_command (string name)
3512 {
3513         if (_session) {
3514                 before.push_back (&_selection_memento->get_state ());
3515                 _session->begin_reversible_command (name);
3516         }
3517 }
3518
3519 void
3520 Editor::begin_reversible_command (GQuark q)
3521 {
3522         if (_session) {
3523                 before.push_back (&_selection_memento->get_state ());
3524                 _session->begin_reversible_command (q);
3525         }
3526 }
3527
3528 void
3529 Editor::abort_reversible_command ()
3530 {
3531         if (_session) {
3532                 while(!before.empty()) {
3533                         delete before.front();
3534                         before.pop_front();
3535                 }
3536                 _session->abort_reversible_command ();
3537         }
3538 }
3539
3540 void
3541 Editor::commit_reversible_command ()
3542 {
3543         if (_session) {
3544                 if (before.size() == 1) {
3545                         _session->add_command (new MementoCommand<SelectionMemento>(*(_selection_memento), before.front(), &_selection_memento->get_state ()));
3546                         redo_action->set_sensitive(false);
3547                         undo_action->set_sensitive(true);
3548                         begin_selection_op_history ();
3549                 }
3550
3551                 if (before.empty()) {
3552                         cerr << "Please call begin_reversible_command() before commit_reversible_command()." << endl;
3553                 } else {
3554                         before.pop_back();
3555                 }
3556
3557                 _session->commit_reversible_command ();
3558         }
3559 }
3560
3561 void
3562 Editor::history_changed ()
3563 {
3564         string label;
3565
3566         if (undo_action && _session) {
3567                 if (_session->undo_depth() == 0) {
3568                         label = S_("Command|Undo");
3569                 } else {
3570                         label = string_compose(S_("Command|Undo (%1)"), _session->next_undo());
3571                 }
3572                 undo_action->property_label() = label;
3573         }
3574
3575         if (redo_action && _session) {
3576                 if (_session->redo_depth() == 0) {
3577                         label = _("Redo");
3578                         redo_action->set_sensitive (false);
3579                 } else {
3580                         label = string_compose(_("Redo (%1)"), _session->next_redo());
3581                         redo_action->set_sensitive (true);
3582                 }
3583                 redo_action->property_label() = label;
3584         }
3585 }
3586
3587 void
3588 Editor::duplicate_range (bool with_dialog)
3589 {
3590         float times = 1.0f;
3591
3592         RegionSelection rs = get_regions_from_selection_and_entered ();
3593
3594         if ( selection->time.length() == 0 && rs.empty()) {
3595                 return;
3596         }
3597
3598         if (with_dialog) {
3599
3600                 ArdourDialog win (_("Duplicate"));
3601                 Label label (_("Number of duplications:"));
3602                 Adjustment adjustment (1.0, 1.0, 1000000.0, 1.0, 5.0);
3603                 SpinButton spinner (adjustment, 0.0, 1);
3604                 HBox hbox;
3605
3606                 win.get_vbox()->set_spacing (12);
3607                 win.get_vbox()->pack_start (hbox);
3608                 hbox.set_border_width (6);
3609                 hbox.pack_start (label, PACK_EXPAND_PADDING, 12);
3610
3611                 /* dialogs have ::add_action_widget() but that puts the spinner in the wrong
3612                    place, visually. so do this by hand.
3613                 */
3614
3615                 hbox.pack_start (spinner, PACK_EXPAND_PADDING, 12);
3616                 spinner.signal_activate().connect (sigc::bind (sigc::mem_fun (win, &ArdourDialog::response), RESPONSE_ACCEPT));
3617                 spinner.grab_focus();
3618
3619                 hbox.show ();
3620                 label.show ();
3621                 spinner.show ();
3622
3623                 win.add_button (Stock::CANCEL, RESPONSE_CANCEL);
3624                 win.add_button (_("Duplicate"), RESPONSE_ACCEPT);
3625                 win.set_default_response (RESPONSE_ACCEPT);
3626
3627                 spinner.grab_focus ();
3628
3629                 switch (win.run ()) {
3630                 case RESPONSE_ACCEPT:
3631                         break;
3632                 default:
3633                         return;
3634                 }
3635
3636                 times = adjustment.get_value();
3637         }
3638
3639         if ((current_mouse_mode() == Editing::MouseRange)) {
3640                 if (selection->time.length()) {
3641                         duplicate_selection (times);
3642                 }
3643         } else if (get_smart_mode()) {
3644                 if (selection->time.length()) {
3645                         duplicate_selection (times);
3646                 } else
3647                         duplicate_some_regions (rs, times);
3648         } else {
3649                 duplicate_some_regions (rs, times);
3650         }
3651 }
3652
3653 void
3654 Editor::set_edit_mode (EditMode m)
3655 {
3656         Config->set_edit_mode (m);
3657 }
3658
3659 void
3660 Editor::cycle_edit_mode ()
3661 {
3662         switch (Config->get_edit_mode()) {
3663         case Slide:
3664                 Config->set_edit_mode (Ripple);
3665                 break;
3666         case Splice:
3667         case Ripple:
3668                 Config->set_edit_mode (Lock);
3669                 break;
3670         case Lock:
3671                 Config->set_edit_mode (Slide);
3672                 break;
3673         }
3674 }
3675
3676 void
3677 Editor::edit_mode_selection_done ( EditMode m )
3678 {
3679         Config->set_edit_mode ( m );
3680 }
3681
3682 void
3683 Editor::snap_type_selection_done (SnapType snaptype)
3684 {
3685         RefPtr<RadioAction> ract = snap_type_action (snaptype);
3686         if (ract) {
3687                 ract->set_active ();
3688         }
3689 }
3690
3691 void
3692 Editor::snap_mode_selection_done (SnapMode mode)
3693 {
3694         RefPtr<RadioAction> ract = snap_mode_action (mode);
3695
3696         if (ract) {
3697                 ract->set_active (true);
3698         }
3699 }
3700
3701 void
3702 Editor::cycle_edit_point (bool with_marker)
3703 {
3704         if(Profile->get_mixbus())
3705                 with_marker = false;
3706
3707         switch (_edit_point) {
3708         case EditAtMouse:
3709                 set_edit_point_preference (EditAtPlayhead);
3710                 break;
3711         case EditAtPlayhead:
3712                 if (with_marker) {
3713                         set_edit_point_preference (EditAtSelectedMarker);
3714                 } else {
3715                         set_edit_point_preference (EditAtMouse);
3716                 }
3717                 break;
3718         case EditAtSelectedMarker:
3719                 set_edit_point_preference (EditAtMouse);
3720                 break;
3721         }
3722 }
3723
3724 void
3725 Editor::edit_point_selection_done (EditPoint ep)
3726 {
3727         set_edit_point_preference ( ep );
3728 }
3729
3730 void
3731 Editor::build_zoom_focus_menu ()
3732 {
3733         using namespace Menu_Helpers;
3734
3735         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusLeft], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusLeft)));
3736         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusRight], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusRight)));
3737         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusCenter], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusCenter)));
3738         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusPlayhead], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusPlayhead)));
3739         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusMouse], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusMouse)));
3740         zoom_focus_selector.AddMenuElem (MenuElem ( zoom_focus_strings[(int)ZoomFocusEdit], sigc::bind (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done), (ZoomFocus) ZoomFocusEdit)));
3741
3742         set_size_request_to_display_given_text (zoom_focus_selector, zoom_focus_strings, COMBO_TRIANGLE_WIDTH, 2);
3743 }
3744
3745 void
3746 Editor::zoom_focus_selection_done ( ZoomFocus f )
3747 {
3748         RefPtr<RadioAction> ract = zoom_focus_action (f);
3749         if (ract) {
3750                 ract->set_active ();
3751         }
3752 }
3753
3754 void
3755 Editor::build_track_count_menu ()
3756 {
3757         using namespace Menu_Helpers;
3758
3759         if (!Profile->get_mixbus()) {
3760                 visible_tracks_selector.AddMenuElem (MenuElem (X_("1"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 1)));
3761                 visible_tracks_selector.AddMenuElem (MenuElem (X_("2"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 2)));
3762                 visible_tracks_selector.AddMenuElem (MenuElem (X_("3"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 3)));
3763                 visible_tracks_selector.AddMenuElem (MenuElem (X_("4"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 4)));
3764                 visible_tracks_selector.AddMenuElem (MenuElem (X_("8"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 8)));
3765                 visible_tracks_selector.AddMenuElem (MenuElem (X_("12"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 12)));
3766                 visible_tracks_selector.AddMenuElem (MenuElem (X_("16"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 16)));
3767                 visible_tracks_selector.AddMenuElem (MenuElem (X_("20"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 20)));
3768                 visible_tracks_selector.AddMenuElem (MenuElem (X_("24"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 24)));
3769                 visible_tracks_selector.AddMenuElem (MenuElem (X_("32"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 32)));
3770                 visible_tracks_selector.AddMenuElem (MenuElem (X_("64"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 64)));
3771                 visible_tracks_selector.AddMenuElem (MenuElem (_("Selection"), sigc::mem_fun(*this, &Editor::fit_selection)));
3772                 visible_tracks_selector.AddMenuElem (MenuElem (_("All"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 0)));
3773         } else {
3774                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 1 track"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 1)));
3775                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 2 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 2)));
3776                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 4 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 4)));
3777                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 8 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 8)));
3778                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 16 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 16)));
3779                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 24 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 24)));
3780                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 32 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 32)));
3781                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit 48 tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 48)));
3782                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit All tracks"), sigc::bind (sigc::mem_fun(*this, &Editor::set_visible_track_count), 0)));
3783                 visible_tracks_selector.AddMenuElem (MenuElem (_("Fit Selection"), sigc::mem_fun(*this, &Editor::fit_selection)));
3784
3785                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 10 ms"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 10)));
3786                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 100 ms"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 100)));
3787                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 1 sec"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 1 * 1000)));
3788                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 10 sec"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 10 * 1000)));
3789                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 1 min"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 60 * 1000)));
3790                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 10 min"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 10 * 60 * 1000)));
3791                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 1 hour"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 60 * 60 * 1000)));
3792                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 8 hours"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 8 * 60 * 60 * 1000)));
3793                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to 24 hours"), sigc::bind (sigc::mem_fun(*this, &Editor::set_zoom_preset), 24 * 60 * 60 * 1000)));
3794                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to Session"), sigc::mem_fun(*this, &Editor::temporal_zoom_session)));
3795                 zoom_preset_selector.AddMenuElem (MenuElem (_("Zoom to Range/Region Selection"), sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_selection), Horizontal)));
3796         }
3797 }
3798
3799 void
3800 Editor::set_zoom_preset (int64_t ms)
3801 {
3802         if ( ms <= 0 ) {
3803                 temporal_zoom_session();
3804                 return;
3805         }
3806
3807         ARDOUR::framecnt_t const sample_rate = ARDOUR::AudioEngine::instance()->sample_rate();
3808         temporal_zoom( (sample_rate * ms / 1000) / _visible_canvas_width );
3809 }
3810
3811 void
3812 Editor::set_visible_track_count (int32_t n)
3813 {
3814         _visible_track_count = n;
3815
3816         /* if the canvas hasn't really been allocated any size yet, just
3817            record the desired number of visible tracks and return. when canvas
3818            allocation happens, we will get called again and then we can do the
3819            real work.
3820         */
3821
3822         if (_visible_canvas_height <= 1) {
3823                 return;
3824         }
3825
3826         int h;
3827         string str;
3828         DisplaySuspender ds;
3829
3830         if (_visible_track_count > 0) {
3831                 h = trackviews_height() / _visible_track_count;
3832                 std::ostringstream s;
3833                 s << _visible_track_count;
3834                 str = s.str();
3835         } else if (_visible_track_count == 0) {
3836                 uint32_t n = 0;
3837                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
3838                         if ((*i)->marked_for_display()) {
3839                                 ++n;
3840                         }
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 RouteTimeAxisView by the ID of its route */
5566 RouteTimeAxisView*
5567 Editor::get_route_view_by_route_id (const PBD::ID& id) const
5568 {
5569         RouteTimeAxisView* v;
5570
5571         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5572                 if((v = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
5573                         if(v->route()->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 }