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