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_region ()
1545 {
1546
1547         nframes64_t start = max_frames;
1548         nframes64_t end = 0;
1549
1550         ensure_entered_region_selected (true);
1551
1552         if (selection->regions.empty()) {
1553                 info << _("cannot set loop: no region selected") << endmsg;
1554                 return;
1555         }
1556
1557         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
1558                 if ((*i)->region()->position() < start) {
1559                         start = (*i)->region()->position();
1560                 }
1561                 if ((*i)->region()->last_frame() + 1 > end) {
1562                         end = (*i)->region()->last_frame() + 1;
1563                 }
1564         }
1565
1566         temporal_zoom_by_frame (start, end, "zoom to region");
1567 }
1568
1569 void
1570 Editor::temporal_zoom_selection ()
1571 {
1572         if (!selection) return;
1573
1574         if (selection->time.empty()) {
1575                 return;
1576         }
1577
1578         nframes_t start = selection->time[clicked_selection].start;
1579         nframes_t end = selection->time[clicked_selection].end;
1580
1581         temporal_zoom_by_frame (start, end, "zoom to selection");
1582 }
1583
1584 void
1585 Editor::temporal_zoom_session ()
1586 {
1587         ENSURE_GUI_THREAD (mem_fun (*this, &Editor::temporal_zoom_session));
1588
1589         if (session) {
1590                 temporal_zoom_by_frame (session->current_start_frame(), session->current_end_frame(), "zoom to session");
1591         }
1592 }
1593
1594 void
1595 Editor::temporal_zoom_by_frame (nframes_t start, nframes_t end, const string & op)
1596 {
1597         if (!session) return;
1598
1599         if ((start == 0 && end == 0) || end < start) {
1600                 return;
1601         }
1602
1603         nframes_t range = end - start;
1604
1605         double new_fpu = (double)range / (double)canvas_width;
1606 //      double p2 = 1.0;
1607
1608 //      while (p2 < new_fpu) {
1609 //              p2 *= 2.0;
1610 //      }
1611 //      new_fpu = p2;
1612
1613         nframes_t new_page = (nframes_t) floor (canvas_width * new_fpu);
1614         nframes_t middle = (nframes_t) floor( (double)start + ((double)range / 2.0f ));
1615         nframes_t new_leftmost = (nframes_t) floor( (double)middle - ((double)new_page/2.0f));
1616
1617         if (new_leftmost > middle) new_leftmost = 0;
1618
1619 //      begin_reversible_command (op);
1620 //      session->add_undo (bind (mem_fun(*this, &Editor::reposition_and_zoom), leftmost_frame, frames_per_unit));
1621 //      session->add_redo (bind (mem_fun(*this, &Editor::reposition_and_zoom), new_leftmost, new_fpu));
1622 //      commit_reversible_command ();
1623
1624         reposition_and_zoom (new_leftmost, new_fpu);
1625 }
1626
1627 void
1628 Editor::temporal_zoom_to_frame (bool coarser, nframes_t frame)
1629 {
1630         if (!session) return;
1631
1632         double range_before = frame - leftmost_frame;
1633         double new_fpu;
1634
1635         new_fpu = frames_per_unit;
1636
1637         if (coarser) {
1638                 new_fpu *= 1.61803399;
1639                 range_before *= 1.61803399;
1640         } else {
1641                 new_fpu = max(1.0,(new_fpu/1.61803399));
1642                 range_before /= 1.61803399;
1643         }
1644
1645         if (new_fpu == frames_per_unit) return;
1646
1647         nframes_t new_leftmost = frame - (nframes_t)range_before;
1648
1649         if (new_leftmost > frame) new_leftmost = 0;
1650
1651 //      begin_reversible_command (_("zoom to frame"));
1652 //      session->add_undo (bind (mem_fun(*this, &Editor::reposition_and_zoom), leftmost_frame, frames_per_unit));
1653 //      session->add_redo (bind (mem_fun(*this, &Editor::reposition_and_zoom), new_leftmost, new_fpu));
1654 //      commit_reversible_command ();
1655
1656         reposition_and_zoom (new_leftmost, new_fpu);
1657 }
1658
1659 void
1660 Editor::add_location_from_selection ()
1661 {
1662         string rangename;
1663
1664         if (selection->time.empty()) {
1665                 return;
1666         }
1667
1668         if (session == 0 || clicked_trackview == 0) {
1669                 return;
1670         }
1671
1672         nframes_t start = selection->time[clicked_selection].start;
1673         nframes_t end = selection->time[clicked_selection].end;
1674
1675         session->locations()->next_available_name(rangename,"selection");
1676         Location *location = new Location (start, end, rangename, Location::IsRangeMarker);
1677
1678         session->begin_reversible_command (_("add marker"));
1679         XMLNode &before = session->locations()->get_state();
1680         session->locations()->add (location, true);
1681         XMLNode &after = session->locations()->get_state();
1682         session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
1683         session->commit_reversible_command ();
1684 }
1685
1686 void
1687 Editor::add_location_mark (nframes64_t where)
1688 {
1689         string markername;
1690
1691         select_new_marker = true;
1692
1693         session->locations()->next_available_name(markername,"mark");
1694         Location *location = new Location (where, where, markername, Location::IsMark);
1695         session->begin_reversible_command (_("add marker"));
1696         XMLNode &before = session->locations()->get_state();
1697         session->locations()->add (location, true);
1698         XMLNode &after = session->locations()->get_state();
1699         session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
1700         session->commit_reversible_command ();
1701 }
1702
1703 void
1704 Editor::add_location_from_playhead_cursor ()
1705 {
1706         add_location_mark (session->audible_frame());
1707 }
1708
1709 void
1710 Editor::add_location_from_audio_region ()
1711 {
1712         if (selection->regions.empty()) {
1713                 return;
1714         }
1715
1716         RegionView* rv = *(selection->regions.begin());
1717         boost::shared_ptr<Region> region = rv->region();
1718
1719         Location *location = new Location (region->position(), region->last_frame(), region->name(), Location::IsRangeMarker);
1720         session->begin_reversible_command (_("add marker"));
1721         XMLNode &before = session->locations()->get_state();
1722         session->locations()->add (location, true);
1723         XMLNode &after = session->locations()->get_state();
1724         session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
1725         session->commit_reversible_command ();
1726 }
1727
1728 void
1729 Editor::amplitude_zoom_step (bool in)
1730 {
1731         gdouble zoom = 1.0;
1732
1733         if (in) {
1734                 zoom *= 2.0;
1735         } else {
1736                 if (zoom > 2.0) {
1737                         zoom /= 2.0;
1738                 } else {
1739                         zoom = 1.0;
1740                 }
1741         }
1742
1743 #ifdef FIX_FOR_CANVAS
1744         /* XXX DO SOMETHING */
1745 #endif
1746 }
1747
1748
1749 /* DELETION */
1750
1751
1752 void
1753 Editor::delete_sample_forward ()
1754 {
1755 }
1756
1757 void
1758 Editor::delete_sample_backward ()
1759 {
1760 }
1761
1762 void
1763 Editor::delete_screen ()
1764 {
1765 }
1766
1767 /* SEARCH */
1768
1769 void
1770 Editor::search_backwards ()
1771 {
1772         /* what ? */
1773 }
1774
1775 void
1776 Editor::search_forwards ()
1777 {
1778         /* what ? */
1779 }
1780
1781 /* MARKS */
1782
1783 void
1784 Editor::jump_forward_to_mark ()
1785 {
1786         if (!session) {
1787                 return;
1788         }
1789
1790         Location *location = session->locations()->first_location_after (playhead_cursor->current_frame);
1791
1792         if (location) {
1793                 session->request_locate (location->start(), session->transport_rolling());
1794         } else {
1795                 session->request_locate (session->current_end_frame());
1796         }
1797 }
1798
1799 void
1800 Editor::jump_backward_to_mark ()
1801 {
1802         if (!session) {
1803                 return;
1804         }
1805
1806         Location *location = session->locations()->first_location_before (playhead_cursor->current_frame);
1807
1808         if (location) {
1809                 session->request_locate (location->start(), session->transport_rolling());
1810         } else {
1811                 session->goto_start ();
1812         }
1813 }
1814
1815 void
1816 Editor::set_mark ()
1817 {
1818         nframes_t pos;
1819         float prefix;
1820         bool was_floating;
1821         string markername;
1822
1823         if (get_prefix (prefix, was_floating)) {
1824                 pos = session->audible_frame ();
1825         } else {
1826                 if (was_floating) {
1827                         pos = (nframes_t) floor (prefix * session->frame_rate ());
1828                 } else {
1829                         pos = (nframes_t) floor (prefix);
1830                 }
1831         }
1832
1833         session->locations()->next_available_name(markername,"mark");
1834         session->locations()->add (new Location (pos, 0, markername, Location::IsMark), true);
1835 }
1836
1837 void
1838 Editor::clear_markers ()
1839 {
1840         if (session) {
1841                 session->begin_reversible_command (_("clear markers"));
1842                 XMLNode &before = session->locations()->get_state();
1843                 session->locations()->clear_markers ();
1844                 XMLNode &after = session->locations()->get_state();
1845                 session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
1846                 session->commit_reversible_command ();
1847         }
1848 }
1849
1850 void
1851 Editor::clear_ranges ()
1852 {
1853         if (session) {
1854                 session->begin_reversible_command (_("clear ranges"));
1855                 XMLNode &before = session->locations()->get_state();
1856
1857                 Location * looploc = session->locations()->auto_loop_location();
1858                 Location * punchloc = session->locations()->auto_punch_location();
1859
1860                 session->locations()->clear_ranges ();
1861                 // re-add these
1862                 if (looploc) session->locations()->add (looploc);
1863                 if (punchloc) session->locations()->add (punchloc);
1864
1865                 XMLNode &after = session->locations()->get_state();
1866                 session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
1867                 session->commit_reversible_command ();
1868         }
1869 }
1870
1871 void
1872 Editor::clear_locations ()
1873 {
1874         session->begin_reversible_command (_("clear locations"));
1875         XMLNode &before = session->locations()->get_state();
1876         session->locations()->clear ();
1877         XMLNode &after = session->locations()->get_state();
1878         session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
1879         session->commit_reversible_command ();
1880         session->locations()->clear ();
1881 }
1882
1883 void
1884 Editor::unhide_markers ()
1885 {
1886         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1887                 Location *l = (*i).first;
1888                 if (l->is_hidden() && l->is_mark()) {
1889                         l->set_hidden(false, this);
1890                 }
1891         }
1892 }
1893
1894 void
1895 Editor::unhide_ranges ()
1896 {
1897         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1898                 Location *l = (*i).first;
1899                 if (l->is_hidden() && l->is_range_marker()) {
1900                         l->set_hidden(false, this);
1901                 }
1902         }
1903 }
1904
1905 /* INSERT/REPLACE */
1906
1907 void
1908 Editor::insert_region_list_drag (boost::shared_ptr<AudioRegion> region, int x, int y)
1909 {
1910         double wx, wy;
1911         double cx, cy;
1912         TimeAxisView *tv;
1913         nframes_t where;
1914         AudioTimeAxisView *atv = 0;
1915         boost::shared_ptr<Playlist> playlist;
1916
1917         track_canvas.window_to_world (x, y, wx, wy);
1918         wx += horizontal_adjustment.get_value();
1919         wy += vertical_adjustment.get_value();
1920
1921         GdkEvent event;
1922         event.type = GDK_BUTTON_RELEASE;
1923         event.button.x = wx;
1924         event.button.y = wy;
1925
1926         where = event_frame (&event, &cx, &cy);
1927
1928         if (where < leftmost_frame || where > leftmost_frame + current_page_frames()) {
1929                 /* clearly outside canvas area */
1930                 return;
1931         }
1932
1933         if ((tv = trackview_by_y_position (cy)) == 0) {
1934                 return;
1935         }
1936
1937         if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) == 0) {
1938                 return;
1939         }
1940
1941         if ((playlist = atv->playlist()) == 0) {
1942                 return;
1943         }
1944
1945         snap_to (where);
1946
1947         begin_reversible_command (_("insert dragged region"));
1948         XMLNode &before = playlist->get_state();
1949         playlist->add_region (RegionFactory::create (region), where, 1.0);
1950         session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
1951         commit_reversible_command ();
1952 }
1953
1954 void
1955 Editor::insert_region_list_selection (float times)
1956 {
1957         RouteTimeAxisView *tv = 0;
1958         boost::shared_ptr<Playlist> playlist;
1959
1960         if (clicked_audio_trackview != 0) {
1961                 tv = clicked_audio_trackview;
1962         } else if (!selection->tracks.empty()) {
1963                 if ((tv = dynamic_cast<RouteTimeAxisView*>(selection->tracks.front())) == 0) {
1964                         return;
1965                 }
1966         } else if (entered_track != 0) {
1967                 if ((tv = dynamic_cast<RouteTimeAxisView*>(entered_track)) == 0) {
1968                         return;
1969                 }
1970         } else {
1971                 return;
1972         }
1973
1974         if ((playlist = tv->playlist()) == 0) {
1975                 return;
1976         }
1977
1978         Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
1979
1980         if (selected->count_selected_rows() != 1) {
1981                 return;
1982         }
1983
1984         TreeView::Selection::ListHandle_Path rows = selected->get_selected_rows ();
1985
1986         /* only one row selected, so rows.begin() is it */
1987
1988         TreeIter iter;
1989
1990         if ((iter = region_list_model->get_iter (*rows.begin()))) {
1991
1992                 boost::shared_ptr<Region> region = (*iter)[region_list_columns.region];
1993
1994                 begin_reversible_command (_("insert region"));
1995                 XMLNode &before = playlist->get_state();
1996                 playlist->add_region ((RegionFactory::create (region)), get_preferred_edit_position(), times);
1997                 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
1998                 commit_reversible_command ();
1999         }
2000 }
2001
2002 /* BUILT-IN EFFECTS */
2003
2004 void
2005 Editor::reverse_selection ()
2006 {
2007
2008 }
2009
2010 /* GAIN ENVELOPE EDITING */
2011
2012 void
2013 Editor::edit_envelope ()
2014 {
2015 }
2016
2017 /* PLAYBACK */
2018
2019 void
2020 Editor::transition_to_rolling (bool fwd)
2021 {
2022         if (!session) {
2023                 return;
2024         }
2025
2026         switch (Config->get_slave_source()) {
2027         case None:
2028         case JACK:
2029                 break;
2030         default:
2031                 /* transport controlled by the master */
2032                 return;
2033         }
2034
2035         if (session->is_auditioning()) {
2036                 session->cancel_audition ();
2037                 return;
2038         }
2039
2040         session->request_transport_speed (fwd ? 1.0f : -1.0f);
2041 }
2042
2043 void
2044 Editor::toggle_playback (bool with_abort)
2045 {
2046         if (!session) {
2047                 return;
2048         }
2049
2050         switch (Config->get_slave_source()) {
2051         case None:
2052         case JACK:
2053                 break;
2054         default:
2055                 /* transport controlled by the master */
2056                 return;
2057         }
2058
2059         if (session->is_auditioning()) {
2060                 session->cancel_audition ();
2061                 return;
2062         }
2063
2064         if (session->transport_rolling()) {
2065                 session->request_stop (with_abort);
2066                 if (session->get_play_loop()) {
2067                         session->request_play_loop (false);
2068                 }
2069         } else {
2070                 session->request_transport_speed (1.0f);
2071         }
2072 }
2073
2074 void
2075 Editor::play_from_start ()
2076 {
2077         session->request_locate (session->current_start_frame(), true);
2078 }
2079
2080 void
2081 Editor::play_from_edit_point ()
2082 {
2083         session->request_locate (get_preferred_edit_position(), true);
2084 }
2085
2086 void
2087 Editor::play_selection ()
2088 {
2089         if (selection->time.empty()) {
2090                 return;
2091         }
2092
2093         session->request_play_range (true);
2094 }
2095
2096 void
2097 Editor::play_selected_region ()
2098 {
2099         if (!selection->regions.empty()) {
2100                 RegionView *rv = *(selection->regions.begin());
2101
2102                 session->request_bounded_roll (rv->region()->position(), rv->region()->last_frame());
2103         }
2104 }
2105
2106 void
2107 Editor::loop_selected_region ()
2108 {
2109         if (!selection->regions.empty()) {
2110                 RegionView *rv = *(selection->regions.begin());
2111                 Location* tll;
2112
2113                 if ((tll = transport_loop_location()) != 0)  {
2114
2115                         tll->set (rv->region()->position(), rv->region()->last_frame());
2116
2117                         // enable looping, reposition and start rolling
2118
2119                         session->request_play_loop (true);
2120                         session->request_locate (tll->start(), false);
2121                         session->request_transport_speed (1.0f);
2122                 }
2123         }
2124 }
2125
2126 void
2127 Editor::play_location (Location& location)
2128 {
2129         if (location.start() <= location.end()) {
2130                 return;
2131         }
2132
2133         session->request_bounded_roll (location.start(), location.end());
2134 }
2135
2136 void
2137 Editor::loop_location (Location& location)
2138 {
2139         if (location.start() <= location.end()) {
2140                 return;
2141         }
2142
2143         Location* tll;
2144
2145         if ((tll = transport_loop_location()) != 0) {
2146                 tll->set (location.start(), location.end());
2147
2148                 // enable looping, reposition and start rolling
2149                 session->request_play_loop (true);
2150                 session->request_locate (tll->start(), true);
2151         }
2152 }
2153
2154 void
2155 Editor::raise_region ()
2156 {
2157         selection->foreach_region (&Region::raise);
2158 }
2159
2160 void
2161 Editor::raise_region_to_top ()
2162 {
2163         selection->foreach_region (&Region::raise_to_top);
2164 }
2165
2166 void
2167 Editor::lower_region ()
2168 {
2169         selection->foreach_region (&Region::lower);
2170 }
2171
2172 void
2173 Editor::lower_region_to_bottom ()
2174 {
2175         selection->foreach_region (&Region::lower_to_bottom);
2176 }
2177
2178 void
2179 Editor::edit_region ()
2180 {
2181         if (clicked_regionview == 0) {
2182                 return;
2183         }
2184
2185         clicked_regionview->show_region_editor ();
2186 }
2187
2188 void
2189 Editor::rename_region()
2190 {
2191         if (selection->regions.empty()) {
2192                 return;
2193         }
2194
2195         WindowTitle title (Glib::get_application_name());
2196         title += _("Rename Region");
2197
2198         ArdourDialog d (*this, title.get_string(), true, false);
2199         Entry entry;
2200         Label label (_("New name:"));
2201         HBox hbox;
2202
2203         hbox.set_spacing (6);
2204         hbox.pack_start (label, false, false);
2205         hbox.pack_start (entry, true, true);
2206
2207         d.get_vbox()->set_border_width (12);
2208         d.get_vbox()->pack_start (hbox, false, false);
2209
2210         d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
2211         d.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2212
2213         d.set_size_request (300, -1);
2214         d.set_position (Gtk::WIN_POS_MOUSE);
2215
2216         entry.set_text (selection->regions.front()->region()->name());
2217         entry.select_region (0, -1);
2218
2219         entry.signal_activate().connect (bind (mem_fun (d, &Dialog::response), RESPONSE_OK));
2220
2221         d.show_all ();
2222
2223         entry.grab_focus();
2224
2225         int ret = d.run();
2226
2227         d.hide ();
2228
2229         if (ret == RESPONSE_OK) {
2230                 std::string str = entry.get_text();
2231                 strip_whitespace_edges (str);
2232                 if (!str.empty()) {
2233                         selection->regions.front()->region()->set_name (str);
2234                         redisplay_regions ();
2235                 }
2236         }
2237 }
2238
2239 void
2240 Editor::audition_playlist_region_via_route (boost::shared_ptr<Region> region, Route& route)
2241 {
2242         if (session->is_auditioning()) {
2243                 session->cancel_audition ();
2244         }
2245
2246         // note: some potential for creativity here, because region doesn't
2247         // have to belong to the playlist that Route is handling
2248
2249         // bool was_soloed = route.soloed();
2250
2251         route.set_solo (true, this);
2252
2253         session->request_bounded_roll (region->position(), region->position() + region->length());
2254
2255         /* XXX how to unset the solo state ? */
2256 }
2257
2258 void
2259 Editor::audition_selected_region ()
2260 {
2261         if (!selection->regions.empty()) {
2262                 RegionView* rv = *(selection->regions.begin());
2263                 session->audition_region (rv->region());
2264         }
2265 }
2266
2267 void
2268 Editor::audition_playlist_region_standalone (boost::shared_ptr<Region> region)
2269 {
2270         session->audition_region (region);
2271 }
2272
2273 void
2274 Editor::build_interthread_progress_window ()
2275 {
2276         interthread_progress_window = new ArdourDialog (X_("interthread progress"), true);
2277
2278         interthread_progress_bar.set_orientation (Gtk::PROGRESS_LEFT_TO_RIGHT);
2279
2280         interthread_progress_window->get_vbox()->pack_start (interthread_progress_label, false, false);
2281         interthread_progress_window->get_vbox()->pack_start (interthread_progress_bar,false, false);
2282
2283         // GTK2FIX: this button needs a modifiable label
2284
2285         Button* b = interthread_progress_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
2286         b->signal_clicked().connect (mem_fun(*this, &Editor::interthread_cancel_clicked));
2287
2288         interthread_cancel_button.add (interthread_cancel_label);
2289
2290         interthread_progress_window->set_default_size (200, 100);
2291 }
2292
2293 void
2294 Editor::interthread_cancel_clicked ()
2295 {
2296         if (current_interthread_info) {
2297                 current_interthread_info->cancel = true;
2298         }
2299 }
2300
2301 void
2302 Editor::region_from_selection ()
2303 {
2304         if (clicked_trackview == 0) {
2305                 return;
2306         }
2307
2308         if (selection->time.empty()) {
2309                 return;
2310         }
2311
2312         nframes_t start = selection->time[clicked_selection].start;
2313         nframes_t end = selection->time[clicked_selection].end;
2314
2315         nframes_t selection_cnt = end - start + 1;
2316
2317         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2318                 boost::shared_ptr<AudioRegion> current;
2319                 boost::shared_ptr<Region> current_r;
2320                 boost::shared_ptr<Playlist> pl;
2321
2322                 nframes_t internal_start;
2323                 string new_name;
2324
2325                 if ((pl = (*i)->playlist()) == 0) {
2326                         continue;
2327                 }
2328
2329                 if ((current_r = pl->top_region_at (start)) == 0) {
2330                         continue;
2331                 }
2332
2333                 current = boost::dynamic_pointer_cast<AudioRegion> (current_r);
2334                 // FIXME: audio only
2335                 if (current != 0) {
2336                         internal_start = start - current->position();
2337                         session->region_name (new_name, current->name(), true);
2338                         boost::shared_ptr<Region> region (RegionFactory::create (current, internal_start, selection_cnt, new_name));
2339                 }
2340         }
2341 }
2342
2343 void
2344 Editor::create_region_from_selection (vector<boost::shared_ptr<AudioRegion> >& new_regions)
2345 {
2346         if (selection->time.empty() || selection->tracks.empty()) {
2347                 return;
2348         }
2349
2350         nframes_t start = selection->time[clicked_selection].start;
2351         nframes_t end = selection->time[clicked_selection].end;
2352
2353         sort_track_selection ();
2354
2355         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2356
2357                 boost::shared_ptr<AudioRegion> current;
2358                 boost::shared_ptr<Region> current_r;
2359                 boost::shared_ptr<Playlist> playlist;
2360                 nframes_t internal_start;
2361                 string new_name;
2362
2363                 if ((playlist = (*i)->playlist()) == 0) {
2364                         continue;
2365                 }
2366
2367                 if ((current_r = playlist->top_region_at(start)) == 0) {
2368                         continue;
2369                 }
2370
2371                 if ((current = boost::dynamic_pointer_cast<AudioRegion>(current_r)) == 0) {
2372                         continue;
2373                 }
2374
2375                 internal_start = start - current->position();
2376                 session->region_name (new_name, current->name(), true);
2377
2378                 new_regions.push_back (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (current, internal_start, end - start + 1, new_name)));
2379         }
2380 }
2381
2382 void
2383 Editor::split_multichannel_region ()
2384 {
2385         if (selection->regions.empty()) {
2386                 return;
2387         }
2388
2389         vector<boost::shared_ptr<AudioRegion> > v;
2390
2391         for (list<RegionView*>::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
2392
2393                 AudioRegionView* arv = dynamic_cast<AudioRegionView*>(*x);
2394
2395                 if (!arv || arv->audio_region()->n_channels() < 2) {
2396                         continue;
2397                 }
2398
2399                 (arv)->audio_region()->separate_by_channel (*session, v);
2400         }
2401 }
2402
2403 void
2404 Editor::new_region_from_selection ()
2405 {
2406         region_from_selection ();
2407         cancel_selection ();
2408 }
2409
2410 static void
2411 add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
2412 {
2413         switch (rv->region()->coverage (ar->start, ar->end - 1)) {
2414         case OverlapNone:
2415                 break;
2416         default:
2417                 rs->push_back (rv);
2418         }
2419 }
2420
2421 void
2422 Editor::separate_regions_between (const TimeSelection& ts)
2423 {
2424         bool in_command = false;
2425         boost::shared_ptr<Playlist> playlist;
2426         RegionSelection new_selection;
2427
2428         sort_track_selection ();
2429
2430         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2431
2432                 AudioTimeAxisView* atv;
2433
2434                 if ((atv = dynamic_cast<AudioTimeAxisView*> ((*i))) != 0) {
2435
2436                         if (atv->is_audio_track()) {
2437
2438                                 /* no edits to destructive tracks */
2439
2440                                 if (atv->audio_track()->audio_diskstream()->destructive()) {
2441                                         continue;
2442                                 }
2443
2444                                 if ((playlist = atv->playlist()) != 0) {
2445
2446
2447                                         XMLNode *before;
2448                                         bool got_some;
2449
2450                                         before = &(playlist->get_state());
2451                                         got_some = false;
2452
2453                                         /* XXX need to consider musical time selections here at some point */
2454
2455                                         double speed = atv->get_diskstream()->speed();
2456
2457
2458                                         for (list<AudioRange>::const_iterator t = ts.begin(); t != ts.end(); ++t) {
2459
2460                                                 sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
2461                                                 latest_regionviews.clear ();
2462
2463                                                 playlist->partition ((nframes_t)((*t).start * speed), (nframes_t)((*t).end * speed), true);
2464
2465                                                 c.disconnect ();
2466
2467                                                 if (!latest_regionviews.empty()) {
2468
2469                                                         got_some = true;
2470
2471                                                         atv->view()->foreach_regionview (bind (sigc::ptr_fun (add_if_covered), &(*t), &new_selection));
2472
2473                                                         if (!in_command) {
2474                                                                 begin_reversible_command (_("separate"));
2475                                                                 in_command = true;
2476                                                         }
2477
2478                                                         session->add_command(new MementoCommand<Playlist>(*playlist, before, &playlist->get_state()));
2479
2480                                                 }
2481                                         }
2482
2483                                         if (!got_some) {
2484                                                 delete before;
2485                                         }
2486                                 }
2487                         }
2488                 }
2489         }
2490
2491         if (in_command) {
2492                 selection->set (new_selection);
2493                 set_mouse_mode (MouseObject);
2494
2495                 commit_reversible_command ();
2496         }
2497 }
2498
2499 void
2500 Editor::separate_region_from_selection ()
2501 {
2502         /* preferentially use *all* ranges in the time selection if we're in range mode
2503            to allow discontiguous operation, since get_edit_op_range() currently
2504            returns a single range.
2505         */
2506         if (mouse_mode == MouseRange && !selection->time.empty()) {
2507
2508                 separate_regions_between (selection->time);
2509
2510         } else {
2511
2512                 nframes64_t start;
2513                 nframes64_t end;
2514
2515                 if (get_edit_op_range (start, end)) {
2516
2517                         AudioRange ar (start, end, 1);
2518                         TimeSelection ts;
2519                         ts.push_back (ar);
2520
2521                         /* force track selection */
2522
2523                         ensure_entered_region_selected ();
2524
2525                         separate_regions_between (ts);
2526                 }
2527         }
2528 }
2529
2530 void
2531 Editor::separate_regions_using_location (Location& loc)
2532 {
2533         if (loc.is_mark()) {
2534                 return;
2535         }
2536
2537         AudioRange ar (loc.start(), loc.end(), 1);
2538         TimeSelection ts;
2539
2540         ts.push_back (ar);
2541
2542         separate_regions_between (ts);
2543 }
2544
2545 void
2546 Editor::crop_region_to_selection ()
2547 {
2548         ensure_entered_region_selected (true);
2549
2550         if (!selection->time.empty()) {
2551
2552                 crop_region_to (selection->time.start(), selection->time.end_frame());
2553
2554         } else {
2555
2556                 nframes64_t start;
2557                 nframes64_t end;
2558
2559                 if (get_edit_op_range (start, end)) {
2560                         crop_region_to (start, end);
2561                 }
2562         }
2563
2564 }
2565
2566 void
2567 Editor::crop_region_to (nframes_t start, nframes_t end)
2568 {
2569         vector<boost::shared_ptr<Playlist> > playlists;
2570         boost::shared_ptr<Playlist> playlist;
2571         TrackSelection* ts;
2572
2573         if (selection->tracks.empty()) {
2574                 ts = &track_views;
2575         } else {
2576                 sort_track_selection ();
2577                 ts = &selection->tracks;
2578         }
2579
2580         for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
2581
2582                 AudioTimeAxisView* atv;
2583
2584                 if ((atv = dynamic_cast<AudioTimeAxisView*> ((*i))) != 0) {
2585
2586                         if (atv->is_audio_track()) {
2587
2588                                 /* no edits to destructive tracks */
2589
2590                                 if (atv->audio_track()->audio_diskstream()->destructive()) {
2591                                         continue;
2592                                 }
2593
2594                                 if ((playlist = atv->playlist()) != 0) {
2595                                         playlists.push_back (playlist);
2596                                 }
2597                         }
2598                 }
2599         }
2600
2601         if (playlists.empty()) {
2602                 return;
2603         }
2604
2605         nframes_t the_start;
2606         nframes_t the_end;
2607         nframes_t cnt;
2608
2609         begin_reversible_command (_("trim to selection"));
2610
2611         for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
2612
2613                 boost::shared_ptr<Region> region;
2614
2615                 the_start = start;
2616
2617                 if ((region = (*i)->top_region_at(the_start)) == 0) {
2618                         continue;
2619                 }
2620
2621                 /* now adjust lengths to that we do the right thing
2622                    if the selection extends beyond the region
2623                 */
2624
2625                 the_start = max (the_start, region->position());
2626                 if (max_frames - the_start < region->length()) {
2627                         the_end = the_start + region->length() - 1;
2628                 } else {
2629                         the_end = max_frames;
2630                 }
2631                 the_end = min (end, the_end);
2632                 cnt = the_end - the_start + 1;
2633
2634                 XMLNode &before = (*i)->get_state();
2635                 region->trim_to (the_start, cnt, this);
2636                 XMLNode &after = (*i)->get_state();
2637                 session->add_command (new MementoCommand<Playlist>(*(*i), &before, &after));
2638         }
2639
2640         commit_reversible_command ();
2641 }
2642
2643 void
2644 Editor::region_fill_track ()
2645 {
2646         nframes_t end;
2647
2648         if (!session || selection->regions.empty()) {
2649                 return;
2650         }
2651
2652         end = session->current_end_frame ();
2653
2654         begin_reversible_command (_("region fill"));
2655
2656         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2657
2658                 boost::shared_ptr<Region> region ((*i)->region());
2659
2660                 // FIXME
2661                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(region);
2662                 if (!ar)
2663                         continue;
2664
2665                 boost::shared_ptr<Playlist> pl = region->playlist();
2666
2667                 if (end <= region->last_frame()) {
2668                         return;
2669                 }
2670
2671                 double times = (double) (end - region->last_frame()) / (double) region->length();
2672
2673                 if (times == 0) {
2674                         return;
2675                 }
2676
2677                 XMLNode &before = pl->get_state();
2678                 pl->add_region (RegionFactory::create (ar), ar->last_frame(), times);
2679                 session->add_command (new MementoCommand<Playlist>(*pl, &before, &pl->get_state()));
2680         }
2681
2682         commit_reversible_command ();
2683 }
2684
2685 void
2686 Editor::region_fill_selection ()
2687 {
2688         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
2689                 return;
2690         }
2691
2692         if (selection->time.empty()) {
2693                 return;
2694         }
2695
2696
2697         Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
2698
2699         if (selected->count_selected_rows() != 1) {
2700                 return;
2701         }
2702
2703         TreeModel::iterator i = region_list_display.get_selection()->get_selected();
2704         boost::shared_ptr<Region> region = (*i)[region_list_columns.region];
2705
2706         nframes_t start = selection->time[clicked_selection].start;
2707         nframes_t end = selection->time[clicked_selection].end;
2708
2709         boost::shared_ptr<Playlist> playlist;
2710
2711         if (selection->tracks.empty()) {
2712                 return;
2713         }
2714
2715         nframes_t selection_length = end - start;
2716         float times = (float)selection_length / region->length();
2717
2718         begin_reversible_command (_("fill selection"));
2719
2720         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2721
2722                 if ((playlist = (*i)->playlist()) == 0) {
2723                         continue;
2724                 }
2725
2726                 XMLNode &before = playlist->get_state();
2727                 playlist->add_region (RegionFactory::create (region), start, times);
2728                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
2729         }
2730
2731         commit_reversible_command ();
2732 }
2733
2734 void
2735 Editor::set_region_sync_from_edit_point ()
2736 {
2737         nframes64_t where = get_preferred_edit_position ();
2738         ensure_entered_region_selected (true);
2739         set_sync_point (where, selection->regions);
2740 }
2741
2742 void
2743 Editor::set_sync_point (nframes64_t where, const RegionSelection& rs)
2744 {
2745         bool in_command = false;
2746
2747         for (RegionSelection::const_iterator r = rs.begin(); r != rs.end(); ++r) {
2748
2749                 if (!(*r)->region()->covers (where)) {
2750                         continue;
2751                 }
2752
2753                 boost::shared_ptr<Region> region ((*r)->region());
2754
2755                 if (!in_command) {
2756                         begin_reversible_command (_("set sync point"));
2757                         in_command = true;
2758                 }
2759
2760                 XMLNode &before = region->playlist()->get_state();
2761                 region->set_sync_position (get_preferred_edit_position());
2762                 XMLNode &after = region->playlist()->get_state();
2763                 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2764         }
2765
2766         if (in_command) {
2767                 commit_reversible_command ();
2768         }
2769 }
2770
2771 void
2772 Editor::remove_region_sync ()
2773 {
2774         if (clicked_regionview) {
2775                 boost::shared_ptr<Region> region (clicked_regionview->region());
2776                 begin_reversible_command (_("remove sync"));
2777                 XMLNode &before = region->playlist()->get_state();
2778                 region->clear_sync_position ();
2779                 XMLNode &after = region->playlist()->get_state();
2780                 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2781                 commit_reversible_command ();
2782         }
2783 }
2784
2785 void
2786 Editor::naturalize ()
2787 {
2788         if (selection->regions.empty()) {
2789                 return;
2790         }
2791         begin_reversible_command (_("naturalize"));
2792         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2793                 XMLNode &before = (*i)->region()->get_state();
2794                 (*i)->region()->move_to_natural_position (this);
2795                 XMLNode &after = (*i)->region()->get_state();
2796                 session->add_command (new MementoCommand<Region>(*((*i)->region().get()), &before, &after));
2797         }
2798         commit_reversible_command ();
2799 }
2800
2801 void
2802 Editor::align (RegionPoint what)
2803 {
2804         ensure_entered_region_selected ();
2805
2806         nframes64_t where = get_preferred_edit_position();
2807
2808         if (!selection->regions.empty()) {
2809                 align_selection (what, where, selection->regions);
2810         } else {
2811
2812                 RegionSelection rs;
2813                 rs = get_regions_at (where, selection->tracks);
2814                 align_selection (what, where, rs);
2815         }
2816 }
2817
2818 void
2819 Editor::align_relative (RegionPoint what)
2820 {
2821         nframes64_t where = get_preferred_edit_position();
2822
2823         if (!selection->regions.empty()) {
2824                 align_selection_relative (what, where, selection->regions);
2825         } else {
2826
2827                 RegionSelection rs;
2828                 rs = get_regions_at (where, selection->tracks);
2829                 align_selection_relative (what, where, rs);
2830         }
2831 }
2832
2833 struct RegionSortByTime {
2834     bool operator() (const AudioRegionView* a, const AudioRegionView* b) {
2835             return a->region()->position() < b->region()->position();
2836     }
2837 };
2838
2839 void
2840 Editor::align_selection_relative (RegionPoint point, nframes_t position, const RegionSelection& rs)
2841 {
2842         if (rs.empty()) {
2843                 return;
2844         }
2845
2846         nframes_t distance;
2847         nframes_t pos = 0;
2848         int dir;
2849
2850         list<RegionView*> sorted;
2851         rs.by_position (sorted);
2852         boost::shared_ptr<Region> r ((*sorted.begin())->region());
2853
2854         switch (point) {
2855         case Start:
2856                 pos = r->first_frame ();
2857                 break;
2858
2859         case End:
2860                 pos = r->last_frame();
2861                 break;
2862
2863         case SyncPoint:
2864                 pos = r->adjust_to_sync (r->first_frame());
2865                 break;
2866         }
2867
2868         if (pos > position) {
2869                 distance = pos - position;
2870                 dir = -1;
2871         } else {
2872                 distance = position - pos;
2873                 dir = 1;
2874         }
2875
2876         begin_reversible_command (_("align selection (relative)"));
2877
2878         for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
2879
2880                 boost::shared_ptr<Region> region ((*i)->region());
2881
2882                 XMLNode &before = region->playlist()->get_state();
2883
2884                 if (dir > 0) {
2885                         region->set_position (region->position() + distance, this);
2886                 } else {
2887                         region->set_position (region->position() - distance, this);
2888                 }
2889
2890                 XMLNode &after = region->playlist()->get_state();
2891                 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2892
2893         }
2894
2895         commit_reversible_command ();
2896 }
2897
2898 void
2899 Editor::align_selection (RegionPoint point, nframes_t position, const RegionSelection& rs)
2900 {
2901         if (rs.empty()) {
2902                 return;
2903         }
2904
2905         begin_reversible_command (_("align selection"));
2906
2907         for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
2908                 align_region_internal ((*i)->region(), point, position);
2909         }
2910
2911         commit_reversible_command ();
2912 }
2913
2914 void
2915 Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
2916 {
2917         begin_reversible_command (_("align region"));
2918         align_region_internal (region, point, position);
2919         commit_reversible_command ();
2920 }
2921
2922 void
2923 Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
2924 {
2925         XMLNode &before = region->playlist()->get_state();
2926
2927         switch (point) {
2928         case SyncPoint:
2929                 region->set_position (region->adjust_to_sync (position), this);
2930                 break;
2931
2932         case End:
2933                 if (position > region->length()) {
2934                         region->set_position (position - region->length(), this);
2935                 }
2936                 break;
2937
2938         case Start:
2939                 region->set_position (position, this);
2940                 break;
2941         }
2942
2943         XMLNode &after = region->playlist()->get_state();
2944         session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2945 }
2946
2947 void
2948 Editor::trim_region_to_loop ()
2949 {
2950         Location* loc = session->locations()->auto_loop_location();
2951         if (!loc) {
2952                 return;
2953         }
2954         trim_region_to_location (*loc, _("trim to loop"));
2955 }
2956
2957 void
2958 Editor::trim_region_to_punch ()
2959 {
2960         Location* loc = session->locations()->auto_punch_location();
2961         if (!loc) {
2962                 return;
2963         }
2964         trim_region_to_location (*loc, _("trim to punch"));
2965 }
2966
2967 void
2968 Editor::trim_region_to_location (const Location& loc, const char* str)
2969 {
2970         ensure_entered_region_selected ();
2971
2972         RegionSelection& rs (get_regions_for_action ());
2973
2974         begin_reversible_command (str);
2975
2976         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
2977                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
2978
2979                 if (!arv) {
2980                         continue;
2981                 }
2982
2983                 /* require region to span proposed trim */
2984
2985                 switch (arv->region()->coverage (loc.start(), loc.end())) {
2986                 case OverlapInternal:
2987                         break;
2988                 default:
2989                         continue;
2990                 }
2991
2992                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
2993
2994                 if (!atav) {
2995                         return;
2996                 }
2997
2998                 float speed = 1.0;
2999                 nframes_t start;
3000                 nframes_t end;
3001
3002                 if (atav->get_diskstream() != 0) {
3003                         speed = atav->get_diskstream()->speed();
3004                 }
3005
3006                 start = session_frame_to_track_frame (loc.start(), speed);
3007                 end = session_frame_to_track_frame (loc.end(), speed);
3008
3009                 XMLNode &before = arv->region()->playlist()->get_state();
3010                 arv->region()->trim_to (start, (end - start), this);
3011                 XMLNode &after = arv->region()->playlist()->get_state();
3012                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3013         }
3014
3015         commit_reversible_command ();
3016 }
3017
3018 void
3019 Editor::trim_region_to_edit_point ()
3020 {
3021         RegionSelection& rs (get_regions_for_action ());
3022         nframes64_t where = get_preferred_edit_position();
3023
3024         begin_reversible_command (_("trim region start to edit point"));
3025
3026         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3027                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3028
3029                 if (!arv) {
3030                         continue;
3031                 }
3032
3033                 /* require region to cover trim */
3034
3035                 if (!arv->region()->covers (where)) {
3036                         continue;
3037                 }
3038
3039                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3040
3041                 if (!atav) {
3042                         return;
3043                 }
3044
3045                 float speed = 1.0;
3046
3047                 if (atav->get_diskstream() != 0) {
3048                         speed = atav->get_diskstream()->speed();
3049                 }
3050
3051                 XMLNode &before = arv->region()->playlist()->get_state();
3052                 arv->region()->trim_end( session_frame_to_track_frame(where, speed), this);
3053                 XMLNode &after = arv->region()->playlist()->get_state();
3054                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3055         }
3056
3057         commit_reversible_command ();
3058 }
3059
3060 void
3061 Editor::trim_region_from_edit_point ()
3062 {
3063         RegionSelection& rs (get_regions_for_action ());
3064         nframes64_t where = get_preferred_edit_position();
3065
3066         begin_reversible_command (_("trim region end to edit point"));
3067
3068         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3069                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3070
3071                 if (!arv) {
3072                         continue;
3073                 }
3074
3075                 /* require region to cover trim */
3076
3077                 if (!arv->region()->covers (where)) {
3078                         continue;
3079                 }
3080
3081                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3082
3083                 if (!atav) {
3084                         return;
3085                 }
3086
3087                 float speed = 1.0;
3088
3089                 if (atav->get_diskstream() != 0) {
3090                         speed = atav->get_diskstream()->speed();
3091                 }
3092
3093                 XMLNode &before = arv->region()->playlist()->get_state();
3094                 arv->region()->trim_front ( session_frame_to_track_frame(where, speed), this);
3095                 XMLNode &after = arv->region()->playlist()->get_state();
3096                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3097         }
3098
3099         commit_reversible_command ();
3100 }
3101
3102 void
3103 Editor::unfreeze_route ()
3104 {
3105         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
3106                 return;
3107         }
3108
3109         clicked_audio_trackview->audio_track()->unfreeze ();
3110 }
3111
3112 void*
3113 Editor::_freeze_thread (void* arg)
3114 {
3115         PBD::ThreadCreated (pthread_self(), X_("Freeze"));
3116         return static_cast<Editor*>(arg)->freeze_thread ();
3117 }
3118
3119 void*
3120 Editor::freeze_thread ()
3121 {
3122         clicked_audio_trackview->audio_track()->freeze (*current_interthread_info);
3123         return 0;
3124 }
3125
3126 gint
3127 Editor::freeze_progress_timeout (void *arg)
3128 {
3129         interthread_progress_bar.set_fraction (current_interthread_info->progress/100);
3130         return !(current_interthread_info->done || current_interthread_info->cancel);
3131 }
3132
3133 void
3134 Editor::freeze_route ()
3135 {
3136         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
3137                 return;
3138         }
3139
3140         InterThreadInfo itt;
3141
3142         if (interthread_progress_window == 0) {
3143                 build_interthread_progress_window ();
3144         }
3145
3146         WindowTitle title(Glib::get_application_name());
3147         title += _("Freeze");
3148         interthread_progress_window->set_title (title.get_string());
3149         interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
3150         interthread_progress_window->show_all ();
3151         interthread_progress_bar.set_fraction (0.0f);
3152         interthread_progress_label.set_text ("");
3153         interthread_cancel_label.set_text (_("Cancel Freeze"));
3154         current_interthread_info = &itt;
3155
3156         interthread_progress_connection =
3157           Glib::signal_timeout().connect (bind (mem_fun(*this, &Editor::freeze_progress_timeout), (gpointer) 0), 100);
3158
3159         itt.done = false;
3160         itt.cancel = false;
3161         itt.progress = 0.0f;
3162
3163         pthread_attr_t attr;
3164         pthread_attr_init(&attr);
3165         pthread_attr_setstacksize(&attr, 500000);
3166
3167         pthread_create (&itt.thread, &attr, _freeze_thread, this);
3168
3169         pthread_attr_destroy(&attr);
3170
3171         track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
3172
3173         while (!itt.done && !itt.cancel) {
3174                 gtk_main_iteration ();
3175         }
3176
3177         interthread_progress_connection.disconnect ();
3178         interthread_progress_window->hide_all ();
3179         current_interthread_info = 0;
3180         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3181 }
3182
3183 void
3184 Editor::bounce_range_selection ()
3185 {
3186         if (selection->time.empty()) {
3187                 return;
3188         }
3189
3190         TrackSelection views = selection->tracks;
3191
3192         nframes_t start = selection->time[clicked_selection].start;
3193         nframes_t end = selection->time[clicked_selection].end;
3194         nframes_t cnt = end - start + 1;
3195
3196         begin_reversible_command (_("bounce range"));
3197
3198         for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
3199
3200                 AudioTimeAxisView* atv;
3201
3202                 if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) == 0) {
3203                         continue;
3204                 }
3205
3206                 boost::shared_ptr<Playlist> playlist;
3207
3208                 if ((playlist = atv->playlist()) == 0) {
3209                         return;
3210                 }
3211
3212                 InterThreadInfo itt;
3213
3214                 itt.done = false;
3215                 itt.cancel = false;
3216                 itt.progress = false;
3217
3218                 XMLNode &before = playlist->get_state();
3219                 atv->audio_track()->bounce_range (start, cnt, itt);
3220                 XMLNode &after = playlist->get_state();
3221                 session->add_command (new MementoCommand<Playlist> (*playlist, &before, &after));
3222         }
3223
3224         commit_reversible_command ();
3225 }
3226
3227 void
3228 Editor::cut ()
3229 {
3230         cut_copy (Cut);
3231 }
3232
3233 void
3234 Editor::copy ()
3235 {
3236         cut_copy (Copy);
3237 }
3238
3239 void
3240 Editor::cut_copy (CutCopyOp op)
3241 {
3242         /* only cancel selection if cut/copy is successful.*/
3243
3244         string opname;
3245
3246         switch (op) {
3247         case Cut:
3248                 opname = _("cut");
3249                 break;
3250         case Copy:
3251                 opname = _("copy");
3252                 break;
3253         case Clear:
3254                 opname = _("clear");
3255                 break;
3256         }
3257
3258         cut_buffer->clear ();
3259
3260         if (entered_marker) {
3261
3262                 /* cut/delete op while pointing at a marker */
3263
3264                 bool ignored;
3265                 Location* loc = find_location_from_marker (entered_marker, ignored);
3266
3267                 if (session && loc) {
3268                         Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::really_remove_marker), loc));
3269                 }
3270
3271                 return;
3272         }
3273
3274         switch (current_mouse_mode()) {
3275         case MouseObject:
3276                 cerr << "cutting in object mode\n";
3277                 if (!selection->regions.empty() || !selection->points.empty()) {
3278
3279                         begin_reversible_command (opname + _(" objects"));
3280
3281                         if (!selection->regions.empty()) {
3282                                 cerr << "have regions to cut" << endl;
3283                                 cut_copy_regions (op);
3284
3285                                 if (op == Cut) {
3286                                         selection->clear_regions ();
3287                                 }
3288                         }
3289
3290                         if (!selection->points.empty()) {
3291                                 cut_copy_points (op);
3292
3293                                 if (op == Cut) {
3294                                         selection->clear_points ();
3295                                 }
3296                         }
3297
3298                         commit_reversible_command ();
3299                         break; // terminate case statement here
3300                 }
3301                 cerr << "nope, now cutting time range" << endl;
3302                 if (!selection->time.empty()) {
3303                         /* don't cause suprises */
3304                         break;
3305                 }
3306                 // fall thru if there was nothing selected
3307
3308         case MouseRange:
3309                 if (selection->time.empty()) {
3310                         nframes64_t start, end;
3311                         cerr << "no time selection, get edit op range" << endl;
3312                         if (!get_edit_op_range (start, end)) {
3313                                 cerr << "no edit op range" << endl;
3314                                 return;
3315                         }
3316                         selection->set ((TimeAxisView*) 0, start, end);
3317                 }
3318
3319                 begin_reversible_command (opname + _(" range"));
3320                 cut_copy_ranges (op);
3321                 commit_reversible_command ();
3322
3323                 if (op == Cut) {
3324                         selection->clear_time ();
3325                 }
3326
3327                 break;
3328
3329         default:
3330                 break;
3331         }
3332 }
3333
3334 void
3335 Editor::cut_copy_points (CutCopyOp op)
3336 {
3337         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3338
3339                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
3340
3341                 if (atv) {
3342                         atv->cut_copy_clear_objects (selection->points, op);
3343                 }
3344         }
3345 }
3346
3347 struct PlaylistState {
3348     boost::shared_ptr<Playlist> playlist;
3349     XMLNode*  before;
3350 };
3351
3352 struct lt_playlist {
3353     bool operator () (const PlaylistState& a, const PlaylistState& b) {
3354             return a.playlist < b.playlist;
3355     }
3356 };
3357
3358 struct PlaylistMapping {
3359     TimeAxisView* tv;
3360     boost::shared_ptr<AudioPlaylist> pl;
3361
3362     PlaylistMapping (TimeAxisView* tvp) : tv (tvp) {}
3363 };
3364
3365 void
3366 Editor::cut_copy_regions (CutCopyOp op)
3367 {
3368         /* we can't use a std::map here because the ordering is important, and we can't trivially sort
3369            a map when we want ordered access to both elements. i think.
3370         */
3371
3372         vector<PlaylistMapping> pmap;
3373
3374         nframes_t first_position = max_frames;
3375
3376         set<PlaylistState, lt_playlist> freezelist;
3377         pair<set<PlaylistState, lt_playlist>::iterator,bool> insert_result;
3378
3379         /* get ordering correct before we cut/copy */
3380
3381         selection->regions.sort_by_position_and_track ();
3382
3383         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
3384
3385                 first_position = min ((*x)->region()->position(), first_position);
3386
3387                 if (op == Cut || op == Clear) {
3388                         boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist>((*x)->region()->playlist());
3389
3390                         if (pl) {
3391
3392                                 PlaylistState before;
3393                                 before.playlist = pl;
3394                                 before.before = &pl->get_state();
3395
3396                                 insert_result = freezelist.insert (before);
3397
3398                                 if (insert_result.second) {
3399                                         pl->freeze ();
3400                                 }
3401                         }
3402                 }
3403
3404                 TimeAxisView* tv = &(*x)->get_trackview();
3405                 vector<PlaylistMapping>::iterator z;
3406
3407                 for (z = pmap.begin(); z != pmap.end(); ++z) {
3408                         if ((*z).tv == tv) {
3409                                 break;
3410                         }
3411                 }
3412
3413                 if (z == pmap.end()) {
3414                         pmap.push_back (PlaylistMapping (tv));
3415                 }
3416         }
3417
3418         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ) {
3419
3420                 boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist>((*x)->region()->playlist());
3421
3422                 if (!pl) {
3423                         /* impossible, but this handles it for the future */
3424                         continue;
3425                 }
3426
3427                 TimeAxisView& tv = (*x)->get_trackview();
3428                 boost::shared_ptr<AudioPlaylist> npl;
3429                 RegionSelection::iterator tmp;
3430
3431                 tmp = x;
3432                 ++tmp;
3433
3434                 vector<PlaylistMapping>::iterator z;
3435
3436                 for (z = pmap.begin(); z != pmap.end(); ++z) {
3437                         if ((*z).tv == &tv) {
3438                                 break;
3439                         }
3440                 }
3441
3442                 assert (z != pmap.end());
3443
3444                 if (!(*z).pl) {
3445                         npl = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (*session, "cutlist", true));
3446                         npl->freeze();
3447                         (*z).pl = npl;
3448                 } else {
3449                         npl = (*z).pl;
3450                 }
3451
3452                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>((*x)->region());
3453                 boost::shared_ptr<Region> _xx;
3454
3455                 switch (op) {
3456                 case Cut:
3457                         if (!ar) break;
3458
3459                         _xx = RegionFactory::create ((*x)->region());
3460                         npl->add_region (_xx, (*x)->region()->position() - first_position);
3461                         pl->remove_region (((*x)->region()));
3462                         break;
3463
3464                 case Copy:
3465                         if (!ar) break;
3466
3467                         /* copy region before adding, so we're not putting same object into two different playlists */
3468                         npl->add_region (RegionFactory::create ((*x)->region()), (*x)->region()->position() - first_position);
3469                         break;
3470
3471                 case Clear:
3472                         pl->remove_region (((*x)->region()));
3473                         break;
3474                 }
3475
3476                 x = tmp;
3477         }
3478
3479         list<boost::shared_ptr<Playlist> > foo;
3480
3481         /* the pmap is in the same order as the tracks in which selected regions occured */
3482
3483         for (vector<PlaylistMapping>::iterator i = pmap.begin(); i != pmap.end(); ++i) {
3484                 (*i).pl->thaw();
3485                 foo.push_back ((*i).pl);
3486         }
3487
3488
3489         if (!foo.empty()) {
3490                 cut_buffer->set (foo);
3491         }
3492
3493         for (set<PlaylistState, lt_playlist>::iterator pl = freezelist.begin(); pl != freezelist.end(); ++pl) {
3494                 (*pl).playlist->thaw ();
3495                 session->add_command (new MementoCommand<Playlist>(*(*pl).playlist, (*pl).before, &(*pl).playlist->get_state()));
3496         }
3497 }
3498
3499 void
3500 Editor::cut_copy_ranges (CutCopyOp op)
3501 {
3502         TrackSelection* ts;
3503
3504         if (selection->tracks.empty()) {
3505                 ts = &track_views;
3506         } else {
3507                 ts = &selection->tracks;
3508         }
3509
3510         for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
3511                 (*i)->cut_copy_clear (*selection, op);
3512         }
3513 }
3514
3515 void
3516 Editor::paste (float times)
3517 {
3518         paste_internal (get_preferred_edit_position(), times);
3519 }
3520
3521 void
3522 Editor::mouse_paste ()
3523 {
3524         nframes64_t where;
3525         bool ignored;
3526
3527         if (!mouse_frame (where, ignored)) {
3528                 return;
3529         }
3530
3531         snap_to (where);
3532         paste_internal (where, 1);
3533 }
3534
3535 void
3536 Editor::paste_internal (nframes_t position, float times)
3537 {
3538         bool commit = false;
3539
3540         if (cut_buffer->empty()) {
3541                 return;
3542         }
3543
3544         if (position == max_frames) {
3545                 position = get_preferred_edit_position();
3546         }
3547
3548         begin_reversible_command (_("paste"));
3549
3550         TrackSelection ts;
3551         TrackSelection::iterator i;
3552         size_t nth;
3553
3554         /* get everything in the correct order */
3555
3556
3557         if (!selection->tracks.empty()) {
3558                 sort_track_selection ();
3559                 ts = selection->tracks;
3560         } else if (entered_track) {
3561                 ts.push_back (entered_track);
3562         }
3563
3564         for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
3565
3566                 /* undo/redo is handled by individual tracks */
3567
3568                 if ((*i)->paste (position, times, *cut_buffer, nth)) {
3569                         commit = true;
3570                 }
3571         }
3572
3573         if (commit) {
3574                 commit_reversible_command ();
3575         }
3576 }
3577
3578 void
3579 Editor::paste_named_selection (float times)
3580 {
3581         TrackSelection::iterator t;
3582
3583         Glib::RefPtr<TreeSelection> selected = named_selection_display.get_selection();
3584
3585         if (selected->count_selected_rows() != 1 || selection->tracks.empty()) {
3586                 return;
3587         }
3588
3589         TreeModel::iterator i = selected->get_selected();
3590         NamedSelection* ns = (*i)[named_selection_columns.selection];
3591
3592         list<boost::shared_ptr<Playlist> >::iterator chunk;
3593         list<boost::shared_ptr<Playlist> >::iterator tmp;
3594
3595         chunk = ns->playlists.begin();
3596
3597         begin_reversible_command (_("paste chunk"));
3598
3599         sort_track_selection ();
3600
3601         for (t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
3602
3603                 AudioTimeAxisView* atv;
3604                 boost::shared_ptr<Playlist> pl;
3605                 boost::shared_ptr<AudioPlaylist> apl;
3606
3607                 if ((atv = dynamic_cast<AudioTimeAxisView*> (*t)) == 0) {
3608                         continue;
3609                 }
3610
3611                 if ((pl = atv->playlist()) == 0) {
3612                         continue;
3613                 }
3614
3615                 if ((apl = boost::dynamic_pointer_cast<AudioPlaylist> (pl)) == 0) {
3616                         continue;
3617                 }
3618
3619                 tmp = chunk;
3620                 ++tmp;
3621
3622                 XMLNode &before = apl->get_state();
3623                 apl->paste (*chunk, get_preferred_edit_position(), times);
3624                 session->add_command(new MementoCommand<AudioPlaylist>(*apl, &before, &apl->get_state()));
3625
3626                 if (tmp != ns->playlists.end()) {
3627                         chunk = tmp;
3628                 }
3629         }
3630
3631         commit_reversible_command();
3632 }
3633
3634 void
3635 Editor::duplicate_some_regions (RegionSelection& regions, float times)
3636 {
3637         boost::shared_ptr<Playlist> playlist;
3638         RegionSelection sel = regions; // clear (below) may  clear the argument list if its the current region selection
3639         RegionSelection foo;
3640
3641         begin_reversible_command (_("duplicate region"));
3642
3643         selection->clear_regions ();
3644
3645         for (RegionSelection::iterator i = sel.begin(); i != sel.end(); ++i) {
3646
3647                 boost::shared_ptr<Region> r ((*i)->region());
3648
3649                 TimeAxisView& tv = (*i)->get_time_axis_view();
3650                 AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (&tv);
3651
3652                 latest_regionviews.clear ();
3653                 sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
3654
3655                 playlist = (*i)->region()->playlist();
3656                 XMLNode &before = playlist->get_state();
3657                 playlist->duplicate (r, r->last_frame() + 1, times);
3658                 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
3659
3660                 c.disconnect ();
3661
3662                 foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
3663         }
3664
3665         commit_reversible_command ();
3666
3667         if (!foo.empty()) {
3668                 selection->set (foo);
3669         }
3670 }
3671
3672 void
3673 Editor::duplicate_selection (float times)
3674 {
3675         if (selection->time.empty() || selection->tracks.empty()) {
3676                 return;
3677         }
3678
3679         boost::shared_ptr<Playlist> playlist;
3680         vector<boost::shared_ptr<AudioRegion> > new_regions;
3681         vector<boost::shared_ptr<AudioRegion> >::iterator ri;
3682
3683         create_region_from_selection (new_regions);
3684
3685         if (new_regions.empty()) {
3686                 return;
3687         }
3688
3689         begin_reversible_command (_("duplicate selection"));
3690
3691         ri = new_regions.begin();
3692
3693         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3694                 if ((playlist = (*i)->playlist()) == 0) {
3695                         continue;
3696                 }
3697                 XMLNode &before = playlist->get_state();
3698                 playlist->duplicate (*ri, selection->time[clicked_selection].end, times);
3699                 XMLNode &after = playlist->get_state();
3700                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
3701
3702                 ++ri;
3703                 if (ri == new_regions.end()) {
3704                         --ri;
3705                 }
3706         }
3707
3708         commit_reversible_command ();
3709 }
3710
3711 void
3712 Editor::reset_point_selection ()
3713 {
3714         /* reset all selected points to the relevant default value */
3715
3716         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3717
3718                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
3719
3720                 if (atv) {
3721                         atv->reset_objects (selection->points);
3722                 }
3723         }
3724 }
3725
3726 void
3727 Editor::center_playhead ()
3728 {
3729         float page = canvas_width * frames_per_unit;
3730         center_screen_internal (playhead_cursor->current_frame, page);
3731 }
3732
3733 void
3734 Editor::center_edit_point ()
3735 {
3736         float page = canvas_width * frames_per_unit;
3737         center_screen_internal (get_preferred_edit_position(), page);
3738 }
3739
3740 void
3741 Editor::clear_playlist (boost::shared_ptr<Playlist> playlist)
3742 {
3743         begin_reversible_command (_("clear playlist"));
3744         XMLNode &before = playlist->get_state();
3745         playlist->clear ();
3746         XMLNode &after = playlist->get_state();
3747         session->add_command (new MementoCommand<Playlist>(*playlist.get(), &before, &after));
3748         commit_reversible_command ();
3749 }
3750
3751 void
3752 Editor::nudge_track (bool use_edit, bool forwards)
3753 {
3754         boost::shared_ptr<Playlist> playlist;
3755         nframes_t distance;
3756         nframes_t next_distance;
3757         nframes_t start;
3758
3759         if (use_edit) {
3760                 start = get_preferred_edit_position();
3761         } else {
3762                 start = 0;
3763         }
3764
3765         if ((distance = get_nudge_distance (start, next_distance)) == 0) {
3766                 return;
3767         }
3768
3769         if (selection->tracks.empty()) {
3770                 return;
3771         }
3772
3773         begin_reversible_command (_("nudge track"));
3774
3775         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3776
3777                 if ((playlist = (*i)->playlist()) == 0) {
3778                         continue;
3779                 }
3780
3781                 XMLNode &before = playlist->get_state();
3782                 playlist->nudge_after (start, distance, forwards);
3783                 XMLNode &after = playlist->get_state();
3784                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
3785         }
3786
3787         commit_reversible_command ();
3788 }
3789
3790 void
3791 Editor::remove_last_capture ()
3792 {
3793         vector<string> choices;
3794         string prompt;
3795
3796         if (!session) {
3797                 return;
3798         }
3799
3800         if (Config->get_verify_remove_last_capture()) {
3801                 prompt  = _("Do you really want to destroy the last capture?"
3802                             "\n(This is destructive and cannot be undone)");
3803
3804                 choices.push_back (_("No, do nothing."));
3805                 choices.push_back (_("Yes, destroy it."));
3806
3807                 Gtkmm2ext::Choice prompter (prompt, choices);
3808
3809                 if (prompter.run () == 1) {
3810                         session->remove_last_capture ();
3811                 }
3812
3813         } else {
3814                 session->remove_last_capture();
3815         }
3816 }
3817
3818 void
3819 Editor::normalize_region ()
3820 {
3821         if (!session) {
3822                 return;
3823         }
3824
3825         if (selection->regions.empty()) {
3826                 return;
3827         }
3828
3829         begin_reversible_command (_("normalize"));
3830
3831         track_canvas.get_window()->set_cursor (*wait_cursor);
3832         gdk_flush ();
3833
3834         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
3835                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
3836                 if (!arv)
3837                         continue;
3838                 XMLNode &before = arv->region()->get_state();
3839                 arv->audio_region()->normalize_to (0.0f);
3840                 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
3841         }
3842
3843         commit_reversible_command ();
3844         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3845 }
3846
3847
3848 void
3849 Editor::denormalize_region ()
3850 {
3851         if (!session) {
3852                 return;
3853         }
3854
3855         if (selection->regions.empty()) {
3856                 return;
3857         }
3858
3859         begin_reversible_command ("denormalize");
3860
3861         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
3862                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
3863                 if (!arv)
3864                         continue;
3865                 XMLNode &before = arv->region()->get_state();
3866                 arv->audio_region()->set_scale_amplitude (1.0f);
3867                 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
3868         }
3869
3870         commit_reversible_command ();
3871 }
3872
3873
3874 void
3875 Editor::reverse_region ()
3876 {
3877         if (!session) {
3878                 return;
3879         }
3880
3881         Reverse rev (*session);
3882         apply_filter (rev, _("reverse regions"));
3883 }
3884
3885 void
3886 Editor::apply_filter (AudioFilter& filter, string command)
3887 {
3888         if (selection->regions.empty()) {
3889                 return;
3890         }
3891
3892         begin_reversible_command (command);
3893
3894         track_canvas.get_window()->set_cursor (*wait_cursor);
3895         gdk_flush ();
3896
3897         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ) {
3898                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
3899                 if (!arv)
3900                         continue;
3901
3902                 boost::shared_ptr<Playlist> playlist = arv->region()->playlist();
3903
3904                 RegionSelection::iterator tmp;
3905
3906                 tmp = r;
3907                 ++tmp;
3908
3909                 if (arv->audio_region()->apply (filter) == 0) {
3910
3911                         XMLNode &before = playlist->get_state();
3912                         playlist->replace_region (arv->region(), filter.results.front(), arv->region()->position());
3913                         XMLNode &after = playlist->get_state();
3914                         session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
3915                 } else {
3916                         goto out;
3917                 }
3918
3919                 r = tmp;
3920         }
3921
3922         commit_reversible_command ();
3923         selection->regions.clear ();
3924
3925   out:
3926         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3927 }
3928
3929 void
3930 Editor::region_selection_op (void (Region::*pmf)(void))
3931 {
3932         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3933                 Region* region = (*i)->region().get();
3934                 (region->*pmf)();
3935         }
3936 }
3937
3938
3939 void
3940 Editor::region_selection_op (void (Region::*pmf)(void*), void *arg)
3941 {
3942         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3943                 Region* region = (*i)->region().get();
3944                 (region->*pmf)(arg);
3945         }
3946 }
3947
3948 void
3949 Editor::region_selection_op (void (Region::*pmf)(bool), bool yn)
3950 {
3951         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3952                 Region* region = (*i)->region().get();
3953                 (region->*pmf)(yn);
3954         }
3955 }
3956
3957 void
3958 Editor::external_edit_region ()
3959 {
3960         if (!clicked_regionview) {
3961                 return;
3962         }
3963
3964         /* more to come */
3965 }
3966
3967 void
3968 Editor::brush (nframes_t pos)
3969 {
3970         RegionSelection sel;
3971         snap_to (pos);
3972
3973         if (selection->regions.empty()) {
3974                 /* XXX get selection from region list */
3975         } else {
3976                 sel = selection->regions;
3977         }
3978
3979         if (sel.empty()) {
3980                 return;
3981         }
3982
3983         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3984                 mouse_brush_insert_region ((*i), pos);
3985         }
3986 }
3987
3988 void
3989 Editor::reset_region_gain_envelopes ()
3990 {
3991         if (!session || selection->regions.empty()) {
3992                 return;
3993         }
3994
3995         session->begin_reversible_command (_("reset region gain"));
3996
3997         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3998                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
3999                 if (arv) {
4000                         AutomationList& alist (arv->audio_region()->envelope());
4001                         XMLNode& before (alist.get_state());
4002
4003                         arv->audio_region()->set_default_envelope ();
4004                         session->add_command (new MementoCommand<AutomationList>(arv->audio_region()->envelope(), &before, &alist.get_state()));
4005                 }
4006         }
4007
4008         session->commit_reversible_command ();
4009 }
4010
4011 void
4012 Editor::toggle_gain_envelope_visibility ()
4013 {
4014         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4015                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4016                 if (arv) {
4017                         bool x = region_envelope_visible_item->get_active();
4018                         if (x != arv->envelope_visible()) {
4019                                 arv->set_envelope_visible (x);
4020                         }
4021                 }
4022         }
4023 }
4024
4025 void
4026 Editor::toggle_gain_envelope_active ()
4027 {
4028         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4029                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4030                 if (arv) {
4031                         bool x = region_envelope_active_item->get_active();
4032                         if (x != arv->audio_region()->envelope_active()) {
4033                                 arv->audio_region()->set_envelope_active (x);
4034                         }
4035                 }
4036         }
4037 }
4038
4039 void
4040 Editor::toggle_region_lock ()
4041 {
4042         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4043                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4044                 if (arv) {
4045                         bool x = region_lock_item->get_active();
4046                         if (x != arv->audio_region()->locked()) {
4047                                 arv->audio_region()->set_locked (x);
4048                         }
4049                 }
4050         }
4051 }
4052
4053 void
4054 Editor::toggle_region_mute ()
4055 {
4056         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4057                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4058                 if (arv) {
4059                         bool x = region_mute_item->get_active();
4060                         if (x != arv->audio_region()->muted()) {
4061                                 arv->audio_region()->set_muted (x);
4062                         }
4063                 }
4064         }
4065 }
4066
4067 void
4068 Editor::toggle_region_opaque ()
4069 {
4070         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4071                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4072                 if (arv) {
4073                         bool x = region_opaque_item->get_active();
4074                         if (x != arv->audio_region()->opaque()) {
4075                                 arv->audio_region()->set_opaque (x);
4076                         }
4077                 }
4078         }
4079 }
4080
4081 void
4082 Editor::set_fade_length (bool in)
4083 {
4084         ensure_entered_region_selected (true);
4085
4086         /* we need a region to measure the offset from the start */
4087
4088         RegionView* rv;
4089
4090         if (entered_regionview) {
4091                 rv = entered_regionview;
4092         } else if (!selection->regions.empty()) {
4093                 rv = selection->regions.front();
4094         } else {
4095                 return;
4096         }
4097
4098         nframes64_t pos = get_preferred_edit_position();
4099         nframes_t len;
4100         char* cmd;
4101
4102         if (in) {
4103                 if (pos <= rv->region()->position()) {
4104                         /* can't do it */
4105                         return;
4106                 }
4107                 len = pos - rv->region()->position();
4108                 cmd = _("set fade in length");
4109         } else {
4110                 if (pos >= rv->region()->last_frame()) {
4111                         /* can't do it */
4112                         return;
4113                 }
4114                 len = rv->region()->last_frame() - pos;
4115                 cmd = _("set fade out length");
4116         }
4117
4118         begin_reversible_command (cmd);
4119
4120         RegionSelection& rs (get_regions_for_action());
4121
4122         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4123                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4124
4125                 if (!tmp) {
4126                         return;
4127                 }
4128
4129                 AutomationList& alist = tmp->audio_region()->fade_in();
4130                 XMLNode &before = alist.get_state();
4131
4132                 if (in) {
4133                         tmp->audio_region()->set_fade_in_length (len);
4134                 } else {
4135                         tmp->audio_region()->set_fade_out_length (len);
4136                 }
4137
4138                 XMLNode &after = alist.get_state();
4139                 session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
4140         }
4141
4142         commit_reversible_command ();
4143 }
4144
4145
4146 void
4147 Editor::toggle_fade_active (bool in)
4148 {
4149         ensure_entered_region_selected (true);
4150
4151         if (selection->regions.empty()) {
4152                 return;
4153         }
4154
4155         const char* cmd = (in ? _("toggle fade in active") : _("toggle fade out active"));
4156
4157         begin_reversible_command (cmd);
4158
4159         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4160                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4161
4162                 if (!tmp) {
4163                         return;
4164                 }
4165
4166                 boost::shared_ptr<AudioRegion> region (tmp->audio_region());
4167
4168                 XMLNode &before = region->get_state();
4169
4170                 if (in) {
4171                         region->set_fade_in_active (!region->fade_in_active());
4172                 } else {
4173                         region->set_fade_out_active (!region->fade_out_active());
4174                 }
4175
4176                 XMLNode &after = region->get_state();
4177                 session->add_command(new MementoCommand<AudioRegion>(*region.get(), &before, &after));
4178         }
4179
4180         commit_reversible_command ();
4181 }
4182
4183 void
4184 Editor::set_fade_in_shape (AudioRegion::FadeShape shape)
4185 {
4186         begin_reversible_command (_("set fade in shape"));
4187
4188         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4189                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4190
4191                 if (!tmp) {
4192                         return;
4193                 }
4194
4195                 AutomationList& alist = tmp->audio_region()->fade_in();
4196                 XMLNode &before = alist.get_state();
4197
4198                 tmp->audio_region()->set_fade_in_shape (shape);
4199
4200                 XMLNode &after = alist.get_state();
4201                 session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
4202         }
4203
4204         commit_reversible_command ();
4205 }
4206
4207 void
4208 Editor::set_fade_out_shape (AudioRegion::FadeShape shape)
4209 {
4210         begin_reversible_command (_("set fade out shape"));
4211
4212         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4213                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4214
4215                 if (!tmp) {
4216                         return;
4217                 }
4218
4219                 AutomationList& alist = tmp->audio_region()->fade_out();
4220                 XMLNode &before = alist.get_state();
4221
4222                 tmp->audio_region()->set_fade_out_shape (shape);
4223
4224                 XMLNode &after = alist.get_state();
4225                 session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
4226         }
4227
4228         commit_reversible_command ();
4229 }
4230
4231 void
4232 Editor::set_fade_in_active (bool yn)
4233 {
4234         begin_reversible_command (_("set fade in active"));
4235
4236         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4237                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4238
4239                 if (!tmp) {
4240                         return;
4241                 }
4242
4243
4244                 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4245
4246                 XMLNode &before = ar->get_state();
4247
4248                 ar->set_fade_in_active (yn);
4249
4250                 XMLNode &after = ar->get_state();
4251                 session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
4252         }
4253 }
4254
4255 void
4256 Editor::set_fade_out_active (bool yn)
4257 {
4258         begin_reversible_command (_("set fade out active"));
4259
4260         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4261                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4262
4263                 if (!tmp) {
4264                         return;
4265                 }
4266
4267                 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4268
4269                 XMLNode &before = ar->get_state();
4270
4271                 ar->set_fade_out_active (yn);
4272
4273                 XMLNode &after = ar->get_state();
4274                 session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
4275         }
4276 }
4277
4278
4279 /** Update crossfade visibility after its configuration has been changed */
4280 void
4281 Editor::update_xfade_visibility ()
4282 {
4283         _xfade_visibility = Config->get_xfades_visible ();
4284
4285         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4286                 AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
4287                 if (v) {
4288                         if (_xfade_visibility) {
4289                                 v->show_all_xfades ();
4290                         } else {
4291                                 v->hide_all_xfades ();
4292                         }
4293                 }
4294         }
4295 }
4296
4297 void
4298 Editor::set_edit_point ()
4299 {
4300         nframes64_t where;
4301         bool ignored;
4302
4303         if (!mouse_frame (where, ignored)) {
4304                 return;
4305         }
4306
4307         snap_to (where);
4308
4309         if (selection->markers.empty()) {
4310
4311                 mouse_add_new_marker (where);
4312
4313         } else {
4314                 bool ignored;
4315
4316                 Location* loc = find_location_from_marker (selection->markers.front(), ignored);
4317
4318                 if (loc) {
4319                         loc->move_to (where);
4320                 }
4321         }
4322 }
4323
4324 void
4325 Editor::set_playhead_cursor ()
4326 {
4327         if (entered_marker) {
4328                 session->request_locate (entered_marker->position(), session->transport_rolling());
4329         } else {
4330                 nframes64_t where;
4331                 bool ignored;
4332
4333                 if (!mouse_frame (where, ignored)) {
4334                         return;
4335                 }
4336
4337                 snap_to (where);
4338
4339                 if (session) {
4340                         session->request_locate (where, session->transport_rolling());
4341                 }
4342         }
4343 }
4344
4345 void
4346 Editor::split ()
4347 {
4348         ensure_entered_region_selected ();
4349
4350         nframes64_t where = get_preferred_edit_position();
4351
4352         if (!selection->regions.empty()) {
4353
4354                 split_regions_at (where, selection->regions);
4355
4356         } else {
4357
4358                 RegionSelection rs;
4359                 rs = get_regions_at (where, selection->tracks);
4360                 split_regions_at (where, rs);
4361         }
4362 }
4363
4364 void
4365 Editor::ensure_entered_track_selected (bool op_really_wants_one_track_if_none_are_selected)
4366 {
4367         if (entered_track && mouse_mode == MouseObject) {
4368                 if (!selection->tracks.empty()) {
4369                         if (!selection->selected (entered_track)) {
4370                                 selection->add (entered_track);
4371                         }
4372                 } else {
4373                         /* there is no selection, but this operation requires/prefers selected objects */
4374
4375                         if (op_really_wants_one_track_if_none_are_selected) {
4376                                 selection->set (entered_track);
4377                         }
4378                 }
4379         }
4380 }
4381
4382 void
4383 Editor::ensure_entered_region_selected (bool op_really_wants_one_region_if_none_are_selected)
4384 {
4385         if (entered_regionview && mouse_mode == MouseObject) {
4386
4387                 /* heuristic:
4388
4389                    - if there is no existing selection, don't change it. the operation will thus apply to "all"
4390
4391                    - if there is an existing selection, but the entered regionview isn't in it, add it. this
4392                        avoids key-mouse ops on unselected regions from interfering with an existing selection,
4393                        but also means that the operation will apply to the pointed-at region.
4394                 */
4395
4396                 if (!selection->regions.empty()) {
4397                         if (find (selection->regions.begin(), selection->regions.end(), entered_regionview) != selection->regions.end()) {
4398                                 selection->add (entered_regionview);
4399                         }
4400                 } else {
4401                         /* there is no selection, but this operation requires/prefers selected objects */
4402
4403                         if (op_really_wants_one_region_if_none_are_selected) {
4404                                 selection->set (entered_regionview, false);
4405                         }
4406                 }
4407         }
4408 }
4409
4410 void
4411 Editor::trim_region_front ()
4412 {
4413         trim_region (true);
4414 }
4415
4416 void
4417 Editor::trim_region_back ()
4418 {
4419         trim_region (false);
4420 }
4421
4422 void
4423 Editor::trim_region (bool front)
4424 {
4425         nframes64_t where = get_preferred_edit_position();
4426         RegionSelection& rs = get_regions_for_action ();
4427
4428         if (rs.empty()) {
4429                 return;
4430         }
4431
4432         begin_reversible_command (front ? _("trim front") : _("trim back"));
4433
4434         for (list<RegionView*>::const_iterator i = rs.by_layer().begin(); i != rs.by_layer().end(); ++i) {
4435                 if (!(*i)->region()->locked()) {
4436                         boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
4437                         XMLNode &before = pl->get_state();
4438                         if (front) {
4439                                 (*i)->region()->trim_front (where, this);
4440                         } else {
4441                                 (*i)->region()->trim_end (where, this);
4442                         }
4443                         XMLNode &after = pl->get_state();
4444                         session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
4445                 }
4446         }
4447         commit_reversible_command ();
4448 }
4449
4450 struct EditorOrderRouteSorter {
4451     bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
4452             /* use of ">" forces the correct sort order */
4453             return a->order_key ("editor") < b->order_key ("editor");
4454     }
4455 };
4456
4457 void
4458 Editor::select_next_route()
4459 {
4460         if (selection->tracks.empty()) {
4461                 selection->set (track_views.front());
4462                 return;
4463         }
4464
4465         TimeAxisView* current = selection->tracks.front();
4466
4467         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4468                 if (*i == current) {
4469                         ++i;
4470                         if (i != track_views.end()) {
4471                                 selection->set (*i);
4472                         } else {
4473                                 selection->set (*(track_views.begin()));
4474                         }
4475                         break;
4476                 }
4477         }
4478 }
4479
4480 void
4481 Editor::select_prev_route()
4482 {
4483         if (selection->tracks.empty()) {
4484                 selection->set (track_views.front());
4485                 return;
4486         }
4487
4488         TimeAxisView* current = selection->tracks.front();
4489
4490         for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
4491                 if (*i == current) {
4492                         ++i;
4493                         if (i != track_views.rend()) {
4494                                 selection->set (*i);
4495                         } else {
4496                                 selection->set (*(track_views.rbegin()));
4497                         }
4498                         break;
4499                 }
4500         }
4501 }
4502
4503 void
4504 Editor::set_loop_from_selection (bool play)
4505 {
4506         if (session == 0 || selection->time.empty()) {
4507                 return;
4508         }
4509
4510         nframes_t start = selection->time[clicked_selection].start;
4511         nframes_t end = selection->time[clicked_selection].end;
4512
4513         set_loop_range (start, end,  _("set loop range from selection"));
4514
4515         if (play) {
4516                 session->request_play_loop (true);
4517                 session->request_locate (start, true);
4518         }
4519 }
4520
4521 void
4522 Editor::set_loop_from_edit_range (bool play)
4523 {
4524         if (session == 0) {
4525                 return;
4526         }
4527
4528         nframes64_t start;
4529         nframes64_t end;
4530
4531         if (!get_edit_op_range (start, end)) {
4532                 return;
4533         }
4534
4535         set_loop_range (start, end,  _("set loop range from edit range"));
4536
4537         if (play) {
4538                 session->request_play_loop (true);
4539                 session->request_locate (start, true);
4540         }
4541 }
4542
4543 void
4544 Editor::set_loop_from_region (bool play)
4545 {
4546         nframes64_t start = max_frames;
4547         nframes64_t end = 0;
4548
4549         ensure_entered_region_selected (true);
4550
4551         if (selection->regions.empty()) {
4552                 info << _("cannot set loop: no region selected") << endmsg;
4553                 return;
4554         }
4555
4556         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4557                 if ((*i)->region()->position() < start) {
4558                         start = (*i)->region()->position();
4559                 }
4560                 if ((*i)->region()->last_frame() + 1 > end) {
4561                         end = (*i)->region()->last_frame() + 1;
4562                 }
4563         }
4564
4565         set_loop_range (start, end, _("set loop range from region"));
4566
4567         if (play) {
4568                 session->request_play_loop (true);
4569                 session->request_locate (start, true);
4570         }
4571 }
4572
4573 void
4574 Editor::set_punch_from_selection ()
4575 {
4576         if (session == 0 || selection->time.empty()) {
4577                 return;
4578         }
4579
4580         nframes_t start = selection->time[clicked_selection].start;
4581         nframes_t end = selection->time[clicked_selection].end;
4582
4583         set_punch_range (start, end,  _("set punch range from selection"));
4584 }
4585
4586 void
4587 Editor::set_punch_from_edit_range ()
4588 {
4589         if (session == 0) {
4590                 return;
4591         }
4592
4593         nframes64_t start;
4594         nframes64_t end;
4595
4596         if (!get_edit_op_range (start, end)) {
4597                 return;
4598         }
4599
4600         set_punch_range (start, end,  _("set punch range from edit range"));
4601 }
4602