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