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