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