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