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