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_region_list_selection (float times)
2100 {
2101         RouteTimeAxisView *tv = 0;
2102         boost::shared_ptr<Playlist> playlist;
2103
2104         if (clicked_routeview != 0) {
2105                 tv = clicked_routeview;
2106         } else if (!selection->tracks.empty()) {
2107                 if ((tv = dynamic_cast<RouteTimeAxisView*>(selection->tracks.front())) == 0) {
2108                         return;
2109                 }
2110         } else if (entered_track != 0) {
2111                 if ((tv = dynamic_cast<RouteTimeAxisView*>(entered_track)) == 0) {
2112                         return;
2113                 }
2114         } else {
2115                 return;
2116         }
2117
2118         if ((playlist = tv->playlist()) == 0) {
2119                 return;
2120         }
2121
2122         Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
2123
2124         if (selected->count_selected_rows() != 1) {
2125                 return;
2126         }
2127
2128         TreeView::Selection::ListHandle_Path rows = selected->get_selected_rows ();
2129
2130         /* only one row selected, so rows.begin() is it */
2131
2132         TreeIter iter;
2133
2134         if ((iter = region_list_model->get_iter (*rows.begin()))) {
2135
2136                 boost::shared_ptr<Region> region = (*iter)[region_list_columns.region];
2137
2138                 begin_reversible_command (_("insert region"));
2139                 XMLNode &before = playlist->get_state();
2140                 playlist->add_region ((RegionFactory::create (region)), get_preferred_edit_position(), times);
2141                 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
2142                 commit_reversible_command ();
2143         }
2144 }
2145
2146 /* BUILT-IN EFFECTS */
2147
2148 void
2149 Editor::reverse_selection ()
2150 {
2151
2152 }
2153
2154 /* GAIN ENVELOPE EDITING */
2155
2156 void
2157 Editor::edit_envelope ()
2158 {
2159 }
2160
2161 /* PLAYBACK */
2162
2163 void
2164 Editor::transition_to_rolling (bool fwd)
2165 {
2166         if (!session) {
2167                 return;
2168         }
2169
2170         switch (Config->get_slave_source()) {
2171         case None:
2172         case JACK:
2173                 break;
2174         default:
2175                 /* transport controlled by the master */
2176                 return;
2177         }
2178
2179         if (session->is_auditioning()) {
2180                 session->cancel_audition ();
2181                 return;
2182         }
2183
2184         session->request_transport_speed (fwd ? 1.0f : -1.0f);
2185 }
2186
2187 void
2188 Editor::toggle_playback (bool with_abort)
2189 {
2190         if (!session) {
2191                 return;
2192         }
2193
2194         switch (Config->get_slave_source()) {
2195         case None:
2196         case JACK:
2197                 break;
2198         default:
2199                 /* transport controlled by the master */
2200                 return;
2201         }
2202
2203         if (session->is_auditioning()) {
2204                 session->cancel_audition ();
2205                 return;
2206         }
2207
2208         if (session->transport_rolling()) {
2209                 session->request_stop (with_abort);
2210                 if (session->get_play_loop()) {
2211                         session->request_play_loop (false);
2212                 }
2213         } else {
2214                 session->request_transport_speed (1.0f);
2215         }
2216 }
2217
2218 void
2219 Editor::play_from_start ()
2220 {
2221         session->request_locate (session->current_start_frame(), true);
2222 }
2223
2224 void
2225 Editor::play_from_edit_point ()
2226 {
2227         session->request_locate (get_preferred_edit_position(), true);
2228 }
2229
2230 void
2231 Editor::play_from_edit_point_and_return ()
2232 {
2233         nframes64_t start_frame;
2234         nframes64_t return_frame;
2235
2236         /* don't reset the return frame if its already set */
2237
2238         if ((return_frame = session->requested_return_frame()) < 0) {
2239                 return_frame = session->audible_frame();
2240         }
2241
2242         start_frame = get_preferred_edit_position (true);
2243
2244         if (start_frame >= 0) {
2245                 session->request_roll_at_and_return (start_frame, return_frame);
2246         }
2247 }
2248
2249 void
2250 Editor::play_selection ()
2251 {
2252         if (selection->time.empty()) {
2253                 return;
2254         }
2255
2256         session->request_play_range (true);
2257 }
2258
2259 void
2260 Editor::loop_selected_region ()
2261 {
2262         if (!selection->regions.empty()) {
2263                 RegionView *rv = *(selection->regions.begin());
2264                 Location* tll;
2265
2266                 if ((tll = transport_loop_location()) != 0)  {
2267
2268                         tll->set (rv->region()->position(), rv->region()->last_frame());
2269
2270                         // enable looping, reposition and start rolling
2271
2272                         session->request_play_loop (true);
2273                         session->request_locate (tll->start(), false);
2274                         session->request_transport_speed (1.0f);
2275                 }
2276         }
2277 }
2278
2279 void
2280 Editor::play_location (Location& location)
2281 {
2282         if (location.start() <= location.end()) {
2283                 return;
2284         }
2285
2286         session->request_bounded_roll (location.start(), location.end());
2287 }
2288
2289 void
2290 Editor::loop_location (Location& location)
2291 {
2292         if (location.start() <= location.end()) {
2293                 return;
2294         }
2295
2296         Location* tll;
2297
2298         if ((tll = transport_loop_location()) != 0) {
2299                 tll->set (location.start(), location.end());
2300
2301                 // enable looping, reposition and start rolling
2302                 session->request_play_loop (true);
2303                 session->request_locate (tll->start(), true);
2304         }
2305 }
2306
2307 void
2308 Editor::raise_region ()
2309 {
2310         selection->foreach_region (&Region::raise);
2311 }
2312
2313 void
2314 Editor::raise_region_to_top ()
2315 {
2316         selection->foreach_region (&Region::raise_to_top);
2317 }
2318
2319 void
2320 Editor::lower_region ()
2321 {
2322         selection->foreach_region (&Region::lower);
2323 }
2324
2325 void
2326 Editor::lower_region_to_bottom ()
2327 {
2328         selection->foreach_region (&Region::lower_to_bottom);
2329 }
2330
2331 /** Show the region editor for the selected regions */
2332 void
2333 Editor::edit_region ()
2334 {
2335         selection->foreach_regionview (&RegionView::show_region_editor);
2336 }
2337
2338 void
2339 Editor::rename_region()
2340 {
2341         if (selection->regions.empty()) {
2342                 return;
2343         }
2344
2345         WindowTitle title (Glib::get_application_name());
2346         title += _("Rename Region");
2347
2348         ArdourDialog d (*this, title.get_string(), true, false);
2349         Entry entry;
2350         Label label (_("New name:"));
2351         HBox hbox;
2352
2353         hbox.set_spacing (6);
2354         hbox.pack_start (label, false, false);
2355         hbox.pack_start (entry, true, true);
2356
2357         d.get_vbox()->set_border_width (12);
2358         d.get_vbox()->pack_start (hbox, false, false);
2359
2360         d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
2361         d.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2362
2363         d.set_size_request (300, -1);
2364         d.set_position (Gtk::WIN_POS_MOUSE);
2365
2366         entry.set_text (selection->regions.front()->region()->name());
2367         entry.select_region (0, -1);
2368
2369         entry.signal_activate().connect (bind (mem_fun (d, &Dialog::response), RESPONSE_OK));
2370
2371         d.show_all ();
2372
2373         entry.grab_focus();
2374
2375         int ret = d.run();
2376
2377         d.hide ();
2378
2379         if (ret == RESPONSE_OK) {
2380                 std::string str = entry.get_text();
2381                 strip_whitespace_edges (str);
2382                 if (!str.empty()) {
2383                         selection->regions.front()->region()->set_name (str);
2384                         redisplay_regions ();
2385                 }
2386         }
2387 }
2388
2389 void
2390 Editor::audition_playlist_region_via_route (boost::shared_ptr<Region> region, Route& route)
2391 {
2392         if (session->is_auditioning()) {
2393                 session->cancel_audition ();
2394         }
2395
2396         // note: some potential for creativity here, because region doesn't
2397         // have to belong to the playlist that Route is handling
2398
2399         // bool was_soloed = route.soloed();
2400
2401         route.set_solo (true, this);
2402
2403         session->request_bounded_roll (region->position(), region->position() + region->length());
2404
2405         /* XXX how to unset the solo state ? */
2406 }
2407
2408 /** Start an audition of the first selected region */
2409 void
2410 Editor::play_edit_range ()
2411 {
2412         nframes64_t start, end;
2413
2414         if (get_edit_op_range (start, end)) {
2415                 session->request_bounded_roll (start, end);
2416         }
2417 }
2418
2419 void
2420 Editor::play_selected_region ()
2421 {
2422         nframes64_t start = max_frames;
2423         nframes64_t end = 0;
2424
2425         ExclusiveRegionSelection esr (*this, entered_regionview);
2426
2427         if (selection->regions.empty()) {
2428                 return;
2429         }
2430
2431         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2432                 if ((*i)->region()->position() < start) {
2433                         start = (*i)->region()->position();
2434                 }
2435                 if ((*i)->region()->last_frame() + 1 > end) {
2436                         end = (*i)->region()->last_frame() + 1;
2437                 }
2438         }
2439
2440         session->request_stop ();
2441         session->request_bounded_roll (start, end);
2442 }
2443
2444 void
2445 Editor::audition_playlist_region_standalone (boost::shared_ptr<Region> region)
2446 {
2447         session->audition_region (region);
2448 }
2449
2450 void
2451 Editor::build_interthread_progress_window ()
2452 {
2453         interthread_progress_window = new ArdourDialog (X_("interthread progress"), true);
2454
2455         interthread_progress_bar.set_orientation (Gtk::PROGRESS_LEFT_TO_RIGHT);
2456
2457         interthread_progress_window->get_vbox()->pack_start (interthread_progress_label, false, false);
2458         interthread_progress_window->get_vbox()->pack_start (interthread_progress_bar,false, false);
2459
2460         // GTK2FIX: this button needs a modifiable label
2461
2462         Button* b = interthread_progress_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
2463         b->signal_clicked().connect (mem_fun(*this, &Editor::interthread_cancel_clicked));
2464
2465         interthread_cancel_button.add (interthread_cancel_label);
2466
2467         interthread_progress_window->set_default_size (200, 100);
2468 }
2469
2470 void
2471 Editor::interthread_cancel_clicked ()
2472 {
2473         if (current_interthread_info) {
2474                 current_interthread_info->cancel = true;
2475         }
2476 }
2477
2478 void
2479 Editor::region_from_selection ()
2480 {
2481         if (clicked_axisview == 0) {
2482                 return;
2483         }
2484
2485         if (selection->time.empty()) {
2486                 return;
2487         }
2488
2489         nframes_t start = selection->time[clicked_selection].start;
2490         nframes_t end = selection->time[clicked_selection].end;
2491
2492         nframes_t selection_cnt = end - start + 1;
2493
2494         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2495                 boost::shared_ptr<AudioRegion> current;
2496                 boost::shared_ptr<Region> current_r;
2497                 boost::shared_ptr<Playlist> pl;
2498
2499                 nframes_t internal_start;
2500                 string new_name;
2501
2502                 if ((pl = (*i)->playlist()) == 0) {
2503                         continue;
2504                 }
2505
2506                 if ((current_r = pl->top_region_at (start)) == 0) {
2507                         continue;
2508                 }
2509
2510                 current = boost::dynamic_pointer_cast<AudioRegion> (current_r);
2511                 assert(current); // FIXME
2512                 if (current != 0) {
2513                         internal_start = start - current->position();
2514                         session->region_name (new_name, current->name(), true);
2515                         boost::shared_ptr<Region> region (RegionFactory::create (current, internal_start, selection_cnt, new_name));
2516                 }
2517         }
2518 }
2519
2520 void
2521 Editor::create_region_from_selection (vector<boost::shared_ptr<AudioRegion> >& new_regions)
2522 {
2523         if (selection->time.empty() || selection->tracks.empty()) {
2524                 return;
2525         }
2526
2527         nframes_t start = selection->time[clicked_selection].start;
2528         nframes_t end = selection->time[clicked_selection].end;
2529
2530         sort_track_selection ();
2531
2532         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2533
2534                 boost::shared_ptr<AudioRegion> current;
2535                 boost::shared_ptr<Region> current_r;
2536                 boost::shared_ptr<Playlist> playlist;
2537                 nframes_t internal_start;
2538                 string new_name;
2539
2540                 if ((playlist = (*i)->playlist()) == 0) {
2541                         continue;
2542                 }
2543
2544                 if ((current_r = playlist->top_region_at(start)) == 0) {
2545                         continue;
2546                 }
2547
2548                 if ((current = boost::dynamic_pointer_cast<AudioRegion>(current_r)) == 0) {
2549                         continue;
2550                 }
2551
2552                 internal_start = start - current->position();
2553                 session->region_name (new_name, current->name(), true);
2554
2555                 new_regions.push_back (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (current, internal_start, end - start + 1, new_name)));
2556         }
2557 }
2558
2559 void
2560 Editor::split_multichannel_region ()
2561 {
2562         if (selection->regions.empty()) {
2563                 return;
2564         }
2565
2566         vector<boost::shared_ptr<AudioRegion> > v;
2567
2568         for (list<RegionView*>::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
2569
2570                 AudioRegionView* arv = dynamic_cast<AudioRegionView*>(*x);
2571
2572                 if (!arv || arv->audio_region()->n_channels() < 2) {
2573                         continue;
2574                 }
2575
2576                 (arv)->audio_region()->separate_by_channel (*session, v);
2577         }
2578 }
2579
2580 void
2581 Editor::new_region_from_selection ()
2582 {
2583         region_from_selection ();
2584         cancel_selection ();
2585 }
2586
2587 static void
2588 add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
2589 {
2590         switch (rv->region()->coverage (ar->start, ar->end - 1)) {
2591         case OverlapNone:
2592                 break;
2593         default:
2594                 rs->push_back (rv);
2595         }
2596 }
2597
2598 void
2599 Editor::separate_regions_between (const TimeSelection& ts)
2600 {
2601         bool in_command = false;
2602         boost::shared_ptr<Playlist> playlist;
2603         RegionSelection new_selection;
2604         TrackSelection tmptracks;
2605
2606         if (selection->tracks.empty()) {
2607
2608                 /* use tracks with selected regions */
2609
2610                 for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2611                         TimeAxisView* tv = &(*i)->get_time_axis_view();
2612
2613                         if (find (tmptracks.begin(), tmptracks.end(), tv) == tmptracks.end()) {
2614                                 tmptracks.push_back (tv);
2615                         }
2616                 }
2617
2618                 if (tmptracks.empty()) {
2619                         /* no regions selected: use all tracks */
2620                         tmptracks = track_views;
2621                 }
2622
2623         } else {
2624
2625                 tmptracks = selection->tracks;
2626
2627         }
2628
2629         sort_track_selection (&tmptracks);
2630
2631
2632
2633
2634         for (TrackSelection::iterator i = tmptracks.begin(); i != tmptracks.end(); ++i) {
2635
2636                 RouteTimeAxisView* rtv;
2637
2638                 if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
2639
2640                         if (rtv->is_track()) {
2641
2642                                 /* no edits to destructive tracks */
2643
2644                                 if (rtv->track()->diskstream()->destructive()) {
2645                                         continue;
2646                                 }
2647
2648                                 if ((playlist = rtv->playlist()) != 0) {
2649
2650                                         XMLNode *before;
2651                                         bool got_some;
2652
2653                                         before = &(playlist->get_state());
2654                                         got_some = false;
2655
2656                                         /* XXX need to consider musical time selections here at some point */
2657
2658                                         double speed = rtv->get_diskstream()->speed();
2659
2660
2661                                         for (list<AudioRange>::const_iterator t = ts.begin(); t != ts.end(); ++t) {
2662
2663                                                 sigc::connection c = rtv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
2664                                                 latest_regionviews.clear ();
2665
2666                                                 playlist->partition ((nframes_t)((*t).start * speed), (nframes_t)((*t).end * speed), true);
2667
2668                                                 c.disconnect ();
2669
2670                                                 if (!latest_regionviews.empty()) {
2671
2672                                                         got_some = true;
2673
2674                                                         rtv->view()->foreach_regionview (bind (sigc::ptr_fun (add_if_covered), &(*t), &new_selection));
2675
2676                                                         if (!in_command) {
2677                                                                 begin_reversible_command (_("separate"));
2678                                                                 in_command = true;
2679                                                         }
2680
2681                                                         session->add_command(new MementoCommand<Playlist>(*playlist, before, &playlist->get_state()));
2682
2683                                                 }
2684                                         }
2685
2686                                         if (!got_some) {
2687                                                 delete before;
2688                                         }
2689                                 }
2690                         }
2691                 }
2692         }
2693
2694         if (in_command) {
2695                 selection->set (new_selection);
2696                 set_mouse_mode (MouseObject);
2697
2698                 commit_reversible_command ();
2699         }
2700 }
2701
2702 void
2703 Editor::separate_region_from_selection ()
2704 {
2705         /* preferentially use *all* ranges in the time selection if we're in range mode
2706            to allow discontiguous operation, since get_edit_op_range() currently
2707            returns a single range.
2708         */
2709         if (mouse_mode == MouseRange && !selection->time.empty()) {
2710
2711                 separate_regions_between (selection->time);
2712
2713         } else {
2714
2715                 nframes64_t start;
2716                 nframes64_t end;
2717
2718                 if (get_edit_op_range (start, end)) {
2719
2720                         AudioRange ar (start, end, 1);
2721                         TimeSelection ts;
2722                         ts.push_back (ar);
2723
2724                         /* force track selection */
2725
2726                         ensure_entered_region_selected ();
2727
2728                         separate_regions_between (ts);
2729                 }
2730         }
2731 }
2732
2733 void
2734 Editor::separate_regions_using_location (Location& loc)
2735 {
2736         if (loc.is_mark()) {
2737                 return;
2738         }
2739
2740         AudioRange ar (loc.start(), loc.end(), 1);
2741         TimeSelection ts;
2742
2743         ts.push_back (ar);
2744
2745         separate_regions_between (ts);
2746 }
2747
2748 void
2749 Editor::crop_region_to_selection ()
2750 {
2751         ensure_entered_region_selected (true);
2752
2753         if (!selection->time.empty()) {
2754
2755                 crop_region_to (selection->time.start(), selection->time.end_frame());
2756
2757         } else {
2758
2759                 nframes64_t start;
2760                 nframes64_t end;
2761
2762                 if (get_edit_op_range (start, end)) {
2763                         crop_region_to (start, end);
2764                 }
2765         }
2766
2767 }
2768
2769 void
2770 Editor::crop_region_to (nframes_t start, nframes_t end)
2771 {
2772         vector<boost::shared_ptr<Playlist> > playlists;
2773         boost::shared_ptr<Playlist> playlist;
2774         TrackSelection* ts;
2775
2776         if (selection->tracks.empty()) {
2777                 ts = &track_views;
2778         } else {
2779                 sort_track_selection ();
2780                 ts = &selection->tracks;
2781         }
2782
2783         for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
2784
2785                 RouteTimeAxisView* rtv;
2786
2787                 if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
2788
2789                         boost::shared_ptr<Track> t = rtv->track();
2790
2791                         if (t != 0 && ! t->diskstream()->destructive()) {
2792
2793                                 if ((playlist = rtv->playlist()) != 0) {
2794                                         playlists.push_back (playlist);
2795                                 }
2796                         }
2797                 }
2798         }
2799
2800         if (playlists.empty()) {
2801                 return;
2802         }
2803
2804         nframes_t the_start;
2805         nframes_t the_end;
2806         nframes_t cnt;
2807
2808         begin_reversible_command (_("trim to selection"));
2809
2810         for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
2811
2812                 boost::shared_ptr<Region> region;
2813
2814                 the_start = start;
2815
2816                 if ((region = (*i)->top_region_at(the_start)) == 0) {
2817                         continue;
2818                 }
2819
2820                 /* now adjust lengths to that we do the right thing
2821                    if the selection extends beyond the region
2822                 */
2823
2824                 the_start = max (the_start, region->position());
2825                 if (max_frames - the_start < region->length()) {
2826                         the_end = the_start + region->length() - 1;
2827                 } else {
2828                         the_end = max_frames;
2829                 }
2830                 the_end = min (end, the_end);
2831                 cnt = the_end - the_start + 1;
2832
2833                 XMLNode &before = (*i)->get_state();
2834                 region->trim_to (the_start, cnt, this);
2835                 XMLNode &after = (*i)->get_state();
2836                 session->add_command (new MementoCommand<Playlist>(*(*i), &before, &after));
2837         }
2838
2839         commit_reversible_command ();
2840 }
2841
2842 void
2843 Editor::region_fill_track ()
2844 {
2845         nframes_t end;
2846
2847         if (!session || selection->regions.empty()) {
2848                 return;
2849         }
2850
2851         end = session->current_end_frame ();
2852
2853         begin_reversible_command (_("region fill"));
2854
2855         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2856
2857                 boost::shared_ptr<Region> region ((*i)->region());
2858
2859                 // FIXME
2860                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(region);
2861                 assert(ar);
2862
2863                 boost::shared_ptr<Playlist> pl = region->playlist();
2864
2865                 if (end <= region->last_frame()) {
2866                         return;
2867                 }
2868
2869                 double times = (double) (end - region->last_frame()) / (double) region->length();
2870
2871                 if (times == 0) {
2872                         return;
2873                 }
2874
2875                 XMLNode &before = pl->get_state();
2876                 pl->add_region (RegionFactory::create (ar), ar->last_frame(), times);
2877                 session->add_command (new MementoCommand<Playlist>(*pl, &before, &pl->get_state()));
2878         }
2879
2880         commit_reversible_command ();
2881 }
2882
2883 void
2884 Editor::region_fill_selection ()
2885 {
2886         if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
2887                 return;
2888         }
2889
2890         if (selection->time.empty()) {
2891                 return;
2892         }
2893
2894
2895         Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
2896
2897         if (selected->count_selected_rows() != 1) {
2898                 return;
2899         }
2900
2901         TreeModel::iterator i = region_list_display.get_selection()->get_selected();
2902         boost::shared_ptr<Region> region = (*i)[region_list_columns.region];
2903
2904         nframes_t start = selection->time[clicked_selection].start;
2905         nframes_t end = selection->time[clicked_selection].end;
2906
2907         boost::shared_ptr<Playlist> playlist;
2908
2909         if (selection->tracks.empty()) {
2910                 return;
2911         }
2912
2913         nframes_t selection_length = end - start;
2914         float times = (float)selection_length / region->length();
2915
2916         begin_reversible_command (_("fill selection"));
2917
2918         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2919
2920                 if ((playlist = (*i)->playlist()) == 0) {
2921                         continue;
2922                 }
2923
2924                 XMLNode &before = playlist->get_state();
2925                 playlist->add_region (RegionFactory::create (region), start, times);
2926                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
2927         }
2928
2929         commit_reversible_command ();
2930 }
2931
2932 void
2933 Editor::set_region_sync_from_edit_point ()
2934 {
2935         nframes64_t where = get_preferred_edit_position ();
2936         ensure_entered_region_selected (true);
2937         set_sync_point (where, selection->regions);
2938 }
2939
2940 void
2941 Editor::set_sync_point (nframes64_t where, const RegionSelection& rs)
2942 {
2943         bool in_command = false;
2944
2945         for (RegionSelection::const_iterator r = rs.begin(); r != rs.end(); ++r) {
2946
2947                 if (!(*r)->region()->covers (where)) {
2948                         continue;
2949                 }
2950
2951                 boost::shared_ptr<Region> region ((*r)->region());
2952
2953                 if (!in_command) {
2954                         begin_reversible_command (_("set sync point"));
2955                         in_command = true;
2956                 }
2957
2958                 XMLNode &before = region->playlist()->get_state();
2959                 region->set_sync_position (get_preferred_edit_position());
2960                 XMLNode &after = region->playlist()->get_state();
2961                 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2962         }
2963
2964         if (in_command) {
2965                 commit_reversible_command ();
2966         }
2967 }
2968
2969 /** Remove the sync positions of the selection */
2970 void
2971 Editor::remove_region_sync ()
2972 {
2973         begin_reversible_command (_("remove sync"));
2974
2975         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2976                 boost::shared_ptr<Region> r = (*i)->region();
2977                 XMLNode &before = r->playlist()->get_state();
2978                 r->clear_sync_position ();
2979                 XMLNode &after = r->playlist()->get_state();
2980                 session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
2981         }
2982
2983         commit_reversible_command ();
2984 }
2985
2986 void
2987 Editor::naturalize ()
2988 {
2989         if (selection->regions.empty()) {
2990                 return;
2991         }
2992         begin_reversible_command (_("naturalize"));
2993         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2994                 XMLNode &before = (*i)->region()->get_state();
2995                 (*i)->region()->move_to_natural_position (this);
2996                 XMLNode &after = (*i)->region()->get_state();
2997                 session->add_command (new MementoCommand<Region>(*((*i)->region().get()), &before, &after));
2998         }
2999         commit_reversible_command ();
3000 }
3001
3002 void
3003 Editor::align (RegionPoint what)
3004 {
3005         ensure_entered_region_selected ();
3006
3007         nframes64_t where = get_preferred_edit_position();
3008
3009         if (!selection->regions.empty()) {
3010                 align_selection (what, where, selection->regions);
3011         } else {
3012
3013                 RegionSelection rs;
3014                 rs = get_regions_at (where, selection->tracks);
3015                 align_selection (what, where, rs);
3016         }
3017 }
3018
3019 void
3020 Editor::align_relative (RegionPoint what)
3021 {
3022         nframes64_t where = get_preferred_edit_position();
3023
3024         if (!selection->regions.empty()) {
3025                 align_selection_relative (what, where, selection->regions);
3026         } else {
3027
3028                 RegionSelection rs;
3029                 rs = get_regions_at (where, selection->tracks);
3030                 align_selection_relative (what, where, rs);
3031         }
3032 }
3033
3034 struct RegionSortByTime {
3035     bool operator() (const RegionView* a, const RegionView* b) {
3036             return a->region()->position() < b->region()->position();
3037     }
3038 };
3039
3040 void
3041 Editor::align_selection_relative (RegionPoint point, nframes_t position, const RegionSelection& rs)
3042 {
3043         if (rs.empty()) {
3044                 return;
3045         }
3046
3047         nframes_t distance = 0;
3048         nframes_t pos = 0;
3049         int dir = 0;
3050
3051         list<RegionView*> sorted;
3052         rs.by_position (sorted);
3053         boost::shared_ptr<Region> r ((*sorted.begin())->region());
3054
3055         switch (point) {
3056         case Start:
3057                 pos = position;
3058                 if (position > r->position()) {
3059                         distance = position - r->position();
3060                         dir = 1;
3061                 } else {
3062                         distance = r->position() - position;
3063                         dir = -1;
3064                 }
3065                 break;
3066
3067         case End:
3068                 if (position > r->last_frame()) {
3069                         distance = position - r->last_frame();
3070                         pos = r->position() + distance;
3071                         dir = 1;
3072                 } else {
3073                         distance = r->last_frame() - position;
3074                         pos = r->position() - distance;
3075                         dir = -1;
3076                 }
3077                 break;
3078
3079         case SyncPoint:
3080                 pos = r->adjust_to_sync (position);
3081                 if (pos > r->position()) {
3082                         distance = pos - r->position();
3083                         dir = 1;
3084                 } else {
3085                         distance = r->position() - pos;
3086                         dir = -1;
3087                 }
3088                 break;
3089         }
3090
3091         if (pos == r->position()) {
3092                 return;
3093         }
3094
3095         begin_reversible_command (_("align selection (relative)"));
3096
3097         /* move first one specially */
3098
3099         XMLNode &before = r->playlist()->get_state();
3100         r->set_position (pos, this);
3101         XMLNode &after = r->playlist()->get_state();
3102         session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
3103
3104         /* move rest by the same amount */
3105
3106         RegionSelection::const_iterator i = rs.begin();
3107         ++i;
3108
3109         for (; i != rs.end(); ++i) {
3110
3111                 boost::shared_ptr<Region> region ((*i)->region());
3112
3113                 XMLNode &before = region->playlist()->get_state();
3114
3115                 if (dir > 0) {
3116                         region->set_position (region->position() + distance, this);
3117                 } else {
3118                         region->set_position (region->position() - distance, this);
3119                 }
3120
3121                 XMLNode &after = region->playlist()->get_state();
3122                 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
3123
3124         }
3125
3126         commit_reversible_command ();
3127 }
3128
3129 void
3130 Editor::align_selection (RegionPoint point, nframes_t position, const RegionSelection& rs)
3131 {
3132         if (rs.empty()) {
3133                 return;
3134         }
3135
3136         begin_reversible_command (_("align selection"));
3137
3138         for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
3139                 align_region_internal ((*i)->region(), point, position);
3140         }
3141
3142         commit_reversible_command ();
3143 }
3144
3145 void
3146 Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
3147 {
3148         begin_reversible_command (_("align region"));
3149         align_region_internal (region, point, position);
3150         commit_reversible_command ();
3151 }
3152
3153 void
3154 Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
3155 {
3156         XMLNode &before = region->playlist()->get_state();
3157
3158         switch (point) {
3159         case SyncPoint:
3160                 region->set_position (region->adjust_to_sync (position), this);
3161                 break;
3162
3163         case End:
3164                 if (position > region->length()) {
3165                         region->set_position (position - region->length(), this);
3166                 }
3167                 break;
3168
3169         case Start:
3170                 region->set_position (position, this);
3171                 break;
3172         }
3173
3174         XMLNode &after = region->playlist()->get_state();
3175         session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
3176 }
3177
3178 /** Trim the end of the selected regions to the position of the edit cursor */
3179 void
3180 Editor::trim_region_to_loop ()
3181 {
3182         Location* loc = session->locations()->auto_loop_location();
3183         if (!loc) {
3184                 return;
3185         }
3186         trim_region_to_location (*loc, _("trim to loop"));
3187 }
3188
3189 void
3190 Editor::trim_region_to_punch ()
3191 {
3192         Location* loc = session->locations()->auto_punch_location();
3193         if (!loc) {
3194                 return;
3195         }
3196         trim_region_to_location (*loc, _("trim to punch"));
3197 }
3198 void
3199 Editor::trim_region_to_location (const Location& loc, const char* str)
3200 {
3201         ExclusiveRegionSelection ers (*this, entered_regionview);
3202
3203         RegionSelection& rs (get_regions_for_action ());
3204
3205         begin_reversible_command (str);
3206
3207         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3208                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3209
3210                 if (!arv) {
3211                         continue;
3212                 }
3213
3214                 /* require region to span proposed trim */
3215
3216                 switch (arv->region()->coverage (loc.start(), loc.end())) {
3217                 case OverlapInternal:
3218                         break;
3219                 default:
3220                         continue;
3221                 }
3222
3223                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3224
3225                 if (!atav) {
3226                         return;
3227                 }
3228
3229                 float speed = 1.0;
3230                 nframes_t start;
3231                 nframes_t end;
3232
3233                 if (atav->get_diskstream() != 0) {
3234                         speed = atav->get_diskstream()->speed();
3235                 }
3236
3237                 start = session_frame_to_track_frame (loc.start(), speed);
3238                 end = session_frame_to_track_frame (loc.end(), speed);
3239
3240                 XMLNode &before = arv->region()->playlist()->get_state();
3241                 arv->region()->trim_to (start, (end - start), this);
3242                 XMLNode &after = arv->region()->playlist()->get_state();
3243                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3244         }
3245
3246         commit_reversible_command ();
3247 }
3248
3249 void
3250 Editor::trim_region_to_edit_point ()
3251 {
3252         ExclusiveRegionSelection ers (*this, entered_regionview);
3253
3254         RegionSelection& rs (get_regions_for_action ());
3255         nframes64_t where = get_preferred_edit_position();
3256
3257         begin_reversible_command (_("trim region start to edit point"));
3258
3259         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3260                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3261
3262                 if (!arv) {
3263                         continue;
3264                 }
3265
3266                 /* require region to cover trim */
3267
3268                 if (!arv->region()->covers (where)) {
3269                         continue;
3270                 }
3271
3272                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3273
3274                 if (!atav) {
3275                         return;
3276                 }
3277
3278                 float speed = 1.0;
3279
3280                 if (atav->get_diskstream() != 0) {
3281                         speed = atav->get_diskstream()->speed();
3282                 }
3283
3284                 XMLNode &before = arv->region()->playlist()->get_state();
3285                 arv->region()->trim_end( session_frame_to_track_frame(where, speed), this);
3286                 XMLNode &after = arv->region()->playlist()->get_state();
3287                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3288         }
3289
3290         commit_reversible_command ();
3291 }
3292
3293 void
3294 Editor::trim_region_from_edit_point ()
3295 {
3296         ExclusiveRegionSelection ers (*this, entered_regionview);
3297
3298         RegionSelection& rs (get_regions_for_action ());
3299         nframes64_t where = get_preferred_edit_position();
3300
3301         begin_reversible_command (_("trim region end to edit point"));
3302
3303         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3304                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3305
3306                 if (!arv) {
3307                         continue;
3308                 }
3309
3310                 /* require region to cover trim */
3311
3312                 if (!arv->region()->covers (where)) {
3313                         continue;
3314                 }
3315
3316                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3317
3318                 if (!atav) {
3319                         return;
3320                 }
3321
3322                 float speed = 1.0;
3323
3324                 if (atav->get_diskstream() != 0) {
3325                         speed = atav->get_diskstream()->speed();
3326                 }
3327
3328                 XMLNode &before = arv->region()->playlist()->get_state();
3329                 arv->region()->trim_front ( session_frame_to_track_frame(where, speed), this);
3330                 XMLNode &after = arv->region()->playlist()->get_state();
3331                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3332         }
3333
3334         commit_reversible_command ();
3335 }
3336
3337 void
3338 Editor::unfreeze_route ()
3339 {
3340         if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
3341                 return;
3342         }
3343
3344         clicked_routeview->audio_track()->unfreeze ();
3345 }
3346
3347 void*
3348 Editor::_freeze_thread (void* arg)
3349 {
3350         PBD::ThreadCreated (pthread_self(), X_("Freeze"));
3351         return static_cast<Editor*>(arg)->freeze_thread ();
3352 }
3353
3354 void*
3355 Editor::freeze_thread ()
3356 {
3357         clicked_routeview->audio_track()->freeze (*current_interthread_info);
3358         return 0;
3359 }
3360
3361 gint
3362 Editor::freeze_progress_timeout (void *arg)
3363 {
3364         interthread_progress_bar.set_fraction (current_interthread_info->progress/100);
3365         return !(current_interthread_info->done || current_interthread_info->cancel);
3366 }
3367
3368 void
3369 Editor::freeze_route ()
3370 {
3371         if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
3372                 return;
3373         }
3374
3375         InterThreadInfo itt;
3376
3377         if (interthread_progress_window == 0) {
3378                 build_interthread_progress_window ();
3379         }
3380
3381         WindowTitle title(Glib::get_application_name());
3382         title += _("Freeze");
3383         interthread_progress_window->set_title (title.get_string());
3384         interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
3385         interthread_progress_window->show_all ();
3386         interthread_progress_bar.set_fraction (0.0f);
3387         interthread_progress_label.set_text ("");
3388         interthread_cancel_label.set_text (_("Cancel Freeze"));
3389         current_interthread_info = &itt;
3390
3391         interthread_progress_connection =
3392           Glib::signal_timeout().connect (bind (mem_fun(*this, &Editor::freeze_progress_timeout), (gpointer) 0), 100);
3393
3394         itt.done = false;
3395         itt.cancel = false;
3396         itt.progress = 0.0f;
3397
3398         pthread_attr_t attr;
3399         pthread_attr_init(&attr);
3400         pthread_attr_setstacksize(&attr, 500000);
3401
3402         pthread_create (&itt.thread, &attr, _freeze_thread, this);
3403
3404         pthread_attr_destroy(&attr);
3405
3406         track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
3407
3408         while (!itt.done && !itt.cancel) {
3409                 gtk_main_iteration ();
3410         }
3411
3412         interthread_progress_connection.disconnect ();
3413         interthread_progress_window->hide_all ();
3414         current_interthread_info = 0;
3415         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3416 }
3417
3418 void
3419 Editor::bounce_range_selection ()
3420 {
3421         if (selection->time.empty()) {
3422                 return;
3423         }
3424
3425         TrackSelection views = selection->tracks;
3426
3427         nframes_t start = selection->time[clicked_selection].start;
3428         nframes_t end = selection->time[clicked_selection].end;
3429         nframes_t cnt = end - start + 1;
3430
3431         begin_reversible_command (_("bounce range"));
3432
3433         for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
3434
3435                 RouteTimeAxisView* rtv;
3436
3437                 if ((rtv = dynamic_cast<RouteTimeAxisView*> (*i)) == 0) {
3438                         continue;
3439                 }
3440
3441                 boost::shared_ptr<Playlist> playlist;
3442
3443                 if ((playlist = rtv->playlist()) == 0) {
3444                         return;
3445                 }
3446
3447                 InterThreadInfo itt;
3448
3449                 itt.done = false;
3450                 itt.cancel = false;
3451                 itt.progress = false;
3452
3453                 XMLNode &before = playlist->get_state();
3454                 rtv->track()->bounce_range (start, cnt, itt);
3455                 XMLNode &after = playlist->get_state();
3456                 session->add_command (new MementoCommand<Playlist> (*playlist, &before, &after));
3457         }
3458
3459         commit_reversible_command ();
3460 }
3461
3462 /** Cut selected regions, automation points or a time range */
3463 void
3464 Editor::cut ()
3465 {
3466         cut_copy (Cut);
3467 }
3468
3469 /** Copy selected regions, automation points or a time range */
3470 void
3471 Editor::copy ()
3472 {
3473         cut_copy (Copy);
3474 }
3475
3476
3477 /** @return true if a Cut, Copy or Clear is possible */
3478 bool
3479 Editor::can_cut_copy () const
3480 {
3481         switch (current_mouse_mode()) {
3482
3483         case MouseObject:
3484                 if (!selection->regions.empty() || !selection->points.empty()) {
3485                         return true;
3486                 }
3487                 break;
3488
3489         case MouseRange:
3490                 if (!selection->time.empty()) {
3491                         return true;
3492                 }
3493                 break;
3494
3495         default:
3496                 break;
3497         }
3498
3499         return false;
3500 }
3501
3502
3503 /** Cut, copy or clear selected regions, automation points or a time range.
3504  * @param op Operation (Cut, Copy or Clear)
3505  */
3506 void
3507 Editor::cut_copy (CutCopyOp op)
3508 {
3509         /* only cancel selection if cut/copy is successful.*/
3510
3511         string opname;
3512
3513         switch (op) {
3514         case Cut:
3515                 opname = _("cut");
3516                 break;
3517         case Copy:
3518                 opname = _("copy");
3519                 break;
3520         case Clear:
3521                 opname = _("clear");
3522                 break;
3523         }
3524
3525         cut_buffer->clear ();
3526
3527         if (entered_marker) {
3528
3529                 /* cut/delete op while pointing at a marker */
3530
3531                 bool ignored;
3532                 Location* loc = find_location_from_marker (entered_marker, ignored);
3533
3534                 if (session && loc) {
3535                         Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::really_remove_marker), loc));
3536                 }
3537
3538                 return;
3539         }
3540
3541         switch (current_mouse_mode()) {
3542         case MouseObject:
3543                 if (!selection->regions.empty() || !selection->points.empty()) {
3544
3545                         begin_reversible_command (opname + _(" objects"));
3546
3547                         if (!selection->regions.empty()) {
3548                                 cut_copy_regions (op);
3549
3550                                 if (op == Cut) {
3551                                         selection->clear_regions ();
3552                                 }
3553                         }
3554
3555                         if (!selection->points.empty()) {
3556                                 cut_copy_points (op);
3557
3558                                 if (op == Cut) {
3559                                         selection->clear_points ();
3560                                 }
3561                         }
3562
3563                         commit_reversible_command ();
3564                         break; // terminate case statement here
3565                 }
3566                 if (!selection->time.empty()) {
3567                         /* don't cause suprises */
3568                         break;
3569                 }
3570                 // fall thru if there was nothing selected
3571
3572         case MouseRange:
3573                 if (selection->time.empty()) {
3574                         nframes64_t start, end;
3575                         if (!get_edit_op_range (start, end)) {
3576                                 return;
3577                         }
3578                         selection->set ((TimeAxisView*) 0, start, end);
3579                 }
3580
3581                 begin_reversible_command (opname + _(" range"));
3582                 cut_copy_ranges (op);
3583                 commit_reversible_command ();
3584
3585                 if (op == Cut) {
3586                         selection->clear_time ();
3587                 }
3588
3589                 break;
3590
3591         default:
3592                 break;
3593         }
3594 }
3595
3596 /** Cut, copy or clear selected automation points.
3597  * @param op Operation (Cut, Copy or Clear)
3598  */
3599 void
3600 Editor::cut_copy_points (CutCopyOp op)
3601 {
3602         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3603
3604                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
3605
3606                 if (atv) {
3607                         atv->cut_copy_clear_objects (selection->points, op);
3608                 }
3609         }
3610 }
3611
3612 struct PlaylistState {
3613     boost::shared_ptr<Playlist> playlist;
3614     XMLNode*  before;
3615 };
3616
3617 struct lt_playlist {
3618     bool operator () (const PlaylistState& a, const PlaylistState& b) {
3619             return a.playlist < b.playlist;
3620     }
3621 };
3622
3623 struct PlaylistMapping {
3624     TimeAxisView* tv;
3625     boost::shared_ptr<Playlist> pl;
3626
3627     PlaylistMapping (TimeAxisView* tvp) : tv (tvp) {}
3628 };
3629
3630
3631 /** Cut, copy or clear selected regions.
3632  * @param op Operation (Cut, Copy or Clear)
3633  */
3634 void
3635 Editor::cut_copy_regions (CutCopyOp op)
3636 {
3637         /* we can't use a std::map here because the ordering is important, and we can't trivially sort
3638            a map when we want ordered access to both elements. i think.
3639         */
3640
3641         vector<PlaylistMapping> pmap;
3642
3643         nframes_t first_position = max_frames;
3644
3645         set<PlaylistState, lt_playlist> freezelist;
3646         pair<set<PlaylistState, lt_playlist>::iterator,bool> insert_result;
3647
3648         /* get ordering correct before we cut/copy */
3649
3650         selection->regions.sort_by_position_and_track ();
3651
3652         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
3653
3654                 first_position = min ((*x)->region()->position(), first_position);
3655
3656                 if (op == Cut || op == Clear) {
3657                         boost::shared_ptr<Playlist> pl = (*x)->region()->playlist();
3658
3659                         if (pl) {
3660
3661                                 PlaylistState before;
3662                                 before.playlist = pl;
3663                                 before.before = &pl->get_state();
3664
3665                                 insert_result = freezelist.insert (before);
3666
3667                                 if (insert_result.second) {
3668                                         pl->freeze ();
3669                                 }
3670                         }
3671                 }
3672
3673                 TimeAxisView* tv = &(*x)->get_trackview();
3674                 vector<PlaylistMapping>::iterator z;
3675
3676                 for (z = pmap.begin(); z != pmap.end(); ++z) {
3677                         if ((*z).tv == tv) {
3678                                 break;
3679                         }
3680                 }
3681
3682                 if (z == pmap.end()) {
3683                         pmap.push_back (PlaylistMapping (tv));
3684                 }
3685         }
3686
3687         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ) {
3688
3689                 boost::shared_ptr<Playlist> pl = (*x)->region()->playlist();
3690
3691                 if (!pl) {
3692                         /* impossible, but this handles it for the future */
3693                         continue;
3694                 }
3695
3696                 TimeAxisView& tv = (*x)->get_trackview();
3697                 boost::shared_ptr<Playlist> npl;
3698                 RegionSelection::iterator tmp;
3699
3700                 tmp = x;
3701                 ++tmp;
3702
3703                 vector<PlaylistMapping>::iterator z;
3704
3705                 for (z = pmap.begin(); z != pmap.end(); ++z) {
3706                         if ((*z).tv == &tv) {
3707                                 break;
3708                         }
3709                 }
3710
3711                 assert (z != pmap.end());
3712
3713                 if (!(*z).pl) {
3714                         npl = PlaylistFactory::create (pl->data_type(), *session, "cutlist", true);
3715                         npl->freeze();
3716                         (*z).pl = npl;
3717                 } else {
3718                         npl = (*z).pl;
3719                 }
3720
3721                 boost::shared_ptr<Region> r = (*x)->region();
3722                 boost::shared_ptr<Region> _xx;
3723
3724                 assert (r != 0);
3725
3726                 switch (op) {
3727                 case Cut:
3728                         _xx = RegionFactory::create (r);
3729                         npl->add_region (_xx, r->position() - first_position);
3730                         pl->remove_region (r);
3731                         break;
3732
3733                 case Copy:
3734                         /* copy region before adding, so we're not putting same object into two different playlists */
3735                         npl->add_region (RegionFactory::create (r), r->position() - first_position);
3736                         break;
3737
3738                 case Clear:
3739                         pl->remove_region (r);
3740                         break;
3741                 }
3742
3743                 x = tmp;
3744         }
3745
3746         list<boost::shared_ptr<Playlist> > foo;
3747
3748         /* the pmap is in the same order as the tracks in which selected regions occured */
3749
3750         for (vector<PlaylistMapping>::iterator i = pmap.begin(); i != pmap.end(); ++i) {
3751                 (*i).pl->thaw();
3752                 foo.push_back ((*i).pl);
3753         }
3754
3755
3756         if (!foo.empty()) {
3757                 cut_buffer->set (foo);
3758         }
3759
3760         for (set<PlaylistState, lt_playlist>::iterator pl = freezelist.begin(); pl != freezelist.end(); ++pl) {
3761                 (*pl).playlist->thaw ();
3762                 session->add_command (new MementoCommand<Playlist>(*(*pl).playlist, (*pl).before, &(*pl).playlist->get_state()));
3763         }
3764 }
3765
3766 void
3767 Editor::cut_copy_ranges (CutCopyOp op)
3768 {
3769         TrackSelection* ts;
3770
3771         if (selection->tracks.empty()) {
3772                 ts = &track_views;
3773         } else {
3774                 ts = &selection->tracks;
3775         }
3776
3777         for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
3778                 (*i)->cut_copy_clear (*selection, op);
3779         }
3780 }
3781
3782 void
3783 Editor::paste (float times)
3784 {
3785         paste_internal (get_preferred_edit_position(), times);
3786 }
3787
3788 void
3789 Editor::mouse_paste ()
3790 {
3791         nframes64_t where;
3792         bool ignored;
3793
3794         if (!mouse_frame (where, ignored)) {
3795                 return;
3796         }
3797
3798         snap_to (where);
3799         paste_internal (where, 1);
3800 }
3801
3802 void
3803 Editor::paste_internal (nframes_t position, float times)
3804 {
3805         bool commit = false;
3806
3807         if (cut_buffer->empty()) {
3808                 return;
3809         }
3810
3811         if (position == max_frames) {
3812                 position = get_preferred_edit_position();
3813         }
3814
3815         begin_reversible_command (_("paste"));
3816
3817         TrackSelection ts;
3818         TrackSelection::iterator i;
3819         size_t nth;
3820
3821         /* get everything in the correct order */
3822
3823
3824         if (!selection->tracks.empty()) {
3825                 sort_track_selection ();
3826                 ts = selection->tracks;
3827         } else if (entered_track) {
3828                 ts.push_back (entered_track);
3829         }
3830
3831         for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
3832
3833                 /* undo/redo is handled by individual tracks */
3834
3835                 if ((*i)->paste (position, times, *cut_buffer, nth)) {
3836                         commit = true;
3837                 }
3838         }
3839
3840         if (commit) {
3841                 commit_reversible_command ();
3842         }
3843 }
3844
3845 void
3846 Editor::paste_named_selection (float times)
3847 {
3848         TrackSelection::iterator t;
3849
3850         Glib::RefPtr<TreeSelection> selected = named_selection_display.get_selection();
3851
3852         if (selected->count_selected_rows() != 1 || selection->tracks.empty()) {
3853                 return;
3854         }
3855
3856         TreeModel::iterator i = selected->get_selected();
3857         NamedSelection* ns = (*i)[named_selection_columns.selection];
3858
3859         list<boost::shared_ptr<Playlist> >::iterator chunk;
3860         list<boost::shared_ptr<Playlist> >::iterator tmp;
3861
3862         chunk = ns->playlists.begin();
3863
3864         begin_reversible_command (_("paste chunk"));
3865
3866         sort_track_selection ();
3867
3868         for (t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
3869
3870                 RouteTimeAxisView* rtv;
3871                 boost::shared_ptr<Playlist> pl;
3872                 boost::shared_ptr<AudioPlaylist> apl;
3873
3874                 if ((rtv = dynamic_cast<RouteTimeAxisView*> (*t)) == 0) {
3875                         continue;
3876                 }
3877
3878                 if ((pl = rtv->playlist()) == 0) {
3879                         continue;
3880                 }
3881
3882                 if ((apl = boost::dynamic_pointer_cast<AudioPlaylist> (pl)) == 0) {
3883                         continue;
3884                 }
3885
3886                 tmp = chunk;
3887                 ++tmp;
3888
3889                 XMLNode &before = apl->get_state();
3890                 apl->paste (*chunk, get_preferred_edit_position(), times);
3891                 session->add_command(new MementoCommand<AudioPlaylist>(*apl, &before, &apl->get_state()));
3892
3893                 if (tmp != ns->playlists.end()) {
3894                         chunk = tmp;
3895                 }
3896         }
3897
3898         commit_reversible_command();
3899 }
3900
3901 void
3902 Editor::duplicate_some_regions (RegionSelection& regions, float times)
3903 {
3904         boost::shared_ptr<Playlist> playlist;
3905         RegionSelection sel = regions; // clear (below) may  clear the argument list if its the current region selection
3906         RegionSelection foo;
3907
3908         begin_reversible_command (_("duplicate region"));
3909
3910         selection->clear_regions ();
3911
3912         for (RegionSelection::iterator i = sel.begin(); i != sel.end(); ++i) {
3913
3914                 boost::shared_ptr<Region> r ((*i)->region());
3915
3916                 TimeAxisView& tv = (*i)->get_time_axis_view();
3917                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&tv);
3918                 latest_regionviews.clear ();
3919                 sigc::connection c = rtv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
3920
3921                 playlist = (*i)->region()->playlist();
3922                 XMLNode &before = playlist->get_state();
3923                 playlist->duplicate (r, r->last_frame(), times);
3924                 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
3925
3926                 c.disconnect ();
3927
3928                 foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
3929         }
3930
3931         commit_reversible_command ();
3932
3933         if (!foo.empty()) {
3934                 selection->set (foo);
3935         }
3936 }
3937
3938 void
3939 Editor::duplicate_selection (float times)
3940 {
3941         if (selection->time.empty() || selection->tracks.empty()) {
3942                 return;
3943         }
3944
3945         boost::shared_ptr<Playlist> playlist;
3946         vector<boost::shared_ptr<AudioRegion> > new_regions;
3947         vector<boost::shared_ptr<AudioRegion> >::iterator ri;
3948
3949         create_region_from_selection (new_regions);
3950
3951         if (new_regions.empty()) {
3952                 return;
3953         }
3954
3955         begin_reversible_command (_("duplicate selection"));
3956
3957         ri = new_regions.begin();
3958
3959         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3960                 if ((playlist = (*i)->playlist()) == 0) {
3961                         continue;
3962                 }
3963                 XMLNode &before = playlist->get_state();
3964                 playlist->duplicate (*ri, selection->time[clicked_selection].end, times);
3965                 XMLNode &after = playlist->get_state();
3966                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
3967
3968                 ++ri;
3969                 if (ri == new_regions.end()) {
3970                         --ri;
3971                 }
3972         }
3973
3974         commit_reversible_command ();
3975 }
3976
3977 void
3978 Editor::reset_point_selection ()
3979 {
3980         /* reset all selected points to the relevant default value */
3981
3982         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3983
3984                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
3985
3986                 if (atv) {
3987                         atv->reset_objects (selection->points);
3988                 }
3989         }
3990 }
3991
3992 void
3993 Editor::center_playhead ()
3994 {
3995         float page = canvas_width * frames_per_unit;
3996         center_screen_internal (playhead_cursor->current_frame, page);
3997 }
3998
3999 void
4000 Editor::center_edit_point ()
4001 {
4002         float page = canvas_width * frames_per_unit;
4003         center_screen_internal (get_preferred_edit_position(), page);
4004 }
4005
4006 void
4007 Editor::clear_playlist (boost::shared_ptr<Playlist> playlist)
4008 {
4009         begin_reversible_command (_("clear playlist"));
4010         XMLNode &before = playlist->get_state();
4011         playlist->clear ();
4012         XMLNode &after = playlist->get_state();
4013         session->add_command (new MementoCommand<Playlist>(*playlist.get(), &before, &after));
4014         commit_reversible_command ();
4015 }
4016
4017 void
4018 Editor::nudge_track (bool use_edit, bool forwards)
4019 {
4020         boost::shared_ptr<Playlist> playlist;
4021         nframes_t distance;
4022         nframes_t next_distance;
4023         nframes_t start;
4024
4025         if (use_edit) {
4026                 start = get_preferred_edit_position();
4027         } else {
4028                 start = 0;
4029         }
4030
4031         if ((distance = get_nudge_distance (start, next_distance)) == 0) {
4032                 return;
4033         }
4034
4035         if (selection->tracks.empty()) {
4036                 return;
4037         }
4038
4039         begin_reversible_command (_("nudge track"));
4040
4041         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
4042
4043                 if ((playlist = (*i)->playlist()) == 0) {
4044                         continue;
4045                 }
4046
4047                 XMLNode &before = playlist->get_state();
4048                 playlist->nudge_after (start, distance, forwards);
4049                 XMLNode &after = playlist->get_state();
4050                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
4051         }
4052
4053         commit_reversible_command ();
4054 }
4055
4056 void
4057 Editor::remove_last_capture ()
4058 {
4059         vector<string> choices;
4060         string prompt;
4061
4062         if (!session) {
4063                 return;
4064         }
4065
4066         if (Config->get_verify_remove_last_capture()) {
4067                 prompt  = _("Do you really want to destroy the last capture?"
4068                             "\n(This is destructive and cannot be undone)");
4069
4070                 choices.push_back (_("No, do nothing."));
4071                 choices.push_back (_("Yes, destroy it."));
4072
4073                 Gtkmm2ext::Choice prompter (prompt, choices);
4074
4075                 if (prompter.run () == 1) {
4076                         session->remove_last_capture ();
4077                 }
4078
4079         } else {
4080                 session->remove_last_capture();
4081         }
4082 }
4083
4084 void
4085 Editor::normalize_region ()
4086 {
4087         if (!session) {
4088                 return;
4089         }
4090
4091         if (selection->regions.empty()) {
4092                 return;
4093         }
4094
4095         begin_reversible_command (_("normalize"));
4096
4097         track_canvas.get_window()->set_cursor (*wait_cursor);
4098         gdk_flush ();
4099
4100         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
4101                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4102                 if (!arv)
4103                         continue;
4104                 XMLNode &before = arv->region()->get_state();
4105                 arv->audio_region()->normalize_to (0.0f);
4106                 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
4107         }
4108
4109         commit_reversible_command ();
4110         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
4111 }
4112
4113
4114 void
4115 Editor::denormalize_region ()
4116 {
4117         if (!session) {
4118                 return;
4119         }
4120
4121         ExclusiveRegionSelection (*this, entered_regionview);
4122
4123         if (selection->regions.empty()) {
4124                 return;
4125         }
4126
4127         begin_reversible_command ("denormalize");
4128
4129         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
4130                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4131                 if (!arv)
4132                         continue;
4133                 XMLNode &before = arv->region()->get_state();
4134                 arv->audio_region()->set_scale_amplitude (1.0f);
4135                 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
4136         }
4137
4138         commit_reversible_command ();
4139 }
4140
4141 void
4142 Editor::adjust_region_scale_amplitude (bool up)
4143 {
4144         if (!session) {
4145                 return;
4146         }
4147
4148         ExclusiveRegionSelection esr (*this, entered_regionview);
4149
4150         if (selection->regions.empty()) {
4151                 return;
4152         }
4153
4154         begin_reversible_command ("denormalize");
4155
4156         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
4157                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4158                 if (!arv)
4159                         continue;
4160                 XMLNode &before = arv->region()->get_state();
4161
4162                 double fraction = gain_to_slider_position (arv->audio_region()->scale_amplitude ());
4163
4164                 if (up) {
4165                         fraction += 0.05;
4166                         fraction = min (fraction, 1.0);
4167                 } else {
4168                         fraction -= 0.05;
4169                         fraction = max (fraction, 0.0);
4170                 }
4171
4172                 if (!up && fraction <= 0) {
4173                         continue;
4174                 }
4175
4176                 fraction = slider_position_to_gain (fraction);
4177                 fraction = coefficient_to_dB (fraction);
4178                 fraction = dB_to_coefficient (fraction);
4179
4180                 if (up && fraction >= 2.0) {
4181                         continue;
4182                 }
4183
4184                 arv->audio_region()->set_scale_amplitude (fraction);
4185                 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
4186         }
4187
4188         commit_reversible_command ();
4189 }
4190
4191
4192 void
4193 Editor::reverse_region ()
4194 {
4195         if (!session) {
4196                 return;
4197         }
4198
4199         Reverse rev (*session);
4200         apply_filter (rev, _("reverse regions"));
4201 }
4202
4203
4204 void
4205 Editor::quantize_region ()
4206 {
4207         if (!session) {
4208                 return;
4209         }
4210
4211         // FIXME: varying meter?
4212         Quantize quant (*session, snap_length_beats(0));
4213         apply_filter (quant, _("quantize regions"));
4214 }
4215
4216 void
4217 Editor::apply_filter (Filter& filter, string command)
4218 {
4219         if (selection->regions.empty()) {
4220                 return;
4221         }
4222
4223         begin_reversible_command (command);
4224
4225         track_canvas.get_window()->set_cursor (*wait_cursor);
4226         gdk_flush ();
4227
4228         /* this is ugly. */
4229         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ) {
4230                 RegionSelection::iterator tmp = r;
4231                 ++tmp;
4232
4233                 MidiRegionView* const mrv = dynamic_cast<MidiRegionView*>(*r);
4234                 if (mrv) {
4235                         if (mrv->midi_region()->apply(filter) == 0) {
4236                                 mrv->redisplay_model();
4237                         }
4238                 }
4239
4240                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
4241                 if (arv) {
4242                         boost::shared_ptr<Playlist> playlist = arv->region()->playlist();
4243
4244                         if (arv->audio_region()->apply (filter) == 0) {
4245
4246                                 XMLNode &before = playlist->get_state();
4247                                 playlist->replace_region (arv->region(), filter.results.front(), arv->region()->position());
4248                                 XMLNode &after = playlist->get_state();
4249                                 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
4250                         } else {
4251                                 goto out;
4252                         }
4253                 }
4254
4255                 r = tmp;
4256         }
4257
4258         commit_reversible_command ();
4259         selection->regions.clear ();
4260
4261   out:
4262         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
4263 }
4264
4265 void
4266 Editor::region_selection_op (void (Region::*pmf)(void))
4267 {
4268         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4269                 Region* region = (*i)->region().get();
4270                 (region->*pmf)();
4271         }
4272 }
4273
4274
4275 void
4276 Editor::region_selection_op (void (Region::*pmf)(void*), void *arg)
4277 {
4278         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4279                 Region* region = (*i)->region().get();
4280                 (region->*pmf)(arg);
4281         }
4282 }
4283
4284 void
4285 Editor::region_selection_op (void (Region::*pmf)(bool), bool yn)
4286 {
4287         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4288                 Region* region = (*i)->region().get();
4289                 (region->*pmf)(yn);
4290         }
4291 }
4292
4293 void
4294 Editor::external_edit_region ()
4295 {
4296         /* more to come */
4297 }
4298
4299 void
4300 Editor::brush (nframes_t pos)
4301 {
4302         RegionSelection sel;
4303         snap_to (pos);
4304
4305         if (selection->regions.empty()) {
4306                 /* XXX get selection from region list */
4307         } else {
4308                 sel = selection->regions;
4309         }
4310
4311         if (sel.empty()) {
4312                 return;
4313         }
4314
4315         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4316                 mouse_brush_insert_region ((*i), pos);
4317         }
4318 }
4319
4320 void
4321 Editor::reset_region_gain_envelopes ()
4322 {
4323         if (!session || selection->regions.empty()) {
4324                 return;
4325         }
4326
4327         session->begin_reversible_command (_("reset region gain"));
4328
4329         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4330                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4331                 if (arv) {
4332                         boost::shared_ptr<AutomationList> alist (arv->audio_region()->envelope());
4333                         XMLNode& before (alist->get_state());
4334
4335                         arv->audio_region()->set_default_envelope ();
4336                         session->add_command (new MementoCommand<AutomationList>(*arv->audio_region()->envelope().get(), &before, &alist->get_state()));
4337                 }
4338         }
4339
4340         session->commit_reversible_command ();
4341 }
4342
4343 void
4344 Editor::toggle_gain_envelope_visibility ()
4345 {
4346         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4347                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4348                 if (arv) {
4349                         arv->set_envelope_visible (!arv->envelope_visible());
4350                 }
4351         }
4352 }
4353
4354 void
4355 Editor::toggle_gain_envelope_active ()
4356 {
4357         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4358                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4359                 if (arv) {
4360                         arv->audio_region()->set_envelope_active (!arv->audio_region()->envelope_active());
4361                 }
4362         }
4363 }
4364
4365 void
4366 Editor::toggle_region_lock ()
4367 {
4368         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4369                 (*i)->region()->set_locked (!(*i)->region()->locked());
4370         }
4371 }
4372
4373 void
4374 Editor::set_region_lock_style (Region::PositionLockStyle ps)
4375 {
4376         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4377                 (*i)->region()->set_position_lock_style (ps);
4378         }
4379 }
4380
4381
4382 void
4383 Editor::toggle_region_mute ()
4384 {
4385         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4386                 (*i)->region()->set_muted (!(*i)->region()->muted());
4387         }
4388 }
4389
4390 void
4391 Editor::toggle_region_opaque ()
4392 {
4393         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4394                 (*i)->region()->set_opaque (!(*i)->region()->opaque());
4395         }
4396 }
4397
4398 void
4399 Editor::set_fade_length (bool in)
4400 {
4401         ExclusiveRegionSelection esr (*this, entered_regionview);
4402
4403         /* we need a region to measure the offset from the start */
4404
4405         RegionView* rv;
4406
4407         if (!selection->regions.empty()) {
4408                 rv = selection->regions.front();
4409         } else if (entered_regionview) {
4410                 rv = entered_regionview;
4411         } else {
4412                 return;
4413         }
4414
4415         nframes64_t pos = get_preferred_edit_position();
4416         nframes_t len;
4417         char* cmd;
4418
4419         if (pos > rv->region()->last_frame() || pos < rv->region()->first_frame()) {
4420                 /* edit point is outside the relevant region */
4421                 return;
4422         }
4423
4424         if (in) {
4425                 if (pos <= rv->region()->position()) {
4426                         /* can't do it */
4427                         return;
4428                 }
4429                 len = pos - rv->region()->position();
4430                 cmd = _("set fade in length");
4431         } else {
4432                 if (pos >= rv->region()->last_frame()) {
4433                         /* can't do it */
4434                         return;
4435                 }
4436                 len = rv->region()->last_frame() - pos;
4437                 cmd = _("set fade out length");
4438         }
4439
4440         begin_reversible_command (cmd);
4441
4442         RegionSelection& rs (get_regions_for_action());
4443
4444         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4445                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4446
4447                 if (!tmp) {
4448                         return;
4449                 }
4450
4451                 boost::shared_ptr<AutomationList> alist;
4452                 if (in) {
4453                         alist = tmp->audio_region()->fade_in();
4454                 } else {
4455                         alist = tmp->audio_region()->fade_out();
4456                 }
4457
4458                 XMLNode &before = alist->get_state();
4459
4460                 if (in) {
4461                         tmp->audio_region()->set_fade_in_length (len);
4462                 } else {
4463                         tmp->audio_region()->set_fade_out_length (len);
4464                 }
4465
4466                 XMLNode &after = alist->get_state();
4467                 session->add_command(new MementoCommand<AutomationList>(*alist, &before, &after));
4468         }
4469
4470         commit_reversible_command ();
4471 }
4472
4473 void
4474 Editor::toggle_fade_active (bool in)
4475 {
4476         ensure_entered_region_selected (true);
4477
4478         if (selection->regions.empty()) {
4479                 return;
4480         }
4481
4482         const char* cmd = (in ? _("toggle fade in active") : _("toggle fade out active"));
4483         bool have_switch = false;
4484         bool yn = false;
4485
4486         begin_reversible_command (cmd);
4487
4488         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4489                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4490
4491                 if (!tmp) {
4492                         return;
4493                 }
4494
4495                 boost::shared_ptr<AudioRegion> region (tmp->audio_region());
4496
4497                 /* make the behaviour consistent across all regions */
4498
4499                 if (!have_switch) {
4500                         if (in) {
4501                                 yn = region->fade_in_active();
4502                         } else {
4503                                 yn = region->fade_out_active();
4504                         }
4505                         have_switch = true;
4506                 }
4507
4508                 XMLNode &before = region->get_state();
4509                 if (in) {
4510                         region->set_fade_in_active (!yn);
4511                 } else {
4512                         region->set_fade_out_active (!yn);
4513                 }
4514                 XMLNode &after = region->get_state();
4515                 session->add_command(new MementoCommand<AudioRegion>(*region.get(), &before, &after));
4516         }
4517
4518         commit_reversible_command ();
4519 }
4520
4521 void
4522 Editor::set_fade_in_shape (AudioRegion::FadeShape shape)
4523 {
4524
4525         begin_reversible_command (_("set fade in shape"));
4526
4527         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4528                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4529
4530                 if (!tmp) {
4531                         return;
4532                 }
4533
4534                 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_in();
4535                 XMLNode &before = alist->get_state();
4536
4537                 tmp->audio_region()->set_fade_in_shape (shape);
4538
4539                 XMLNode &after = alist->get_state();
4540                 session->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
4541         }
4542
4543         commit_reversible_command ();
4544
4545 }
4546
4547 void
4548 Editor::set_fade_out_shape (AudioRegion::FadeShape shape)
4549 {
4550         begin_reversible_command (_("set fade out shape"));
4551
4552         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4553                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4554
4555                 if (!tmp) {
4556                         return;
4557                 }
4558
4559                 boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_out();
4560                 XMLNode &before = alist->get_state();
4561
4562                 tmp->audio_region()->set_fade_out_shape (shape);
4563
4564                 XMLNode &after = alist->get_state();
4565                 session->add_command(new MementoCommand<AutomationList>(*alist.get(), &before, &after));
4566         }
4567
4568         commit_reversible_command ();
4569 }
4570
4571 void
4572 Editor::set_fade_in_active (bool yn)
4573 {
4574         begin_reversible_command (_("set fade in active"));
4575
4576         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4577                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4578
4579                 if (!tmp) {
4580                         return;
4581                 }
4582
4583
4584                 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4585
4586                 XMLNode &before = ar->get_state();
4587
4588                 ar->set_fade_in_active (yn);
4589
4590                 XMLNode &after = ar->get_state();
4591                 session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
4592         }
4593
4594         commit_reversible_command ();
4595 }
4596
4597 void
4598 Editor::set_fade_out_active (bool yn)
4599 {
4600         begin_reversible_command (_("set fade out active"));
4601
4602         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4603                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4604
4605                 if (!tmp) {
4606                         return;
4607                 }
4608
4609                 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4610
4611                 XMLNode &before = ar->get_state();
4612
4613                 ar->set_fade_out_active (yn);
4614
4615                 XMLNode &after = ar->get_state();
4616                 session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
4617         }
4618
4619         commit_reversible_command ();
4620 }
4621
4622
4623 /** Update crossfade visibility after its configuration has been changed */
4624 void
4625 Editor::update_xfade_visibility ()
4626 {
4627         _xfade_visibility = Config->get_xfades_visible ();
4628
4629         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4630                 AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
4631                 if (v) {
4632                         if (_xfade_visibility) {
4633                                 v->show_all_xfades ();
4634                         } else {
4635                                 v->hide_all_xfades ();
4636                         }
4637                 }
4638         }
4639 }
4640
4641 void
4642 Editor::set_edit_point ()
4643 {
4644         nframes64_t where;
4645         bool ignored;
4646
4647         if (!mouse_frame (where, ignored)) {
4648                 return;
4649         }
4650
4651         snap_to (where);
4652
4653         if (selection->markers.empty()) {
4654
4655                 mouse_add_new_marker (where);
4656
4657         } else {
4658                 bool ignored;
4659
4660                 Location* loc = find_location_from_marker (selection->markers.front(), ignored);
4661
4662                 if (loc) {
4663                         loc->move_to (where);
4664                 }
4665         }
4666 }
4667
4668 void
4669 Editor::set_playhead_cursor ()
4670 {
4671         if (entered_marker) {
4672                 session->request_locate (entered_marker->position(), session->transport_rolling());
4673         } else {
4674                 nframes64_t where;
4675                 bool ignored;
4676
4677                 if (!mouse_frame (where, ignored)) {
4678                         return;
4679                 }
4680
4681                 snap_to (where);
4682
4683                 if (session) {
4684                         session->request_locate (where, session->transport_rolling());
4685                 }
4686         }
4687 }
4688
4689 void
4690 Editor::split ()
4691 {
4692         ensure_entered_region_selected ();
4693
4694         nframes64_t where = get_preferred_edit_position();
4695
4696         if (!selection->regions.empty()) {
4697
4698                 split_regions_at (where, selection->regions);
4699
4700         } else {
4701
4702                 RegionSelection rs;
4703                 rs = get_regions_at (where, selection->tracks);
4704                 split_regions_at (where, rs);
4705         }
4706 }
4707
4708 void
4709 Editor::ensure_entered_track_selected (bool op_really_wants_one_track_if_none_are_selected)
4710 {
4711         if (entered_track && mouse_mode == MouseObject) {
4712                 if (!selection->tracks.empty()) {
4713                         if (!selection->selected (entered_track)) {
4714                                 selection->add (entered_track);
4715                         }
4716                 } else {
4717                         /* there is no selection, but this operation requires/prefers selected objects */
4718
4719                         if (op_really_wants_one_track_if_none_are_selected) {
4720                                 selection->set (entered_track);
4721                         }
4722                 }
4723         }
4724 }
4725
4726 void
4727 Editor::ensure_entered_region_selected (bool op_really_wants_one_region_if_none_are_selected)
4728 {
4729         if (!entered_regionview || mouse_mode != MouseObject) {
4730                 return;
4731         }
4732
4733
4734         /* heuristic:
4735
4736         - if there is no existing selection, don't change it. the operation will thus apply to "all"
4737
4738         - if there is an existing selection, but the entered regionview isn't in it, add it. this
4739         avoids key-mouse ops on unselected regions from interfering with an existing selection,
4740         but also means that the operation will apply to the pointed-at region.
4741         */
4742
4743         if (!selection->regions.empty()) {
4744                 if (!selection->selected (entered_regionview)) {
4745                         selection->add (entered_regionview);
4746                 }
4747         } else {
4748                 /* there is no selection, but this operation requires/prefers selected objects */
4749
4750                 if (op_really_wants_one_region_if_none_are_selected) {
4751                         selection->set (entered_regionview, false);
4752                 }
4753         }
4754 }
4755
4756 void
4757 Editor::trim_region_front ()
4758 {
4759         trim_region (true);
4760 }
4761
4762 void
4763 Editor::trim_region_back ()
4764 {
4765         trim_region (false);
4766 }
4767
4768 void
4769 Editor::trim_region (bool front)
4770 {
4771         ExclusiveRegionSelection ers (*this, entered_regionview);
4772
4773         nframes64_t where = get_preferred_edit_position();
4774         RegionSelection& rs = get_regions_for_action ();
4775
4776         if (rs.empty()) {
4777                 return;
4778         }
4779
4780         begin_reversible_command (front ? _("trim front") : _("trim back"));
4781
4782         for (list<RegionView*>::const_iterator i = rs.by_layer().begin(); i != rs.by_layer().end(); ++i) {
4783                 if (!(*i)->region()->locked()) {
4784                         boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
4785                         XMLNode &before = pl->get_state();
4786                         if (front) {
4787                                 (*i)->region()->trim_front (where, this);
4788                         } else {
4789                                 (*i)->region()->trim_end (where, this);
4790                         }
4791                         XMLNode &after = pl->get_state();
4792                         session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
4793                 }
4794         }
4795
4796         commit_reversible_command ();
4797 }
4798
4799 struct EditorOrderRouteSorter {
4800     bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
4801             /* use of ">" forces the correct sort order */
4802             return a->order_key ("editor") < b->order_key ("editor");
4803     }
4804 };
4805
4806 void
4807 Editor::select_next_route()
4808 {
4809         if (selection->tracks.empty()) {
4810                 selection->set (track_views.front());
4811                 return;
4812         }
4813
4814         TimeAxisView* current = selection->tracks.front();
4815
4816         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4817                 if (*i == current) {
4818                         ++i;
4819                         if (i != track_views.end()) {
4820                                 selection->set (*i);
4821                         } else {
4822                                 selection->set (*(track_views.begin()));
4823                         }
4824                         break;
4825                 }
4826         }
4827 }
4828
4829 void
4830 Editor::select_prev_route()
4831 {
4832         if (selection->tracks.empty()) {
4833                 selection->set (track_views.front());
4834                 return;
4835         }
4836
4837         TimeAxisView* current = selection->tracks.front();
4838
4839         for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
4840                 if (*i == current) {
4841                         ++i;
4842                         if (i != track_views.rend()) {
4843                                 selection->set (*i);
4844                         } else {
4845                                 selection->set (*(track_views.rbegin()));
4846                         }
4847                         break;
4848                 }
4849         }
4850 }
4851
4852 void
4853 Editor::set_loop_from_selection (bool play)
4854 {
4855         if (session == 0 || selection->time.empty()) {
4856                 return;
4857         }
4858
4859         nframes_t start = selection->time[clicked_selection].start;
4860         nframes_t end = selection->time[clicked_selection].end;
4861
4862         set_loop_range (start, end,  _("set loop range from selection"));
4863
4864         if (play) {
4865                 session->request_play_loop (true);
4866                 session->request_locate (start, true);
4867         }
4868 }
4869
4870 void
4871 Editor::set_loop_from_edit_range (bool play)
4872 {
4873         if (session == 0) {
4874                 return;
4875         }
4876
4877         nframes64_t start;
4878         nframes64_t end;
4879
4880         if (!get_edit_op_range (start, end)) {
4881                 return;
4882         }
4883
4884         set_loop_range (start, end,  _("set loop range from edit range"));
4885
4886         if (play) {
4887                 session->request_play_loop (true);
4888                 session->request_locate (start, true);
4889         }
4890 }
4891
4892 void
4893 Editor::set_loop_from_region (bool play)
4894 {
4895         nframes64_t start = max_frames;
4896         nframes64_t end = 0;
4897
4898         ExclusiveRegionSelection esr (*this, entered_regionview);
4899
4900         if (selection->regions.empty()) {
4901                 info << _("cannot set loop: no region selected") << endmsg;
4902                 return;
4903         }
4904
4905         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4906                 if ((*i)->region()->position() < start) {
4907                         start = (*i)->region()->position();
4908                 }
4909                 if ((*i)->region()->last_frame() + 1 > end) {
4910                         end = (*i)->region()->last_frame() + 1;
4911                 }
4912         }
4913
4914         set_loop_range (start, end, _("set loop range from region"));
4915
4916         if (play) {
4917                 session->request_play_loop (true);
4918                 session->request_locate (start, true);
4919         }
4920 }
4921
4922 void
4923 Editor::set_punch_from_selection ()
4924 {
4925         if (session == 0 || selection->time.empty()) {
4926                 return;
4927         }
4928
4929         nframes_t start = selection->time[clicked_selection].start;
4930         nframes_t end = selection->time[clicked_selection].end;
4931
4932         set_punch_range (start, end,  _("set punch range from selection"));
4933 }
4934
4935 void
4936 Editor::set_punch_from_edit_range ()
4937 {
4938         if (session == 0) {
4939                 return;
4940         }
4941
4942         nframes64_t start;
4943         nframes64_t end;
4944
4945         if (!get_edit_op_range (start, end)) {
4946                 return;
4947         }
4948
4949         set_punch_range (start, end,  _("set punch range from edit range"));
4950 }
4951
4952 void
4953 Editor::set_punch_from_region ()
4954 {
4955         nframes64_t start = max_frames;
4956         nframes64_t end = 0;
4957
4958         ExclusiveRegionSelection esr (*this, entered_regionview);
4959
4960         if (selection->regions.empty()) {
4961                 info << _("cannot set punch: no region selected") << endmsg;
4962                 return;
4963         }
4964
4965         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4966                 if ((*i)->region()->position() < start) {
4967                         start = (*i)->region()->position();
4968                 }
4969                 if ((*i)->region()->last_frame() + 1 > end) {
4970                         end = (*i)->region()->last_frame() + 1;
4971                 }
4972         }
4973
4974         set_punch_range (start, end, _("set punch range from region"));
4975 }
4976
4977 void
4978 Editor::pitch_shift_regions ()
4979 {
4980         ensure_entered_region_selected (true);
4981
4982         if (selection->regions.empty()) {
4983                 return;
4984         }
4985
4986         pitch_shift (selection->regions, 1.2);
4987 }
4988
4989 void
4990 Editor::use_region_as_bar ()
4991 {
4992         if (!session) {
4993                 return;
4994         }
4995
4996         ExclusiveRegionSelection esr (*this, entered_regionview);
4997
4998         if (selection->regions.empty()) {
4999                 return;
5000         }
5001
5002         RegionView* rv = selection->regions.front();
5003
5004         define_one_bar (rv->region()->position(), rv->region()->last_frame() + 1);
5005 }
5006
5007 void
5008 Editor::use_range_as_bar ()
5009 {
5010         nframes64_t start, end;
5011         if (get_edit_op_range (start, end)) {
5012                 define_one_bar (start, end);
5013         }
5014 }
5015
5016 void
5017 Editor::define_one_bar (nframes64_t start, nframes64_t end)
5018 {
5019         nframes64_t length = end - start;
5020
5021         const Meter& m (session->tempo_map().meter_at (start));
5022
5023         /* length = 1 bar */
5024
5025         /* now we want frames per beat.
5026            we have frames per bar, and beats per bar, so ...
5027         */
5028
5029         double frames_per_beat = length / m.beats_per_bar();
5030
5031         /* beats per minute = */
5032
5033         double beats_per_minute = (session->frame_rate() * 60.0) / frames_per_beat;
5034
5035         /* now decide whether to:
5036
5037             (a) set global tempo
5038             (b) add a new tempo marker
5039
5040         */
5041
5042         const TempoSection& t (session->tempo_map().tempo_section_at (start));
5043
5044         bool do_global = false;
5045
5046         if ((session->tempo_map().n_tempos() == 1) && (session->tempo_map().n_meters() == 1)) {
5047
5048                 /* only 1 tempo & 1 meter: ask if the user wants to set the tempo
5049                    at the start, or create a new marker
5050                 */
5051
5052                 vector<string> options;
5053                 options.push_back (_("Set global tempo"));
5054                 options.push_back (_("Add new marker"));
5055                 options.push_back (_("Cancel"));
5056                 Choice c (_("Do you want to set the global tempo or add new tempo marker?"),
5057                           options);
5058
5059                 switch (c.run()) {
5060                 case 0:
5061                         do_global = true;
5062                         break;
5063                 case 2:
5064                         return;
5065
5066                 default:
5067                         do_global = false;
5068                 }
5069
5070         } else {
5071
5072                 /* more than 1 tempo and/or meter section already, go ahead do the "usual":
5073                    if the marker is at the region starter, change it, otherwise add
5074                    a new tempo marker
5075                 */
5076         }
5077
5078         begin_reversible_command (_("set tempo from region"));
5079         XMLNode& before (session->tempo_map().get_state());
5080
5081         if (do_global) {
5082                 session->tempo_map().change_initial_tempo (beats_per_minute, t.note_type());
5083         } else if (t.frame() == start) {
5084                 session->tempo_map().change_existing_tempo_at (start, beats_per_minute, t.note_type());
5085         } else {
5086                 session->tempo_map().add_tempo (Tempo (beats_per_minute, t.note_type()), start);
5087         }
5088
5089         XMLNode& after (session->tempo_map().get_state());
5090
5091         session->add_command (new MementoCommand<TempoMap>(session->tempo_map(), &before, &after));
5092         commit_reversible_command ();
5093 }
5094
5095 void
5096 Editor::split_region_at_transients ()
5097 {
5098         AnalysisFeatureList positions;
5099
5100         if (!session) {
5101                 return;
5102         }
5103
5104         ExclusiveRegionSelection esr (*this, entered_regionview);
5105
5106         if (selection->regions.empty()) {
5107                 return;
5108         }
5109
5110         session->begin_reversible_command (_("split regions"));
5111
5112         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ) {
5113
5114                 RegionSelection::iterator tmp;
5115
5116                 tmp = i;
5117                 ++tmp;
5118
5119                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> ((*i)->region());
5120
5121                 if (ar && (ar->get_transients (positions) == 0)) {
5122                         split_region_at_points ((*i)->region(), positions);
5123                         positions.clear ();
5124                 }
5125
5126                 i = tmp;
5127         }
5128
5129         session->commit_reversible_command ();
5130
5131 }
5132
5133 void
5134 Editor::split_region_at_points (boost::shared_ptr<Region> r, AnalysisFeatureList& positions)
5135 {
5136         boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> (r);
5137
5138         if (!ar) {
5139                 return;
5140         }
5141
5142         boost::shared_ptr<Playlist> pl = ar->playlist();
5143
5144         if (!pl) {
5145                 return;
5146         }
5147
5148         if (positions.empty()) {
5149                 return;
5150         }
5151
5152         AnalysisFeatureList::const_iterator x;
5153
5154         nframes64_t pos = ar->position();
5155
5156         XMLNode& before (pl->get_state());
5157
5158         x = positions.begin();
5159
5160         while (x != positions.end()) {
5161                 if ((*x) > pos) {
5162                         break;
5163                 }
5164         }
5165
5166         if (x == positions.end()) {
5167                 return;
5168         }
5169
5170         pl->freeze ();
5171         pl->remove_region (ar);
5172
5173         do {
5174
5175                 /* file start = original start + how far we from the initial position ?
5176                  */
5177
5178                 nframes64_t file_start = ar->start() + (pos - ar->position());
5179
5180                 /* length = next position - current position
5181                  */
5182
5183                 nframes64_t len = (*x) - pos;
5184
5185                 string new_name;
5186
5187                 if (session->region_name (new_name, ar->name())) {
5188                         continue;
5189                 }
5190
5191                 pl->add_region (RegionFactory::create (ar->sources(), file_start, len, new_name), pos);
5192
5193                 pos += len;
5194
5195                 ++x;
5196
5197         } while (x != positions.end() && (*x) < ar->last_frame());
5198
5199         pl->thaw ();
5200
5201         XMLNode& after (pl->get_state());
5202
5203         session->add_command (new MementoCommand<Playlist>(*pl, &before, &after));
5204 }
5205
5206 void
5207 Editor::tab_to_transient (bool forward)
5208 {
5209         AnalysisFeatureList positions;
5210
5211         if (!session) {
5212                 return;
5213         }
5214
5215         nframes64_t pos = session->audible_frame ();
5216
5217         if (!selection->tracks.empty()) {
5218
5219                 for (TrackSelection::iterator t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
5220
5221                         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*t);
5222
5223                         if (rtv) {
5224                                 boost::shared_ptr<Diskstream> ds = rtv->get_diskstream();
5225                                 if (ds) {
5226                                         boost::shared_ptr<Playlist> pl = rtv->get_diskstream()->playlist ();
5227                                         if (pl) {
5228                                                 nframes64_t result = pl->find_next_transient (pos, forward ? 1 : -1);
5229
5230                                                 if (result >= 0) {
5231                                                         positions.push_back (result);
5232                                                 }
5233                                         }
5234                                 }
5235                         }
5236                 }
5237
5238         } else {
5239
5240                 ExclusiveRegionSelection esr (*this, entered_regionview);
5241
5242                 if (selection->regions.empty()) {
5243                         return;
5244                 }
5245
5246                 for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
5247                         (*r)->region()->get_transients (positions);
5248                 }
5249         }
5250
5251         TransientDetector::cleanup_transients (positions, session->frame_rate(), 3.0);
5252
5253         if (forward) {
5254                 AnalysisFeatureList::iterator x;
5255
5256                 for (x = positions.begin(); x != positions.end(); ++x) {
5257                         if ((*x) > pos) {
5258                                 break;
5259                         }
5260                 }
5261
5262                 if (x != positions.end ()) {
5263                         session->request_locate (*x);
5264                 }
5265
5266         } else {
5267                 AnalysisFeatureList::reverse_iterator x;
5268
5269                 for (x = positions.rbegin(); x != positions.rend(); ++x) {
5270                         if ((*x) < pos) {
5271                                 break;
5272                         }
5273                 }
5274
5275                 if (x != positions.rend ()) {
5276                         session->request_locate (*x);
5277                 }
5278         }
5279 }