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         ensure_entered_region_selected (true);
2262
2263         if (selection->regions.empty()) {
2264                 return;
2265         }
2266
2267         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2268                 session->audition_region ((*i)->region());
2269                 /* XXX need to check if user requested stop between each one, but how? */
2270         }
2271 }
2272
2273 void
2274 Editor::audition_playlist_region_standalone (boost::shared_ptr<Region> region)
2275 {
2276         session->audition_region (region);
2277 }
2278
2279 void
2280 Editor::build_interthread_progress_window ()
2281 {
2282         interthread_progress_window = new ArdourDialog (X_("interthread progress"), true);
2283
2284         interthread_progress_bar.set_orientation (Gtk::PROGRESS_LEFT_TO_RIGHT);
2285
2286         interthread_progress_window->get_vbox()->pack_start (interthread_progress_label, false, false);
2287         interthread_progress_window->get_vbox()->pack_start (interthread_progress_bar,false, false);
2288
2289         // GTK2FIX: this button needs a modifiable label
2290
2291         Button* b = interthread_progress_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
2292         b->signal_clicked().connect (mem_fun(*this, &Editor::interthread_cancel_clicked));
2293
2294         interthread_cancel_button.add (interthread_cancel_label);
2295
2296         interthread_progress_window->set_default_size (200, 100);
2297 }
2298
2299 void
2300 Editor::interthread_cancel_clicked ()
2301 {
2302         if (current_interthread_info) {
2303                 current_interthread_info->cancel = true;
2304         }
2305 }
2306
2307 void
2308 Editor::region_from_selection ()
2309 {
2310         if (clicked_trackview == 0) {
2311                 return;
2312         }
2313
2314         if (selection->time.empty()) {
2315                 return;
2316         }
2317
2318         nframes_t start = selection->time[clicked_selection].start;
2319         nframes_t end = selection->time[clicked_selection].end;
2320
2321         nframes_t selection_cnt = end - start + 1;
2322
2323         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2324                 boost::shared_ptr<AudioRegion> current;
2325                 boost::shared_ptr<Region> current_r;
2326                 boost::shared_ptr<Playlist> pl;
2327
2328                 nframes_t internal_start;
2329                 string new_name;
2330
2331                 if ((pl = (*i)->playlist()) == 0) {
2332                         continue;
2333                 }
2334
2335                 if ((current_r = pl->top_region_at (start)) == 0) {
2336                         continue;
2337                 }
2338
2339                 current = boost::dynamic_pointer_cast<AudioRegion> (current_r);
2340                 // FIXME: audio only
2341                 if (current != 0) {
2342                         internal_start = start - current->position();
2343                         session->region_name (new_name, current->name(), true);
2344                         boost::shared_ptr<Region> region (RegionFactory::create (current, internal_start, selection_cnt, new_name));
2345                 }
2346         }
2347 }
2348
2349 void
2350 Editor::create_region_from_selection (vector<boost::shared_ptr<AudioRegion> >& new_regions)
2351 {
2352         if (selection->time.empty() || selection->tracks.empty()) {
2353                 return;
2354         }
2355
2356         nframes_t start = selection->time[clicked_selection].start;
2357         nframes_t end = selection->time[clicked_selection].end;
2358
2359         sort_track_selection ();
2360
2361         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2362
2363                 boost::shared_ptr<AudioRegion> current;
2364                 boost::shared_ptr<Region> current_r;
2365                 boost::shared_ptr<Playlist> playlist;
2366                 nframes_t internal_start;
2367                 string new_name;
2368
2369                 if ((playlist = (*i)->playlist()) == 0) {
2370                         continue;
2371                 }
2372
2373                 if ((current_r = playlist->top_region_at(start)) == 0) {
2374                         continue;
2375                 }
2376
2377                 if ((current = boost::dynamic_pointer_cast<AudioRegion>(current_r)) == 0) {
2378                         continue;
2379                 }
2380
2381                 internal_start = start - current->position();
2382                 session->region_name (new_name, current->name(), true);
2383
2384                 new_regions.push_back (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (current, internal_start, end - start + 1, new_name)));
2385         }
2386 }
2387
2388 void
2389 Editor::split_multichannel_region ()
2390 {
2391         if (selection->regions.empty()) {
2392                 return;
2393         }
2394
2395         vector<boost::shared_ptr<AudioRegion> > v;
2396
2397         for (list<RegionView*>::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
2398
2399                 AudioRegionView* arv = dynamic_cast<AudioRegionView*>(*x);
2400
2401                 if (!arv || arv->audio_region()->n_channels() < 2) {
2402                         continue;
2403                 }
2404
2405                 (arv)->audio_region()->separate_by_channel (*session, v);
2406         }
2407 }
2408
2409 void
2410 Editor::new_region_from_selection ()
2411 {
2412         region_from_selection ();
2413         cancel_selection ();
2414 }
2415
2416 static void
2417 add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
2418 {
2419         switch (rv->region()->coverage (ar->start, ar->end - 1)) {
2420         case OverlapNone:
2421                 break;
2422         default:
2423                 rs->push_back (rv);
2424         }
2425 }
2426
2427 void
2428 Editor::separate_regions_between (const TimeSelection& ts)
2429 {
2430         bool in_command = false;
2431         boost::shared_ptr<Playlist> playlist;
2432         RegionSelection new_selection;
2433
2434         sort_track_selection ();
2435
2436         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2437
2438                 AudioTimeAxisView* atv;
2439
2440                 if ((atv = dynamic_cast<AudioTimeAxisView*> ((*i))) != 0) {
2441
2442                         if (atv->is_audio_track()) {
2443
2444                                 /* no edits to destructive tracks */
2445
2446                                 if (atv->audio_track()->audio_diskstream()->destructive()) {
2447                                         continue;
2448                                 }
2449
2450                                 if ((playlist = atv->playlist()) != 0) {
2451
2452
2453                                         XMLNode *before;
2454                                         bool got_some;
2455
2456                                         before = &(playlist->get_state());
2457                                         got_some = false;
2458
2459                                         /* XXX need to consider musical time selections here at some point */
2460
2461                                         double speed = atv->get_diskstream()->speed();
2462
2463
2464                                         for (list<AudioRange>::const_iterator t = ts.begin(); t != ts.end(); ++t) {
2465
2466                                                 sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
2467                                                 latest_regionviews.clear ();
2468
2469                                                 playlist->partition ((nframes_t)((*t).start * speed), (nframes_t)((*t).end * speed), true);
2470
2471                                                 c.disconnect ();
2472
2473                                                 if (!latest_regionviews.empty()) {
2474
2475                                                         got_some = true;
2476
2477                                                         atv->view()->foreach_regionview (bind (sigc::ptr_fun (add_if_covered), &(*t), &new_selection));
2478
2479                                                         if (!in_command) {
2480                                                                 begin_reversible_command (_("separate"));
2481                                                                 in_command = true;
2482                                                         }
2483
2484                                                         session->add_command(new MementoCommand<Playlist>(*playlist, before, &playlist->get_state()));
2485
2486                                                 }
2487                                         }
2488
2489                                         if (!got_some) {
2490                                                 delete before;
2491                                         }
2492                                 }
2493                         }
2494                 }
2495         }
2496
2497         if (in_command) {
2498                 selection->set (new_selection);
2499                 set_mouse_mode (MouseObject);
2500
2501                 commit_reversible_command ();
2502         }
2503 }
2504
2505 void
2506 Editor::separate_region_from_selection ()
2507 {
2508         /* preferentially use *all* ranges in the time selection if we're in range mode
2509            to allow discontiguous operation, since get_edit_op_range() currently
2510            returns a single range.
2511         */
2512         if (mouse_mode == MouseRange && !selection->time.empty()) {
2513
2514                 separate_regions_between (selection->time);
2515
2516         } else {
2517
2518                 nframes64_t start;
2519                 nframes64_t end;
2520
2521                 if (get_edit_op_range (start, end)) {
2522
2523                         AudioRange ar (start, end, 1);
2524                         TimeSelection ts;
2525                         ts.push_back (ar);
2526
2527                         /* force track selection */
2528
2529                         ensure_entered_region_selected ();
2530
2531                         separate_regions_between (ts);
2532                 }
2533         }
2534 }
2535
2536 void
2537 Editor::separate_regions_using_location (Location& loc)
2538 {
2539         if (loc.is_mark()) {
2540                 return;
2541         }
2542
2543         AudioRange ar (loc.start(), loc.end(), 1);
2544         TimeSelection ts;
2545
2546         ts.push_back (ar);
2547
2548         separate_regions_between (ts);
2549 }
2550
2551 void
2552 Editor::crop_region_to_selection ()
2553 {
2554         ensure_entered_region_selected (true);
2555
2556         if (!selection->time.empty()) {
2557
2558                 crop_region_to (selection->time.start(), selection->time.end_frame());
2559
2560         } else {
2561
2562                 nframes64_t start;
2563                 nframes64_t end;
2564
2565                 if (get_edit_op_range (start, end)) {
2566                         crop_region_to (start, end);
2567                 }
2568         }
2569
2570 }
2571
2572 void
2573 Editor::crop_region_to (nframes_t start, nframes_t end)
2574 {
2575         vector<boost::shared_ptr<Playlist> > playlists;
2576         boost::shared_ptr<Playlist> playlist;
2577         TrackSelection* ts;
2578
2579         if (selection->tracks.empty()) {
2580                 ts = &track_views;
2581         } else {
2582                 sort_track_selection ();
2583                 ts = &selection->tracks;
2584         }
2585
2586         for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
2587
2588                 AudioTimeAxisView* atv;
2589
2590                 if ((atv = dynamic_cast<AudioTimeAxisView*> ((*i))) != 0) {
2591
2592                         if (atv->is_audio_track()) {
2593
2594                                 /* no edits to destructive tracks */
2595
2596                                 if (atv->audio_track()->audio_diskstream()->destructive()) {
2597                                         continue;
2598                                 }
2599
2600                                 if ((playlist = atv->playlist()) != 0) {
2601                                         playlists.push_back (playlist);
2602                                 }
2603                         }
2604                 }
2605         }
2606
2607         if (playlists.empty()) {
2608                 return;
2609         }
2610
2611         nframes_t the_start;
2612         nframes_t the_end;
2613         nframes_t cnt;
2614
2615         begin_reversible_command (_("trim to selection"));
2616
2617         for (vector<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
2618
2619                 boost::shared_ptr<Region> region;
2620
2621                 the_start = start;
2622
2623                 if ((region = (*i)->top_region_at(the_start)) == 0) {
2624                         continue;
2625                 }
2626
2627                 /* now adjust lengths to that we do the right thing
2628                    if the selection extends beyond the region
2629                 */
2630
2631                 the_start = max (the_start, region->position());
2632                 if (max_frames - the_start < region->length()) {
2633                         the_end = the_start + region->length() - 1;
2634                 } else {
2635                         the_end = max_frames;
2636                 }
2637                 the_end = min (end, the_end);
2638                 cnt = the_end - the_start + 1;
2639
2640                 XMLNode &before = (*i)->get_state();
2641                 region->trim_to (the_start, cnt, this);
2642                 XMLNode &after = (*i)->get_state();
2643                 session->add_command (new MementoCommand<Playlist>(*(*i), &before, &after));
2644         }
2645
2646         commit_reversible_command ();
2647 }
2648
2649 void
2650 Editor::region_fill_track ()
2651 {
2652         nframes_t end;
2653
2654         if (!session || selection->regions.empty()) {
2655                 return;
2656         }
2657
2658         end = session->current_end_frame ();
2659
2660         begin_reversible_command (_("region fill"));
2661
2662         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2663
2664                 boost::shared_ptr<Region> region ((*i)->region());
2665
2666                 // FIXME
2667                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(region);
2668                 if (!ar)
2669                         continue;
2670
2671                 boost::shared_ptr<Playlist> pl = region->playlist();
2672
2673                 if (end <= region->last_frame()) {
2674                         return;
2675                 }
2676
2677                 double times = (double) (end - region->last_frame()) / (double) region->length();
2678
2679                 if (times == 0) {
2680                         return;
2681                 }
2682
2683                 XMLNode &before = pl->get_state();
2684                 pl->add_region (RegionFactory::create (ar), ar->last_frame(), times);
2685                 session->add_command (new MementoCommand<Playlist>(*pl, &before, &pl->get_state()));
2686         }
2687
2688         commit_reversible_command ();
2689 }
2690
2691 void
2692 Editor::region_fill_selection ()
2693 {
2694         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
2695                 return;
2696         }
2697
2698         if (selection->time.empty()) {
2699                 return;
2700         }
2701
2702
2703         Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
2704
2705         if (selected->count_selected_rows() != 1) {
2706                 return;
2707         }
2708
2709         TreeModel::iterator i = region_list_display.get_selection()->get_selected();
2710         boost::shared_ptr<Region> region = (*i)[region_list_columns.region];
2711
2712         nframes_t start = selection->time[clicked_selection].start;
2713         nframes_t end = selection->time[clicked_selection].end;
2714
2715         boost::shared_ptr<Playlist> playlist;
2716
2717         if (selection->tracks.empty()) {
2718                 return;
2719         }
2720
2721         nframes_t selection_length = end - start;
2722         float times = (float)selection_length / region->length();
2723
2724         begin_reversible_command (_("fill selection"));
2725
2726         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2727
2728                 if ((playlist = (*i)->playlist()) == 0) {
2729                         continue;
2730                 }
2731
2732                 XMLNode &before = playlist->get_state();
2733                 playlist->add_region (RegionFactory::create (region), start, times);
2734                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
2735         }
2736
2737         commit_reversible_command ();
2738 }
2739
2740 void
2741 Editor::set_region_sync_from_edit_point ()
2742 {
2743         nframes64_t where = get_preferred_edit_position ();
2744         ensure_entered_region_selected (true);
2745         set_sync_point (where, selection->regions);
2746 }
2747
2748 void
2749 Editor::set_sync_point (nframes64_t where, const RegionSelection& rs)
2750 {
2751         bool in_command = false;
2752
2753         for (RegionSelection::const_iterator r = rs.begin(); r != rs.end(); ++r) {
2754
2755                 if (!(*r)->region()->covers (where)) {
2756                         continue;
2757                 }
2758
2759                 boost::shared_ptr<Region> region ((*r)->region());
2760
2761                 if (!in_command) {
2762                         begin_reversible_command (_("set sync point"));
2763                         in_command = true;
2764                 }
2765
2766                 XMLNode &before = region->playlist()->get_state();
2767                 region->set_sync_position (get_preferred_edit_position());
2768                 XMLNode &after = region->playlist()->get_state();
2769                 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2770         }
2771
2772         if (in_command) {
2773                 commit_reversible_command ();
2774         }
2775 }
2776
2777 void
2778 Editor::remove_region_sync ()
2779 {
2780         if (clicked_regionview) {
2781                 boost::shared_ptr<Region> region (clicked_regionview->region());
2782                 begin_reversible_command (_("remove sync"));
2783                 XMLNode &before = region->playlist()->get_state();
2784                 region->clear_sync_position ();
2785                 XMLNode &after = region->playlist()->get_state();
2786                 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2787                 commit_reversible_command ();
2788         }
2789 }
2790
2791 void
2792 Editor::naturalize ()
2793 {
2794         if (selection->regions.empty()) {
2795                 return;
2796         }
2797         begin_reversible_command (_("naturalize"));
2798         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
2799                 XMLNode &before = (*i)->region()->get_state();
2800                 (*i)->region()->move_to_natural_position (this);
2801                 XMLNode &after = (*i)->region()->get_state();
2802                 session->add_command (new MementoCommand<Region>(*((*i)->region().get()), &before, &after));
2803         }
2804         commit_reversible_command ();
2805 }
2806
2807 void
2808 Editor::align (RegionPoint what)
2809 {
2810         ensure_entered_region_selected ();
2811
2812         nframes64_t where = get_preferred_edit_position();
2813
2814         if (!selection->regions.empty()) {
2815                 align_selection (what, where, selection->regions);
2816         } else {
2817
2818                 RegionSelection rs;
2819                 rs = get_regions_at (where, selection->tracks);
2820                 align_selection (what, where, rs);
2821         }
2822 }
2823
2824 void
2825 Editor::align_relative (RegionPoint what)
2826 {
2827         nframes64_t where = get_preferred_edit_position();
2828
2829         if (!selection->regions.empty()) {
2830                 align_selection_relative (what, where, selection->regions);
2831         } else {
2832
2833                 RegionSelection rs;
2834                 rs = get_regions_at (where, selection->tracks);
2835                 align_selection_relative (what, where, rs);
2836         }
2837 }
2838
2839 struct RegionSortByTime {
2840     bool operator() (const AudioRegionView* a, const AudioRegionView* b) {
2841             return a->region()->position() < b->region()->position();
2842     }
2843 };
2844
2845 void
2846 Editor::align_selection_relative (RegionPoint point, nframes_t position, const RegionSelection& rs)
2847 {
2848         if (rs.empty()) {
2849                 return;
2850         }
2851
2852         nframes_t distance;
2853         nframes_t pos = 0;
2854         int dir;
2855
2856         list<RegionView*> sorted;
2857         rs.by_position (sorted);
2858         boost::shared_ptr<Region> r ((*sorted.begin())->region());
2859
2860         switch (point) {
2861         case Start:
2862                 pos = r->first_frame ();
2863                 break;
2864
2865         case End:
2866                 pos = r->last_frame();
2867                 break;
2868
2869         case SyncPoint:
2870                 pos = r->adjust_to_sync (r->first_frame());
2871                 break;
2872         }
2873
2874         if (pos > position) {
2875                 distance = pos - position;
2876                 dir = -1;
2877         } else {
2878                 distance = position - pos;
2879                 dir = 1;
2880         }
2881
2882         begin_reversible_command (_("align selection (relative)"));
2883
2884         for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
2885
2886                 boost::shared_ptr<Region> region ((*i)->region());
2887
2888                 XMLNode &before = region->playlist()->get_state();
2889
2890                 if (dir > 0) {
2891                         region->set_position (region->position() + distance, this);
2892                 } else {
2893                         region->set_position (region->position() - distance, this);
2894                 }
2895
2896                 XMLNode &after = region->playlist()->get_state();
2897                 session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2898
2899         }
2900
2901         commit_reversible_command ();
2902 }
2903
2904 void
2905 Editor::align_selection (RegionPoint point, nframes_t position, const RegionSelection& rs)
2906 {
2907         if (rs.empty()) {
2908                 return;
2909         }
2910
2911         begin_reversible_command (_("align selection"));
2912
2913         for (RegionSelection::const_iterator i = rs.begin(); i != rs.end(); ++i) {
2914                 align_region_internal ((*i)->region(), point, position);
2915         }
2916
2917         commit_reversible_command ();
2918 }
2919
2920 void
2921 Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
2922 {
2923         begin_reversible_command (_("align region"));
2924         align_region_internal (region, point, position);
2925         commit_reversible_command ();
2926 }
2927
2928 void
2929 Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
2930 {
2931         XMLNode &before = region->playlist()->get_state();
2932
2933         switch (point) {
2934         case SyncPoint:
2935                 region->set_position (region->adjust_to_sync (position), this);
2936                 break;
2937
2938         case End:
2939                 if (position > region->length()) {
2940                         region->set_position (position - region->length(), this);
2941                 }
2942                 break;
2943
2944         case Start:
2945                 region->set_position (position, this);
2946                 break;
2947         }
2948
2949         XMLNode &after = region->playlist()->get_state();
2950         session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
2951 }
2952
2953 void
2954 Editor::trim_region_to_loop ()
2955 {
2956         Location* loc = session->locations()->auto_loop_location();
2957         if (!loc) {
2958                 return;
2959         }
2960         trim_region_to_location (*loc, _("trim to loop"));
2961 }
2962
2963 void
2964 Editor::trim_region_to_punch ()
2965 {
2966         Location* loc = session->locations()->auto_punch_location();
2967         if (!loc) {
2968                 return;
2969         }
2970         trim_region_to_location (*loc, _("trim to punch"));
2971 }
2972
2973 void
2974 Editor::trim_region_to_location (const Location& loc, const char* str)
2975 {
2976         ensure_entered_region_selected ();
2977
2978         RegionSelection& rs (get_regions_for_action ());
2979
2980         begin_reversible_command (str);
2981
2982         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
2983                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
2984
2985                 if (!arv) {
2986                         continue;
2987                 }
2988
2989                 /* require region to span proposed trim */
2990
2991                 switch (arv->region()->coverage (loc.start(), loc.end())) {
2992                 case OverlapInternal:
2993                         break;
2994                 default:
2995                         continue;
2996                 }
2997
2998                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
2999
3000                 if (!atav) {
3001                         return;
3002                 }
3003
3004                 float speed = 1.0;
3005                 nframes_t start;
3006                 nframes_t end;
3007
3008                 if (atav->get_diskstream() != 0) {
3009                         speed = atav->get_diskstream()->speed();
3010                 }
3011
3012                 start = session_frame_to_track_frame (loc.start(), speed);
3013                 end = session_frame_to_track_frame (loc.end(), speed);
3014
3015                 XMLNode &before = arv->region()->playlist()->get_state();
3016                 arv->region()->trim_to (start, (end - start), this);
3017                 XMLNode &after = arv->region()->playlist()->get_state();
3018                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3019         }
3020
3021         commit_reversible_command ();
3022 }
3023
3024 void
3025 Editor::trim_region_to_edit_point ()
3026 {
3027         RegionSelection& rs (get_regions_for_action ());
3028         nframes64_t where = get_preferred_edit_position();
3029
3030         begin_reversible_command (_("trim region start to edit point"));
3031
3032         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3033                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3034
3035                 if (!arv) {
3036                         continue;
3037                 }
3038
3039                 /* require region to cover trim */
3040
3041                 if (!arv->region()->covers (where)) {
3042                         continue;
3043                 }
3044
3045                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3046
3047                 if (!atav) {
3048                         return;
3049                 }
3050
3051                 float speed = 1.0;
3052
3053                 if (atav->get_diskstream() != 0) {
3054                         speed = atav->get_diskstream()->speed();
3055                 }
3056
3057                 XMLNode &before = arv->region()->playlist()->get_state();
3058                 arv->region()->trim_end( session_frame_to_track_frame(where, speed), this);
3059                 XMLNode &after = arv->region()->playlist()->get_state();
3060                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3061         }
3062
3063         commit_reversible_command ();
3064 }
3065
3066 void
3067 Editor::trim_region_from_edit_point ()
3068 {
3069         RegionSelection& rs (get_regions_for_action ());
3070         nframes64_t where = get_preferred_edit_position();
3071
3072         begin_reversible_command (_("trim region end to edit point"));
3073
3074         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
3075                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*x);
3076
3077                 if (!arv) {
3078                         continue;
3079                 }
3080
3081                 /* require region to cover trim */
3082
3083                 if (!arv->region()->covers (where)) {
3084                         continue;
3085                 }
3086
3087                 AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
3088
3089                 if (!atav) {
3090                         return;
3091                 }
3092
3093                 float speed = 1.0;
3094
3095                 if (atav->get_diskstream() != 0) {
3096                         speed = atav->get_diskstream()->speed();
3097                 }
3098
3099                 XMLNode &before = arv->region()->playlist()->get_state();
3100                 arv->region()->trim_front ( session_frame_to_track_frame(where, speed), this);
3101                 XMLNode &after = arv->region()->playlist()->get_state();
3102                 session->add_command(new MementoCommand<Playlist>(*(arv->region()->playlist()), &before, &after));
3103         }
3104
3105         commit_reversible_command ();
3106 }
3107
3108 void
3109 Editor::unfreeze_route ()
3110 {
3111         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
3112                 return;
3113         }
3114
3115         clicked_audio_trackview->audio_track()->unfreeze ();
3116 }
3117
3118 void*
3119 Editor::_freeze_thread (void* arg)
3120 {
3121         PBD::ThreadCreated (pthread_self(), X_("Freeze"));
3122         return static_cast<Editor*>(arg)->freeze_thread ();
3123 }
3124
3125 void*
3126 Editor::freeze_thread ()
3127 {
3128         clicked_audio_trackview->audio_track()->freeze (*current_interthread_info);
3129         return 0;
3130 }
3131
3132 gint
3133 Editor::freeze_progress_timeout (void *arg)
3134 {
3135         interthread_progress_bar.set_fraction (current_interthread_info->progress/100);
3136         return !(current_interthread_info->done || current_interthread_info->cancel);
3137 }
3138
3139 void
3140 Editor::freeze_route ()
3141 {
3142         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
3143                 return;
3144         }
3145
3146         InterThreadInfo itt;
3147
3148         if (interthread_progress_window == 0) {
3149                 build_interthread_progress_window ();
3150         }
3151
3152         WindowTitle title(Glib::get_application_name());
3153         title += _("Freeze");
3154         interthread_progress_window->set_title (title.get_string());
3155         interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
3156         interthread_progress_window->show_all ();
3157         interthread_progress_bar.set_fraction (0.0f);
3158         interthread_progress_label.set_text ("");
3159         interthread_cancel_label.set_text (_("Cancel Freeze"));
3160         current_interthread_info = &itt;
3161
3162         interthread_progress_connection =
3163           Glib::signal_timeout().connect (bind (mem_fun(*this, &Editor::freeze_progress_timeout), (gpointer) 0), 100);
3164
3165         itt.done = false;
3166         itt.cancel = false;
3167         itt.progress = 0.0f;
3168
3169         pthread_attr_t attr;
3170         pthread_attr_init(&attr);
3171         pthread_attr_setstacksize(&attr, 500000);
3172
3173         pthread_create (&itt.thread, &attr, _freeze_thread, this);
3174
3175         pthread_attr_destroy(&attr);
3176
3177         track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
3178
3179         while (!itt.done && !itt.cancel) {
3180                 gtk_main_iteration ();
3181         }
3182
3183         interthread_progress_connection.disconnect ();
3184         interthread_progress_window->hide_all ();
3185         current_interthread_info = 0;
3186         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3187 }
3188
3189 void
3190 Editor::bounce_range_selection ()
3191 {
3192         if (selection->time.empty()) {
3193                 return;
3194         }
3195
3196         TrackSelection views = selection->tracks;
3197
3198         nframes_t start = selection->time[clicked_selection].start;
3199         nframes_t end = selection->time[clicked_selection].end;
3200         nframes_t cnt = end - start + 1;
3201
3202         begin_reversible_command (_("bounce range"));
3203
3204         for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
3205
3206                 AudioTimeAxisView* atv;
3207
3208                 if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) == 0) {
3209                         continue;
3210                 }
3211
3212                 boost::shared_ptr<Playlist> playlist;
3213
3214                 if ((playlist = atv->playlist()) == 0) {
3215                         return;
3216                 }
3217
3218                 InterThreadInfo itt;
3219
3220                 itt.done = false;
3221                 itt.cancel = false;
3222                 itt.progress = false;
3223
3224                 XMLNode &before = playlist->get_state();
3225                 atv->audio_track()->bounce_range (start, cnt, itt);
3226                 XMLNode &after = playlist->get_state();
3227                 session->add_command (new MementoCommand<Playlist> (*playlist, &before, &after));
3228         }
3229
3230         commit_reversible_command ();
3231 }
3232
3233 void
3234 Editor::cut ()
3235 {
3236         cut_copy (Cut);
3237 }
3238
3239 void
3240 Editor::copy ()
3241 {
3242         cut_copy (Copy);
3243 }
3244
3245 void
3246 Editor::cut_copy (CutCopyOp op)
3247 {
3248         /* only cancel selection if cut/copy is successful.*/
3249
3250         string opname;
3251
3252         switch (op) {
3253         case Cut:
3254                 opname = _("cut");
3255                 break;
3256         case Copy:
3257                 opname = _("copy");
3258                 break;
3259         case Clear:
3260                 opname = _("clear");
3261                 break;
3262         }
3263
3264         cut_buffer->clear ();
3265
3266         if (entered_marker) {
3267
3268                 /* cut/delete op while pointing at a marker */
3269
3270                 bool ignored;
3271                 Location* loc = find_location_from_marker (entered_marker, ignored);
3272
3273                 if (session && loc) {
3274                         Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::really_remove_marker), loc));
3275                 }
3276
3277                 return;
3278         }
3279
3280         switch (current_mouse_mode()) {
3281         case MouseObject:
3282                 cerr << "cutting in object mode\n";
3283                 if (!selection->regions.empty() || !selection->points.empty()) {
3284
3285                         begin_reversible_command (opname + _(" objects"));
3286
3287                         if (!selection->regions.empty()) {
3288                                 cerr << "have regions to cut" << endl;
3289                                 cut_copy_regions (op);
3290
3291                                 if (op == Cut) {
3292                                         selection->clear_regions ();
3293                                 }
3294                         }
3295
3296                         if (!selection->points.empty()) {
3297                                 cut_copy_points (op);
3298
3299                                 if (op == Cut) {
3300                                         selection->clear_points ();
3301                                 }
3302                         }
3303
3304                         commit_reversible_command ();
3305                         break; // terminate case statement here
3306                 }
3307                 cerr << "nope, now cutting time range" << endl;
3308                 if (!selection->time.empty()) {
3309                         /* don't cause suprises */
3310                         break;
3311                 }
3312                 // fall thru if there was nothing selected
3313
3314         case MouseRange:
3315                 if (selection->time.empty()) {
3316                         nframes64_t start, end;
3317                         cerr << "no time selection, get edit op range" << endl;
3318                         if (!get_edit_op_range (start, end)) {
3319                                 cerr << "no edit op range" << endl;
3320                                 return;
3321                         }
3322                         selection->set ((TimeAxisView*) 0, start, end);
3323                 }
3324
3325                 begin_reversible_command (opname + _(" range"));
3326                 cut_copy_ranges (op);
3327                 commit_reversible_command ();
3328
3329                 if (op == Cut) {
3330                         selection->clear_time ();
3331                 }
3332
3333                 break;
3334
3335         default:
3336                 break;
3337         }
3338 }
3339
3340 void
3341 Editor::cut_copy_points (CutCopyOp op)
3342 {
3343         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3344
3345                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
3346
3347                 if (atv) {
3348                         atv->cut_copy_clear_objects (selection->points, op);
3349                 }
3350         }
3351 }
3352
3353 struct PlaylistState {
3354     boost::shared_ptr<Playlist> playlist;
3355     XMLNode*  before;
3356 };
3357
3358 struct lt_playlist {
3359     bool operator () (const PlaylistState& a, const PlaylistState& b) {
3360             return a.playlist < b.playlist;
3361     }
3362 };
3363
3364 struct PlaylistMapping {
3365     TimeAxisView* tv;
3366     boost::shared_ptr<AudioPlaylist> pl;
3367
3368     PlaylistMapping (TimeAxisView* tvp) : tv (tvp) {}
3369 };
3370
3371 void
3372 Editor::cut_copy_regions (CutCopyOp op)
3373 {
3374         /* we can't use a std::map here because the ordering is important, and we can't trivially sort
3375            a map when we want ordered access to both elements. i think.
3376         */
3377
3378         vector<PlaylistMapping> pmap;
3379
3380         nframes_t first_position = max_frames;
3381
3382         set<PlaylistState, lt_playlist> freezelist;
3383         pair<set<PlaylistState, lt_playlist>::iterator,bool> insert_result;
3384
3385         /* get ordering correct before we cut/copy */
3386
3387         selection->regions.sort_by_position_and_track ();
3388
3389         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
3390
3391                 first_position = min ((*x)->region()->position(), first_position);
3392
3393                 if (op == Cut || op == Clear) {
3394                         boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist>((*x)->region()->playlist());
3395
3396                         if (pl) {
3397
3398                                 PlaylistState before;
3399                                 before.playlist = pl;
3400                                 before.before = &pl->get_state();
3401
3402                                 insert_result = freezelist.insert (before);
3403
3404                                 if (insert_result.second) {
3405                                         pl->freeze ();
3406                                 }
3407                         }
3408                 }
3409
3410                 TimeAxisView* tv = &(*x)->get_trackview();
3411                 vector<PlaylistMapping>::iterator z;
3412
3413                 for (z = pmap.begin(); z != pmap.end(); ++z) {
3414                         if ((*z).tv == tv) {
3415                                 break;
3416                         }
3417                 }
3418
3419                 if (z == pmap.end()) {
3420                         pmap.push_back (PlaylistMapping (tv));
3421                 }
3422         }
3423
3424         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ) {
3425
3426                 boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist>((*x)->region()->playlist());
3427
3428                 if (!pl) {
3429                         /* impossible, but this handles it for the future */
3430                         continue;
3431                 }
3432
3433                 TimeAxisView& tv = (*x)->get_trackview();
3434                 boost::shared_ptr<AudioPlaylist> npl;
3435                 RegionSelection::iterator tmp;
3436
3437                 tmp = x;
3438                 ++tmp;
3439
3440                 vector<PlaylistMapping>::iterator z;
3441
3442                 for (z = pmap.begin(); z != pmap.end(); ++z) {
3443                         if ((*z).tv == &tv) {
3444                                 break;
3445                         }
3446                 }
3447
3448                 assert (z != pmap.end());
3449
3450                 if (!(*z).pl) {
3451                         npl = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (*session, "cutlist", true));
3452                         npl->freeze();
3453                         (*z).pl = npl;
3454                 } else {
3455                         npl = (*z).pl;
3456                 }
3457
3458                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>((*x)->region());
3459                 boost::shared_ptr<Region> _xx;
3460
3461                 switch (op) {
3462                 case Cut:
3463                         if (!ar) break;
3464
3465                         _xx = RegionFactory::create ((*x)->region());
3466                         npl->add_region (_xx, (*x)->region()->position() - first_position);
3467                         pl->remove_region (((*x)->region()));
3468                         break;
3469
3470                 case Copy:
3471                         if (!ar) break;
3472
3473                         /* copy region before adding, so we're not putting same object into two different playlists */
3474                         npl->add_region (RegionFactory::create ((*x)->region()), (*x)->region()->position() - first_position);
3475                         break;
3476
3477                 case Clear:
3478                         pl->remove_region (((*x)->region()));
3479                         break;
3480                 }
3481
3482                 x = tmp;
3483         }
3484
3485         list<boost::shared_ptr<Playlist> > foo;
3486
3487         /* the pmap is in the same order as the tracks in which selected regions occured */
3488
3489         for (vector<PlaylistMapping>::iterator i = pmap.begin(); i != pmap.end(); ++i) {
3490                 (*i).pl->thaw();
3491                 foo.push_back ((*i).pl);
3492         }
3493
3494
3495         if (!foo.empty()) {
3496                 cut_buffer->set (foo);
3497         }
3498
3499         for (set<PlaylistState, lt_playlist>::iterator pl = freezelist.begin(); pl != freezelist.end(); ++pl) {
3500                 (*pl).playlist->thaw ();
3501                 session->add_command (new MementoCommand<Playlist>(*(*pl).playlist, (*pl).before, &(*pl).playlist->get_state()));
3502         }
3503 }
3504
3505 void
3506 Editor::cut_copy_ranges (CutCopyOp op)
3507 {
3508         TrackSelection* ts;
3509
3510         if (selection->tracks.empty()) {
3511                 ts = &track_views;
3512         } else {
3513                 ts = &selection->tracks;
3514         }
3515
3516         for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
3517                 (*i)->cut_copy_clear (*selection, op);
3518         }
3519 }
3520
3521 void
3522 Editor::paste (float times)
3523 {
3524         paste_internal (get_preferred_edit_position(), times);
3525 }
3526
3527 void
3528 Editor::mouse_paste ()
3529 {
3530         nframes64_t where;
3531         bool ignored;
3532
3533         if (!mouse_frame (where, ignored)) {
3534                 return;
3535         }
3536
3537         snap_to (where);
3538         paste_internal (where, 1);
3539 }
3540
3541 void
3542 Editor::paste_internal (nframes_t position, float times)
3543 {
3544         bool commit = false;
3545
3546         if (cut_buffer->empty()) {
3547                 return;
3548         }
3549
3550         if (position == max_frames) {
3551                 position = get_preferred_edit_position();
3552         }
3553
3554         begin_reversible_command (_("paste"));
3555
3556         TrackSelection ts;
3557         TrackSelection::iterator i;
3558         size_t nth;
3559
3560         /* get everything in the correct order */
3561
3562
3563         if (!selection->tracks.empty()) {
3564                 sort_track_selection ();
3565                 ts = selection->tracks;
3566         } else if (entered_track) {
3567                 ts.push_back (entered_track);
3568         }
3569
3570         for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
3571
3572                 /* undo/redo is handled by individual tracks */
3573
3574                 if ((*i)->paste (position, times, *cut_buffer, nth)) {
3575                         commit = true;
3576                 }
3577         }
3578
3579         if (commit) {
3580                 commit_reversible_command ();
3581         }
3582 }
3583
3584 void
3585 Editor::paste_named_selection (float times)
3586 {
3587         TrackSelection::iterator t;
3588
3589         Glib::RefPtr<TreeSelection> selected = named_selection_display.get_selection();
3590
3591         if (selected->count_selected_rows() != 1 || selection->tracks.empty()) {
3592                 return;
3593         }
3594
3595         TreeModel::iterator i = selected->get_selected();
3596         NamedSelection* ns = (*i)[named_selection_columns.selection];
3597
3598         list<boost::shared_ptr<Playlist> >::iterator chunk;
3599         list<boost::shared_ptr<Playlist> >::iterator tmp;
3600
3601         chunk = ns->playlists.begin();
3602
3603         begin_reversible_command (_("paste chunk"));
3604
3605         sort_track_selection ();
3606
3607         for (t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
3608
3609                 AudioTimeAxisView* atv;
3610                 boost::shared_ptr<Playlist> pl;
3611                 boost::shared_ptr<AudioPlaylist> apl;
3612
3613                 if ((atv = dynamic_cast<AudioTimeAxisView*> (*t)) == 0) {
3614                         continue;
3615                 }
3616
3617                 if ((pl = atv->playlist()) == 0) {
3618                         continue;
3619                 }
3620
3621                 if ((apl = boost::dynamic_pointer_cast<AudioPlaylist> (pl)) == 0) {
3622                         continue;
3623                 }
3624
3625                 tmp = chunk;
3626                 ++tmp;
3627
3628                 XMLNode &before = apl->get_state();
3629                 apl->paste (*chunk, get_preferred_edit_position(), times);
3630                 session->add_command(new MementoCommand<AudioPlaylist>(*apl, &before, &apl->get_state()));
3631
3632                 if (tmp != ns->playlists.end()) {
3633                         chunk = tmp;
3634                 }
3635         }
3636
3637         commit_reversible_command();
3638 }
3639
3640 void
3641 Editor::duplicate_some_regions (RegionSelection& regions, float times)
3642 {
3643         boost::shared_ptr<Playlist> playlist;
3644         RegionSelection sel = regions; // clear (below) may  clear the argument list if its the current region selection
3645         RegionSelection foo;
3646
3647         begin_reversible_command (_("duplicate region"));
3648
3649         selection->clear_regions ();
3650
3651         for (RegionSelection::iterator i = sel.begin(); i != sel.end(); ++i) {
3652
3653                 boost::shared_ptr<Region> r ((*i)->region());
3654
3655                 TimeAxisView& tv = (*i)->get_time_axis_view();
3656                 AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (&tv);
3657
3658                 latest_regionviews.clear ();
3659                 sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
3660
3661                 playlist = (*i)->region()->playlist();
3662                 XMLNode &before = playlist->get_state();
3663                 playlist->duplicate (r, r->last_frame() + 1, times);
3664                 session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
3665
3666                 c.disconnect ();
3667
3668                 foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
3669         }
3670
3671         commit_reversible_command ();
3672
3673         if (!foo.empty()) {
3674                 selection->set (foo);
3675         }
3676 }
3677
3678 void
3679 Editor::duplicate_selection (float times)
3680 {
3681         if (selection->time.empty() || selection->tracks.empty()) {
3682                 return;
3683         }
3684
3685         boost::shared_ptr<Playlist> playlist;
3686         vector<boost::shared_ptr<AudioRegion> > new_regions;
3687         vector<boost::shared_ptr<AudioRegion> >::iterator ri;
3688
3689         create_region_from_selection (new_regions);
3690
3691         if (new_regions.empty()) {
3692                 return;
3693         }
3694
3695         begin_reversible_command (_("duplicate selection"));
3696
3697         ri = new_regions.begin();
3698
3699         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3700                 if ((playlist = (*i)->playlist()) == 0) {
3701                         continue;
3702                 }
3703                 XMLNode &before = playlist->get_state();
3704                 playlist->duplicate (*ri, selection->time[clicked_selection].end, times);
3705                 XMLNode &after = playlist->get_state();
3706                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
3707
3708                 ++ri;
3709                 if (ri == new_regions.end()) {
3710                         --ri;
3711                 }
3712         }
3713
3714         commit_reversible_command ();
3715 }
3716
3717 void
3718 Editor::reset_point_selection ()
3719 {
3720         /* reset all selected points to the relevant default value */
3721
3722         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3723
3724                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
3725
3726                 if (atv) {
3727                         atv->reset_objects (selection->points);
3728                 }
3729         }
3730 }
3731
3732 void
3733 Editor::center_playhead ()
3734 {
3735         float page = canvas_width * frames_per_unit;
3736         center_screen_internal (playhead_cursor->current_frame, page);
3737 }
3738
3739 void
3740 Editor::center_edit_point ()
3741 {
3742         float page = canvas_width * frames_per_unit;
3743         center_screen_internal (get_preferred_edit_position(), page);
3744 }
3745
3746 void
3747 Editor::clear_playlist (boost::shared_ptr<Playlist> playlist)
3748 {
3749         begin_reversible_command (_("clear playlist"));
3750         XMLNode &before = playlist->get_state();
3751         playlist->clear ();
3752         XMLNode &after = playlist->get_state();
3753         session->add_command (new MementoCommand<Playlist>(*playlist.get(), &before, &after));
3754         commit_reversible_command ();
3755 }
3756
3757 void
3758 Editor::nudge_track (bool use_edit, bool forwards)
3759 {
3760         boost::shared_ptr<Playlist> playlist;
3761         nframes_t distance;
3762         nframes_t next_distance;
3763         nframes_t start;
3764
3765         if (use_edit) {
3766                 start = get_preferred_edit_position();
3767         } else {
3768                 start = 0;
3769         }
3770
3771         if ((distance = get_nudge_distance (start, next_distance)) == 0) {
3772                 return;
3773         }
3774
3775         if (selection->tracks.empty()) {
3776                 return;
3777         }
3778
3779         begin_reversible_command (_("nudge track"));
3780
3781         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3782
3783                 if ((playlist = (*i)->playlist()) == 0) {
3784                         continue;
3785                 }
3786
3787                 XMLNode &before = playlist->get_state();
3788                 playlist->nudge_after (start, distance, forwards);
3789                 XMLNode &after = playlist->get_state();
3790                 session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
3791         }
3792
3793         commit_reversible_command ();
3794 }
3795
3796 void
3797 Editor::remove_last_capture ()
3798 {
3799         vector<string> choices;
3800         string prompt;
3801
3802         if (!session) {
3803                 return;
3804         }
3805
3806         if (Config->get_verify_remove_last_capture()) {
3807                 prompt  = _("Do you really want to destroy the last capture?"
3808                             "\n(This is destructive and cannot be undone)");
3809
3810                 choices.push_back (_("No, do nothing."));
3811                 choices.push_back (_("Yes, destroy it."));
3812
3813                 Gtkmm2ext::Choice prompter (prompt, choices);
3814
3815                 if (prompter.run () == 1) {
3816                         session->remove_last_capture ();
3817                 }
3818
3819         } else {
3820                 session->remove_last_capture();
3821         }
3822 }
3823
3824 void
3825 Editor::normalize_region ()
3826 {
3827         if (!session) {
3828                 return;
3829         }
3830
3831         if (selection->regions.empty()) {
3832                 return;
3833         }
3834
3835         begin_reversible_command (_("normalize"));
3836
3837         track_canvas.get_window()->set_cursor (*wait_cursor);
3838         gdk_flush ();
3839
3840         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
3841                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
3842                 if (!arv)
3843                         continue;
3844                 XMLNode &before = arv->region()->get_state();
3845                 arv->audio_region()->normalize_to (0.0f);
3846                 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
3847         }
3848
3849         commit_reversible_command ();
3850         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3851 }
3852
3853
3854 void
3855 Editor::denormalize_region ()
3856 {
3857         if (!session) {
3858                 return;
3859         }
3860
3861         if (selection->regions.empty()) {
3862                 return;
3863         }
3864
3865         begin_reversible_command ("denormalize");
3866
3867         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ++r) {
3868                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
3869                 if (!arv)
3870                         continue;
3871                 XMLNode &before = arv->region()->get_state();
3872                 arv->audio_region()->set_scale_amplitude (1.0f);
3873                 session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
3874         }
3875
3876         commit_reversible_command ();
3877 }
3878
3879
3880 void
3881 Editor::reverse_region ()
3882 {
3883         if (!session) {
3884                 return;
3885         }
3886
3887         Reverse rev (*session);
3888         apply_filter (rev, _("reverse regions"));
3889 }
3890
3891 void
3892 Editor::apply_filter (AudioFilter& filter, string command)
3893 {
3894         if (selection->regions.empty()) {
3895                 return;
3896         }
3897
3898         begin_reversible_command (command);
3899
3900         track_canvas.get_window()->set_cursor (*wait_cursor);
3901         gdk_flush ();
3902
3903         for (RegionSelection::iterator r = selection->regions.begin(); r != selection->regions.end(); ) {
3904                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
3905                 if (!arv)
3906                         continue;
3907
3908                 boost::shared_ptr<Playlist> playlist = arv->region()->playlist();
3909
3910                 RegionSelection::iterator tmp;
3911
3912                 tmp = r;
3913                 ++tmp;
3914
3915                 if (arv->audio_region()->apply (filter) == 0) {
3916
3917                         XMLNode &before = playlist->get_state();
3918                         playlist->replace_region (arv->region(), filter.results.front(), arv->region()->position());
3919                         XMLNode &after = playlist->get_state();
3920                         session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
3921                 } else {
3922                         goto out;
3923                 }
3924
3925                 r = tmp;
3926         }
3927
3928         commit_reversible_command ();
3929         selection->regions.clear ();
3930
3931   out:
3932         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3933 }
3934
3935 void
3936 Editor::region_selection_op (void (Region::*pmf)(void))
3937 {
3938         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3939                 Region* region = (*i)->region().get();
3940                 (region->*pmf)();
3941         }
3942 }
3943
3944
3945 void
3946 Editor::region_selection_op (void (Region::*pmf)(void*), void *arg)
3947 {
3948         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3949                 Region* region = (*i)->region().get();
3950                 (region->*pmf)(arg);
3951         }
3952 }
3953
3954 void
3955 Editor::region_selection_op (void (Region::*pmf)(bool), bool yn)
3956 {
3957         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3958                 Region* region = (*i)->region().get();
3959                 (region->*pmf)(yn);
3960         }
3961 }
3962
3963 void
3964 Editor::external_edit_region ()
3965 {
3966         if (!clicked_regionview) {
3967                 return;
3968         }
3969
3970         /* more to come */
3971 }
3972
3973 void
3974 Editor::brush (nframes_t pos)
3975 {
3976         RegionSelection sel;
3977         snap_to (pos);
3978
3979         if (selection->regions.empty()) {
3980                 /* XXX get selection from region list */
3981         } else {
3982                 sel = selection->regions;
3983         }
3984
3985         if (sel.empty()) {
3986                 return;
3987         }
3988
3989         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
3990                 mouse_brush_insert_region ((*i), pos);
3991         }
3992 }
3993
3994 void
3995 Editor::reset_region_gain_envelopes ()
3996 {
3997         if (!session || selection->regions.empty()) {
3998                 return;
3999         }
4000
4001         session->begin_reversible_command (_("reset region gain"));
4002
4003         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4004                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4005                 if (arv) {
4006                         AutomationList& alist (arv->audio_region()->envelope());
4007                         XMLNode& before (alist.get_state());
4008
4009                         arv->audio_region()->set_default_envelope ();
4010                         session->add_command (new MementoCommand<AutomationList>(arv->audio_region()->envelope(), &before, &alist.get_state()));
4011                 }
4012         }
4013
4014         session->commit_reversible_command ();
4015 }
4016
4017 void
4018 Editor::toggle_gain_envelope_visibility ()
4019 {
4020         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4021                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4022                 if (arv) {
4023                         bool x = region_envelope_visible_item->get_active();
4024                         if (x != arv->envelope_visible()) {
4025                                 arv->set_envelope_visible (x);
4026                         }
4027                 }
4028         }
4029 }
4030
4031 void
4032 Editor::toggle_gain_envelope_active ()
4033 {
4034         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4035                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4036                 if (arv) {
4037                         bool x = region_envelope_active_item->get_active();
4038                         if (x != arv->audio_region()->envelope_active()) {
4039                                 arv->audio_region()->set_envelope_active (x);
4040                         }
4041                 }
4042         }
4043 }
4044
4045 void
4046 Editor::toggle_region_lock ()
4047 {
4048         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4049                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4050                 if (arv) {
4051                         bool x = region_lock_item->get_active();
4052                         if (x != arv->audio_region()->locked()) {
4053                                 arv->audio_region()->set_locked (x);
4054                         }
4055                 }
4056         }
4057 }
4058
4059 void
4060 Editor::toggle_region_mute ()
4061 {
4062         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4063                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4064                 if (arv) {
4065                         bool x = region_mute_item->get_active();
4066                         if (x != arv->audio_region()->muted()) {
4067                                 arv->audio_region()->set_muted (x);
4068                         }
4069                 }
4070         }
4071 }
4072
4073 void
4074 Editor::toggle_region_opaque ()
4075 {
4076         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4077                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4078                 if (arv) {
4079                         bool x = region_opaque_item->get_active();
4080                         if (x != arv->audio_region()->opaque()) {
4081                                 arv->audio_region()->set_opaque (x);
4082                         }
4083                 }
4084         }
4085 }
4086
4087 void
4088 Editor::set_fade_length (bool in)
4089 {
4090         ensure_entered_region_selected (true);
4091
4092         /* we need a region to measure the offset from the start */
4093
4094         RegionView* rv;
4095
4096         if (entered_regionview) {
4097                 rv = entered_regionview;
4098         } else if (!selection->regions.empty()) {
4099                 rv = selection->regions.front();
4100         } else {
4101                 return;
4102         }
4103
4104         nframes64_t pos = get_preferred_edit_position();
4105         nframes_t len;
4106         char* cmd;
4107
4108         if (in) {
4109                 if (pos <= rv->region()->position()) {
4110                         /* can't do it */
4111                         return;
4112                 }
4113                 len = pos - rv->region()->position();
4114                 cmd = _("set fade in length");
4115         } else {
4116                 if (pos >= rv->region()->last_frame()) {
4117                         /* can't do it */
4118                         return;
4119                 }
4120                 len = rv->region()->last_frame() - pos;
4121                 cmd = _("set fade out length");
4122         }
4123
4124         begin_reversible_command (cmd);
4125
4126         RegionSelection& rs (get_regions_for_action());
4127
4128         for (RegionSelection::iterator x = rs.begin(); x != rs.end(); ++x) {
4129                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4130
4131                 if (!tmp) {
4132                         return;
4133                 }
4134
4135                 AutomationList& alist = tmp->audio_region()->fade_in();
4136                 XMLNode &before = alist.get_state();
4137
4138                 if (in) {
4139                         tmp->audio_region()->set_fade_in_length (len);
4140                 } else {
4141                         tmp->audio_region()->set_fade_out_length (len);
4142                 }
4143
4144                 XMLNode &after = alist.get_state();
4145                 session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
4146         }
4147
4148         commit_reversible_command ();
4149 }
4150
4151
4152 void
4153 Editor::toggle_fade_active (bool in)
4154 {
4155         ensure_entered_region_selected (true);
4156
4157         if (selection->regions.empty()) {
4158                 return;
4159         }
4160
4161         const char* cmd = (in ? _("toggle fade in active") : _("toggle fade out active"));
4162
4163         begin_reversible_command (cmd);
4164
4165         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4166                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4167
4168                 if (!tmp) {
4169                         return;
4170                 }
4171
4172                 boost::shared_ptr<AudioRegion> region (tmp->audio_region());
4173
4174                 XMLNode &before = region->get_state();
4175
4176                 if (in) {
4177                         region->set_fade_in_active (!region->fade_in_active());
4178                 } else {
4179                         region->set_fade_out_active (!region->fade_out_active());
4180                 }
4181
4182                 XMLNode &after = region->get_state();
4183                 session->add_command(new MementoCommand<AudioRegion>(*region.get(), &before, &after));
4184         }
4185
4186         commit_reversible_command ();
4187 }
4188
4189 void
4190 Editor::set_fade_in_shape (AudioRegion::FadeShape shape)
4191 {
4192         begin_reversible_command (_("set fade in shape"));
4193
4194         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4195                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4196
4197                 if (!tmp) {
4198                         return;
4199                 }
4200
4201                 AutomationList& alist = tmp->audio_region()->fade_in();
4202                 XMLNode &before = alist.get_state();
4203
4204                 tmp->audio_region()->set_fade_in_shape (shape);
4205
4206                 XMLNode &after = alist.get_state();
4207                 session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
4208         }
4209
4210         commit_reversible_command ();
4211 }
4212
4213 void
4214 Editor::set_fade_out_shape (AudioRegion::FadeShape shape)
4215 {
4216         begin_reversible_command (_("set fade out shape"));
4217
4218         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4219                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4220
4221                 if (!tmp) {
4222                         return;
4223                 }
4224
4225                 AutomationList& alist = tmp->audio_region()->fade_out();
4226                 XMLNode &before = alist.get_state();
4227
4228                 tmp->audio_region()->set_fade_out_shape (shape);
4229
4230                 XMLNode &after = alist.get_state();
4231                 session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
4232         }
4233
4234         commit_reversible_command ();
4235 }
4236
4237 void
4238 Editor::set_fade_in_active (bool yn)
4239 {
4240         begin_reversible_command (_("set fade in active"));
4241
4242         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4243                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4244
4245                 if (!tmp) {
4246                         return;
4247                 }
4248
4249
4250                 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4251
4252                 XMLNode &before = ar->get_state();
4253
4254                 ar->set_fade_in_active (yn);
4255
4256                 XMLNode &after = ar->get_state();
4257                 session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
4258         }
4259 }
4260
4261 void
4262 Editor::set_fade_out_active (bool yn)
4263 {
4264         begin_reversible_command (_("set fade out active"));
4265
4266         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
4267                 AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*x);
4268
4269                 if (!tmp) {
4270                         return;
4271                 }
4272
4273                 boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
4274
4275                 XMLNode &before = ar->get_state();
4276
4277                 ar->set_fade_out_active (yn);
4278
4279                 XMLNode &after = ar->get_state();
4280                 session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
4281         }
4282 }
4283
4284
4285 /** Update crossfade visibility after its configuration has been changed */
4286 void
4287 Editor::update_xfade_visibility ()
4288 {
4289         _xfade_visibility = Config->get_xfades_visible ();
4290
4291         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4292                 AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
4293                 if (v) {
4294                         if (_xfade_visibility) {
4295                                 v->show_all_xfades ();
4296                         } else {
4297                                 v->hide_all_xfades ();
4298                         }
4299                 }
4300         }
4301 }
4302
4303 void
4304 Editor::set_edit_point ()
4305 {
4306         nframes64_t where;
4307         bool ignored;
4308
4309         if (!mouse_frame (where, ignored)) {
4310                 return;
4311         }
4312
4313         snap_to (where);
4314
4315         if (selection->markers.empty()) {
4316
4317                 mouse_add_new_marker (where);
4318
4319         } else {
4320                 bool ignored;
4321
4322                 Location* loc = find_location_from_marker (selection->markers.front(), ignored);
4323
4324                 if (loc) {
4325                         loc->move_to (where);
4326                 }
4327         }
4328 }
4329
4330 void
4331 Editor::set_playhead_cursor ()
4332 {
4333         if (entered_marker) {
4334                 session->request_locate (entered_marker->position(), session->transport_rolling());
4335         } else {
4336                 nframes64_t where;
4337                 bool ignored;
4338
4339                 if (!mouse_frame (where, ignored)) {
4340                         return;
4341                 }
4342
4343                 snap_to (where);
4344
4345                 if (session) {
4346                         session->request_locate (where, session->transport_rolling());
4347                 }
4348         }
4349 }
4350
4351 void
4352 Editor::split ()
4353 {
4354         ensure_entered_region_selected ();
4355
4356         nframes64_t where = get_preferred_edit_position();
4357
4358         if (!selection->regions.empty()) {
4359
4360                 split_regions_at (where, selection->regions);
4361
4362         } else {
4363
4364                 RegionSelection rs;
4365                 rs = get_regions_at (where, selection->tracks);
4366                 split_regions_at (where, rs);
4367         }
4368 }
4369
4370 void
4371 Editor::ensure_entered_track_selected (bool op_really_wants_one_track_if_none_are_selected)
4372 {
4373         if (entered_track && mouse_mode == MouseObject) {
4374                 if (!selection->tracks.empty()) {
4375                         if (!selection->selected (entered_track)) {
4376                                 selection->add (entered_track);
4377                         }
4378                 } else {
4379                         /* there is no selection, but this operation requires/prefers selected objects */
4380
4381                         if (op_really_wants_one_track_if_none_are_selected) {
4382                                 selection->set (entered_track);
4383                         }
4384                 }
4385         }
4386 }
4387
4388 void
4389 Editor::ensure_entered_region_selected (bool op_really_wants_one_region_if_none_are_selected)
4390 {
4391         if (entered_regionview && mouse_mode == MouseObject) {
4392
4393                 /* heuristic:
4394
4395                    - if there is no existing selection, don't change it. the operation will thus apply to "all"
4396
4397                    - if there is an existing selection, but the entered regionview isn't in it, add it. this
4398                        avoids key-mouse ops on unselected regions from interfering with an existing selection,
4399                        but also means that the operation will apply to the pointed-at region.
4400                 */
4401
4402                 if (!selection->regions.empty()) {
4403                         if (find (selection->regions.begin(), selection->regions.end(), entered_regionview) != selection->regions.end()) {
4404                                 selection->add (entered_regionview);
4405                         }
4406                 } else {
4407                         /* there is no selection, but this operation requires/prefers selected objects */
4408
4409                         if (op_really_wants_one_region_if_none_are_selected) {
4410                                 selection->set (entered_regionview, false);
4411                         }
4412                 }
4413         }
4414 }
4415
4416 void
4417 Editor::trim_region_front ()
4418 {
4419         trim_region (true);
4420 }
4421
4422 void
4423 Editor::trim_region_back ()
4424 {
4425         trim_region (false);
4426 }
4427
4428 void
4429 Editor::trim_region (bool front)
4430 {
4431         nframes64_t where = get_preferred_edit_position();
4432         RegionSelection& rs = get_regions_for_action ();
4433
4434         if (rs.empty()) {
4435                 return;
4436         }
4437
4438         begin_reversible_command (front ? _("trim front") : _("trim back"));
4439
4440         for (list<RegionView*>::const_iterator i = rs.by_layer().begin(); i != rs.by_layer().end(); ++i) {
4441                 if (!(*i)->region()->locked()) {
4442                         boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
4443                         XMLNode &before = pl->get_state();
4444                         if (front) {
4445                                 (*i)->region()->trim_front (where, this);
4446                         } else {
4447                                 (*i)->region()->trim_end (where, this);
4448                         }
4449                         XMLNode &after = pl->get_state();
4450                         session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
4451                 }
4452         }
4453         commit_reversible_command ();
4454 }
4455
4456 struct EditorOrderRouteSorter {
4457     bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
4458             /* use of ">" forces the correct sort order */
4459             return a->order_key ("editor") < b->order_key ("editor");
4460     }
4461 };
4462
4463 void
4464 Editor::select_next_route()
4465 {
4466         if (selection->tracks.empty()) {
4467                 selection->set (track_views.front());
4468                 return;
4469         }
4470
4471         TimeAxisView* current = selection->tracks.front();
4472
4473         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
4474                 if (*i == current) {
4475                         ++i;
4476                         if (i != track_views.end()) {
4477                                 selection->set (*i);
4478                         } else {
4479                                 selection->set (*(track_views.begin()));
4480                         }
4481                         break;
4482                 }
4483         }
4484 }
4485
4486 void
4487 Editor::select_prev_route()
4488 {
4489         if (selection->tracks.empty()) {
4490                 selection->set (track_views.front());
4491                 return;
4492         }
4493
4494         TimeAxisView* current = selection->tracks.front();
4495
4496         for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
4497                 if (*i == current) {
4498                         ++i;
4499                         if (i != track_views.rend()) {
4500                                 selection->set (*i);
4501                         } else {
4502                                 selection->set (*(track_views.rbegin()));
4503                         }
4504                         break;
4505                 }
4506         }
4507 }
4508
4509 void
4510 Editor::set_loop_from_selection (bool play)
4511 {
4512         if (session == 0 || selection->time.empty()) {
4513                 return;
4514         }
4515
4516         nframes_t start = selection->time[clicked_selection].start;
4517         nframes_t end = selection->time[clicked_selection].end;
4518
4519         set_loop_range (start, end,  _("set loop range from selection"));
4520
4521         if (play) {
4522                 session->request_play_loop (true);
4523                 session->request_locate (start, true);
4524         }
4525 }
4526
4527 void
4528 Editor::set_loop_from_edit_range (bool play)
4529 {
4530         if (session == 0) {
4531                 return;
4532         }
4533
4534         nframes64_t start;
4535         nframes64_t end;
4536
4537         if (!get_edit_op_range (start, end)) {
4538                 return;
4539         }
4540
4541         set_loop_range (start, end,  _("set loop range from edit range"));
4542
4543         if (play) {
4544                 session->request_play_loop (true);
4545                 session->request_locate (start, true);
4546         }
4547 }
4548
4549 void
4550 Editor::set_loop_from_region (bool play)
4551 {
4552         nframes64_t start = max_frames;
4553         nframes64_t end = 0;
4554
4555         ensure_entered_region_selected (true);
4556
4557         if (selection->regions.empty()) {
4558                 info << _("cannot set loop: no region selected") << endmsg;
4559                 return;
4560         }
4561
4562         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
4563                 if ((*i)->region()->position() < start) {
4564                         start = (*i)->region()->position();
4565                 }
4566                 if ((*i)->region()->last_frame() + 1 > end) {
4567                         end = (*i)->region()->last_frame() + 1;
4568                 }
4569         }
4570
4571         set_loop_range (start, end, _("set loop range from region"));
4572
4573         if (play) {
4574                 session->request_play_loop (true);
4575                 session->request_locate (start, true);
4576         }
4577 }
4578
4579 void
4580 Editor::set_punch_from_selection ()
4581 {
4582         if (session == 0 || selection->time.empty()) {
4583                 return;
4584         }
4585
4586         nframes_t start = selection->time[clicked_selection].start;
4587         nframes_t end = selection->time[clicked_selection].end;
4588
4589         set_punch_range (start, end,  _("set punch range from selection"));
4590 }
4591
4592 void
4593 Editor::set_punch_from_edit_range ()
4594 {
4595         if (session == 0) {
4596                 return;
4597         }
4598
4599         nframes64_t start;
4600         nframes64_t end;
4601
4602         if (!get_edit_op_range (start, end)) {
4603                 return;
4604         }
4605
4606         set_punch_range (start, end,  _("set punch range from edit range"));
4607 }
4608
4609 void
4610 Editor::pitch_shift_regions ()
4611 {
4612         ensure_entered_region_selected (true);
4613
4614         if (selection->regions.empty()) {
4615                 return;
4616         }
4617
4618         pitch_shift (selection->regions, 1.2);
4619 }
4620