gtk2_ardour/editor_ops.cc

   1 /*
   2     Copyright (C) 2000-2004 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 <unistd.h>
  23
  24 #include <cstdlib>
  25 #include <cmath>
  26 #include <string>
  27 #include <map>
  28 #include <set>
  29
  30 #include "pbd/error.h"
  31 #include "pbd/basename.h"
  32 #include "pbd/pthread_utils.h"
  33 #include "pbd/memento_command.h"
  34 #include "pbd/whitespace.h"
  35 #include "pbd/stateful_diff_command.h"
  36
  37 #include <gtkmm2ext/utils.h>
  38 #include <gtkmm2ext/choice.h>
  39 #include <gtkmm2ext/popup.h>
  40
  41 #include "ardour/audio_track.h"
  42 #include "ardour/audioregion.h"
  43 #include "ardour/dB.h"
  44 #include "ardour/location.h"
  45 #include "ardour/midi_region.h"
  46 #include "ardour/operations.h"
  47 #include "ardour/playlist_factory.h"
  48 #include "ardour/quantize.h"
  49 #include "ardour/region_factory.h"
  50 #include "ardour/reverse.h"
  51 #include "ardour/route_group.h"
  52 #include "ardour/session.h"
  53 #include "ardour/session_playlists.h"
  54 #include "ardour/strip_silence.h"
  55 #include "ardour/transient_detector.h"
  56 #include "ardour/utils.h"
  57
  58 #include "ardour_ui.h"
  59 #include "debug.h"
  60 #include "editor.h"
  61 #include "time_axis_view.h"
  62 #include "route_time_axis.h"
  63 #include "audio_time_axis.h"
  64 #include "automation_time_axis.h"
  65 #include "streamview.h"
  66 #include "audio_streamview.h"
  67 #include "audio_region_view.h"
  68 #include "midi_region_view.h"
  69 #include "rgb_macros.h"
  70 #include "selection_templates.h"
  71 #include "selection.h"
  72 #include "editing.h"
  73 #include "gtk-custom-hruler.h"
  74 #include "gui_thread.h"
  75 #include "keyboard.h"
  76 #include "utils.h"
  77 #include "editor_drag.h"
  78 #include "strip_silence_dialog.h"
  79 #include "editor_routes.h"
  80 #include "editor_regions.h"
  81 #include "quantize_dialog.h"
  82 #include "interthread_progress_window.h"
  83 #include "insert_time_dialog.h"
  84 #include "normalize_dialog.h"
  85 #include "editor_cursors.h"
  86 #include "mouse_cursors.h"
  87 #include "patch_change_dialog.h"
  88 #include "transpose_dialog.h"
  89
  90 #include "i18n.h"
  91
  92 using namespace std;
  93 using namespace ARDOUR;
  94 using namespace PBD;
  95 using namespace Gtk;
  96 using namespace Gtkmm2ext;
  97 using namespace Editing;
  98 using Gtkmm2ext::Keyboard;
  99
 100 /***********************************************************************
 101   Editor operations
 102  ***********************************************************************/
 103
 104 void
 105 Editor::undo (uint32_t n)
 106 {
 107         if (_drags->active ()) {
 108                 _drags->abort ();
 109         }
 110
 111         if (_session) {
 112                 _session->undo (n);
 113         }
 114 }
 115
 116 void
 117 Editor::redo (uint32_t n)
 118 {
 119         if (_drags->active ()) {
 120                 _drags->abort ();
 121         }
 122
 123         if (_session) {
 124                 _session->redo (n);
 125         }
 126 }
 127
 128 void
 129 Editor::split_regions_at (framepos_t where, RegionSelection& regions)
 130 {
 131         bool frozen = false;
 132
 133         list <boost::shared_ptr<Playlist > > used_playlists;
 134
 135         if (regions.empty()) {
 136                 return;
 137         }
 138
 139         begin_reversible_command (_("split"));
 140
 141         // if splitting a single region, and snap-to is using
 142         // region boundaries, don't pay attention to them
 143
 144         if (regions.size() == 1) {
 145                 switch (_snap_type) {
 146                 case SnapToRegionStart:
 147                 case SnapToRegionSync:
 148                 case SnapToRegionEnd:
 149                         break;
 150                 default:
 151                         snap_to (where);
 152                 }
 153         } else {
 154                 snap_to (where);
 155
 156                 frozen = true;
 157                 EditorFreeze(); /* Emit Signal */
 158         }
 159
 160         for (RegionSelection::iterator a = regions.begin(); a != regions.end(); ) {
 161
 162                 RegionSelection::iterator tmp;
 163
 164                 /* XXX this test needs to be more complicated, to make sure we really
 165                    have something to split.
 166                 */
 167
 168                 if (!(*a)->region()->covers (where)) {
 169                         ++a;
 170                         continue;
 171                 }
 172
 173                 tmp = a;
 174                 ++tmp;
 175
 176                 boost::shared_ptr<Playlist> pl = (*a)->region()->playlist();
 177
 178                 if (!pl) {
 179                         a = tmp;
 180                         continue;
 181                 }
 182
 183                 if (!pl->frozen()) {
 184                         /* we haven't seen this playlist before */
 185
 186                         /* remember used playlists so we can thaw them later */
 187                         used_playlists.push_back(pl);
 188                         pl->freeze();
 189                 }
 190
 191                 if (pl) {
 192                         pl->clear_changes ();
 193                         pl->split_region ((*a)->region(), where);
 194                         _session->add_command (new StatefulDiffCommand (pl));
 195                 }
 196
 197                 a = tmp;
 198         }
 199
 200         while (used_playlists.size() > 0) {
 201                 list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
 202                 (*i)->thaw();
 203                 used_playlists.pop_front();
 204         }
 205
 206         commit_reversible_command ();
 207
 208         if (frozen){
 209                 EditorThaw(); /* Emit Signal */
 210         }
 211 }
 212
 213 /** Move one extreme of the current range selection.  If more than one range is selected,
 214  *  the start of the earliest range or the end of the latest range is moved.
 215  *
 216  *  @param move_end true to move the end of the current range selection, false to move
 217  *  the start.
 218  *  @param next true to move the extreme to the next region boundary, false to move to
 219  *  the previous.
 220  */
 221 void
 222 Editor::move_range_selection_start_or_end_to_region_boundary (bool move_end, bool next)
 223 {
 224         if (selection->time.start() == selection->time.end_frame()) {
 225                 return;
 226         }
 227
 228         framepos_t start = selection->time.start ();
 229         framepos_t end = selection->time.end_frame ();
 230
 231         /* the position of the thing we may move */
 232         framepos_t pos = move_end ? end : start;
 233         int dir = next ? 1 : -1;
 234
 235         /* so we don't find the current region again */
 236         if (dir > 0 || pos > 0) {
 237                 pos += dir;
 238         }
 239
 240         framepos_t const target = get_region_boundary (pos, dir, true, false);
 241         if (target < 0) {
 242                 return;
 243         }
 244
 245         if (move_end) {
 246                 end = target;
 247         } else {
 248                 start = target;
 249         }
 250
 251         if (end < start) {
 252                 return;
 253         }
 254
 255         begin_reversible_command (_("alter selection"));
 256         selection->set_preserving_all_ranges (start, end);
 257         commit_reversible_command ();
 258 }
 259
 260 bool
 261 Editor::nudge_forward_release (GdkEventButton* ev)
 262 {
 263         if (ev->state & Keyboard::PrimaryModifier) {
 264                 nudge_forward (false, true);
 265         } else {
 266                 nudge_forward (false, false);
 267         }
 268         return false;
 269 }
 270
 271 bool
 272 Editor::nudge_backward_release (GdkEventButton* ev)
 273 {
 274         if (ev->state & Keyboard::PrimaryModifier) {
 275                 nudge_backward (false, true);
 276         } else {
 277                 nudge_backward (false, false);
 278         }
 279         return false;
 280 }
 281
 282
 283 void
 284 Editor::nudge_forward (bool next, bool force_playhead)
 285 {
 286         framepos_t distance;
 287         framepos_t next_distance;
 288
 289         if (!_session) {
 290                 return;
 291         }
 292
 293         RegionSelection rs = get_regions_from_selection_and_entered ();
 294
 295         if (!force_playhead && !rs.empty()) {
 296
 297                 begin_reversible_command (_("nudge regions forward"));
 298
 299                 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 300                         boost::shared_ptr<Region> r ((*i)->region());
 301
 302                         distance = get_nudge_distance (r->position(), next_distance);
 303
 304                         if (next) {
 305                                 distance = next_distance;
 306                         }
 307
 308                         r->clear_changes ();
 309                         r->set_position (r->position() + distance);
 310                         _session->add_command (new StatefulDiffCommand (r));
 311                 }
 312
 313                 commit_reversible_command ();
 314
 315
 316         } else if (!force_playhead && !selection->markers.empty()) {
 317
 318                 bool is_start;
 319
 320                 begin_reversible_command (_("nudge location forward"));
 321
 322                 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
 323
 324                         Location* loc = find_location_from_marker ((*i), is_start);
 325
 326                         if (loc) {
 327
 328                                 XMLNode& before (loc->get_state());
 329
 330                                 if (is_start) {
 331                                         distance = get_nudge_distance (loc->start(), next_distance);
 332                                         if (next) {
 333                                                 distance = next_distance;
 334                                         }
 335                                         if (max_framepos - distance > loc->start() + loc->length()) {
 336                                                 loc->set_start (loc->start() + distance);
 337                                         } else {
 338                                                 loc->set_start (max_framepos - loc->length());
 339                                         }
 340                                 } else {
 341                                         distance = get_nudge_distance (loc->end(), next_distance);
 342                                         if (next) {
 343                                                 distance = next_distance;
 344                                         }
 345                                         if (max_framepos - distance > loc->end()) {
 346                                                 loc->set_end (loc->end() + distance);
 347                                         } else {
 348                                                 loc->set_end (max_framepos);
 349                                         }
 350                                 }
 351                                 XMLNode& after (loc->get_state());
 352                                 _session->add_command (new MementoCommand<Location>(*loc, &before, &after));
 353                         }
 354                 }
 355
 356                 commit_reversible_command ();
 357
 358         } else {
 359                 distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
 360                 _session->request_locate (playhead_cursor->current_frame + distance);
 361         }
 362 }
 363
 364 void
 365 Editor::nudge_backward (bool next, bool force_playhead)
 366 {
 367         framepos_t distance;
 368         framepos_t next_distance;
 369
 370         if (!_session) {
 371                 return;
 372         }
 373
 374         RegionSelection rs = get_regions_from_selection_and_entered ();
 375
 376         if (!force_playhead && !rs.empty()) {
 377
 378                 begin_reversible_command (_("nudge regions backward"));
 379
 380                 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 381                         boost::shared_ptr<Region> r ((*i)->region());
 382
 383                         distance = get_nudge_distance (r->position(), next_distance);
 384
 385                         if (next) {
 386                                 distance = next_distance;
 387                         }
 388
 389                         r->clear_changes ();
 390
 391                         if (r->position() > distance) {
 392                                 r->set_position (r->position() - distance);
 393                         } else {
 394                                 r->set_position (0);
 395                         }
 396                         _session->add_command (new StatefulDiffCommand (r));
 397                 }
 398
 399                 commit_reversible_command ();
 400
 401         } else if (!force_playhead && !selection->markers.empty()) {
 402
 403                 bool is_start;
 404
 405                 begin_reversible_command (_("nudge location forward"));
 406
 407                 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
 408
 409                         Location* loc = find_location_from_marker ((*i), is_start);
 410
 411                         if (loc) {
 412
 413                                 XMLNode& before (loc->get_state());
 414
 415                                 if (is_start) {
 416                                         distance = get_nudge_distance (loc->start(), next_distance);
 417                                         if (next) {
 418                                                 distance = next_distance;
 419                                         }
 420                                         if (distance < loc->start()) {
 421                                                 loc->set_start (loc->start() - distance);
 422                                         } else {
 423                                                 loc->set_start (0);
 424                                         }
 425                                 } else {
 426                                         distance = get_nudge_distance (loc->end(), next_distance);
 427
 428                                         if (next) {
 429                                                 distance = next_distance;
 430                                         }
 431
 432                                         if (distance < loc->end() - loc->length()) {
 433                                                 loc->set_end (loc->end() - distance);
 434                                         } else {
 435                                                 loc->set_end (loc->length());
 436                                         }
 437                                 }
 438
 439                                 XMLNode& after (loc->get_state());
 440                                 _session->add_command (new MementoCommand<Location>(*loc, &before, &after));
 441                         }
 442                 }
 443
 444                 commit_reversible_command ();
 445
 446         } else {
 447
 448                 distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
 449
 450                 if (playhead_cursor->current_frame > distance) {
 451                         _session->request_locate (playhead_cursor->current_frame - distance);
 452                 } else {
 453                         _session->goto_start();
 454                 }
 455         }
 456 }
 457
 458 void
 459 Editor::nudge_forward_capture_offset ()
 460 {
 461         RegionSelection rs = get_regions_from_selection_and_entered ();
 462
 463         if (!_session || rs.empty()) {
 464                 return;
 465         }
 466
 467         begin_reversible_command (_("nudge forward"));
 468
 469         framepos_t const distance = _session->worst_output_latency();
 470
 471         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 472                 boost::shared_ptr<Region> r ((*i)->region());
 473
 474                 r->clear_changes ();
 475                 r->set_position (r->position() + distance);
 476                 _session->add_command(new StatefulDiffCommand (r));
 477         }
 478
 479         commit_reversible_command ();
 480 }
 481
 482 void
 483 Editor::nudge_backward_capture_offset ()
 484 {
 485         RegionSelection rs = get_regions_from_selection_and_entered ();
 486
 487         if (!_session || rs.empty()) {
 488                 return;
 489         }
 490
 491         begin_reversible_command (_("nudge forward"));
 492
 493         framepos_t const distance = _session->worst_output_latency();
 494
 495         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 496                 boost::shared_ptr<Region> r ((*i)->region());
 497
 498                 r->clear_changes ();
 499
 500                 if (r->position() > distance) {
 501                         r->set_position (r->position() - distance);
 502                 } else {
 503                         r->set_position (0);
 504                 }
 505                 _session->add_command(new StatefulDiffCommand (r));
 506         }
 507
 508         commit_reversible_command ();
 509 }
 510
 511 /* DISPLAY MOTION */
 512
 513 void
 514 Editor::move_to_start ()
 515 {
 516         _session->goto_start ();
 517 }
 518
 519 void
 520 Editor::move_to_end ()
 521 {
 522
 523         _session->request_locate (_session->current_end_frame());
 524 }
 525
 526 void
 527 Editor::build_region_boundary_cache ()
 528 {
 529         framepos_t pos = 0;
 530         vector<RegionPoint> interesting_points;
 531         boost::shared_ptr<Region> r;
 532         TrackViewList tracks;
 533         bool at_end = false;
 534
 535         region_boundary_cache.clear ();
 536
 537         if (_session == 0) {
 538                 return;
 539         }
 540
 541         switch (_snap_type) {
 542         case SnapToRegionStart:
 543                 interesting_points.push_back (Start);
 544                 break;
 545         case SnapToRegionEnd:
 546                 interesting_points.push_back (End);
 547                 break;
 548         case SnapToRegionSync:
 549                 interesting_points.push_back (SyncPoint);
 550                 break;
 551         case SnapToRegionBoundary:
 552                 interesting_points.push_back (Start);
 553                 interesting_points.push_back (End);
 554                 break;
 555         default:
 556                 fatal << string_compose (_("build_region_boundary_cache called with snap_type = %1"), _snap_type) << endmsg;
 557                 /*NOTREACHED*/
 558                 return;
 559         }
 560
 561         TimeAxisView *ontrack = 0;
 562         TrackViewList tlist;
 563
 564         if (!selection->tracks.empty()) {
 565                 tlist = selection->tracks;
 566         } else {
 567                 tlist = track_views;
 568         }
 569
 570         while (pos < _session->current_end_frame() && !at_end) {
 571
 572                 framepos_t rpos;
 573                 framepos_t lpos = max_framepos;
 574
 575                 for (vector<RegionPoint>::iterator p = interesting_points.begin(); p != interesting_points.end(); ++p) {
 576
 577                         if ((r = find_next_region (pos, *p, 1, tlist, &ontrack)) == 0) {
 578                                 if (*p == interesting_points.back()) {
 579                                         at_end = true;
 580                                 }
 581                                 /* move to next point type */
 582                                 continue;
 583                         }
 584
 585                         switch (*p) {
 586                         case Start:
 587                                 rpos = r->first_frame();
 588                                 break;
 589
 590                         case End:
 591                                 rpos = r->last_frame();
 592                                 break;
 593
 594                         case SyncPoint:
 595                                 rpos = r->sync_position ();
 596                                 break;
 597
 598                         default:
 599                                 break;
 600                         }
 601
 602                         float speed = 1.0f;
 603                         RouteTimeAxisView *rtav;
 604
 605                         if (ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0 ) {
 606                                 if (rtav->track() != 0) {
 607                                         speed = rtav->track()->speed();
 608                                 }
 609                         }
 610
 611                         rpos = track_frame_to_session_frame (rpos, speed);
 612
 613                         if (rpos < lpos) {
 614                                 lpos = rpos;
 615                         }
 616
 617                         /* prevent duplicates, but we don't use set<> because we want to be able
 618                            to sort later.
 619                         */
 620
 621                         vector<framepos_t>::iterator ri;
 622
 623                         for (ri = region_boundary_cache.begin(); ri != region_boundary_cache.end(); ++ri) {
 624                                 if (*ri == rpos) {
 625                                         break;
 626                                 }
 627                         }
 628
 629                         if (ri == region_boundary_cache.end()) {
 630                                 region_boundary_cache.push_back (rpos);
 631                         }
 632                 }
 633
 634                 pos = lpos + 1;
 635         }
 636
 637         /* finally sort to be sure that the order is correct */
 638
 639         sort (region_boundary_cache.begin(), region_boundary_cache.end());
 640 }
 641
 642 boost::shared_ptr<Region>
 643 Editor::find_next_region (framepos_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
 644 {
 645         TrackViewList::iterator i;
 646         framepos_t closest = max_framepos;
 647         boost::shared_ptr<Region> ret;
 648         framepos_t rpos = 0;
 649
 650         float track_speed;
 651         framepos_t track_frame;
 652         RouteTimeAxisView *rtav;
 653
 654         for (i = tracks.begin(); i != tracks.end(); ++i) {
 655
 656                 framecnt_t distance;
 657                 boost::shared_ptr<Region> r;
 658
 659                 track_speed = 1.0f;
 660                 if ( (rtav = dynamic_cast<RouteTimeAxisView*>(*i)) != 0 ) {
 661                         if (rtav->track()!=0)
 662                                 track_speed = rtav->track()->speed();
 663                 }
 664
 665                 track_frame = session_frame_to_track_frame(frame, track_speed);
 666
 667                 if ((r = (*i)->find_next_region (track_frame, point, dir)) == 0) {
 668                         continue;
 669                 }
 670
 671                 switch (point) {
 672                 case Start:
 673                         rpos = r->first_frame ();
 674                         break;
 675
 676                 case End:
 677                         rpos = r->last_frame ();
 678                         break;
 679
 680                 case SyncPoint:
 681                         rpos = r->sync_position ();
 682                         break;
 683                 }
 684
 685                 // rpos is a "track frame", converting it to "_session frame"
 686                 rpos = track_frame_to_session_frame(rpos, track_speed);
 687
 688                 if (rpos > frame) {
 689                         distance = rpos - frame;
 690                 } else {
 691                         distance = frame - rpos;
 692                 }
 693
 694                 if (distance < closest) {
 695                         closest = distance;
 696                         if (ontrack != 0)
 697                                 *ontrack = (*i);
 698                         ret = r;
 699                 }
 700         }
 701
 702         return ret;
 703 }
 704
 705 framepos_t
 706 Editor::find_next_region_boundary (framepos_t pos, int32_t dir, const TrackViewList& tracks)
 707 {
 708         framecnt_t distance = max_framepos;
 709         framepos_t current_nearest = -1;
 710
 711         for (TrackViewList::const_iterator i = tracks.begin(); i != tracks.end(); ++i) {
 712                 framepos_t contender;
 713                 framecnt_t d;
 714
 715                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
 716
 717                 if (!rtv) {
 718                         continue;
 719                 }
 720
 721                 if ((contender = rtv->find_next_region_boundary (pos, dir)) < 0) {
 722                         continue;
 723                 }
 724
 725                 d = ::llabs (pos - contender);
 726
 727                 if (d < distance) {
 728                         current_nearest = contender;
 729                         distance = d;
 730                 }
 731         }
 732
 733         return current_nearest;
 734 }
 735
 736 framepos_t
 737 Editor::get_region_boundary (framepos_t pos, int32_t dir, bool with_selection, bool only_onscreen)
 738 {
 739         framepos_t target;
 740         TrackViewList tvl;
 741
 742         if (with_selection && Config->get_region_boundaries_from_selected_tracks()) {
 743
 744                 if (!selection->tracks.empty()) {
 745
 746                         target = find_next_region_boundary (pos, dir, selection->tracks);
 747
 748                 } else {
 749
 750                         if (only_onscreen || Config->get_region_boundaries_from_onscreen_tracks()) {
 751                                 get_onscreen_tracks (tvl);
 752                                 target = find_next_region_boundary (pos, dir, tvl);
 753                         } else {
 754                                 target = find_next_region_boundary (pos, dir, track_views);
 755                         }
 756                 }
 757
 758         } else {
 759
 760                 if (only_onscreen || Config->get_region_boundaries_from_onscreen_tracks()) {
 761                         get_onscreen_tracks (tvl);
 762                         target = find_next_region_boundary (pos, dir, tvl);
 763                 } else {
 764                         target = find_next_region_boundary (pos, dir, track_views);
 765                 }
 766         }
 767
 768         return target;
 769 }
 770
 771 void
 772 Editor::cursor_to_region_boundary (bool with_selection, int32_t dir)
 773 {
 774         framepos_t pos = playhead_cursor->current_frame;
 775         framepos_t target;
 776
 777         if (!_session) {
 778                 return;
 779         }
 780
 781         // so we don't find the current region again..
 782         if (dir > 0 || pos > 0) {
 783                 pos += dir;
 784         }
 785
 786         if ((target = get_region_boundary (pos, dir, with_selection, false)) < 0) {
 787                 return;
 788         }
 789
 790         _session->request_locate (target);
 791 }
 792
 793 void
 794 Editor::cursor_to_next_region_boundary (bool with_selection)
 795 {
 796         cursor_to_region_boundary (with_selection, 1);
 797 }
 798
 799 void
 800 Editor::cursor_to_previous_region_boundary (bool with_selection)
 801 {
 802         cursor_to_region_boundary (with_selection, -1);
 803 }
 804
 805 void
 806 Editor::cursor_to_region_point (EditorCursor* cursor, RegionPoint point, int32_t dir)
 807 {
 808         boost::shared_ptr<Region> r;
 809         framepos_t pos = cursor->current_frame;
 810
 811         if (!_session) {
 812                 return;
 813         }
 814
 815         TimeAxisView *ontrack = 0;
 816
 817         // so we don't find the current region again..
 818         if (dir>0 || pos>0)
 819                 pos+=dir;
 820
 821         if (!selection->tracks.empty()) {
 822
 823                 r = find_next_region (pos, point, dir, selection->tracks, &ontrack);
 824
 825         } else if (clicked_axisview) {
 826
 827                 TrackViewList t;
 828                 t.push_back (clicked_axisview);
 829
 830                 r = find_next_region (pos, point, dir, t, &ontrack);
 831
 832         } else {
 833
 834                 r = find_next_region (pos, point, dir, track_views, &ontrack);
 835         }
 836
 837         if (r == 0) {
 838                 return;
 839         }
 840
 841         switch (point) {
 842         case Start:
 843                 pos = r->first_frame ();
 844                 break;
 845
 846         case End:
 847                 pos = r->last_frame ();
 848                 break;
 849
 850         case SyncPoint:
 851                 pos = r->sync_position ();
 852                 break;
 853         }
 854
 855         float speed = 1.0f;
 856         RouteTimeAxisView *rtav;
 857
 858         if ( ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0 ) {
 859                 if (rtav->track() != 0) {
 860                         speed = rtav->track()->speed();
 861                 }
 862         }
 863
 864         pos = track_frame_to_session_frame(pos, speed);
 865
 866         if (cursor == playhead_cursor) {
 867                 _session->request_locate (pos);
 868         } else {
 869                 cursor->set_position (pos);
 870         }
 871 }
 872
 873 void
 874 Editor::cursor_to_next_region_point (EditorCursor* cursor, RegionPoint point)
 875 {
 876         cursor_to_region_point (cursor, point, 1);
 877 }
 878
 879 void
 880 Editor::cursor_to_previous_region_point (EditorCursor* cursor, RegionPoint point)
 881 {
 882         cursor_to_region_point (cursor, point, -1);
 883 }
 884
 885 void
 886 Editor::cursor_to_selection_start (EditorCursor *cursor)
 887 {
 888         framepos_t pos = 0;
 889
 890         switch (mouse_mode) {
 891         case MouseObject:
 892                 if (!selection->regions.empty()) {
 893                         pos = selection->regions.start();
 894                 }
 895                 break;
 896
 897         case MouseRange:
 898                 if (!selection->time.empty()) {
 899                         pos = selection->time.start ();
 900                 }
 901                 break;
 902
 903         default:
 904                 return;
 905         }
 906
 907         if (cursor == playhead_cursor) {
 908                 _session->request_locate (pos);
 909         } else {
 910                 cursor->set_position (pos);
 911         }
 912 }
 913
 914 void
 915 Editor::cursor_to_selection_end (EditorCursor *cursor)
 916 {
 917         framepos_t pos = 0;
 918
 919         switch (mouse_mode) {
 920         case MouseObject:
 921                 if (!selection->regions.empty()) {
 922                         pos = selection->regions.end_frame();
 923                 }
 924                 break;
 925
 926         case MouseRange:
 927                 if (!selection->time.empty()) {
 928                         pos = selection->time.end_frame ();
 929                 }
 930                 break;
 931
 932         default:
 933                 return;
 934         }
 935
 936         if (cursor == playhead_cursor) {
 937                 _session->request_locate (pos);
 938         } else {
 939                 cursor->set_position (pos);
 940         }
 941 }
 942
 943 void
 944 Editor::selected_marker_to_region_boundary (bool with_selection, int32_t dir)
 945 {
 946         framepos_t target;
 947         Location* loc;
 948         bool ignored;
 949
 950         if (!_session) {
 951                 return;
 952         }
 953
 954         if (selection->markers.empty()) {
 955                 framepos_t mouse;
 956                 bool ignored;
 957
 958                 if (!mouse_frame (mouse, ignored)) {
 959                         return;
 960                 }
 961
 962                 add_location_mark (mouse);
 963         }
 964
 965         if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
 966                 return;
 967         }
 968
 969         framepos_t pos = loc->start();
 970
 971         // so we don't find the current region again..
 972         if (dir > 0 || pos > 0) {
 973                 pos += dir;
 974         }
 975
 976         if ((target = get_region_boundary (pos, dir, with_selection, false)) < 0) {
 977                 return;
 978         }
 979
 980         loc->move_to (target);
 981 }
 982
 983 void
 984 Editor::selected_marker_to_next_region_boundary (bool with_selection)
 985 {
 986         selected_marker_to_region_boundary (with_selection, 1);
 987 }
 988
 989 void
 990 Editor::selected_marker_to_previous_region_boundary (bool with_selection)
 991 {
 992         selected_marker_to_region_boundary (with_selection, -1);
 993 }
 994
 995 void
 996 Editor::selected_marker_to_region_point (RegionPoint point, int32_t dir)
 997 {
 998         boost::shared_ptr<Region> r;
 999         framepos_t pos;
1000         Location* loc;
1001         bool ignored;
1002
1003         if (!_session || selection->markers.empty()) {
1004                 return;
1005         }
1006
1007         if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1008                 return;
1009         }
1010
1011         TimeAxisView *ontrack = 0;
1012
1013         pos = loc->start();
1014
1015         // so we don't find the current region again..
1016         if (dir>0 || pos>0)
1017                 pos+=dir;
1018
1019         if (!selection->tracks.empty()) {
1020
1021                 r = find_next_region (pos, point, dir, selection->tracks, &ontrack);
1022
1023         } else {
1024
1025                 r = find_next_region (pos, point, dir, track_views, &ontrack);
1026         }
1027
1028         if (r == 0) {
1029                 return;
1030         }
1031
1032         switch (point) {
1033         case Start:
1034                 pos = r->first_frame ();
1035                 break;
1036
1037         case End:
1038                 pos = r->last_frame ();
1039                 break;
1040
1041         case SyncPoint:
1042                 pos = r->adjust_to_sync (r->first_frame());
1043                 break;
1044         }
1045
1046         float speed = 1.0f;
1047         RouteTimeAxisView *rtav;
1048
1049         if (ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0) {
1050                 if (rtav->track() != 0) {
1051                         speed = rtav->track()->speed();
1052                 }
1053         }
1054
1055         pos = track_frame_to_session_frame(pos, speed);
1056
1057         loc->move_to (pos);
1058 }
1059
1060 void
1061 Editor::selected_marker_to_next_region_point (RegionPoint point)
1062 {
1063         selected_marker_to_region_point (point, 1);
1064 }
1065
1066 void
1067 Editor::selected_marker_to_previous_region_point (RegionPoint point)
1068 {
1069         selected_marker_to_region_point (point, -1);
1070 }
1071
1072 void
1073 Editor::selected_marker_to_selection_start ()
1074 {
1075         framepos_t pos = 0;
1076         Location* loc;
1077         bool ignored;
1078
1079         if (!_session || selection->markers.empty()) {
1080                 return;
1081         }
1082
1083         if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1084                 return;
1085         }
1086
1087         switch (mouse_mode) {
1088         case MouseObject:
1089                 if (!selection->regions.empty()) {
1090                         pos = selection->regions.start();
1091                 }
1092                 break;
1093
1094         case MouseRange:
1095                 if (!selection->time.empty()) {
1096                         pos = selection->time.start ();
1097                 }
1098                 break;
1099
1100         default:
1101                 return;
1102         }
1103
1104         loc->move_to (pos);
1105 }
1106
1107 void
1108 Editor::selected_marker_to_selection_end ()
1109 {
1110         framepos_t pos = 0;
1111         Location* loc;
1112         bool ignored;
1113
1114         if (!_session || selection->markers.empty()) {
1115                 return;
1116         }
1117
1118         if ((loc = find_location_from_marker (selection->markers.front(), ignored)) == 0) {
1119                 return;
1120         }
1121
1122         switch (mouse_mode) {
1123         case MouseObject:
1124                 if (!selection->regions.empty()) {
1125                         pos = selection->regions.end_frame();
1126                 }
1127                 break;
1128
1129         case MouseRange:
1130                 if (!selection->time.empty()) {
1131                         pos = selection->time.end_frame ();
1132                 }
1133                 break;
1134
1135         default:
1136                 return;
1137         }
1138
1139         loc->move_to (pos);
1140 }
1141
1142 void
1143 Editor::scroll_playhead (bool forward)
1144 {
1145         framepos_t pos = playhead_cursor->current_frame;
1146         framecnt_t delta = (framecnt_t) floor (current_page_frames() / 0.8);
1147
1148         if (forward) {
1149                 if (pos == max_framepos) {
1150                         return;
1151                 }
1152
1153                 if (pos < max_framepos - delta) {
1154                         pos += delta ;
1155                 } else {
1156                         pos = max_framepos;
1157                 }
1158
1159         } else {
1160
1161                 if (pos == 0) {
1162                         return;
1163                 }
1164
1165                 if (pos > delta) {
1166                         pos -= delta;
1167                 } else {
1168                         pos = 0;
1169                 }
1170         }
1171
1172         _session->request_locate (pos);
1173 }
1174
1175 void
1176 Editor::cursor_align (bool playhead_to_edit)
1177 {
1178         if (!_session) {
1179                 return;
1180         }
1181
1182         if (playhead_to_edit) {
1183
1184                 if (selection->markers.empty()) {
1185                         return;
1186                 }
1187
1188                 _session->request_locate (selection->markers.front()->position(), _session->transport_rolling());
1189
1190         } else {
1191                 /* move selected markers to playhead */
1192
1193                 for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
1194                         bool ignored;
1195
1196                         Location* loc = find_location_from_marker (*i, ignored);
1197
1198                         if (loc->is_mark()) {
1199                                 loc->set_start (playhead_cursor->current_frame);
1200                         } else {
1201                                 loc->set (playhead_cursor->current_frame,
1202                                           playhead_cursor->current_frame + loc->length());
1203                         }
1204                 }
1205         }
1206 }
1207
1208 void
1209 Editor::scroll_backward (float pages)
1210 {
1211         framepos_t const one_page = (framepos_t) rint (_canvas_width * frames_per_unit);
1212         framepos_t const cnt = (framepos_t) floor (pages * one_page);
1213
1214         framepos_t frame;
1215         if (leftmost_frame < cnt) {
1216                 frame = 0;
1217         } else {
1218                 frame = leftmost_frame - cnt;
1219         }
1220
1221         reset_x_origin (frame);
1222 }
1223
1224 void
1225 Editor::scroll_forward (float pages)
1226 {
1227         framepos_t const one_page = (framepos_t) rint (_canvas_width * frames_per_unit);
1228         framepos_t const cnt = (framepos_t) floor (pages * one_page);
1229
1230         framepos_t frame;
1231         if (max_framepos - cnt < leftmost_frame) {
1232                 frame = max_framepos - cnt;
1233         } else {
1234                 frame = leftmost_frame + cnt;
1235         }
1236
1237         reset_x_origin (frame);
1238 }
1239
1240 void
1241 Editor::scroll_tracks_down ()
1242 {
1243         double vert_value = vertical_adjustment.get_value() + vertical_adjustment.get_page_size();
1244         if (vert_value > vertical_adjustment.get_upper() - _canvas_height) {
1245                 vert_value = vertical_adjustment.get_upper() - _canvas_height;
1246         }
1247
1248         vertical_adjustment.set_value (vert_value);
1249 }
1250
1251 void
1252 Editor::scroll_tracks_up ()
1253 {
1254         vertical_adjustment.set_value (vertical_adjustment.get_value() - vertical_adjustment.get_page_size());
1255 }
1256
1257 void
1258 Editor::scroll_tracks_down_line ()
1259 {
1260         double vert_value = vertical_adjustment.get_value() + 60;
1261
1262         if (vert_value > vertical_adjustment.get_upper() - _canvas_height) {
1263                 vert_value = vertical_adjustment.get_upper() - _canvas_height;
1264         }
1265
1266         vertical_adjustment.set_value (vert_value);
1267 }
1268
1269 void
1270 Editor::scroll_tracks_up_line ()
1271 {
1272         reset_y_origin (vertical_adjustment.get_value() - 60);
1273 }
1274
1275 /* ZOOM */
1276
1277 void
1278 Editor::tav_zoom_step (bool coarser)
1279 {
1280         ENSURE_GUI_THREAD (*this, &Editor::temporal_zoom_step, coarser)
1281
1282         _routes->suspend_redisplay ();
1283
1284         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
1285                 TimeAxisView *tv = (static_cast<TimeAxisView*>(*i));
1286                         tv->step_height (coarser);
1287         }
1288
1289         _routes->resume_redisplay ();
1290 }
1291
1292 void
1293 Editor::temporal_zoom_step (bool coarser)
1294 {
1295         ENSURE_GUI_THREAD (*this, &Editor::temporal_zoom_step, coarser)
1296
1297         double nfpu;
1298
1299         nfpu = frames_per_unit;
1300
1301         if (coarser) {
1302                 nfpu *= 1.61803399;
1303         } else {
1304                 nfpu = max(1.0,(nfpu/1.61803399));
1305         }
1306
1307         temporal_zoom (nfpu);
1308 }
1309
1310 void
1311 Editor::temporal_zoom (gdouble fpu)
1312 {
1313         if (!_session) return;
1314
1315         framepos_t current_page = current_page_frames();
1316         framepos_t current_leftmost = leftmost_frame;
1317         framepos_t current_rightmost;
1318         framepos_t current_center;
1319         framepos_t new_page_size;
1320         framepos_t half_page_size;
1321         framepos_t leftmost_after_zoom = 0;
1322         framepos_t where;
1323         bool in_track_canvas;
1324         double nfpu;
1325         double l;
1326
1327         /* XXX this limit is also in ::set_frames_per_unit() */
1328
1329         if (frames_per_unit <= 1.0 && fpu <= frames_per_unit) {
1330                 return;
1331         }
1332
1333         nfpu = fpu;
1334
1335         new_page_size = (framepos_t) floor (_canvas_width * nfpu);
1336         half_page_size = new_page_size / 2;
1337
1338         switch (zoom_focus) {
1339         case ZoomFocusLeft:
1340                 leftmost_after_zoom = current_leftmost;
1341                 break;
1342
1343         case ZoomFocusRight:
1344                 current_rightmost = leftmost_frame + current_page;
1345                 if (current_rightmost < new_page_size) {
1346                         leftmost_after_zoom = 0;
1347                 } else {
1348                         leftmost_after_zoom = current_rightmost - new_page_size;
1349                 }
1350                 break;
1351
1352         case ZoomFocusCenter:
1353                 current_center = current_leftmost + (current_page/2);
1354                 if (current_center < half_page_size) {
1355                         leftmost_after_zoom = 0;
1356                 } else {
1357                         leftmost_after_zoom = current_center - half_page_size;
1358                 }
1359                 break;
1360
1361         case ZoomFocusPlayhead:
1362                 /* centre playhead */
1363                 l = playhead_cursor->current_frame - (new_page_size * 0.5);
1364
1365                 if (l < 0) {
1366                         leftmost_after_zoom = 0;
1367                 } else if (l > max_framepos) {
1368                         leftmost_after_zoom = max_framepos - new_page_size;
1369                 } else {
1370                         leftmost_after_zoom = (framepos_t) l;
1371                 }
1372                 break;
1373
1374         case ZoomFocusMouse:
1375                 /* try to keep the mouse over the same point in the display */
1376
1377                 if (!mouse_frame (where, in_track_canvas)) {
1378                         /* use playhead instead */
1379                         where = playhead_cursor->current_frame;
1380
1381                         if (where < half_page_size) {
1382                                 leftmost_after_zoom = 0;
1383                         } else {
1384                                 leftmost_after_zoom = where - half_page_size;
1385                         }
1386
1387                 } else {
1388
1389                         l = - ((new_page_size * ((where - current_leftmost)/(double)current_page)) - where);
1390
1391                         if (l < 0) {
1392                                 leftmost_after_zoom = 0;
1393                         } else if (l > max_framepos) {
1394                                 leftmost_after_zoom = max_framepos - new_page_size;
1395                         } else {
1396                                 leftmost_after_zoom = (framepos_t) l;
1397                         }
1398                 }
1399
1400                 break;
1401
1402         case ZoomFocusEdit:
1403                 /* try to keep the edit point in the same place */
1404                 where = get_preferred_edit_position ();
1405
1406                 if (where > 0) {
1407
1408                         double l = - ((new_page_size * ((where - current_leftmost)/(double)current_page)) - where);
1409
1410                         if (l < 0) {
1411                                 leftmost_after_zoom = 0;
1412                         } else if (l > max_framepos) {
1413                                 leftmost_after_zoom = max_framepos - new_page_size;
1414                         } else {
1415                                 leftmost_after_zoom = (framepos_t) l;
1416                         }
1417
1418                 } else {
1419                         /* edit point not defined */
1420                         return;
1421                 }
1422                 break;
1423
1424         }
1425
1426         // leftmost_after_zoom = min (leftmost_after_zoom, _session->current_end_frame());
1427
1428         reposition_and_zoom (leftmost_after_zoom, nfpu);
1429 }
1430
1431 void
1432 Editor::temporal_zoom_region (bool both_axes)
1433 {
1434         framepos_t start = max_framepos;
1435         framepos_t end = 0;
1436         set<TimeAxisView*> tracks;
1437
1438         RegionSelection rs = get_regions_from_selection_and_entered ();
1439
1440         if (rs.empty()) {
1441                 return;
1442         }
1443
1444         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
1445
1446                 if ((*i)->region()->position() < start) {
1447                         start = (*i)->region()->position();
1448                 }
1449
1450                 if ((*i)->region()->last_frame() + 1 > end) {
1451                         end = (*i)->region()->last_frame() + 1;
1452                 }
1453
1454                 tracks.insert (&((*i)->get_time_axis_view()));
1455         }
1456
1457         /* now comes an "interesting" hack ... make sure we leave a little space
1458            at each end of the editor so that the zoom doesn't fit the region
1459            precisely to the screen.
1460         */
1461
1462         GdkScreen* screen = gdk_screen_get_default ();
1463         gint pixwidth = gdk_screen_get_width (screen);
1464         gint mmwidth = gdk_screen_get_width_mm (screen);
1465         double pix_per_mm = (double) pixwidth/ (double) mmwidth;
1466         double one_centimeter_in_pixels = pix_per_mm * 10.0;
1467
1468         if ((start == 0 && end == 0) || end < start) {
1469                 return;
1470         }
1471
1472         framepos_t range = end - start;
1473         double new_fpu = (double)range / (double)_canvas_width;
1474         framepos_t extra_samples = (framepos_t) floor (one_centimeter_in_pixels * new_fpu);
1475
1476         if (start > extra_samples) {
1477                 start -= extra_samples;
1478         } else {
1479                 start = 0;
1480         }
1481
1482         if (max_framepos - extra_samples > end) {
1483                 end += extra_samples;
1484         } else {
1485                 end = max_framepos;
1486         }
1487
1488         if (both_axes) {
1489                 /* save visual state with track states included, and prevent
1490                    set_frames_per_unit() from doing it again.
1491                 */
1492                 undo_visual_stack.push_back (current_visual_state(true));
1493                 no_save_visual = true;
1494         }
1495
1496         temporal_zoom_by_frame (start, end, "zoom to region");
1497
1498         if (both_axes) {
1499                 uint32_t per_track_height = (uint32_t) floor ((_canvas_height - canvas_timebars_vsize - 10.0) / tracks.size());
1500
1501                 /* set visible track heights appropriately */
1502
1503                 for (set<TimeAxisView*>::iterator t = tracks.begin(); t != tracks.end(); ++t) {
1504                         (*t)->set_height (per_track_height);
1505                 }
1506
1507                 /* hide irrelevant tracks */
1508
1509                 _routes->suspend_redisplay ();
1510
1511                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
1512                         if (find (tracks.begin(), tracks.end(), (*i)) == tracks.end()) {
1513                                 hide_track_in_display (*i);
1514                         }
1515                 }
1516
1517                 _routes->resume_redisplay ();
1518
1519                 vertical_adjustment.set_value (0.0);
1520                 no_save_visual = false;
1521         }
1522
1523         redo_visual_stack.push_back (current_visual_state());
1524 }
1525
1526 void
1527 Editor::zoom_to_region (bool both_axes)
1528 {
1529         temporal_zoom_region (both_axes);
1530 }
1531
1532 void
1533 Editor::temporal_zoom_selection ()
1534 {
1535         if (!selection) return;
1536
1537         if (selection->time.empty()) {
1538                 return;
1539         }
1540
1541         framepos_t start = selection->time[clicked_selection].start;
1542         framepos_t end = selection->time[clicked_selection].end;
1543
1544         temporal_zoom_by_frame (start, end, "zoom to selection");
1545 }
1546
1547 void
1548 Editor::temporal_zoom_session ()
1549 {
1550         ENSURE_GUI_THREAD (*this, &Editor::temporal_zoom_session)
1551
1552         if (_session) {
1553                 framecnt_t const l = _session->current_end_frame() - _session->current_start_frame();
1554                 double s = _session->current_start_frame() - l * 0.01;
1555                 if (s < 0) {
1556                         s = 0;
1557                 }
1558                 framecnt_t const e = _session->current_end_frame() + l * 0.01;
1559                 temporal_zoom_by_frame (framecnt_t (s), e, "zoom to _session");
1560         }
1561 }
1562
1563 void
1564 Editor::temporal_zoom_by_frame (framepos_t start, framepos_t end, const string & /*op*/)
1565 {
1566         if (!_session) return;
1567
1568         if ((start == 0 && end == 0) || end < start) {
1569                 return;
1570         }
1571
1572         framepos_t range = end - start;
1573
1574         double new_fpu = (double)range / (double)_canvas_width;
1575
1576         framepos_t new_page = (framepos_t) floor (_canvas_width * new_fpu);
1577         framepos_t middle = (framepos_t) floor( (double)start + ((double)range / 2.0f ));
1578         framepos_t new_leftmost = (framepos_t) floor( (double)middle - ((double)new_page/2.0f));
1579
1580         if (new_leftmost > middle) {
1581                 new_leftmost = 0;
1582         }
1583
1584         reposition_and_zoom (new_leftmost, new_fpu);
1585 }
1586
1587 void
1588 Editor::temporal_zoom_to_frame (bool coarser, framepos_t frame)
1589 {
1590         if (!_session) {
1591                 return;
1592         }
1593         double range_before = frame - leftmost_frame;
1594         double new_fpu;
1595
1596         new_fpu = frames_per_unit;
1597
1598         if (coarser) {
1599                 new_fpu *= 1.61803399;
1600                 range_before *= 1.61803399;
1601         } else {
1602                 new_fpu = max(1.0,(new_fpu/1.61803399));
1603                 range_before /= 1.61803399;
1604         }
1605
1606         if (new_fpu == frames_per_unit)  {
1607                 return;
1608         }
1609
1610         framepos_t new_leftmost = frame - (framepos_t)range_before;
1611
1612         if (new_leftmost > frame) {
1613                 new_leftmost = 0;
1614         }
1615
1616         if (new_leftmost < 0) {
1617                 new_leftmost = 0;
1618         }
1619
1620         reposition_and_zoom (new_leftmost, new_fpu);
1621 }
1622
1623
1624 bool
1625 Editor::choose_new_marker_name(string &name) {
1626
1627         if (!Config->get_name_new_markers()) {
1628                 /* don't prompt user for a new name */
1629                 return true;
1630         }
1631
1632         ArdourPrompter dialog (true);
1633
1634         dialog.set_prompt (_("New Name:"));
1635
1636         dialog.set_title (_("New Location Marker"));
1637
1638         dialog.set_name ("MarkNameWindow");
1639         dialog.set_size_request (250, -1);
1640         dialog.set_position (Gtk::WIN_POS_MOUSE);
1641
1642         dialog.add_button (Stock::OK, RESPONSE_ACCEPT);
1643         dialog.set_initial_text (name);
1644
1645         dialog.show ();
1646
1647         switch (dialog.run ()) {
1648         case RESPONSE_ACCEPT:
1649                 break;
1650         default:
1651                 return false;
1652         }
1653
1654         dialog.get_result(name);
1655         return true;
1656
1657 }
1658
1659
1660 void
1661 Editor::add_location_from_selection ()
1662 {
1663         string rangename;
1664
1665         if (selection->time.empty()) {
1666                 return;
1667         }
1668
1669         if (_session == 0 || clicked_axisview == 0) {
1670                 return;
1671         }
1672
1673         framepos_t start = selection->time[clicked_selection].start;
1674         framepos_t end = selection->time[clicked_selection].end;
1675
1676         _session->locations()->next_available_name(rangename,"selection");
1677         Location *location = new Location (*_session, start, end, rangename, Location::IsRangeMarker);
1678
1679         _session->begin_reversible_command (_("add marker"));
1680         XMLNode &before = _session->locations()->get_state();
1681         _session->locations()->add (location, true);
1682         XMLNode &after = _session->locations()->get_state();
1683         _session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1684         _session->commit_reversible_command ();
1685 }
1686
1687 void
1688 Editor::add_location_mark (framepos_t where)
1689 {
1690         string markername;
1691
1692         select_new_marker = true;
1693
1694         _session->locations()->next_available_name(markername,"mark");
1695         if (!choose_new_marker_name(markername)) {
1696                 return;
1697         }
1698         Location *location = new Location (*_session, where, where, markername, Location::IsMark);
1699         _session->begin_reversible_command (_("add marker"));
1700         XMLNode &before = _session->locations()->get_state();
1701         _session->locations()->add (location, true);
1702         XMLNode &after = _session->locations()->get_state();
1703         _session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1704         _session->commit_reversible_command ();
1705 }
1706
1707 void
1708 Editor::add_location_from_playhead_cursor ()
1709 {
1710         add_location_mark (_session->audible_frame());
1711 }
1712
1713 /** Add a range marker around each selected region */
1714 void
1715 Editor::add_locations_from_region ()
1716 {
1717         RegionSelection rs = get_regions_from_selection_and_entered ();
1718
1719         if (rs.empty()) {
1720                 return;
1721         }
1722
1723         _session->begin_reversible_command (selection->regions.size () > 1 ? _("add markers") : _("add marker"));
1724         XMLNode &before = _session->locations()->get_state();
1725
1726         for (RegionSelection::iterator i = rs.begin (); i != rs.end (); ++i) {
1727
1728                 boost::shared_ptr<Region> region = (*i)->region ();
1729
1730                 Location *location = new Location (*_session, region->position(), region->last_frame(), region->name(), Location::IsRangeMarker);
1731
1732                 _session->locations()->add (location, true);
1733         }
1734
1735         XMLNode &after = _session->locations()->get_state();
1736         _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1737         _session->commit_reversible_command ();
1738 }
1739
1740 /** Add a single range marker around all selected regions */
1741 void
1742 Editor::add_location_from_region ()
1743 {
1744         RegionSelection rs = get_regions_from_selection_and_entered ();
1745
1746         if (rs.empty()) {
1747                 return;
1748         }
1749
1750         _session->begin_reversible_command (_("add marker"));
1751         XMLNode &before = _session->locations()->get_state();
1752
1753         string markername;
1754
1755         if (rs.size() > 1) {
1756                 _session->locations()->next_available_name(markername, "regions");
1757         } else {
1758                 RegionView* rv = *(rs.begin());
1759                 boost::shared_ptr<Region> region = rv->region();
1760                 markername = region->name();
1761         }
1762
1763         if (!choose_new_marker_name(markername)) {
1764                 return;
1765         }
1766
1767         // single range spanning all selected
1768         Location *location = new Location (*_session, selection->regions.start(), selection->regions.end_frame(), markername, Location::IsRangeMarker);
1769         _session->locations()->add (location, true);
1770
1771         XMLNode &after = _session->locations()->get_state();
1772         _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1773         _session->commit_reversible_command ();
1774 }
1775
1776 /* MARKS */
1777
1778 void
1779 Editor::jump_forward_to_mark ()
1780 {
1781         if (!_session) {
1782                 return;
1783         }
1784
1785         Location *location = _session->locations()->first_location_after (playhead_cursor->current_frame);
1786
1787         if (location) {
1788                 _session->request_locate (location->start(), _session->transport_rolling());
1789         } else {
1790                 _session->request_locate (_session->current_end_frame());
1791         }
1792 }
1793
1794 void
1795 Editor::jump_backward_to_mark ()
1796 {
1797         if (!_session) {
1798                 return;
1799         }
1800
1801         Location *location = _session->locations()->first_location_before (playhead_cursor->current_frame);
1802
1803         if (location) {
1804                 _session->request_locate (location->start(), _session->transport_rolling());
1805         } else {
1806                 _session->goto_start ();
1807         }
1808 }
1809
1810 void
1811 Editor::set_mark ()
1812 {
1813         framepos_t const pos = _session->audible_frame ();
1814
1815         string markername;
1816         _session->locations()->next_available_name (markername, "mark");
1817
1818         if (!choose_new_marker_name (markername)) {
1819                 return;
1820         }
1821
1822         _session->locations()->add (new Location (*_session, pos, 0, markername, Location::IsMark), true);
1823 }
1824
1825 void
1826 Editor::clear_markers ()
1827 {
1828         if (_session) {
1829                 _session->begin_reversible_command (_("clear markers"));
1830                 XMLNode &before = _session->locations()->get_state();
1831                 _session->locations()->clear_markers ();
1832                 XMLNode &after = _session->locations()->get_state();
1833                 _session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1834                 _session->commit_reversible_command ();
1835         }
1836 }
1837
1838 void
1839 Editor::clear_ranges ()
1840 {
1841         if (_session) {
1842                 _session->begin_reversible_command (_("clear ranges"));
1843                 XMLNode &before = _session->locations()->get_state();
1844
1845                 Location * looploc = _session->locations()->auto_loop_location();
1846                 Location * punchloc = _session->locations()->auto_punch_location();
1847                 Location * sessionloc = _session->locations()->session_range_location();
1848
1849                 _session->locations()->clear_ranges ();
1850                 // re-add these
1851                 if (looploc) _session->locations()->add (looploc);
1852                 if (punchloc) _session->locations()->add (punchloc);
1853                 if (sessionloc) _session->locations()->add (sessionloc);
1854
1855                 XMLNode &after = _session->locations()->get_state();
1856                 _session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1857                 _session->commit_reversible_command ();
1858         }
1859 }
1860
1861 void
1862 Editor::clear_locations ()
1863 {
1864         _session->begin_reversible_command (_("clear locations"));
1865         XMLNode &before = _session->locations()->get_state();
1866         _session->locations()->clear ();
1867         XMLNode &after = _session->locations()->get_state();
1868         _session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1869         _session->commit_reversible_command ();
1870         _session->locations()->clear ();
1871 }
1872
1873 void
1874 Editor::unhide_markers ()
1875 {
1876         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1877                 Location *l = (*i).first;
1878                 if (l->is_hidden() && l->is_mark()) {
1879                         l->set_hidden(false, this);
1880                 }
1881         }
1882 }
1883
1884 void
1885 Editor::unhide_ranges ()
1886 {
1887         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1888                 Location *l = (*i).first;
1889                 if (l->is_hidden() && l->is_range_marker()) {
1890                         l->set_hidden(false, this);
1891                 }
1892         }
1893 }
1894
1895 /* INSERT/REPLACE */
1896
1897 void
1898 Editor::insert_region_list_drag (boost::shared_ptr<Region> region, int x, int y)
1899 {
1900         double wx, wy;
1901         double cx, cy;
1902         framepos_t where;
1903         RouteTimeAxisView *rtv = 0;
1904         boost::shared_ptr<Playlist> playlist;
1905
1906         track_canvas->window_to_world (x, y, wx, wy);
1907
1908         GdkEvent event;
1909         event.type = GDK_BUTTON_RELEASE;
1910         event.button.x = wx;
1911         event.button.y = wy;
1912
1913         where = event_frame (&event, &cx, &cy);
1914
1915         if (where < leftmost_frame || where > leftmost_frame + current_page_frames()) {
1916                 /* clearly outside canvas area */
1917                 return;
1918         }
1919
1920         std::pair<TimeAxisView*, int> tv = trackview_by_y_position (cy);
1921         if (tv.first == 0) {
1922                 return;
1923         }
1924
1925         if ((rtv = dynamic_cast<RouteTimeAxisView*> (tv.first)) == 0) {
1926                 return;
1927         }
1928
1929         if ((playlist = rtv->playlist()) == 0) {
1930                 return;
1931         }
1932
1933         snap_to (where);
1934
1935         begin_reversible_command (_("insert dragged region"));
1936         playlist->clear_changes ();
1937         playlist->add_region (RegionFactory::create (region, true), where, 1.0);
1938         _session->add_command(new StatefulDiffCommand (playlist));
1939         commit_reversible_command ();
1940 }
1941
1942 void
1943 Editor::insert_route_list_drag (boost::shared_ptr<Route> route, int x, int y)
1944 {
1945         double wx, wy;
1946         double cx, cy;
1947         RouteTimeAxisView *dest_rtv = 0;
1948         RouteTimeAxisView *source_rtv = 0;
1949
1950         track_canvas->window_to_world (x, y, wx, wy);
1951         wx += horizontal_position ();
1952         wy += vertical_adjustment.get_value();
1953
1954         GdkEvent event;
1955         event.type = GDK_BUTTON_RELEASE;
1956         event.button.x = wx;
1957         event.button.y = wy;
1958
1959         event_frame (&event, &cx, &cy);
1960
1961         std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (cy);
1962         if (tv.first == 0) {
1963                 return;
1964         }
1965
1966         if ((dest_rtv = dynamic_cast<RouteTimeAxisView*> (tv.first)) == 0) {
1967                 return;
1968         }
1969
1970         /* use this drag source to add underlay to a track. But we really don't care
1971            about the Route, only the view of the route, so find it first */
1972         for(TrackViewList::iterator it = track_views.begin(); it != track_views.end(); ++it) {
1973                 if((source_rtv = dynamic_cast<RouteTimeAxisView*>(*it)) == 0) {
1974                         continue;
1975                 }
1976
1977                 if(source_rtv->route() == route && source_rtv != dest_rtv) {
1978                         dest_rtv->add_underlay(source_rtv->view());
1979                         break;
1980                 }
1981         }
1982 }
1983
1984 void
1985 Editor::insert_region_list_selection (float times)
1986 {
1987         RouteTimeAxisView *tv = 0;
1988         boost::shared_ptr<Playlist> playlist;
1989
1990         if (clicked_routeview != 0) {
1991                 tv = clicked_routeview;
1992         } else if (!selection->tracks.empty()) {
1993                 if ((tv = dynamic_cast<RouteTimeAxisView*>(selection->tracks.front())) == 0) {
1994                         return;
1995                 }
1996         } else if (entered_track != 0) {
1997                 if ((tv = dynamic_cast<RouteTimeAxisView*>(entered_track)) == 0) {
1998                         return;
1999                 }
2000         } else {
2001                 return;
2002         }
2003
2004         if ((playlist = tv->playlist()) == 0) {
2005                 return;
2006         }
2007
2008         boost::shared_ptr<Region> region = _regions->get_single_selection ();
2009         if (region == 0) {
2010                 return;
2011         }
2012
2013         begin_reversible_command (_("insert region"));
2014         playlist->clear_changes ();
2015         playlist->add_region ((RegionFactory::create (region, true)), get_preferred_edit_position(), times);
2016         _session->add_command(new StatefulDiffCommand (playlist));
2017         commit_reversible_command ();
2018 }
2019
2020 /* BUILT-IN EFFECTS */
2021
2022 void
2023 Editor::reverse_selection ()
2024 {
2025
2026 }
2027
2028 /* GAIN ENVELOPE EDITING */
2029
2030 void
2031 Editor::edit_envelope ()
2032 {
2033 }
2034
2035 /* PLAYBACK */
2036
2037 void
2038 Editor::transition_to_rolling (bool fwd)
2039 {
2040         if (!_session) {
2041                 return;
2042         }
2043
2044         if (_session->config.get_external_sync()) {
2045                 switch (_session->config.get_sync_source()) {
2046                 case JACK:
2047                         break;
2048                 default:
2049                         /* transport controlled by the master */
2050                         return;
2051                 }
2052         }
2053
2054         if (_session->is_auditioning()) {
2055                 _session->cancel_audition ();
2056                 return;
2057         }
2058
2059         _session->request_transport_speed (fwd ? 1.0f : -1.0f);
2060 }
2061
2062 void
2063 Editor::play_from_start ()
2064 {
2065         _session->request_locate (_session->current_start_frame(), true);
2066 }
2067
2068 void
2069 Editor::play_from_edit_point ()
2070 {
2071         _session->request_locate (get_preferred_edit_position(), true);
2072 }
2073
2074 void
2075 Editor::play_from_edit_point_and_return ()
2076 {
2077         framepos_t start_frame;
2078         framepos_t return_frame;
2079
2080         start_frame = get_preferred_edit_position (true);
2081
2082         if (_session->transport_rolling()) {
2083                 _session->request_locate (start_frame, false);
2084                 return;
2085         }
2086
2087         /* don't reset the return frame if its already set */
2088
2089         if ((return_frame = _session->requested_return_frame()) < 0) {
2090                 return_frame = _session->audible_frame();
2091         }
2092
2093         if (start_frame >= 0) {
2094                 _session->request_roll_at_and_return (start_frame, return_frame);
2095         }
2096 }
2097
2098 void
2099 Editor::play_selection ()
2100 {
2101         if (selection->time.empty()) {
2102                 return;
2103         }
2104
2105         _session->request_play_range (&selection->time, true);
2106 }
2107
2108 void
2109 Editor::play_location (Location& location)
2110 {
2111         if (location.start() <= location.end()) {
2112                 return;
2113         }
2114
2115         _session->request_bounded_roll (location.start(), location.end());
2116 }
2117
2118 void
2119 Editor::loop_location (Location& location)
2120 {
2121         if (location.start() <= location.end()) {
2122                 return;
2123         }
2124
2125         Location* tll;
2126
2127         if ((tll = transport_loop_location()) != 0) {
2128                 tll->set (location.start(), location.end());
2129
2130                 // enable looping, reposition and start rolling
2131                 _session->request_play_loop (true);
2132                 _session->request_locate (tll->start(), true);
2133         }
2134 }
2135
2136 void
2137 Editor::raise_region ()
2138 {
2139         selection->foreach_region (&Region::raise);
2140 }
2141
2142 void
2143 Editor::raise_region_to_top ()
2144 {
2145         selection->foreach_region (&Region::raise_to_top);
2146 }
2147
2148 void
2149 Editor::lower_region ()
2150 {
2151         selection->foreach_region (&Region::lower);
2152 }
2153
2154 void
2155 Editor::lower_region_to_bottom ()
2156 {
2157         selection->foreach_region (&Region::lower_to_bottom);
2158 }
2159
2160 /** Show the region editor for the selected regions */
2161 void
2162 Editor::show_region_properties ()
2163 {
2164         selection->foreach_regionview (&RegionView::show_region_editor);
2165 }
2166
2167 /** Show the midi list editor for the selected MIDI regions */
2168 void
2169 Editor::show_midi_list_editor ()
2170 {
2171         selection->foreach_midi_regionview (&MidiRegionView::show_list_editor);
2172 }
2173
2174 void
2175 Editor::rename_region ()
2176 {
2177         RegionSelection rs = get_regions_from_selection_and_entered ();
2178
2179         if (rs.empty()) {
2180                 return;
2181         }
2182
2183         ArdourDialog d (*this, _("Rename Region"), true, false);
2184         Entry entry;
2185         Label label (_("New name:"));
2186         HBox hbox;
2187
2188         hbox.set_spacing (6);
2189         hbox.pack_start (label, false, false);
2190         hbox.pack_start (entry, true, true);
2191
2192         d.get_vbox()->set_border_width (12);
2193         d.get_vbox()->pack_start (hbox, false, false);
2194
2195         d.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2196         d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
2197
2198         d.set_size_request (300, -1);
2199         d.set_position (Gtk::WIN_POS_MOUSE);
2200
2201         entry.set_text (rs.front()->region()->name());
2202         entry.select_region (0, -1);
2203
2204         entry.signal_activate().connect (sigc::bind (sigc::mem_fun (d, &Dialog::response), RESPONSE_OK));
2205
2206         d.show_all ();
2207
2208         entry.grab_focus();
2209
2210         int const ret = d.run();
2211
2212         d.hide ();
2213
2214         if (ret != RESPONSE_OK) {
2215                 return;
2216         }
2217
2218         std::string str = entry.get_text();
2219         strip_whitespace_edges (str);
2220         if (!str.empty()) {
2221                 rs.front()->region()->set_name (str);
2222                 _regions->redisplay ();
2223         }
2224 }
2225
2226 void
2227 Editor::audition_playlist_region_via_route (boost::shared_ptr<Region> region, Route& route)
2228 {
2229         if (_session->is_auditioning()) {
2230                 _session->cancel_audition ();
2231         }
2232
2233         // note: some potential for creativity here, because region doesn't
2234         // have to belong to the playlist that Route is handling
2235
2236         // bool was_soloed = route.soloed();
2237
2238         route.set_solo (true, this);
2239
2240         _session->request_bounded_roll (region->position(), region->position() + region->length());
2241
2242         /* XXX how to unset the solo state ? */
2243 }
2244
2245 /** Start an audition of the first selected region */
2246 void
2247 Editor::play_edit_range ()
2248 {
2249         framepos_t start, end;
2250
2251         if (get_edit_op_range (start, end)) {
2252                 _session->request_bounded_roll (start, end);
2253         }
2254 }
2255
2256 void
2257 Editor::play_selected_region ()
2258 {
2259         framepos_t start = max_framepos;
2260         framepos_t end = 0;
2261
2262         RegionSelection rs = get_regions_from_selection_and_entered ();
2263
2264         if (rs.empty()) {
2265                 return;
2266         }
2267
2268         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2269                 if ((*i)->region()->position() < start) {
2270                         start = (*i)->region()->position();
2271                 }
2272                 if ((*i)->region()->last_frame() + 1 > end) {
2273                         end = (*i)->region()->last_frame() + 1;
2274                 }
2275         }
2276
2277         _session->request_bounded_roll (start, end);
2278 }
2279
2280 void
2281 Editor::audition_playlist_region_standalone (boost::shared_ptr<Region> region)
2282 {
2283         _session->audition_region (region);
2284 }
2285
2286 void
2287 Editor::region_from_selection ()
2288 {
2289         if (clicked_axisview == 0) {
2290                 return;
2291         }
2292
2293         if (selection->time.empty()) {
2294                 return;
2295         }
2296
2297         framepos_t start = selection->time[clicked_selection].start;
2298         framepos_t end = selection->time[clicked_selection].end;
2299
2300         TrackViewList tracks = get_tracks_for_range_action ();
2301
2302         framepos_t selection_cnt = end - start + 1;
2303
2304         for (TrackSelection::iterator i = tracks.begin(); i != tracks.end(); ++i) {
2305                 boost::shared_ptr<Region> current;
2306                 boost::shared_ptr<Playlist> pl;
2307                 framepos_t internal_start;
2308                 string new_name;
2309
2310                 if ((pl = (*i)->playlist()) == 0) {
2311                         continue;
2312                 }
2313
2314                 if ((current = pl->top_region_at (start)) == 0) {
2315                         continue;
2316                 }
2317
2318                 internal_start = start - current->position();
2319                 RegionFactory::region_name (new_name, current->name(), true);
2320
2321                 PropertyList plist;
2322
2323                 plist.add (ARDOUR::Properties::start, current->start() + internal_start);
2324                 plist.add (ARDOUR::Properties::length, selection_cnt);
2325                 plist.add (ARDOUR::Properties::name, new_name);
2326                 plist.add (ARDOUR::Properties::layer, 0);
2327
2328                 boost::shared_ptr<Region> region (RegionFactory::create (current, plist));
2329         }
2330 }
2331
2332 void
2333 Editor::create_region_from_selection (vector<boost::shared_ptr<Region> >& new_regions)
2334 {
2335         if (selection->time.empty() || selection->tracks.empty()) {
2336                 return;
2337         }
2338
2339         framepos_t start = selection->time[clicked_selection].start;
2340         framepos_t end = selection->time[clicked_selection].end;
2341
2342         sort_track_selection ();
2343
2344         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2345                 boost::shared_ptr<Region> current;
2346                 boost::shared_ptr<Playlist> playlist;
2347                 framepos_t internal_start;
2348                 string new_name;
2349
2350                 if ((playlist = (*i)->playlist()) == 0) {
2351                         continue;
2352                 }
2353
2354                 if ((current = playlist->top_region_at(start)) == 0) {
2355                         continue;
2356                 }
2357
2358                 internal_start = start - current->position();
2359                 RegionFactory::region_name (new_name, current->name(), true);
2360
2361                 PropertyList plist;
2362
2363                 plist.add (ARDOUR::Properties::start, current->start() + internal_start);
2364                 plist.add (ARDOUR::Properties::length, end - start + 1);
2365                 plist.add (ARDOUR::Properties::name, new_name);
2366
2367                 new_regions.push_back (RegionFactory::create (current, plist));
2368         }
2369 }
2370
2371 void
2372 Editor::split_multichannel_region ()
2373 {
2374         RegionSelection rs = get_regions_from_selection_and_entered ();
2375
2376         if (rs.empty()) {
2377                 return;
2378         }
2379
2380         vector< boost::shared_ptr<Region> > v;
2381
2382         for (list<RegionView*>::iterator x = rs.begin(); x != rs.end(); ++x) {
2383                 (*x)->region()->separate_by_channel (*_session, v);
2384         }
2385 }
2386
2387 void
2388 Editor::new_region_from_selection ()
2389 {
2390         region_from_selection ();
2391         cancel_selection ();
2392 }
2393
2394 static void
2395 add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
2396 {
2397         switch (rv->region()->coverage (ar->start, ar->end - 1)) {
2398         case OverlapNone:
2399                 break;
2400         default:
2401                 rs->push_back (rv);
2402         }
2403 }
2404
2405 /** Return either:
2406  *    - selected tracks, or if there are none...
2407  *    - tracks containing selected regions, or if there are none...
2408  *    - all tracks
2409  * @return tracks.
2410  */
2411 TrackViewList
2412 Editor::get_tracks_for_range_action () const
2413 {
2414         TrackViewList t;
2415
2416         if (selection->tracks.empty()) {
2417
2418                 /* use tracks with selected regions */
2419
2420                 RegionSelection rs = selection->regions;
2421
2422                 for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2423                         TimeAxisView* tv = &(*i)->get_time_axis_view();
2424
2425                         if (!t.contains (tv)) {
2426                                 t.push_back (tv);
2427                         }
2428                 }
2429
2430                 if (t.empty()) {
2431                         /* no regions and no tracks: use all tracks */
2432                         t = track_views;
2433                 }
2434
2435         } else {
2436
2437                 t = selection->tracks;
2438         }
2439
2440         return t;
2441 }
2442
2443 void
2444 Editor::separate_regions_between (const TimeSelection& ts)
2445 {
2446         bool in_command = false;
2447         boost::shared_ptr<Playlist> playlist;
2448         RegionSelection new_selection;
2449
2450         TrackViewList tmptracks = get_tracks_for_range_action ();
2451         sort_track_selection (&tmptracks);
2452
2453         for (TrackSelection::iterator i = tmptracks.begin(); i != tmptracks.end(); ++i) {
2454
2455                 RouteTimeAxisView* rtv;
2456
2457                 if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
2458
2459                         if (rtv->is_track()) {
2460
2461                                 /* no edits to destructive tracks */
2462
2463                                 if (rtv->track()->destructive()) {
2464                                         continue;
2465                                 }
2466
2467                                 if ((playlist = rtv->playlist()) != 0) {
2468
2469                                         playlist->clear_changes ();
2470
2471                                         /* XXX need to consider musical time selections here at some point */
2472
2473                                         double speed = rtv->track()->speed();
2474
2475
2476                                         for (list<AudioRange>::const_iterator t = ts.begin(); t != ts.end(); ++t) {
2477
2478                                                 sigc::connection c = rtv->view()->RegionViewAdded.connect (
2479                                                                 sigc::mem_fun(*this, &Editor::collect_new_region_view));
2480
2481                                                 latest_regionviews.clear ();
2482
2483                                                 playlist->partition ((framepos_t)((*t).start * speed),
2484                                                                 (framepos_t)((*t).end * speed), false);
2485
2486                                                 c.disconnect ();
2487
2488                                                 if (!latest_regionviews.empty()) {
2489
2490                                                         rtv->view()->foreach_regionview (sigc::bind (
2491                                                                                 sigc::ptr_fun (add_if_covered),
2492                                                                                 &(*t), &new_selection));
2493
2494                                                         if (!in_command) {
2495                                                                 begin_reversible_command (_("separate"));
2496                                                                 in_command = true;
2497                                                         }
2498
2499                                                         /* pick up changes to existing regions */
2500
2501                                                         vector<Command*> cmds;
2502                                                         playlist->rdiff (cmds);
2503                                                         _session->add_commands (cmds);
2504
2505                                                         /* pick up changes to the playlist itself (adds/removes)
2506                                                          */
2507
2508                                                         _session->add_command(new StatefulDiffCommand (playlist));
2509                                                 }
2510                                         }
2511                                 }
2512                         }
2513                 }
2514         }
2515
2516         if (in_command) {
2517                 selection->set (new_selection);
2518                 set_mouse_mode (MouseObject);
2519
2520                 commit_reversible_command ();
2521         }
2522 }
2523
2524 struct PlaylistState {
2525     boost::shared_ptr<Playlist> playlist;
2526     XMLNode*  before;
2527 };
2528
2529 /** Take tracks from get_tracks_for_range_action and cut any regions
2530  *  on those tracks so that the tracks are empty over the time
2531  *  selection.
2532  */
2533 void
2534 Editor::separate_region_from_selection ()
2535 {
2536         /* preferentially use *all* ranges in the time selection if we're in range mode
2537            to allow discontiguous operation, since get_edit_op_range() currently
2538            returns a single range.
2539         */
2540
2541         if (mouse_mode == MouseRange && !selection->time.empty()) {
2542
2543                 separate_regions_between (selection->time);
2544
2545         } else {
2546
2547                 framepos_t start;
2548                 framepos_t end;
2549
2550                 if (get_edit_op_range (start, end)) {
2551
2552                         AudioRange ar (start, end, 1);
2553                         TimeSelection ts;
2554                         ts.push_back (ar);
2555
2556                         separate_regions_between (ts);
2557                 }
2558         }
2559 }
2560
2561 void
2562 Editor::separate_region_from_punch ()
2563 {
2564         Location* loc  = _session->locations()->auto_punch_location();
2565         if (loc) {
2566                 separate_regions_using_location (*loc);
2567         }
2568 }
2569
2570 void
2571 Editor::separate_region_from_loop ()
2572 {
2573         Location* loc  = _session->locations()->auto_loop_location();
2574         if (loc) {
2575                 separate_regions_using_location (*loc);
2576         }
2577 }
2578
2579 void
2580 Editor::separate_regions_using_location (Location& loc)
2581 {
2582         if (loc.is_mark()) {
2583                 return;
2584         }
2585
2586         AudioRange ar (loc.start(), loc.end(), 1);
2587         TimeSelection ts;
2588
2589         ts.push_back (ar);
2590
2591         separate_regions_between (ts);
2592 }
2593
2594 /** Separate regions under the selected region */
2595 void
2596 Editor::separate_under_selected_regions ()
2597 {
2598         vector<PlaylistState> playlists;
2599
2600         RegionSelection rs;
2601
2602         rs = get_regions_from_selection_and_entered();
2603
2604         if (!_session || rs.empty()) {
2605                 return;
2606         }
2607
2608         begin_reversible_command (_("separate region under"));
2609
2610         list<boost::shared_ptr<Region> > regions_to_remove;
2611
2612         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2613                 // we can't just remove the region(s) in this loop because
2614                 // this removes them from the RegionSelection, and they thus
2615                 // disappear from underneath the iterator, and the ++i above
2616                 // SEGVs in a puzzling fashion.
2617
2618                 // so, first iterate over the regions to be removed from rs and
2619                 // add them to the regions_to_remove list, and then
2620                 // iterate over the list to actually remove them.
2621
2622                 regions_to_remove.push_back ((*i)->region());
2623         }
2624
2625         for (list<boost::shared_ptr<Region> >::iterator rl = regions_to_remove.begin(); rl != regions_to_remove.end(); ++rl) {
2626
2627                 boost::shared_ptr<Playlist> playlist = (*rl)->playlist();
2628
2629                 if (!playlist) {
2630                         // is this check necessary?
2631                         continue;
2632                 }
2633
2634                 vector<PlaylistState>::iterator i;
2635
2636                 //only take state if this is a new playlist.
2637                 for (i = playlists.begin(); i != playlists.end(); ++i) {
2638                         if ((*i).playlist == playlist) {
2639                                 break;
2640                         }
2641                 }
2642
2643                 if (i == playlists.end()) {
2644
2645                         PlaylistState before;
2646                         before.playlist = playlist;
2647                         before.before = &playlist->get_state();
2648
2649                         playlist->freeze ();
2650                         playlists.push_back(before);
2651                 }
2652
2653                 //Partition on the region bounds
2654                 playlist->partition ((*rl)->first_frame() - 1, (*rl)->last_frame() + 1, true);
2655
2656                 //Re-add region that was just removed due to the partition operation
2657                 playlist->add_region( (*rl), (*rl)->first_frame() );
2658         }
2659
2660         vector<PlaylistState>::iterator pl;
2661
2662         for (pl = playlists.begin(); pl != playlists.end(); ++pl) {
2663                 (*pl).playlist->thaw ();
2664                 _session->add_command(new MementoCommand<Playlist>(*(*pl).playlist, (*pl).before, &(*pl).playlist->get_state()));
2665         }
2666
2667         commit_reversible_command ();
2668 }
2669
2670 void
2671 Editor::crop_region_to_selection ()
2672 {
2673         if (!selection->time.empty()) {
2674
2675                 crop_region_to (selection->time.start(), selection->time.end_frame());
2676
2677         } else {
2678
2679                 framepos_t start;
2680                 framepos_t end;
2681
2682                 if (get_edit_op_range (start, end)) {
2683                         crop_region_to (start, end);
2684                 }
2685         }
2686
2687 }
2688
2689 void
2690 Editor::crop_region_to (framepos_t start, framepos_t end)
2691 {
2692         vector<boost::shared_ptr<Playlist> > playlists;
2693         boost::shared_ptr<Playlist> playlist;
2694         TrackViewList* ts;
2695
2696         if (selection->tracks.empty()) {
2697                 ts = &track_views;
2698         } else {
2699                 sort_track_selection ();
2700                 ts = &selection->tracks;
2701         }
2702
2703         for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
2704
2705                 RouteTimeAxisView* rtv;
2706
2707                 if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
2708
2709                         boost::shared_ptr<Track> t = rtv->track();
2710
2711                         if (t != 0 && ! t->destructive()) {
2712
2713                                 if ((playlist = rtv->playlist()) != 0) {
2714                                         playlists.push_back (playlist);
2715                                 }
2716                         }
2717                 }
2718         }
2719
2720         if (playlists.empty()) {
2721                 return;
2722         }
2723
2724         framepos_t the_start;
2725         framepos_t the_end;
2726         framepos_t cnt;
2727
2728         begin_reversible_command (_("trim to selection"));
2729
2730         for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
2731
2732                 boost::shared_ptr<Region> region;
2733
2734                 the_start = start;
2735
2736                 if ((region = (*i)->top_region_at(the_start)) == 0) {
2737                         continue;
2738                 }
2739
2740                 /* now adjust lengths to that we do the right thing
2741                    if the selection extends beyond the region
2742                 */
2743
2744                 the_start = max (the_start, (framepos_t) region->position());
2745                 if (max_framepos - the_start < region->length()) {
2746                         the_end = the_start + region->length() - 1;
2747                 } else {
2748                         the_end = max_framepos;
2749                 }
2750                 the_end = min (end, the_end);
2751                 cnt = the_end - the_start + 1;
2752
2753                 region->clear_changes ();
2754                 region->trim_to (the_start, cnt);
2755                 _session->add_command (new StatefulDiffCommand (region));
2756         }
2757
2758         commit_reversible_command ();
2759 }
2760
2761 void
2762 Editor::region_fill_track ()
2763 {
2764         RegionSelection rs = get_regions_from_selection_and_entered ();
2765
2766         if (!_session || rs.empty()) {
2767                 return;
2768         }
2769
2770         framepos_t const end = _session->current_end_frame ();
2771
2772         begin_reversible_command (Operations::region_fill);
2773
2774         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2775
2776                 boost::shared_ptr<Region> region ((*i)->region());
2777
2778                 boost::shared_ptr<Playlist> pl = region->playlist();
2779
2780                 if (end <= region->last_frame()) {
2781                         return;
2782                 }
2783
2784                 double times = (double) (end - region->last_frame()) / (double) region->length();
2785
2786                 if (times == 0) {
2787                         return;
2788                 }
2789
2790                 pl->clear_changes ();
2791                 pl->add_region (RegionFactory::create (region, true), region->last_frame(), times);
2792                 _session->add_command (new StatefulDiffCommand (pl));
2793         }
2794
2795         commit_reversible_command ();
2796 }
2797
2798 void
2799 Editor::region_fill_selection ()
2800 {
2801         if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
2802                 return;
2803         }
2804
2805         if (selection->time.empty()) {
2806                 return;
2807         }
2808
2809         boost::shared_ptr<Region> region = _regions->get_single_selection ();
2810         if (region == 0) {
2811                 return;
2812         }
2813
2814         framepos_t start = selection->time[clicked_selection].start;
2815         framepos_t end = selection->time[clicked_selection].end;
2816
2817         boost::shared_ptr<Playlist> playlist;
2818
2819         if (selection->tracks.empty()) {
2820                 return;
2821         }
2822
2823         framepos_t selection_length = end - start;
2824         float times = (float)selection_length / region->length();
2825
2826         begin_reversible_command (Operations::fill_selection);
2827
2828         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2829
2830                 if ((playlist = (*i)->playlist()) == 0) {
2831                         continue;
2832                 }
2833
2834                 playlist->clear_changes ();
2835                 playlist->add_region (RegionFactory::create (region, true), start, times);
2836                 _session->add_command (new StatefulDiffCommand (playlist));
2837         }
2838
2839         commit_reversible_command ();
2840 }
2841
2842 void
2843 Editor::set_region_sync_position ()
2844 {
2845         set_sync_point (get_preferred_edit_position (), get_regions_from_selection_and_edit_point ());
2846 }
2847
2848 void
2849 Editor::set_sync_point (framepos_t where, const RegionSelection& rs)
2850 {
2851         bool in_command = false;
2852
2853         for (RegionSelection::const_iterator r = rs.begin(); r != rs.end(); ++r) {
2854
2855                 if (!(*r)->region()->covers (where)) {
2856                         continue;
2857                 }
2858
2859                 boost::shared_ptr<Region> region ((*r)->region());
2860
2861                 if (!in_command) {
2862                         begin_reversible_command (_("set sync point"));
2863                         in_command = true;
2864                 }
2865
2866                 region->clear_changes ();
2867                 region->set_sync_position (where);
2868                 _session->add_command(new StatefulDiffCommand (region));
2869         }
2870
2871         if (in_command) {
2872                 commit_reversible_command ();
2873         }
2874 }
2875
2876 /** Remove the sync positions of the selection */
2877 void
2878 Editor::remove_region_sync ()
2879 {
2880         RegionSelection rs = get_regions_from_selection_and_entered ();
2881
2882         if (rs.empty()) {
2883                 return;
2884         }
2885
2886         begin_reversible_command (_("remove region sync"));
2887
2888         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2889
2890                 (*i)->region()->clear_changes ();
2891                 (*i)->region()->clear_sync_position ();
2892                 _session->add_command(new StatefulDiffCommand ((*i)->region()));
2893         }
2894
2895         commit_reversible_command ();
2896 }
2897
2898 void
2899 Editor::naturalize_region ()
2900 {
2901         RegionSelection rs = get_regions_from_selection_and_entered ();
2902
2903         if (rs.empty()) {
2904                 return;
2905         }
2906
2907         if (rs.size() > 1) {
2908                 begin_reversible_command (_("move regions to original position"));
2909         } else {
2910                 begin_reversible_command (_("move region to original position"));
2911         }
2912
2913         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
2914                 (*i)->region()->clear_changes ();
2915                 (*i)->region()->move_to_natural_position ();
2916                 _session->add_command (new StatefulDiffCommand ((*i)->region()));
2917         }
2918
2919         commit_reversible_command ();
2920 }
2921
2922 void
2923 Editor::align_regions (RegionPoint what)
2924 {
2925         RegionSelection const rs = get_regions_from_selection_and_edit_point ();
2926
2927         if (rs.empty()) {
2928                 return;
2929         }
2930
2931         begin_reversible_command (_("align selection"));
2932
2933         framepos_t const position = get_preferred_edit_position ();
2934
2935         for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
2936                 align_region_internal ((*i)->region(), what, position);
2937         }
2938
2939         commit_reversible_command ();
2940 }
2941
2942 struct RegionSortByTime {
2943     bool operator() (const RegionView* a, const RegionView* b) {
2944             return a->region()->position() < b->region()->position();
2945     }
2946 };
2947
2948 void
2949 Editor::align_regions_relative (RegionPoint point)
2950 {
2951         RegionSelection const rs = get_regions_from_selection_and_edit_point ();
2952
2953         if (rs.empty()) {
2954                 return;
2955         }
2956
2957         framepos_t const position = get_preferred_edit_position ();
2958
2959         framepos_t distance = 0;
2960         framepos_t pos = 0;
2961         int dir = 1;
2962
2963         list<RegionView*> sorted;
2964         rs.by_position (sorted);
2965
2966         boost::shared_ptr<Region> r ((*sorted.begin())->region());
2967
2968         switch (point) {
2969         case Start:
2970                 pos = position;
2971                 if (position > r->position()) {
2972                         distance = position - r->position();
2973                 } else {
2974                         distance = r->position() - position;
2975                         dir = -1;
2976                 }
2977                 break;
2978
2979         case End:
2980                 if (position > r->last_frame()) {
2981                         distance = position - r->last_frame();
2982                         pos = r->position() + distance;
2983                 } else {
2984                         distance = r->last_frame() - position;
2985                         pos = r->position() - distance;
2986                         dir = -1;
2987                 }
2988                 break;
2989
2990         case SyncPoint:
2991                 pos = r->adjust_to_sync (position);
2992                 if (pos > r->position()) {
2993                         distance = pos - r->position();
2994                 } else {
2995                         distance = r->position() - pos;
2996                         dir = -1;
2997                 }
2998                 break;
2999         }
3000
3001         if (pos == r->position()) {
3002                 return;
3003         }
3004
3005         begin_reversible_command (_("align selection (relative)"));
3006
3007         /* move first one specially */
3008
3009         r->clear_changes ();
3010         r->set_position (pos);
3011         _session->add_command(new StatefulDiffCommand (r));
3012
3013         /* move rest by the same amount */
3014
3015         sorted.pop_front();
3016
3017         for (list<RegionView*>::iterator i = sorted.begin(); i != sorted.end(); ++i) {
3018
3019                 boost::shared_ptr<Region> region ((*i)->region());
3020
3021                 region->clear_changes ();
3022
3023                 if (dir > 0) {
3024                         region->set_position (region->position() + distance);
3025                 } else {
3026                         region->set_position (region->position() - distance);
3027                 }
3028
3029                 _session->add_command(new StatefulDiffCommand (region));
3030
3031         }
3032
3033         commit_reversible_command ();
3034 }
3035
3036 void
3037 Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, framepos_t position)
3038 {
3039         begin_reversible_command (_("align region"));
3040         align_region_internal (region, point, position);
3041         commit_reversible_command ();
3042 }
3043
3044 void
3045 Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, framepos_t position)
3046 {
3047         region->clear_changes ();
3048
3049         switch (point) {
3050         case SyncPoint:
3051                 region->set_position (region->adjust_to_sync (position));
3052                 break;
3053
3054         case End:
3055                 if (position > region->length()) {
3056                         region->set_position (position - region->length());
3057                 }
3058                 break;
3059
3060         case Start:
3061                 region->set_position (position);
3062                 break;
3063         }
3064
3065         _session->add_command(new StatefulDiffCommand (region));
3066 }
3067
3068 void
3069 Editor::trim_region_front ()
3070 {
3071         trim_region (true);
3072 }
3073
3074 void
3075 Editor::trim_region_back ()
3076 {
3077         trim_region (false);
3078 }
3079
3080 void
3081 Editor::trim_region (bool front)
3082 {
3083         framepos_t where = get_preferred_edit_position();
3084         RegionSelection rs = get_regions_from_selection_and_edit_point ();
3085
3086         cerr << "trim regions\n";
3087
3088         if (rs.empty()) {
3089                 cerr << " no regions\n";
3090                 return;
3091         }
3092
3093         cerr << "where = " << where << endl;
3094
3095         begin_reversible_command (front ? _("trim front") : _("trim back"));
3096
3097         for (list<RegionView*>::const_iterator i = rs.by_layer().begin(); i != rs.by_layer().end(); ++i) {
3098                 if (!(*i)->region()->locked()) {
3099
3100                         (*i)->region()->clear_changes ();
3101
3102                         if (front) {
3103                                 (*i)->region()->trim_front (where);
3104                         } else {
3105                                 (*i)->region()->trim_end (where);
3106                         }
3107
3108                         _session->add_command (new StatefulDiffCommand ((*i)->region()));
3109                 }
3110         }
3111
3112         commit_reversible_command ();
3113 }
3114
3115 /** Trim the end of the selected regions to the position of the edit cursor */
3116 void
3117 Editor::trim_region_to_loop ()
3118 {
3119         Location* loc = _session->locations()->auto_loop_location();
3120         if (!loc) {
3121                 return;
3122         }
3123         trim_region_to_location (*loc, _("trim to loop"));
3124 }
3125
3126 void
3127 Editor::trim_region_to_punch ()
3128 {
3129         Location* loc = _session->locations()->auto_punch_location();
3130         if (!loc) {
3131                 return;
3132         }
3133         trim_region_to_location (*loc, _("trim to punch"));
3134 }
3135
3136 void
3137 Editor::trim_region_to_location (const Location& loc, const char* str)
3138 {
3139         RegionSelection rs = get_regions_from_selection_and_entered ();
3140
3141         begin_reversible_command (str);
3142
3143         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3144                 RegionView* rv = (*x);
3145
3146                 /* require region to span proposed trim */
3147                 switch (rv->region()->coverage (loc.start(), loc.end())) {
3148                 case OverlapInternal:
3149                         break;
3150                 default:
3151                         continue;
3152                 }
3153
3154                 RouteTimeAxisView* tav = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view());
3155                 if (!tav) {
3156                         return;
3157                 }
3158
3159                 float speed = 1.0;
3160                 framepos_t start;
3161                 framepos_t end;
3162
3163                 if (tav->track() != 0) {
3164                         speed = tav->track()->speed();
3165                 }
3166
3167                 start = session_frame_to_track_frame (loc.start(), speed);
3168                 end = session_frame_to_track_frame (loc.end(), speed);
3169
3170                 rv->region()->clear_changes ();
3171                 rv->region()->trim_to (start, (end - start));
3172                 _session->add_command(new StatefulDiffCommand (rv->region()));
3173         }
3174
3175         commit_reversible_command ();
3176 }
3177
3178 void
3179 Editor::trim_region_to_previous_region_end ()
3180 {
3181         return trim_to_region(false);
3182 }
3183
3184 void
3185 Editor::trim_region_to_next_region_start ()
3186 {
3187         return trim_to_region(true);
3188 }
3189
3190 void
3191 Editor::trim_to_region(bool forward)
3192 {
3193         RegionSelection rs = get_regions_from_selection_and_entered ();
3194
3195         begin_reversible_command (_("trim to region"));
3196
3197         boost::shared_ptr<Region> next_region;
3198
3199         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3200
3201                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3202
3203                 if (!arv) {
3204                         continue;
3205                 }
3206
3207                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3208
3209                 if (!atav) {
3210                         return;
3211                 }
3212
3213                 float speed = 1.0;
3214
3215                 if (atav->track() != 0) {
3216                         speed = atav->track()->speed();
3217                 }
3218
3219
3220                 boost::shared_ptr<Region> region = arv->region();
3221                 boost::shared_ptr<Playlist> playlist (region->playlist());
3222
3223                 region->clear_changes ();
3224
3225                 if (forward) {
3226
3227                     next_region = playlist->find_next_region (region->first_frame(), Start, 1);
3228
3229                     if (!next_region) {
3230                         continue;
3231                     }
3232
3233                     region->trim_end((framepos_t) ( (next_region->first_frame() - 1) * speed));
3234                     arv->region_changed (PropertyChange (ARDOUR::Properties::length));
3235                 }
3236                 else {
3237
3238                     next_region = playlist->find_next_region (region->first_frame(), Start, 0);
3239
3240                     if(!next_region){
3241                         continue;
3242                     }
3243
3244                     region->trim_front((framepos_t) ((next_region->last_frame() + 1) * speed));
3245
3246                     arv->region_changed (ARDOUR::bounds_change);
3247                 }
3248
3249                 _session->add_command(new StatefulDiffCommand (region));
3250         }
3251
3252         commit_reversible_command ();
3253 }
3254
3255 void
3256 Editor::unfreeze_route ()
3257 {
3258         if (clicked_routeview == 0 || !clicked_routeview->is_track()) {
3259                 return;
3260         }
3261
3262         clicked_routeview->track()->unfreeze ();
3263 }
3264
3265 void*
3266 Editor::_freeze_thread (void* arg)
3267 {
3268         SessionEvent::create_per_thread_pool ("freeze events", 64);
3269
3270         return static_cast<Editor*>(arg)->freeze_thread ();
3271 }
3272
3273 void*
3274 Editor::freeze_thread ()
3275 {
3276         clicked_routeview->audio_track()->freeze_me (*current_interthread_info);
3277         current_interthread_info->done = true;
3278         return 0;
3279 }
3280
3281 void
3282 Editor::freeze_route ()
3283 {
3284         if (!_session) {
3285                 return;
3286         }
3287
3288         /* stop transport before we start. this is important */
3289
3290         _session->request_transport_speed (0.0);
3291
3292         if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
3293                 return;
3294         }
3295
3296         if (!clicked_routeview->track()->bounceable()) {
3297                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (clicked_routeview);
3298                 if (rtv && !rtv->track()->bounceable()) {
3299                         MessageDialog d (
3300                                 _("This route cannot be frozen because it has more outputs than inputs.  "
3301                                   "You can fix this by increasing the number of inputs.")
3302                                 );
3303                         d.set_title (_("Cannot freeze"));
3304                         d.run ();
3305                         return;
3306                 }
3307         }
3308
3309         InterThreadInfo itt;
3310         current_interthread_info = &itt;
3311
3312         InterthreadProgressWindow ipw (current_interthread_info, _("Freeze"), _("Cancel Freeze"));
3313
3314         pthread_create_and_store (X_("freezer"), &itt.thread, _freeze_thread, this);
3315
3316         set_canvas_cursor (_cursors->wait);
3317
3318         while (!itt.done && !itt.cancel) {
3319                 gtk_main_iteration ();
3320         }
3321
3322         current_interthread_info = 0;
3323         set_canvas_cursor (current_canvas_cursor);
3324 }
3325
3326 void
3327 Editor::bounce_range_selection (bool replace, bool enable_processing)
3328 {
3329         if (selection->time.empty()) {
3330                 return;
3331         }
3332
3333         TrackSelection views = selection->tracks;
3334
3335         for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
3336                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
3337                 if (rtv && rtv->track() && replace && enable_processing && !rtv->track()->bounceable()) {
3338                         MessageDialog d (
3339                                 _("You can't perform this operation because the processing of the signal "
3340                                   "will cause one or more of the tracks will end up with a region with more channels than this track has inputs.\n\n"
3341                                   "You can do this without processing, which is a different operation.")
3342                                 );
3343                         d.set_title (_("Cannot bounce"));
3344                         d.run ();
3345                         return;
3346                 }
3347         }
3348
3349         framepos_t start = selection->time[clicked_selection].start;
3350         framepos_t end = selection->time[clicked_selection].end;
3351         framepos_t cnt = end - start + 1;
3352
3353         begin_reversible_command (_("bounce range"));
3354
3355         for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
3356
3357                 RouteTimeAxisView* rtv;
3358
3359                 if ((rtv = dynamic_cast<RouteTimeAxisView*> (*i)) == 0) {
3360                         continue;
3361                 }
3362
3363                 boost::shared_ptr<Playlist> playlist;
3364
3365                 if ((playlist = rtv->playlist()) == 0) {
3366                         return;
3367                 }
3368
3369                 InterThreadInfo itt;
3370
3371                 playlist->clear_changes ();
3372                 playlist->clear_owned_changes ();
3373
3374                 boost::shared_ptr<Region> r = rtv->track()->bounce_range (start, start+cnt, itt, enable_processing);
3375
3376                 if (!r) {
3377                         continue;
3378                 }
3379
3380                 if (replace) {
3381                         list<AudioRange> ranges;
3382                         ranges.push_back (AudioRange (start, start+cnt, 0));
3383                         playlist->cut (ranges); // discard result
3384                         playlist->add_region (r, start);
3385                 }
3386
3387                 vector<Command*> cmds;
3388                 playlist->rdiff (cmds);
3389                 _session->add_commands (cmds);
3390
3391                 _session->add_command (new StatefulDiffCommand (playlist));
3392         }
3393
3394         commit_reversible_command ();
3395 }
3396
3397 /** Delete selected regions, automation points or a time range */
3398 void
3399 Editor::delete_ ()
3400 {
3401         cut_copy (Delete);
3402 }
3403
3404 /** Cut selected regions, automation points or a time range */
3405 void
3406 Editor::cut ()
3407 {
3408         cut_copy (Cut);
3409 }
3410
3411 /** Copy selected regions, automation points or a time range */
3412 void
3413 Editor::copy ()
3414 {
3415         cut_copy (Copy);
3416 }
3417
3418
3419 /** @return true if a Cut, Copy or Clear is possible */
3420 bool
3421 Editor::can_cut_copy () const
3422 {
3423         switch (current_mouse_mode()) {
3424
3425         case MouseObject:
3426                 if (!selection->regions.empty() || !selection->points.empty()) {
3427                         return true;
3428                 }
3429                 break;
3430
3431         case MouseRange:
3432                 if (!selection->time.empty()) {
3433                         return true;
3434                 }
3435                 break;
3436
3437         default:
3438                 break;
3439         }
3440
3441         return false;
3442 }
3443
3444
3445 /** Cut, copy or clear selected regions, automation points or a time range.
3446  * @param op Operation (Cut, Copy or Clear)
3447  */
3448 void
3449 Editor::cut_copy (CutCopyOp op)
3450 {
3451         /* only cancel selection if cut/copy is successful.*/
3452
3453         string opname;
3454
3455         switch (op) {
3456         case Delete:
3457                 opname = _("delete");
3458                 break;
3459         case Cut:
3460                 opname = _("cut");
3461                 break;
3462         case Copy:
3463                 opname = _("copy");
3464                 break;
3465         case Clear:
3466                 opname = _("clear");
3467                 break;
3468         }
3469
3470         /* if we're deleting something, and the mouse is still pressed,
3471            the thing we started a drag for will be gone when we release
3472            the mouse button(s). avoid this. see part 2 at the end of
3473            this function.
3474         */
3475
3476         if (op == Delete || op == Cut || op == Clear) {
3477                 if (_drags->active ()) {
3478                         _drags->abort ();
3479                 }
3480         }
3481
3482         cut_buffer->clear ();
3483
3484         if (entered_marker) {
3485
3486                 /* cut/delete op while pointing at a marker */
3487
3488                 bool ignored;
3489                 Location* loc = find_location_from_marker (entered_marker, ignored);
3490
3491                 if (_session && loc) {
3492                         Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::really_remove_marker), loc));
3493                 }
3494
3495                 _drags->abort ();
3496                 return;
3497         }
3498
3499         if (internal_editing()) {
3500
3501                 switch (current_mouse_mode()) {
3502                 case MouseObject:
3503                 case MouseRange:
3504                         cut_copy_midi (op);
3505                         break;
3506                 default:
3507                         break;
3508                 }
3509
3510         } else {
3511
3512                 RegionSelection rs;
3513
3514                 /* we only want to cut regions if some are selected */
3515
3516                 if (!selection->regions.empty()) {
3517                         rs = selection->regions;
3518                 }
3519
3520                 switch (current_mouse_mode()) {
3521                 case MouseObject:
3522                         if (!rs.empty() || !selection->points.empty()) {
3523
3524                                 begin_reversible_command (opname + _(" objects"));
3525
3526                                 if (!rs.empty()) {
3527                                         cut_copy_regions (op, rs);
3528
3529                                         if (op == Cut || op == Delete) {
3530                                                 selection->clear_regions ();
3531                                         }
3532                                 }
3533
3534                                 if (!selection->points.empty()) {
3535                                         cut_copy_points (op);
3536
3537                                         if (op == Cut || op == Delete) {
3538                                                 selection->clear_points ();
3539                                         }
3540                                 }
3541                                 commit_reversible_command ();
3542                                 break; // terminate case statement here
3543                         }
3544                         if (!selection->time.empty()) {
3545                                 /* don't cause suprises */
3546                                 break;
3547                         }
3548                         // fall thru if there was nothing selected
3549
3550                 case MouseRange:
3551                         if (selection->time.empty()) {
3552                                 framepos_t start, end;
3553                                 if (!get_edit_op_range (start, end)) {
3554                                         return;
3555                                 }
3556                                 selection->set (start, end);
3557                         }
3558
3559                         begin_reversible_command (opname + _(" range"));
3560                         cut_copy_ranges (op);
3561                         commit_reversible_command ();
3562
3563                         if (op == Cut || op == Delete) {
3564                                 selection->clear_time ();
3565                         }
3566
3567                         break;
3568
3569                 default:
3570                         break;
3571                 }
3572         }
3573
3574         if (op == Delete || op == Cut || op == Clear) {
3575                 _drags->abort ();
3576         }
3577 }
3578
3579 /** Cut, copy or clear selected automation points.
3580  * @param op Operation (Cut, Copy or Clear)
3581  */
3582 void
3583 Editor::cut_copy_points (CutCopyOp op)
3584 {
3585         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3586
3587                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>((*i).track);
3588                 _last_cut_copy_source_track = atv;
3589
3590                 if (atv) {
3591                         atv->cut_copy_clear_objects (selection->points, op);
3592                 }
3593         }
3594 }
3595
3596 /** Cut, copy or clear selected automation points.
3597  * @param op Operation (Cut, Copy or Clear)
3598  */
3599 void
3600 Editor::cut_copy_midi (CutCopyOp op)
3601 {
3602         for (MidiRegionSelection::iterator i = selection->midi_regions.begin(); i != selection->midi_regions.end(); ++i) {
3603                 MidiRegionView* mrv = *i;
3604                 mrv->cut_copy_clear (op);
3605         }
3606 }
3607
3608
3609
3610 struct lt_playlist {
3611     bool operator () (const PlaylistState& a, const PlaylistState& b) {
3612             return a.playlist < b.playlist;
3613     }
3614 };
3615
3616 struct PlaylistMapping {
3617     TimeAxisView* tv;
3618     boost::shared_ptr<Playlist> pl;
3619
3620     PlaylistMapping (TimeAxisView* tvp) : tv (tvp) {}
3621 };
3622
3623 /** Remove `clicked_regionview' */
3624 void
3625 Editor::remove_clicked_region ()
3626 {
3627         if (clicked_routeview == 0 || clicked_regionview == 0) {
3628                 return;
3629         }
3630
3631         boost::shared_ptr<Playlist> playlist = clicked_routeview->playlist();
3632
3633         begin_reversible_command (_("remove region"));
3634         playlist->clear_changes ();
3635         playlist->remove_region (clicked_regionview->region());
3636         _session->add_command(new StatefulDiffCommand (playlist));
3637         commit_reversible_command ();
3638 }
3639
3640
3641 /** Remove the selected regions */
3642 void
3643 Editor::remove_selected_regions ()
3644 {
3645         RegionSelection rs = get_regions_from_selection_and_entered ();
3646
3647         if (!_session || rs.empty()) {
3648                 return;
3649         }
3650
3651         begin_reversible_command (_("remove region"));
3652
3653         list<boost::shared_ptr<Region> > regions_to_remove;
3654
3655         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
3656                 // we can't just remove the region(s) in this loop because
3657                 // this removes them from the RegionSelection, and they thus
3658                 // disappear from underneath the iterator, and the ++i above
3659                 // SEGVs in a puzzling fashion.
3660
3661                 // so, first iterate over the regions to be removed from rs and
3662                 // add them to the regions_to_remove list, and then
3663                 // iterate over the list to actually remove them.
3664
3665                 regions_to_remove.push_back ((*i)->region());
3666         }
3667
3668         vector<boost::shared_ptr<Playlist> > playlists;
3669
3670         for (list<boost::shared_ptr<Region> >::iterator rl = regions_to_remove.begin(); rl != regions_to_remove.end(); ++rl) {
3671
3672                 boost::shared_ptr<Playlist> playlist = (*rl)->playlist();
3673
3674                 if (!playlist) {
3675                         // is this check necessary?
3676                         continue;
3677                 }
3678
3679                 vector<boost::shared_ptr<Playlist> >::iterator i;
3680
3681                 //only prep history if this is a new playlist.
3682                 for (i = playlists.begin(); i != playlists.end(); ++i) {
3683                         if ((*i) == playlist) {
3684                                 break;
3685                         }
3686                 }
3687
3688                 if (i == playlists.end()) {
3689
3690                         playlist->clear_changes ();
3691                         playlist->freeze ();
3692
3693                         playlists.push_back (playlist);
3694                 }
3695
3696                 playlist->remove_region (*rl);
3697         }
3698
3699         vector<boost::shared_ptr<Playlist> >::iterator pl;
3700
3701         for (pl = playlists.begin(); pl != playlists.end(); ++pl) {
3702                 (*pl)->thaw ();
3703                 _session->add_command(new StatefulDiffCommand (*pl));
3704         }
3705
3706         commit_reversible_command ();
3707 }
3708
3709 /** Cut, copy or clear selected regions.
3710  * @param op Operation (Cut, Copy or Clear)
3711  */
3712 void
3713 Editor::cut_copy_regions (CutCopyOp op, RegionSelection& rs)
3714 {
3715         /* we can't use a std::map here because the ordering is important, and we can't trivially sort
3716            a map when we want ordered access to both elements. i think.
3717         */
3718
3719         vector<PlaylistMapping> pmap;
3720
3721         framepos_t first_position = max_framepos;
3722
3723         typedef set<boost::shared_ptr<Playlist> > FreezeList;
3724         FreezeList freezelist;
3725
3726         /* get ordering correct before we cut/copy */
3727
3728         rs.sort_by_position_and_track ();
3729
3730         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3731
3732                 first_position = min ((framepos_t) (*x)->region()->position(), first_position);
3733
3734                 if (op == Cut || op == Clear || op == Delete) {
3735                         boost::shared_ptr<Playlist> pl = (*x)->region()->playlist();
3736
3737                         if (pl) {
3738                                 FreezeList::iterator fl;
3739
3740                                 // only take state if this is a new playlist.
3741                                 for (fl = freezelist.begin(); fl != freezelist.end(); ++fl) {
3742                                         if ((*fl) == pl) {
3743                                                 break;
3744                                         }
3745                                 }
3746
3747                                 if (fl == freezelist.end()) {
3748                                         pl->clear_changes();
3749                                         pl->freeze ();
3750                                         freezelist.insert (pl);
3751                                 }
3752                         }
3753                 }
3754
3755                 TimeAxisView* tv = &(*x)->get_time_axis_view();
3756                 vector<PlaylistMapping>::iterator z;
3757
3758                 for (z = pmap.begin(); z != pmap.end(); ++z) {
3759                         if ((*z).tv == tv) {
3760                                 break;
3761                         }
3762                 }
3763
3764                 if (z == pmap.end()) {
3765                         pmap.push_back (PlaylistMapping (tv));
3766                 }
3767         }
3768
3769         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ) {
3770
3771                 boost::shared_ptr<Playlist> pl = (*x)->region()->playlist();
3772
3773                 if (!pl) {
3774                         /* region not yet associated with a playlist (e.g. unfinished
3775                            capture pass.
3776                         */
3777                         ++x;
3778                         continue;
3779                 }
3780
3781                 TimeAxisView& tv = (*x)->get_time_axis_view();
3782                 boost::shared_ptr<Playlist> npl;
3783                 RegionSelection::iterator tmp;
3784
3785                 tmp = x;
3786                 ++tmp;
3787
3788                 if (op != Delete) {
3789
3790                         vector<PlaylistMapping>::iterator z;
3791
3792                         for (z = pmap.begin(); z != pmap.end(); ++z) {
3793                                 if ((*z).tv == &tv) {
3794                                         break;
3795                                 }
3796                         }
3797
3798                         assert (z != pmap.end());
3799
3800                         if (!(*z).pl) {
3801                                 npl = PlaylistFactory::create (pl->data_type(), *_session, "cutlist", true);
3802                                 npl->freeze();
3803                                 (*z).pl = npl;
3804                         } else {
3805                                 npl = (*z).pl;
3806                         }
3807                 }
3808
3809                 boost::shared_ptr<Region> r = (*x)->region();
3810                 boost::shared_ptr<Region> _xx;
3811
3812                 assert (r != 0);
3813
3814                 switch (op) {
3815                 case Delete:
3816                         pl->remove_region (r);
3817                         break;
3818
3819                 case Cut:
3820                         _xx = RegionFactory::create (r);
3821                         npl->add_region (_xx, r->position() - first_position);
3822                         pl->remove_region (r);
3823                         break;
3824
3825                 case Copy:
3826                         /* copy region before adding, so we're not putting same object into two different playlists */
3827                         npl->add_region (RegionFactory::create (r), r->position() - first_position);
3828                         break;
3829
3830                 case Clear:
3831                         pl->remove_region (r);
3832                         break;
3833                 }
3834
3835                 x = tmp;
3836         }
3837
3838         if (op != Delete) {
3839
3840                 list<boost::shared_ptr<Playlist> > foo;
3841
3842                 /* the pmap is in the same order as the tracks in which selected regions occured */
3843
3844                 for (vector<PlaylistMapping>::iterator i = pmap.begin(); i != pmap.end(); ++i) {
3845                         if ((*i).pl) {
3846                                 (*i).pl->thaw();
3847                                 foo.push_back ((*i).pl);
3848                         }
3849                 }
3850
3851                 if (!foo.empty()) {
3852                         cut_buffer->set (foo);
3853                 }
3854
3855                 if (pmap.empty()) {
3856                         _last_cut_copy_source_track = 0;
3857                 } else {
3858                         _last_cut_copy_source_track = pmap.front().tv;
3859                 }
3860         }
3861
3862         for (FreezeList::iterator pl = freezelist.begin(); pl != freezelist.end(); ++pl) {
3863                 (*pl)->thaw ();
3864                 _session->add_command (new StatefulDiffCommand (*pl));
3865         }
3866 }
3867
3868 void
3869 Editor::cut_copy_ranges (CutCopyOp op)
3870 {
3871         TrackViewList* ts;
3872         TrackViewList entered;
3873
3874         /* Sort the track selection now, so that it if is used, the playlists
3875            selected by the calls below to cut_copy_clear are in the order that
3876            their tracks appear in the editor.  This makes things like paste
3877            of ranges work properly.
3878         */
3879         sort_track_selection (&selection->tracks);
3880
3881         if (selection->tracks.empty()) {
3882                 if (!entered_track) {
3883                         return;
3884                 }
3885                 entered.push_back (entered_track);
3886                 ts = &entered;
3887         } else {
3888                 ts = &selection->tracks;
3889         }
3890
3891         for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
3892                 (*i)->cut_copy_clear (*selection, op);
3893         }
3894 }
3895
3896 void
3897 Editor::paste (float times)
3898 {
3899         DEBUG_TRACE (DEBUG::CutNPaste, "paste to preferred edit pos\n");
3900         paste_internal (get_preferred_edit_position(), times);
3901 }
3902
3903 void
3904 Editor::mouse_paste ()
3905 {
3906         framepos_t where;
3907         bool ignored;
3908
3909         if (!mouse_frame (where, ignored)) {
3910                 return;
3911         }
3912
3913         snap_to (where);
3914         paste_internal (where, 1);
3915 }
3916
3917 void
3918 Editor::paste_internal (framepos_t position, float times)
3919 {
3920         DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("apparent paste position is %1\n", position));
3921
3922         if (internal_editing()) {
3923                 if (cut_buffer->midi_notes.empty()) {
3924                         return;
3925                 }
3926         } else {
3927                 if (cut_buffer->empty()) {
3928                         return;
3929                 }
3930         }
3931
3932         if (position == max_framepos) {
3933                 position = get_preferred_edit_position();
3934                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("preferred edit position is %1\n", position));
3935         }
3936
3937         TrackViewList ts;
3938         TrackViewList::iterator i;
3939         size_t nth;
3940
3941         /* get everything in the correct order */
3942
3943         if (!selection->tracks.empty()) {
3944                 /* there are some selected tracks, so paste to them */
3945                 sort_track_selection ();
3946                 ts = selection->tracks;
3947         } else if (_last_cut_copy_source_track) {
3948                 /* otherwise paste to the track that the cut/copy came from;
3949                    see discussion in mantis #3333.
3950                 */
3951                 ts.push_back (_last_cut_copy_source_track);
3952         }
3953
3954         if (internal_editing ()) {
3955
3956                 /* undo/redo is handled by individual tracks/regions */
3957
3958                 for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
3959
3960                         RegionSelection rs;
3961                         RegionSelection::iterator r;
3962                         MidiNoteSelection::iterator cb;
3963
3964                         get_regions_at (rs, position, ts);
3965
3966                         for (cb = cut_buffer->midi_notes.begin(), r = rs.begin();
3967                              cb != cut_buffer->midi_notes.end() && r != rs.end(); ++r) {
3968                                 MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (*r);
3969                                 if (mrv) {
3970                                         mrv->paste (position, times, **cb);
3971                                         ++cb;
3972                                 }
3973                         }
3974                 }
3975
3976         } else {
3977
3978                 /* we do redo (do you do voodoo?) */
3979
3980                 begin_reversible_command (Operations::paste);
3981
3982                 for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
3983                         (*i)->paste (position, times, *cut_buffer, nth);
3984                 }
3985
3986                 commit_reversible_command ();
3987         }
3988 }
3989
3990 void
3991 Editor::duplicate_some_regions (RegionSelection& regions, float times)
3992 {
3993         boost::shared_ptr<Playlist> playlist;
3994         RegionSelection sel = regions; // clear (below) may  clear the argument list if its the current region selection
3995         RegionSelection foo;
3996
3997         framepos_t const start_frame = regions.start ();
3998         framepos_t const end_frame = regions.end_frame ();
3999
4000         begin_reversible_command (Operations::duplicate_region);
4001
4002         selection->clear_regions ();
4003
4004         for (RegionSelection::iterator i = sel.begin(); i != sel.end(); ++i) {
4005
4006                 boost::shared_ptr<Region> r ((*i)->region());
4007
4008                 TimeAxisView& tv = (*i)->get_time_axis_view();
4009                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&tv);
4010                 latest_regionviews.clear ();
4011                 sigc::connection c = rtv->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view));
4012
4013                 playlist = (*i)->region()->playlist();
4014                 playlist->clear_changes ();
4015                 playlist->duplicate (r, end_frame + (r->first_frame() - start_frame), times);
4016                 _session->add_command(new StatefulDiffCommand (playlist));
4017
4018                 c.disconnect ();
4019
4020                 foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
4021         }
4022
4023         commit_reversible_command ();
4024
4025         if (!foo.empty()) {
4026                 selection->set (foo);
4027         }
4028 }
4029
4030 void
4031 Editor::duplicate_selection (float times)
4032 {
4033         if (selection->time.empty() || selection->tracks.empty()) {
4034                 return;
4035         }
4036
4037         boost::shared_ptr<Playlist> playlist;
4038         vector<boost::shared_ptr<Region> > new_regions;
4039         vector<boost::shared_ptr<Region> >::iterator ri;
4040
4041         create_region_from_selection (new_regions);
4042
4043         if (new_regions.empty()) {
4044                 return;
4045         }
4046
4047         begin_reversible_command (_("duplicate selection"));
4048
4049         ri = new_regions.begin();
4050
4051         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4052                 if ((playlist = (*i)->playlist()) == 0) {
4053                         continue;
4054                 }
4055                 playlist->clear_changes ();
4056                 playlist->duplicate (*ri, selection->time[clicked_selection].end, times);
4057                 _session->add_command (new StatefulDiffCommand (playlist));
4058
4059                 ++ri;
4060                 if (ri == new_regions.end()) {
4061                         --ri;
4062                 }
4063         }
4064
4065         commit_reversible_command ();
4066 }
4067
4068 void
4069 Editor::reset_point_selection ()
4070 {
4071         /* reset all selected points to the relevant default value */
4072
4073         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
4074
4075                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>((*i).track);
4076
4077                 if (atv) {
4078                         atv->reset_objects (selection->points);
4079                 }
4080         }
4081 }
4082
4083 void
4084 Editor::center_playhead ()
4085 {
4086         float page = _canvas_width * frames_per_unit;
4087         center_screen_internal (playhead_cursor->current_frame, page);
4088 }
4089
4090 void
4091 Editor::center_edit_point ()
4092 {
4093         float page = _canvas_width * frames_per_unit;
4094         center_screen_internal (get_preferred_edit_position(), page);
4095 }
4096
4097 /** Caller must begin and commit a reversible command */
4098 void
4099 Editor::clear_playlist (boost::shared_ptr<Playlist> playlist)
4100 {
4101         playlist->clear_changes ();
4102         playlist->clear ();
4103         _session->add_command (new StatefulDiffCommand (playlist));
4104 }
4105
4106 void
4107 Editor::nudge_track (bool use_edit, bool forwards)
4108 {
4109         boost::shared_ptr<Playlist> playlist;
4110         framepos_t distance;
4111         framepos_t next_distance;
4112         framepos_t start;
4113
4114         if (use_edit) {
4115                 start = get_preferred_edit_position();
4116         } else {
4117                 start = 0;
4118         }
4119
4120         if ((distance = get_nudge_distance (start, next_distance)) == 0) {
4121                 return;
4122         }
4123
4124         if (selection->tracks.empty()) {
4125                 return;
4126         }
4127
4128         begin_reversible_command (_("nudge track"));
4129
4130         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4131
4132                 if ((playlist = (*i)->playlist()) == 0) {
4133                         continue;
4134                 }
4135
4136                 playlist->clear_changes ();
4137                 playlist->clear_owned_changes ();
4138
4139                 playlist->nudge_after (start, distance, forwards);
4140
4141                 vector<Command*> cmds;
4142
4143                 playlist->rdiff (cmds);
4144                 _session->add_commands (cmds);
4145
4146                 _session->add_command (new StatefulDiffCommand (playlist));
4147         }
4148
4149         commit_reversible_command ();
4150 }
4151
4152 void
4153 Editor::remove_last_capture ()
4154 {
4155         vector<string> choices;
4156         string prompt;
4157
4158         if (!_session) {
4159                 return;
4160         }
4161
4162         if (Config->get_verify_remove_last_capture()) {
4163                 prompt  = _("Do you really want to destroy the last capture?"
4164                             "\n(This is destructive and cannot be undone)");
4165
4166                 choices.push_back (_("No, do nothing."));
4167                 choices.push_back (_("Yes, destroy it."));
4168
4169                 Gtkmm2ext::Choice prompter (_("Destroy last capture"), prompt, choices);
4170
4171                 if (prompter.run () == 1) {
4172                         _session->remove_last_capture ();
4173                         _regions->redisplay ();
4174                 }
4175
4176         } else {
4177                 _session->remove_last_capture();
4178                 _regions->redisplay ();
4179         }
4180 }
4181
4182 void
4183 Editor::normalize_region ()
4184 {
4185         if (!_session) {
4186                 return;
4187         }
4188
4189         RegionSelection rs = get_regions_from_selection_and_entered ();
4190
4191         if (rs.empty()) {
4192                 return;
4193         }
4194
4195         NormalizeDialog dialog (rs.size() > 1);
4196
4197         if (dialog.run () == RESPONSE_CANCEL) {
4198                 return;
4199         }
4200
4201         set_canvas_cursor (_cursors->wait);
4202         gdk_flush ();
4203
4204         /* XXX: should really only count audio regions here */
4205         int const regions = rs.size ();
4206
4207         /* Make a list of the selected audio regions' maximum amplitudes, and also
4208            obtain the maximum amplitude of them all.
4209         */
4210         list<double> max_amps;
4211         double max_amp = 0;
4212         for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
4213                 AudioRegionView const * arv = dynamic_cast<AudioRegionView const *> (*i);
4214                 if (arv) {
4215                         dialog.descend (1.0 / regions);
4216                         double const a = arv->audio_region()->maximum_amplitude (&dialog);
4217
4218                         if (a == -1) {
4219                                 /* the user cancelled the operation */
4220                                 set_canvas_cursor (current_canvas_cursor);
4221                                 return;
4222                         }
4223
4224                         max_amps.push_back (a);
4225                         max_amp = max (max_amp, a);
4226                         dialog.ascend ();
4227                 }
4228         }
4229
4230         begin_reversible_command (_("normalize"));
4231
4232         list<double>::const_iterator a = max_amps.begin ();
4233
4234         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
4235                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*> (*r);
4236                 if (!arv) {
4237                         continue;
4238                 }
4239
4240                 arv->region()->clear_changes ();
4241
4242                 double const amp = dialog.normalize_individually() ? *a : max_amp;
4243
4244                 arv->audio_region()->normalize (amp, dialog.target ());
4245                 _session->add_command (new StatefulDiffCommand (arv->region()));
4246
4247                 ++a;
4248         }
4249
4250         commit_reversible_command ();
4251         set_canvas_cursor (current_canvas_cursor);
4252 }
4253
4254
4255 void
4256 Editor::reset_region_scale_amplitude ()
4257 {
4258         if (!_session) {
4259                 return;
4260         }
4261
4262         RegionSelection rs = get_regions_from_selection_and_entered ();
4263
4264         if (rs.empty()) {
4265                 return;
4266         }
4267
4268         begin_reversible_command ("reset gain");
4269
4270         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
4271                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4272                 if (!arv)
4273                         continue;
4274                 arv->region()->clear_changes ();
4275                 arv->audio_region()->set_scale_amplitude (1.0f);
4276                 _session->add_command (new StatefulDiffCommand (arv->region()));
4277         }
4278
4279         commit_reversible_command ();
4280 }
4281
4282 void
4283 Editor::adjust_region_gain (bool up)
4284 {
4285         RegionSelection rs = get_regions_from_selection_and_entered ();
4286
4287         if (!_session || rs.empty()) {
4288                 return;
4289         }
4290
4291         begin_reversible_command ("adjust region gain");
4292
4293         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
4294                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4295                 if (!arv) {
4296                         continue;
4297                 }
4298
4299                 arv->region()->clear_changes ();
4300
4301                 double dB = accurate_coefficient_to_dB (arv->audio_region()->scale_amplitude ());
4302
4303                 if (up) {
4304                         dB += 1;
4305                 } else {
4306                         dB -= 1;
4307                 }
4308
4309                 arv->audio_region()->set_scale_amplitude (dB_to_coefficient (dB));
4310                 _session->add_command (new StatefulDiffCommand (arv->region()));
4311         }
4312
4313         commit_reversible_command ();
4314 }
4315
4316
4317 void
4318 Editor::reverse_region ()
4319 {
4320         if (!_session) {
4321                 return;
4322         }
4323
4324         Reverse rev (*_session);
4325         apply_filter (rev, _("reverse regions"));
4326 }
4327
4328 void
4329 Editor::strip_region_silence ()
4330 {
4331         if (!_session) {
4332                 return;
4333         }
4334
4335         RegionSelection rs = get_regions_from_selection_and_entered ();
4336
4337         if (rs.empty()) {
4338                 return;
4339         }
4340
4341         std::list<RegionView*> audio_only;
4342
4343         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4344                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*> (*i);
4345                 if (arv) {
4346                         audio_only.push_back (arv);
4347                 }
4348         }
4349
4350         StripSilenceDialog d (_session, audio_only);
4351         int const r = d.run ();
4352
4353         d.drop_rects ();
4354
4355         if (r == Gtk::RESPONSE_OK) {
4356                 ARDOUR::AudioIntervalMap silences;
4357                 d.silences (silences);
4358                 StripSilence s (*_session, silences, d.fade_length());
4359                 apply_filter (s, _("strip silence"), &d);
4360         }
4361 }
4362
4363 Command*
4364 Editor::apply_midi_note_edit_op_to_region (MidiOperator& op, MidiRegionView& mrv)
4365 {
4366         Evoral::Sequence<Evoral::MusicalTime>::Notes selected;
4367         mrv.selection_as_notelist (selected, true);
4368
4369         vector<Evoral::Sequence<Evoral::MusicalTime>::Notes> v;
4370         v.push_back (selected);
4371
4372         framepos_t pos_frames = mrv.midi_region()->position();
4373         double     pos_beats  = _session->tempo_map().framewalk_to_beats(0, pos_frames);
4374
4375         return op (mrv.midi_region()->model(), pos_beats, v);
4376 }
4377
4378 void
4379 Editor::apply_midi_note_edit_op (MidiOperator& op)
4380 {
4381         Command* cmd;
4382
4383         RegionSelection rs = get_regions_from_selection_and_entered ();
4384
4385         if (rs.empty()) {
4386                 return;
4387         }
4388
4389         begin_reversible_command (op.name ());
4390
4391         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
4392                 RegionSelection::iterator tmp = r;
4393                 ++tmp;
4394
4395                 MidiRegionView* const mrv = dynamic_cast<MidiRegionView*> (*r);
4396
4397                 if (mrv) {
4398                         cmd = apply_midi_note_edit_op_to_region (op, *mrv);
4399                         if (cmd) {
4400                                 (*cmd)();
4401                                 _session->add_command (cmd);
4402                         }
4403                 }
4404
4405                 r = tmp;
4406         }
4407
4408         commit_reversible_command ();
4409 }
4410
4411 void
4412 Editor::fork_region ()
4413 {
4414         RegionSelection rs = get_regions_from_selection_and_entered ();
4415
4416         if (rs.empty()) {
4417                 return;
4418         }
4419
4420         begin_reversible_command (_("Fork Region(s)"));
4421
4422         set_canvas_cursor (_cursors->wait);
4423         gdk_flush ();
4424
4425         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
4426                 RegionSelection::iterator tmp = r;
4427                 ++tmp;
4428
4429                 MidiRegionView* const mrv = dynamic_cast<MidiRegionView*>(*r);
4430
4431                 if (mrv) {
4432                         boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
4433                         boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone ();
4434
4435                         playlist->clear_changes ();
4436                         playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
4437                         _session->add_command(new StatefulDiffCommand (playlist));
4438                 }
4439
4440                 r = tmp;
4441         }
4442
4443         commit_reversible_command ();
4444
4445         set_canvas_cursor (current_canvas_cursor);
4446 }
4447
4448 void
4449 Editor::quantize_region ()
4450 {
4451         int selected_midi_region_cnt = 0;
4452
4453         if (!_session) {
4454                 return;
4455         }
4456
4457         RegionSelection rs = get_regions_from_selection_and_entered ();
4458
4459         if (rs.empty()) {
4460                 return;
4461         }
4462
4463         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
4464                 MidiRegionView* const mrv = dynamic_cast<MidiRegionView*> (*r);
4465                 if (mrv) {
4466                         selected_midi_region_cnt++;
4467                 }
4468         }
4469
4470         if (selected_midi_region_cnt == 0) {
4471                 return;
4472         }
4473
4474         QuantizeDialog* qd = new QuantizeDialog (*this);
4475
4476         qd->present ();
4477         const int r = qd->run ();
4478         qd->hide ();
4479
4480         if (r == Gtk::RESPONSE_OK) {
4481                 Quantize quant (*_session, Plain,
4482                                 qd->snap_start(), qd->snap_end(),
4483                                 qd->start_grid_size(), qd->end_grid_size(),
4484                                 qd->strength(), qd->swing(), qd->threshold());
4485
4486                 apply_midi_note_edit_op (quant);
4487         }
4488 }
4489
4490 void
4491 Editor::insert_patch_change ()
4492 {
4493         RegionSelection rs = get_regions_from_selection_and_entered ();
4494         if (rs.empty ()) {
4495                 return;
4496         }
4497
4498         framepos_t const p = get_preferred_edit_position (false);
4499
4500         Evoral::PatchChange<Evoral::MusicalTime> empty (0, 0, 0, 0);
4501         PatchChangeDialog d (0, _session, empty, Gtk::Stock::ADD);
4502
4503         if (d.run() == RESPONSE_CANCEL) {
4504                 return;
4505         }
4506
4507         for (RegionSelection::iterator i = rs.begin (); i != rs.end(); ++i) {
4508                 MidiRegionView* const mrv = dynamic_cast<MidiRegionView*> (*i);
4509                 if (mrv) {
4510                         if (p >= mrv->region()->first_frame() && p <= mrv->region()->last_frame()) {
4511                                 mrv->add_patch_change (p - mrv->region()->position(), d.patch ());
4512                         }
4513                 }
4514         }
4515 }
4516
4517 void
4518 Editor::apply_filter (Filter& filter, string command, ProgressReporter* progress)
4519 {
4520         RegionSelection rs = get_regions_from_selection_and_entered ();
4521
4522         if (rs.empty()) {
4523                 return;
4524         }
4525
4526         begin_reversible_command (command);
4527
4528         set_canvas_cursor (_cursors->wait);
4529         gdk_flush ();
4530
4531         int n = 0;
4532         int const N = rs.size ();
4533
4534         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ) {
4535                 RegionSelection::iterator tmp = r;
4536                 ++tmp;
4537
4538                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4539                 if (arv) {
4540                         boost::shared_ptr<Playlist> playlist = arv->region()->playlist();
4541
4542                         if (progress) {
4543                                 progress->descend (1.0 / N);
4544                         }
4545
4546                         if (arv->audio_region()->apply (filter, progress) == 0) {
4547
4548                                 playlist->clear_changes ();
4549
4550                                 if (filter.results.empty ()) {
4551
4552                                         /* no regions returned; remove the old one */
4553                                         playlist->remove_region (arv->region ());
4554
4555                                 } else {
4556
4557                                         std::vector<boost::shared_ptr<Region> >::iterator res = filter.results.begin ();
4558
4559                                         /* first region replaces the old one */
4560                                         playlist->replace_region (arv->region(), *res, (*res)->position());
4561                                         ++res;
4562
4563                                         /* add the rest */
4564                                         while (res != filter.results.end()) {
4565                                                 playlist->add_region (*res, (*res)->position());
4566                                                 ++res;
4567                                         }
4568
4569                                 }
4570
4571                                 _session->add_command(new StatefulDiffCommand (playlist));
4572                         } else {
4573                                 goto out;
4574                         }
4575
4576                         if (progress) {
4577                                 progress->ascend ();
4578                         }
4579                 }
4580
4581                 r = tmp;
4582                 ++n;
4583         }
4584
4585         commit_reversible_command ();
4586
4587   out:
4588         set_canvas_cursor (current_canvas_cursor);
4589 }
4590
4591 void
4592 Editor::external_edit_region ()
4593 {
4594         /* more to come */
4595 }
4596
4597 void
4598 Editor::reset_region_gain_envelopes ()
4599 {
4600         RegionSelection rs = get_regions_from_selection_and_entered ();
4601
4602         if (!_session || rs.empty()) {
4603                 return;
4604         }
4605
4606         _session->begin_reversible_command (_("reset region gain"));
4607
4608         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4609                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4610                 if (arv) {
4611                         boost::shared_ptr<AutomationList> alist (arv->audio_region()->envelope());
4612                         XMLNode& before (alist->get_state());
4613
4614                         arv->audio_region()->set_default_envelope ();
4615                         _session->add_command (new MementoCommand<AutomationList>(*arv->audio_region()->envelope().get(), &before, &alist->get_state()));
4616                 }
4617         }
4618
4619         _session->commit_reversible_command ();
4620 }
4621
4622 void
4623 Editor::toggle_gain_envelope_visibility ()
4624 {
4625         if (_ignore_region_action) {
4626                 return;
4627         }
4628
4629         RegionSelection rs = get_regions_from_selection_and_entered ();
4630
4631         if (!_session || rs.empty()) {
4632                 return;
4633         }
4634
4635         _session->begin_reversible_command (_("region gain envelope visible"));
4636
4637         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4638                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4639                 if (arv) {
4640                         arv->region()->clear_changes ();
4641                         arv->set_envelope_visible (!arv->envelope_visible());
4642                         _session->add_command (new StatefulDiffCommand (arv->region()));
4643                 }
4644         }
4645
4646         _session->commit_reversible_command ();
4647 }
4648
4649 void
4650 Editor::toggle_gain_envelope_active ()
4651 {
4652         if (_ignore_region_action) {
4653                 return;
4654         }
4655
4656         RegionSelection rs = get_regions_from_selection_and_entered ();
4657
4658         if (!_session || rs.empty()) {
4659                 return;
4660         }
4661
4662         _session->begin_reversible_command (_("region gain envelope active"));
4663
4664         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4665                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4666                 if (arv) {
4667                         arv->region()->clear_changes ();
4668                         arv->audio_region()->set_envelope_active (!arv->audio_region()->envelope_active());
4669                         _session->add_command (new StatefulDiffCommand (arv->region()));
4670                 }
4671         }
4672
4673         _session->commit_reversible_command ();
4674 }
4675
4676 void
4677 Editor::toggle_region_lock ()
4678 {
4679         if (_ignore_region_action) {
4680                 return;
4681         }
4682
4683         RegionSelection rs = get_regions_from_selection_and_entered ();
4684
4685         if (!_session || rs.empty()) {
4686                 return;
4687         }
4688
4689         _session->begin_reversible_command (_("toggle region lock"));
4690
4691         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4692                 (*i)->region()->clear_changes ();
4693                 (*i)->region()->set_locked (!(*i)->region()->locked());
4694                 _session->add_command (new StatefulDiffCommand ((*i)->region()));
4695         }
4696
4697         _session->commit_reversible_command ();
4698 }
4699
4700 void
4701 Editor::toggle_region_lock_style ()
4702 {
4703         if (_ignore_region_action) {
4704                 return;
4705         }
4706
4707         RegionSelection rs = get_regions_from_selection_and_entered ();
4708
4709         if (!_session || rs.empty()) {
4710                 return;
4711         }
4712
4713         _session->begin_reversible_command (_("region lock style"));
4714
4715         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4716                 (*i)->region()->clear_changes ();
4717                 PositionLockStyle const ns = (*i)->region()->position_lock_style() == AudioTime ? MusicTime : AudioTime;
4718                 (*i)->region()->set_position_lock_style (ns);
4719                 _session->add_command (new StatefulDiffCommand ((*i)->region()));
4720         }
4721
4722         _session->commit_reversible_command ();
4723 }
4724
4725 void
4726 Editor::toggle_opaque_region ()
4727 {
4728         if (_ignore_region_action) {
4729                 return;
4730         }
4731
4732         RegionSelection rs = get_regions_from_selection_and_entered ();
4733
4734         if (!_session || rs.empty()) {
4735                 return;
4736         }
4737
4738         _session->begin_reversible_command (_("change region opacity"));
4739
4740         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
4741                 (*i)->region()->clear_changes ();
4742                 (*i)->region()->set_opaque (!(*i)->region()->opaque());
4743                 _session->add_command (new StatefulDiffCommand ((*i)->region()));
4744         }
4745
4746         _session->commit_reversible_command ();
4747 }
4748
4749 void
4750 Editor::toggle_record_enable ()
4751 {
4752         bool new_state = false;
4753         bool first = true;
4754         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4755                 RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
4756                 if (!rtav)
4757                         continue;
4758                 if (!rtav->is_track())
4759                         continue;
4760
4761                 if (first) {
4762                         new_state = !rtav->track()->record_enabled();
4763                         first = false;
4764                 }
4765
4766                 rtav->track()->set_record_enabled (new_state, this);
4767         }
4768 }
4769
4770 void
4771 Editor::toggle_solo ()
4772 {
4773         bool new_state = false;
4774         bool first = true;
4775         boost::shared_ptr<RouteList> rl (new RouteList);
4776
4777         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4778                 RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
4779
4780                 if (!rtav) {
4781                         continue;
4782                 }
4783
4784                 if (first) {
4785                         new_state = !rtav->route()->soloed ();
4786                         first = false;
4787                 }
4788
4789                 rl->push_back (rtav->route());
4790         }
4791
4792         _session->set_solo (rl, new_state, Session::rt_cleanup, true);
4793 }
4794
4795 void
4796 Editor::toggle_mute ()
4797 {
4798         bool new_state = false;
4799         bool first = true;
4800         boost::shared_ptr<RouteList> rl (new RouteList);
4801
4802         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4803                 RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
4804
4805                 if (!rtav) {
4806                         continue;
4807                 }
4808
4809                 if (first) {
4810                         new_state = !rtav->route()->muted();
4811                         first = false;
4812                 }
4813
4814                 rl->push_back (rtav->route());
4815         }
4816
4817         _session->set_mute (rl, new_state, Session::rt_cleanup, true);
4818 }
4819
4820 void
4821 Editor::toggle_solo_isolate ()
4822 {
4823 }
4824
4825 void
4826 Editor::set_fade_length (bool in)
4827 {
4828         RegionSelection rs = get_regions_from_selection_and_entered ();
4829
4830         if (rs.empty()) {
4831                 return;
4832         }
4833
4834         /* we need a region to measure the offset from the start */
4835
4836         RegionView* rv = rs.front ();
4837
4838         framepos_t pos = get_preferred_edit_position();
4839         framepos_t len;
4840         char const * cmd;
4841
4842         if (pos > rv->region()->last_frame() || pos < rv->region()->first_frame()) {
4843                 /* edit point is outside the relevant region */
4844                 return;
4845         }
4846
4847         if (in) {
4848                 if (pos <= rv->region()->position()) {
4849                         /* can't do it */
4850                         return;
4851                 }
4852                 len = pos - rv->region()->position();
4853                 cmd = _("set fade in length");
4854         } else {
4855                 if (pos >= rv->region()->last_frame()) {
4856                         /* can't do it */
4857                         return;
4858                 }
4859                 len = rv->region()->last_frame() - pos;
4860                 cmd = _("set fade out length");
4861         }
4862
4863         begin_reversible_command (cmd);
4864
4865         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4866                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4867
4868                 if (!tmp) {
4869                         return;
4870                 }
4871
4872                 boost::shared_ptr<AutomationList> alist;
4873                 if (in) {
4874                         alist = tmp->audio_region()->fade_in();
4875                 } else {
4876                         alist = tmp->audio_region()->fade_out();
4877                 }
4878
4879                 XMLNode &before = alist->get_state();
4880
4881                 if (in) {
4882                         tmp->audio_region()->set_fade_in_length (len);
4883                         tmp->audio_region()->set_fade_in_active (true);
4884                 } else {
4885                         tmp->audio_region()->set_fade_out_length (len);
4886                         tmp->audio_region()->set_fade_out_active (true);
4887                 }
4888
4889                 XMLNode &after = alist->get_state();
4890                 _session->add_command(new MementoCommand<AutomationList>(*alist, &before, &after));
4891         }
4892
4893         commit_reversible_command ();
4894 }
4895
4896 void
4897 Editor::set_fade_in_shape (FadeShape shape)
4898 {
4899         RegionSelection rs = get_regions_from_selection_and_entered ();
4900
4901         if (rs.empty()) {
4902                 return;
4903         }
4904
4905         begin_reversible_command (_("set fade in shape"));
4906
4907         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4908                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4909
4910                 if (!tmp) {
4911                         return;
4912                 }
4913
4914                 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_in();
4915                 XMLNode &before = alist->get_state();
4916
4917                 tmp->audio_region()->set_fade_in_shape (shape);
4918
4919                 XMLNode &after = alist->get_state();
4920                 _session->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
4921         }
4922
4923         commit_reversible_command ();
4924
4925 }
4926
4927 void
4928 Editor::set_fade_out_shape (FadeShape shape)
4929 {
4930         RegionSelection rs = get_regions_from_selection_and_entered ();
4931
4932         if (rs.empty()) {
4933                 return;
4934         }
4935
4936         begin_reversible_command (_("set fade out shape"));
4937
4938         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4939                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4940
4941                 if (!tmp) {
4942                         return;
4943                 }
4944
4945                 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_out();
4946                 XMLNode &before = alist->get_state();
4947
4948                 tmp->audio_region()->set_fade_out_shape (shape);
4949
4950                 XMLNode &after = alist->get_state();
4951                 _session->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
4952         }
4953
4954         commit_reversible_command ();
4955 }
4956
4957 void
4958 Editor::set_fade_in_active (bool yn)
4959 {
4960         RegionSelection rs = get_regions_from_selection_and_entered ();
4961
4962         if (rs.empty()) {
4963                 return;
4964         }
4965
4966         begin_reversible_command (_("set fade in active"));
4967
4968         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4969                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4970
4971                 if (!tmp) {
4972                         return;
4973                 }
4974
4975
4976                 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4977
4978                 ar->clear_changes ();
4979                 ar->set_fade_in_active (yn);
4980                 _session->add_command (new StatefulDiffCommand (ar));
4981         }
4982
4983         commit_reversible_command ();
4984 }
4985
4986 void
4987 Editor::set_fade_out_active (bool yn)
4988 {
4989         RegionSelection rs = get_regions_from_selection_and_entered ();
4990
4991         if (rs.empty()) {
4992                 return;
4993         }
4994
4995         begin_reversible_command (_("set fade out active"));
4996
4997         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4998                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4999
5000                 if (!tmp) {
5001                         return;
5002                 }
5003
5004                 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
5005
5006                 ar->clear_changes ();
5007                 ar->set_fade_out_active (yn);
5008                 _session->add_command(new StatefulDiffCommand (ar));
5009         }
5010
5011         commit_reversible_command ();
5012 }
5013
5014 void
5015 Editor::toggle_region_fades (int dir)
5016 {
5017         boost::shared_ptr<AudioRegion> ar;
5018         bool yn = false;
5019
5020         RegionSelection rs = get_regions_from_selection_and_entered ();
5021
5022         if (rs.empty()) {
5023                 return;
5024         }
5025
5026         RegionSelection::iterator i;
5027         for (i = rs.begin(); i != rs.end(); ++i) {
5028                 if ((ar = boost::dynamic_pointer_cast<AudioRegion>((*i)->region())) != 0) {
5029                         if (dir == -1) {
5030                                 yn = ar->fade_out_active ();
5031                         } else {
5032                                 yn = ar->fade_in_active ();
5033                         }
5034                         break;
5035                 }
5036         }
5037
5038         if (i == rs.end()) {
5039                 return;
5040         }
5041
5042         /* XXX should this undo-able? */
5043
5044         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5045                 if ((ar = boost::dynamic_pointer_cast<AudioRegion>((*i)->region())) == 0) {
5046                         continue;
5047                 }
5048                 if (dir == 1 || dir == 0) {
5049                         ar->set_fade_in_active (!yn);
5050                 }
5051
5052                 if (dir == -1 || dir == 0) {
5053                         ar->set_fade_out_active (!yn);
5054                 }
5055         }
5056 }
5057
5058
5059 /** Update region fade visibility after its configuration has been changed */
5060 void
5061 Editor::update_region_fade_visibility ()
5062 {
5063         bool _fade_visibility = _session->config.get_show_region_fades ();
5064
5065         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5066                 AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
5067                 if (v) {
5068                         if (_fade_visibility) {
5069                                 v->audio_view()->show_all_fades ();
5070                         } else {
5071                                 v->audio_view()->hide_all_fades ();
5072                         }
5073                 }
5074         }
5075 }
5076
5077 /** Update crossfade visibility after its configuration has been changed */
5078 void
5079 Editor::update_xfade_visibility ()
5080 {
5081         _xfade_visibility = _session->config.get_xfades_visible ();
5082
5083         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5084                 AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
5085                 if (v) {
5086                         if (_xfade_visibility) {
5087                                 v->show_all_xfades ();
5088                         } else {
5089                                 v->hide_all_xfades ();
5090                         }
5091                 }
5092         }
5093 }
5094
5095 void
5096 Editor::set_edit_point ()
5097 {
5098         framepos_t where;
5099         bool ignored;
5100
5101         if (!mouse_frame (where, ignored)) {
5102                 return;
5103         }
5104
5105         snap_to (where);
5106
5107         if (selection->markers.empty()) {
5108
5109                 mouse_add_new_marker (where);
5110
5111         } else {
5112                 bool ignored;
5113
5114                 Location* loc = find_location_from_marker (selection->markers.front(), ignored);
5115
5116                 if (loc) {
5117                         loc->move_to (where);
5118                 }
5119         }
5120 }
5121
5122 void
5123 Editor::set_playhead_cursor ()
5124 {
5125         if (entered_marker) {
5126                 _session->request_locate (entered_marker->position(), _session->transport_rolling());
5127         } else {
5128                 framepos_t where;
5129                 bool ignored;
5130
5131                 if (!mouse_frame (where, ignored)) {
5132                         return;
5133                 }
5134
5135                 snap_to (where);
5136
5137                 if (_session) {
5138                         _session->request_locate (where, _session->transport_rolling());
5139                 }
5140         }
5141 }
5142
5143 void
5144 Editor::split_region ()
5145 {
5146         if (((mouse_mode == MouseRange) ||
5147              (mouse_mode != MouseObject && _join_object_range_state == JOIN_OBJECT_RANGE_RANGE)) &&
5148             !selection->time.empty()) {
5149                 separate_regions_between (selection->time);
5150                 return;
5151         }
5152
5153         RegionSelection rs = get_regions_from_selection_and_edit_point ();
5154
5155         framepos_t where = get_preferred_edit_position ();
5156
5157         if (rs.empty()) {
5158                 return;
5159         }
5160
5161         split_regions_at (where, rs);
5162 }
5163
5164 void
5165 Editor::ensure_entered_track_selected (bool op_really_wants_one_track_if_none_are_selected)
5166 {
5167         if (entered_track && mouse_mode == MouseObject) {
5168                 if (!selection->tracks.empty()) {
5169                         if (!selection->selected (entered_track)) {
5170                                 selection->add (entered_track);
5171                         }
5172                 } else {
5173                         /* there is no selection, but this operation requires/prefers selected objects */
5174
5175                         if (op_really_wants_one_track_if_none_are_selected) {
5176                                 selection->set (entered_track);
5177                         }
5178                 }
5179         }
5180 }
5181
5182 struct EditorOrderRouteSorter {
5183     bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
5184             /* use of ">" forces the correct sort order */
5185             return a->order_key ("editor") < b->order_key ("editor");
5186     }
5187 };
5188
5189 void
5190 Editor::select_next_route()
5191 {
5192         if (selection->tracks.empty()) {
5193                 selection->set (track_views.front());
5194                 return;
5195         }
5196
5197         TimeAxisView* current = selection->tracks.front();
5198
5199         RouteUI *rui;
5200         do {
5201                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
5202                         if (*i == current) {
5203                                 ++i;
5204                                 if (i != track_views.end()) {
5205                                         current = (*i);
5206                                 } else {
5207                                         current = (*(track_views.begin()));
5208                                         //selection->set (*(track_views.begin()));
5209                                 }
5210                                 break;
5211                         }
5212                 }
5213                 rui = dynamic_cast<RouteUI *>(current);
5214         } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
5215
5216         selection->set(current);
5217
5218         ensure_track_visible(current);
5219 }
5220
5221 void
5222 Editor::select_prev_route()
5223 {
5224         if (selection->tracks.empty()) {
5225                 selection->set (track_views.front());
5226                 return;
5227         }
5228
5229         TimeAxisView* current = selection->tracks.front();
5230
5231         RouteUI *rui;
5232         do {
5233                 for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
5234                         if (*i == current) {
5235                                 ++i;
5236                                 if (i != track_views.rend()) {
5237                                         current = (*i);
5238                                 } else {
5239                                         current = *(track_views.rbegin());
5240                                 }
5241                                 break;
5242                         }
5243                 }
5244                 rui = dynamic_cast<RouteUI *>(current);
5245         } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
5246
5247         selection->set (current);
5248
5249         ensure_track_visible(current);
5250 }
5251
5252 void
5253 Editor::ensure_track_visible(TimeAxisView *track)
5254 {
5255         if (track->hidden())
5256                 return;
5257
5258         double const current_view_min_y = vertical_adjustment.get_value();
5259         double const current_view_max_y = vertical_adjustment.get_value() + vertical_adjustment.get_page_size() - canvas_timebars_vsize;
5260
5261         double const track_min_y = track->y_position ();
5262         double const track_max_y = track->y_position () + track->effective_height ();
5263
5264         if (track_min_y >= current_view_min_y &&
5265             track_max_y <= current_view_max_y) {
5266                 return;
5267         }
5268
5269         double new_value;
5270
5271         if (track_min_y < current_view_min_y) {
5272                 // Track is above the current view
5273                 new_value = track_min_y;
5274         } else {
5275                 // Track is below the current view
5276                 new_value = track->y_position () + track->effective_height() + canvas_timebars_vsize - vertical_adjustment.get_page_size();
5277         }
5278
5279         vertical_adjustment.set_value(new_value);
5280 }
5281
5282 void
5283 Editor::set_loop_from_selection (bool play)
5284 {
5285         if (_session == 0 || selection->time.empty()) {
5286                 return;
5287         }
5288
5289         framepos_t start = selection->time[clicked_selection].start;
5290         framepos_t end = selection->time[clicked_selection].end;
5291
5292         set_loop_range (start, end,  _("set loop range from selection"));
5293
5294         if (play) {
5295                 _session->request_play_loop (true);
5296                 _session->request_locate (start, true);
5297         }
5298 }
5299
5300 void
5301 Editor::set_loop_from_edit_range (bool play)
5302 {
5303         if (_session == 0) {
5304                 return;
5305         }
5306
5307         framepos_t start;
5308         framepos_t end;
5309
5310         if (!get_edit_op_range (start, end)) {
5311                 return;
5312         }
5313
5314         set_loop_range (start, end,  _("set loop range from edit range"));
5315
5316         if (play) {
5317                 _session->request_play_loop (true);
5318                 _session->request_locate (start, true);
5319         }
5320 }
5321
5322 void
5323 Editor::set_loop_from_region (bool play)
5324 {
5325         framepos_t start = max_framepos;
5326         framepos_t end = 0;
5327
5328         RegionSelection rs = get_regions_from_selection_and_entered ();
5329
5330         if (rs.empty()) {
5331                 return;
5332         }
5333
5334         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5335                 if ((*i)->region()->position() < start) {
5336                         start = (*i)->region()->position();
5337                 }
5338                 if ((*i)->region()->last_frame() + 1 > end) {
5339                         end = (*i)->region()->last_frame() + 1;
5340                 }
5341         }
5342
5343         set_loop_range (start, end, _("set loop range from region"));
5344
5345         if (play) {
5346                 _session->request_play_loop (true);
5347                 _session->request_locate (start, true);
5348         }
5349 }
5350
5351 void
5352 Editor::set_punch_from_selection ()
5353 {
5354         if (_session == 0 || selection->time.empty()) {
5355                 return;
5356         }
5357
5358         framepos_t start = selection->time[clicked_selection].start;
5359         framepos_t end = selection->time[clicked_selection].end;
5360
5361         set_punch_range (start, end,  _("set punch range from selection"));
5362 }
5363
5364 void
5365 Editor::set_punch_from_edit_range ()
5366 {
5367         if (_session == 0) {
5368                 return;
5369         }
5370
5371         framepos_t start;
5372         framepos_t end;
5373
5374         if (!get_edit_op_range (start, end)) {
5375                 return;
5376         }
5377
5378         set_punch_range (start, end,  _("set punch range from edit range"));
5379 }
5380
5381 void
5382 Editor::set_punch_from_region ()
5383 {
5384         framepos_t start = max_framepos;
5385         framepos_t end = 0;
5386
5387         RegionSelection rs = get_regions_from_selection_and_entered ();
5388
5389         if (rs.empty()) {
5390                 return;
5391         }
5392
5393         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5394                 if ((*i)->region()->position() < start) {
5395                         start = (*i)->region()->position();
5396                 }
5397                 if ((*i)->region()->last_frame() + 1 > end) {
5398                         end = (*i)->region()->last_frame() + 1;
5399                 }
5400         }
5401
5402         set_punch_range (start, end, _("set punch range from region"));
5403 }
5404
5405 void
5406 Editor::pitch_shift_region ()
5407 {
5408         RegionSelection rs = get_regions_from_selection_and_entered ();
5409
5410         RegionSelection audio_rs;
5411         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5412                 if (dynamic_cast<AudioRegionView*> (*i)) {
5413                         audio_rs.push_back (*i);
5414                 }
5415         }
5416
5417         if (audio_rs.empty()) {
5418                 return;
5419         }
5420
5421         pitch_shift (audio_rs, 1.2);
5422 }
5423
5424 void
5425 Editor::transpose_region ()
5426 {
5427         RegionSelection rs = get_regions_from_selection_and_entered ();
5428
5429         list<MidiRegionView*> midi_region_views;
5430         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
5431                 MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (*i);
5432                 if (mrv) {
5433                         midi_region_views.push_back (mrv);
5434                 }
5435         }
5436
5437         TransposeDialog d;
5438         int const r = d.run ();
5439         if (r != RESPONSE_ACCEPT) {
5440                 return;
5441         }
5442
5443         for (list<MidiRegionView*>::iterator i = midi_region_views.begin(); i != midi_region_views.end(); ++i) {
5444                 (*i)->midi_region()->transpose (d.semitones ());
5445         }
5446 }
5447
5448 void
5449 Editor::set_tempo_from_region ()
5450 {
5451         RegionSelection rs = get_regions_from_selection_and_entered ();
5452
5453         if (!_session || rs.empty()) {
5454                 return;
5455         }
5456
5457         RegionView* rv = rs.front();
5458
5459         define_one_bar (rv->region()->position(), rv->region()->last_frame() + 1);
5460 }
5461
5462 void
5463 Editor::use_range_as_bar ()
5464 {
5465         framepos_t start, end;
5466         if (get_edit_op_range (start, end)) {
5467                 define_one_bar (start, end);
5468         }
5469 }
5470
5471 void
5472 Editor::define_one_bar (framepos_t start, framepos_t end)
5473 {
5474         framepos_t length = end - start;
5475
5476         const Meter& m (_session->tempo_map().meter_at (start));
5477
5478         /* length = 1 bar */
5479
5480         /* now we want frames per beat.
5481            we have frames per bar, and beats per bar, so ...
5482         */
5483
5484         double frames_per_beat = length / m.beats_per_bar();
5485
5486         /* beats per minute = */
5487
5488         double beats_per_minute = (_session->frame_rate() * 60.0) / frames_per_beat;
5489
5490         /* now decide whether to:
5491
5492             (a) set global tempo
5493             (b) add a new tempo marker
5494
5495         */
5496
5497         const TempoSection& t (_session->tempo_map().tempo_section_at (start));
5498
5499         bool do_global = false;
5500
5501         if ((_session->tempo_map().n_tempos() == 1) && (_session->tempo_map().n_meters() == 1)) {
5502
5503                 /* only 1 tempo & 1 meter: ask if the user wants to set the tempo
5504                    at the start, or create a new marker
5505                 */
5506
5507                 vector<string> options;
5508                 options.push_back (_("Cancel"));
5509                 options.push_back (_("Add new marker"));
5510                 options.push_back (_("Set global tempo"));
5511
5512                 Choice c (
5513                         _("Define one bar"),
5514                         _("Do you want to set the global tempo or add a new tempo marker?"),
5515                         options
5516                         );
5517
5518                 c.set_default_response (2);
5519
5520                 switch (c.run()) {
5521                 case 0:
5522                         return;
5523
5524                 case 2:
5525                         do_global = true;
5526                         break;
5527
5528                 default:
5529                         do_global = false;
5530                 }
5531
5532         } else {
5533
5534                 /* more than 1 tempo and/or meter section already, go ahead do the "usual":
5535                    if the marker is at the region starter, change it, otherwise add
5536                    a new tempo marker
5537                 */
5538         }
5539
5540         begin_reversible_command (_("set tempo from region"));
5541         XMLNode& before (_session->tempo_map().get_state());
5542
5543         if (do_global) {
5544                 _session->tempo_map().change_initial_tempo (beats_per_minute, t.note_type());
5545         } else if (t.frame() == start) {
5546                 _session->tempo_map().change_existing_tempo_at (start, beats_per_minute, t.note_type());
5547         } else {
5548                 _session->tempo_map().add_tempo (Tempo (beats_per_minute, t.note_type()), start);
5549         }
5550
5551         XMLNode& after (_session->tempo_map().get_state());
5552
5553         _session->add_command (new MementoCommand<TempoMap>(_session->tempo_map(), &before, &after));
5554         commit_reversible_command ();
5555 }
5556
5557 void
5558 Editor::split_region_at_transients ()
5559 {
5560         AnalysisFeatureList positions;
5561
5562         RegionSelection rs = get_regions_from_selection_and_entered ();
5563
5564         if (!_session || rs.empty()) {
5565                 return;
5566         }
5567
5568         _session->begin_reversible_command (_("split regions"));
5569
5570         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ) {
5571
5572                 RegionSelection::iterator tmp;
5573
5574                 tmp = i;
5575                 ++tmp;
5576
5577                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> ((*i)->region());
5578
5579                 if (ar && (ar->get_transients (positions) == 0)) {
5580                         split_region_at_points ((*i)->region(), positions, true);
5581                         positions.clear ();
5582                 }
5583
5584                 i = tmp;
5585         }
5586
5587         _session->commit_reversible_command ();
5588
5589 }
5590
5591 void
5592 Editor::split_region_at_points (boost::shared_ptr<Region> r, AnalysisFeatureList& positions, bool can_ferret, bool select_new)
5593 {
5594         bool use_rhythmic_rodent = false;
5595
5596         boost::shared_ptr<Playlist> pl = r->playlist();
5597
5598         list<boost::shared_ptr<Region> > new_regions;
5599
5600         if (!pl) {
5601                 return;
5602         }
5603
5604         if (positions.empty()) {
5605                 return;
5606         }
5607
5608
5609         if (positions.size() > 20 && can_ferret) {
5610                 std::string msgstr = string_compose (_("You are about to split\n%1\ninto %2 pieces.\nThis could take a long time."), r->name(), positions.size() + 1);
5611                 MessageDialog msg (msgstr,
5612                                    false,
5613                                    Gtk::MESSAGE_INFO,
5614                                    Gtk::BUTTONS_OK_CANCEL);
5615
5616                 if (can_ferret) {
5617                         msg.add_button (_("Call for the Ferret!"), RESPONSE_APPLY);
5618                         msg.set_secondary_text (_("Press OK to continue with this split operation\nor ask the Ferret dialog to tune the analysis"));
5619                 } else {
5620                         msg.set_secondary_text (_("Press OK to continue with this split operation"));
5621                 }
5622
5623                 msg.set_title (_("Excessive split?"));
5624                 msg.present ();
5625
5626                 int response = msg.run();
5627                 msg.hide ();
5628
5629                 switch (response) {
5630                 case RESPONSE_OK:
5631                         break;
5632                 case RESPONSE_APPLY:
5633                         use_rhythmic_rodent = true;
5634                         break;
5635                 default:
5636                         return;
5637                 }
5638         }
5639
5640         if (use_rhythmic_rodent) {
5641                 show_rhythm_ferret ();
5642                 return;
5643         }
5644
5645         AnalysisFeatureList::const_iterator x;
5646
5647         pl->clear_changes ();
5648
5649         x = positions.begin();
5650
5651         if (x == positions.end()) {
5652                 return;
5653         }
5654
5655         pl->freeze ();
5656         pl->remove_region (r);
5657
5658         framepos_t pos = 0;
5659
5660         while (x != positions.end()) {
5661
5662                 /* deal with positons that are out of scope of present region bounds */
5663                 if (*x <= 0 || *x > r->length()) {
5664                         ++x;
5665                         continue;
5666                 }
5667
5668                 /* file start = original start + how far we from the initial position ?
5669                  */
5670
5671                 framepos_t file_start = r->start() + pos;
5672
5673                 /* length = next position - current position
5674                  */
5675
5676                 framepos_t len = (*x) - pos;
5677
5678                 /* XXX we do we really want to allow even single-sample regions?
5679                    shouldn't we have some kind of lower limit on region size?
5680                 */
5681
5682                 if (len <= 0) {
5683                         break;
5684                 }
5685
5686                 string new_name;
5687
5688                 if (RegionFactory::region_name (new_name, r->name())) {
5689                         break;
5690                 }
5691
5692                 /* do NOT announce new regions 1 by one, just wait till they are all done */
5693
5694                 PropertyList plist;
5695
5696                 plist.add (ARDOUR::Properties::start, file_start);
5697                 plist.add (ARDOUR::Properties::length, len);
5698                 plist.add (ARDOUR::Properties::name, new_name);
5699                 plist.add (ARDOUR::Properties::layer, 0);
5700
5701                 boost::shared_ptr<Region> nr = RegionFactory::create (r->sources(), plist, false);
5702
5703                 pl->add_region (nr, r->position() + pos);
5704
5705                 if (select_new) {
5706                         new_regions.push_front(nr);
5707                 }
5708
5709                 pos += len;
5710                 ++x;
5711         }
5712
5713         string new_name;
5714
5715         RegionFactory::region_name (new_name, r->name());
5716
5717         /* Add the final region */
5718         PropertyList plist;
5719
5720         plist.add (ARDOUR::Properties::start, r->start() + pos);
5721         plist.add (ARDOUR::Properties::length, r->last_frame() - (r->position() + pos) + 1);
5722         plist.add (ARDOUR::Properties::name, new_name);
5723         plist.add (ARDOUR::Properties::layer, 0);
5724
5725         boost::shared_ptr<Region> nr = RegionFactory::create (r->sources(), plist, false);
5726         pl->add_region (nr, r->position() + pos);
5727
5728         if (select_new) {
5729                 new_regions.push_front(nr);
5730         }
5731
5732         pl->thaw ();
5733
5734         _session->add_command (new StatefulDiffCommand (pl));
5735
5736         if (select_new) {
5737
5738                 for (list<boost::shared_ptr<Region> >::iterator i = new_regions.begin(); i != new_regions.end(); ++i){
5739                         set_selected_regionview_from_region_list ((*i), Selection::Add);
5740                 }
5741         }
5742 }
5743
5744 void
5745 Editor::place_transient()
5746 {
5747         if (!_session) {
5748                 return;
5749         }
5750
5751         RegionSelection rs = get_regions_from_selection_and_edit_point ();
5752
5753         if (rs.empty()) {
5754                 return;
5755         }
5756
5757         framepos_t where = get_preferred_edit_position();
5758
5759         _session->begin_reversible_command (_("place transient"));
5760
5761         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
5762                 framepos_t position = (*r)->region()->position();
5763                 (*r)->region()->add_transient(where - position);
5764         }
5765
5766         _session->commit_reversible_command ();
5767 }
5768
5769 void
5770 Editor::remove_transient(ArdourCanvas::Item* item)
5771 {
5772         if (!_session) {
5773                 return;
5774         }
5775
5776         ArdourCanvas::Line* _line = reinterpret_cast<ArdourCanvas::Line*> (item);
5777         assert (_line);
5778
5779         AudioRegionView* _arv = reinterpret_cast<AudioRegionView*> (item->get_data ("regionview"));
5780         _arv->remove_transient (*(float*) _line->get_data ("position"));
5781 }
5782
5783 void
5784 Editor::snap_regions_to_grid ()
5785 {
5786         list <boost::shared_ptr<Playlist > > used_playlists;
5787
5788         RegionSelection rs = get_regions_from_selection_and_entered ();
5789
5790         if (!_session || rs.empty()) {
5791                 return;
5792         }
5793
5794         _session->begin_reversible_command (_("snap regions to grid"));
5795
5796         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
5797
5798                 boost::shared_ptr<Playlist> pl = (*r)->region()->playlist();
5799
5800                 if (!pl->frozen()) {
5801                         /* we haven't seen this playlist before */
5802
5803                         /* remember used playlists so we can thaw them later */
5804                         used_playlists.push_back(pl);
5805                         pl->freeze();
5806                 }
5807
5808                 framepos_t start_frame = (*r)->region()->first_frame ();
5809                 snap_to (start_frame);
5810                 (*r)->region()->set_position (start_frame);
5811         }
5812
5813         while (used_playlists.size() > 0) {
5814                 list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
5815                 (*i)->thaw();
5816                 used_playlists.pop_front();
5817         }
5818
5819         _session->commit_reversible_command ();
5820 }
5821
5822 void
5823 Editor::close_region_gaps ()
5824 {
5825         list <boost::shared_ptr<Playlist > > used_playlists;
5826
5827         RegionSelection rs = get_regions_from_selection_and_entered ();
5828
5829         if (!_session || rs.empty()) {
5830                 return;
5831         }
5832
5833         Dialog dialog (_("Close Region Gaps"));
5834
5835         Table table (2, 3);
5836         table.set_spacings (12);
5837         table.set_border_width (12);
5838         Label* l = manage (new Label (_("Crossfade length")));
5839         l->set_alignment (0, 0.5);
5840         table.attach (*l, 0, 1, 0, 1);
5841
5842         SpinButton spin_crossfade (1, 0);
5843         spin_crossfade.set_range (0, 15);
5844         spin_crossfade.set_increments (1, 1);
5845         spin_crossfade.set_value (5);
5846         table.attach (spin_crossfade, 1, 2, 0, 1);
5847
5848         table.attach (*manage (new Label (_("ms"))), 2, 3, 0, 1);
5849
5850         l = manage (new Label (_("Pull-back length")));
5851         l->set_alignment (0, 0.5);
5852         table.attach (*l, 0, 1, 1, 2);
5853
5854         SpinButton spin_pullback (1, 0);
5855         spin_pullback.set_range (0, 100);
5856         spin_pullback.set_increments (1, 1);
5857         spin_pullback.set_value(30);
5858         table.attach (spin_pullback, 1, 2, 1, 2);
5859
5860         table.attach (*manage (new Label (_("ms"))), 2, 3, 1, 2);
5861
5862         dialog.get_vbox()->pack_start (table);
5863         dialog.add_button (Stock::CANCEL, RESPONSE_CANCEL);
5864         dialog.add_button (_("Ok"), RESPONSE_ACCEPT);
5865         dialog.show_all ();
5866
5867         if (dialog.run () == RESPONSE_CANCEL) {
5868                 return;
5869         }
5870
5871         framepos_t crossfade_len = spin_crossfade.get_value();
5872         framepos_t pull_back_frames = spin_pullback.get_value();
5873
5874         crossfade_len = lrintf (crossfade_len * _session->frame_rate()/1000);
5875         pull_back_frames = lrintf (pull_back_frames * _session->frame_rate()/1000);
5876
5877         /* Iterate over the region list and make adjacent regions overlap by crossfade_len_ms */
5878
5879         _session->begin_reversible_command (_("close region gaps"));
5880
5881         int idx = 0;
5882         boost::shared_ptr<Region> last_region;
5883
5884         rs.sort_by_position_and_track();
5885
5886         for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
5887
5888                 boost::shared_ptr<Playlist> pl = (*r)->region()->playlist();
5889
5890                 if (!pl->frozen()) {
5891                         /* we haven't seen this playlist before */
5892
5893                         /* remember used playlists so we can thaw them later */
5894                         used_playlists.push_back(pl);
5895                         pl->freeze();
5896                 }
5897
5898                 framepos_t position = (*r)->region()->position();
5899
5900                 if (idx == 0 || position < last_region->position()){
5901                         last_region = (*r)->region();
5902                         idx++;
5903                         continue;
5904                 }
5905
5906                 (*r)->region()->trim_front( (position - pull_back_frames));
5907                 last_region->trim_end( (position - pull_back_frames + crossfade_len));
5908
5909                 last_region = (*r)->region();
5910
5911                 idx++;
5912         }
5913
5914         while (used_playlists.size() > 0) {
5915                 list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
5916                 (*i)->thaw();
5917                 used_playlists.pop_front();
5918         }
5919
5920         _session->commit_reversible_command ();
5921 }
5922
5923 void
5924 Editor::tab_to_transient (bool forward)
5925 {
5926         AnalysisFeatureList positions;
5927
5928         RegionSelection rs = get_regions_from_selection_and_entered ();
5929
5930         if (!_session) {
5931                 return;
5932         }
5933
5934         framepos_t pos = _session->audible_frame ();
5935
5936         if (!selection->tracks.empty()) {
5937
5938                 for (TrackSelection::iterator t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
5939
5940                         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*t);
5941
5942                         if (rtv) {
5943                                 boost::shared_ptr<Track> tr = rtv->track();
5944                                 if (tr) {
5945                                         boost::shared_ptr<Playlist> pl = tr->playlist ();
5946                                         if (pl) {
5947                                                 framepos_t result = pl->find_next_transient (pos, forward ? 1 : -1);
5948
5949                                                 if (result >= 0) {
5950                                                         positions.push_back (result);
5951                                                 }
5952                                         }
5953                                 }
5954                         }
5955                 }
5956
5957         } else {
5958
5959                 if (rs.empty()) {
5960                         return;
5961                 }
5962
5963                 for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
5964                         (*r)->region()->get_transients (positions);
5965                 }
5966         }
5967
5968         TransientDetector::cleanup_transients (positions, _session->frame_rate(), 3.0);
5969
5970         if (forward) {
5971                 AnalysisFeatureList::iterator x;
5972
5973                 for (x = positions.begin(); x != positions.end(); ++x) {
5974                         if ((*x) > pos) {
5975                                 break;
5976                         }
5977                 }
5978
5979                 if (x != positions.end ()) {
5980                         _session->request_locate (*x);
5981                 }
5982
5983         } else {
5984                 AnalysisFeatureList::reverse_iterator x;
5985
5986                 for (x = positions.rbegin(); x != positions.rend(); ++x) {
5987                         if ((*x) < pos) {
5988                                 break;
5989                         }
5990                 }
5991
5992                 if (x != positions.rend ()) {
5993                         _session->request_locate (*x);
5994                 }
5995         }
5996 }
5997
5998 void
5999 Editor::playhead_forward_to_grid ()
6000 {
6001         if (!_session) return;
6002         framepos_t pos = playhead_cursor->current_frame;
6003         if (pos < max_framepos - 1) {
6004                 pos += 2;
6005                 snap_to_internal (pos, 1, false);
6006                 _session->request_locate (pos);
6007         }
6008 }
6009
6010
6011 void
6012 Editor::playhead_backward_to_grid ()
6013 {
6014         if (!_session) return;
6015         framepos_t pos = playhead_cursor->current_frame;
6016         if (pos > 2) {
6017                 pos -= 2;
6018                 snap_to_internal (pos, -1, false);
6019                 _session->request_locate (pos);
6020         }
6021 }
6022
6023 void
6024 Editor::set_track_height (Height h)
6025 {
6026         TrackSelection& ts (selection->tracks);
6027
6028         for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
6029                 (*x)->set_height_enum (h);
6030         }
6031 }
6032
6033 void
6034 Editor::toggle_tracks_active ()
6035 {
6036         TrackSelection& ts (selection->tracks);
6037         bool first = true;
6038         bool target = false;
6039
6040         if (ts.empty()) {
6041                 return;
6042         }
6043
6044         for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
6045                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*x);
6046
6047                 if (rtv) {
6048                         if (first) {
6049                                 target = !rtv->_route->active();
6050                                 first = false;
6051                         }
6052                         rtv->_route->set_active (target, this);
6053                 }
6054         }
6055 }
6056
6057 void
6058 Editor::remove_tracks ()
6059 {
6060         TrackSelection& ts (selection->tracks);
6061
6062         if (ts.empty()) {
6063                 return;
6064         }
6065
6066         vector<string> choices;
6067         string prompt;
6068         int ntracks = 0;
6069         int nbusses = 0;
6070         const char* trackstr;
6071         const char* busstr;
6072         vector<boost::shared_ptr<Route> > routes;
6073         bool special_bus = false;
6074
6075         for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
6076                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*x);
6077                 if (rtv) {
6078                         if (rtv->is_track()) {
6079                                 ntracks++;
6080                         } else {
6081                                 nbusses++;
6082                         }
6083                 }
6084                 routes.push_back (rtv->_route);
6085
6086                 if (rtv->route()->is_master() || rtv->route()->is_monitor()) {
6087                         special_bus = true;
6088                 }
6089         }
6090
6091         if (special_bus && !Config->get_allow_special_bus_removal()) {
6092                 MessageDialog msg (_("That would be bad news ...."),
6093                                    false,
6094                                    Gtk::MESSAGE_INFO,
6095                                    Gtk::BUTTONS_OK);
6096                 msg.set_secondary_text (string_compose (_(
6097                                                                 "Removing the master or monitor bus is such a bad idea\n\
6098 that %1 is not going to allow it.\n\
6099 \n\
6100 If you really want to do this sort of thing\n\
6101 edit your ardour.rc file to set the\n\
6102 \"allow-special-bus-removal\" option to be \"yes\""), PROGRAM_NAME));
6103
6104                 msg.present ();
6105                 msg.run ();
6106                 return;
6107         }
6108
6109         if (ntracks + nbusses == 0) {
6110                 return;
6111         }
6112
6113         if (ntracks > 1) {
6114                 trackstr = _("tracks");
6115         } else {
6116                 trackstr = _("track");
6117         }
6118
6119         if (nbusses > 1) {
6120                 busstr = _("busses");
6121         } else {
6122                 busstr = _("bus");
6123         }
6124
6125         if (ntracks) {
6126                 if (nbusses) {
6127                         prompt  = string_compose (_("Do you really want to remove %1 %2 and %3 %4?\n"
6128                                                     "(You may also lose the playlists associated with the %2)\n\n"
6129                                                     "This action cannot be undone, and the session file will be overwritten!"),
6130                                                   ntracks, trackstr, nbusses, busstr);
6131                 } else {
6132                         prompt  = string_compose (_("Do you really want to remove %1 %2?\n"
6133                                                     "(You may also lose the playlists associated with the %2)\n\n"
6134                                                     "This action cannot be undone, and the session file will be overwritten!"),
6135                                                   ntracks, trackstr);
6136                 }
6137         } else if (nbusses) {
6138                 prompt  = string_compose (_("Do you really want to remove %1 %2?\n\n"
6139                                             "This action cannot be undon, and the session file will be overwritten"),
6140                                           nbusses, busstr);
6141         }
6142
6143         choices.push_back (_("No, do nothing."));
6144         if (ntracks + nbusses > 1) {
6145                 choices.push_back (_("Yes, remove them."));
6146         } else {
6147                 choices.push_back (_("Yes, remove it."));
6148         }
6149
6150         string title;
6151         if (ntracks) {
6152                 title = string_compose (_("Remove %1"), trackstr);
6153         } else {
6154                 title = string_compose (_("Remove %1"), busstr);
6155         }
6156
6157         Choice prompter (title, prompt, choices);
6158
6159         if (prompter.run () != 1) {
6160                 return;
6161         }
6162
6163         for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
6164                 _session->remove_route (*x);
6165         }
6166 }
6167
6168 void
6169 Editor::do_insert_time ()
6170 {
6171         if (selection->tracks.empty()) {
6172                 return;
6173         }
6174
6175         InsertTimeDialog d (*this);
6176         int response = d.run ();
6177
6178         if (response != RESPONSE_OK) {
6179                 return;
6180         }
6181
6182         if (d.distance() == 0) {
6183                 return;
6184         }
6185
6186         InsertTimeOption opt = d.intersected_region_action ();
6187
6188         insert_time (
6189                 get_preferred_edit_position(),
6190                 d.distance(),
6191                 opt,
6192                 d.all_playlists(),
6193                 d.move_glued(),
6194                 d.move_markers(),
6195                 d.move_glued_markers(),
6196                 d.move_locked_markers(),
6197                 d.move_tempos()
6198                 );
6199 }
6200
6201 void
6202 Editor::insert_time (
6203         framepos_t pos, framecnt_t frames, InsertTimeOption opt,
6204         bool all_playlists, bool ignore_music_glue, bool markers_too, bool glued_markers_too, bool locked_markers_too, bool tempo_too
6205         )
6206 {
6207         bool commit = false;
6208
6209         if (Config->get_edit_mode() == Lock) {
6210                 return;
6211         }
6212
6213         begin_reversible_command (_("insert time"));
6214
6215         for (TrackSelection::iterator x = selection->tracks.begin(); x != selection->tracks.end(); ++x) {
6216
6217                 /* regions */
6218
6219                 vector<boost::shared_ptr<Playlist> > pl;
6220                 if (all_playlists) {
6221                         RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*x);
6222                         if (rtav) {
6223                                 pl = _session->playlists->playlists_for_track (rtav->track ());
6224                         }
6225                 } else {
6226                         if ((*x)->playlist ()) {
6227                                 pl.push_back ((*x)->playlist ());
6228                         }
6229                 }
6230
6231                 for (vector<boost::shared_ptr<Playlist> >::iterator i = pl.begin(); i != pl.end(); ++i) {
6232
6233                         (*i)->clear_changes ();
6234                         (*i)->clear_owned_changes ();
6235
6236                         if (opt == SplitIntersected) {
6237                                 (*i)->split (pos);
6238                         }
6239
6240                         (*i)->shift (pos, frames, (opt == MoveIntersected), ignore_music_glue);
6241
6242                         vector<Command*> cmds;
6243                         (*i)->rdiff (cmds);
6244                         _session->add_commands (cmds);
6245
6246                         _session->add_command (new StatefulDiffCommand (*i));
6247                         commit = true;
6248                 }
6249
6250                 /* automation */
6251                 RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*x);
6252                 if (rtav) {
6253                         rtav->route ()->shift (pos, frames);
6254                         commit = true;
6255                 }
6256         }
6257
6258         /* markers */
6259         if (markers_too) {
6260                 bool moved = false;
6261                 XMLNode& before (_session->locations()->get_state());
6262                 Locations::LocationList copy (_session->locations()->list());
6263
6264                 for (Locations::LocationList::iterator i = copy.begin(); i != copy.end(); ++i) {
6265
6266                         Locations::LocationList::const_iterator tmp;
6267
6268                         bool const was_locked = (*i)->locked ();
6269                         if (locked_markers_too) {
6270                                 (*i)->unlock ();
6271                         }
6272
6273                         if ((*i)->position_lock_style() == AudioTime || glued_markers_too) {
6274
6275                                 if ((*i)->start() >= pos) {
6276                                         (*i)->set_start ((*i)->start() + frames);
6277                                         if (!(*i)->is_mark()) {
6278                                                 (*i)->set_end ((*i)->end() + frames);
6279                                         }
6280                                         moved = true;
6281                                 }
6282
6283                         }
6284
6285                         if (was_locked) {
6286                                 (*i)->lock ();
6287                         }
6288                 }
6289
6290                 if (moved) {
6291                         XMLNode& after (_session->locations()->get_state());
6292                         _session->add_command (new MementoCommand<Locations>(*_session->locations(), &before, &after));
6293                 }
6294         }
6295
6296         if (tempo_too) {
6297                 _session->tempo_map().insert_time (pos, frames);
6298         }
6299
6300         if (commit) {
6301                 commit_reversible_command ();
6302         }
6303 }
6304
6305 void
6306 Editor::fit_selected_tracks ()
6307 {
6308         if (!selection->tracks.empty()) {
6309                 fit_tracks (selection->tracks);
6310         } else {
6311                 TrackViewList tvl;
6312
6313                 /* no selected tracks - use tracks with selected regions */
6314
6315                 if (!selection->regions.empty()) {
6316                         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
6317                                 tvl.push_back (&(*r)->get_time_axis_view ());
6318                         }
6319
6320                         if (!tvl.empty()) {
6321                                 fit_tracks (tvl);
6322                         }
6323                 } else if (internal_editing()) {
6324                         /* no selected tracks, or regions, but in internal edit mode, so follow the mouse and use
6325                            the entered track
6326                         */
6327                         if (entered_track) {
6328                                 tvl.push_back (entered_track);
6329                                 fit_tracks (tvl);
6330                         }
6331                 }
6332         }
6333 }
6334
6335 void
6336 Editor::fit_tracks (TrackViewList & tracks)
6337 {
6338         if (tracks.empty()) {
6339                 return;
6340         }
6341
6342         uint32_t child_heights = 0;
6343         int visible_tracks = 0;
6344
6345         for (TrackSelection::iterator t = tracks.begin(); t != tracks.end(); ++t) {
6346
6347                 if (!(*t)->marked_for_display()) {
6348                         continue;
6349                 }
6350
6351                 child_heights += (*t)->effective_height() - (*t)->current_height();
6352                 ++visible_tracks;
6353         }
6354
6355         uint32_t h = (uint32_t) floor ((_canvas_height - child_heights - canvas_timebars_vsize) / visible_tracks);
6356         double first_y_pos = DBL_MAX;
6357
6358         if (h < TimeAxisView::preset_height (HeightSmall)) {
6359                 MessageDialog msg (*this, _("There are too many tracks to fit in the current window"));
6360                 /* too small to be displayed */
6361                 return;
6362         }
6363
6364         undo_visual_stack.push_back (current_visual_state());
6365
6366         /* build a list of all tracks, including children */
6367
6368         TrackViewList all;
6369         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
6370                 all.push_back (*i);
6371                 TimeAxisView::Children c = (*i)->get_child_list ();
6372                 for (TimeAxisView::Children::iterator j = c.begin(); j != c.end(); ++j) {
6373                         all.push_back (j->get());
6374                 }
6375         }
6376
6377         /* operate on all tracks, hide unselected ones that are in the middle of selected ones */
6378
6379         bool prev_was_selected = false;
6380         bool is_selected = tracks.contains (all.front());
6381         bool next_is_selected;
6382
6383         for (TrackViewList::iterator t = all.begin(); t != all.end(); ++t) {
6384
6385                 TrackViewList::iterator next;
6386
6387                 next = t;
6388                 ++next;
6389
6390                 if (next != all.end()) {
6391                         next_is_selected = tracks.contains (*next);
6392                 } else {
6393                         next_is_selected = false;
6394                 }
6395
6396                 if ((*t)->marked_for_display ()) {
6397                         if (is_selected) {
6398                                 (*t)->set_height (h);
6399                                 first_y_pos = std::min ((*t)->y_position (), first_y_pos);
6400                         } else {
6401                                 if (prev_was_selected && next_is_selected) {
6402                                         hide_track_in_display (*t);
6403                                 }
6404                         }
6405                 }
6406
6407                 prev_was_selected = is_selected;
6408                 is_selected = next_is_selected;
6409         }
6410
6411         /*
6412            set the controls_layout height now, because waiting for its size
6413            request signal handler will cause the vertical adjustment setting to fail
6414         */
6415
6416         controls_layout.property_height () = full_canvas_height - canvas_timebars_vsize;
6417         vertical_adjustment.set_value (first_y_pos);
6418
6419         redo_visual_stack.push_back (current_visual_state());
6420 }
6421
6422 void
6423 Editor::save_visual_state (uint32_t n)
6424 {
6425         while (visual_states.size() <= n) {
6426                 visual_states.push_back (0);
6427         }
6428
6429         delete visual_states[n];
6430
6431         visual_states[n] = current_visual_state (true);
6432         gdk_beep ();
6433 }
6434
6435 void
6436 Editor::goto_visual_state (uint32_t n)
6437 {
6438         if (visual_states.size() <= n) {
6439                 return;
6440         }
6441
6442         if (visual_states[n] == 0) {
6443                 return;
6444         }
6445
6446         use_visual_state (*visual_states[n]);
6447 }
6448
6449 void
6450 Editor::start_visual_state_op (uint32_t n)
6451 {
6452         if (visual_state_op_connection.empty()) {
6453                 visual_state_op_connection = Glib::signal_timeout().connect (sigc::bind (sigc::mem_fun (*this, &Editor::end_visual_state_op), n), 1000);
6454         }
6455 }
6456
6457 void
6458 Editor::cancel_visual_state_op (uint32_t n)
6459 {
6460         if (!visual_state_op_connection.empty()) {
6461                 visual_state_op_connection.disconnect();
6462                 goto_visual_state (n);
6463         }  else {
6464                 //we land here if called from the menu OR if end_visual_state_op has been called
6465                 //so check if we are already in visual state n
6466                 // XXX not yet checking it at all, but redoing does not hurt
6467                 goto_visual_state (n);
6468         }
6469 }
6470
6471 bool
6472 Editor::end_visual_state_op (uint32_t n)
6473 {
6474         visual_state_op_connection.disconnect();
6475         save_visual_state (n);
6476
6477         PopUp* pup = new PopUp (WIN_POS_MOUSE, 1000, true);
6478         char buf[32];
6479         snprintf (buf, sizeof (buf), _("Saved view %u"), n+1);
6480         pup->set_text (buf);
6481         pup->touch();
6482
6483         return false; // do not call again
6484 }
6485
6486 void
6487 Editor::toggle_region_mute ()
6488 {
6489         if (_ignore_region_action) {
6490                 return;
6491         }
6492
6493         RegionSelection rs = get_regions_from_selection_and_entered ();
6494
6495         if (rs.empty ()) {
6496                 return;
6497         }
6498
6499         if (rs.size() > 1) {
6500                 begin_reversible_command (_("mute regions"));
6501         } else {
6502                 begin_reversible_command (_("mute region"));
6503         }
6504
6505         for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
6506
6507                 (*i)->region()->playlist()->clear_changes ();
6508                 (*i)->region()->set_muted (!(*i)->region()->muted ());
6509                 _session->add_command (new StatefulDiffCommand ((*i)->region()->playlist()));
6510
6511         }
6512
6513         commit_reversible_command ();
6514 }
6515
6516 void
6517 Editor::combine_regions ()
6518 {
6519         /* foreach track with selected regions, take all selected regions
6520            and join them into a new region containing the subregions (as a
6521            playlist)
6522         */
6523
6524         typedef set<RouteTimeAxisView*> RTVS;
6525         RTVS tracks;
6526
6527         if (selection->regions.empty()) {
6528                 return;
6529         }
6530
6531         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
6532                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&(*i)->get_time_axis_view());
6533
6534                 if (rtv) {
6535                         tracks.insert (rtv);
6536                 }
6537         }
6538
6539         begin_reversible_command (_("combine regions"));
6540
6541         vector<RegionView*> new_selection;
6542
6543         for (RTVS::iterator i = tracks.begin(); i != tracks.end(); ++i) {
6544                 RegionView* rv;
6545
6546                 if ((rv = (*i)->combine_regions ()) != 0) {
6547                         new_selection.push_back (rv);
6548                 }
6549         }
6550
6551         selection->clear_regions ();
6552         for (vector<RegionView*>::iterator i = new_selection.begin(); i != new_selection.end(); ++i) {
6553                 selection->add (*i);
6554         }
6555
6556         commit_reversible_command ();
6557 }
6558
6559 void
6560 Editor::uncombine_regions ()
6561 {
6562         typedef set<RouteTimeAxisView*> RTVS;
6563         RTVS tracks;
6564
6565         if (selection->regions.empty()) {
6566                 return;
6567         }
6568
6569         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
6570                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&(*i)->get_time_axis_view());
6571
6572                 if (rtv) {
6573                         tracks.insert (rtv);
6574                 }
6575         }
6576
6577         begin_reversible_command (_("uncombine regions"));
6578
6579         for (RTVS::iterator i = tracks.begin(); i != tracks.end(); ++i) {
6580                 (*i)->uncombine_regions ();
6581         }
6582
6583         commit_reversible_command ();
6584 }
6585