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     $Id$
  19 */
  20
  21 #include <unistd.h>
  22
  23 #include <cstdlib>
  24 #include <cmath>
  25 #include <string>
  26 #include <map>
  27
  28 #include <sndfile.h>
  29
  30 #include <pbd/error.h>
  31 #include <pbd/basename.h>
  32 #include <pbd/pthread_utils.h>
  33
  34 #include <gtkmm2ext/utils.h>
  35 #include <gtkmm2ext/choice.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/diskstream.h>
  42 #include <ardour/filesource.h>
  43 #include <ardour/sndfilesource.h>
  44 #include <ardour/utils.h>
  45 #include <ardour/location.h>
  46 #include <ardour/named_selection.h>
  47 #include <ardour/audio_track.h>
  48 #include <ardour/audioplaylist.h>
  49 #include <ardour/region_factory.h>
  50 #include <ardour/reverse.h>
  51
  52 #include "ardour_ui.h"
  53 #include "editor.h"
  54 #include "time_axis_view.h"
  55 #include "audio_time_axis.h"
  56 #include "automation_time_axis.h"
  57 #include "streamview.h"
  58 #include "regionview.h"
  59 #include "rgb_macros.h"
  60 #include "selection_templates.h"
  61 #include "selection.h"
  62 #include "sfdb_ui.h"
  63 #include "editing.h"
  64 #include "gtk-custom-hruler.h"
  65
  66 #include "i18n.h"
  67
  68 using namespace std;
  69 using namespace ARDOUR;
  70 using namespace sigc;
  71 using namespace Gtk;
  72 using namespace Editing;
  73
  74 /***********************************************************************
  75   Editor operations
  76  ***********************************************************************/
  77
  78 void
  79 Editor::undo (uint32_t n)
  80 {
  81         if (session) {
  82                 session->undo (n);
  83         }
  84 }
  85
  86 void
  87 Editor::redo (uint32_t n)
  88 {
  89         if (session) {
  90                 session->redo (n);
  91         }
  92 }
  93
  94 int
  95 Editor::ensure_cursor (jack_nframes_t *pos)
  96 {
  97         *pos = edit_cursor->current_frame;
  98         return 0;
  99 }
 100
 101 void
 102 Editor::split_region ()
 103 {
 104         split_region_at (edit_cursor->current_frame);
 105 }
 106
 107 void
 108 Editor::split_region_at (jack_nframes_t where)
 109 {
 110         split_regions_at (where, selection->audio_regions);
 111 }
 112
 113 void
 114 Editor::split_regions_at (jack_nframes_t where, AudioRegionSelection& regions)
 115 {
 116         begin_reversible_command (_("split"));
 117
 118         snap_to (where);
 119         for (AudioRegionSelection::iterator a = regions.begin(); a != regions.end(); ) {
 120
 121                 AudioRegionSelection::iterator tmp;
 122
 123                 tmp = a;
 124                 ++tmp;
 125
 126                 Playlist* pl = (*a)->region.playlist();
 127
 128                 _new_regionviews_show_envelope = (*a)->envelope_visible();
 129
 130                 if (pl) {
 131                         session->add_undo (pl->get_memento());
 132                         pl->split_region ((*a)->region, where);
 133                         session->add_redo_no_execute (pl->get_memento());
 134                 }
 135
 136                 a = tmp;
 137     }
 138
 139         commit_reversible_command ();
 140         _new_regionviews_show_envelope = false;
 141 }
 142
 143 void
 144 Editor::remove_clicked_region ()
 145 {
 146         if (clicked_audio_trackview == 0 || clicked_regionview == 0) {
 147                 return;
 148         }
 149
 150         Playlist* playlist = clicked_audio_trackview->playlist();
 151
 152         begin_reversible_command (_("remove region"));
 153         session->add_undo (playlist->get_memento());
 154         playlist->remove_region (&clicked_regionview->region);
 155         session->add_redo_no_execute (playlist->get_memento());
 156         commit_reversible_command ();
 157 }
 158
 159 void
 160 Editor::destroy_clicked_region ()
 161 {
 162         int32_t selected = selection->audio_regions.size();
 163
 164         if (!session || clicked_regionview == 0 && selected == 0) {
 165                 return;
 166         }
 167
 168         vector<string> choices;
 169         string prompt;
 170
 171         prompt  = string_compose (_(" This is destructive, will possibly delete audio files\n\
 172 It cannot be undone\n\
 173 Do you really want to destroy %1 ?"),
 174                            (selected > 1 ?
 175                             _("these regions") : _("this region")));
 176
 177         if (selected > 1) {
 178                 choices.push_back (_("Yes, destroy them."));
 179         } else {
 180                 choices.push_back (_("Yes, destroy it."));
 181         }
 182
 183         choices.push_back (_("No, do nothing."));
 184
 185         Gtkmm2ext::Choice prompter (prompt, choices);
 186
 187         prompter.chosen.connect (ptr_fun (Main::quit));
 188         prompter.show_all ();
 189
 190         Main::run ();
 191
 192         if (prompter.get_choice() != 0) {
 193                 return;
 194         }
 195
 196         if (selected > 0) {
 197                 list<Region*> r;
 198
 199                 for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
 200                         r.push_back (&(*i)->region);
 201                 }
 202
 203                 session->destroy_regions (r);
 204
 205         } else if (clicked_regionview) {
 206                 session->destroy_region (&clicked_regionview->region);
 207         }
 208 }
 209
 210 AudioRegion *
 211 Editor::select_region_for_operation (int dir, TimeAxisView **tv)
 212 {
 213         AudioRegionView* rv;
 214         AudioRegion *region;
 215         jack_nframes_t start = 0;
 216
 217         if (selection->time.start () == selection->time.end_frame ()) {
 218
 219                 /* no current selection-> is there a selected regionview? */
 220
 221                 if (selection->audio_regions.empty()) {
 222                         return 0;
 223                 }
 224
 225         }
 226
 227         region = 0;
 228
 229         if (!selection->audio_regions.empty()) {
 230
 231                 rv = *(selection->audio_regions.begin());
 232                 (*tv) = &rv->get_time_axis_view();
 233                 region = &rv->region;
 234
 235         } else if (!selection->tracks.empty()) {
 236
 237                 (*tv) = selection->tracks.front();
 238
 239                 AudioTimeAxisView* atv;
 240
 241                 if ((atv = dynamic_cast<AudioTimeAxisView*> (*tv)) != 0) {
 242                         Playlist *pl;
 243
 244                         if ((pl = atv->playlist()) == 0) {
 245                                 return 0;
 246                         }
 247
 248                         region = dynamic_cast<AudioRegion*> (pl->top_region_at (start));
 249                 }
 250         }
 251
 252         return region;
 253 }
 254
 255 void
 256 Editor::extend_selection_to_end_of_region (bool next)
 257 {
 258         TimeAxisView *tv;
 259         Region *region;
 260         jack_nframes_t start;
 261
 262         if ((region = select_region_for_operation (next ? 1 : 0, &tv)) == 0) {
 263                 return;
 264         }
 265
 266         if (region && selection->time.start () == selection->time.end_frame ()) {
 267                 start = region->position();
 268         } else {
 269                 start = selection->time.start ();
 270         }
 271
 272         /* Try to leave the selection with the same route if possible */
 273
 274         if ((tv = selection->time.track) == 0) {
 275                 return;
 276         }
 277
 278         begin_reversible_command (_("extend selection"));
 279         selection->set (tv, start, region->position() + region->length());
 280         commit_reversible_command ();
 281 }
 282
 283 void
 284 Editor::extend_selection_to_start_of_region (bool previous)
 285 {
 286         TimeAxisView *tv;
 287         Region *region;
 288         jack_nframes_t end;
 289
 290         if ((region = select_region_for_operation (previous ? -1 : 0, &tv)) == 0) {
 291                 return;
 292         }
 293
 294         if (region && selection->time.start () == selection->time.end_frame ()) {
 295                 end = region->position() + region->length();
 296         } else {
 297                 end = selection->time.end_frame ();
 298         }
 299
 300         /* Try to leave the selection with the same route if possible */
 301
 302         if ((tv = selection->time.track) == 0) {
 303                 return;
 304         }
 305
 306         begin_reversible_command (_("extend selection"));
 307         selection->set (tv, region->position(), end);
 308         commit_reversible_command ();
 309 }
 310
 311
 312 void
 313 Editor::nudge_forward (bool next)
 314 {
 315         jack_nframes_t distance;
 316         jack_nframes_t next_distance;
 317
 318         if (!session) return;
 319
 320         if (!selection->audio_regions.empty()) {
 321
 322                 begin_reversible_command (_("nudge forward"));
 323
 324                 for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
 325                         AudioRegion& r ((*i)->region);
 326
 327                         distance = get_nudge_distance (r.position(), next_distance);
 328
 329                         if (next) {
 330                                 distance = next_distance;
 331                         }
 332
 333                         session->add_undo (r.playlist()->get_memento());
 334                         r.set_position (r.position() + distance, this);
 335                         session->add_redo_no_execute (r.playlist()->get_memento());
 336                 }
 337
 338                 commit_reversible_command ();
 339
 340         } else {
 341                 distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
 342                 session->request_locate (playhead_cursor->current_frame + distance);
 343         }
 344 }
 345
 346 void
 347 Editor::nudge_backward (bool next)
 348 {
 349         jack_nframes_t distance;
 350         jack_nframes_t next_distance;
 351
 352         if (!session) return;
 353
 354         if (!selection->audio_regions.empty()) {
 355
 356                 begin_reversible_command (_("nudge forward"));
 357
 358                 for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
 359                         AudioRegion& r ((*i)->region);
 360
 361                         distance = get_nudge_distance (r.position(), next_distance);
 362
 363                         if (next) {
 364                                 distance = next_distance;
 365                         }
 366
 367                         session->add_undo (r.playlist()->get_memento());
 368
 369                         if (r.position() > distance) {
 370                                 r.set_position (r.position() - distance, this);
 371                         } else {
 372                                 r.set_position (0, this);
 373                         }
 374                         session->add_redo_no_execute (r.playlist()->get_memento());
 375                 }
 376
 377                 commit_reversible_command ();
 378
 379         } else {
 380
 381                 distance = get_nudge_distance (playhead_cursor->current_frame, next_distance);
 382
 383                 if (playhead_cursor->current_frame > distance) {
 384                         session->request_locate (playhead_cursor->current_frame - distance);
 385                 } else {
 386                         session->request_locate (0);
 387                 }
 388         }
 389 }
 390
 391 void
 392 Editor::nudge_forward_capture_offset ()
 393 {
 394         jack_nframes_t distance;
 395
 396         if (!session) return;
 397
 398         if (!selection->audio_regions.empty()) {
 399
 400                 begin_reversible_command (_("nudge forward"));
 401
 402                 distance = session->worst_output_latency();
 403
 404                 for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
 405                         AudioRegion& r ((*i)->region);
 406
 407                         session->add_undo (r.playlist()->get_memento());
 408                         r.set_position (r.position() + distance, this);
 409                         session->add_redo_no_execute (r.playlist()->get_memento());
 410                 }
 411
 412                 commit_reversible_command ();
 413
 414         }
 415 }
 416
 417 void
 418 Editor::nudge_backward_capture_offset ()
 419 {
 420         jack_nframes_t distance;
 421
 422         if (!session) return;
 423
 424         if (!selection->audio_regions.empty()) {
 425
 426                 begin_reversible_command (_("nudge forward"));
 427
 428                 distance = session->worst_output_latency();
 429
 430                 for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
 431                         AudioRegion& r ((*i)->region);
 432
 433                         session->add_undo (r.playlist()->get_memento());
 434
 435                         if (r.position() > distance) {
 436                                 r.set_position (r.position() - distance, this);
 437                         } else {
 438                                 r.set_position (0, this);
 439                         }
 440                         session->add_redo_no_execute (r.playlist()->get_memento());
 441                 }
 442
 443                 commit_reversible_command ();
 444         }
 445 }
 446
 447 /* DISPLAY MOTION */
 448
 449 void
 450 Editor::move_to_start ()
 451 {
 452         session->request_locate (0);
 453 }
 454
 455 void
 456 Editor::move_to_end ()
 457 {
 458
 459         session->request_locate (session->current_end_frame());
 460 }
 461
 462 void
 463 Editor::build_region_boundary_cache ()
 464 {
 465         jack_nframes_t pos = 0;
 466         RegionPoint point;
 467         Region *r;
 468         TrackViewList tracks;
 469
 470         region_boundary_cache.clear ();
 471
 472         if (session == 0) {
 473                 return;
 474         }
 475
 476         switch (snap_type) {
 477         case SnapToRegionStart:
 478                 point = Start;
 479                 break;
 480         case SnapToRegionEnd:
 481                 point = End;
 482                 break;
 483         case SnapToRegionSync:
 484                 point = SyncPoint;
 485                 break;
 486         case SnapToRegionBoundary:
 487                 point = Start;
 488                 break;
 489         default:
 490                 fatal << string_compose (_("build_region_boundary_cache called with snap_type = %1"), snap_type) << endmsg;
 491                 /*NOTREACHED*/
 492                 return;
 493         }
 494
 495         TimeAxisView *ontrack = 0;
 496
 497         while (pos < session->current_end_frame()) {
 498
 499                 if (!selection->tracks.empty()) {
 500
 501                         if ((r = find_next_region (pos, point, 1, selection->tracks, &ontrack)) == 0) {
 502                                 break;
 503                         }
 504
 505                 } else if (clicked_trackview) {
 506
 507                         TrackViewList t;
 508                         t.push_back (clicked_trackview);
 509
 510                         if ((r = find_next_region (pos, point, 1, t, &ontrack)) == 0) {
 511                                 break;
 512                         }
 513
 514                 } else {
 515
 516                         if ((r = find_next_region (pos, point, 1, track_views, &ontrack)) == 0) {
 517                                 break;
 518                         }
 519                 }
 520
 521                 jack_nframes_t rpos;
 522
 523                 switch (snap_type) {
 524                 case SnapToRegionStart:
 525                         rpos = r->first_frame();
 526                         break;
 527                 case SnapToRegionEnd:
 528                         rpos = r->last_frame();
 529                         break;
 530                 case SnapToRegionSync:
 531                         rpos = r->adjust_to_sync (r->first_frame());
 532                         break;
 533
 534                 case SnapToRegionBoundary:
 535                         rpos = r->last_frame();
 536                         break;
 537                 default:
 538                         break;
 539                 }
 540
 541                 float speed = 1.0f;
 542                 AudioTimeAxisView *atav;
 543
 544                 if ( ontrack != 0 && (atav = dynamic_cast<AudioTimeAxisView*>(ontrack)) != 0 ) {
 545                         if (atav->get_diskstream() != 0) {
 546                                 speed = atav->get_diskstream()->speed();
 547                         }
 548                 }
 549
 550                 rpos = track_frame_to_session_frame(rpos, speed);
 551
 552                 if (region_boundary_cache.empty() || rpos != region_boundary_cache.back()) {
 553                         if (snap_type == SnapToRegionBoundary) {
 554                                 region_boundary_cache.push_back (r->first_frame());
 555                         }
 556                         region_boundary_cache.push_back (rpos);
 557                 }
 558
 559                 pos = rpos + 1;
 560         }
 561 }
 562
 563 Region*
 564 Editor::find_next_region (jack_nframes_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
 565 {
 566         TrackViewList::iterator i;
 567         jack_nframes_t closest = max_frames;
 568         Region* ret = 0;
 569         jack_nframes_t rpos = 0;
 570
 571         float track_speed;
 572         jack_nframes_t track_frame;
 573         AudioTimeAxisView *atav;
 574
 575         for (i = tracks.begin(); i != tracks.end(); ++i) {
 576
 577                 jack_nframes_t distance;
 578                 Region* r;
 579
 580                 track_speed = 1.0f;
 581                 if ( (atav = dynamic_cast<AudioTimeAxisView*>(*i)) != 0 ) {
 582                         if (atav->get_diskstream()!=0)
 583                                 track_speed = atav->get_diskstream()->speed();
 584                 }
 585
 586                 track_frame = session_frame_to_track_frame(frame, track_speed);
 587
 588                 if ((r = (*i)->find_next_region (track_frame, point, dir)) == 0) {
 589                         continue;
 590                 }
 591
 592                 switch (point) {
 593                 case Start:
 594                         rpos = r->first_frame ();
 595                         break;
 596
 597                 case End:
 598                         rpos = r->last_frame ();
 599                         break;
 600
 601                 case SyncPoint:
 602                         rpos = r->adjust_to_sync (r->first_frame());
 603                         break;
 604                 }
 605                 // rpos is a "track frame", converting it to "session frame"
 606                 rpos = track_frame_to_session_frame(rpos, track_speed);
 607
 608                 if (rpos > frame) {
 609                         distance = rpos - frame;
 610                 } else {
 611                         distance = frame - rpos;
 612                 }
 613
 614                 if (distance < closest) {
 615                         closest = distance;
 616                         if (ontrack != 0)
 617                                 *ontrack = (*i);
 618                         ret = r;
 619                 }
 620         }
 621
 622         return ret;
 623 }
 624
 625 void
 626 Editor::cursor_to_region_point (Cursor* cursor, RegionPoint point, int32_t dir)
 627 {
 628         Region* r;
 629         jack_nframes_t pos = cursor->current_frame;
 630
 631         if (!session) {
 632                 return;
 633         }
 634
 635         TimeAxisView *ontrack = 0;
 636
 637         // so we don't find the current region again..
 638         if (dir>0 || pos>0)
 639                 pos+=dir;
 640
 641         if (!selection->tracks.empty()) {
 642
 643                 r = find_next_region (pos, point, dir, selection->tracks, &ontrack);
 644
 645         } else if (clicked_trackview) {
 646
 647                 TrackViewList t;
 648                 t.push_back (clicked_trackview);
 649
 650                 r = find_next_region (pos, point, dir, t, &ontrack);
 651
 652         } else {
 653
 654                 r = find_next_region (pos, point, dir, track_views, &ontrack);
 655         }
 656
 657         if (r == 0) {
 658                 return;
 659         }
 660
 661         switch (point){
 662         case Start:
 663                 pos = r->first_frame ();
 664                 break;
 665
 666         case End:
 667                 pos = r->last_frame ();
 668                 break;
 669
 670         case SyncPoint:
 671                 pos = r->adjust_to_sync (r->first_frame());
 672                 break;
 673         }
 674
 675         float speed = 1.0f;
 676         AudioTimeAxisView *atav;
 677
 678         if ( ontrack != 0 && (atav = dynamic_cast<AudioTimeAxisView*>(ontrack)) != 0 ) {
 679                 if (atav->get_diskstream() != 0) {
 680                         speed = atav->get_diskstream()->speed();
 681                 }
 682         }
 683
 684         pos = track_frame_to_session_frame(pos, speed);
 685
 686         if (cursor == playhead_cursor) {
 687                 session->request_locate (pos);
 688         } else {
 689                 cursor->set_position (pos);
 690         }
 691 }
 692
 693 void
 694 Editor::cursor_to_next_region_point (Cursor* cursor, RegionPoint point)
 695 {
 696         cursor_to_region_point (cursor, point, 1);
 697 }
 698
 699 void
 700 Editor::cursor_to_previous_region_point (Cursor* cursor, RegionPoint point)
 701 {
 702         cursor_to_region_point (cursor, point, -1);
 703 }
 704
 705 void
 706 Editor::cursor_to_selection_start (Cursor *cursor)
 707 {
 708         jack_nframes_t pos = 0;
 709         switch (mouse_mode) {
 710         case MouseObject:
 711                 if (!selection->audio_regions.empty()) {
 712                         pos = selection->audio_regions.start();
 713                 }
 714                 break;
 715
 716         case MouseRange:
 717                 if (!selection->time.empty()) {
 718                         pos = selection->time.start ();
 719                 }
 720                 break;
 721
 722         default:
 723                 return;
 724         }
 725
 726         if (cursor == playhead_cursor) {
 727                 session->request_locate (pos);
 728         } else {
 729                 cursor->set_position (pos);
 730         }
 731 }
 732
 733 void
 734 Editor::cursor_to_selection_end (Cursor *cursor)
 735 {
 736         jack_nframes_t pos = 0;
 737
 738         switch (mouse_mode) {
 739         case MouseObject:
 740                 if (!selection->audio_regions.empty()) {
 741                         pos = selection->audio_regions.end_frame();
 742                 }
 743                 break;
 744
 745         case MouseRange:
 746                 if (!selection->time.empty()) {
 747                         pos = selection->time.end_frame ();
 748                 }
 749                 break;
 750
 751         default:
 752                 return;
 753         }
 754
 755         if (cursor == playhead_cursor) {
 756                 session->request_locate (pos);
 757         } else {
 758                 cursor->set_position (pos);
 759         }
 760 }
 761
 762 void
 763 Editor::playhead_backward ()
 764 {
 765         jack_nframes_t pos;
 766         jack_nframes_t cnt;
 767         float prefix;
 768         bool was_floating;
 769
 770         if (get_prefix (prefix, was_floating)) {
 771                 cnt = 1;
 772         } else {
 773                 if (was_floating) {
 774                         cnt = (jack_nframes_t) floor (prefix * session->frame_rate ());
 775                 } else {
 776                         cnt = (jack_nframes_t) prefix;
 777                 }
 778         }
 779
 780         pos = playhead_cursor->current_frame;
 781
 782         if ((jack_nframes_t) pos < cnt) {
 783                 pos = 0;
 784         } else {
 785                 pos -= cnt;
 786         }
 787
 788         /* XXX this is completely insane. with the current buffering
 789            design, we'll force a complete track buffer flush and
 790            reload, just to move 1 sample !!!
 791         */
 792
 793         session->request_locate (pos);
 794 }
 795
 796 void
 797 Editor::playhead_forward ()
 798 {
 799         jack_nframes_t pos;
 800         jack_nframes_t cnt;
 801         bool was_floating;
 802         float prefix;
 803
 804         if (get_prefix (prefix, was_floating)) {
 805                 cnt = 1;
 806         } else {
 807                 if (was_floating) {
 808                         cnt = (jack_nframes_t) floor (prefix * session->frame_rate ());
 809                 } else {
 810                         cnt = (jack_nframes_t) floor (prefix);
 811                 }
 812         }
 813
 814         pos = playhead_cursor->current_frame;
 815
 816         /* XXX this is completely insane. with the current buffering
 817            design, we'll force a complete track buffer flush and
 818            reload, just to move 1 sample !!!
 819         */
 820
 821         session->request_locate (pos+cnt);
 822 }
 823
 824 void
 825 Editor::cursor_align (bool playhead_to_edit)
 826 {
 827         if (playhead_to_edit) {
 828                 if (session) {
 829                         session->request_locate (edit_cursor->current_frame);
 830                 }
 831         } else {
 832                 edit_cursor->set_position (playhead_cursor->current_frame);
 833         }
 834 }
 835
 836 void
 837 Editor::edit_cursor_backward ()
 838 {
 839         jack_nframes_t pos;
 840         jack_nframes_t cnt;
 841         float prefix;
 842         bool was_floating;
 843
 844         if (get_prefix (prefix, was_floating)) {
 845                 cnt = 1;
 846         } else {
 847                 if (was_floating) {
 848                         cnt = (jack_nframes_t) floor (prefix * session->frame_rate ());
 849                 } else {
 850                         cnt = (jack_nframes_t) prefix;
 851                 }
 852         }
 853
 854         pos = edit_cursor->current_frame;
 855
 856         if ((jack_nframes_t) pos < cnt) {
 857                 pos = 0;
 858         } else {
 859                 pos -= cnt;
 860         }
 861
 862         edit_cursor->set_position (pos);
 863 }
 864
 865 void
 866 Editor::edit_cursor_forward ()
 867 {
 868         jack_nframes_t pos;
 869         jack_nframes_t cnt;
 870         bool was_floating;
 871         float prefix;
 872
 873         if (get_prefix (prefix, was_floating)) {
 874                 cnt = 1;
 875         } else {
 876                 if (was_floating) {
 877                         cnt = (jack_nframes_t) floor (prefix * session->frame_rate ());
 878                 } else {
 879                         cnt = (jack_nframes_t) floor (prefix);
 880                 }
 881         }
 882
 883         pos = edit_cursor->current_frame;
 884         edit_cursor->set_position (pos+cnt);
 885 }
 886
 887 void
 888 Editor::goto_frame ()
 889 {
 890         float prefix;
 891         bool was_floating;
 892         jack_nframes_t frame;
 893
 894         if (get_prefix (prefix, was_floating)) {
 895                 return;
 896         }
 897
 898         if (was_floating) {
 899                 frame = (jack_nframes_t) floor (prefix * session->frame_rate());
 900         } else {
 901                 frame = (jack_nframes_t) floor (prefix);
 902         }
 903
 904         session->request_locate (frame);
 905 }
 906
 907 void
 908 Editor::scroll_backward (float pages)
 909 {
 910         jack_nframes_t frame;
 911         jack_nframes_t one_page = (jack_nframes_t) rint (canvas_width * frames_per_unit);
 912         bool was_floating;
 913         float prefix;
 914         jack_nframes_t cnt;
 915
 916         if (get_prefix (prefix, was_floating)) {
 917                 cnt = (jack_nframes_t) floor (pages * one_page);
 918         } else {
 919                 if (was_floating) {
 920                         cnt = (jack_nframes_t) floor (prefix * session->frame_rate());
 921                 } else {
 922                         cnt = (jack_nframes_t) floor (prefix * one_page);
 923                 }
 924         }
 925
 926         if (leftmost_frame < cnt) {
 927                 frame = 0;
 928         } else {
 929                 frame = leftmost_frame - cnt;
 930         }
 931
 932         reposition_x_origin (frame);
 933 }
 934
 935 void
 936 Editor::scroll_forward (float pages)
 937 {
 938         jack_nframes_t frame;
 939         jack_nframes_t one_page = (jack_nframes_t) rint (canvas_width * frames_per_unit);
 940         bool was_floating;
 941         float prefix;
 942         jack_nframes_t cnt;
 943
 944         if (get_prefix (prefix, was_floating)) {
 945                 cnt = (jack_nframes_t) floor (pages * one_page);
 946         } else {
 947                 if (was_floating) {
 948                         cnt = (jack_nframes_t) floor (prefix * session->frame_rate());
 949                 } else {
 950                         cnt = (jack_nframes_t) floor (prefix * one_page);
 951                 }
 952         }
 953
 954         if (ULONG_MAX - cnt < leftmost_frame) {
 955                 frame = ULONG_MAX - cnt;
 956         } else {
 957                 frame = leftmost_frame + cnt;
 958         }
 959
 960         reposition_x_origin (frame);
 961 }
 962
 963 void
 964 Editor::scroll_tracks_down ()
 965 {
 966         float prefix;
 967         bool was_floating;
 968         int cnt;
 969
 970         if (get_prefix (prefix, was_floating)) {
 971                 cnt = 1;
 972         } else {
 973                 cnt = (int) floor (prefix);
 974         }
 975
 976         vertical_adjustment.set_value (vertical_adjustment.get_value() + (cnt * vertical_adjustment.get_page_size()));
 977 }
 978
 979 void
 980 Editor::scroll_tracks_up ()
 981 {
 982         float prefix;
 983         bool was_floating;
 984         int cnt;
 985
 986         if (get_prefix (prefix, was_floating)) {
 987                 cnt = 1;
 988         } else {
 989                 cnt = (int) floor (prefix);
 990         }
 991
 992         vertical_adjustment.set_value (vertical_adjustment.get_value() - (cnt * vertical_adjustment.get_page_size()));
 993 }
 994
 995 void
 996 Editor::scroll_tracks_down_line ()
 997 {
 998         Gtk::Adjustment* adj = edit_vscrollbar.get_adjustment();
 999         adj->set_value (adj->get_value() + 10);
1000 }
1001
1002 void
1003 Editor::scroll_tracks_up_line ()
1004 {
1005         Gtk::Adjustment* adj = edit_vscrollbar.get_adjustment();
1006         adj->set_value (adj->get_value() - 10);
1007 }
1008
1009 /* ZOOM */
1010
1011 void
1012 Editor::temporal_zoom_step (bool coarser)
1013 {
1014         double nfpu;
1015
1016         nfpu = frames_per_unit;
1017
1018         if (coarser) {
1019                 nfpu *= 2.0;
1020         } else {
1021                 nfpu = max(1.0,(nfpu/2.0));
1022         }
1023
1024         temporal_zoom (nfpu);
1025 }
1026
1027 void
1028 Editor::temporal_zoom (gdouble fpu)
1029 {
1030         if (!session) return;
1031
1032         jack_nframes_t current_page = current_page_frames();
1033         jack_nframes_t current_leftmost = leftmost_frame;
1034         jack_nframes_t current_rightmost;
1035         jack_nframes_t current_center;
1036         jack_nframes_t new_page;
1037         jack_nframes_t leftmost_after_zoom = 0;
1038         double nfpu;
1039
1040         nfpu = fpu;
1041
1042         new_page = (jack_nframes_t) floor (canvas_width * nfpu);
1043
1044         switch (zoom_focus) {
1045         case ZoomFocusLeft:
1046                 leftmost_after_zoom = current_leftmost;
1047                 break;
1048
1049         case ZoomFocusRight:
1050                 current_rightmost = leftmost_frame + current_page;
1051                 if (current_rightmost > new_page) {
1052                         leftmost_after_zoom = current_rightmost - new_page;
1053                 } else {
1054                         leftmost_after_zoom = 0;
1055                 }
1056                 break;
1057
1058         case ZoomFocusCenter:
1059                 current_center = current_leftmost + (current_page/2);
1060                 if (current_center > (new_page/2)) {
1061                         leftmost_after_zoom = current_center - (new_page / 2);
1062                 } else {
1063                         leftmost_after_zoom = 0;
1064                 }
1065                 break;
1066
1067         case ZoomFocusPlayhead:
1068                 /* try to keep the playhead in the center */
1069                 if (playhead_cursor->current_frame > new_page/2) {
1070                         leftmost_after_zoom = playhead_cursor->current_frame - (new_page/2);
1071                 } else {
1072                         leftmost_after_zoom = 0;
1073                 }
1074                 break;
1075
1076         case ZoomFocusEdit:
1077                 /* try to keep the edit cursor in the center */
1078                 if (edit_cursor->current_frame > leftmost_frame + (new_page/2)) {
1079                         leftmost_after_zoom = edit_cursor->current_frame - (new_page/2);
1080                 } else {
1081                         leftmost_after_zoom = 0;
1082                 }
1083                 break;
1084
1085         }
1086
1087         // leftmost_after_zoom = min (leftmost_after_zoom, session->current_end_frame());
1088
1089 //      begin_reversible_command (_("zoom"));
1090 //      session->add_undo (bind (mem_fun(*this, &Editor::reposition_and_zoom), current_leftmost, frames_per_unit));
1091 //      session->add_redo (bind (mem_fun(*this, &Editor::reposition_and_zoom), leftmost_after_zoom, nfpu));
1092 //      commit_reversible_command ();
1093
1094         reposition_and_zoom (leftmost_after_zoom, nfpu);
1095 }
1096
1097 void
1098 Editor::temporal_zoom_selection ()
1099 {
1100         if (!selection) return;
1101
1102         if (selection->time.empty()) {
1103                 return;
1104         }
1105
1106         jack_nframes_t start = selection->time[clicked_selection].start;
1107         jack_nframes_t end = selection->time[clicked_selection].end;
1108
1109         temporal_zoom_by_frame (start, end, "zoom to selection");
1110 }
1111
1112 void
1113 Editor::temporal_zoom_session ()
1114 {
1115         if (session) {
1116                 temporal_zoom_by_frame (0, session->current_end_frame(), "zoom to session");
1117         }
1118 }
1119
1120 void
1121 Editor::temporal_zoom_by_frame (jack_nframes_t start, jack_nframes_t end, stringcr_t op)
1122 {
1123         if (!session) return;
1124
1125         if ((start == 0 && end == 0) || end < start) {
1126                 return;
1127         }
1128
1129         jack_nframes_t range = end - start;
1130
1131         double new_fpu = (double)range / (double)canvas_width;
1132 //      double p2 = 1.0;
1133
1134 //      while (p2 < new_fpu) {
1135 //              p2 *= 2.0;
1136 //      }
1137 //      new_fpu = p2;
1138
1139         jack_nframes_t new_page = (jack_nframes_t) floor (canvas_width * new_fpu);
1140         jack_nframes_t middle = (jack_nframes_t) floor( (double)start + ((double)range / 2.0f ));
1141         jack_nframes_t new_leftmost = (jack_nframes_t) floor( (double)middle - ((double)new_page/2.0f));
1142
1143         if (new_leftmost > middle) new_leftmost = 0;
1144
1145 //      begin_reversible_command (op);
1146 //      session->add_undo (bind (mem_fun(*this, &Editor::reposition_and_zoom), leftmost_frame, frames_per_unit));
1147 //      session->add_redo (bind (mem_fun(*this, &Editor::reposition_and_zoom), new_leftmost, new_fpu));
1148 //      commit_reversible_command ();
1149
1150         reposition_and_zoom (new_leftmost, new_fpu);
1151 }
1152
1153 void
1154 Editor::temporal_zoom_to_frame (bool coarser, jack_nframes_t frame)
1155 {
1156         if (!session) return;
1157
1158         jack_nframes_t range_before = frame - leftmost_frame;
1159         double new_fpu;
1160
1161         new_fpu = frames_per_unit;
1162
1163         if (coarser) {
1164                 new_fpu *= 2.0;
1165                 range_before *= 2;
1166         } else {
1167                 new_fpu = max(1.0,(new_fpu/2.0));
1168                 range_before /= 2;
1169         }
1170
1171         if (new_fpu == frames_per_unit) return;
1172
1173         jack_nframes_t new_leftmost = frame - range_before;
1174
1175         if (new_leftmost > frame) new_leftmost = 0;
1176
1177 //      begin_reversible_command (_("zoom to frame"));
1178 //      session->add_undo (bind (mem_fun(*this, &Editor::reposition_and_zoom), leftmost_frame, frames_per_unit));
1179 //      session->add_redo (bind (mem_fun(*this, &Editor::reposition_and_zoom), new_leftmost, new_fpu));
1180 //      commit_reversible_command ();
1181
1182         reposition_and_zoom (new_leftmost, new_fpu);
1183 }
1184
1185 void
1186 Editor::select_all_in_track (bool add)
1187 {
1188         list<Selectable *> touched;
1189
1190         if (!clicked_trackview) {
1191                 return;
1192         }
1193
1194         clicked_trackview->get_selectables (0, max_frames, 0, DBL_MAX, touched);
1195
1196         if (add) {
1197                 selection->add (touched);
1198         } else {
1199                 selection->set (touched);
1200         }
1201 }
1202
1203 void
1204 Editor::select_all (bool add)
1205 {
1206         list<Selectable *> touched;
1207
1208         for (TrackViewList::iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
1209                 if ((*iter)->hidden()) {
1210                         continue;
1211                 }
1212                 (*iter)->get_selectables (0, max_frames, 0, DBL_MAX, touched);
1213         }
1214
1215         if (add) {
1216                 selection->add (touched);
1217         } else {
1218                 selection->set (touched);
1219         }
1220
1221 }
1222
1223 void
1224 Editor::invert_selection_in_track ()
1225 {
1226         list<Selectable *> touched;
1227
1228         if (!clicked_trackview) {
1229                 return;
1230         }
1231
1232         clicked_trackview->get_inverted_selectables (*selection, touched);
1233         selection->set (touched);
1234 }
1235
1236 void
1237 Editor::invert_selection ()
1238 {
1239         list<Selectable *> touched;
1240
1241         for (TrackViewList::iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
1242                 if ((*iter)->hidden()) {
1243                         continue;
1244                 }
1245                 (*iter)->get_inverted_selectables (*selection, touched);
1246         }
1247
1248         selection->set (touched);
1249 }
1250
1251 bool
1252 Editor::select_all_within (jack_nframes_t start, jack_nframes_t end, double top, double bot, bool add)
1253 {
1254         list<Selectable *> touched;
1255
1256         for (TrackViewList::iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
1257                 if ((*iter)->hidden()) {
1258                         continue;
1259                 }
1260                 (*iter)->get_selectables (start, end, top, bot, touched);
1261         }
1262
1263         if (add) {
1264                 selection->add (touched);
1265         } else {
1266                 selection->set (touched);
1267         }
1268
1269         return !touched.empty();
1270 }
1271
1272 void
1273 Editor::set_selection_from_punch()
1274 {
1275         Location* location;
1276
1277         if ((location = session->locations()->auto_punch_location()) == 0)  {
1278                 return;
1279         }
1280
1281         set_selection_from_range (*location);
1282 }
1283
1284 void
1285 Editor::set_selection_from_loop()
1286 {
1287         Location* location;
1288
1289         if ((location = session->locations()->auto_loop_location()) == 0)  {
1290                 return;
1291         }
1292
1293         set_selection_from_range (*location);
1294 }
1295
1296 void
1297 Editor::set_selection_from_range (Location& range)
1298 {
1299         if (clicked_trackview == 0) {
1300                 return;
1301         }
1302
1303         begin_reversible_command (_("set selection from range"));
1304         selection->set (0, range.start(), range.end());
1305         commit_reversible_command ();
1306 }
1307
1308 void
1309 Editor::amplitude_zoom_step (bool in)
1310 {
1311         gdouble zoom = 1.0;
1312
1313         if (in) {
1314                 zoom *= 2.0;
1315         } else {
1316                 if (zoom > 2.0) {
1317                         zoom /= 2.0;
1318                 } else {
1319                         zoom = 1.0;
1320                 }
1321         }
1322
1323 #ifdef FIX_FOR_CANVAS
1324         /* XXX DO SOMETHING */
1325 #endif
1326 }
1327
1328
1329 /* DELETION */
1330
1331
1332 void
1333 Editor::delete_sample_forward ()
1334 {
1335 }
1336
1337 void
1338 Editor::delete_sample_backward ()
1339 {
1340 }
1341
1342 void
1343 Editor::delete_screen ()
1344 {
1345 }
1346
1347 /* SEARCH */
1348
1349 void
1350 Editor::search_backwards ()
1351 {
1352         /* what ? */
1353 }
1354
1355 void
1356 Editor::search_forwards ()
1357 {
1358         /* what ? */
1359 }
1360
1361 /* MARKS */
1362
1363 void
1364 Editor::jump_forward_to_mark ()
1365 {
1366         if (!session) {
1367                 return;
1368         }
1369
1370         Location *location = session->locations()->first_location_after (playhead_cursor->current_frame);
1371
1372         if (location) {
1373                 session->request_locate (location->start(), session->transport_rolling());
1374         } else {
1375                 session->request_locate (session->current_end_frame());
1376         }
1377 }
1378
1379 void
1380 Editor::jump_backward_to_mark ()
1381 {
1382         if (!session) {
1383                 return;
1384         }
1385
1386         Location *location = session->locations()->first_location_before (playhead_cursor->current_frame);
1387
1388         if (location) {
1389                 session->request_locate (location->start(), session->transport_rolling());
1390         } else {
1391                 session->request_locate (0);
1392         }
1393 }
1394
1395 void
1396 Editor::set_mark ()
1397 {
1398         jack_nframes_t pos;
1399         float prefix;
1400         bool was_floating;
1401
1402         if (get_prefix (prefix, was_floating)) {
1403                 pos = session->audible_frame ();
1404         } else {
1405                 if (was_floating) {
1406                         pos = (jack_nframes_t) floor (prefix * session->frame_rate ());
1407                 } else {
1408                         pos = (jack_nframes_t) floor (prefix);
1409                 }
1410         }
1411
1412         session->locations()->add (new Location (pos, 0, "mark", Location::IsMark), true);
1413 }
1414
1415 void
1416 Editor::clear_markers ()
1417 {
1418         if (session) {
1419                 session->begin_reversible_command (_("clear markers"));
1420                 session->add_undo (session->locations()->get_memento());
1421                 session->locations()->clear_markers ();
1422                 session->add_redo_no_execute (session->locations()->get_memento());
1423                 session->commit_reversible_command ();
1424         }
1425 }
1426
1427 void
1428 Editor::clear_ranges ()
1429 {
1430         if (session) {
1431                 session->begin_reversible_command (_("clear ranges"));
1432                 session->add_undo (session->locations()->get_memento());
1433
1434                 Location * looploc = session->locations()->auto_loop_location();
1435                 Location * punchloc = session->locations()->auto_punch_location();
1436
1437                 session->locations()->clear_ranges ();
1438                 // re-add these
1439                 if (looploc) session->locations()->add (looploc);
1440                 if (punchloc) session->locations()->add (punchloc);
1441
1442                 session->add_redo_no_execute (session->locations()->get_memento());
1443                 session->commit_reversible_command ();
1444         }
1445 }
1446
1447 void
1448 Editor::clear_locations ()
1449 {
1450         session->begin_reversible_command (_("clear locations"));
1451         session->add_undo (session->locations()->get_memento());
1452         session->locations()->clear ();
1453         session->add_redo_no_execute (session->locations()->get_memento());
1454         session->commit_reversible_command ();
1455         session->locations()->clear ();
1456 }
1457
1458 /* INSERT/REPLACE */
1459
1460 void
1461 Editor::insert_region_list_drag (AudioRegion& region)
1462 {
1463         int x, y;
1464         double wx, wy;
1465         double cx, cy;
1466         TimeAxisView *tv;
1467         jack_nframes_t where;
1468         AudioTimeAxisView *atv = 0;
1469         Playlist *playlist;
1470
1471         track_canvas.get_pointer (x, y);
1472         track_canvas.window_to_world (x, y, wx, wy);
1473
1474         GdkEvent event;
1475         event.type = GDK_BUTTON_RELEASE;
1476         event.button.x = wx;
1477         event.button.y = wy;
1478
1479         where = event_frame (&event, &cx, &cy);
1480
1481         if (where < leftmost_frame || where > leftmost_frame + current_page_frames()) {
1482                 /* clearly outside canvas area */
1483                 return;
1484         }
1485
1486         if ((tv = trackview_by_y_position (cy)) == 0) {
1487                 return;
1488         }
1489
1490         if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) == 0) {
1491                 return;
1492         }
1493
1494         if ((playlist = atv->playlist()) == 0) {
1495                 return;
1496         }
1497
1498         snap_to (where);
1499
1500         begin_reversible_command (_("insert dragged region"));
1501         session->add_undo (playlist->get_memento());
1502         playlist->add_region (*(new AudioRegion (region)), where, 1.0);
1503         session->add_redo_no_execute (playlist->get_memento());
1504         commit_reversible_command ();
1505 }
1506
1507 void
1508 Editor::insert_region_list_selection (float times)
1509 {
1510         AudioTimeAxisView *tv = 0;
1511         Playlist *playlist;
1512
1513         if (clicked_audio_trackview != 0) {
1514                 tv = clicked_audio_trackview;
1515         } else if (!selection->tracks.empty()) {
1516                 if ((tv = dynamic_cast<AudioTimeAxisView*>(selection->tracks.front())) == 0) {
1517                         return;
1518                 }
1519         } else {
1520                 return;
1521         }
1522
1523         if ((playlist = tv->playlist()) == 0) {
1524                 return;
1525         }
1526
1527         Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
1528
1529         if (selected->count_selected_rows() != 1) {
1530                 return;
1531         }
1532
1533         TreeModel::iterator i = region_list_display.get_selection()->get_selected();
1534         Region* region = (*i)[region_list_columns.region];
1535
1536         begin_reversible_command (_("insert region"));
1537         session->add_undo (playlist->get_memento());
1538         playlist->add_region (*(createRegion (*region)), edit_cursor->current_frame, times);
1539         session->add_redo_no_execute (playlist->get_memento());
1540         commit_reversible_command ();
1541 }
1542
1543
1544 /* BUILT-IN EFFECTS */
1545
1546 void
1547 Editor::reverse_selection ()
1548 {
1549
1550 }
1551
1552 /* GAIN ENVELOPE EDITING */
1553
1554 void
1555 Editor::edit_envelope ()
1556 {
1557 }
1558
1559 /* PLAYBACK */
1560
1561 void
1562 Editor::toggle_playback (bool with_abort)
1563 {
1564         if (!session) {
1565                 return;
1566         }
1567
1568         switch (session->slave_source()) {
1569         case Session::None:
1570         case Session::JACK:
1571                 break;
1572         default:
1573                 /* transport controlled by the master */
1574                 return;
1575         }
1576
1577         if (session->is_auditioning()) {
1578                 session->cancel_audition ();
1579                 return;
1580         }
1581
1582         if (session->transport_rolling()) {
1583                 session->request_stop (with_abort);
1584                 if (session->get_auto_loop()) {
1585                         session->request_auto_loop (false);
1586                 }
1587         } else {
1588                 session->request_transport_speed (1.0f);
1589         }
1590 }
1591
1592 void
1593 Editor::play_from_start ()
1594 {
1595         session->request_locate (0, true);
1596 }
1597
1598 void
1599 Editor::play_selection ()
1600 {
1601         if (selection->time.empty()) {
1602                 return;
1603         }
1604
1605         session->request_play_range (true);
1606 }
1607
1608 void
1609 Editor::play_selected_region ()
1610 {
1611         if (!selection->audio_regions.empty()) {
1612                 AudioRegionView *rv = *(selection->audio_regions.begin());
1613
1614                 session->request_bounded_roll (rv->region.position(), rv->region.last_frame());
1615         }
1616 }
1617
1618 void
1619 Editor::loop_selected_region ()
1620 {
1621         if (!selection->audio_regions.empty()) {
1622                 AudioRegionView *rv = *(selection->audio_regions.begin());
1623                 Location* tll;
1624
1625                 if ((tll = transport_loop_location()) != 0)  {
1626
1627                         tll->set (rv->region.position(), rv->region.last_frame());
1628
1629                         // enable looping, reposition and start rolling
1630
1631                         session->request_auto_loop (true);
1632                         session->request_locate (tll->start(), false);
1633                         session->request_transport_speed (1.0f);
1634                 }
1635         }
1636 }
1637
1638 void
1639 Editor::play_location (Location& location)
1640 {
1641         if (location.start() <= location.end()) {
1642                 return;
1643         }
1644
1645         session->request_bounded_roll (location.start(), location.end());
1646 }
1647
1648 void
1649 Editor::loop_location (Location& location)
1650 {
1651         if (location.start() <= location.end()) {
1652                 return;
1653         }
1654
1655         Location* tll;
1656
1657         if ((tll = transport_loop_location()) != 0) {
1658                 tll->set (location.start(), location.end());
1659
1660                 // enable looping, reposition and start rolling
1661                 session->request_auto_loop (true);
1662                 session->request_locate (tll->start(), true);
1663         }
1664 }
1665
1666 void
1667 Editor::toggle_region_mute ()
1668 {
1669         if (clicked_regionview) {
1670                 clicked_regionview->region.set_muted (!clicked_regionview->region.muted());
1671         } else if (!selection->audio_regions.empty()) {
1672                 bool yn = ! (*selection->audio_regions.begin())->region.muted();
1673                 selection->foreach_audio_region (&AudioRegion::set_muted, yn);
1674         }
1675 }
1676
1677 void
1678 Editor::toggle_region_opaque ()
1679 {
1680         if (clicked_regionview) {
1681                 clicked_regionview->region.set_opaque (!clicked_regionview->region.opaque());
1682         } else if (!selection->audio_regions.empty()) {
1683                 bool yn = ! (*selection->audio_regions.begin())->region.opaque();
1684                 selection->foreach_audio_region (&Region::set_opaque, yn);
1685         }
1686 }
1687
1688 void
1689 Editor::raise_region ()
1690 {
1691         selection->foreach_audio_region (&Region::raise);
1692 }
1693
1694 void
1695 Editor::raise_region_to_top ()
1696 {
1697         selection->foreach_audio_region (&Region::raise_to_top);
1698 }
1699
1700 void
1701 Editor::lower_region ()
1702 {
1703         selection->foreach_audio_region (&Region::lower);
1704 }
1705
1706 void
1707 Editor::lower_region_to_bottom ()
1708 {
1709         selection->foreach_audio_region (&Region::lower_to_bottom);
1710 }
1711
1712 void
1713 Editor::edit_region ()
1714 {
1715         if (clicked_regionview == 0) {
1716                 return;
1717         }
1718
1719         clicked_regionview->show_region_editor ();
1720 }
1721
1722 void
1723 Editor::rename_region ()
1724 {
1725         Dialog dialog;
1726         Entry  entry;
1727         Button ok_button (_("OK"));
1728         Button cancel_button (_("Cancel"));
1729
1730         if (selection->audio_regions.empty()) {
1731                 return;
1732         }
1733
1734         dialog.set_title (_("ardour: rename region"));
1735         dialog.set_name ("RegionRenameWindow");
1736         dialog.set_size_request (300, -1);
1737         dialog.set_position (Gtk::WIN_POS_MOUSE);
1738         dialog.set_modal (true);
1739
1740         dialog.get_vbox()->set_border_width (10);
1741         dialog.get_vbox()->pack_start (entry);
1742         dialog.get_action_area()->pack_start (ok_button);
1743         dialog.get_action_area()->pack_start (cancel_button);
1744
1745         entry.set_name ("RegionNameDisplay");
1746         ok_button.set_name ("EditorGTKButton");
1747         cancel_button.set_name ("EditorGTKButton");
1748
1749         region_renamed = false;
1750
1751         entry.signal_activate().connect (bind (mem_fun(*this, &Editor::rename_region_finished), true));
1752         ok_button.signal_clicked().connect (bind (mem_fun(*this, &Editor::rename_region_finished), true));
1753         cancel_button.signal_clicked().connect (bind (mem_fun(*this, &Editor::rename_region_finished), false));
1754
1755         /* recurse */
1756
1757         dialog.show_all ();
1758         Main::run ();
1759
1760         if (region_renamed) {
1761                 (*selection->audio_regions.begin())->region.set_name (entry.get_text());
1762                 redisplay_regions ();
1763         }
1764 }
1765
1766 void
1767 Editor::rename_region_finished (bool status)
1768
1769 {
1770         region_renamed = status;
1771         Main::quit ();
1772 }
1773
1774 void
1775 Editor::audition_playlist_region_via_route (AudioRegion& region, Route& route)
1776 {
1777         if (session->is_auditioning()) {
1778                 session->cancel_audition ();
1779         }
1780
1781         // note: some potential for creativity here, because region doesn't
1782         // have to belong to the playlist that Route is handling
1783
1784         // bool was_soloed = route.soloed();
1785
1786         route.set_solo (true, this);
1787
1788         session->request_bounded_roll (region.position(), region.position() + region.length());
1789
1790         /* XXX how to unset the solo state ? */
1791 }
1792
1793 void
1794 Editor::audition_selected_region ()
1795 {
1796         if (!selection->audio_regions.empty()) {
1797                 AudioRegionView* rv = *(selection->audio_regions.begin());
1798                 session->audition_region (rv->region);
1799         }
1800 }
1801
1802 void
1803 Editor::audition_playlist_region_standalone (AudioRegion& region)
1804 {
1805         session->audition_region (region);
1806 }
1807
1808 void
1809 Editor::build_interthread_progress_window ()
1810 {
1811         interthread_progress_window = new ArdourDialog (X_("interthread progress"), true);
1812
1813         interthread_progress_bar.set_orientation (Gtk::PROGRESS_LEFT_TO_RIGHT);
1814
1815         interthread_progress_window->get_vbox()->pack_start (interthread_progress_label, false, false);
1816         interthread_progress_window->get_vbox()->pack_start (interthread_progress_bar,false, false);
1817
1818         // GTK2FIX: this button needs a modifiable label
1819
1820         Button* b = interthread_progress_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
1821         b->signal_clicked().connect (mem_fun(*this, &Editor::interthread_cancel_clicked));
1822
1823         interthread_cancel_button.add (interthread_cancel_label);
1824
1825         interthread_progress_window->set_default_size (200, 100);
1826 }
1827
1828 void
1829 Editor::interthread_cancel_clicked ()
1830 {
1831         if (current_interthread_info) {
1832                 current_interthread_info->cancel = true;
1833         }
1834 }
1835
1836 void *
1837 Editor::_import_thread (void *arg)
1838 {
1839         PBD::ThreadCreated (pthread_self(), X_("Import"));
1840
1841         Editor *ed = (Editor *) arg;
1842         return ed->import_thread ();
1843 }
1844
1845 void *
1846 Editor::import_thread ()
1847 {
1848         session->import_audiofile (import_status);
1849         return 0;
1850 }
1851
1852 gint
1853 Editor::import_progress_timeout (void *arg)
1854 {
1855         interthread_progress_label.set_text (import_status.doing_what);
1856
1857         if (import_status.freeze) {
1858                 interthread_cancel_button.set_sensitive(false);
1859         } else {
1860                 interthread_cancel_button.set_sensitive(true);
1861         }
1862
1863         if (import_status.doing_what == "building peak files") {
1864                 interthread_progress_bar.pulse ();
1865                 return FALSE;
1866         } else {
1867                 interthread_progress_bar.set_fraction (import_status.progress/100);
1868         }
1869
1870         return !(import_status.done || import_status.cancel);
1871 }
1872
1873 void
1874 Editor::import_audio (bool as_tracks)
1875 {
1876         if (session == 0) {
1877                 warning << _("You can't import an audiofile until you have a session loaded.") << endmsg;
1878                 return;
1879         }
1880
1881         string str;
1882
1883         if (as_tracks) {
1884                 str =_("Import selected as tracks");
1885         } else {
1886                 str = _("Import selected to region list");
1887         }
1888
1889         SoundFileOmega sfdb (str);
1890         sfdb.Imported.connect (bind (mem_fun (*this, &Editor::do_import), as_tracks));
1891
1892         sfdb.run();
1893 }
1894
1895 void
1896 Editor::catch_new_audio_region (AudioRegion* ar)
1897 {
1898         last_audio_region = ar;
1899 }
1900
1901 void
1902 Editor::do_import (vector<string> paths, bool split, bool as_tracks)
1903 {
1904         sigc::connection c;
1905
1906         /* SFDB sets "multichan" to true to indicate "split channels"
1907            so reverse the setting to match the way libardour
1908            interprets it.
1909         */
1910
1911         import_status.multichan = !split;
1912
1913         if (interthread_progress_window == 0) {
1914                 build_interthread_progress_window ();
1915         }
1916
1917         interthread_progress_window->set_title (_("ardour: audio import in progress"));
1918         interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
1919         interthread_progress_window->show_all ();
1920         interthread_progress_bar.set_fraction (0.0f);
1921         interthread_cancel_label.set_text (_("Cancel Import"));
1922         current_interthread_info = &import_status;
1923
1924         c = session->AudioRegionAdded.connect (mem_fun(*this, &Editor::catch_new_audio_region));
1925
1926         for (vector<string>::iterator i = paths.begin(); i != paths.end(); ++i ) {
1927
1928                 interthread_progress_window->set_title (string_compose (_("ardour: importing %1"), (*i)));
1929
1930                 import_status.pathname = (*i);
1931                 import_status.done = false;
1932                 import_status.cancel = false;
1933                 import_status.freeze = false;
1934                 import_status.done = 0.0;
1935
1936                 interthread_progress_connection =
1937                   Glib::signal_timeout().connect (bind (mem_fun(*this, &Editor::import_progress_timeout), (gpointer) 0), 100);
1938
1939                 last_audio_region = 0;
1940
1941                 pthread_create_and_store ("import", &import_status.thread, 0, _import_thread, this);
1942                 pthread_detach (import_status.thread);
1943
1944                 while (!(import_status.done || import_status.cancel)) {
1945                         gtk_main_iteration ();
1946                 }
1947
1948                 import_status.done = true;
1949                 interthread_progress_connection.disconnect ();
1950
1951                 if (as_tracks && last_audio_region != 0) {
1952                         uint32_t channels = last_audio_region->n_channels();
1953
1954                         AudioTrack* at = session->new_audio_track (channels, channels);
1955                         AudioRegion* copy = new AudioRegion (*last_audio_region);
1956                         at->disk_stream().playlist()->add_region (*copy, 0);
1957                 }
1958         }
1959
1960         c.disconnect ();
1961         interthread_progress_window->hide_all ();
1962 }
1963
1964 int
1965 Editor::reject_because_rate_differs (stringcr_t path, SF_INFO& finfo, stringcr_t action, bool multiple_pending)
1966 {
1967         if (!session) {
1968                 return 1;
1969         }
1970
1971         if (finfo.samplerate != (int) session->frame_rate()) {
1972                 vector<string> choices;
1973
1974                 choices.push_back (string_compose (_("%1 it anyway"), action));
1975
1976                 if (multiple_pending) {
1977                         /* XXX assumptions about sentence structure
1978                            here for translators. Sorry.
1979                         */
1980                         choices.push_back (string_compose (_("Don't %1 it"), action));
1981                         choices.push_back (string_compose (_("%1 all without questions"), action));
1982                         choices.push_back (_("Cancel entire import"));
1983                 } else {
1984                         choices.push_back (_("Cancel"));
1985                 }
1986
1987                 Gtkmm2ext::Choice rate_choice (
1988                         string_compose (_("%1\nThis audiofile's sample rate doesn't match the session sample rate!"), path),
1989                         choices);
1990
1991                 rate_choice.chosen.connect (ptr_fun (Main::quit));
1992                 rate_choice.show_all ();
1993
1994                 Main::run ();
1995
1996                 switch (rate_choice.get_choice()) {
1997                 case 0: /* do it anyway */
1998                         return 0;
1999                 case 1: /* don't import this one */
2000                         return 1;
2001                 case 2: /* do the rest without asking */
2002                         return -1;
2003                 case 3: /* stop a multi-file import */
2004                 default:
2005                         return -2;
2006                 }
2007         }
2008
2009         return 0;
2010 }
2011
2012 void
2013 Editor::embed_audio ()
2014 {
2015         if (session == 0) {
2016                 warning << _("You can't embed an audiofile until you have a session loaded.") << endmsg;
2017                 return;
2018         }
2019
2020         SoundFileOmega sfdb (_("Add to External Region list"));
2021         sfdb.Embedded.connect (mem_fun (*this, &Editor::do_embed_sndfiles));
2022
2023         sfdb.run ();
2024 }
2025
2026 void
2027 Editor::do_embed_sndfiles (vector<string> paths, bool split)
2028 {
2029         bool multiple_files = paths.size() > 1;
2030         bool check_sample_rate = true;
2031
2032         for (vector<string>::iterator i = paths.begin(); i != paths.end(); ++i) {
2033                 embed_sndfile (*i, split, multiple_files, check_sample_rate);
2034         }
2035
2036         session->save_state ("");
2037 }
2038
2039 void
2040 Editor::embed_sndfile (string path, bool split, bool multiple_files, bool& check_sample_rate)
2041 {
2042         SndFileSource *source = 0; /* keep g++ quiet */
2043         AudioRegion::SourceList sources;
2044         string idspec;
2045         string linked_path;
2046         SNDFILE *sf;
2047         SF_INFO finfo;
2048
2049         /* lets see if we can link it into the session */
2050
2051         linked_path = session->sound_dir();
2052         linked_path += PBD::basename (path);
2053
2054         if (link (path.c_str(), linked_path.c_str()) == 0) {
2055
2056                 /* there are many reasons why link(2) might have failed.
2057                    but if it succeeds, we now have a link in the
2058                    session sound dir that will protect against
2059                    unlinking of the original path. nice.
2060                 */
2061
2062                 path = linked_path;
2063         }
2064
2065         memset (&finfo, 0, sizeof(finfo));
2066
2067         /* note that we temporarily truncated _id at the colon */
2068
2069         if ((sf = sf_open (path.c_str(), SFM_READ, &finfo)) == 0) {
2070                 char errbuf[256];
2071                 sf_error_str (0, errbuf, sizeof (errbuf) - 1);
2072                 error << string_compose(_("Editor: cannot open file \"%1\" (%2)"), selection, errbuf) << endmsg;
2073                 return;
2074         }
2075         sf_close (sf);
2076         sf = 0;
2077
2078         if (check_sample_rate) {
2079                 switch (reject_because_rate_differs (path, finfo, "Embed", multiple_files)) {
2080                 case 0:
2081                         break;
2082                 case 1:
2083                         return;
2084                 case -1:
2085                         check_sample_rate = false;
2086                         break;
2087
2088                 case -2:
2089                 default:
2090                         return;
2091                 }
2092         }
2093
2094         track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
2095         ARDOUR_UI::instance()->flush_pending ();
2096
2097         /* make the proper number of channels in the region */
2098
2099         for (int n=0; n < finfo.channels; ++n)
2100         {
2101                 idspec = path;
2102                 idspec += string_compose(":%1", n);
2103
2104                 try {
2105                         source = new SndFileSource (idspec.c_str());
2106                         sources.push_back(source);
2107                 }
2108
2109                 catch (failed_constructor& err) {
2110                         error << string_compose(_("could not open %1"), path) << endmsg;
2111                         goto out;
2112                 }
2113
2114                 ARDOUR_UI::instance()->flush_pending ();
2115         }
2116
2117         if (sources.size() > 0) {
2118
2119                 string region_name = PBD::basename_nosuffix (path);
2120                 region_name += "-0";
2121
2122                 /* The created region isn't dropped.  It emits a signal
2123                    that is picked up by the session.
2124                 */
2125
2126                 new AudioRegion (sources, 0, sources[0]->length(), region_name, 0,
2127                                  Region::Flag (Region::DefaultFlags|Region::WholeFile|Region::External));
2128
2129                 /* make sure we can see it in the list */
2130
2131                 /* its the second node, always */
2132
2133                 // GTK2FIX ?? is it still always the 2nd node
2134
2135                 TreeModel::Path path ("2");
2136                 region_list_display.expand_row (path, true);
2137
2138                 ARDOUR_UI::instance()->flush_pending ();
2139         }
2140
2141   out:
2142         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
2143 }
2144
2145 void
2146 Editor::insert_sndfile (bool as_tracks)
2147 {
2148 //      SoundFileSelector& sfdb (ARDOUR_UI::instance()->get_sfdb_window());
2149         sigc::connection c;
2150         string str;
2151
2152         if (as_tracks) {
2153
2154 //              c = sfdb.Action.connect (mem_fun(*this, &Editor::insert_paths_as_new_tracks));
2155                 str = _("Insert selected as new tracks");
2156
2157         } else {
2158
2159                 jack_nframes_t pos;
2160
2161                 if (clicked_audio_trackview == 0) {
2162                         return;
2163                 }
2164
2165                 if (ensure_cursor (&pos)) {
2166                         return;
2167                 }
2168
2169 //              c = sfdb.Action.connect (bind (mem_fun(*this, &Editor::do_insert_sndfile), pos));
2170                 str = _("Insert selected");
2171         }
2172
2173 //      sfdb.run (str, false);
2174 //      c.disconnect ();
2175 }
2176
2177 void
2178 Editor::insert_paths_as_new_tracks (vector<string> paths, bool split)
2179 {
2180         SNDFILE *sf;
2181         SF_INFO finfo;
2182         bool multiple_files;
2183         bool check_sample_rate = true;
2184
2185         multiple_files = paths.size() > 1;
2186
2187         for (vector<string>::iterator p = paths.begin(); p != paths.end(); ++p) {
2188
2189                 memset (&finfo, 0, sizeof(finfo));
2190
2191                 if ((sf = sf_open ((*p).c_str(), SFM_READ, &finfo)) == 0) {
2192                         char errbuf[256];
2193                         sf_error_str (0, errbuf, sizeof (errbuf) - 1);
2194                         error << string_compose(_("Editor: cannot open file \"%1\" (%2)"), (*p), errbuf) << endmsg;
2195                         continue;
2196                 }
2197
2198                 sf_close (sf);
2199                 sf = 0;
2200
2201                 /* add a new track */
2202
2203                 if (check_sample_rate) {
2204                         switch (reject_because_rate_differs (*p, finfo, "Insert", multiple_files)) {
2205                         case 0:
2206                                 break;
2207                         case 1:
2208                                 continue;
2209                         case -1:
2210                                 check_sample_rate = false;
2211                                 break;
2212
2213                         case -2:
2214                                 return;
2215                         }
2216                 }
2217
2218                 uint32_t input_chan = finfo.channels;
2219                 uint32_t output_chan;
2220
2221                 if (session->get_output_auto_connect() & Session::AutoConnectMaster) {
2222                         output_chan = (session->master_out() ? session->master_out()->n_inputs() : input_chan);
2223                 } else {
2224                         output_chan = input_chan;
2225                 }
2226
2227                 (void) session->new_audio_track (input_chan, output_chan);
2228
2229
2230                 /* get the last (most recently added) track view */
2231
2232                 AudioTimeAxisView* tv;
2233
2234                 if ((tv = dynamic_cast<AudioTimeAxisView*>(track_views.back())) == 0) {
2235                         fatal << _("programming error: ")
2236                               << X_("last trackview after new_audio_track is not an audio track!")
2237                               << endmsg;
2238                         /*NOTREACHED*/
2239                 }
2240
2241                 jack_nframes_t pos = 0;
2242                 insert_sndfile_into (*p, true, tv, pos, false);
2243         }
2244 }
2245
2246 void
2247 Editor::do_insert_sndfile (vector<string> paths, bool split, jack_nframes_t pos)
2248 {
2249         for (vector<string>::iterator x = paths.begin(); x != paths.end(); ++x) {
2250                 insert_sndfile_into (*x, !split, clicked_audio_trackview, pos);
2251         }
2252 }
2253
2254 void
2255 Editor::insert_sndfile_into (stringcr_t path, bool multi, AudioTimeAxisView* tv, jack_nframes_t& pos, bool prompt)
2256 {
2257         SndFileSource *source = 0; /* keep g++ quiet */
2258         AudioRegion::SourceList sources;
2259         string idspec;
2260         SNDFILE *sf;
2261         SF_INFO finfo;
2262
2263         memset (&finfo, 0, sizeof(finfo));
2264
2265         /* note that we temporarily truncated _id at the colon */
2266
2267         if ((sf = sf_open (path.c_str(), SFM_READ, &finfo)) == 0) {
2268                 char errbuf[256];
2269                 sf_error_str (0, errbuf, sizeof (errbuf) - 1);
2270                 error << string_compose(_("Editor: cannot open file \"%1\" (%2)"), path, errbuf) << endmsg;
2271                 return;
2272         }
2273         sf_close (sf);
2274         sf = 0;
2275
2276         if (prompt && (reject_because_rate_differs (path, finfo, "Insert", false) != 0)) {
2277                 return;
2278         }
2279
2280         track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
2281         ARDOUR_UI::instance()->flush_pending ();
2282
2283         /* make the proper number of channels in the region */
2284
2285         for (int n=0; n < finfo.channels; ++n)
2286         {
2287                 idspec = path;
2288                 idspec += string_compose(":%1", n);
2289
2290                 try {
2291                         source = new SndFileSource (idspec.c_str());
2292                         sources.push_back(source);
2293                 }
2294
2295                 catch (failed_constructor& err) {
2296                         error << string_compose(_("could not open %1"), path) << endmsg;
2297                         goto out;
2298                 }
2299
2300                 ARDOUR_UI::instance()->flush_pending ();
2301         }
2302
2303         if (sources.size() > 0) {
2304
2305                 string region_name = region_name_from_path (PBD::basename (path));
2306
2307                 AudioRegion *region = new AudioRegion (sources, 0, sources[0]->length(), region_name,
2308                                                        0, /* irrelevant these days */
2309                                                        Region::Flag (Region::DefaultFlags|Region::WholeFile|Region::External));
2310
2311                 begin_reversible_command (_("insert sndfile"));
2312                 session->add_undo (tv->playlist()->get_memento());
2313                 tv->playlist()->add_region (*region, pos);
2314                 session->add_redo_no_execute (tv->playlist()->get_memento());
2315                 commit_reversible_command ();
2316
2317                 pos += sources[0]->length();
2318
2319                 ARDOUR_UI::instance()->flush_pending ();
2320         }
2321
2322   out:
2323         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
2324         return;
2325 }
2326
2327 void
2328 Editor::region_from_selection ()
2329 {
2330         if (clicked_trackview == 0) {
2331                 return;
2332         }
2333
2334         if (selection->time.empty()) {
2335                 return;
2336         }
2337
2338         jack_nframes_t start = selection->time[clicked_selection].start;
2339         jack_nframes_t end = selection->time[clicked_selection].end;
2340
2341         jack_nframes_t selection_cnt = end - start + 1;
2342
2343         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2344
2345                 AudioRegion *region;
2346                 AudioRegion *current;
2347                 Region* current_r;
2348                 Playlist *pl;
2349
2350                 jack_nframes_t internal_start;
2351                 string new_name;
2352
2353                 if ((pl = (*i)->playlist()) == 0) {
2354                         continue;
2355                 }
2356
2357                 if ((current_r = pl->top_region_at (start)) == 0) {
2358                         continue;
2359                 }
2360
2361                 if ((current = dynamic_cast<AudioRegion*> (current_r)) != 0) {
2362                         internal_start = start - current->position();
2363                         session->region_name (new_name, current->name(), true);
2364                         region = new AudioRegion (*current, internal_start, selection_cnt, new_name);
2365                 }
2366         }
2367 }
2368
2369 void
2370 Editor::create_region_from_selection (vector<AudioRegion *>& new_regions)
2371 {
2372         if (selection->time.empty() || selection->tracks.empty()) {
2373                 return;
2374         }
2375
2376         jack_nframes_t start = selection->time[clicked_selection].start;
2377         jack_nframes_t end = selection->time[clicked_selection].end;
2378
2379         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2380
2381                 AudioRegion* current;
2382                 Region* current_r;
2383                 Playlist* playlist;
2384                 jack_nframes_t internal_start;
2385                 string new_name;
2386
2387                 if ((playlist = (*i)->playlist()) == 0) {
2388                         continue;
2389                 }
2390
2391                 if ((current_r = playlist->top_region_at(start)) == 0) {
2392                         continue;
2393                 }
2394
2395                 if ((current = dynamic_cast<AudioRegion*>(current_r)) == 0) {
2396                         continue;
2397                 }
2398
2399                 internal_start = start - current->position();
2400                 session->region_name (new_name, current->name(), true);
2401
2402                 new_regions.push_back (new AudioRegion (*current, internal_start, end - start + 1, new_name));
2403         }
2404 }
2405
2406 void
2407 Editor::split_multichannel_region ()
2408 {
2409         vector<AudioRegion*> v;
2410
2411         if (!clicked_regionview || clicked_regionview->region.n_channels() < 2) {
2412                 return;
2413         }
2414
2415         clicked_regionview->region.separate_by_channel (*session, v);
2416
2417         /* nothing else to do, really */
2418 }
2419
2420 void
2421 Editor::new_region_from_selection ()
2422 {
2423         region_from_selection ();
2424         cancel_selection ();
2425 }
2426
2427 void
2428 Editor::separate_region_from_selection ()
2429 {
2430         bool doing_undo = false;
2431
2432         if (selection->time.empty()) {
2433                 return;
2434         }
2435
2436         Playlist *playlist;
2437
2438         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2439
2440                 AudioTimeAxisView* atv;
2441
2442                 if ((atv = dynamic_cast<AudioTimeAxisView*> ((*i))) != 0) {
2443
2444                         if (atv->is_audio_track()) {
2445
2446                                 if ((playlist = atv->playlist()) != 0) {
2447                                         if (!doing_undo) {
2448                                                 begin_reversible_command (_("separate"));
2449                                                 doing_undo = true;
2450                                         }
2451                                         if (doing_undo) session->add_undo ((playlist)->get_memento());
2452
2453                                         /* XXX need to consider musical time selections here at some point */
2454
2455                                         double speed = atv->get_diskstream()->speed();
2456
2457                                         for (list<AudioRange>::iterator t = selection->time.begin(); t != selection->time.end(); ++t) {
2458                                                 playlist->partition ((jack_nframes_t)((*t).start * speed), (jack_nframes_t)((*t).end * speed), true);
2459                                         }
2460
2461                                         if (doing_undo) session->add_redo_no_execute (playlist->get_memento());
2462                                 }
2463                         }
2464                 }
2465         }
2466
2467         if (doing_undo) commit_reversible_command ();
2468 }
2469
2470 void
2471 Editor::crop_region_to_selection ()
2472 {
2473         if (selection->time.empty()) {
2474                 return;
2475         }
2476
2477         vector<Playlist*> playlists;
2478         Playlist *playlist;
2479
2480         if (clicked_trackview != 0) {
2481
2482                 if ((playlist = clicked_trackview->playlist()) == 0) {
2483                         return;
2484                 }
2485
2486                 playlists.push_back (playlist);
2487
2488         } else {
2489
2490                 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2491
2492                         AudioTimeAxisView* atv;
2493
2494                         if ((atv = dynamic_cast<AudioTimeAxisView*> ((*i))) != 0) {
2495
2496                                 if (atv->is_audio_track()) {
2497
2498                                         if ((playlist = atv->playlist()) != 0) {
2499                                                 playlists.push_back (playlist);
2500                                         }
2501                                 }
2502                         }
2503                 }
2504         }
2505
2506         if (!playlists.empty()) {
2507
2508                 jack_nframes_t start;
2509                 jack_nframes_t end;
2510                 jack_nframes_t cnt;
2511
2512                 begin_reversible_command (_("trim to selection"));
2513
2514                 for (vector<Playlist*>::iterator i = playlists.begin(); i != playlists.end(); ++i) {
2515
2516                         Region *region;
2517
2518                         start = selection->time.start();
2519
2520                         if ((region = (*i)->top_region_at(start)) == 0) {
2521                                 continue;
2522                         }
2523
2524                         /* now adjust lengths to that we do the right thing
2525                            if the selection extends beyond the region
2526                         */
2527
2528                         start = max (start, region->position());
2529                         end = min (selection->time.end_frame(), start + region->length() - 1);
2530                         cnt = end - start + 1;
2531
2532                         session->add_undo ((*i)->get_memento());
2533                         region->trim_to (start, cnt, this);
2534                         session->add_redo_no_execute ((*i)->get_memento());
2535                 }
2536
2537                 commit_reversible_command ();
2538         }
2539 }
2540
2541 void
2542 Editor::region_fill_track ()
2543 {
2544         jack_nframes_t end;
2545
2546         if (!session || selection->audio_regions.empty()) {
2547                 return;
2548         }
2549
2550         end = session->current_end_frame ();
2551
2552         begin_reversible_command (_("region fill"));
2553
2554         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
2555
2556                 AudioRegion& region ((*i)->region);
2557                 Playlist* pl = region.playlist();
2558
2559                 if (end <= region.last_frame()) {
2560                         return;
2561                 }
2562
2563                 double times = (double) (end - region.last_frame()) / (double) region.length();
2564
2565                 if (times == 0) {
2566                         return;
2567                 }
2568
2569                 session->add_undo (pl->get_memento());
2570                 pl->add_region (*(new AudioRegion (region)), region.last_frame(), times);
2571                 session->add_redo_no_execute (pl->get_memento());
2572         }
2573
2574         commit_reversible_command ();
2575 }
2576
2577 void
2578 Editor::region_fill_selection ()
2579 {
2580         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
2581                 return;
2582         }
2583
2584         if (selection->time.empty()) {
2585                 return;
2586         }
2587
2588         Region *region;
2589
2590         Glib::RefPtr<TreeSelection> selected = region_list_display.get_selection();
2591
2592         if (selected->count_selected_rows() != 1) {
2593                 return;
2594         }
2595
2596         TreeModel::iterator i = region_list_display.get_selection()->get_selected();
2597         region = (*i)[region_list_columns.region];
2598
2599         jack_nframes_t start = selection->time[clicked_selection].start;
2600         jack_nframes_t end = selection->time[clicked_selection].end;
2601
2602         Playlist *playlist;
2603
2604         if (selection->tracks.empty()) {
2605                 return;
2606         }
2607
2608         jack_nframes_t selection_length = end - start;
2609         float times = (float)selection_length / region->length();
2610
2611         begin_reversible_command (_("fill selection"));
2612
2613         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
2614
2615                 if ((playlist = (*i)->playlist()) == 0) {
2616                         continue;
2617                 }
2618
2619                 session->add_undo (playlist->get_memento());
2620                 playlist->add_region (*(createRegion (*region)), start, times);
2621                 session->add_redo_no_execute (playlist->get_memento());
2622         }
2623
2624         commit_reversible_command ();
2625 }
2626
2627 void
2628 Editor::set_region_sync_from_edit_cursor ()
2629 {
2630         if (clicked_regionview == 0) {
2631                 return;
2632         }
2633
2634         if (!clicked_regionview->region.covers (edit_cursor->current_frame)) {
2635                 error << _("Place the edit cursor at the desired sync point") << endmsg;
2636                 return;
2637         }
2638
2639         Region& region (clicked_regionview->region);
2640
2641         begin_reversible_command (_("set sync from edit cursor"));
2642         session->add_undo (region.playlist()->get_memento());
2643         region.set_sync_position (edit_cursor->current_frame);
2644         session->add_redo_no_execute (region.playlist()->get_memento());
2645         commit_reversible_command ();
2646 }
2647
2648 void
2649 Editor::remove_region_sync ()
2650 {
2651         if (clicked_regionview) {
2652                 Region& region (clicked_regionview->region);
2653                 begin_reversible_command (_("remove sync"));
2654                 session->add_undo (region.playlist()->get_memento());
2655                 region.clear_sync_position ();
2656                 session->add_redo_no_execute (region.playlist()->get_memento());
2657                 commit_reversible_command ();
2658         }
2659 }
2660
2661 void
2662 Editor::naturalize ()
2663 {
2664         if (selection->audio_regions.empty()) {
2665                 return;
2666         }
2667         begin_reversible_command (_("naturalize"));
2668         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
2669                 session->add_undo ((*i)->region.get_memento());
2670                 (*i)->region.move_to_natural_position (this);
2671                 session->add_redo_no_execute ((*i)->region.get_memento());
2672         }
2673         commit_reversible_command ();
2674 }
2675
2676 void
2677 Editor::align (RegionPoint what)
2678 {
2679         align_selection (what, edit_cursor->current_frame);
2680 }
2681
2682 void
2683 Editor::align_relative (RegionPoint what)
2684 {
2685         align_selection_relative (what, edit_cursor->current_frame);
2686 }
2687
2688 struct RegionSortByTime {
2689     bool operator() (const AudioRegionView* a, const AudioRegionView* b) {
2690             return a->region.position() < b->region.position();
2691     }
2692 };
2693
2694 void
2695 Editor::align_selection_relative (RegionPoint point, jack_nframes_t position)
2696 {
2697         if (selection->audio_regions.empty()) {
2698                 return;
2699         }
2700
2701         jack_nframes_t distance;
2702         jack_nframes_t pos = 0;
2703         int dir;
2704
2705         list<AudioRegionView*> sorted;
2706         selection->audio_regions.by_position (sorted);
2707         Region& r ((*sorted.begin())->region);
2708
2709         switch (point) {
2710         case Start:
2711                 pos = r.first_frame ();
2712                 break;
2713
2714         case End:
2715                 pos = r.last_frame();
2716                 break;
2717
2718         case SyncPoint:
2719                 pos = r.adjust_to_sync (r.first_frame());
2720                 break;
2721         }
2722
2723         if (pos > position) {
2724                 distance = pos - position;
2725                 dir = -1;
2726         } else {
2727                 distance = position - pos;
2728                 dir = 1;
2729         }
2730
2731         begin_reversible_command (_("align selection (relative)"));
2732
2733         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
2734
2735                 Region& region ((*i)->region);
2736
2737                 session->add_undo (region.playlist()->get_memento());
2738
2739                 if (dir > 0) {
2740                         region.set_position (region.position() + distance, this);
2741                 } else {
2742                         region.set_position (region.position() - distance, this);
2743                 }
2744
2745                 session->add_redo_no_execute (region.playlist()->get_memento());
2746
2747         }
2748
2749         commit_reversible_command ();
2750 }
2751
2752 void
2753 Editor::align_selection (RegionPoint point, jack_nframes_t position)
2754 {
2755         if (selection->audio_regions.empty()) {
2756                 return;
2757         }
2758
2759         begin_reversible_command (_("align selection"));
2760
2761         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
2762                 align_region_internal ((*i)->region, point, position);
2763         }
2764
2765         commit_reversible_command ();
2766 }
2767
2768 void
2769 Editor::align_region (Region& region, RegionPoint point, jack_nframes_t position)
2770 {
2771         begin_reversible_command (_("align region"));
2772         align_region_internal (region, point, position);
2773         commit_reversible_command ();
2774 }
2775
2776 void
2777 Editor::align_region_internal (Region& region, RegionPoint point, jack_nframes_t position)
2778 {
2779         session->add_undo (region.playlist()->get_memento());
2780
2781         switch (point) {
2782         case SyncPoint:
2783                 region.set_position (region.adjust_to_sync (position), this);
2784                 break;
2785
2786         case End:
2787                 if (position > region.length()) {
2788                         region.set_position (position - region.length(), this);
2789                 }
2790                 break;
2791
2792         case Start:
2793                 region.set_position (position, this);
2794                 break;
2795         }
2796
2797         session->add_redo_no_execute (region.playlist()->get_memento());
2798 }
2799
2800 void
2801 Editor::trim_region_to_edit_cursor ()
2802 {
2803         if (clicked_regionview == 0) {
2804                 return;
2805         }
2806
2807         Region& region (clicked_regionview->region);
2808
2809         float speed = 1.0f;
2810         AudioTimeAxisView *atav;
2811
2812         if ( clicked_trackview != 0 && (atav = dynamic_cast<AudioTimeAxisView*>(clicked_trackview)) != 0 ) {
2813                 if (atav->get_diskstream() != 0) {
2814                         speed = atav->get_diskstream()->speed();
2815                 }
2816         }
2817
2818         begin_reversible_command (_("trim to edit"));
2819         session->add_undo (region.playlist()->get_memento());
2820         region.trim_end( session_frame_to_track_frame(edit_cursor->current_frame, speed), this);
2821         session->add_redo_no_execute (region.playlist()->get_memento());
2822         commit_reversible_command ();
2823 }
2824
2825 void
2826 Editor::trim_region_from_edit_cursor ()
2827 {
2828         if (clicked_regionview == 0) {
2829                 return;
2830         }
2831
2832         Region& region (clicked_regionview->region);
2833
2834         float speed = 1.0f;
2835         AudioTimeAxisView *atav;
2836
2837         if ( clicked_trackview != 0 && (atav = dynamic_cast<AudioTimeAxisView*>(clicked_trackview)) != 0 ) {
2838                 if (atav->get_diskstream() != 0) {
2839                         speed = atav->get_diskstream()->speed();
2840                 }
2841         }
2842
2843         begin_reversible_command (_("trim to edit"));
2844         session->add_undo (region.playlist()->get_memento());
2845         region.trim_end( session_frame_to_track_frame(edit_cursor->current_frame, speed), this);
2846         session->add_redo_no_execute (region.playlist()->get_memento());
2847         commit_reversible_command ();
2848 }
2849
2850 void
2851 Editor::unfreeze_route ()
2852 {
2853         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
2854                 return;
2855         }
2856
2857         clicked_audio_trackview->audio_track()->unfreeze ();
2858 }
2859
2860 void*
2861 Editor::_freeze_thread (void* arg)
2862 {
2863         PBD::ThreadCreated (pthread_self(), X_("Freeze"));
2864         return static_cast<Editor*>(arg)->freeze_thread ();
2865 }
2866
2867 void*
2868 Editor::freeze_thread ()
2869 {
2870         clicked_audio_trackview->audio_track()->freeze (*current_interthread_info);
2871         return 0;
2872 }
2873
2874 gint
2875 Editor::freeze_progress_timeout (void *arg)
2876 {
2877         interthread_progress_bar.set_fraction (current_interthread_info->progress/100);
2878         return !(current_interthread_info->done || current_interthread_info->cancel);
2879 }
2880
2881 void
2882 Editor::freeze_route ()
2883 {
2884         if (clicked_audio_trackview == 0 || !clicked_audio_trackview->is_audio_track()) {
2885                 return;
2886         }
2887
2888         InterThreadInfo itt;
2889
2890         if (interthread_progress_window == 0) {
2891                 build_interthread_progress_window ();
2892         }
2893
2894         interthread_progress_window->set_title (_("ardour: freeze"));
2895         interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
2896         interthread_progress_window->show_all ();
2897         interthread_progress_bar.set_fraction (0.0f);
2898         interthread_progress_label.set_text ("");
2899         interthread_cancel_label.set_text (_("Cancel Freeze"));
2900         current_interthread_info = &itt;
2901
2902         interthread_progress_connection =
2903           Glib::signal_timeout().connect (bind (mem_fun(*this, &Editor::freeze_progress_timeout), (gpointer) 0), 100);
2904
2905         itt.done = false;
2906         itt.cancel = false;
2907         itt.progress = 0.0f;
2908
2909         pthread_create (&itt.thread, 0, _freeze_thread, this);
2910
2911         track_canvas.get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
2912
2913         while (!itt.done && !itt.cancel) {
2914                 gtk_main_iteration ();
2915         }
2916
2917         interthread_progress_connection.disconnect ();
2918         interthread_progress_window->hide_all ();
2919         current_interthread_info = 0;
2920         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
2921 }
2922
2923 void
2924 Editor::bounce_range_selection ()
2925 {
2926         if (selection->time.empty()) {
2927                 return;
2928         }
2929
2930         TrackViewList *views = get_valid_views (selection->time.track, selection->time.group);
2931
2932         jack_nframes_t start = selection->time[clicked_selection].start;
2933         jack_nframes_t end = selection->time[clicked_selection].end;
2934         jack_nframes_t cnt = end - start + 1;
2935
2936         begin_reversible_command (_("bounce range"));
2937
2938         for (TrackViewList::iterator i = views->begin(); i != views->end(); ++i) {
2939
2940                 AudioTimeAxisView* atv;
2941
2942                 if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) == 0) {
2943                         continue;
2944                 }
2945
2946                 Playlist* playlist;
2947
2948                 if ((playlist = atv->playlist()) == 0) {
2949                         return;
2950                 }
2951
2952                 InterThreadInfo itt;
2953
2954                 itt.done = false;
2955                 itt.cancel = false;
2956                 itt.progress = false;
2957
2958                 session->add_undo (playlist->get_memento());
2959                 atv->audio_track()->bounce_range (start, cnt, itt);
2960                 session->add_redo_no_execute (playlist->get_memento());
2961         }
2962
2963         commit_reversible_command ();
2964
2965         delete views;
2966 }
2967
2968 void
2969 Editor::cut ()
2970 {
2971         cut_copy (Cut);
2972 }
2973
2974 void
2975 Editor::copy ()
2976 {
2977         cut_copy (Copy);
2978 }
2979
2980 void
2981 Editor::cut_copy (CutCopyOp op)
2982 {
2983         /* only cancel selection if cut/copy is successful.*/
2984
2985         string opname;
2986
2987         switch (op) {
2988         case Cut:
2989                 opname = _("cut");
2990                 break;
2991         case Copy:
2992                 opname = _("copy");
2993                 break;
2994         case Clear:
2995                 opname = _("clear");
2996                 break;
2997         }
2998
2999         cut_buffer->clear ();
3000
3001         switch (current_mouse_mode()) {
3002         case MouseObject:
3003                 if (!selection->audio_regions.empty() || !selection->points.empty()) {
3004
3005                         begin_reversible_command (opname + _(" objects"));
3006
3007                         if (!selection->audio_regions.empty()) {
3008
3009                                 cut_copy_regions (op);
3010
3011                                 if (op == Cut) {
3012                                         selection->clear_audio_regions ();
3013                                 }
3014                         }
3015
3016                         if (!selection->points.empty()) {
3017                                 cut_copy_points (op);
3018
3019                                 if (op == Cut) {
3020                                         selection->clear_points ();
3021                                 }
3022                         }
3023
3024                         commit_reversible_command ();
3025                 }
3026                 break;
3027
3028         case MouseRange:
3029                 if (!selection->time.empty()) {
3030
3031                         begin_reversible_command (opname + _(" range"));
3032                         cut_copy_ranges (op);
3033                         commit_reversible_command ();
3034
3035                         if (op == Cut) {
3036                                 selection->clear_time ();
3037                         }
3038
3039                 }
3040                 break;
3041
3042         default:
3043                 break;
3044         }
3045 }
3046
3047 void
3048 Editor::cut_copy_points (CutCopyOp op)
3049 {
3050         for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
3051
3052                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
3053
3054                 if (atv) {
3055                         atv->cut_copy_clear_objects (selection->points, op);
3056                 }
3057         }
3058 }
3059
3060 void
3061 Editor::cut_copy_regions (CutCopyOp op)
3062 {
3063         typedef std::map<AudioPlaylist*,AudioPlaylist*> PlaylistMapping;
3064         PlaylistMapping pmap;
3065         jack_nframes_t first_position = max_frames;
3066         set<Playlist*> freezelist;
3067         pair<set<Playlist*>::iterator,bool> insert_result;
3068
3069         for (AudioRegionSelection::iterator x = selection->audio_regions.begin(); x != selection->audio_regions.end(); ++x) {
3070                 first_position = min ((*x)->region.position(), first_position);
3071
3072                 if (op == Cut || op == Clear) {
3073                         AudioPlaylist *pl = dynamic_cast<AudioPlaylist*>((*x)->region.playlist());
3074                         if (pl) {
3075                                 insert_result = freezelist.insert (pl);
3076                                 if (insert_result.second) {
3077                                         pl->freeze ();
3078                                         session->add_undo (pl->get_memento());
3079                                 }
3080                         }
3081                 }
3082         }
3083
3084         for (AudioRegionSelection::iterator x = selection->audio_regions.begin(); x != selection->audio_regions.end(); ) {
3085
3086                 AudioPlaylist *pl = dynamic_cast<AudioPlaylist*>((*x)->region.playlist());
3087                 AudioPlaylist* npl;
3088                 AudioRegionSelection::iterator tmp;
3089
3090                 tmp = x;
3091                 ++tmp;
3092
3093                 if (pl) {
3094
3095                         PlaylistMapping::iterator pi = pmap.find (pl);
3096
3097                         if (pi == pmap.end()) {
3098                                 npl = new AudioPlaylist (*session, "cutlist", true);
3099                                 npl->freeze();
3100                                 pmap[pl] = npl;
3101                         } else {
3102                                 npl = pi->second;
3103                         }
3104
3105                         switch (op) {
3106                         case Cut:
3107                                 npl->add_region (*(new AudioRegion ((*x)->region)), (*x)->region.position() - first_position);
3108                                 pl->remove_region (&((*x)->region));
3109                                 break;
3110
3111                         case Copy:
3112                                 npl->add_region (*(new AudioRegion ((*x)->region)), (*x)->region.position() - first_position);
3113                                 break;
3114
3115                         case Clear:
3116                                 pl->remove_region (&((*x)->region));
3117                                 break;
3118                         }
3119                 }
3120
3121                 x = tmp;
3122         }
3123
3124         list<Playlist*> foo;
3125
3126         for (PlaylistMapping::iterator i = pmap.begin(); i != pmap.end(); ++i) {
3127                 foo.push_back (i->second);
3128         }
3129
3130         if (!foo.empty()) {
3131                 cut_buffer->set (foo);
3132         }
3133
3134         for (set<Playlist*>::iterator pl = freezelist.begin(); pl != freezelist.end(); ++pl) {
3135                 (*pl)->thaw ();
3136                 session->add_redo_no_execute ((*pl)->get_memento());
3137         }
3138 }
3139
3140 void
3141 Editor::cut_copy_ranges (CutCopyOp op)
3142 {
3143         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3144                 (*i)->cut_copy_clear (*selection, op);
3145         }
3146 }
3147
3148 void
3149 Editor::paste (float times)
3150 {
3151         paste_internal (edit_cursor->current_frame, times);
3152 }
3153
3154 void
3155 Editor::mouse_paste ()
3156 {
3157         int x, y;
3158         double wx, wy;
3159         track_canvas.get_pointer (x, y);
3160         track_canvas.window_to_world (x, y, wx, wy);
3161         GdkEvent event;
3162         event.type = GDK_BUTTON_RELEASE;
3163         event.button.x = wx;
3164         event.button.y = wy;
3165
3166         jack_nframes_t where = event_frame (&event, 0, 0);
3167         snap_to (where);
3168         paste_internal (where, 1);
3169 }
3170
3171 void
3172 Editor::paste_internal (jack_nframes_t position, float times)
3173 {
3174         bool commit = false;
3175
3176         if (cut_buffer->empty() || selection->tracks.empty()) {
3177                 return;
3178         }
3179
3180         if (position == max_frames) {
3181                 position = edit_cursor->current_frame;
3182         }
3183
3184         begin_reversible_command (_("paste"));
3185
3186         TrackSelection::iterator i;
3187         size_t nth;
3188
3189         for (nth = 0, i = selection->tracks.begin(); i != selection->tracks.end(); ++i, ++nth) {
3190
3191                 /* undo/redo is handled by individual tracks */
3192
3193                 if ((*i)->paste (position, times, *cut_buffer, nth)) {
3194                         commit = true;
3195                 }
3196         }
3197
3198         if (commit) {
3199                 commit_reversible_command ();
3200         }
3201 }
3202
3203 void
3204 Editor::paste_named_selection (float times)
3205 {
3206         TrackSelection::iterator t;
3207
3208         Glib::RefPtr<TreeSelection> selected = named_selection_display.get_selection();
3209
3210         if (selected->count_selected_rows() != 1 || selection->tracks.empty()) {
3211                 return;
3212         }
3213
3214         TreeModel::iterator i = selected->get_selected();
3215         NamedSelection* ns = (*i)[named_selection_columns.selection];
3216
3217         list<Playlist*>::iterator chunk;
3218         list<Playlist*>::iterator tmp;
3219
3220         chunk = ns->playlists.begin();
3221
3222         begin_reversible_command (_("paste chunk"));
3223
3224         for (t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
3225
3226                 AudioTimeAxisView* atv;
3227                 Playlist* pl;
3228                 AudioPlaylist* apl;
3229
3230                 if ((atv = dynamic_cast<AudioTimeAxisView*> (*t)) == 0) {
3231                         continue;
3232                 }
3233
3234                 if ((pl = atv->playlist()) == 0) {
3235                         continue;
3236                 }
3237
3238                 if ((apl = dynamic_cast<AudioPlaylist*> (pl)) == 0) {
3239                         continue;
3240                 }
3241
3242                 tmp = chunk;
3243                 ++tmp;
3244
3245                 session->add_undo (apl->get_memento());
3246                 apl->paste (**chunk, edit_cursor->current_frame, times);
3247                 session->add_redo_no_execute (apl->get_memento());
3248
3249                 if (tmp != ns->playlists.end()) {
3250                         chunk = tmp;
3251                 }
3252         }
3253
3254         commit_reversible_command();
3255 }
3256
3257 void
3258 Editor::duplicate_some_regions (AudioRegionSelection& regions, float times)
3259 {
3260         Playlist *playlist;
3261
3262         begin_reversible_command (_("duplicate region"));
3263
3264         for (AudioRegionSelection::iterator i = regions.begin(); i != regions.end(); ++i) {
3265
3266                 Region& r ((*i)->region);
3267
3268                 playlist = (*i)->region.playlist();
3269                 session->add_undo (playlist->get_memento());
3270                 playlist->duplicate (r, r.last_frame(), times);
3271                 session->add_redo_no_execute (playlist->get_memento());
3272
3273         }
3274
3275         commit_reversible_command ();
3276 }
3277
3278 void
3279 Editor::duplicate_selection (float times)
3280 {
3281         if (selection->time.empty() || selection->tracks.empty()) {
3282                 return;
3283         }
3284
3285         Playlist *playlist;
3286         vector<AudioRegion*> new_regions;
3287         vector<AudioRegion*>::iterator ri;
3288
3289         create_region_from_selection (new_regions);
3290
3291         if (new_regions.empty()) {
3292                 return;
3293         }
3294
3295         begin_reversible_command (_("duplicate selection"));
3296
3297         ri = new_regions.begin();
3298
3299         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3300                 if ((playlist = (*i)->playlist()) == 0) {
3301                         continue;
3302                 }
3303                 session->add_undo (playlist->get_memento());
3304                 playlist->duplicate (**ri, selection->time[clicked_selection].end, times);
3305                 session->add_redo_no_execute (playlist->get_memento());
3306
3307                 ++ri;
3308                 if (ri == new_regions.end()) {
3309                         --ri;
3310                 }
3311         }
3312
3313         commit_reversible_command ();
3314 }
3315
3316 void
3317 Editor::center_playhead ()
3318 {
3319         float page = canvas_width * frames_per_unit;
3320
3321         center_screen_internal (playhead_cursor->current_frame, page);
3322 }
3323
3324 void
3325 Editor::center_edit_cursor ()
3326 {
3327         float page = canvas_width * frames_per_unit;
3328
3329         center_screen_internal (edit_cursor->current_frame, page);
3330 }
3331
3332 void
3333 Editor::clear_playlist (Playlist& playlist)
3334 {
3335         begin_reversible_command (_("clear playlist"));
3336         session->add_undo (playlist.get_memento());
3337         playlist.clear ();
3338         session->add_redo_no_execute (playlist.get_memento());
3339         commit_reversible_command ();
3340 }
3341
3342 void
3343 Editor::nudge_track (bool use_edit_cursor, bool forwards)
3344 {
3345         Playlist *playlist;
3346         jack_nframes_t distance;
3347         jack_nframes_t next_distance;
3348         jack_nframes_t start;
3349
3350         if (use_edit_cursor) {
3351                 start = edit_cursor->current_frame;
3352         } else {
3353                 start = 0;
3354         }
3355
3356         if ((distance = get_nudge_distance (start, next_distance)) == 0) {
3357                 return;
3358         }
3359
3360         if (selection->tracks.empty()) {
3361                 return;
3362         }
3363
3364         begin_reversible_command (_("nudge track"));
3365
3366         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
3367
3368                 if ((playlist = (*i)->playlist()) == 0) {
3369                         continue;
3370                 }
3371
3372                 session->add_undo (playlist->get_memento());
3373                 playlist->nudge_after (start, distance, forwards);
3374                 session->add_redo_no_execute (playlist->get_memento());
3375         }
3376
3377         commit_reversible_command ();
3378 }
3379
3380 void
3381 Editor::toggle_xfades_active ()
3382 {
3383         if (session) {
3384                 session->set_crossfades_active (!session->get_crossfades_active());
3385         }
3386 }
3387
3388 void
3389 Editor::toggle_follow_playhead ()
3390 {
3391         set_follow_playhead (!_follow_playhead);
3392 }
3393
3394 void
3395 Editor::set_xfade_visibility (bool yn)
3396 {
3397
3398 }
3399
3400 void
3401 Editor::toggle_xfade_visibility ()
3402 {
3403         set_xfade_visibility (!xfade_visibility());
3404 }
3405
3406 void
3407 Editor::remove_last_capture ()
3408 {
3409         vector<string> choices;
3410         string prompt;
3411
3412         if (!session) {
3413                 return;
3414         }
3415
3416         if (Config->get_verify_remove_last_capture()) {
3417                 prompt  = _("Do you really want to destroy the last capture?"
3418                             "\n(This is destructive and cannot be undone)");
3419
3420                 choices.push_back (_("Yes, destroy it."));
3421                 choices.push_back (_("No, do nothing."));
3422
3423                 Gtkmm2ext::Choice prompter (prompt, choices);
3424                 prompter.chosen.connect (ptr_fun (Main::quit));
3425                 prompter.show_all ();
3426
3427                 Main::run ();
3428
3429                 if (prompter.get_choice() == 0) {
3430                         session->remove_last_capture ();
3431                 }
3432
3433         } else {
3434                 session->remove_last_capture();
3435         }
3436 }
3437
3438 void
3439 Editor::normalize_region ()
3440 {
3441         if (!session) {
3442                 return;
3443         }
3444
3445         if (selection->audio_regions.empty()) {
3446                 return;
3447         }
3448
3449         begin_reversible_command (_("normalize"));
3450
3451         track_canvas.get_window()->set_cursor (*wait_cursor);
3452         gdk_flush ();
3453
3454         for (AudioRegionSelection::iterator r = selection->audio_regions.begin(); r != selection->audio_regions.end(); ++r) {
3455                 session->add_undo ((*r)->region.get_memento());
3456                 (*r)->region.normalize_to (0.0f);
3457                 session->add_redo_no_execute ((*r)->region.get_memento());
3458         }
3459
3460         commit_reversible_command ();
3461         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3462 }
3463
3464
3465 void
3466 Editor::denormalize_region ()
3467 {
3468         if (!session) {
3469                 return;
3470         }
3471
3472         if (selection->audio_regions.empty()) {
3473                 return;
3474         }
3475
3476         begin_reversible_command ("denormalize");
3477
3478         for (AudioRegionSelection::iterator r = selection->audio_regions.begin(); r != selection->audio_regions.end(); ++r) {
3479                 session->add_undo ((*r)->region.get_memento());
3480                 (*r)->region.set_scale_amplitude (1.0f);
3481                 session->add_redo_no_execute ((*r)->region.get_memento());
3482         }
3483
3484         commit_reversible_command ();
3485 }
3486
3487
3488 void
3489 Editor::reverse_region ()
3490 {
3491         if (!session) {
3492                 return;
3493         }
3494
3495         Reverse rev (*session);
3496         apply_filter (rev, _("reverse regions"));
3497 }
3498
3499 void
3500 Editor::apply_filter (AudioFilter& filter, string command)
3501 {
3502         if (selection->audio_regions.empty()) {
3503                 return;
3504         }
3505
3506         begin_reversible_command (command);
3507
3508         track_canvas.get_window()->set_cursor (*wait_cursor);
3509         gdk_flush ();
3510
3511         for (AudioRegionSelection::iterator r = selection->audio_regions.begin(); r != selection->audio_regions.end(); ) {
3512
3513                 AudioRegion& region ((*r)->region);
3514                 Playlist* playlist = region.playlist();
3515
3516                 AudioRegionSelection::iterator tmp;
3517
3518                 tmp = r;
3519                 ++tmp;
3520
3521                 if (region.apply (filter) == 0) {
3522
3523                         session->add_undo (playlist->get_memento());
3524                         playlist->replace_region (region, *(filter.results.front()), region.position());
3525                         session->add_redo_no_execute (playlist->get_memento());
3526                 } else {
3527                         goto out;
3528                 }
3529
3530                 r = tmp;
3531         }
3532
3533         commit_reversible_command ();
3534         selection->audio_regions.clear ();
3535
3536   out:
3537         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
3538 }
3539
3540 void
3541 Editor::region_selection_op (void (Region::*pmf)(void))
3542 {
3543         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
3544                 ((*i)->region.*pmf)();
3545         }
3546 }
3547
3548
3549 void
3550 Editor::region_selection_op (void (Region::*pmf)(void*), void *arg)
3551 {
3552         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
3553                 ((*i)->region.*pmf)(arg);
3554         }
3555 }
3556
3557 void
3558 Editor::region_selection_op (void (Region::*pmf)(bool), bool yn)
3559 {
3560         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
3561                 ((*i)->region.*pmf)(yn);
3562         }
3563 }
3564
3565 void
3566 Editor::external_edit_region ()
3567 {
3568         if (!clicked_regionview) {
3569                 return;
3570         }
3571
3572         /* more to come */
3573 }
3574
3575 void
3576 Editor::brush (jack_nframes_t pos)
3577 {
3578         AudioRegionSelection sel;
3579         snap_to (pos);
3580
3581         if (selection->audio_regions.empty()) {
3582                 /* XXX get selection from region list */
3583         } else {
3584                 sel = selection->audio_regions;
3585         }
3586
3587         if (sel.empty()) {
3588                 return;
3589         }
3590
3591         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
3592                 mouse_brush_insert_region ((*i), pos);
3593         }
3594 }
3595
3596 void
3597 Editor::toggle_gain_envelope_visibility ()
3598 {
3599         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
3600                 (*i)->set_envelope_visible (!(*i)->envelope_visible());
3601         }
3602 }
3603
3604 void
3605 Editor::toggle_gain_envelope_active ()
3606 {
3607         for (AudioRegionSelection::iterator i = selection->audio_regions.begin(); i != selection->audio_regions.end(); ++i) {
3608                 AudioRegion* ar = dynamic_cast<AudioRegion*>(&(*i)->region);
3609                 if (ar) {
3610                         ar->set_envelope_active (true);
3611                 }
3612         }
3613 }