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