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
  47 #include <glibmm/miscutils.h>
  48 #include <gtkmm/image.h>
  49 #include <gdkmm/color.h>
  50 #include <gdkmm/bitmap.h>
  51
  52 #include "gtkmm2ext/bindings.h"
  53 #include "gtkmm2ext/grouped_buttons.h"
  54 #include "gtkmm2ext/gtk_ui.h"
  55 #include "gtkmm2ext/tearoff.h"
  56 #include "gtkmm2ext/utils.h"
  57 #include "gtkmm2ext/window_title.h"
  58 #include "gtkmm2ext/choice.h"
  59 #include "gtkmm2ext/cell_renderer_pixbuf_toggle.h"
  60
  61 #include "ardour/audio_diskstream.h"
  62 #include "ardour/audio_track.h"
  63 #include "ardour/audioplaylist.h"
  64 #include "ardour/audioregion.h"
  65 #include "ardour/location.h"
  66 #include "ardour/midi_region.h"
  67 #include "ardour/plugin_manager.h"
  68 #include "ardour/profile.h"
  69 #include "ardour/route_group.h"
  70 #include "ardour/session_directory.h"
  71 #include "ardour/session_route.h"
  72 #include "ardour/session_state_utils.h"
  73 #include "ardour/tempo.h"
  74 #include "ardour/utils.h"
  75 #include "ardour/session_playlists.h"
  76 #include "ardour/audioengine.h"
  77
  78 #include "control_protocol/control_protocol.h"
  79
  80 #include "actions.h"
  81 #include "actions.h"
  82 #include "analysis_window.h"
  83 #include "audio_clock.h"
  84 #include "audio_region_view.h"
  85 #include "audio_streamview.h"
  86 #include "audio_time_axis.h"
  87 #include "automation_time_axis.h"
  88 #include "bundle_manager.h"
  89 #include "canvas-noevent-text.h"
  90 #include "canvas_impl.h"
  91 #include "crossfade_edit.h"
  92 #include "crossfade_view.h"
  93 #include "debug.h"
  94 #include "editing.h"
  95 #include "editor.h"
  96 #include "editor_cursors.h"
  97 #include "editor_drag.h"
  98 #include "editor_group_tabs.h"
  99 #include "editor_locations.h"
 100 #include "editor_regions.h"
 101 #include "editor_route_groups.h"
 102 #include "editor_routes.h"
 103 #include "editor_snapshots.h"
 104 #include "editor_summary.h"
 105 #include "global_port_matrix.h"
 106 #include "gui_object.h"
 107 #include "gui_thread.h"
 108 #include "keyboard.h"
 109 #include "marker.h"
 110 #include "midi_time_axis.h"
 111 #include "mixer_strip.h"
 112 #include "mouse_cursors.h"
 113 #include "playlist_selector.h"
 114 #include "public_editor.h"
 115 #include "region_layering_order_editor.h"
 116 #include "rgb_macros.h"
 117 #include "rhythm_ferret.h"
 118 #include "selection.h"
 119 #include "sfdb_ui.h"
 120 #include "simpleline.h"
 121 #include "tempo_lines.h"
 122 #include "time_axis_view.h"
 123 #include "utils.h"
 124
 125 #include "i18n.h"
 126
 127 #ifdef WITH_CMT
 128 #include "imageframe_socket_handler.h"
 129 #endif
 130
 131 using namespace std;
 132 using namespace ARDOUR;
 133 using namespace PBD;
 134 using namespace Gtk;
 135 using namespace Glib;
 136 using namespace Gtkmm2ext;
 137 using namespace Editing;
 138
 139 using PBD::internationalize;
 140 using PBD::atoi;
 141 using Gtkmm2ext::Keyboard;
 142
 143 const double Editor::timebar_height = 15.0;
 144
 145 static const gchar *_snap_type_strings[] = {
 146         N_("CD Frames"),
 147         N_("Timecode Frames"),
 148         N_("Timecode Seconds"),
 149         N_("Timecode Minutes"),
 150         N_("Seconds"),
 151         N_("Minutes"),
 152         N_("Beats/32"),
 153         N_("Beats/28"),
 154         N_("Beats/24"),
 155         N_("Beats/20"),
 156         N_("Beats/16"),
 157         N_("Beats/14"),
 158         N_("Beats/12"),
 159         N_("Beats/10"),
 160         N_("Beats/8"),
 161         N_("Beats/7"),
 162         N_("Beats/6"),
 163         N_("Beats/5"),
 164         N_("Beats/4"),
 165         N_("Beats/3"),
 166         N_("Beats/2"),
 167         N_("Beats"),
 168         N_("Bars"),
 169         N_("Marks"),
 170         N_("Region starts"),
 171         N_("Region ends"),
 172         N_("Region syncs"),
 173         N_("Region bounds"),
 174         0
 175 };
 176
 177 static const gchar *_snap_mode_strings[] = {
 178         N_("No Grid"),
 179         N_("Grid"),
 180         N_("Magnetic"),
 181         0
 182 };
 183
 184 static const gchar *_edit_point_strings[] = {
 185         N_("Playhead"),
 186         N_("Marker"),
 187         N_("Mouse"),
 188         0
 189 };
 190
 191 static const gchar *_zoom_focus_strings[] = {
 192         N_("Left"),
 193         N_("Right"),
 194         N_("Center"),
 195         N_("Playhead"),
 196         N_("Mouse"),
 197         N_("Edit point"),
 198         0
 199 };
 200
 201 #ifdef USE_RUBBERBAND
 202 static const gchar *_rb_opt_strings[] = {
 203         N_("Mushy"),
 204         N_("Smooth"),
 205         N_("Balanced multitimbral mixture"),
 206         N_("Unpitched percussion with stable notes"),
 207         N_("Crisp monophonic instrumental"),
 208         N_("Unpitched solo percussion"),
 209         N_("Resample without preserving pitch"),
 210         0
 211 };
 212 #endif
 213
 214 void
 215 show_me_the_size (Requisition* r, const char* what)
 216 {
 217         cerr << "size of " << what << " = " << r->width << " x " << r->height << endl;
 218 }
 219
 220 #ifdef GTKOSX
 221 static void
 222 pane_size_watcher (Paned* pane)
 223 {
 224         /* if the handle of a pane vanishes into (at least) the tabs of a notebook,
 225            it is no longer accessible. so stop that. this doesn't happen on X11,
 226            just the quartz backend.
 227
 228            ugh.
 229         */
 230
 231         int max_width_of_lhs = GTK_WIDGET(pane->gobj())->allocation.width - 25;
 232
 233         gint pos = pane->get_position ();
 234
 235         if (pos > max_width_of_lhs) {
 236                 pane->set_position (max_width_of_lhs);
 237         }
 238 }
 239 #endif
 240
 241 Editor::Editor ()
 242         : _join_object_range_state (JOIN_OBJECT_RANGE_NONE)
 243
 244           /* time display buttons */
 245         , minsec_label (_("Mins:Secs"))
 246         , bbt_label (_("Bars:Beats"))
 247         , timecode_label (_("Timecode"))
 248         , samples_label (_("Samples"))
 249         , tempo_label (_("Tempo"))
 250         , meter_label (_("Meter"))
 251         , mark_label (_("Location Markers"))
 252         , range_mark_label (_("Range Markers"))
 253         , transport_mark_label (_("Loop/Punch Ranges"))
 254         , cd_mark_label (_("CD Markers"))
 255         , edit_packer (4, 4, true)
 256
 257           /* the values here don't matter: layout widgets
 258              reset them as needed.
 259           */
 260
 261         , vertical_adjustment (0.0, 0.0, 10.0, 400.0)
 262
 263           /* tool bar related */
 264
 265         , zoom_range_clock (new AudioClock (X_("zoomrange"), false, X_("ZoomRangeClock"), true, false, true))
 266
 267         , toolbar_selection_clock_table (2,3)
 268
 269         , automation_mode_button (_("mode"))
 270         , global_automation_button (_("automation"))
 271
 272         , _toolbar_viewport (*manage (new Gtk::Adjustment (0, 0, 1e10)), *manage (new Gtk::Adjustment (0, 0, 1e10)))
 273         , midi_panic_button (_("Panic"))
 274
 275 #ifdef WITH_CMT
 276         , image_socket_listener(0)
 277 #endif
 278
 279           /* nudge */
 280
 281         , nudge_clock (new AudioClock (X_("nudge"), false, X_("NudgeClock"), true, false, true))
 282         , meters_running(false)
 283         , _pending_locate_request (false)
 284         , _pending_initial_locate (false)
 285         , _last_cut_copy_source_track (0)
 286
 287         , _region_selection_change_updates_region_list (true)
 288 {
 289         constructed = false;
 290
 291         /* we are a singleton */
 292
 293         PublicEditor::_instance = this;
 294
 295         _have_idled = false;
 296
 297         selection = new Selection (this);
 298         cut_buffer = new Selection (this);
 299
 300         clicked_regionview = 0;
 301         clicked_axisview = 0;
 302         clicked_routeview = 0;
 303         clicked_crossfadeview = 0;
 304         clicked_control_point = 0;
 305         last_update_frame = 0;
 306         pre_press_cursor = 0;
 307         _drags = new DragManager (this);
 308         current_mixer_strip = 0;
 309         current_bbt_points = 0;
 310         tempo_lines = 0;
 311
 312         snap_type_strings =  I18N (_snap_type_strings);
 313         snap_mode_strings =  I18N (_snap_mode_strings);
 314         zoom_focus_strings = I18N (_zoom_focus_strings);
 315         edit_point_strings = I18N (_edit_point_strings);
 316 #ifdef USE_RUBBERBAND
 317         rb_opt_strings = I18N (_rb_opt_strings);
 318         rb_current_opt = 4;
 319 #endif
 320
 321         snap_threshold = 5.0;
 322         bbt_beat_subdivision = 4;
 323         _canvas_width = 0;
 324         _canvas_height = 0;
 325         last_autoscroll_x = 0;
 326         last_autoscroll_y = 0;
 327         autoscroll_active = false;
 328         autoscroll_timeout_tag = -1;
 329         logo_item = 0;
 330
 331         analysis_window = 0;
 332
 333         current_interthread_info = 0;
 334         _show_measures = true;
 335         show_gain_after_trim = false;
 336         last_item_entered = 0;
 337
 338         have_pending_keyboard_selection = false;
 339         _follow_playhead = true;
 340         _stationary_playhead = false;
 341         _xfade_visibility = true;
 342         editor_ruler_menu = 0;
 343         no_ruler_shown_update = false;
 344         marker_menu = 0;
 345         range_marker_menu = 0;
 346         marker_menu_item = 0;
 347         tempo_or_meter_marker_menu = 0;
 348         transport_marker_menu = 0;
 349         new_transport_marker_menu = 0;
 350         editor_mixer_strip_width = Wide;
 351         show_editor_mixer_when_tracks_arrive = false;
 352         region_edit_menu_split_multichannel_item = 0;
 353         region_edit_menu_split_item = 0;
 354         temp_location = 0;
 355         leftmost_frame = 0;
 356         current_stepping_trackview = 0;
 357         entered_track = 0;
 358         entered_regionview = 0;
 359         entered_marker = 0;
 360         clear_entered_track = false;
 361         current_timefx = 0;
 362         playhead_cursor = 0;
 363         button_release_can_deselect = true;
 364         _dragging_playhead = false;
 365         _dragging_edit_point = false;
 366         select_new_marker = false;
 367         rhythm_ferret = 0;
 368         layering_order_editor = 0;
 369         no_save_visual = false;
 370         resize_idle_id = -1;
 371
 372         scrubbing_direction = 0;
 373
 374         sfbrowser = 0;
 375
 376         location_marker_color = ARDOUR_UI::config()->canvasvar_LocationMarker.get();
 377         location_range_color = ARDOUR_UI::config()->canvasvar_LocationRange.get();
 378         location_cd_marker_color = ARDOUR_UI::config()->canvasvar_LocationCDMarker.get();
 379         location_loop_color = ARDOUR_UI::config()->canvasvar_LocationLoop.get();
 380         location_punch_color = ARDOUR_UI::config()->canvasvar_LocationPunch.get();
 381
 382         _edit_point = EditAtMouse;
 383         _internal_editing = false;
 384         current_canvas_cursor = 0;
 385
 386         frames_per_unit = 2048; /* too early to use reset_zoom () */
 387
 388         _scroll_callbacks = 0;
 389
 390         zoom_focus = ZoomFocusLeft;
 391         set_zoom_focus (ZoomFocusLeft);
 392         zoom_range_clock->ValueChanged.connect (sigc::mem_fun(*this, &Editor::zoom_adjustment_changed));
 393
 394         bbt_label.set_name ("EditorTimeButton");
 395         bbt_label.set_size_request (-1, (int)timebar_height);
 396         bbt_label.set_alignment (1.0, 0.5);
 397         bbt_label.set_padding (5,0);
 398         bbt_label.hide ();
 399         bbt_label.set_no_show_all();
 400         minsec_label.set_name ("EditorTimeButton");
 401         minsec_label.set_size_request (-1, (int)timebar_height);
 402         minsec_label.set_alignment (1.0, 0.5);
 403         minsec_label.set_padding (5,0);
 404         minsec_label.hide ();
 405         minsec_label.set_no_show_all();
 406         timecode_label.set_name ("EditorTimeButton");
 407         timecode_label.set_size_request (-1, (int)timebar_height);
 408         timecode_label.set_alignment (1.0, 0.5);
 409         timecode_label.set_padding (5,0);
 410         timecode_label.hide ();
 411         timecode_label.set_no_show_all();
 412         samples_label.set_name ("EditorTimeButton");
 413         samples_label.set_size_request (-1, (int)timebar_height);
 414         samples_label.set_alignment (1.0, 0.5);
 415         samples_label.set_padding (5,0);
 416         samples_label.hide ();
 417         samples_label.set_no_show_all();
 418
 419         tempo_label.set_name ("EditorTimeButton");
 420         tempo_label.set_size_request (-1, (int)timebar_height);
 421         tempo_label.set_alignment (1.0, 0.5);
 422         tempo_label.set_padding (5,0);
 423         tempo_label.hide();
 424         tempo_label.set_no_show_all();
 425
 426         meter_label.set_name ("EditorTimeButton");
 427         meter_label.set_size_request (-1, (int)timebar_height);
 428         meter_label.set_alignment (1.0, 0.5);
 429         meter_label.set_padding (5,0);
 430         meter_label.hide();
 431         meter_label.set_no_show_all();
 432
 433         mark_label.set_name ("EditorTimeButton");
 434         mark_label.set_size_request (-1, (int)timebar_height);
 435         mark_label.set_alignment (1.0, 0.5);
 436         mark_label.set_padding (5,0);
 437         mark_label.hide();
 438         mark_label.set_no_show_all();
 439
 440         cd_mark_label.set_name ("EditorTimeButton");
 441         cd_mark_label.set_size_request (-1, (int)timebar_height);
 442         cd_mark_label.set_alignment (1.0, 0.5);
 443         cd_mark_label.set_padding (5,0);
 444         cd_mark_label.hide();
 445         cd_mark_label.set_no_show_all();
 446
 447         range_mark_label.set_name ("EditorTimeButton");
 448         range_mark_label.set_size_request (-1, (int)timebar_height);
 449         range_mark_label.set_alignment (1.0, 0.5);
 450         range_mark_label.set_padding (5,0);
 451         range_mark_label.hide();
 452         range_mark_label.set_no_show_all();
 453
 454         transport_mark_label.set_name ("EditorTimeButton");
 455         transport_mark_label.set_size_request (-1, (int)timebar_height);
 456         transport_mark_label.set_alignment (1.0, 0.5);
 457         transport_mark_label.set_padding (5,0);
 458         transport_mark_label.hide();
 459         transport_mark_label.set_no_show_all();
 460
 461         initialize_rulers ();
 462         initialize_canvas ();
 463
 464         _summary = new EditorSummary (this);
 465
 466         selection->TimeChanged.connect (sigc::mem_fun(*this, &Editor::time_selection_changed));
 467         selection->TracksChanged.connect (sigc::mem_fun(*this, &Editor::track_selection_changed));
 468
 469         editor_regions_selection_changed_connection = selection->RegionsChanged.connect (sigc::mem_fun(*this, &Editor::region_selection_changed));
 470
 471         selection->PointsChanged.connect (sigc::mem_fun(*this, &Editor::point_selection_changed));
 472         selection->MarkersChanged.connect (sigc::mem_fun(*this, &Editor::marker_selection_changed));
 473
 474         edit_controls_vbox.set_spacing (0);
 475         vertical_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &Editor::tie_vertical_scrolling), true);
 476         track_canvas->signal_map_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_map_handler));
 477
 478         HBox* h = manage (new HBox);
 479         _group_tabs = new EditorGroupTabs (this);
 480         h->pack_start (*_group_tabs, PACK_SHRINK);
 481         h->pack_start (edit_controls_vbox);
 482         controls_layout.add (*h);
 483
 484         controls_layout.set_name ("EditControlsBase");
 485         controls_layout.add_events (Gdk::SCROLL_MASK);
 486         controls_layout.signal_scroll_event().connect (sigc::mem_fun(*this, &Editor::control_layout_scroll), false);
 487
 488         controls_layout.add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK);
 489         controls_layout.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::edit_controls_button_release));
 490
 491         _cursors = new MouseCursors;
 492
 493         ArdourCanvas::Canvas* time_pad = manage(new ArdourCanvas::Canvas());
 494         ArdourCanvas::SimpleLine* pad_line_1 = manage(new ArdourCanvas::SimpleLine(*time_pad->root(),
 495                         0.0, 1.0, 100.0, 1.0));
 496
 497         pad_line_1->property_color_rgba() = 0xFF0000FF;
 498         pad_line_1->show();
 499
 500         time_pad->show();
 501
 502         time_canvas_vbox.set_size_request (-1, (int)(timebar_height * visible_timebars) + 2);
 503         time_canvas_vbox.set_size_request (-1, -1);
 504
 505         ruler_label_event_box.add (ruler_label_vbox);
 506         ruler_label_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 507         ruler_label_event_box.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_label_button_release));
 508
 509         time_button_event_box.add (time_button_vbox);
 510         time_button_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 511         time_button_event_box.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_label_button_release));
 512
 513         /* these enable us to have a dedicated window (for cursor setting, etc.)
 514            for the canvas areas.
 515         */
 516
 517         track_canvas_event_box.add (*track_canvas);
 518
 519         time_canvas_event_box.add (time_canvas_vbox);
 520         time_canvas_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::POINTER_MOTION_MASK);
 521
 522         edit_packer.set_col_spacings (0);
 523         edit_packer.set_row_spacings (0);
 524         edit_packer.set_homogeneous (false);
 525         edit_packer.set_border_width (0);
 526         edit_packer.set_name ("EditorWindow");
 527
 528         /* labels for the rulers */
 529         edit_packer.attach (ruler_label_event_box,   1, 2, 0, 1,    FILL,        SHRINK, 0, 0);
 530         /* labels for the marker "tracks" */
 531         edit_packer.attach (time_button_event_box,   1, 2, 1, 2,    FILL,        SHRINK, 0, 0);
 532         /* the rulers */
 533         edit_packer.attach (time_canvas_event_box,   2, 3, 0, 1,    FILL|EXPAND, FILL, 0, 0);
 534         /* track controls */
 535         edit_packer.attach (controls_layout,         0, 2, 2, 3,    FILL,        FILL|EXPAND, 0, 0);
 536         /* main canvas */
 537         edit_packer.attach (track_canvas_event_box,  2, 3, 1, 3,    FILL|EXPAND, FILL|EXPAND, 0, 0);
 538
 539         bottom_hbox.set_border_width (2);
 540         bottom_hbox.set_spacing (3);
 541
 542         _route_groups = new EditorRouteGroups (this);
 543         _routes = new EditorRoutes (this);
 544         _regions = new EditorRegions (this);
 545         _snapshots = new EditorSnapshots (this);
 546         _locations = new EditorLocations (this);
 547
 548         add_notebook_page (_("Regions"), _regions->widget ());
 549         add_notebook_page (_("Tracks & Busses"), _routes->widget ());
 550         add_notebook_page (_("Snapshots"), _snapshots->widget ());
 551         add_notebook_page (_("Route Groups"), _route_groups->widget ());
 552         add_notebook_page (_("Ranges & Marks"), _locations->widget ());
 553
 554         _the_notebook.set_show_tabs (true);
 555         _the_notebook.set_scrollable (true);
 556         _the_notebook.popup_disable ();
 557         _the_notebook.set_tab_pos (Gtk::POS_RIGHT);
 558         _the_notebook.show_all ();
 559
 560         post_maximal_editor_width = 0;
 561         post_maximal_horizontal_pane_position = 0;
 562         post_maximal_editor_height = 0;
 563         post_maximal_vertical_pane_position = 0;
 564         _notebook_shrunk = false;
 565
 566         editor_summary_pane.pack1(edit_packer);
 567
 568         Button* summary_arrows_left_left = manage (new Button);
 569         summary_arrows_left_left->add (*manage (new Arrow (ARROW_LEFT, SHADOW_NONE)));
 570         summary_arrows_left_left->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), LEFT)));
 571         summary_arrows_left_left->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 572
 573         Button* summary_arrows_left_right = manage (new Button);
 574         summary_arrows_left_right->add (*manage (new Arrow (ARROW_RIGHT, SHADOW_NONE)));
 575         summary_arrows_left_right->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), RIGHT)));
 576         summary_arrows_left_right->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 577
 578         VBox* summary_arrows_left = manage (new VBox);
 579         summary_arrows_left->pack_start (*summary_arrows_left_left);
 580         summary_arrows_left->pack_start (*summary_arrows_left_right);
 581
 582         Button* summary_arrows_right_up = manage (new Button);
 583         summary_arrows_right_up->add (*manage (new Arrow (ARROW_UP, SHADOW_NONE)));
 584         summary_arrows_right_up->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), UP)));
 585         summary_arrows_right_up->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 586
 587         Button* summary_arrows_right_down = manage (new Button);
 588         summary_arrows_right_down->add (*manage (new Arrow (ARROW_DOWN, SHADOW_NONE)));
 589         summary_arrows_right_down->signal_pressed().connect (sigc::hide_return (sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), DOWN)));
 590         summary_arrows_right_down->signal_released().connect (sigc::mem_fun (*this, &Editor::scroll_release));
 591
 592         VBox* summary_arrows_right = manage (new VBox);
 593         summary_arrows_right->pack_start (*summary_arrows_right_up);
 594         summary_arrows_right->pack_start (*summary_arrows_right_down);
 595
 596         Frame* summary_frame = manage (new Frame);
 597         summary_frame->set_shadow_type (Gtk::SHADOW_ETCHED_IN);
 598
 599         summary_frame->add (*_summary);
 600         summary_frame->show ();
 601
 602         _summary_hbox.pack_start (*summary_arrows_left, false, false);
 603         _summary_hbox.pack_start (*summary_frame, true, true);
 604         _summary_hbox.pack_start (*summary_arrows_right, false, false);
 605
 606         editor_summary_pane.pack2 (_summary_hbox);
 607
 608         edit_pane.pack1 (editor_summary_pane, true, true);
 609         edit_pane.pack2 (_the_notebook, false, true);
 610
 611         editor_summary_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun (*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&editor_summary_pane)));
 612
 613         /* XXX: editor_summary_pane might need similar special OS X treatment to the edit_pane */
 614
 615         edit_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
 616 #ifdef GTKOSX
 617         Glib::PropertyProxy<int> proxy = edit_pane.property_position();
 618         proxy.signal_changed().connect (bind (sigc::ptr_fun (pane_size_watcher), static_cast<Paned*> (&edit_pane)));
 619 #endif
 620         top_hbox.pack_start (toolbar_frame);
 621
 622         HBox *hbox = manage (new HBox);
 623         hbox->pack_start (edit_pane, true, true);
 624
 625         global_vpacker.pack_start (top_hbox, false, false);
 626         global_vpacker.pack_start (*hbox, true, true);
 627
 628         global_hpacker.pack_start (global_vpacker, true, true);
 629
 630         set_name ("EditorWindow");
 631         add_accel_group (ActionManager::ui_manager->get_accel_group());
 632
 633         status_bar_hpacker.show ();
 634
 635         vpacker.pack_end (status_bar_hpacker, false, false);
 636         vpacker.pack_end (global_hpacker, true, true);
 637
 638         /* register actions now so that set_state() can find them and set toggles/checks etc */
 639
 640         register_actions ();
 641
 642         setup_toolbar ();
 643         setup_midi_toolbar ();
 644
 645         _snap_type = SnapToBeat;
 646         set_snap_to (_snap_type);
 647         _snap_mode = SnapOff;
 648         set_snap_mode (_snap_mode);
 649         set_mouse_mode (MouseObject, true);
 650         pre_internal_mouse_mode = MouseObject;
 651         set_edit_point_preference (EditAtMouse, true);
 652
 653         _playlist_selector = new PlaylistSelector();
 654         _playlist_selector->signal_delete_event().connect (sigc::bind (sigc::ptr_fun (just_hide_it), static_cast<Window *> (_playlist_selector)));
 655
 656         RegionView::RegionViewGoingAway.connect (*this, invalidator (*this),  ui_bind (&Editor::catch_vanishing_regionview, this, _1), gui_context());
 657
 658         /* nudge stuff */
 659
 660         nudge_forward_button.add (*(manage (new Image (::get_icon("nudge_right")))));
 661         nudge_backward_button.add (*(manage (new Image (::get_icon("nudge_left")))));
 662
 663         nudge_forward_button.set_name ("TransportButton");
 664         nudge_backward_button.set_name ("TransportButton");
 665
 666         fade_context_menu.set_name ("ArdourContextMenu");
 667
 668         /* icons, titles, WM stuff */
 669
 670         list<Glib::RefPtr<Gdk::Pixbuf> > window_icons;
 671         Glib::RefPtr<Gdk::Pixbuf> icon;
 672
 673         if ((icon = ::get_icon ("ardour_icon_16px")) != 0) {
 674                 window_icons.push_back (icon);
 675         }
 676         if ((icon = ::get_icon ("ardour_icon_22px")) != 0) {
 677                 window_icons.push_back (icon);
 678         }
 679         if ((icon = ::get_icon ("ardour_icon_32px")) != 0) {
 680                 window_icons.push_back (icon);
 681         }
 682         if ((icon = ::get_icon ("ardour_icon_48px")) != 0) {
 683                 window_icons.push_back (icon);
 684         }
 685         if (!window_icons.empty()) {
 686                 // set_icon_list (window_icons);
 687                 set_default_icon_list (window_icons);
 688         }
 689
 690         WindowTitle title(Glib::get_application_name());
 691         title += _("Editor");
 692         set_title (title.get_string());
 693         set_wmclass (X_("ardour_editor"), PROGRAM_NAME);
 694
 695         add (vpacker);
 696         add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
 697
 698         signal_configure_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::configure_handler));
 699         signal_delete_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::exit_on_main_window_close));
 700
 701         /* allow external control surfaces/protocols to do various things */
 702
 703         ControlProtocol::ZoomToSession.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_session, this), gui_context());
 704         ControlProtocol::ZoomIn.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_step, this, false), gui_context());
 705         ControlProtocol::ZoomOut.connect (*this, invalidator (*this), boost::bind (&Editor::temporal_zoom_step, this, true), gui_context());
 706         ControlProtocol::ScrollTimeline.connect (*this, invalidator (*this), ui_bind (&Editor::control_scroll, this, _1), gui_context());
 707         ControlProtocol::SelectByRID.connect (*this, invalidator (*this), ui_bind (&Editor::control_select, this, _1), gui_context());
 708         BasicUI::AccessAction.connect (*this, invalidator (*this), ui_bind (&Editor::access_action, this, _1, _2), gui_context());
 709
 710         /* problematic: has to return a value and thus cannot be x-thread */
 711
 712         Session::AskAboutPlaylistDeletion.connect_same_thread (*this, boost::bind (&Editor::playlist_deletion_dialog, this, _1));
 713
 714         Config->ParameterChanged.connect (*this, invalidator (*this), ui_bind (&Editor::parameter_changed, this, _1), gui_context());
 715
 716         TimeAxisView::CatchDeletion.connect (*this, invalidator (*this), ui_bind (&Editor::timeaxisview_deleted, this, _1), gui_context());
 717
 718         _ignore_region_action = false;
 719         _last_region_menu_was_main = false;
 720         _popup_region_menu_item = 0;
 721
 722         _show_marker_lines = false;
 723         _over_region_trim_target = false;
 724
 725         /* Button bindings */
 726
 727         button_bindings = new Bindings;
 728
 729         XMLNode* node = button_settings();
 730         if (node) {
 731                 for (XMLNodeList::const_iterator i = node->children().begin(); i != node->children().end(); ++i) {
 732                         button_bindings->load (**i);
 733                 }
 734         }
 735
 736         constructed = true;
 737         instant_save ();
 738
 739         setup_fade_images ();
 740 }
 741
 742 Editor::~Editor()
 743 {
 744 #ifdef WITH_CMT
 745         if(image_socket_listener) {
 746                 if(image_socket_listener->is_connected())
 747                 {
 748                         image_socket_listener->close_connection() ;
 749                 }
 750
 751                 delete image_socket_listener ;
 752                 image_socket_listener = 0 ;
 753         }
 754 #endif
 755
 756         delete button_bindings;
 757         delete _routes;
 758         delete _route_groups;
 759         delete track_canvas;
 760         delete _drags;
 761 }
 762
 763 XMLNode*
 764 Editor::button_settings () const
 765 {
 766         XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
 767         XMLNode* node = find_named_node (*settings, X_("Buttons"));
 768
 769         if (!node) {
 770                 cerr << "new empty Button node\n";
 771                 node = new XMLNode (X_("Buttons"));
 772         }
 773
 774         return node;
 775 }
 776
 777 void
 778 Editor::add_toplevel_controls (Container& cont)
 779 {
 780         vpacker.pack_start (cont, false, false);
 781         cont.show_all ();
 782 }
 783
 784 void
 785 Editor::catch_vanishing_regionview (RegionView *rv)
 786 {
 787         /* note: the selection will take care of the vanishing
 788            audioregionview by itself.
 789         */
 790
 791         if (_drags->active() && _drags->have_item (rv->get_canvas_group()) && !_drags->ending()) {
 792                 _drags->abort ();
 793         }
 794
 795         if (clicked_regionview == rv) {
 796                 clicked_regionview = 0;
 797         }
 798
 799         if (entered_regionview == rv) {
 800                 set_entered_regionview (0);
 801         }
 802
 803         if (!_all_region_actions_sensitized) {
 804                 sensitize_all_region_actions (true);
 805         }
 806
 807         _over_region_trim_target = false;
 808 }
 809
 810 void
 811 Editor::set_entered_regionview (RegionView* rv)
 812 {
 813         if (rv == entered_regionview) {
 814                 return;
 815         }
 816
 817         if (entered_regionview) {
 818                 entered_regionview->exited ();
 819         }
 820
 821         if ((entered_regionview = rv) != 0) {
 822                 entered_regionview->entered (internal_editing ());
 823         }
 824
 825         if (!_all_region_actions_sensitized && _last_region_menu_was_main) {
 826                 /* This RegionView entry might have changed what region actions
 827                    are allowed, so sensitize them all in case a key is pressed.
 828                 */
 829                 sensitize_all_region_actions (true);
 830         }
 831 }
 832
 833 void
 834 Editor::set_entered_track (TimeAxisView* tav)
 835 {
 836         if (entered_track) {
 837                 entered_track->exited ();
 838         }
 839
 840         if ((entered_track = tav) != 0) {
 841                 entered_track->entered ();
 842         }
 843 }
 844
 845 void
 846 Editor::show_window ()
 847 {
 848         if (!is_visible ()) {
 849                 show_all ();
 850
 851                 /* XXX: this is a bit unfortunate; it would probably
 852                    be nicer if we could just call show () above rather
 853                    than needing the show_all ()
 854                 */
 855
 856                 /* re-hide stuff if necessary */
 857                 editor_list_button_toggled ();
 858                 parameter_changed ("show-summary");
 859                 parameter_changed ("show-group-tabs");
 860                 parameter_changed ("show-zoom-tools");
 861
 862                 /* now reset all audio_time_axis heights, because widgets might need
 863                    to be re-hidden
 864                 */
 865
 866                 TimeAxisView *tv;
 867
 868                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 869                         tv = (static_cast<TimeAxisView*>(*i));
 870                         tv->reset_height ();
 871                 }
 872
 873                 if (current_mixer_strip) {
 874                         current_mixer_strip->hide_things ();
 875                 }
 876         }
 877
 878         present ();
 879 }
 880
 881 void
 882 Editor::instant_save ()
 883 {
 884         if (!constructed || !ARDOUR_UI::instance()->session_loaded) {
 885                 return;
 886         }
 887
 888         if (_session) {
 889                 _session->add_instant_xml(get_state());
 890         } else {
 891                 Config->add_instant_xml(get_state());
 892         }
 893 }
 894
 895 void
 896 Editor::zoom_adjustment_changed ()
 897 {
 898         if (_session == 0) {
 899                 return;
 900         }
 901
 902         double fpu = zoom_range_clock->current_duration() / _canvas_width;
 903
 904         if (fpu < 1.0) {
 905                 fpu = 1.0;
 906                 zoom_range_clock->set ((framepos_t) floor (fpu * _canvas_width));
 907         } else if (fpu > _session->current_end_frame() / _canvas_width) {
 908                 fpu = _session->current_end_frame() / _canvas_width;
 909                 zoom_range_clock->set ((framepos_t) floor (fpu * _canvas_width));
 910         }
 911
 912         temporal_zoom (fpu);
 913 }
 914
 915 void
 916 Editor::control_select (uint32_t rid)
 917 {
 918         /* handles the (static) signal from the ControlProtocol class that
 919          * requests setting the selected track to a given RID
 920          */
 921
 922         if (!_session) {
 923                 return;
 924         }
 925
 926         boost::shared_ptr<Route> r = _session->route_by_remote_id (rid);
 927
 928         if (!r) {
 929                 return;
 930         }
 931
 932         TimeAxisView* tav = axis_view_from_route (r);
 933
 934         if (tav) {
 935                 selection->set (tav);
 936         } else {
 937                 selection->clear_tracks ();
 938         }
 939 }
 940
 941 void
 942 Editor::control_scroll (float fraction)
 943 {
 944         ENSURE_GUI_THREAD (*this, &Editor::control_scroll, fraction)
 945
 946         if (!_session) {
 947                 return;
 948         }
 949
 950         double step = fraction * current_page_frames();
 951
 952         /*
 953                 _control_scroll_target is an optional<T>
 954
 955                 it acts like a pointer to an framepos_t, with
 956                 a operator conversion to boolean to check
 957                 that it has a value could possibly use
 958                 playhead_cursor->current_frame to store the
 959                 value and a boolean in the class to know
 960                 when it's out of date
 961         */
 962
 963         if (!_control_scroll_target) {
 964                 _control_scroll_target = _session->transport_frame();
 965                 _dragging_playhead = true;
 966         }
 967
 968         if ((fraction < 0.0f) && (*_control_scroll_target < (framepos_t) fabs(step))) {
 969                 *_control_scroll_target = 0;
 970         } else if ((fraction > 0.0f) && (max_framepos - *_control_scroll_target < step)) {
 971                 *_control_scroll_target = max_framepos - (current_page_frames()*2); // allow room for slop in where the PH is on the screen
 972         } else {
 973                 *_control_scroll_target += (framepos_t) floor (step);
 974         }
 975
 976         /* move visuals, we'll catch up with it later */
 977
 978         playhead_cursor->set_position (*_control_scroll_target);
 979         UpdateAllTransportClocks (*_control_scroll_target);
 980
 981         if (*_control_scroll_target > (current_page_frames() / 2)) {
 982                 /* try to center PH in window */
 983                 reset_x_origin (*_control_scroll_target - (current_page_frames()/2));
 984         } else {
 985                 reset_x_origin (0);
 986         }
 987
 988         /*
 989                 Now we do a timeout to actually bring the session to the right place
 990                 according to the playhead. This is to avoid reading disk buffers on every
 991                 call to control_scroll, which is driven by ScrollTimeline and therefore
 992                 probably by a control surface wheel which can generate lots of events.
 993         */
 994         /* cancel the existing timeout */
 995
 996         control_scroll_connection.disconnect ();
 997
 998         /* add the next timeout */
 999
1000         control_scroll_connection = Glib::signal_timeout().connect (sigc::bind (sigc::mem_fun (*this, &Editor::deferred_control_scroll), *_control_scroll_target), 250);
1001 }
1002
1003 bool
1004 Editor::deferred_control_scroll (framepos_t /*target*/)
1005 {
1006         _session->request_locate (*_control_scroll_target, _session->transport_rolling());
1007         // reset for next stream
1008         _control_scroll_target = boost::none;
1009         _dragging_playhead = false;
1010         return false;
1011 }
1012
1013 void
1014 Editor::access_action (std::string action_group, std::string action_item)
1015 {
1016         if (!_session) {
1017                 return;
1018         }
1019
1020         ENSURE_GUI_THREAD (*this, &Editor::access_action, action_group, action_item)
1021
1022         RefPtr<Action> act;
1023         act = ActionManager::get_action( action_group.c_str(), action_item.c_str() );
1024
1025         if (act) {
1026                 act->activate();
1027         }
1028 }
1029
1030 void
1031 Editor::on_realize ()
1032 {
1033         Window::on_realize ();
1034         Realized ();
1035 }
1036
1037 void
1038 Editor::map_position_change (framepos_t frame)
1039 {
1040         ENSURE_GUI_THREAD (*this, &Editor::map_position_change, frame)
1041
1042         if (_session == 0) {
1043                 return;
1044         }
1045
1046         if (_follow_playhead) {
1047                 center_screen (frame);
1048         }
1049
1050         playhead_cursor->set_position (frame);
1051 }
1052
1053 void
1054 Editor::center_screen (framepos_t frame)
1055 {
1056         double page = _canvas_width * frames_per_unit;
1057
1058         /* if we're off the page, then scroll.
1059          */
1060
1061         if (frame < leftmost_frame || frame >= leftmost_frame + page) {
1062                 center_screen_internal (frame, page);
1063         }
1064 }
1065
1066 void
1067 Editor::center_screen_internal (framepos_t frame, float page)
1068 {
1069         page /= 2;
1070
1071         if (frame > page) {
1072                 frame -= (framepos_t) page;
1073         } else {
1074                 frame = 0;
1075         }
1076
1077         reset_x_origin (frame);
1078 }
1079
1080
1081 void
1082 Editor::update_title ()
1083 {
1084         ENSURE_GUI_THREAD (*this, &Editor::update_title)
1085
1086         if (_session) {
1087                 bool dirty = _session->dirty();
1088
1089                 string session_name;
1090
1091                 if (_session->snap_name() != _session->name()) {
1092                         session_name = _session->snap_name();
1093                 } else {
1094                         session_name = _session->name();
1095                 }
1096
1097                 if (dirty) {
1098                         session_name = "*" + session_name;
1099                 }
1100
1101                 WindowTitle title(session_name);
1102                 title += Glib::get_application_name();
1103                 set_title (title.get_string());
1104         }
1105 }
1106
1107 void
1108 Editor::set_session (Session *t)
1109 {
1110         SessionHandlePtr::set_session (t);
1111
1112         if (!_session) {
1113                 return;
1114         }
1115
1116         zoom_range_clock->set_session (_session);
1117         _playlist_selector->set_session (_session);
1118         nudge_clock->set_session (_session);
1119         _summary->set_session (_session);
1120         _group_tabs->set_session (_session);
1121         _route_groups->set_session (_session);
1122         _regions->set_session (_session);
1123         _snapshots->set_session (_session);
1124         _routes->set_session (_session);
1125         _locations->set_session (_session);
1126
1127         if (rhythm_ferret) {
1128                 rhythm_ferret->set_session (_session);
1129         }
1130
1131         if (analysis_window) {
1132                 analysis_window->set_session (_session);
1133         }
1134
1135         if (sfbrowser) {
1136                 sfbrowser->set_session (_session);
1137         }
1138
1139         compute_fixed_ruler_scale ();
1140
1141         XMLNode* node = ARDOUR_UI::instance()->editor_settings();
1142         set_state (*node, Stateful::loading_state_version);
1143
1144         /* catch up with the playhead */
1145
1146         _session->request_locate (playhead_cursor->current_frame);
1147         _pending_initial_locate = true;
1148
1149         update_title ();
1150
1151         /* These signals can all be emitted by a non-GUI thread. Therefore the
1152            handlers for them must not attempt to directly interact with the GUI,
1153            but use Gtkmm2ext::UI::instance()->call_slot();
1154         */
1155
1156         _session->StepEditStatusChange.connect (_session_connections, invalidator (*this), ui_bind(&Editor::step_edit_status_change, this, _1), gui_context());
1157         _session->TransportStateChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_transport_state, this), gui_context());
1158         _session->PositionChanged.connect (_session_connections, invalidator (*this), ui_bind (&Editor::map_position_change, this, _1), gui_context());
1159         _session->RouteAdded.connect (_session_connections, invalidator (*this), ui_bind (&Editor::handle_new_route, this, _1), gui_context());
1160         _session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::update_title, this), gui_context());
1161         _session->tempo_map().PropertyChanged.connect (_session_connections, invalidator (*this), ui_bind (&Editor::tempo_map_changed, this, _1), gui_context());
1162         _session->Located.connect (_session_connections, invalidator (*this), boost::bind (&Editor::located, this), gui_context());
1163         _session->config.ParameterChanged.connect (_session_connections, invalidator (*this), ui_bind (&Editor::parameter_changed, this, _1), gui_context());
1164         _session->StateSaved.connect (_session_connections, invalidator (*this), ui_bind (&Editor::session_state_saved, this, _1), gui_context());
1165         _session->locations()->added.connect (_session_connections, invalidator (*this), ui_bind (&Editor::add_new_location, this, _1), gui_context());
1166         _session->locations()->removed.connect (_session_connections, invalidator (*this), ui_bind (&Editor::location_gone, this, _1), gui_context());
1167         _session->locations()->changed.connect (_session_connections, invalidator (*this), boost::bind (&Editor::refresh_location_display, this), gui_context());
1168         _session->locations()->StateChanged.connect (_session_connections, invalidator (*this), ui_bind (&Editor::refresh_location_display, this), gui_context());
1169         _session->history().Changed.connect (_session_connections, invalidator (*this), boost::bind (&Editor::history_changed, this), gui_context());
1170
1171         if (Profile->get_sae()) {
1172                 Timecode::BBT_Time bbt;
1173                 bbt.bars = 0;
1174                 bbt.beats = 0;
1175                 bbt.ticks = 120;
1176                 framepos_t pos = _session->tempo_map().bbt_duration_at (0, bbt, 1);
1177                 nudge_clock->set_mode(AudioClock::BBT);
1178                 nudge_clock->set (pos, true, 0, AudioClock::BBT);
1179
1180         } else {
1181                 nudge_clock->set (_session->frame_rate() * 5, true, 0, AudioClock::Timecode); // default of 5 seconds
1182         }
1183
1184         playhead_cursor->canvas_item.show ();
1185
1186         Location* loc = _session->locations()->auto_loop_location();
1187         if (loc == 0) {
1188                 loc = new Location (*_session, 0, _session->current_end_frame(), _("Loop"),(Location::Flags) (Location::IsAutoLoop | Location::IsHidden));
1189
1190                 if (loc->start() == loc->end()) {
1191                         loc->set_end (loc->start() + 1);
1192                 }
1193
1194                 _session->locations()->add (loc, false);
1195                 _session->set_auto_loop_location (loc);
1196         } else {
1197                 // force name
1198                 loc->set_name (_("Loop"));
1199         }
1200
1201         loc = _session->locations()->auto_punch_location();
1202
1203         if (loc == 0) {
1204                 loc = new Location (*_session, 0, _session->current_end_frame(), _("Punch"), (Location::Flags) (Location::IsAutoPunch | Location::IsHidden));
1205
1206                 if (loc->start() == loc->end()) {
1207                         loc->set_end (loc->start() + 1);
1208                 }
1209
1210                 _session->locations()->add (loc, false);
1211                 _session->set_auto_punch_location (loc);
1212         } else {
1213                 // force name
1214                 loc->set_name (_("Punch"));
1215         }
1216
1217         boost::function<void (string)> pc (boost::bind (&Editor::parameter_changed, this, _1));
1218         Config->map_parameters (pc);
1219         _session->config.map_parameters (pc);
1220
1221         refresh_location_display ();
1222
1223         restore_ruler_visibility ();
1224         //tempo_map_changed (PropertyChange (0));
1225         _session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks);
1226
1227         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
1228                 (static_cast<TimeAxisView*>(*i))->set_samples_per_unit (frames_per_unit);
1229         }
1230
1231         super_rapid_screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (
1232                 sigc::mem_fun (*this, &Editor::super_rapid_screen_update)
1233                 );
1234
1235         switch (_snap_type) {
1236         case SnapToRegionStart:
1237         case SnapToRegionEnd:
1238         case SnapToRegionSync:
1239         case SnapToRegionBoundary:
1240                 build_region_boundary_cache ();
1241                 break;
1242
1243         default:
1244                 break;
1245         }
1246
1247         /* register for undo history */
1248         _session->register_with_memento_command_factory(_id, this);
1249
1250         ActionManager::ui_manager->signal_pre_activate().connect (sigc::mem_fun (*this, &Editor::action_pre_activated));
1251
1252         start_updating_meters ();
1253 }
1254
1255 void
1256 Editor::action_pre_activated (Glib::RefPtr<Action> const & a)
1257 {
1258         if (a->get_name() == "RegionMenu") {
1259                 /* When the main menu's region menu is opened, we setup the actions so that they look right
1260                    in the menu.  I can't find a way of getting a signal when this menu is subsequently closed,
1261                    so we resensitize all region actions when the entered regionview or the region selection
1262                    changes.  HOWEVER we can't always resensitize on entered_regionview change because that
1263                    happens after the region context menu is opened.  So we set a flag here, too.
1264
1265                    What a carry on :(
1266                 */
1267                 sensitize_the_right_region_actions ();
1268                 _last_region_menu_was_main = true;
1269         }
1270 }
1271
1272 /** Pop up a context menu for when the user clicks on a fade in or fade out */
1273 void
1274 Editor::popup_fade_context_menu (int button, int32_t time, ArdourCanvas::Item* item, ItemType item_type)
1275 {
1276         using namespace Menu_Helpers;
1277         AudioRegionView* arv = static_cast<AudioRegionView*> (item->get_data ("regionview"));
1278
1279         if (arv == 0) {
1280                 fatal << _("programming error: fade in canvas item has no regionview data pointer!") << endmsg;
1281                 /*NOTREACHED*/
1282         }
1283
1284         MenuList& items (fade_context_menu.items());
1285
1286         items.clear ();
1287
1288         switch (item_type) {
1289         case FadeInItem:
1290         case FadeInHandleItem:
1291                 if (arv->audio_region()->fade_in_active()) {
1292                         items.push_back (MenuElem (_("Deactivate"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_active), false)));
1293                 } else {
1294                         items.push_back (MenuElem (_("Activate"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_active), true)));
1295                 }
1296
1297                 items.push_back (SeparatorElem());
1298
1299                 if (Profile->get_sae()) {
1300
1301                         items.push_back (MenuElem (_("Linear"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_shape), FadeLinear)));
1302                         items.push_back (MenuElem (_("Slowest"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_shape), FadeFast)));
1303
1304                 } else {
1305
1306                         items.push_back (
1307                                 ImageMenuElem (
1308                                         _("Linear"),
1309                                         *_fade_in_images[FadeLinear],
1310                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_shape), FadeLinear)
1311                                         )
1312                                 );
1313
1314                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1315
1316                         items.push_back (
1317                                 ImageMenuElem (
1318                                         _("Slowest"),
1319                                         *_fade_in_images[FadeFast],
1320                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_shape), FadeFast)
1321                                         ));
1322
1323                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1324
1325                         items.push_back (
1326                                 ImageMenuElem (
1327                                         _("Slow"),
1328                                         *_fade_in_images[FadeLogB],
1329                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_shape), FadeLogB)
1330                                         ));
1331
1332                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1333
1334                         items.push_back (
1335                                 ImageMenuElem (
1336                                         _("Fast"),
1337                                         *_fade_in_images[FadeLogA],
1338                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_shape), FadeLogA)
1339                                         ));
1340
1341                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1342
1343                         items.push_back (
1344                                 ImageMenuElem (
1345                                         _("Fastest"),
1346                                         *_fade_in_images[FadeSlow],
1347                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_shape), FadeSlow)
1348                                         ));
1349
1350                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1351                 }
1352
1353                 break;
1354
1355         case FadeOutItem:
1356         case FadeOutHandleItem:
1357                 if (arv->audio_region()->fade_out_active()) {
1358                         items.push_back (MenuElem (_("Deactivate"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_active), false)));
1359                 } else {
1360                         items.push_back (MenuElem (_("Activate"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_active), true)));
1361                 }
1362
1363                 items.push_back (SeparatorElem());
1364
1365                 if (Profile->get_sae()) {
1366                         items.push_back (MenuElem (_("Linear"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_shape), FadeLinear)));
1367                         items.push_back (MenuElem (_("Slowest"), sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_shape), FadeSlow)));
1368                 } else {
1369
1370                         items.push_back (
1371                                 ImageMenuElem (
1372                                         _("Linear"),
1373                                         *_fade_out_images[FadeLinear],
1374                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_shape), FadeLinear)
1375                                         )
1376                                 );
1377
1378                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1379
1380                         items.push_back (
1381                                 ImageMenuElem (
1382                                         _("Slowest"),
1383                                         *_fade_out_images[FadeFast],
1384                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_shape), FadeSlow)
1385                                         ));
1386
1387                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1388
1389                         items.push_back (
1390                                 ImageMenuElem (
1391                                         _("Slow"),
1392                                         *_fade_out_images[FadeLogB],
1393                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_shape), FadeLogA)
1394                                         ));
1395
1396                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1397
1398                         items.push_back (
1399                                 ImageMenuElem (
1400                                         _("Fast"),
1401                                         *_fade_out_images[FadeLogA],
1402                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_shape), FadeLogB)
1403                                         ));
1404
1405                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1406
1407                         items.push_back (
1408                                 ImageMenuElem (
1409                                         _("Fastest"),
1410                                         *_fade_out_images[FadeSlow],
1411                                         sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_shape), FadeFast)
1412                                         ));
1413
1414                         dynamic_cast<ImageMenuItem*>(&items.back())->set_always_show_image ();
1415                 }
1416
1417                 break;
1418
1419         default:
1420                 fatal << _("programming error: ")
1421                       << X_("non-fade canvas item passed to popup_fade_context_menu()")
1422                       << endmsg;
1423                 /*NOTREACHED*/
1424         }
1425
1426         fade_context_menu.popup (button, time);
1427 }
1428
1429 void
1430 Editor::popup_track_context_menu (int button, int32_t time, ItemType item_type, bool with_selection)
1431 {
1432         using namespace Menu_Helpers;
1433         Menu* (Editor::*build_menu_function)();
1434         Menu *menu;
1435
1436         switch (item_type) {
1437         case RegionItem:
1438         case RegionViewName:
1439         case RegionViewNameHighlight:
1440         case LeftFrameHandle:
1441         case RightFrameHandle:
1442                 if (with_selection) {
1443                         build_menu_function = &Editor::build_track_selection_context_menu;
1444                 } else {
1445                         build_menu_function = &Editor::build_track_region_context_menu;
1446                 }
1447                 break;
1448
1449         case SelectionItem:
1450                 if (with_selection) {
1451                         build_menu_function = &Editor::build_track_selection_context_menu;
1452                 } else {
1453                         build_menu_function = &Editor::build_track_context_menu;
1454                 }
1455                 break;
1456
1457         case CrossfadeViewItem:
1458                 build_menu_function = &Editor::build_track_crossfade_context_menu;
1459                 break;
1460
1461         case StreamItem:
1462                 if (clicked_routeview->track()) {
1463                         build_menu_function = &Editor::build_track_context_menu;
1464                 } else {
1465                         build_menu_function = &Editor::build_track_bus_context_menu;
1466                 }
1467                 break;
1468
1469         default:
1470                 /* probably shouldn't happen but if it does, we don't care */
1471                 return;
1472         }
1473
1474         menu = (this->*build_menu_function)();
1475         menu->set_name ("ArdourContextMenu");
1476
1477         /* now handle specific situations */
1478
1479         switch (item_type) {
1480         case RegionItem:
1481         case RegionViewName:
1482         case RegionViewNameHighlight:
1483         case LeftFrameHandle:
1484         case RightFrameHandle:
1485                 if (!with_selection) {
1486                         if (region_edit_menu_split_item) {
1487                                 if (clicked_regionview && clicked_regionview->region()->covers (get_preferred_edit_position())) {
1488                                         ActionManager::set_sensitive (ActionManager::edit_point_in_region_sensitive_actions, true);
1489                                 } else {
1490                                         ActionManager::set_sensitive (ActionManager::edit_point_in_region_sensitive_actions, false);
1491                                 }
1492                         }
1493                         if (region_edit_menu_split_multichannel_item) {
1494                                 if (clicked_regionview && clicked_regionview->region()->n_channels() > 1) {
1495                                         region_edit_menu_split_multichannel_item->set_sensitive (true);
1496                                 } else {
1497                                         region_edit_menu_split_multichannel_item->set_sensitive (false);
1498                                 }
1499                         }
1500                 }
1501                 break;
1502
1503         case SelectionItem:
1504                 break;
1505
1506         case CrossfadeViewItem:
1507                 break;
1508
1509         case StreamItem:
1510                 break;
1511
1512         default:
1513                 /* probably shouldn't happen but if it does, we don't care */
1514                 return;
1515         }
1516
1517         if (item_type != SelectionItem && clicked_routeview && clicked_routeview->audio_track()) {
1518
1519                 /* Bounce to disk */
1520
1521                 using namespace Menu_Helpers;
1522                 MenuList& edit_items  = menu->items();
1523
1524                 edit_items.push_back (SeparatorElem());
1525
1526                 switch (clicked_routeview->audio_track()->freeze_state()) {
1527                 case AudioTrack::NoFreeze:
1528                         edit_items.push_back (MenuElem (_("Freeze"), sigc::mem_fun(*this, &Editor::freeze_route)));
1529                         break;
1530
1531                 case AudioTrack::Frozen:
1532                         edit_items.push_back (MenuElem (_("Unfreeze"), sigc::mem_fun(*this, &Editor::unfreeze_route)));
1533                         break;
1534
1535                 case AudioTrack::UnFrozen:
1536                         edit_items.push_back (MenuElem (_("Freeze"), sigc::mem_fun(*this, &Editor::freeze_route)));
1537                         break;
1538                 }
1539
1540         }
1541
1542         if (item_type == StreamItem && clicked_routeview) {
1543                 clicked_routeview->build_underlay_menu(menu);
1544         }
1545
1546         /* When the region menu is opened, we setup the actions so that they look right
1547            in the menu.
1548         */
1549         sensitize_the_right_region_actions ();
1550         _last_region_menu_was_main = false;
1551
1552         menu->signal_hide().connect (sigc::bind (sigc::mem_fun (*this, &Editor::sensitize_all_region_actions), true));
1553         menu->popup (button, time);
1554 }
1555
1556 Menu*
1557 Editor::build_track_context_menu ()
1558 {
1559         using namespace Menu_Helpers;
1560
1561         MenuList& edit_items = track_context_menu.items();
1562         edit_items.clear();
1563
1564         add_dstream_context_items (edit_items);
1565         return &track_context_menu;
1566 }
1567
1568 Menu*
1569 Editor::build_track_bus_context_menu ()
1570 {
1571         using namespace Menu_Helpers;
1572
1573         MenuList& edit_items = track_context_menu.items();
1574         edit_items.clear();
1575
1576         add_bus_context_items (edit_items);
1577         return &track_context_menu;
1578 }
1579
1580 Menu*
1581 Editor::build_track_region_context_menu ()
1582 {
1583         using namespace Menu_Helpers;
1584         MenuList& edit_items  = track_region_context_menu.items();
1585         edit_items.clear();
1586
1587         /* we've just cleared the track region context menu, so the menu that these
1588            two items were on will have disappeared; stop them dangling.
1589         */
1590         region_edit_menu_split_item = 0;
1591         region_edit_menu_split_multichannel_item = 0;
1592
1593         /* we might try to use items that are currently attached to a crossfade menu,
1594            so clear that, too.
1595         */
1596         track_crossfade_context_menu.items().clear ();
1597
1598         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (clicked_axisview);
1599
1600         if (rtv) {
1601                 boost::shared_ptr<Track> tr;
1602                 boost::shared_ptr<Playlist> pl;
1603
1604                 if ((tr = rtv->track())) {
1605                         add_region_context_items (edit_items, tr);
1606                 }
1607         }
1608
1609         add_dstream_context_items (edit_items);
1610
1611         return &track_region_context_menu;
1612 }
1613
1614 Menu*
1615 Editor::build_track_crossfade_context_menu ()
1616 {
1617         using namespace Menu_Helpers;
1618         MenuList& edit_items  = track_crossfade_context_menu.items();
1619         edit_items.clear ();
1620
1621         /* we might try to use items that are currently attached to a crossfade menu,
1622            so clear that, too.
1623         */
1624         track_region_context_menu.items().clear ();
1625
1626         AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (clicked_axisview);
1627
1628         if (atv) {
1629                 boost::shared_ptr<Track> tr;
1630                 boost::shared_ptr<Playlist> pl;
1631                 boost::shared_ptr<AudioPlaylist> apl;
1632
1633                 if ((tr = atv->track()) && ((pl = tr->playlist()) != 0) && ((apl = boost::dynamic_pointer_cast<AudioPlaylist> (pl)) != 0)) {
1634
1635                         AudioPlaylist::Crossfades xfades;
1636                         framepos_t where;
1637                         bool ignored;
1638
1639                         /* The xfade menu is a bit of a special case, as we always use the mouse position
1640                            to decide whether or not to display it (rather than the edit point).  No particularly
1641                            strong reasons for this, other than it is a bit surprising to right-click on a xfade
1642                            and not get a menu.
1643                         */
1644                         mouse_frame (where, ignored);
1645                         apl->crossfades_at (where, xfades);
1646
1647                         bool const many = xfades.size() > 1;
1648
1649                         for (AudioPlaylist::Crossfades::iterator i = xfades.begin(); i != xfades.end(); ++i) {
1650                                 add_crossfade_context_items (atv->audio_view(), (*i), edit_items, many);
1651                         }
1652
1653                         add_region_context_items (edit_items, tr);
1654                 }
1655         }
1656
1657         add_dstream_context_items (edit_items);
1658
1659         return &track_crossfade_context_menu;
1660 }
1661
1662 void
1663 Editor::analyze_region_selection ()
1664 {
1665         if (analysis_window == 0) {
1666                 analysis_window = new AnalysisWindow();
1667
1668                 if (_session != 0)
1669                         analysis_window->set_session(_session);
1670
1671                 analysis_window->show_all();
1672         }
1673
1674         analysis_window->set_regionmode();
1675         analysis_window->analyze();
1676
1677         analysis_window->present();
1678 }
1679
1680 void
1681 Editor::analyze_range_selection()
1682 {
1683         if (analysis_window == 0) {
1684                 analysis_window = new AnalysisWindow();
1685
1686                 if (_session != 0)
1687                         analysis_window->set_session(_session);
1688
1689                 analysis_window->show_all();
1690         }
1691
1692         analysis_window->set_rangemode();
1693         analysis_window->analyze();
1694
1695         analysis_window->present();
1696 }
1697
1698 Menu*
1699 Editor::build_track_selection_context_menu ()
1700 {
1701         using namespace Menu_Helpers;
1702         MenuList& edit_items  = track_selection_context_menu.items();
1703         edit_items.clear ();
1704
1705         add_selection_context_items (edit_items);
1706         // edit_items.push_back (SeparatorElem());
1707         // add_dstream_context_items (edit_items);
1708
1709         return &track_selection_context_menu;
1710 }
1711
1712 /** Add context menu items relevant to crossfades.
1713  * @param edit_items List to add the items to.
1714  */
1715 void
1716 Editor::add_crossfade_context_items (AudioStreamView* /*view*/, boost::shared_ptr<Crossfade> xfade, Menu_Helpers::MenuList& edit_items, bool many)
1717 {
1718         using namespace Menu_Helpers;
1719         Menu     *xfade_menu = manage (new Menu);
1720         MenuList& items       = xfade_menu->items();
1721         xfade_menu->set_name ("ArdourContextMenu");
1722         string str;
1723
1724         if (xfade->active()) {
1725                 str = _("Mute");
1726         } else {
1727                 str = _("Unmute");
1728         }
1729
1730         items.push_back (MenuElem (str, sigc::bind (sigc::mem_fun(*this, &Editor::toggle_xfade_active), boost::weak_ptr<Crossfade> (xfade))));
1731         items.push_back (MenuElem (_("Edit..."), sigc::bind (sigc::mem_fun(*this, &Editor::edit_xfade), boost::weak_ptr<Crossfade> (xfade))));
1732
1733         if (xfade->can_follow_overlap()) {
1734
1735                 if (xfade->following_overlap()) {
1736                         str = _("Convert to Short");
1737                 } else {
1738                         str = _("Convert to Full");
1739                 }
1740
1741                 items.push_back (MenuElem (str, sigc::bind (sigc::mem_fun(*this, &Editor::toggle_xfade_length), xfade)));
1742         }
1743
1744         if (many) {
1745                 str = xfade->out()->name();
1746                 str += "->";
1747                 str += xfade->in()->name();
1748         } else {
1749                 str = _("Crossfade");
1750         }
1751
1752         edit_items.push_back (MenuElem (str, *xfade_menu));
1753         edit_items.push_back (SeparatorElem());
1754 }
1755
1756 void
1757 Editor::xfade_edit_left_region ()
1758 {
1759         if (clicked_crossfadeview) {
1760                 clicked_crossfadeview->left_view.show_region_editor ();
1761         }
1762 }
1763
1764 void
1765 Editor::xfade_edit_right_region ()
1766 {
1767         if (clicked_crossfadeview) {
1768                 clicked_crossfadeview->right_view.show_region_editor ();
1769         }
1770 }
1771
1772 void
1773 Editor::add_region_context_items (Menu_Helpers::MenuList& edit_items, boost::shared_ptr<Track> track)
1774 {
1775         using namespace Menu_Helpers;
1776
1777         /* OK, stick the region submenu at the top of the list, and then add
1778            the standard items.
1779         */
1780
1781         RegionSelection rs = get_regions_from_selection_and_entered ();
1782
1783         string::size_type pos = 0;
1784         string menu_item_name = (rs.size() == 1) ? rs.front()->region()->name() : _("Selected Regions");
1785
1786         /* we have to hack up the region name because "_" has a special
1787            meaning for menu titles.
1788         */
1789
1790         while ((pos = menu_item_name.find ("_", pos)) != string::npos) {
1791                 menu_item_name.replace (pos, 1, "__");
1792                 pos += 2;
1793         }
1794
1795         if (_popup_region_menu_item == 0) {
1796                 _popup_region_menu_item = new MenuItem (menu_item_name);
1797                 _popup_region_menu_item->set_submenu (*dynamic_cast<Menu*> (ActionManager::get_widget (X_("/PopupRegionMenu"))));
1798                 _popup_region_menu_item->show ();
1799         } else {
1800                 _popup_region_menu_item->set_label (menu_item_name);
1801         }
1802
1803         /* Use the mouse position rather than the edit point to decide whether to show the `choose top region'
1804            dialogue.  If we use the edit point it gets a bit messy because the user still has to click over
1805            *some* region in order to get the region context menu stuff to be displayed at all.
1806         */
1807
1808         framepos_t mouse;
1809         bool ignored;
1810         mouse_frame (mouse, ignored);
1811
1812         edit_items.push_back (*_popup_region_menu_item);
1813         if (track->playlist()->count_regions_at (mouse) > 1 && (layering_order_editor == 0 || !layering_order_editor->is_visible ())) {
1814                 edit_items.push_back (*manage (_region_actions->get_action ("choose-top-region")->create_menu_item ()));
1815         }
1816         edit_items.push_back (SeparatorElem());
1817 }
1818
1819 /** Add context menu items relevant to selection ranges.
1820  * @param edit_items List to add the items to.
1821  */
1822 void
1823 Editor::add_selection_context_items (Menu_Helpers::MenuList& edit_items)
1824 {
1825         using namespace Menu_Helpers;
1826
1827         edit_items.push_back (MenuElem (_("Play Range"), sigc::mem_fun(*this, &Editor::play_selection)));
1828         edit_items.push_back (MenuElem (_("Loop Range"), sigc::bind (sigc::mem_fun(*this, &Editor::set_loop_from_selection), true)));
1829
1830         edit_items.push_back (SeparatorElem());
1831         edit_items.push_back (MenuElem (_("Spectral Analysis"), sigc::mem_fun(*this, &Editor::analyze_range_selection)));
1832
1833         edit_items.push_back (SeparatorElem());
1834
1835         edit_items.push_back (
1836                 MenuElem (
1837                         _("Move Range Start to Previous Region Boundary"),
1838                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), false, false)
1839                         )
1840                 );
1841
1842         edit_items.push_back (
1843                 MenuElem (
1844                         _("Move Range Start to Next Region Boundary"),
1845                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), false, true)
1846                         )
1847                 );
1848
1849         edit_items.push_back (
1850                 MenuElem (
1851                         _("Move Range End to Previous Region Boundary"),
1852                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), true, false)
1853                         )
1854                 );
1855
1856         edit_items.push_back (
1857                 MenuElem (
1858                         _("Move Range End to Next Region Boundary"),
1859                         sigc::bind (sigc::mem_fun (*this, &Editor::move_range_selection_start_or_end_to_region_boundary), true, true)
1860                         )
1861                 );
1862
1863         edit_items.push_back (SeparatorElem());
1864         edit_items.push_back (MenuElem (_("Convert to Region In-Place"), mem_fun(*this, &Editor::separate_region_from_selection)));
1865         edit_items.push_back (MenuElem (_("Convert to Region in Region List"), sigc::mem_fun(*this, &Editor::new_region_from_selection)));
1866
1867         edit_items.push_back (SeparatorElem());
1868         edit_items.push_back (MenuElem (_("Select All in Range"), sigc::mem_fun(*this, &Editor::select_all_selectables_using_time_selection)));
1869
1870         edit_items.push_back (SeparatorElem());
1871         edit_items.push_back (MenuElem (_("Set Loop from Range"), sigc::bind (sigc::mem_fun(*this, &Editor::set_loop_from_selection), false)));
1872         edit_items.push_back (MenuElem (_("Set Punch from Range"), sigc::mem_fun(*this, &Editor::set_punch_from_selection)));
1873
1874         edit_items.push_back (SeparatorElem());
1875         edit_items.push_back (MenuElem (_("Add Range Markers"), sigc::mem_fun (*this, &Editor::add_location_from_selection)));
1876
1877         edit_items.push_back (SeparatorElem());
1878         edit_items.push_back (MenuElem (_("Crop Region to Range"), sigc::mem_fun(*this, &Editor::crop_region_to_selection)));
1879         edit_items.push_back (MenuElem (_("Fill Range with Region"), sigc::mem_fun(*this, &Editor::region_fill_selection)));
1880         edit_items.push_back (MenuElem (_("Duplicate Range"), sigc::bind (sigc::mem_fun(*this, &Editor::duplicate_dialog), false)));
1881
1882         edit_items.push_back (SeparatorElem());
1883         edit_items.push_back (MenuElem (_("Consolidate Range"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, false)));
1884         edit_items.push_back (MenuElem (_("Consolidate Range With Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), true, true)));
1885         edit_items.push_back (MenuElem (_("Bounce Range to Region List"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, false)));
1886         edit_items.push_back (MenuElem (_("Bounce Range to Region List With Processing"), sigc::bind (sigc::mem_fun(*this, &Editor::bounce_range_selection), false, true)));
1887         edit_items.push_back (MenuElem (_("Export Range"), sigc::mem_fun(*this, &Editor::export_selection)));
1888 }
1889
1890
1891 void
1892 Editor::add_dstream_context_items (Menu_Helpers::MenuList& edit_items)
1893 {
1894         using namespace Menu_Helpers;
1895
1896         /* Playback */
1897
1898         Menu *play_menu = manage (new Menu);
1899         MenuList& play_items = play_menu->items();
1900         play_menu->set_name ("ArdourContextMenu");
1901
1902         play_items.push_back (MenuElem (_("Play From Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
1903         play_items.push_back (MenuElem (_("Play From Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
1904         play_items.push_back (MenuElem (_("Play Region"), sigc::mem_fun(*this, &Editor::play_selected_region)));
1905         play_items.push_back (SeparatorElem());
1906         play_items.push_back (MenuElem (_("Loop Region"), sigc::bind (sigc::mem_fun (*this, &Editor::set_loop_from_region), true)));
1907
1908         edit_items.push_back (MenuElem (_("Play"), *play_menu));
1909
1910         /* Selection */
1911
1912         Menu *select_menu = manage (new Menu);
1913         MenuList& select_items = select_menu->items();
1914         select_menu->set_name ("ArdourContextMenu");
1915
1916         select_items.push_back (MenuElem (_("Select All in Track"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_in_track), Selection::Set)));
1917         select_items.push_back (MenuElem (_("Select All"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all), Selection::Set)));
1918         select_items.push_back (MenuElem (_("Invert Selection in Track"), sigc::mem_fun(*this, &Editor::invert_selection_in_track)));
1919         select_items.push_back (MenuElem (_("Invert Selection"), sigc::mem_fun(*this, &Editor::invert_selection)));
1920         select_items.push_back (SeparatorElem());
1921         select_items.push_back (MenuElem (_("Set Range to Loop Range"), sigc::mem_fun(*this, &Editor::set_selection_from_loop)));
1922         select_items.push_back (MenuElem (_("Set Range to Punch Range"), sigc::mem_fun(*this, &Editor::set_selection_from_punch)));
1923         select_items.push_back (SeparatorElem());
1924         select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true)));
1925         select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false)));
1926         select_items.push_back (MenuElem (_("Select All After Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
1927         select_items.push_back (MenuElem (_("Select All Before Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
1928         select_items.push_back (MenuElem (_("Select All Between Playhead and Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_between), false)));
1929         select_items.push_back (MenuElem (_("Select All Within Playhead and Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_between), true)));
1930         select_items.push_back (MenuElem (_("Select Range Between Playhead and Edit Point"), sigc::mem_fun(*this, &Editor::select_range_between)));
1931
1932         edit_items.push_back (MenuElem (_("Select"), *select_menu));
1933
1934         /* Cut-n-Paste */
1935
1936         Menu *cutnpaste_menu = manage (new Menu);
1937         MenuList& cutnpaste_items = cutnpaste_menu->items();
1938         cutnpaste_menu->set_name ("ArdourContextMenu");
1939
1940         cutnpaste_items.push_back (MenuElem (_("Cut"), sigc::mem_fun(*this, &Editor::cut)));
1941         cutnpaste_items.push_back (MenuElem (_("Copy"), sigc::mem_fun(*this, &Editor::copy)));
1942         cutnpaste_items.push_back (MenuElem (_("Paste"), sigc::bind (sigc::mem_fun(*this, &Editor::paste), 1.0f)));
1943
1944         cutnpaste_items.push_back (SeparatorElem());
1945
1946         cutnpaste_items.push_back (MenuElem (_("Align"), sigc::bind (sigc::mem_fun (*this, &Editor::align_regions), ARDOUR::SyncPoint)));
1947         cutnpaste_items.push_back (MenuElem (_("Align Relative"), sigc::bind (sigc::mem_fun (*this, &Editor::align_regions_relative), ARDOUR::SyncPoint)));
1948
1949         edit_items.push_back (MenuElem (_("Edit"), *cutnpaste_menu));
1950
1951         /* Adding new material */
1952
1953         edit_items.push_back (SeparatorElem());
1954         edit_items.push_back (MenuElem (_("Insert Selected Region"), sigc::bind (sigc::mem_fun(*this, &Editor::insert_region_list_selection), 1.0f)));
1955         edit_items.push_back (MenuElem (_("Insert Existing Media"), sigc::bind (sigc::mem_fun(*this, &Editor::add_external_audio_action), ImportToTrack)));
1956
1957         /* Nudge track */
1958
1959         Menu *nudge_menu = manage (new Menu());
1960         MenuList& nudge_items = nudge_menu->items();
1961         nudge_menu->set_name ("ArdourContextMenu");
1962
1963         edit_items.push_back (SeparatorElem());
1964         nudge_items.push_back (MenuElem (_("Nudge Entire Track Forward"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, true))));
1965         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Forward"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, true))));
1966         nudge_items.push_back (MenuElem (_("Nudge Entire Track Backward"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, false))));
1967         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Backward"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, false))));
1968
1969         edit_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
1970 }
1971
1972 void
1973 Editor::add_bus_context_items (Menu_Helpers::MenuList& edit_items)
1974 {
1975         using namespace Menu_Helpers;
1976
1977         /* Playback */
1978
1979         Menu *play_menu = manage (new Menu);
1980         MenuList& play_items = play_menu->items();
1981         play_menu->set_name ("ArdourContextMenu");
1982
1983         play_items.push_back (MenuElem (_("Play From Edit Point"), sigc::mem_fun(*this, &Editor::play_from_edit_point)));
1984         play_items.push_back (MenuElem (_("Play From Start"), sigc::mem_fun(*this, &Editor::play_from_start)));
1985         edit_items.push_back (MenuElem (_("Play"), *play_menu));
1986
1987         /* Selection */
1988
1989         Menu *select_menu = manage (new Menu);
1990         MenuList& select_items = select_menu->items();
1991         select_menu->set_name ("ArdourContextMenu");
1992
1993         select_items.push_back (MenuElem (_("Select All in Track"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_in_track), Selection::Set)));
1994         select_items.push_back (MenuElem (_("Select All"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all), Selection::Set)));
1995         select_items.push_back (MenuElem (_("Invert Selection in Track"), sigc::mem_fun(*this, &Editor::invert_selection_in_track)));
1996         select_items.push_back (MenuElem (_("Invert Selection"), sigc::mem_fun(*this, &Editor::invert_selection)));
1997         select_items.push_back (SeparatorElem());
1998         select_items.push_back (MenuElem (_("Select All After Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), true)));
1999         select_items.push_back (MenuElem (_("Select All Before Edit Point"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_edit), false)));
2000         select_items.push_back (MenuElem (_("Select All After Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
2001         select_items.push_back (MenuElem (_("Select All Before Playhead"), sigc::bind (sigc::mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
2002
2003         edit_items.push_back (MenuElem (_("Select"), *select_menu));
2004
2005         /* Cut-n-Paste */
2006
2007         Menu *cutnpaste_menu = manage (new Menu);
2008         MenuList& cutnpaste_items = cutnpaste_menu->items();
2009         cutnpaste_menu->set_name ("ArdourContextMenu");
2010
2011         cutnpaste_items.push_back (MenuElem (_("Cut"), sigc::mem_fun(*this, &Editor::cut)));
2012         cutnpaste_items.push_back (MenuElem (_("Copy"), sigc::mem_fun(*this, &Editor::copy)));
2013         cutnpaste_items.push_back (MenuElem (_("Paste"), sigc::bind (sigc::mem_fun(*this, &Editor::paste), 1.0f)));
2014
2015         Menu *nudge_menu = manage (new Menu());
2016         MenuList& nudge_items = nudge_menu->items();
2017         nudge_menu->set_name ("ArdourContextMenu");
2018
2019         edit_items.push_back (SeparatorElem());
2020         nudge_items.push_back (MenuElem (_("Nudge Entire Track Forward"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, true))));
2021         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Forward"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, true))));
2022         nudge_items.push_back (MenuElem (_("Nudge Entire Track Backward"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), false, false))));
2023         nudge_items.push_back (MenuElem (_("Nudge Track After Edit Point Backward"), (sigc::bind (sigc::mem_fun(*this, &Editor::nudge_track), true, false))));
2024
2025         edit_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
2026 }
2027
2028 SnapType
2029 Editor::snap_type() const
2030 {
2031         return _snap_type;
2032 }
2033
2034 SnapMode
2035 Editor::snap_mode() const
2036 {
2037         return _snap_mode;
2038 }
2039
2040 void
2041 Editor::set_snap_to (SnapType st)
2042 {
2043         unsigned int snap_ind = (unsigned int)st;
2044
2045         _snap_type = st;
2046
2047         if (snap_ind > snap_type_strings.size() - 1) {
2048                 snap_ind = 0;
2049                 _snap_type = (SnapType)snap_ind;
2050         }
2051
2052         string str = snap_type_strings[snap_ind];
2053
2054         if (str != snap_type_selector.get_active_text()) {
2055                 snap_type_selector.set_active_text (str);
2056         }
2057
2058         instant_save ();
2059
2060         switch (_snap_type) {
2061         case SnapToBeatDiv32:
2062         case SnapToBeatDiv28:
2063         case SnapToBeatDiv24:
2064         case SnapToBeatDiv20:
2065         case SnapToBeatDiv16:
2066         case SnapToBeatDiv14:
2067         case SnapToBeatDiv12:
2068         case SnapToBeatDiv10:
2069         case SnapToBeatDiv8:
2070         case SnapToBeatDiv7:
2071         case SnapToBeatDiv6:
2072         case SnapToBeatDiv5:
2073         case SnapToBeatDiv4:
2074         case SnapToBeatDiv3:
2075         case SnapToBeatDiv2:
2076                 compute_bbt_ruler_scale (leftmost_frame, leftmost_frame + current_page_frames());
2077                 update_tempo_based_rulers ();
2078                 break;
2079
2080         case SnapToRegionStart:
2081         case SnapToRegionEnd:
2082         case SnapToRegionSync:
2083         case SnapToRegionBoundary:
2084                 build_region_boundary_cache ();
2085                 break;
2086
2087         default:
2088                 /* relax */
2089                 break;
2090         }
2091
2092         SnapChanged (); /* EMIT SIGNAL */
2093 }
2094
2095 void
2096 Editor::set_snap_mode (SnapMode mode)
2097 {
2098         _snap_mode = mode;
2099         string str = snap_mode_strings[(int)mode];
2100
2101         if (str != snap_mode_selector.get_active_text ()) {
2102                 snap_mode_selector.set_active_text (str);
2103         }
2104
2105         instant_save ();
2106 }
2107 void
2108 Editor::set_edit_point_preference (EditPoint ep, bool force)
2109 {
2110         bool changed = (_edit_point != ep);
2111
2112         _edit_point = ep;
2113         string str = edit_point_strings[(int)ep];
2114
2115         if (str != edit_point_selector.get_active_text ()) {
2116                 edit_point_selector.set_active_text (str);
2117         }
2118
2119         set_canvas_cursor ();
2120
2121         if (!force && !changed) {
2122                 return;
2123         }
2124
2125         const char* action=NULL;
2126
2127         switch (_edit_point) {
2128         case EditAtPlayhead:
2129                 action = "edit-at-playhead";
2130                 break;
2131         case EditAtSelectedMarker:
2132                 action = "edit-at-marker";
2133                 break;
2134         case EditAtMouse:
2135                 action = "edit-at-mouse";
2136                 break;
2137         }
2138
2139         Glib::RefPtr<Action> act = ActionManager::get_action ("Editor", action);
2140         if (act) {
2141                 Glib::RefPtr<RadioAction>::cast_dynamic(act)->set_active (true);
2142         }
2143
2144         framepos_t foo;
2145         bool in_track_canvas;
2146
2147         if (!mouse_frame (foo, in_track_canvas)) {
2148                 in_track_canvas = false;
2149         }
2150
2151         reset_canvas_action_sensitivity (in_track_canvas);
2152
2153         instant_save ();
2154 }
2155
2156 int
2157 Editor::set_state (const XMLNode& node, int /*version*/)
2158 {
2159         const XMLProperty* prop;
2160         XMLNode* geometry;
2161         int x, y;
2162         Gdk::Geometry g;
2163
2164         if ((prop = node.property ("id")) != 0) {
2165                 _id = prop->value ();
2166         }
2167
2168         g.base_width = default_width;
2169         g.base_height = default_height;
2170         x = 1;
2171         y = 1;
2172
2173         if ((geometry = find_named_node (node, "geometry")) != 0) {
2174
2175                 XMLProperty* prop;
2176
2177                 if ((prop = geometry->property("x_size")) == 0) {
2178                         prop = geometry->property ("x-size");
2179                 }
2180                 if (prop) {
2181                         g.base_width = atoi(prop->value());
2182                 }
2183                 if ((prop = geometry->property("y_size")) == 0) {
2184                         prop = geometry->property ("y-size");
2185                 }
2186                 if (prop) {
2187                         g.base_height = atoi(prop->value());
2188                 }
2189
2190                 if ((prop = geometry->property ("x_pos")) == 0) {
2191                         prop = geometry->property ("x-pos");
2192                 }
2193                 if (prop) {
2194                         x = atoi (prop->value());
2195
2196                 }
2197                 if ((prop = geometry->property ("y_pos")) == 0) {
2198                         prop = geometry->property ("y-pos");
2199                 }
2200                 if (prop) {
2201                         y = atoi (prop->value());
2202                 }
2203         }
2204
2205         set_default_size (g.base_width, g.base_height);
2206         move (x, y);
2207
2208         if (_session && (prop = node.property ("playhead"))) {
2209                 framepos_t pos;
2210                 sscanf (prop->value().c_str(), "%" PRIi64, &pos);
2211                 playhead_cursor->set_position (pos);
2212         } else {
2213                 playhead_cursor->set_position (0);
2214         }
2215
2216         if ((prop = node.property ("mixer-width"))) {
2217                 editor_mixer_strip_width = Width (string_2_enum (prop->value(), editor_mixer_strip_width));
2218         }
2219
2220         if ((prop = node.property ("zoom-focus"))) {
2221                 set_zoom_focus ((ZoomFocus) atoi (prop->value()));
2222         }
2223
2224         if ((prop = node.property ("zoom"))) {
2225                 reset_zoom (PBD::atof (prop->value()));
2226         } else {
2227                 reset_zoom (frames_per_unit);
2228         }
2229
2230         if ((prop = node.property ("snap-to"))) {
2231                 set_snap_to ((SnapType) atoi (prop->value()));
2232         }
2233
2234         if ((prop = node.property ("snap-mode"))) {
2235                 set_snap_mode ((SnapMode) atoi (prop->value()));
2236         }
2237
2238         if ((prop = node.property ("mouse-mode"))) {
2239                 MouseMode m = str2mousemode(prop->value());
2240                 set_mouse_mode (m, true);
2241         } else {
2242                 set_mouse_mode (MouseObject, true);
2243         }
2244
2245         if ((prop = node.property ("left-frame")) != 0) {
2246                 framepos_t pos;
2247                 if (sscanf (prop->value().c_str(), "%" PRId64, &pos) == 1) {
2248                         reset_x_origin (pos);
2249                 }
2250         }
2251
2252         if ((prop = node.property ("y-origin")) != 0) {
2253                 reset_y_origin (atof (prop->value ()));
2254         }
2255
2256         if ((prop = node.property ("internal-edit"))) {
2257                 bool yn = string_is_affirmative (prop->value());
2258                 RefPtr<Action> act = ActionManager::get_action (X_("MouseMode"), X_("toggle-internal-edit"));
2259                 if (act) {
2260                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2261                         tact->set_active (!yn);
2262                         tact->set_active (yn);
2263                 }
2264         }
2265
2266         if ((prop = node.property ("join-object-range"))) {
2267                 join_object_range_button.set_active (string_is_affirmative (prop->value ()));
2268         }
2269
2270         if ((prop = node.property ("edit-point"))) {
2271                 set_edit_point_preference ((EditPoint) string_2_enum (prop->value(), _edit_point), true);
2272         }
2273
2274         if ((prop = node.property ("show-measures"))) {
2275                 bool yn = string_is_affirmative (prop->value());
2276                 _show_measures = yn;
2277                 RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("ToggleMeasureVisibility"));
2278                 if (act) {
2279                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2280                         /* do it twice to force the change */
2281                         tact->set_active (!yn);
2282                         tact->set_active (yn);
2283                 }
2284         }
2285
2286         if ((prop = node.property ("follow-playhead"))) {
2287                 bool yn = string_is_affirmative (prop->value());
2288                 set_follow_playhead (yn);
2289                 RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-follow-playhead"));
2290                 if (act) {
2291                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2292                         if (tact->get_active() != yn) {
2293                                 tact->set_active (yn);
2294                         }
2295                 }
2296         }
2297
2298         if ((prop = node.property ("stationary-playhead"))) {
2299                 bool yn = string_is_affirmative (prop->value());
2300                 set_stationary_playhead (yn);
2301                 RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-stationary-playhead"));
2302                 if (act) {
2303                         RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
2304                         if (tact->get_active() != yn) {
2305                                 tact->set_active (yn);
2306                         }
2307                 }
2308         }
2309
2310         if ((prop = node.property ("region-list-sort-type"))) {
2311                 RegionListSortType st;
2312                 _regions->reset_sort_type ((RegionListSortType) string_2_enum (prop->value(), st), true);
2313         }
2314
2315         if ((prop = node.property ("xfades-visible"))) {
2316                 bool yn = string_is_affirmative (prop->value());
2317                 _xfade_visibility = !yn;
2318                 // set_xfade_visibility (yn);
2319         }
2320
2321         if ((prop = node.property ("show-editor-mixer"))) {
2322
2323                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
2324                 assert (act);
2325
2326                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2327                 bool yn = string_is_affirmative (prop->value());
2328
2329                 /* do it twice to force the change */
2330
2331                 tact->set_active (!yn);
2332                 tact->set_active (yn);
2333         }
2334
2335         if ((prop = node.property ("show-editor-list"))) {
2336
2337                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-list"));
2338                 assert (act);
2339
2340                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2341                 bool yn = string_is_affirmative (prop->value());
2342
2343                 /* do it twice to force the change */
2344
2345                 tact->set_active (!yn);
2346                 tact->set_active (yn);
2347         }
2348
2349         if ((prop = node.property (X_("editor-list-page")))) {
2350                 _the_notebook.set_current_page (atoi (prop->value ()));
2351         }
2352
2353         if ((prop = node.property (X_("show-marker-lines")))) {
2354                 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-marker-lines"));
2355                 assert (act);
2356                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
2357                 bool yn = string_is_affirmative (prop->value ());
2358
2359                 tact->set_active (!yn);
2360                 tact->set_active (yn);
2361         }
2362
2363         XMLNodeList children = node.children ();
2364         for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
2365                 selection->set_state (**i, Stateful::current_state_version);
2366                 _regions->set_state (**i);
2367         }
2368
2369         return 0;
2370 }
2371
2372 XMLNode&
2373 Editor::get_state ()
2374 {
2375         XMLNode* node = new XMLNode ("Editor");
2376         char buf[32];
2377
2378         _id.print (buf, sizeof (buf));
2379         node->add_property ("id", buf);
2380
2381         if (is_realized()) {
2382                 Glib::RefPtr<Gdk::Window> win = get_window();
2383
2384                 int x, y, width, height;
2385                 win->get_root_origin(x, y);
2386                 win->get_size(width, height);
2387
2388                 XMLNode* geometry = new XMLNode ("geometry");
2389
2390                 snprintf(buf, sizeof(buf), "%d", width);
2391                 geometry->add_property("x-size", string(buf));
2392                 snprintf(buf, sizeof(buf), "%d", height);
2393                 geometry->add_property("y-size", string(buf));
2394                 snprintf(buf, sizeof(buf), "%d", x);
2395                 geometry->add_property("x-pos", string(buf));
2396                 snprintf(buf, sizeof(buf), "%d", y);
2397                 geometry->add_property("y-pos", string(buf));
2398                 snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&edit_pane)->gobj()));
2399                 geometry->add_property("edit-horizontal-pane-pos", string(buf));
2400                 geometry->add_property("notebook-shrunk", _notebook_shrunk ? "1" : "0");
2401                 snprintf(buf,sizeof(buf), "%d",pre_maximal_horizontal_pane_position);
2402                 geometry->add_property("pre-maximal-horizontal-pane-position", string(buf));
2403                 snprintf(buf,sizeof(buf), "%d",gtk_paned_get_position (static_cast<Paned*>(&editor_summary_pane)->gobj()));
2404                 geometry->add_property("edit-vertical-pane-pos", string(buf));
2405
2406                 node->add_child_nocopy (*geometry);
2407         }
2408
2409         maybe_add_mixer_strip_width (*node);
2410
2411         snprintf (buf, sizeof(buf), "%d", (int) zoom_focus);
2412         node->add_property ("zoom-focus", buf);
2413         snprintf (buf, sizeof(buf), "%f", frames_per_unit);
2414         node->add_property ("zoom", buf);
2415         snprintf (buf, sizeof(buf), "%d", (int) _snap_type);
2416         node->add_property ("snap-to", buf);
2417         snprintf (buf, sizeof(buf), "%d", (int) _snap_mode);
2418         node->add_property ("snap-mode", buf);
2419
2420         node->add_property ("edit-point", enum_2_string (_edit_point));
2421
2422         snprintf (buf, sizeof (buf), "%" PRIi64, playhead_cursor->current_frame);
2423         node->add_property ("playhead", buf);
2424         snprintf (buf, sizeof (buf), "%" PRIi64, leftmost_frame);
2425         node->add_property ("left-frame", buf);
2426         snprintf (buf, sizeof (buf), "%f", vertical_adjustment.get_value ());
2427         node->add_property ("y-origin", buf);
2428
2429         node->add_property ("show-measures", _show_measures ? "yes" : "no");
2430         node->add_property ("follow-playhead", _follow_playhead ? "yes" : "no");
2431         node->add_property ("stationary-playhead", _stationary_playhead ? "yes" : "no");
2432         node->add_property ("xfades-visible", _xfade_visibility ? "yes" : "no");
2433         node->add_property ("region-list-sort-type", enum_2_string (_regions->sort_type ()));
2434         node->add_property ("mouse-mode", enum2str(mouse_mode));
2435         node->add_property ("internal-edit", _internal_editing ? "yes" : "no");
2436         node->add_property ("join-object-range", join_object_range_button.get_active () ? "yes" : "no");
2437
2438         Glib::RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
2439         if (act) {
2440                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2441                 node->add_property (X_("show-editor-mixer"), tact->get_active() ? "yes" : "no");
2442         }
2443
2444         act = ActionManager::get_action (X_("Editor"), X_("show-editor-list"));
2445         if (act) {
2446                 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
2447                 node->add_property (X_("show-editor-list"), tact->get_active() ? "yes" : "no");
2448         }
2449
2450         snprintf (buf, sizeof (buf), "%d", _the_notebook.get_current_page ());
2451         node->add_property (X_("editor-list-page"), buf);
2452
2453         if (button_bindings) {
2454                 XMLNode* bb = new XMLNode (X_("Buttons"));
2455                 button_bindings->save (*bb);
2456                 node->add_child_nocopy (*bb);
2457         }
2458
2459         node->add_property (X_("show-marker-lines"), _show_marker_lines ? "yes" : "no");
2460
2461         node->add_child_nocopy (selection->get_state ());
2462         node->add_child_nocopy (_regions->get_state ());
2463
2464         return *node;
2465 }
2466
2467
2468
2469 /** @param y y offset from the top of all trackviews.
2470  *  @return pair: TimeAxisView that y is over, layer index.
2471  *  TimeAxisView may be 0.  Layer index is the layer number if the TimeAxisView is valid and is
2472  *  in stacked region display mode, otherwise 0.
2473  */
2474 std::pair<TimeAxisView *, layer_t>
2475 Editor::trackview_by_y_position (double y)
2476 {
2477         for (TrackViewList::iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
2478
2479                 std::pair<TimeAxisView*, int> const r = (*iter)->covers_y_position (y);
2480                 if (r.first) {
2481                         return r;
2482                 }
2483         }
2484
2485         return std::make_pair ( (TimeAxisView *) 0, 0);
2486 }
2487
2488 /** Snap a position to the grid, if appropriate, taking into account current
2489  *  grid settings and also the state of any snap modifier keys that may be pressed.
2490  *  @param start Position to snap.
2491  *  @param event Event to get current key modifier information from, or 0.
2492  */
2493 void
2494 Editor::snap_to_with_modifier (framepos_t& start, GdkEvent const * event, int32_t direction, bool for_mark)
2495 {
2496         if (!_session || !event) {
2497                 return;
2498         }
2499
2500         if (Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
2501                 if (_snap_mode == SnapOff) {
2502                         snap_to_internal (start, direction, for_mark);
2503                 }
2504         } else {
2505                 if (_snap_mode != SnapOff) {
2506                         snap_to_internal (start, direction, for_mark);
2507                 }
2508         }
2509 }
2510
2511 void
2512 Editor::snap_to (framepos_t& start, int32_t direction, bool for_mark)
2513 {
2514         if (!_session || _snap_mode == SnapOff) {
2515                 return;
2516         }
2517
2518         snap_to_internal (start, direction, for_mark);
2519 }
2520
2521 void
2522 Editor::timecode_snap_to_internal (framepos_t& start, int32_t direction, bool /*for_mark*/)
2523 {
2524         const framepos_t one_timecode_second = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->frames_per_timecode_frame());
2525         framepos_t one_timecode_minute = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->frames_per_timecode_frame() * 60);
2526
2527         switch (_snap_type) {
2528         case SnapToTimecodeFrame:
2529                 if (((direction == 0) && (fmod((double)start, (double)_session->frames_per_timecode_frame()) > (_session->frames_per_timecode_frame() / 2))) || (direction > 0)) {
2530                         start = (framepos_t) (ceil ((double) start / _session->frames_per_timecode_frame()) * _session->frames_per_timecode_frame());
2531                 } else {
2532                         start = (framepos_t) (floor ((double) start / _session->frames_per_timecode_frame()) *  _session->frames_per_timecode_frame());
2533                 }
2534                 break;
2535
2536         case SnapToTimecodeSeconds:
2537                 if (_session->config.get_timecode_offset_negative()) {
2538                         start += _session->config.get_timecode_offset ();
2539                 } else {
2540                         start -= _session->config.get_timecode_offset ();
2541                 }
2542                 if (((direction == 0) && (start % one_timecode_second > one_timecode_second / 2)) || direction > 0) {
2543                         start = (framepos_t) ceil ((double) start / one_timecode_second) * one_timecode_second;
2544                 } else {
2545                         start = (framepos_t) floor ((double) start / one_timecode_second) * one_timecode_second;
2546                 }
2547
2548                 if (_session->config.get_timecode_offset_negative()) {
2549                         start -= _session->config.get_timecode_offset ();
2550                 } else {
2551                         start += _session->config.get_timecode_offset ();
2552                 }
2553                 break;
2554
2555         case SnapToTimecodeMinutes:
2556                 if (_session->config.get_timecode_offset_negative()) {
2557                         start += _session->config.get_timecode_offset ();
2558                 } else {
2559                         start -= _session->config.get_timecode_offset ();
2560                 }
2561                 if (((direction == 0) && (start % one_timecode_minute > one_timecode_minute / 2)) || direction > 0) {
2562                         start = (framepos_t) ceil ((double) start / one_timecode_minute) * one_timecode_minute;
2563                 } else {
2564                         start = (framepos_t) floor ((double) start / one_timecode_minute) * one_timecode_minute;
2565                 }
2566                 if (_session->config.get_timecode_offset_negative()) {
2567                         start -= _session->config.get_timecode_offset ();
2568                 } else {
2569                         start += _session->config.get_timecode_offset ();
2570                 }
2571                 break;
2572         default:
2573                 fatal << "Editor::smpte_snap_to_internal() called with non-timecode snap type!" << endmsg;
2574                 /*NOTREACHED*/
2575         }
2576 }
2577
2578 void
2579 Editor::snap_to_internal (framepos_t& start, int32_t direction, bool for_mark)
2580 {
2581         const framepos_t one_second = _session->frame_rate();
2582         const framepos_t one_minute = _session->frame_rate() * 60;
2583         framepos_t presnap = start;
2584         framepos_t before;
2585         framepos_t after;
2586
2587         switch (_snap_type) {
2588         case SnapToTimecodeFrame:
2589         case SnapToTimecodeSeconds:
2590         case SnapToTimecodeMinutes:
2591                 return timecode_snap_to_internal (start, direction, for_mark);
2592
2593         case SnapToCDFrame:
2594                 if (((direction == 0) && (start % (one_second/75) > (one_second/75) / 2)) || (direction > 0)) {
2595                         start = (framepos_t) ceil ((double) start / (one_second / 75)) * (one_second / 75);
2596                 } else {
2597                         start = (framepos_t) floor ((double) start / (one_second / 75)) * (one_second / 75);
2598                 }
2599                 break;
2600
2601         case SnapToSeconds:
2602                 if (((direction == 0) && (start % one_second > one_second / 2)) || (direction > 0)) {
2603                         start = (framepos_t) ceil ((double) start / one_second) * one_second;
2604                 } else {
2605                         start = (framepos_t) floor ((double) start / one_second) * one_second;
2606                 }
2607                 break;
2608
2609         case SnapToMinutes:
2610                 if (((direction == 0) && (start % one_minute > one_minute / 2)) || (direction > 0)) {
2611                         start = (framepos_t) ceil ((double) start / one_minute) * one_minute;
2612                 } else {
2613                         start = (framepos_t) floor ((double) start / one_minute) * one_minute;
2614                 }
2615                 break;
2616
2617         case SnapToBar:
2618                 start = _session->tempo_map().round_to_bar (start, direction);
2619                 break;
2620
2621         case SnapToBeat:
2622                 start = _session->tempo_map().round_to_beat (start, direction);
2623                 break;
2624
2625         case SnapToBeatDiv32:
2626                 start = _session->tempo_map().round_to_beat_subdivision (start, 32, direction);
2627                 break;
2628         case SnapToBeatDiv28:
2629                 start = _session->tempo_map().round_to_beat_subdivision (start, 28, direction);
2630                 break;
2631         case SnapToBeatDiv24:
2632                 start = _session->tempo_map().round_to_beat_subdivision (start, 24, direction);
2633                 break;
2634         case SnapToBeatDiv20:
2635                 start = _session->tempo_map().round_to_beat_subdivision (start, 20, direction);
2636                 break;
2637         case SnapToBeatDiv16:
2638                 start = _session->tempo_map().round_to_beat_subdivision (start, 16, direction);
2639                 break;
2640         case SnapToBeatDiv14:
2641                 start = _session->tempo_map().round_to_beat_subdivision (start, 14, direction);
2642                 break;
2643         case SnapToBeatDiv12:
2644                 start = _session->tempo_map().round_to_beat_subdivision (start, 12, direction);
2645                 break;
2646         case SnapToBeatDiv10:
2647                 start = _session->tempo_map().round_to_beat_subdivision (start, 10, direction);
2648                 break;
2649         case SnapToBeatDiv8:
2650                 start = _session->tempo_map().round_to_beat_subdivision (start, 8, direction);
2651                 break;
2652         case SnapToBeatDiv7:
2653                 start = _session->tempo_map().round_to_beat_subdivision (start, 7, direction);
2654                 break;
2655         case SnapToBeatDiv6:
2656                 start = _session->tempo_map().round_to_beat_subdivision (start, 6, direction);
2657                 break;
2658         case SnapToBeatDiv5:
2659                 start = _session->tempo_map().round_to_beat_subdivision (start, 5, direction);
2660                 break;
2661         case SnapToBeatDiv4:
2662                 start = _session->tempo_map().round_to_beat_subdivision (start, 4, direction);
2663                 break;
2664         case SnapToBeatDiv3:
2665                 start = _session->tempo_map().round_to_beat_subdivision (start, 3, direction);
2666                 break;
2667         case SnapToBeatDiv2:
2668                 start = _session->tempo_map().round_to_beat_subdivision (start, 2, direction);
2669                 break;
2670
2671         case SnapToMark:
2672                 if (for_mark) {
2673                         return;
2674                 }
2675
2676                 _session->locations()->marks_either_side (start, before, after);
2677
2678                 if (before == max_framepos) {
2679                         start = after;
2680                 } else if (after == max_framepos) {
2681                         start = before;
2682                 } else if (before != max_framepos && after != max_framepos) {
2683                         /* have before and after */
2684                         if ((start - before) < (after - start)) {
2685                                 start = before;
2686                         } else {
2687                                 start = after;
2688                         }
2689                 }
2690
2691                 break;
2692
2693         case SnapToRegionStart:
2694         case SnapToRegionEnd:
2695         case SnapToRegionSync:
2696         case SnapToRegionBoundary:
2697                 if (!region_boundary_cache.empty()) {
2698
2699                         vector<framepos_t>::iterator prev = region_boundary_cache.end ();
2700                         vector<framepos_t>::iterator next = region_boundary_cache.end ();
2701
2702                         if (direction > 0) {
2703                                 next = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start);
2704                         } else {
2705                                 next = std::lower_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start);
2706                         }
2707
2708                         if (next != region_boundary_cache.begin ()) {
2709                                 prev = next;
2710                                 prev--;
2711                         }
2712
2713                         framepos_t const p = (prev == region_boundary_cache.end()) ? region_boundary_cache.front () : *prev;
2714                         framepos_t const n = (next == region_boundary_cache.end()) ? region_boundary_cache.back () : *next;
2715
2716                         if (start > (p + n) / 2) {
2717                                 start = n;
2718                         } else {
2719                                 start = p;
2720                         }
2721                 }
2722                 break;
2723         }
2724
2725         switch (_snap_mode) {
2726         case SnapNormal:
2727                 return;
2728
2729         case SnapMagnetic:
2730
2731                 if (presnap > start) {
2732                         if (presnap > (start + unit_to_frame(snap_threshold))) {
2733                                 start = presnap;
2734                         }
2735
2736                 } else if (presnap < start) {
2737                         if (presnap < (start - unit_to_frame(snap_threshold))) {
2738                                 start = presnap;
2739                         }
2740                 }
2741
2742         default:
2743                 /* handled at entry */
2744                 return;
2745
2746         }
2747 }
2748
2749
2750 void
2751 Editor::setup_toolbar ()
2752 {
2753         HBox* mode_box = manage(new HBox);
2754         mode_box->set_border_width (2);
2755         mode_box->set_spacing(4);
2756
2757         /* table containing mode buttons */
2758
2759         HBox* mouse_mode_button_box = manage (new HBox ());
2760
2761         if (Profile->get_sae()) {
2762                 mouse_mode_button_box->pack_start (mouse_move_button);
2763         } else {
2764                 mouse_mode_button_box->pack_start (mouse_move_button);
2765                 mouse_mode_button_box->pack_start (join_object_range_button);
2766                 mouse_mode_button_box->pack_start (mouse_select_button);
2767         }
2768
2769         mouse_mode_button_box->pack_start (mouse_zoom_button);
2770
2771         if (!Profile->get_sae()) {
2772                 mouse_mode_button_box->pack_start (mouse_gain_button);
2773         }
2774
2775         mouse_mode_button_box->pack_start (mouse_timefx_button);
2776         mouse_mode_button_box->pack_start (mouse_audition_button);
2777         mouse_mode_button_box->pack_start (internal_edit_button);
2778
2779         edit_mode_strings.push_back (edit_mode_to_string (Slide));
2780         if (!Profile->get_sae()) {
2781                 edit_mode_strings.push_back (edit_mode_to_string (Splice));
2782         }
2783         edit_mode_strings.push_back (edit_mode_to_string (Lock));
2784
2785         edit_mode_selector.set_name ("EditModeSelector");
2786         set_popdown_strings (edit_mode_selector, edit_mode_strings, true);
2787         edit_mode_selector.signal_changed().connect (sigc::mem_fun(*this, &Editor::edit_mode_selection_done));
2788
2789         mode_box->pack_start (edit_mode_selector);
2790         mode_box->pack_start (*mouse_mode_button_box);
2791
2792         _mouse_mode_tearoff = manage (new TearOff (*mode_box));
2793         _mouse_mode_tearoff->set_name ("MouseModeBase");
2794         _mouse_mode_tearoff->tearoff_window().signal_key_press_event().connect (sigc::bind (sigc::ptr_fun (relay_key_press), &_mouse_mode_tearoff->tearoff_window()), false);
2795
2796         if (Profile->get_sae()) {
2797                 _mouse_mode_tearoff->set_can_be_torn_off (false);
2798         }
2799
2800         _mouse_mode_tearoff->Detach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
2801                                                          &_mouse_mode_tearoff->tearoff_window()));
2802         _mouse_mode_tearoff->Attach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
2803                                                          &_mouse_mode_tearoff->tearoff_window(), 1));
2804         _mouse_mode_tearoff->Hidden.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
2805                                                          &_mouse_mode_tearoff->tearoff_window()));
2806         _mouse_mode_tearoff->Visible.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
2807                                                           &_mouse_mode_tearoff->tearoff_window(), 1));
2808
2809         mouse_move_button.set_mode (false);
2810         mouse_select_button.set_mode (false);
2811         mouse_gain_button.set_mode (false);
2812         mouse_zoom_button.set_mode (false);
2813         mouse_timefx_button.set_mode (false);
2814         mouse_audition_button.set_mode (false);
2815         join_object_range_button.set_mode (false);
2816
2817         mouse_move_button.set_name ("MouseModeButton");
2818         mouse_select_button.set_name ("MouseModeButton");
2819         mouse_gain_button.set_name ("MouseModeButton");
2820         mouse_zoom_button.set_name ("MouseModeButton");
2821         mouse_timefx_button.set_name ("MouseModeButton");
2822         mouse_audition_button.set_name ("MouseModeButton");
2823         internal_edit_button.set_name ("MouseModeButton");
2824         join_object_range_button.set_name ("MouseModeButton");
2825
2826         mouse_move_button.unset_flags (CAN_FOCUS);
2827         mouse_select_button.unset_flags (CAN_FOCUS);
2828         mouse_gain_button.unset_flags (CAN_FOCUS);
2829         mouse_zoom_button.unset_flags (CAN_FOCUS);
2830         mouse_timefx_button.unset_flags (CAN_FOCUS);
2831         mouse_audition_button.unset_flags (CAN_FOCUS);
2832         internal_edit_button.unset_flags (CAN_FOCUS);
2833         join_object_range_button.unset_flags (CAN_FOCUS);
2834
2835         /* Zoom */
2836
2837         _zoom_box.set_spacing (1);
2838         _zoom_box.set_border_width (0);
2839
2840         zoom_in_button.set_name ("EditorTimeButton");
2841         zoom_in_button.set_image (*(manage (new Image (::get_icon ("zoom_in")))));
2842         zoom_in_button.signal_clicked().connect (sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_step), false));
2843
2844         zoom_out_button.set_name ("EditorTimeButton");
2845         zoom_out_button.set_image (*(manage (new Image (::get_icon ("zoom_out")))));
2846         zoom_out_button.signal_clicked().connect (sigc::bind (sigc::mem_fun(*this, &Editor::temporal_zoom_step), true));
2847
2848         zoom_out_full_button.set_name ("EditorTimeButton");
2849         zoom_out_full_button.set_image (*(manage (new Image (::get_icon ("zoom_full")))));
2850         zoom_out_full_button.signal_clicked().connect (sigc::mem_fun(*this, &Editor::temporal_zoom_session));
2851
2852         zoom_focus_selector.set_name ("ZoomFocusSelector");
2853         set_popdown_strings (zoom_focus_selector, zoom_focus_strings, true);
2854         zoom_focus_selector.signal_changed().connect (sigc::mem_fun(*this, &Editor::zoom_focus_selection_done));
2855
2856         _zoom_box.pack_start (zoom_out_button, false, false);
2857         _zoom_box.pack_start (zoom_in_button, false, false);
2858         _zoom_box.pack_start (zoom_out_full_button, false, false);
2859
2860         _zoom_box.pack_start (zoom_focus_selector);
2861
2862         /* Track zoom buttons */
2863         tav_expand_button.set_name ("TrackHeightButton");
2864         tav_expand_button.set_size_request (-1, 20);
2865         tav_expand_button.add (*(manage (new Image (::get_icon ("tav_exp")))));
2866         RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("expand-tracks"));
2867         act->connect_proxy (tav_expand_button);
2868
2869         tav_shrink_button.set_name ("TrackHeightButton");
2870         tav_shrink_button.set_size_request (-1, 20);
2871         tav_shrink_button.add (*(manage (new Image (::get_icon ("tav_shrink")))));
2872         act = ActionManager::get_action (X_("Editor"), X_("shrink-tracks"));
2873         act->connect_proxy (tav_shrink_button);
2874
2875         _zoom_box.pack_start (tav_shrink_button);
2876         _zoom_box.pack_start (tav_expand_button);
2877
2878         _zoom_tearoff = manage (new TearOff (_zoom_box));
2879
2880         _zoom_tearoff->Detach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
2881                                                    &_zoom_tearoff->tearoff_window()));
2882         _zoom_tearoff->Attach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
2883                                                    &_zoom_tearoff->tearoff_window(), 0));
2884         _zoom_tearoff->Hidden.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
2885                                                    &_zoom_tearoff->tearoff_window()));
2886         _zoom_tearoff->Visible.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
2887                                                     &_zoom_tearoff->tearoff_window(), 0));
2888
2889         snap_box.set_spacing (1);
2890         snap_box.set_border_width (2);
2891
2892         snap_type_selector.set_name ("SnapTypeSelector");
2893         set_popdown_strings (snap_type_selector, snap_type_strings, true);
2894         snap_type_selector.signal_changed().connect (sigc::mem_fun(*this, &Editor::snap_type_selection_done));
2895
2896         snap_mode_selector.set_name ("SnapModeSelector");
2897         set_popdown_strings (snap_mode_selector, snap_mode_strings, true);
2898         snap_mode_selector.signal_changed().connect (sigc::mem_fun(*this, &Editor::snap_mode_selection_done));
2899
2900         edit_point_selector.set_name ("EditPointSelector");
2901         set_popdown_strings (edit_point_selector, edit_point_strings, true);
2902         edit_point_selector.signal_changed().connect (sigc::mem_fun(*this, &Editor::edit_point_selection_done));
2903
2904         snap_box.pack_start (snap_mode_selector, false, false);
2905         snap_box.pack_start (snap_type_selector, false, false);
2906         snap_box.pack_start (edit_point_selector, false, false);
2907
2908         /* Nudge */
2909
2910         HBox *nudge_box = manage (new HBox);
2911         nudge_box->set_spacing(1);
2912         nudge_box->set_border_width (2);
2913
2914         nudge_forward_button.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::nudge_forward_release), false);
2915         nudge_backward_button.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::nudge_backward_release), false);
2916
2917         nudge_box->pack_start (nudge_backward_button, false, false);
2918         nudge_box->pack_start (nudge_forward_button, false, false);
2919         nudge_box->pack_start (*nudge_clock, false, false);
2920
2921
2922         /* Pack everything in... */
2923
2924         HBox* hbox = manage (new HBox);
2925         hbox->set_spacing(10);
2926
2927         _tools_tearoff = manage (new TearOff (*hbox));
2928         _tools_tearoff->set_name ("MouseModeBase");
2929         _tools_tearoff->tearoff_window().signal_key_press_event().connect (sigc::bind (sigc::ptr_fun (relay_key_press), &_tools_tearoff->tearoff_window()), false);
2930
2931         if (Profile->get_sae()) {
2932                 _tools_tearoff->set_can_be_torn_off (false);
2933         }
2934
2935         _tools_tearoff->Detach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
2936                                                     &_tools_tearoff->tearoff_window()));
2937         _tools_tearoff->Attach.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
2938                                                     &_tools_tearoff->tearoff_window(), 0));
2939         _tools_tearoff->Hidden.connect (sigc::bind (sigc::mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&toolbar_hbox),
2940                                                     &_tools_tearoff->tearoff_window()));
2941         _tools_tearoff->Visible.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
2942                                                      &_tools_tearoff->tearoff_window(), 0));
2943
2944         toolbar_hbox.set_spacing (10);
2945         toolbar_hbox.set_border_width (1);
2946
2947         toolbar_hbox.pack_start (*_mouse_mode_tearoff, false, false);
2948         toolbar_hbox.pack_start (*_zoom_tearoff, false, false);
2949         toolbar_hbox.pack_start (*_tools_tearoff, false, false);
2950
2951         hbox->pack_start (snap_box, false, false);
2952         if (!Profile->get_small_screen()) {
2953                 hbox->pack_start (*nudge_box, false, false);
2954         } else {
2955                 ARDOUR_UI::instance()->editor_transport_box().pack_start (*nudge_box, false, false);
2956         }
2957         hbox->pack_start (panic_box, false, false);
2958
2959         hbox->show_all ();
2960
2961         toolbar_base.set_name ("ToolBarBase");
2962         toolbar_base.add (toolbar_hbox);
2963
2964         _toolbar_viewport.add (toolbar_base);
2965         /* stick to the required height but allow width to vary if there's not enough room */
2966         _toolbar_viewport.set_size_request (1, -1);
2967
2968         toolbar_frame.set_shadow_type (SHADOW_OUT);
2969         toolbar_frame.set_name ("BaseFrame");
2970         toolbar_frame.add (_toolbar_viewport);
2971
2972         DPIReset.connect (sigc::mem_fun (*this, &Editor::resize_text_widgets));
2973 }
2974
2975 void
2976 Editor::setup_tooltips ()
2977 {
2978         ARDOUR_UI::instance()->set_tip (mouse_move_button, _("Select/Move Objects"));
2979         ARDOUR_UI::instance()->set_tip (mouse_gain_button, _("Draw Region Gain"));
2980         ARDOUR_UI::instance()->set_tip (mouse_zoom_button, _("Select Zoom Range"));
2981         ARDOUR_UI::instance()->set_tip (mouse_timefx_button, _("Stretch/Shrink Regions and MIDI Notes"));
2982         ARDOUR_UI::instance()->set_tip (mouse_audition_button, _("Listen to Specific Regions"));
2983         ARDOUR_UI::instance()->set_tip (join_object_range_button, _("Select/Move Objects or Ranges"));
2984         ARDOUR_UI::instance()->set_tip (internal_edit_button, _("Edit Region Contents (e.g. notes)"));
2985         ARDOUR_UI::instance()->set_tip (*_group_tabs, _("Groups: click to (de)activate\nContext-click for other operations"));
2986         ARDOUR_UI::instance()->set_tip (nudge_forward_button, _("Nudge Region/Selection Forwards"));
2987         ARDOUR_UI::instance()->set_tip (nudge_backward_button, _("Nudge Region/Selection Backwards"));
2988         ARDOUR_UI::instance()->set_tip (zoom_in_button, _("Zoom In"));
2989         ARDOUR_UI::instance()->set_tip (zoom_out_button, _("Zoom Out"));
2990         ARDOUR_UI::instance()->set_tip (zoom_out_full_button, _("Zoom to Session"));
2991         ARDOUR_UI::instance()->set_tip (zoom_focus_selector, _("Zoom focus"));
2992         ARDOUR_UI::instance()->set_tip (tav_expand_button, _("Expand Tracks"));
2993         ARDOUR_UI::instance()->set_tip (tav_shrink_button, _("Shrink Tracks"));
2994         ARDOUR_UI::instance()->set_tip (snap_type_selector, _("Snap/Grid Units"));
2995         ARDOUR_UI::instance()->set_tip (snap_mode_selector, _("Snap/Grid Mode"));
2996         ARDOUR_UI::instance()->set_tip (edit_point_selector, _("Edit point"));
2997         ARDOUR_UI::instance()->set_tip (midi_sound_notes, _("Sound Notes"));
2998         ARDOUR_UI::instance()->set_tip (midi_panic_button, _("Send note off and reset controller messages on all MIDI channels"));
2999         ARDOUR_UI::instance()->set_tip (edit_mode_selector, _("Edit Mode"));
3000 }
3001
3002 void
3003 Editor::midi_panic ()
3004 {
3005         cerr << "MIDI panic\n";
3006
3007         if (_session) {
3008                 _session->midi_panic();
3009         }
3010 }
3011
3012 void
3013 Editor::setup_midi_toolbar ()
3014 {
3015         RefPtr<Action> act;
3016
3017         /* Midi sound notes */
3018         midi_sound_notes.add (*(manage (new Image (::get_icon("midi_sound_notes")))));
3019         midi_sound_notes.unset_flags (CAN_FOCUS);
3020
3021         /* Panic */
3022
3023         act = ActionManager::get_action (X_("MIDI"), X_("panic"));
3024         midi_panic_button.set_name("MidiPanicButton");
3025         act->connect_proxy (midi_panic_button);
3026
3027         panic_box.pack_start (midi_sound_notes , true, true);
3028         panic_box.pack_start (midi_panic_button, true, true);
3029 }
3030
3031 int
3032 Editor::convert_drop_to_paths (
3033                 vector<string>&                paths,
3034                 const RefPtr<Gdk::DragContext>& /*context*/,
3035                 gint                            /*x*/,
3036                 gint                            /*y*/,
3037                 const SelectionData&            data,
3038                 guint                           /*info*/,
3039                 guint                           /*time*/)
3040 {
3041         if (_session == 0) {
3042                 return -1;
3043         }
3044
3045         vector<string> uris = data.get_uris();
3046
3047         if (uris.empty()) {
3048
3049                 /* This is seriously fucked up. Nautilus doesn't say that its URI lists
3050                    are actually URI lists. So do it by hand.
3051                 */
3052
3053                 if (data.get_target() != "text/plain") {
3054                         return -1;
3055                 }
3056
3057                 /* Parse the "uri-list" format that Nautilus provides,
3058                    where each pathname is delimited by \r\n.
3059
3060                    THERE MAY BE NO NULL TERMINATING CHAR!!!
3061                 */
3062
3063                 string txt = data.get_text();
3064                 const char* p;
3065                 const char* q;
3066
3067                 p = (const char *) malloc (txt.length() + 1);
3068                 txt.copy ((char *) p, txt.length(), 0);
3069                 ((char*)p)[txt.length()] = '\0';
3070
3071                 while (p)
3072                 {
3073                         if (*p != '#')
3074                         {
3075                                 while (g_ascii_isspace (*p))
3076                                         p++;
3077
3078                                 q = p;
3079                                 while (*q && (*q != '\n') && (*q != '\r')) {
3080                                         q++;
3081                                 }
3082
3083                                 if (q > p)
3084                                 {
3085                                         q--;
3086                                         while (q > p && g_ascii_isspace (*q))
3087                                                 q--;
3088
3089                                         if (q > p)
3090                                         {
3091                                                 uris.push_back (string (p, q - p + 1));
3092                                         }
3093                                 }
3094                         }
3095                         p = strchr (p, '\n');
3096                         if (p)
3097                                 p++;
3098                 }
3099
3100                 free ((void*)p);
3101
3102                 if (uris.empty()) {
3103                         return -1;
3104                 }
3105         }
3106
3107         for (vector<string>::iterator i = uris.begin(); i != uris.end(); ++i) {
3108
3109                 if ((*i).substr (0,7) == "file://") {
3110
3111                         string p = *i;
3112                         PBD::url_decode (p);
3113
3114                         // scan forward past three slashes
3115
3116                         string::size_type slashcnt = 0;
3117                         string::size_type n = 0;
3118                         string::iterator x = p.begin();
3119
3120                         while (slashcnt < 3 && x != p.end()) {
3121                                 if ((*x) == '/') {
3122                                         slashcnt++;
3123                                 } else if (slashcnt == 3) {
3124                                         break;
3125                                 }
3126                                 ++n;
3127                                 ++x;
3128                         }
3129
3130                         if (slashcnt != 3 || x == p.end()) {
3131                                 error << _("malformed URL passed to drag-n-drop code") << endmsg;
3132                                 continue;
3133                         }
3134
3135                         paths.push_back (p.substr (n - 1));
3136                 }
3137         }
3138
3139         return 0;
3140 }
3141
3142 void
3143 Editor::new_tempo_section ()
3144
3145 {
3146 }
3147
3148 void
3149 Editor::map_transport_state ()
3150 {
3151         ENSURE_GUI_THREAD (*this, &Editor::map_transport_state)
3152
3153         if (_session && _session->transport_stopped()) {
3154                 have_pending_keyboard_selection = false;
3155         }
3156
3157         update_loop_range_view (true);
3158 }
3159
3160 /* UNDO/REDO */
3161
3162 Editor::State::State (PublicEditor const * e)
3163 {
3164         selection = new Selection (e);
3165 }
3166
3167 Editor::State::~State ()
3168 {
3169         delete selection;
3170 }
3171
3172 void
3173 Editor::begin_reversible_command (string name)
3174 {
3175         if (_session) {
3176                 _session->begin_reversible_command (name);
3177         }
3178 }
3179
3180 void
3181 Editor::begin_reversible_command (GQuark q)
3182 {
3183         if (_session) {
3184                 _session->begin_reversible_command (q);
3185         }
3186 }
3187
3188 void
3189 Editor::commit_reversible_command ()
3190 {
3191         if (_session) {
3192                 _session->commit_reversible_command ();
3193         }
3194 }
3195
3196 void
3197 Editor::history_changed ()
3198 {
3199         string label;
3200
3201         if (undo_action && _session) {
3202                 if (_session->undo_depth() == 0) {
3203                         label = _("Undo");
3204                 } else {
3205                         label = string_compose(_("Undo (%1)"), _session->next_undo());
3206                 }
3207                 undo_action->property_label() = label;
3208         }
3209
3210         if (redo_action && _session) {
3211                 if (_session->redo_depth() == 0) {
3212                         label = _("Redo");
3213                 } else {
3214                         label = string_compose(_("Redo (%1)"), _session->next_redo());
3215                 }
3216                 redo_action->property_label() = label;
3217         }
3218 }
3219
3220 void
3221 Editor::duplicate_dialog (bool with_dialog)
3222 {
3223         float times = 1.0f;
3224
3225         if (mouse_mode == MouseRange) {
3226                 if (selection->time.length() == 0) {
3227                         return;
3228                 }
3229         }
3230
3231         RegionSelection rs = get_regions_from_selection_and_entered ();
3232
3233         if (mouse_mode != MouseRange && rs.empty()) {
3234                 return;
3235         }
3236
3237         if (with_dialog) {
3238
3239                 ArdourDialog win (_("Duplicate"));
3240                 Label label (_("Number of duplications:"));
3241                 Adjustment adjustment (1.0, 1.0, 1000000.0, 1.0, 5.0);
3242                 SpinButton spinner (adjustment, 0.0, 1);
3243                 HBox hbox;
3244
3245                 win.get_vbox()->set_spacing (12);
3246                 win.get_vbox()->pack_start (hbox);
3247                 hbox.set_border_width (6);
3248                 hbox.pack_start (label, PACK_EXPAND_PADDING, 12);
3249
3250                 /* dialogs have ::add_action_widget() but that puts the spinner in the wrong
3251                    place, visually. so do this by hand.
3252                 */
3253
3254                 hbox.pack_start (spinner, PACK_EXPAND_PADDING, 12);
3255                 spinner.signal_activate().connect (sigc::bind (sigc::mem_fun (win, &ArdourDialog::response), RESPONSE_ACCEPT));
3256                 spinner.grab_focus();
3257
3258                 hbox.show ();
3259                 label.show ();
3260                 spinner.show ();
3261
3262                 win.add_button (Stock::CANCEL, RESPONSE_CANCEL);
3263                 win.add_button (_("Duplicate"), RESPONSE_ACCEPT);
3264                 win.set_default_response (RESPONSE_ACCEPT);
3265
3266                 win.set_position (WIN_POS_MOUSE);
3267
3268                 spinner.grab_focus ();
3269
3270                 switch (win.run ()) {
3271                 case RESPONSE_ACCEPT:
3272                         break;
3273                 default:
3274                         return;
3275                 }
3276
3277                 times = adjustment.get_value();
3278         }
3279
3280         if (mouse_mode == MouseRange) {
3281                 duplicate_selection (times);
3282         } else {
3283                 duplicate_some_regions (rs, times);
3284         }
3285 }
3286
3287 void
3288 Editor::set_edit_mode (EditMode m)
3289 {
3290         Config->set_edit_mode (m);
3291 }
3292
3293 void
3294 Editor::cycle_edit_mode ()
3295 {
3296         switch (Config->get_edit_mode()) {
3297         case Slide:
3298                 if (Profile->get_sae()) {
3299                         Config->set_edit_mode (Lock);
3300                 } else {
3301                         Config->set_edit_mode (Splice);
3302                 }
3303                 break;
3304         case Splice:
3305                 Config->set_edit_mode (Lock);
3306                 break;
3307         case Lock:
3308                 Config->set_edit_mode (Slide);
3309                 break;
3310         }
3311 }
3312
3313 void
3314 Editor::edit_mode_selection_done ()
3315 {
3316         string s = edit_mode_selector.get_active_text ();
3317
3318         if (!s.empty()) {
3319                 Config->set_edit_mode (string_to_edit_mode (s));
3320         }
3321 }
3322
3323 void
3324 Editor::snap_type_selection_done ()
3325 {
3326         string choice = snap_type_selector.get_active_text();
3327         SnapType snaptype = SnapToBeat;
3328
3329         if (choice == _("Beats/2")) {
3330                 snaptype = SnapToBeatDiv2;
3331         } else if (choice == _("Beats/3")) {
3332                 snaptype = SnapToBeatDiv3;
3333         } else if (choice == _("Beats/4")) {
3334                 snaptype = SnapToBeatDiv4;
3335         } else if (choice == _("Beats/5")) {
3336                 snaptype = SnapToBeatDiv5;
3337         } else if (choice == _("Beats/6")) {
3338                 snaptype = SnapToBeatDiv6;
3339         } else if (choice == _("Beats/7")) {
3340                 snaptype = SnapToBeatDiv7;
3341         } else if (choice == _("Beats/8")) {
3342                 snaptype = SnapToBeatDiv8;
3343         } else if (choice == _("Beats/10")) {
3344                 snaptype = SnapToBeatDiv10;
3345         } else if (choice == _("Beats/12")) {
3346                 snaptype = SnapToBeatDiv12;
3347         } else if (choice == _("Beats/14")) {
3348                 snaptype = SnapToBeatDiv14;
3349         } else if (choice == _("Beats/16")) {
3350                 snaptype = SnapToBeatDiv16;
3351         } else if (choice == _("Beats/20")) {
3352                 snaptype = SnapToBeatDiv20;
3353         } else if (choice == _("Beats/24")) {
3354                 snaptype = SnapToBeatDiv24;
3355         } else if (choice == _("Beats/28")) {
3356                 snaptype = SnapToBeatDiv28;
3357         } else if (choice == _("Beats/32")) {
3358                 snaptype = SnapToBeatDiv32;
3359         } else if (choice == _("Beats")) {
3360                 snaptype = SnapToBeat;
3361         } else if (choice == _("Bars")) {
3362                 snaptype = SnapToBar;
3363         } else if (choice == _("Marks")) {
3364                 snaptype = SnapToMark;
3365         } else if (choice == _("Region starts")) {
3366                 snaptype = SnapToRegionStart;
3367         } else if (choice == _("Region ends")) {
3368                 snaptype = SnapToRegionEnd;
3369         } else if (choice == _("Region bounds")) {
3370                 snaptype = SnapToRegionBoundary;
3371         } else if (choice == _("Region syncs")) {
3372                 snaptype = SnapToRegionSync;
3373         } else if (choice == _("CD Frames")) {
3374                 snaptype = SnapToCDFrame;
3375         } else if (choice == _("Timecode Frames")) {
3376                 snaptype = SnapToTimecodeFrame;
3377         } else if (choice == _("Timecode Seconds")) {
3378                 snaptype = SnapToTimecodeSeconds;
3379         } else if (choice == _("Timecode Minutes")) {
3380                 snaptype = SnapToTimecodeMinutes;
3381         } else if (choice == _("Seconds")) {
3382                 snaptype = SnapToSeconds;
3383         } else if (choice == _("Minutes")) {
3384                 snaptype = SnapToMinutes;
3385         }
3386
3387         RefPtr<RadioAction> ract = snap_type_action (snaptype);
3388         if (ract) {
3389                 ract->set_active ();
3390         }
3391 }
3392
3393 void
3394 Editor::snap_mode_selection_done ()
3395 {
3396         string choice = snap_mode_selector.get_active_text();
3397         SnapMode mode = SnapNormal;
3398
3399         if (choice == _("No Grid")) {
3400                 mode = SnapOff;
3401         } else if (choice == _("Grid")) {
3402                 mode = SnapNormal;
3403         } else if (choice == _("Magnetic")) {
3404                 mode = SnapMagnetic;
3405         }
3406
3407         RefPtr<RadioAction> ract = snap_mode_action (mode);
3408
3409         if (ract) {
3410                 ract->set_active (true);
3411         }
3412 }
3413
3414 void
3415 Editor::cycle_edit_point (bool with_marker)
3416 {
3417         switch (_edit_point) {
3418         case EditAtMouse:
3419                 set_edit_point_preference (EditAtPlayhead);
3420                 break;
3421         case EditAtPlayhead:
3422                 if (with_marker) {
3423                         set_edit_point_preference (EditAtSelectedMarker);
3424                 } else {
3425                         set_edit_point_preference (EditAtMouse);
3426                 }
3427                 break;
3428         case EditAtSelectedMarker:
3429                 set_edit_point_preference (EditAtMouse);
3430                 break;
3431         }
3432 }
3433
3434 void
3435 Editor::edit_point_selection_done ()
3436 {
3437         string choice = edit_point_selector.get_active_text();
3438         EditPoint ep = EditAtSelectedMarker;
3439
3440         if (choice == _("Marker")) {
3441                 set_edit_point_preference (EditAtSelectedMarker);
3442         } else if (choice == _("Playhead")) {
3443                 set_edit_point_preference (EditAtPlayhead);
3444         } else {
3445                 set_edit_point_preference (EditAtMouse);
3446         }
3447
3448         RefPtr<RadioAction> ract = edit_point_action (ep);
3449
3450         if (ract) {
3451                 ract->set_active (true);
3452         }
3453 }
3454
3455 void
3456 Editor::zoom_focus_selection_done ()
3457 {
3458         string choice = zoom_focus_selector.get_active_text();
3459         ZoomFocus focus_type = ZoomFocusLeft;
3460
3461         if (choice == _("Left")) {
3462                 focus_type = ZoomFocusLeft;
3463         } else if (choice == _("Right")) {
3464                 focus_type = ZoomFocusRight;
3465         } else if (choice == _("Center")) {
3466                 focus_type = ZoomFocusCenter;
3467         } else if (choice == _("Playhead")) {
3468                 focus_type = ZoomFocusPlayhead;
3469         } else if (choice == _("Mouse")) {
3470                 focus_type = ZoomFocusMouse;
3471         } else if (choice == _("Edit point")) {
3472                 focus_type = ZoomFocusEdit;
3473         }
3474
3475         RefPtr<RadioAction> ract = zoom_focus_action (focus_type);
3476
3477         if (ract) {
3478                 ract->set_active ();
3479         }
3480 }
3481
3482 bool
3483 Editor::edit_controls_button_release (GdkEventButton* ev)
3484 {
3485         if (Keyboard::is_context_menu_event (ev)) {
3486                 ARDOUR_UI::instance()->add_route (this);
3487         } else if (ev->button == 1) {
3488                 selection->clear_tracks ();
3489         }
3490
3491         return true;
3492 }
3493
3494 bool
3495 Editor::mouse_select_button_release (GdkEventButton* ev)
3496 {
3497         /* this handles just right-clicks */
3498
3499         if (ev->button != 3) {
3500                 return false;
3501         }
3502
3503         return true;
3504 }
3505
3506 void
3507 Editor::set_zoom_focus (ZoomFocus f)
3508 {
3509         string str = zoom_focus_strings[(int)f];
3510
3511         if (str != zoom_focus_selector.get_active_text()) {
3512                 zoom_focus_selector.set_active_text (str);
3513         }
3514
3515         if (zoom_focus != f) {
3516                 zoom_focus = f;
3517                 instant_save ();
3518         }
3519 }
3520
3521 void
3522 Editor::ensure_float (Window& win)
3523 {
3524         win.set_transient_for (*this);
3525 }
3526
3527 void
3528 Editor::pane_allocation_handler (Allocation &alloc, Paned* which)
3529 {
3530         /* recover or initialize pane positions. do this here rather than earlier because
3531            we don't want the positions to change the child allocations, which they seem to do.
3532          */
3533
3534         int pos;
3535         XMLProperty* prop;
3536         char buf[32];
3537         XMLNode* node = ARDOUR_UI::instance()->editor_settings();
3538
3539         enum Pane {
3540                 Horizontal = 0x1,
3541                 Vertical = 0x2
3542         };
3543
3544         static Pane done;
3545
3546         XMLNode* geometry = find_named_node (*node, "geometry");
3547
3548         if (which == static_cast<Paned*> (&edit_pane)) {
3549
3550                 if (done & Horizontal) {
3551                         return;
3552                 }
3553
3554                 if (geometry && (prop = geometry->property ("notebook-shrunk"))) {
3555                         _notebook_shrunk = string_is_affirmative (prop->value ());
3556                 }
3557
3558                 if (geometry && (prop = geometry->property ("pre-maximal-horizontal-pane-position"))) {
3559                         pre_maximal_horizontal_pane_position = atoi (prop->value ());
3560                 }
3561
3562                 if (!geometry || (prop = geometry->property ("edit-horizontal-pane-pos")) == 0) {
3563                         /* initial allocation is 90% to canvas, 10% to notebook */
3564                         pos = (int) floor (alloc.get_width() * 0.90f);
3565                         snprintf (buf, sizeof(buf), "%d", pos);
3566                 } else {
3567                         pos = atoi (prop->value());
3568                 }
3569
3570                 if (GTK_WIDGET(edit_pane.gobj())->allocation.width > pos) {
3571                         edit_pane.set_position (pos);
3572                         if (pre_maximal_horizontal_pane_position == 0) {
3573                                 pre_maximal_horizontal_pane_position = pos;
3574                         }
3575                 }
3576
3577                 done = (Pane) (done | Horizontal);
3578
3579         } else if (which == static_cast<Paned*> (&editor_summary_pane)) {
3580
3581                 if (done & Vertical) {
3582                         return;
3583                 }
3584
3585                 if (!geometry || (prop = geometry->property ("edit-vertical-pane-pos")) == 0) {
3586                         /* initial allocation is 90% to canvas, 10% to summary */
3587                         pos = (int) floor (alloc.get_height() * 0.90f);
3588                         snprintf (buf, sizeof(buf), "%d", pos);
3589                 } else {
3590                         pos = atoi (prop->value());
3591                 }
3592
3593                 if (GTK_WIDGET(editor_summary_pane.gobj())->allocation.height > pos) {
3594                         editor_summary_pane.set_position (pos);
3595                         pre_maximal_vertical_pane_position = pos;
3596                 }
3597
3598                 done = (Pane) (done | Vertical);
3599         }
3600 }
3601
3602 void
3603 Editor::detach_tearoff (Box* /*b*/, Window* /*w*/)
3604 {
3605         if (_tools_tearoff->torn_off() && _mouse_mode_tearoff->torn_off()) {
3606                 top_hbox.remove (toolbar_frame);
3607         }
3608 }
3609
3610 void
3611 Editor::reattach_tearoff (Box* /*b*/, Window* /*w*/, int32_t /*n*/)
3612 {
3613         if (toolbar_frame.get_parent() == 0) {
3614                 top_hbox.pack_end (toolbar_frame);
3615         }
3616 }
3617
3618 void
3619 Editor::set_show_measures (bool yn)
3620 {
3621         if (_show_measures != yn) {
3622                 hide_measures ();
3623
3624                 if ((_show_measures = yn) == true) {
3625                         if (tempo_lines)
3626                                 tempo_lines->show();
3627                         draw_measures ();
3628                 }
3629                 instant_save ();
3630         }
3631 }
3632
3633 void
3634 Editor::toggle_follow_playhead ()
3635 {
3636         RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-follow-playhead"));
3637         if (act) {
3638                 RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
3639                 set_follow_playhead (tact->get_active());
3640         }
3641 }
3642
3643 /** @param yn true to follow playhead, otherwise false.
3644  *  @param catch_up true to reset the editor view to show the playhead (if yn == true), otherwise false.
3645  */
3646 void
3647 Editor::set_follow_playhead (bool yn, bool catch_up)
3648 {
3649         if (_follow_playhead != yn) {
3650                 if ((_follow_playhead = yn) == true && catch_up) {
3651                         /* catch up */
3652                         reset_x_origin_to_follow_playhead ();
3653                 }
3654                 instant_save ();
3655         }
3656 }
3657
3658 void
3659 Editor::toggle_stationary_playhead ()
3660 {
3661         RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-stationary-playhead"));
3662         if (act) {
3663                 RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
3664                 set_stationary_playhead (tact->get_active());
3665         }
3666 }
3667
3668 void
3669 Editor::set_stationary_playhead (bool yn)
3670 {
3671         if (_stationary_playhead != yn) {
3672                 if ((_stationary_playhead = yn) == true) {
3673                         /* catch up */
3674                         // FIXME need a 3.0 equivalent of this 2.X call
3675                         // update_current_screen ();
3676                 }
3677                 instant_save ();
3678         }
3679 }
3680
3681 void
3682 Editor::toggle_xfade_active (boost::weak_ptr<Crossfade> wxfade)
3683 {
3684         boost::shared_ptr<Crossfade> xfade (wxfade.lock());
3685         if (xfade) {
3686                 xfade->set_active (!xfade->active());
3687         }
3688 }
3689
3690 void
3691 Editor::toggle_xfade_length (boost::weak_ptr<Crossfade> wxfade)
3692 {
3693         boost::shared_ptr<Crossfade> xfade (wxfade.lock());
3694         if (xfade) {
3695                 xfade->set_follow_overlap (!xfade->following_overlap());
3696         }
3697 }
3698
3699 void
3700 Editor::edit_xfade (boost::weak_ptr<Crossfade> wxfade)
3701 {
3702         boost::shared_ptr<Crossfade> xfade (wxfade.lock());
3703
3704         if (!xfade) {
3705                 return;
3706         }
3707
3708         CrossfadeEditor cew (_session, xfade, xfade->fade_in().get_min_y(), 1.0);
3709
3710         ensure_float (cew);
3711
3712         switch (cew.run ()) {
3713         case RESPONSE_ACCEPT:
3714                 break;
3715         default:
3716                 return;
3717         }
3718
3719         cew.apply ();
3720         PropertyChange all_crossfade_properties;
3721         all_crossfade_properties.add (ARDOUR::Properties::active);
3722         all_crossfade_properties.add (ARDOUR::Properties::follow_overlap);
3723         xfade->PropertyChanged (all_crossfade_properties);
3724 }
3725
3726 PlaylistSelector&
3727 Editor::playlist_selector () const
3728 {
3729         return *_playlist_selector;
3730 }
3731
3732 Evoral::MusicalTime
3733 Editor::get_grid_type_as_beats (bool& success, framepos_t position)
3734 {
3735         success = true;
3736
3737         switch (_snap_type) {
3738         case SnapToBeat:
3739                 return 1.0;
3740                 break;
3741
3742         case SnapToBeatDiv32:
3743                 return 1.0/32.0;
3744                 break;
3745         case SnapToBeatDiv28:
3746                 return 1.0/28.0;
3747                 break;
3748         case SnapToBeatDiv24:
3749                 return 1.0/24.0;
3750                 break;
3751         case SnapToBeatDiv20:
3752                 return 1.0/20.0;
3753                 break;
3754         case SnapToBeatDiv16:
3755                 return 1.0/16.0;
3756                 break;
3757         case SnapToBeatDiv14:
3758                 return 1.0/14.0;
3759                 break;
3760         case SnapToBeatDiv12:
3761                 return 1.0/12.0;
3762                 break;
3763         case SnapToBeatDiv10:
3764                 return 1.0/10.0;
3765                 break;
3766         case SnapToBeatDiv8:
3767                 return 1.0/8.0;
3768                 break;
3769         case SnapToBeatDiv7:
3770                 return 1.0/7.0;
3771                 break;
3772         case SnapToBeatDiv6:
3773                 return 1.0/6.0;
3774                 break;
3775         case SnapToBeatDiv5:
3776                 return 1.0/5.0;
3777                 break;
3778         case SnapToBeatDiv4:
3779                 return 1.0/4.0;
3780                 break;
3781         case SnapToBeatDiv3:
3782                 return 1.0/3.0;
3783                 break;
3784         case SnapToBeatDiv2:
3785                 return 1.0/2.0;
3786                 break;
3787
3788         case SnapToBar:
3789                 if (_session) {
3790                         return _session->tempo_map().meter_at (position).beats_per_bar();
3791                 }
3792                 break;
3793
3794         case SnapToCDFrame:
3795         case SnapToTimecodeFrame:
3796         case SnapToTimecodeSeconds:
3797         case SnapToTimecodeMinutes:
3798         case SnapToSeconds:
3799         case SnapToMinutes:
3800         case SnapToRegionStart:
3801         case SnapToRegionEnd:
3802         case SnapToRegionSync:
3803         case SnapToRegionBoundary:
3804         default:
3805                 success = false;
3806                 break;
3807         }
3808
3809         return 0.0;
3810 }
3811
3812 framecnt_t
3813 Editor::get_nudge_distance (framepos_t pos, framecnt_t& next)
3814 {
3815         framecnt_t ret;
3816
3817         ret = nudge_clock->current_duration (pos);
3818         next = ret + 1; /* XXXX fix me */
3819
3820         return ret;
3821 }
3822
3823 int
3824 Editor::playlist_deletion_dialog (boost::shared_ptr<Playlist> pl)
3825 {
3826         ArdourDialog dialog (_("Playlist Deletion"));
3827         Label  label (string_compose (_("Playlist %1 is currently unused.\n"
3828                                         "If it is kept, its audio files will not be cleaned.\n"
3829                                         "If it is deleted, audio files used by it alone will be cleaned."),
3830                                       pl->name()));
3831
3832         dialog.set_position (WIN_POS_CENTER);
3833         dialog.get_vbox()->pack_start (label);
3834
3835         label.show ();
3836
3837         dialog.add_button (_("Delete Playlist"), RESPONSE_ACCEPT);
3838         dialog.add_button (_("Keep Playlist"), RESPONSE_REJECT);
3839         dialog.add_button (_("Cancel"), RESPONSE_CANCEL);
3840
3841         switch (dialog.run ()) {
3842         case RESPONSE_ACCEPT:
3843                 /* delete the playlist */
3844                 return 0;
3845                 break;
3846
3847         case RESPONSE_REJECT:
3848                 /* keep the playlist */
3849                 return 1;
3850                 break;
3851
3852         default:
3853                 break;
3854         }
3855
3856         return -1;
3857 }
3858
3859 bool
3860 Editor::audio_region_selection_covers (framepos_t where)
3861 {
3862         for (RegionSelection::iterator a = selection->regions.begin(); a != selection->regions.end(); ++a) {
3863                 if ((*a)->region()->covers (where)) {
3864                         return true;
3865                 }
3866         }
3867
3868         return false;
3869 }
3870
3871 void
3872 Editor::prepare_for_cleanup ()
3873 {
3874         cut_buffer->clear_regions ();
3875         cut_buffer->clear_playlists ();
3876
3877         selection->clear_regions ();
3878         selection->clear_playlists ();
3879
3880         _regions->suspend_redisplay ();
3881 }
3882
3883 void
3884 Editor::finish_cleanup ()
3885 {
3886         _regions->resume_redisplay ();
3887 }
3888
3889 Location*
3890 Editor::transport_loop_location()
3891 {
3892         if (_session) {
3893                 return _session->locations()->auto_loop_location();
3894         } else {
3895                 return 0;
3896         }
3897 }
3898
3899 Location*
3900 Editor::transport_punch_location()
3901 {
3902         if (_session) {
3903                 return _session->locations()->auto_punch_location();
3904         } else {
3905                 return 0;
3906         }
3907 }
3908
3909 bool
3910 Editor::control_layout_scroll (GdkEventScroll* ev)
3911 {
3912         if (Keyboard::some_magic_widget_has_focus()) {
3913                 return false;
3914         }
3915
3916         switch (ev->direction) {
3917         case GDK_SCROLL_UP:
3918                 scroll_tracks_up_line ();
3919                 return true;
3920                 break;
3921
3922         case GDK_SCROLL_DOWN:
3923                 scroll_tracks_down_line ();
3924                 return true;
3925
3926         default:
3927                 /* no left/right handling yet */
3928                 break;
3929         }
3930
3931         return false;
3932 }
3933
3934 void
3935 Editor::session_state_saved (string)
3936 {
3937         update_title ();
3938         _snapshots->redisplay ();
3939 }
3940
3941 void
3942 Editor::maximise_editing_space ()
3943 {
3944         _mouse_mode_tearoff->set_visible (false);
3945         _tools_tearoff->set_visible (false);
3946         _zoom_tearoff->set_visible (false);
3947
3948         pre_maximal_horizontal_pane_position = edit_pane.get_position ();
3949         pre_maximal_vertical_pane_position = editor_summary_pane.get_position ();
3950         pre_maximal_editor_width = this->get_width ();
3951         pre_maximal_editor_height = this->get_height ();
3952
3953         if (post_maximal_horizontal_pane_position == 0) {
3954                 post_maximal_horizontal_pane_position = edit_pane.get_width();
3955         }
3956
3957         if (post_maximal_vertical_pane_position == 0) {
3958                 post_maximal_vertical_pane_position = editor_summary_pane.get_height();
3959         }
3960
3961         fullscreen ();
3962
3963         if (post_maximal_editor_width) {
3964                 edit_pane.set_position (post_maximal_horizontal_pane_position -
3965                         abs(post_maximal_editor_width - pre_maximal_editor_width));
3966         } else {
3967                 edit_pane.set_position (post_maximal_horizontal_pane_position);
3968         }
3969
3970         /* Hack: we must do this in an idle handler for it to work; see comment in
3971            restore_editing_space()
3972         */
3973
3974         Glib::signal_idle().connect (
3975                 sigc::bind (
3976                         sigc::mem_fun (*this, &Editor::idle_reset_vertical_pane_position),
3977                         post_maximal_vertical_pane_position
3978                         )
3979                 );
3980
3981         if (Config->get_keep_tearoffs()) {
3982                 _mouse_mode_tearoff->set_visible (true);
3983                 _tools_tearoff->set_visible (true);
3984                 if (Config->get_show_zoom_tools ()) {
3985                         _zoom_tearoff->set_visible (true);
3986                 }
3987         }
3988
3989 }
3990
3991 bool
3992 Editor::idle_reset_vertical_pane_position (int p)
3993 {
3994         editor_summary_pane.set_position (p);
3995         return false;
3996 }
3997
3998 void
3999 Editor::restore_editing_space ()
4000 {
4001         // user changed width/height of panes during fullscreen
4002
4003         if (post_maximal_horizontal_pane_position != edit_pane.get_position()) {
4004                 post_maximal_horizontal_pane_position = edit_pane.get_position();
4005         }
4006
4007         if (post_maximal_vertical_pane_position != editor_summary_pane.get_position()) {
4008                 post_maximal_vertical_pane_position = editor_summary_pane.get_position();
4009         }
4010
4011         unfullscreen();
4012
4013         _mouse_mode_tearoff->set_visible (true);
4014         _tools_tearoff->set_visible (true);
4015         if (Config->get_show_zoom_tools ()) {
4016                 _zoom_tearoff->set_visible (true);
4017         }
4018         post_maximal_editor_width = this->get_width();
4019         post_maximal_editor_height = this->get_height();
4020
4021         edit_pane.set_position (pre_maximal_horizontal_pane_position + abs(this->get_width() - pre_maximal_editor_width));
4022
4023         /* This is a bit of a hack, but it seems that if you set the vertical pane position
4024            here it gets reset to some wrong value after this method has finished.  Doing
4025            the setup in an idle callback seems to work.
4026         */
4027         Glib::signal_idle().connect (
4028                 sigc::bind (
4029                         sigc::mem_fun (*this, &Editor::idle_reset_vertical_pane_position),
4030                         pre_maximal_vertical_pane_position
4031                         )
4032                 );
4033 }
4034
4035 /**
4036  *  Make new playlists for a given track and also any others that belong
4037  *  to the same active route group with the `edit' property.
4038  *  @param v Track.
4039  */
4040
4041 void
4042 Editor::new_playlists (TimeAxisView* v)
4043 {
4044         begin_reversible_command (_("new playlists"));
4045         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4046         _session->playlists->get (playlists);
4047         mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::edit.property_id);
4048         commit_reversible_command ();
4049 }
4050
4051 /**
4052  *  Use a copy of the current playlist for a given track and also any others that belong
4053  *  to the same active route group with the `edit' property.
4054  *  @param v Track.
4055  */
4056
4057 void
4058 Editor::copy_playlists (TimeAxisView* v)
4059 {
4060         begin_reversible_command (_("copy playlists"));
4061         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4062         _session->playlists->get (playlists);
4063         mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::edit.property_id);
4064         commit_reversible_command ();
4065 }
4066
4067 /** Clear the current playlist for a given track and also any others that belong
4068  *  to the same active route group with the `edit' property.
4069  *  @param v Track.
4070  */
4071
4072 void
4073 Editor::clear_playlists (TimeAxisView* v)
4074 {
4075         begin_reversible_command (_("clear playlists"));
4076         vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
4077         _session->playlists->get (playlists);
4078         mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::edit.property_id);
4079         commit_reversible_command ();
4080 }
4081
4082 void
4083 Editor::mapped_use_new_playlist (RouteTimeAxisView& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
4084 {
4085         atv.use_new_playlist (sz > 1 ? false : true, playlists);
4086 }
4087
4088 void
4089 Editor::mapped_use_copy_playlist (RouteTimeAxisView& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
4090 {
4091         atv.use_copy_playlist (sz > 1 ? false : true, playlists);
4092 }
4093
4094 void
4095 Editor::mapped_clear_playlist (RouteTimeAxisView& atv, uint32_t /*sz*/)
4096 {
4097         atv.clear_playlist ();
4098 }
4099
4100 bool
4101 Editor::on_key_press_event (GdkEventKey* ev)
4102 {
4103         return key_press_focus_accelerator_handler (*this, ev);
4104 }
4105
4106 bool
4107 Editor::on_key_release_event (GdkEventKey* ev)
4108 {
4109         return Gtk::Window::on_key_release_event (ev);
4110         // return key_press_focus_accelerator_handler (*this, ev);
4111 }
4112
4113 /** Queue up a change to the viewport x origin.
4114  *  @param frame New x origin.
4115  */
4116 void
4117 Editor::reset_x_origin (framepos_t frame)
4118 {
4119         queue_visual_change (frame);
4120 }
4121
4122 void
4123 Editor::reset_y_origin (double y)
4124 {
4125         queue_visual_change_y (y);
4126 }
4127
4128 void
4129 Editor::reset_zoom (double fpu)
4130 {
4131         queue_visual_change (fpu);
4132 }
4133
4134 void
4135 Editor::reposition_and_zoom (framepos_t frame, double fpu)
4136 {
4137         reset_x_origin (frame);
4138         reset_zoom (fpu);
4139
4140         if (!no_save_visual) {
4141                 undo_visual_stack.push_back (current_visual_state(false));
4142         }
4143 }
4144
4145 Editor::VisualState::VisualState ()
4146         : gui_state (new GUIObjectState)
4147 {
4148 }
4149
4150 Editor::VisualState::~VisualState ()
4151 {
4152         delete gui_state;
4153 }
4154
4155 Editor::VisualState*
4156 Editor::current_visual_state (bool with_tracks)
4157 {
4158         VisualState* vs = new VisualState;
4159         vs->y_position = vertical_adjustment.get_value();
4160         vs->frames_per_unit = frames_per_unit;
4161         vs->leftmost_frame = leftmost_frame;
4162         vs->zoom_focus = zoom_focus;
4163
4164         if (with_tracks) {
4165                 *(vs->gui_state) = *ARDOUR_UI::instance()->gui_object_state;
4166         }
4167
4168         return vs;
4169 }
4170
4171 void
4172 Editor::undo_visual_state ()
4173 {
4174         if (undo_visual_stack.empty()) {
4175                 return;
4176         }
4177
4178         redo_visual_stack.push_back (current_visual_state());
4179
4180         VisualState* vs = undo_visual_stack.back();
4181         undo_visual_stack.pop_back();
4182         use_visual_state (*vs);
4183 }
4184
4185 void
4186 Editor::redo_visual_state ()
4187 {
4188         if (redo_visual_stack.empty()) {
4189                 return;
4190         }
4191
4192         undo_visual_stack.push_back (current_visual_state());
4193
4194         VisualState* vs = redo_visual_stack.back();
4195         redo_visual_stack.pop_back();
4196         use_visual_state (*vs);
4197 }
4198
4199 void
4200 Editor::swap_visual_state ()
4201 {
4202         if (undo_visual_stack.empty()) {
4203                 redo_visual_state ();
4204         } else {
4205                 undo_visual_state ();
4206         }
4207 }
4208
4209 void
4210 Editor::use_visual_state (VisualState& vs)
4211 {
4212         no_save_visual = true;
4213
4214         _routes->suspend_redisplay ();
4215
4216         vertical_adjustment.set_value (vs.y_position);
4217
4218         set_zoom_focus (vs.zoom_focus);
4219         reposition_and_zoom (vs.leftmost_frame, vs.frames_per_unit);
4220
4221         *ARDOUR_UI::instance()->gui_object_state = *vs.gui_state;
4222
4223         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4224                 (*i)->reset_visual_state ();
4225         }
4226
4227         _routes->update_visibility ();
4228         _routes->resume_redisplay ();
4229
4230         no_save_visual = false;
4231 }
4232
4233 void
4234 Editor::set_frames_per_unit (double fpu)
4235 {
4236         /* this is the core function that controls the zoom level of the canvas. it is called
4237            whenever one or more calls are made to reset_zoom(). it executes in an idle handler.
4238         */
4239
4240         if (fpu == frames_per_unit) {
4241                 return;
4242         }
4243
4244         if (fpu < 2.0) {
4245                 fpu = 2.0;
4246         }
4247
4248
4249         /* don't allow zooms that fit more than the maximum number
4250            of frames into an 800 pixel wide space.
4251         */
4252
4253         if (max_framepos / fpu < 800.0) {
4254                 return;
4255         }
4256
4257         if (tempo_lines)
4258                 tempo_lines->tempo_map_changed();
4259
4260         frames_per_unit = fpu;
4261         post_zoom ();
4262 }
4263
4264 void
4265 Editor::post_zoom ()
4266 {
4267         // convert fpu to frame count
4268
4269         framepos_t frames = (framepos_t) floor (frames_per_unit * _canvas_width);
4270
4271         if (frames_per_unit != zoom_range_clock->current_duration()) {
4272                 zoom_range_clock->set (frames);
4273         }
4274
4275         if (mouse_mode == MouseRange && selection->time.start () != selection->time.end_frame ()) {
4276                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4277                         (*i)->reshow_selection (selection->time);
4278                 }
4279         }
4280
4281         ZoomChanged (); /* EMIT_SIGNAL */
4282
4283         //reset_scrolling_region ();
4284
4285         if (playhead_cursor) {
4286                 playhead_cursor->set_position (playhead_cursor->current_frame);
4287         }
4288
4289         refresh_location_display();
4290         _summary->set_overlays_dirty ();
4291
4292         update_marker_labels ();
4293
4294         instant_save ();
4295 }
4296
4297 void
4298 Editor::queue_visual_change (framepos_t where)
4299 {
4300         pending_visual_change.add (VisualChange::TimeOrigin);
4301         pending_visual_change.time_origin = where;
4302         ensure_visual_change_idle_handler ();
4303 }
4304
4305 void
4306 Editor::queue_visual_change (double fpu)
4307 {
4308         pending_visual_change.add (VisualChange::ZoomLevel);
4309         pending_visual_change.frames_per_unit = fpu;
4310
4311         ensure_visual_change_idle_handler ();
4312 }
4313
4314 void
4315 Editor::queue_visual_change_y (double y)
4316 {
4317         pending_visual_change.add (VisualChange::YOrigin);
4318         pending_visual_change.y_origin = y;
4319
4320         ensure_visual_change_idle_handler ();
4321 }
4322
4323 void
4324 Editor::ensure_visual_change_idle_handler ()
4325 {
4326         if (pending_visual_change.idle_handler_id < 0) {
4327                 pending_visual_change.idle_handler_id = g_idle_add (_idle_visual_changer, this);
4328         }
4329 }
4330
4331 int
4332 Editor::_idle_visual_changer (void* arg)
4333 {
4334         return static_cast<Editor*>(arg)->idle_visual_changer ();
4335 }
4336
4337 int
4338 Editor::idle_visual_changer ()
4339 {
4340         VisualChange::Type p = pending_visual_change.pending;
4341         pending_visual_change.pending = (VisualChange::Type) 0;
4342
4343         double const last_time_origin = horizontal_position ();
4344
4345         if (p & VisualChange::TimeOrigin) {
4346                 /* This is a bit of a hack, but set_frames_per_unit
4347                    below will (if called) end up with the
4348                    CrossfadeViews looking at Editor::leftmost_frame,
4349                    and if we're changing origin and zoom in the same
4350                    operation it will be the wrong value unless we
4351                    update it here.
4352                 */
4353
4354                 leftmost_frame = pending_visual_change.time_origin;
4355         }
4356
4357         if (p & VisualChange::ZoomLevel) {
4358                 set_frames_per_unit (pending_visual_change.frames_per_unit);
4359
4360                 compute_fixed_ruler_scale ();
4361                 compute_current_bbt_points(pending_visual_change.time_origin, pending_visual_change.time_origin + current_page_frames());
4362                 compute_bbt_ruler_scale (pending_visual_change.time_origin, pending_visual_change.time_origin + current_page_frames());
4363                 update_tempo_based_rulers ();
4364         }
4365         if (p & VisualChange::TimeOrigin) {
4366                 set_horizontal_position (pending_visual_change.time_origin / frames_per_unit);
4367         }
4368         if (p & VisualChange::YOrigin) {
4369                 vertical_adjustment.set_value (pending_visual_change.y_origin);
4370         }
4371
4372         if (last_time_origin == horizontal_position ()) {
4373                 /* changed signal not emitted */
4374                 update_fixed_rulers ();
4375                 redisplay_tempo (true);
4376         }
4377
4378         _summary->set_overlays_dirty ();
4379
4380         pending_visual_change.idle_handler_id = -1;
4381         return 0; /* this is always a one-shot call */
4382 }
4383
4384 struct EditorOrderTimeAxisSorter {
4385     bool operator() (const TimeAxisView* a, const TimeAxisView* b) const {
4386             return a->order () < b->order ();
4387     }
4388 };
4389
4390 void
4391 Editor::sort_track_selection (TrackViewList* sel)
4392 {
4393         EditorOrderTimeAxisSorter cmp;
4394
4395         if (sel) {
4396                 sel->sort (cmp);
4397         } else {
4398                 selection->tracks.sort (cmp);
4399         }
4400 }
4401
4402 framepos_t
4403 Editor::get_preferred_edit_position (bool ignore_playhead)
4404 {
4405         bool ignored;
4406         framepos_t where = 0;
4407         EditPoint ep = _edit_point;
4408
4409         if (entered_marker) {
4410                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use entered marker @ %1\n", entered_marker->position()));
4411                 return entered_marker->position();
4412         }
4413
4414         if (ignore_playhead && ep == EditAtPlayhead) {
4415                 ep = EditAtSelectedMarker;
4416         }
4417
4418         switch (ep) {
4419         case EditAtPlayhead:
4420                 where = _session->audible_frame();
4421                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use playhead @ %1\n", where));
4422                 break;
4423
4424         case EditAtSelectedMarker:
4425                 if (!selection->markers.empty()) {
4426                         bool is_start;
4427                         Location* loc = find_location_from_marker (selection->markers.front(), is_start);
4428                         if (loc) {
4429                                 if (is_start) {
4430                                         where =  loc->start();
4431                                 } else {
4432                                         where = loc->end();
4433                                 }
4434                                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use selected marker @ %1\n", where));
4435                                 break;
4436                         }
4437                 }
4438                 /* fallthru */
4439
4440         default:
4441         case EditAtMouse:
4442                 if (!mouse_frame (where, ignored)) {
4443                         /* XXX not right but what can we do ? */
4444                         return 0;
4445                 }
4446                 snap_to (where);
4447                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use mouse @ %1\n", where));
4448                 break;
4449         }
4450
4451         return where;
4452 }
4453
4454 void
4455 Editor::set_loop_range (framepos_t start, framepos_t end, string cmd)
4456 {
4457         if (!_session) return;
4458
4459         begin_reversible_command (cmd);
4460
4461         Location* tll;
4462
4463         if ((tll = transport_loop_location()) == 0) {
4464                 Location* loc = new Location (*_session, start, end, _("Loop"),  Location::IsAutoLoop);
4465                 XMLNode &before = _session->locations()->get_state();
4466                 _session->locations()->add (loc, true);
4467                 _session->set_auto_loop_location (loc);
4468                 XMLNode &after = _session->locations()->get_state();
4469                 _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
4470         } else {
4471                 XMLNode &before = tll->get_state();
4472                 tll->set_hidden (false, this);
4473                 tll->set (start, end);
4474                 XMLNode &after = tll->get_state();
4475                 _session->add_command (new MementoCommand<Location>(*tll, &before, &after));
4476         }
4477
4478         commit_reversible_command ();
4479 }
4480
4481 void
4482 Editor::set_punch_range (framepos_t start, framepos_t end, string cmd)
4483 {
4484         if (!_session) return;
4485
4486         begin_reversible_command (cmd);
4487
4488         Location* tpl;
4489
4490         if ((tpl = transport_punch_location()) == 0) {
4491                 Location* loc = new Location (*_session, start, end, _("Loop"),  Location::IsAutoPunch);
4492                 XMLNode &before = _session->locations()->get_state();
4493                 _session->locations()->add (loc, true);
4494                 _session->set_auto_loop_location (loc);
4495                 XMLNode &after = _session->locations()->get_state();
4496                 _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
4497         }
4498         else {
4499                 XMLNode &before = tpl->get_state();
4500                 tpl->set_hidden (false, this);
4501                 tpl->set (start, end);
4502                 XMLNode &after = tpl->get_state();
4503                 _session->add_command (new MementoCommand<Location>(*tpl, &before, &after));
4504         }
4505
4506         commit_reversible_command ();
4507 }
4508
4509 /** Find regions which exist at a given time, and optionally on a given list of tracks.
4510  *  @param rs List to which found regions are added.
4511  *  @param where Time to look at.
4512  *  @param ts Tracks to look on; if this is empty, all tracks are examined.
4513  */
4514 void
4515 Editor::get_regions_at (RegionSelection& rs, framepos_t where, const TrackViewList& ts) const
4516 {
4517         const TrackViewList* tracks;
4518
4519         if (ts.empty()) {
4520                 tracks = &track_views;
4521         } else {
4522                 tracks = &ts;
4523         }
4524
4525         for (TrackViewList::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
4526
4527                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*t);
4528
4529                 if (rtv) {
4530                         boost::shared_ptr<Track> tr;
4531                         boost::shared_ptr<Playlist> pl;
4532
4533                         if ((tr = rtv->track()) && ((pl = tr->playlist()))) {
4534
4535                                 Playlist::RegionList* regions = pl->regions_at (
4536                                                 (framepos_t) floor ( (double) where * tr->speed()));
4537
4538                                 for (Playlist::RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
4539                                         RegionView* rv = rtv->view()->find_view (*i);
4540                                         if (rv) {
4541                                                 rs.add (rv);
4542                                         }
4543                                 }
4544
4545                                 delete regions;
4546                         }
4547                 }
4548         }
4549 }
4550
4551 void
4552 Editor::get_regions_after (RegionSelection& rs, framepos_t where, const TrackViewList& ts) const
4553 {
4554         const TrackViewList* tracks;
4555
4556         if (ts.empty()) {
4557                 tracks = &track_views;
4558         } else {
4559                 tracks = &ts;
4560         }
4561
4562         for (TrackViewList::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
4563                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*t);
4564                 if (rtv) {
4565                         boost::shared_ptr<Track> tr;
4566                         boost::shared_ptr<Playlist> pl;
4567
4568                         if ((tr = rtv->track()) && ((pl = tr->playlist()))) {
4569
4570                                 Playlist::RegionList* regions = pl->regions_touched (
4571                                         (framepos_t) floor ( (double)where * tr->speed()), max_framepos);
4572
4573                                 for (Playlist::RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
4574
4575                                         RegionView* rv = rtv->view()->find_view (*i);
4576
4577                                         if (rv) {
4578                                                 rs.push_back (rv);
4579                                         }
4580                                 }
4581
4582                                 delete regions;
4583                         }
4584                 }
4585         }
4586 }
4587
4588 /** Start with regions that are selected.  Then add equivalent regions
4589  *  on tracks in the same active edit-enabled route group as any of
4590  *  the regions that we started with.
4591  */
4592
4593 RegionSelection
4594 Editor::get_regions_from_selection ()
4595 {
4596         return get_equivalent_regions (selection->regions, ARDOUR::Properties::edit.property_id);
4597 }
4598
4599 /** Get regions using the following method:
4600  *
4601  *  Make an initial region list using the selected regions, unless
4602  *  the edit point is `mouse' and the mouse is over an unselected
4603  *  region.  In this case, start with just that region.
4604  *
4605  *  Then, make an initial track list of the tracks that these
4606  *  regions are on, and if the edit point is not `mouse', add the
4607  *  selected tracks.
4608  *
4609  *  Look at this track list and add any other tracks that are on the
4610  *  same active edit-enabled route group as one of the initial tracks.
4611  *
4612  *  Finally take the initial region list and add any regions that are
4613  *  under the edit point on one of the tracks on the track list to get
4614  *  the returned region list.
4615  *
4616  *  The rationale here is that the mouse edit point is special in that
4617  *  its position describes both a time and a track; the other edit
4618  *  modes only describe a time.  Hence if the edit point is `mouse' we
4619  *  ignore selected tracks, as we assume the user means something by
4620  *  pointing at a particular track.  Also in this case we take note of
4621  *  the region directly under the edit point, as there is always just one
4622  *  (rather than possibly several with non-mouse edit points).
4623  */
4624
4625 RegionSelection
4626 Editor::get_regions_from_selection_and_edit_point ()
4627 {
4628         RegionSelection regions;
4629
4630         if (_edit_point == EditAtMouse && entered_regionview && !selection->regions.contains (entered_regionview)) {
4631                 regions.add (entered_regionview);
4632         } else {
4633                 regions = selection->regions;
4634         }
4635
4636         TrackViewList tracks;
4637
4638         if (_edit_point != EditAtMouse) {
4639                 tracks = selection->tracks;
4640         }
4641
4642         /* Add any other tracks that have regions that are in the same
4643            edit-activated route group as one of our regions.
4644          */
4645         for (RegionSelection::iterator i = regions.begin (); i != regions.end(); ++i) {
4646
4647                 RouteGroup* g = (*i)->get_time_axis_view().route_group ();
4648
4649                 if (g && g->is_active() && g->is_edit()) {
4650                         tracks.add (axis_views_from_routes (g->route_list()));
4651                 }
4652         }
4653
4654         if (!tracks.empty()) {
4655                 /* now find regions that are at the edit position on those tracks */
4656                 framepos_t const where = get_preferred_edit_position ();
4657                 get_regions_at (regions, where, tracks);
4658         }
4659
4660         return regions;
4661 }
4662
4663 /** Start with regions that are selected, or the entered regionview if none are selected.
4664  *  Then add equivalent regions on tracks in the same active edit-enabled route group as any
4665  *  of the regions that we started with.
4666  */
4667
4668 RegionSelection
4669 Editor::get_regions_from_selection_and_entered ()
4670 {
4671         RegionSelection regions = selection->regions;
4672
4673         if (regions.empty() && entered_regionview) {
4674                 regions.add (entered_regionview);
4675         }
4676
4677         return get_equivalent_regions (regions, ARDOUR::Properties::edit.property_id);
4678 }
4679
4680 void
4681 Editor::get_regions_corresponding_to (boost::shared_ptr<Region> region, vector<RegionView*>& regions)
4682 {
4683         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4684
4685                 RouteTimeAxisView* tatv;
4686
4687                 if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
4688
4689                         boost::shared_ptr<Playlist> pl;
4690                         vector<boost::shared_ptr<Region> > results;
4691                         RegionView* marv;
4692                         boost::shared_ptr<Track> tr;
4693
4694                         if ((tr = tatv->track()) == 0) {
4695                                 /* bus */
4696                                 continue;
4697                         }
4698
4699                         if ((pl = (tr->playlist())) != 0) {
4700                                 pl->get_region_list_equivalent_regions (region, results);
4701                         }
4702
4703                         for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
4704                                 if ((marv = tatv->view()->find_view (*ir)) != 0) {
4705                                         regions.push_back (marv);
4706                                 }
4707                         }
4708
4709                 }
4710         }
4711 }
4712
4713 void
4714 Editor::show_rhythm_ferret ()
4715 {
4716         if (rhythm_ferret == 0) {
4717                 rhythm_ferret = new RhythmFerret(*this);
4718         }
4719
4720         rhythm_ferret->set_session (_session);
4721         rhythm_ferret->show ();
4722         rhythm_ferret->present ();
4723 }
4724
4725 void
4726 Editor::first_idle ()
4727 {
4728         MessageDialog* dialog = 0;
4729
4730         if (track_views.size() > 1) {
4731                 dialog = new MessageDialog (*this,
4732                                             string_compose (_("Please wait while %1 loads visual data"), PROGRAM_NAME),
4733                                             true,
4734                                             Gtk::MESSAGE_INFO,
4735                                             Gtk::BUTTONS_NONE);
4736                 dialog->present ();
4737                 ARDOUR_UI::instance()->flush_pending ();
4738         }
4739
4740         for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
4741                 (*t)->first_idle();
4742         }
4743
4744         // first idle adds route children (automation tracks), so we need to redisplay here
4745         _routes->redisplay ();
4746
4747         delete dialog;
4748
4749         _have_idled = true;
4750 }
4751
4752 gboolean
4753 Editor::_idle_resize (gpointer arg)
4754 {
4755         return ((Editor*)arg)->idle_resize ();
4756 }
4757
4758 void
4759 Editor::add_to_idle_resize (TimeAxisView* view, int32_t h)
4760 {
4761         if (resize_idle_id < 0) {
4762                 resize_idle_id = g_idle_add (_idle_resize, this);
4763                 _pending_resize_amount = 0;
4764         }
4765
4766         /* make a note of the smallest resulting height, so that we can clamp the
4767            lower limit at TimeAxisView::hSmall */
4768
4769         int32_t min_resulting = INT32_MAX;
4770
4771         _pending_resize_amount += h;
4772         _pending_resize_view = view;
4773
4774         min_resulting = min (min_resulting, int32_t (_pending_resize_view->current_height()) + _pending_resize_amount);
4775
4776         if (selection->tracks.contains (_pending_resize_view)) {
4777                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4778                         min_resulting = min (min_resulting, int32_t ((*i)->current_height()) + _pending_resize_amount);
4779                 }
4780         }
4781
4782         if (min_resulting < 0) {
4783                 min_resulting = 0;
4784         }
4785
4786         /* clamp */
4787         if (uint32_t (min_resulting) < TimeAxisView::preset_height (HeightSmall)) {
4788                 _pending_resize_amount += TimeAxisView::preset_height (HeightSmall) - min_resulting;
4789         }
4790 }
4791
4792 /** Handle pending resizing of tracks */
4793 bool
4794 Editor::idle_resize ()
4795 {
4796         _pending_resize_view->idle_resize (_pending_resize_view->current_height() + _pending_resize_amount);
4797
4798         if (dynamic_cast<AutomationTimeAxisView*> (_pending_resize_view) == 0 &&
4799             selection->tracks.contains (_pending_resize_view)) {
4800
4801                 for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4802                         if (*i != _pending_resize_view) {
4803                                 (*i)->idle_resize ((*i)->current_height() + _pending_resize_amount);
4804                         }
4805                 }
4806         }
4807
4808         _pending_resize_amount = 0;
4809         flush_canvas ();
4810         _group_tabs->set_dirty ();
4811         resize_idle_id = -1;
4812
4813         return false;
4814 }
4815
4816 void
4817 Editor::located ()
4818 {
4819         ENSURE_GUI_THREAD (*this, &Editor::located);
4820
4821         playhead_cursor->set_position (_session->audible_frame ());
4822         if (_follow_playhead && !_pending_initial_locate) {
4823                 reset_x_origin_to_follow_playhead ();
4824         }
4825
4826         _pending_locate_request = false;
4827         _pending_initial_locate = false;
4828 }
4829
4830 void
4831 Editor::region_view_added (RegionView *)
4832 {
4833         _summary->set_dirty ();
4834 }
4835
4836 void
4837 Editor::region_view_removed ()
4838 {
4839         _summary->set_dirty ();
4840 }
4841
4842 TimeAxisView*
4843 Editor::axis_view_from_route (boost::shared_ptr<Route> r) const
4844 {
4845         TrackViewList::const_iterator j = track_views.begin ();
4846         while (j != track_views.end()) {
4847                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*j);
4848                 if (rtv && rtv->route() == r) {
4849                         return rtv;
4850                 }
4851                 ++j;
4852         }
4853
4854         return 0;
4855 }
4856
4857
4858 TrackViewList
4859 Editor::axis_views_from_routes (boost::shared_ptr<RouteList> r) const
4860 {
4861         TrackViewList t;
4862
4863         for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4864                 TimeAxisView* tv = axis_view_from_route (*i);
4865                 if (tv) {
4866                         t.push_back (tv);
4867                 }
4868         }
4869
4870         return t;
4871 }
4872
4873
4874 void
4875 Editor::handle_new_route (RouteList& routes)
4876 {
4877         ENSURE_GUI_THREAD (*this, &Editor::handle_new_route, routes)
4878
4879         RouteTimeAxisView *rtv;
4880         list<RouteTimeAxisView*> new_views;
4881
4882         for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
4883                 boost::shared_ptr<Route> route = (*x);
4884
4885                 if (route->is_hidden() || route->is_monitor()) {
4886                         continue;
4887                 }
4888
4889                 DataType dt = route->input()->default_type();
4890
4891                 if (dt == ARDOUR::DataType::AUDIO) {
4892                         rtv = new AudioTimeAxisView (*this, _session, *track_canvas);
4893                         rtv->set_route (route);
4894                 } else if (dt == ARDOUR::DataType::MIDI) {
4895                         rtv = new MidiTimeAxisView (*this, _session, *track_canvas);
4896                         rtv->set_route (route);
4897                 } else {
4898                         throw unknown_type();
4899                 }
4900
4901                 new_views.push_back (rtv);
4902                 track_views.push_back (rtv);
4903
4904                 rtv->effective_gain_display ();
4905
4906                 if (internal_editing()) {
4907                         rtv->enter_internal_edit_mode ();
4908                 } else {
4909                         rtv->leave_internal_edit_mode ();
4910                 }
4911
4912                 rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
4913                 rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
4914         }
4915
4916         _routes->routes_added (new_views);
4917         _summary->routes_added (new_views);
4918
4919         if (show_editor_mixer_when_tracks_arrive) {
4920                 show_editor_mixer (true);
4921         }
4922
4923         editor_list_button.set_sensitive (true);
4924 }
4925
4926 void
4927 Editor::timeaxisview_deleted (TimeAxisView *tv)
4928 {
4929         if (_session && _session->deletion_in_progress()) {
4930                 /* the situation is under control */
4931                 return;
4932         }
4933
4934         ENSURE_GUI_THREAD (*this, &Editor::timeaxisview_deleted, tv);
4935
4936         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (tv);
4937
4938         _routes->route_removed (tv);
4939
4940         if (tv == entered_track) {
4941                 entered_track = 0;
4942         }
4943
4944         TimeAxisView::Children c = tv->get_child_list ();
4945         for (TimeAxisView::Children::const_iterator i = c.begin(); i != c.end(); ++i) {
4946                 if (entered_track == i->get()) {
4947                         entered_track = 0;
4948                 }
4949         }
4950
4951         /* remove it from the list of track views */
4952
4953         TrackViewList::iterator i;
4954
4955         if ((i = find (track_views.begin(), track_views.end(), tv)) != track_views.end()) {
4956                 i = track_views.erase (i);
4957         }
4958
4959         /* update whatever the current mixer strip is displaying, if revelant */
4960
4961         boost::shared_ptr<Route> route;
4962
4963         if (rtav) {
4964                 route = rtav->route ();
4965         }
4966
4967         if (current_mixer_strip && current_mixer_strip->route() == route) {
4968
4969                 TimeAxisView* next_tv;
4970
4971                 if (track_views.empty()) {
4972                         next_tv = 0;
4973                 } else if (i == track_views.end()) {
4974                         next_tv = track_views.front();
4975                 } else {
4976                         next_tv = (*i);
4977                 }
4978
4979
4980                 if (next_tv) {
4981                         set_selected_mixer_strip (*next_tv);
4982                 } else {
4983                         /* make the editor mixer strip go away setting the
4984                          * button to inactive (which also unticks the menu option)
4985                          */
4986
4987                         ActionManager::uncheck_toggleaction ("<Actions>/Editor/show-editor-mixer");
4988                 }
4989         }
4990 }
4991
4992 void
4993 Editor::hide_track_in_display (TimeAxisView* tv, bool apply_to_selection)
4994 {
4995         if (apply_to_selection) {
4996                 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ) {
4997
4998                         TrackSelection::iterator j = i;
4999                         ++j;
5000
5001                         hide_track_in_display (*i, false);
5002
5003                         i = j;
5004                 }
5005         } else {
5006                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
5007
5008                 if (rtv && current_mixer_strip && (rtv->route() == current_mixer_strip->route())) {
5009                         // this will hide the mixer strip
5010                         set_selected_mixer_strip (*tv);
5011                 }
5012
5013                 _routes->hide_track_in_display (*tv);
5014         }
5015 }
5016
5017 bool
5018 Editor::sync_track_view_list_and_routes ()
5019 {
5020         track_views = TrackViewList (_routes->views ());
5021
5022         _summary->set_dirty ();
5023         _group_tabs->set_dirty ();
5024
5025         return false; // do not call again (until needed)
5026 }
5027
5028 void
5029 Editor::foreach_time_axis_view (sigc::slot<void,TimeAxisView&> theslot)
5030 {
5031         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5032                 theslot (**i);
5033         }
5034 }
5035
5036 /** Find a RouteTimeAxisView by the ID of its route */
5037 RouteTimeAxisView*
5038 Editor::get_route_view_by_route_id (PBD::ID& id) const
5039 {
5040         RouteTimeAxisView* v;
5041
5042         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
5043                 if((v = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
5044                         if(v->route()->id() == id) {
5045                                 return v;
5046                         }
5047                 }
5048         }
5049
5050         return 0;
5051 }
5052
5053 void
5054 Editor::fit_route_group (RouteGroup *g)
5055 {
5056         TrackViewList ts = axis_views_from_routes (g->route_list ());
5057         fit_tracks (ts);
5058 }
5059
5060 void
5061 Editor::consider_auditioning (boost::shared_ptr<Region> region)
5062 {
5063         boost::shared_ptr<AudioRegion> r = boost::dynamic_pointer_cast<AudioRegion> (region);
5064
5065         if (r == 0) {
5066                 _session->cancel_audition ();
5067                 return;
5068         }
5069
5070         if (_session->is_auditioning()) {
5071                 _session->cancel_audition ();
5072                 if (r == last_audition_region) {
5073                         return;
5074                 }
5075         }
5076
5077         _session->audition_region (r);
5078         last_audition_region = r;
5079 }
5080
5081
5082 void
5083 Editor::hide_a_region (boost::shared_ptr<Region> r)
5084 {
5085         r->set_hidden (true);
5086 }
5087
5088 void
5089 Editor::show_a_region (boost::shared_ptr<Region> r)
5090 {
5091         r->set_hidden (false);
5092 }
5093
5094 void
5095 Editor::audition_region_from_region_list ()
5096 {
5097         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::consider_auditioning));
5098 }
5099
5100 void
5101 Editor::hide_region_from_region_list ()
5102 {
5103         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::hide_a_region));
5104 }
5105
5106 void
5107 Editor::show_region_in_region_list ()
5108 {
5109         _regions->selection_mapover (sigc::mem_fun (*this, &Editor::show_a_region));
5110 }
5111
5112 void
5113 Editor::step_edit_status_change (bool yn)
5114 {
5115         if (yn) {
5116                 start_step_editing ();
5117         } else {
5118                 stop_step_editing ();
5119         }
5120 }
5121
5122 void
5123 Editor::start_step_editing ()
5124 {
5125         step_edit_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &Editor::check_step_edit), 20);
5126 }
5127
5128 void
5129 Editor::stop_step_editing ()
5130 {
5131         step_edit_connection.disconnect ();
5132 }
5133
5134 bool
5135 Editor::check_step_edit ()
5136 {
5137         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5138                 MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (*i);
5139                 if (mtv) {
5140                         mtv->check_step_edit ();
5141                 }
5142         }
5143
5144         return true; // do it again, till we stop
5145 }
5146
5147 bool
5148 Editor::scroll_press (Direction dir)
5149 {
5150         ++_scroll_callbacks;
5151
5152         if (_scroll_connection.connected() && _scroll_callbacks < 5) {
5153                 /* delay the first auto-repeat */
5154                 return true;
5155         }
5156
5157         switch (dir) {
5158         case LEFT:
5159                 scroll_backward (1);
5160                 break;
5161
5162         case RIGHT:
5163                 scroll_forward (1);
5164                 break;
5165
5166         case UP:
5167                 scroll_tracks_up_line ();
5168                 break;
5169
5170         case DOWN:
5171                 scroll_tracks_down_line ();
5172                 break;
5173         }
5174
5175         /* do hacky auto-repeat */
5176         if (!_scroll_connection.connected ()) {
5177
5178                 _scroll_connection = Glib::signal_timeout().connect (
5179                         sigc::bind (sigc::mem_fun (*this, &Editor::scroll_press), dir), 100
5180                         );
5181
5182                 _scroll_callbacks = 0;
5183         }
5184
5185         return true;
5186 }
5187
5188 void
5189 Editor::scroll_release ()
5190 {
5191         _scroll_connection.disconnect ();
5192 }
5193
5194 /** Queue a change for the Editor viewport x origin to follow the playhead */
5195 void
5196 Editor::reset_x_origin_to_follow_playhead ()
5197 {
5198         framepos_t const frame = playhead_cursor->current_frame;
5199
5200         if (frame < leftmost_frame || frame > leftmost_frame + current_page_frames()) {
5201
5202                 if (_session->transport_speed() < 0) {
5203
5204                         if (frame > (current_page_frames() / 2)) {
5205                                 center_screen (frame-(current_page_frames()/2));
5206                         } else {
5207                                 center_screen (current_page_frames()/2);
5208                         }
5209
5210                 } else {
5211
5212                         if (frame < leftmost_frame) {
5213                                 /* moving left */
5214                                 framepos_t l = 0;
5215                                 if (_session->transport_rolling()) {
5216                                         /* rolling; end up with the playhead at the right of the page */
5217                                         l = frame - current_page_frames ();
5218                                 } else {
5219                                         /* not rolling: end up with the playhead 3/4 of the way along the page */
5220                                         l = frame - (3 * current_page_frames() / 4);
5221                                 }
5222
5223                                 if (l < 0) {
5224                                         l = 0;
5225                                 }
5226
5227                                 center_screen_internal (l + (current_page_frames() / 2), current_page_frames ());
5228                         } else {
5229                                 /* moving right */
5230                                 if (_session->transport_rolling()) {
5231                                         /* rolling: end up with the playhead on the left of the page */
5232                                         center_screen_internal (frame + (current_page_frames() / 2), current_page_frames ());
5233                                 } else {
5234                                         /* not rolling: end up with the playhead 1/4 of the way along the page */
5235                                         center_screen_internal (frame + (current_page_frames() / 4), current_page_frames ());
5236                                 }
5237                         }
5238                 }
5239         }
5240 }
5241
5242 void
5243 Editor::super_rapid_screen_update ()
5244 {
5245         if (!_session || !_session->engine().running()) {
5246                 return;
5247         }
5248
5249         /* METERING / MIXER STRIPS */
5250
5251         /* update track meters, if required */
5252         if (is_mapped() && meters_running) {
5253                 RouteTimeAxisView* rtv;
5254                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5255                         if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
5256                                 rtv->fast_update ();
5257                         }
5258                 }
5259         }
5260
5261         /* and any current mixer strip */
5262         if (current_mixer_strip) {
5263                 current_mixer_strip->fast_update ();
5264         }
5265
5266         /* PLAYHEAD AND VIEWPORT */
5267
5268         framepos_t const frame = _session->audible_frame();
5269
5270         /* There are a few reasons why we might not update the playhead / viewport stuff:
5271          *
5272          * 1.  we don't update things when there's a pending locate request, otherwise
5273          *     when the editor requests a locate there is a chance that this method
5274          *     will move the playhead before the locate request is processed, causing
5275          *     a visual glitch.
5276          * 2.  if we're not rolling, there's nothing to do here (locates are handled elsewhere).
5277          * 3.  if we're still at the same frame that we were last time, there's nothing to do.
5278          */
5279
5280         if (!_pending_locate_request && _session->transport_speed() != 0 && frame != last_update_frame) {
5281
5282                 last_update_frame = frame;
5283
5284                 if (!_dragging_playhead) {
5285                         playhead_cursor->set_position (frame);
5286                 }
5287
5288                 if (!_stationary_playhead) {
5289
5290                         if (!_dragging_playhead && _follow_playhead && _session->requested_return_frame() < 0) {
5291                                 reset_x_origin_to_follow_playhead ();
5292                         }
5293
5294                 } else {
5295
5296                         /* don't do continuous scroll till the new position is in the rightmost quarter of the
5297                            editor canvas
5298                         */
5299 #if 0
5300                         // FIXME DO SOMETHING THAT WORKS HERE - this is 2.X code
5301                         double target = ((double)frame - (double)current_page_frames()/2.0) / frames_per_unit;
5302                         if (target <= 0.0) {
5303                                 target = 0.0;
5304                         }
5305                         if (fabs(target - current) < current_page_frames() / frames_per_unit) {
5306                                 target = (target * 0.15) + (current * 0.85);
5307                         } else {
5308                                 /* relax */
5309                         }
5310
5311                         current = target;
5312                         set_horizontal_position (current);
5313 #endif
5314                 }
5315
5316         }
5317 }
5318
5319
5320 void
5321 Editor::session_going_away ()
5322 {
5323         _have_idled = false;
5324
5325         _session_connections.drop_connections ();
5326
5327         super_rapid_screen_update_connection.disconnect ();
5328
5329         selection->clear ();
5330         cut_buffer->clear ();
5331
5332         clicked_regionview = 0;
5333         clicked_axisview = 0;
5334         clicked_routeview = 0;
5335         clicked_crossfadeview = 0;
5336         entered_regionview = 0;
5337         entered_track = 0;
5338         last_update_frame = 0;
5339         _drags->abort ();
5340
5341         playhead_cursor->canvas_item.hide ();
5342
5343         /* rip everything out of the list displays */
5344
5345         _regions->clear ();
5346         _routes->clear ();
5347         _route_groups->clear ();
5348
5349         /* do this first so that deleting a track doesn't reset cms to null
5350            and thus cause a leak.
5351         */
5352
5353         if (current_mixer_strip) {
5354                 if (current_mixer_strip->get_parent() != 0) {
5355                         global_hpacker.remove (*current_mixer_strip);
5356                 }
5357                 delete current_mixer_strip;
5358                 current_mixer_strip = 0;
5359         }
5360
5361         /* delete all trackviews */
5362
5363         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5364                 delete *i;
5365         }
5366         track_views.clear ();
5367
5368         zoom_range_clock->set_session (0);
5369         nudge_clock->set_session (0);
5370
5371         editor_list_button.set_active(false);
5372         editor_list_button.set_sensitive(false);
5373
5374         /* clear tempo/meter rulers */
5375         remove_metric_marks ();
5376         hide_measures ();
5377         clear_marker_display ();
5378
5379         delete current_bbt_points;
5380         current_bbt_points = 0;
5381
5382         /* get rid of any existing editor mixer strip */
5383
5384         WindowTitle title(Glib::get_application_name());
5385         title += _("Editor");
5386
5387         set_title (title.get_string());
5388
5389         SessionHandlePtr::session_going_away ();
5390 }
5391
5392
5393 void
5394 Editor::show_editor_list (bool yn)
5395 {
5396         if (yn) {
5397                 _the_notebook.show ();
5398         } else {
5399                 _the_notebook.hide ();
5400         }
5401 }
5402
5403 void
5404 Editor::change_region_layering_order ()
5405 {
5406         framepos_t const position = get_preferred_edit_position ();
5407
5408         if (!clicked_routeview) {
5409                 if (layering_order_editor) {
5410                         layering_order_editor->hide ();
5411                 }
5412                 return;
5413         }
5414
5415         boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (clicked_routeview->route());
5416
5417         if (!track) {
5418                 return;
5419         }
5420
5421         boost::shared_ptr<Playlist> pl = track->playlist();
5422
5423         if (!pl) {
5424                 return;
5425         }
5426
5427         if (layering_order_editor == 0) {
5428                 layering_order_editor = new RegionLayeringOrderEditor(*this);
5429         }
5430
5431         layering_order_editor->set_context (clicked_routeview->name(), _session, pl, position);
5432         layering_order_editor->maybe_present ();
5433 }
5434
5435 void
5436 Editor::update_region_layering_order_editor ()
5437 {
5438         if (layering_order_editor && layering_order_editor->is_visible ()) {
5439                 change_region_layering_order ();
5440         }
5441 }
5442
5443 void
5444 Editor::setup_fade_images ()
5445 {
5446         _fade_in_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("crossfade-in-linear")));
5447         _fade_in_images[FadeFast] = new Gtk::Image (get_icon_path (X_("crossfade-in-short-cut")));
5448         _fade_in_images[FadeLogB] = new Gtk::Image (get_icon_path (X_("crossfade-in-slow-cut")));
5449         _fade_in_images[FadeLogA] = new Gtk::Image (get_icon_path (X_("crossfade-in-fast-cut")));
5450         _fade_in_images[FadeSlow] = new Gtk::Image (get_icon_path (X_("crossfade-in-long-cut")));
5451
5452         _fade_out_images[FadeLinear] = new Gtk::Image (get_icon_path (X_("crossfade-out-linear")));
5453         _fade_out_images[FadeFast] = new Gtk::Image (get_icon_path (X_("crossfade-out-short-cut")));
5454         _fade_out_images[FadeLogB] = new Gtk::Image (get_icon_path (X_("crossfade-out-slow-cut")));
5455         _fade_out_images[FadeLogA] = new Gtk::Image (get_icon_path (X_("crossfade-out-fast-cut")));
5456         _fade_out_images[FadeSlow] = new Gtk::Image (get_icon_path (X_("crossfade-out-long-cut")));
5457 }
5458
5459
5460 /** @return Gtk::manage()d menu item for a given action from `editor_actions' */
5461 Gtk::MenuItem&
5462 Editor::action_menu_item (std::string const & name)
5463 {
5464         Glib::RefPtr<Action> a = editor_actions->get_action (name);
5465         assert (a);
5466
5467         return *manage (a->create_menu_item ());
5468 }
5469
5470 void
5471 Editor::resize_text_widgets ()
5472 {
5473         set_size_request_to_display_given_text (edit_mode_selector, edit_mode_strings, COMBO_FUDGE+10, 15);
5474         set_size_request_to_display_given_text (zoom_focus_selector, zoom_focus_strings, COMBO_FUDGE+10, 15);
5475         set_size_request_to_display_given_text (snap_type_selector, snap_type_strings, COMBO_FUDGE+10, 15);
5476         set_size_request_to_display_given_text (snap_mode_selector, snap_mode_strings, COMBO_FUDGE+10, 15);
5477         set_size_request_to_display_given_text (edit_point_selector, edit_point_strings, COMBO_FUDGE+10, 15);
5478 }
5479
5480 void
5481 Editor::add_notebook_page (string const & name, Gtk::Widget& widget)
5482 {
5483         EventBox* b = manage (new EventBox);
5484         b->signal_button_press_event().connect (sigc::bind (sigc::mem_fun (*this, &Editor::notebook_tab_clicked), &widget));
5485         Label* l = manage (new Label (name));
5486         l->set_angle (-90);
5487         b->add (*l);
5488         b->show_all ();
5489         _the_notebook.append_page (widget, *b);
5490 }
5491
5492 bool
5493 Editor::notebook_tab_clicked (GdkEventButton* ev, Gtk::Widget* page)
5494 {
5495         if (ev->type == GDK_BUTTON_PRESS || ev->type == GDK_2BUTTON_PRESS) {
5496                 _the_notebook.set_current_page (_the_notebook.page_num (*page));
5497         }
5498
5499         if (ev->type == GDK_2BUTTON_PRESS) {
5500
5501                 /* double-click on a notebook tab shrinks or expands the notebook */
5502
5503                 if (_notebook_shrunk) {
5504                         edit_pane.set_position (pre_maximal_horizontal_pane_position);
5505                         _notebook_shrunk = false;
5506                 } else {
5507                         pre_maximal_horizontal_pane_position = edit_pane.get_position ();
5508                         edit_pane.set_position (edit_pane.get_position() + page->get_width());
5509                         _notebook_shrunk = true;
5510                 }
5511         }
5512
5513         return true;
5514 }
5515
5516 void
5517 Editor::popup_control_point_context_menu (ArdourCanvas::Item* item, GdkEvent* event)
5518 {
5519         using namespace Menu_Helpers;
5520
5521         MenuList& items = _control_point_context_menu.items ();
5522         items.clear ();
5523
5524         items.push_back (MenuElem (_("Edit..."), sigc::bind (sigc::mem_fun (*this, &Editor::edit_control_point), item)));
5525         items.push_back (MenuElem (_("Delete"), sigc::bind (sigc::mem_fun (*this, &Editor::remove_control_point), item)));
5526         if (!can_remove_control_point (item)) {
5527                 items.back().set_sensitive (false);
5528         }
5529
5530         _control_point_context_menu.popup (event->button.button, event->button.time);
5531 }