gtk2_ardour/editor_selection.cc

   1 /*
   2     Copyright (C) 2000-2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <algorithm>
  21 #include <cstdlib>
  22
  23 #include "pbd/stacktrace.h"
  24
  25 #include "ardour/session.h"
  26 #include "ardour/playlist.h"
  27 #include "ardour/route_group.h"
  28 #include "ardour/profile.h"
  29 #include "ardour/midi_region.h"
  30
  31 #include "editor.h"
  32 #include "actions.h"
  33 #include "audio_time_axis.h"
  34 #include "audio_region_view.h"
  35 #include "audio_streamview.h"
  36 #include "automation_line.h"
  37 #include "control_point.h"
  38 #include "editor_regions.h"
  39
  40 #include "i18n.h"
  41
  42 using namespace std;
  43 using namespace ARDOUR;
  44 using namespace PBD;
  45 using namespace Gtk;
  46 using namespace Glib;
  47 using namespace Gtkmm2ext;
  48 using namespace Editing;
  49
  50 struct TrackViewByPositionSorter
  51 {
  52     bool operator() (const TimeAxisView* a, const TimeAxisView *b) {
  53             return a->y_position() < b->y_position();
  54     }
  55 };
  56
  57 bool
  58 Editor::extend_selection_to_track (TimeAxisView& view)
  59 {
  60         if (selection->selected (&view)) {
  61                 /* already selected, do nothing */
  62                 return false;
  63         }
  64
  65         if (selection->tracks.empty()) {
  66
  67                 if (!selection->selected (&view)) {
  68                         selection->set (&view);
  69                         return true;
  70                 } else {
  71                         return false;
  72                 }
  73         }
  74
  75         /* something is already selected, so figure out which range of things to add */
  76
  77         TrackViewList to_be_added;
  78         TrackViewList sorted = track_views;
  79         TrackViewByPositionSorter cmp;
  80         bool passed_clicked = false;
  81         bool forwards = true;
  82
  83         sorted.sort (cmp);
  84
  85         if (!selection->selected (&view)) {
  86                 to_be_added.push_back (&view);
  87         }
  88
  89         /* figure out if we should go forward or backwards */
  90
  91         for (TrackViewList::iterator i = sorted.begin(); i != sorted.end(); ++i) {
  92
  93                 if ((*i) == &view) {
  94                         passed_clicked = true;
  95                 }
  96
  97                 if (selection->selected (*i)) {
  98                         if (passed_clicked) {
  99                                 forwards = true;
 100                         } else {
 101                                 forwards = false;
 102                         }
 103                         break;
 104                 }
 105         }
 106
 107         passed_clicked = false;
 108
 109         if (forwards) {
 110
 111                 for (TrackViewList::iterator i = sorted.begin(); i != sorted.end(); ++i) {
 112
 113                         if ((*i) == &view) {
 114                                 passed_clicked = true;
 115                                 continue;
 116                         }
 117
 118                         if (passed_clicked) {
 119                                 if ((*i)->hidden()) {
 120                                         continue;
 121                                 }
 122                                 if (selection->selected (*i)) {
 123                                         break;
 124                                 } else if (!(*i)->hidden()) {
 125                                         to_be_added.push_back (*i);
 126                                 }
 127                         }
 128                 }
 129
 130         } else {
 131
 132                 for (TrackViewList::reverse_iterator r = sorted.rbegin(); r != sorted.rend(); ++r) {
 133
 134                         if ((*r) == &view) {
 135                                 passed_clicked = true;
 136                                 continue;
 137                         }
 138
 139                         if (passed_clicked) {
 140
 141                                 if ((*r)->hidden()) {
 142                                         continue;
 143                                 }
 144
 145                                 if (selection->selected (*r)) {
 146                                         break;
 147                                 } else if (!(*r)->hidden()) {
 148                                         to_be_added.push_back (*r);
 149                                 }
 150                         }
 151                 }
 152         }
 153
 154         if (!to_be_added.empty()) {
 155                 selection->add (to_be_added);
 156                 return true;
 157         }
 158
 159         return false;
 160 }
 161
 162 void
 163 Editor::select_all_tracks ()
 164 {
 165         TrackViewList visible_views;
 166         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 167                 if ((*i)->marked_for_display()) {
 168                         visible_views.push_back (*i);
 169                 }
 170         }
 171         selection->set (visible_views);
 172 }
 173
 174 /** Select clicked_axisview, unless there are no currently selected
 175  *  tracks, in which case nothing will happen unless `force' is true.
 176  */
 177 void
 178 Editor::set_selected_track_as_side_effect (Selection::Operation op, bool /*force*/)
 179 {
 180         if (!clicked_axisview) {
 181                 return;
 182         }
 183
 184 #if 1
 185         if (!clicked_routeview) {
 186                 return;
 187         }
 188
 189         bool had_tracks = !selection->tracks.empty();
 190         RouteGroup* group = clicked_routeview->route()->route_group();
 191         RouteGroup& arg (_session->all_route_group());
 192
 193         switch (op) {
 194         case Selection::Toggle:
 195                 if (selection->selected (clicked_axisview)) {
 196                         if (arg.is_select() && arg.is_active()) {
 197                                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end (); ++i) {
 198                                         selection->remove(*i);
 199                                 }
 200                         } else if (group && group->is_active()) {
 201                                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end (); ++i) {
 202                                         if ((*i)->route_group() == group)
 203                                                 selection->remove(*i);
 204                                 }
 205                         } else {
 206                                 selection->remove (clicked_axisview);
 207                         }
 208                 } else {
 209                         if (arg.is_select() && arg.is_active()) {
 210                                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end (); ++i) {
 211                                                 selection->add(*i);
 212                                 }
 213                         } else if (group && group->is_active()) {
 214                                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end (); ++i) {
 215                                         if ( (*i)->route_group() == group)
 216                                                 selection->add(*i);
 217                                 }
 218                         } else {
 219                                 selection->add (clicked_axisview);
 220                         }
 221                 }
 222                 break;
 223
 224         case Selection::Add:
 225                 if (!had_tracks && arg.is_select() && arg.is_active()) {
 226                         /* nothing was selected already, and all group is active etc. so use
 227                            all tracks.
 228                         */
 229                         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end (); ++i) {
 230                                         selection->add(*i);
 231                         }
 232                 } else if (group && group->is_active()) {
 233                         for (TrackViewList::iterator i  = track_views.begin(); i != track_views.end (); ++i) {
 234                                 if ((*i)->route_group() == group)
 235                                         selection->add(*i);
 236                         }
 237                 } else {
 238                         selection->add (clicked_axisview);
 239                 }
 240                 break;
 241
 242         case Selection::Set:
 243                 selection->clear();
 244                 if (!had_tracks && arg.is_select() && arg.is_active()) {
 245                         /* nothing was selected already, and all group is active etc. so use
 246                            all tracks.
 247                         */
 248                         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end (); ++i) {
 249                                         selection->add(*i);
 250                         }
 251                 } else if (group && group->is_active()) {
 252                         for (TrackViewList::iterator i  = track_views.begin(); i != track_views.end (); ++i) {
 253                                 if ((*i)->route_group() == group)
 254                                         selection->add(*i);
 255                         }
 256                 } else {
 257                         selection->set (clicked_axisview);
 258                 }
 259                 break;
 260
 261         case Selection::Extend:
 262                 selection->clear();
 263                 cerr << ("Editor::set_selected_track_as_side_effect  case  Selection::Add  not yet implemented\n");
 264                 break;
 265         }
 266
 267 #else // the older version
 268
 269         if (!selection->tracks.empty()) {
 270                 if (!selection->selected (clicked_axisview)) {
 271                         selection->add (clicked_axisview);
 272                 }
 273
 274         } else if (force) {
 275                 selection->set (clicked_axisview);
 276         }
 277 #endif
 278 }
 279
 280 void
 281 Editor::set_selected_track (TimeAxisView& view, Selection::Operation op, bool no_remove)
 282 {
 283         switch (op) {
 284         case Selection::Toggle:
 285                 if (selection->selected (&view)) {
 286                         if (!no_remove) {
 287                                 selection->remove (&view);
 288                         }
 289                 } else {
 290                         selection->add (&view);
 291                 }
 292                 break;
 293
 294         case Selection::Add:
 295                 if (!selection->selected (&view)) {
 296                         selection->add (&view);
 297                 }
 298                 break;
 299
 300         case Selection::Set:
 301                 selection->set (&view);
 302                 break;
 303
 304         case Selection::Extend:
 305                 extend_selection_to_track (view);
 306                 break;
 307         }
 308 }
 309
 310 void
 311 Editor::set_selected_track_from_click (bool press, Selection::Operation op, bool no_remove)
 312 {
 313         if (!clicked_routeview) {
 314                 return;
 315         }
 316
 317         if (!press) {
 318                 return;
 319         }
 320
 321         set_selected_track (*clicked_routeview, op, no_remove);
 322 }
 323
 324 bool
 325 Editor::set_selected_control_point_from_click (Selection::Operation op, bool /*no_remove*/)
 326 {
 327         if (!clicked_control_point) {
 328                 return false;
 329         }
 330
 331         switch (op) {
 332         case Selection::Set:
 333                 selection->set (clicked_control_point);
 334                 break;
 335         case Selection::Add:
 336                 selection->add (clicked_control_point);
 337                 break;
 338         case Selection::Toggle:
 339                 selection->toggle (clicked_control_point);
 340                 break;
 341         case Selection::Extend:
 342                 /* XXX */
 343                 break;
 344         }
 345
 346         return true;
 347 }
 348
 349 void
 350 Editor::get_onscreen_tracks (TrackViewList& tvl)
 351 {
 352         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 353                 if ((*i)->y_position() < _canvas_height) {
 354                         tvl.push_back (*i);
 355                 }
 356         }
 357 }
 358
 359 /** Call a slot for a given `basis' track and also for any track that is in the same
 360  *  active route group with a particular set of properties.
 361  *
 362  *  @param sl Slot to call.
 363  *  @param basis Basis track.
 364  *  @param prop Properties that active edit groups must share to be included in the map.
 365  */
 366
 367 void
 368 Editor::mapover_tracks (sigc::slot<void, RouteTimeAxisView&, uint32_t> sl, TimeAxisView* basis, PBD::PropertyID prop) const
 369 {
 370         RouteTimeAxisView* route_basis = dynamic_cast<RouteTimeAxisView*> (basis);
 371
 372         if (route_basis == 0) {
 373                 return;
 374         }
 375
 376         set<RouteTimeAxisView*> tracks;
 377         tracks.insert (route_basis);
 378
 379         RouteGroup* group = route_basis->route()->route_group();
 380
 381         if (group && group->enabled_property(prop) && group->enabled_property (Properties::active.property_id) ) {
 382
 383                 /* the basis is a member of an active route group, with the appropriate
 384                    properties; find other members */
 385
 386                 for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
 387                         RouteTimeAxisView* v = dynamic_cast<RouteTimeAxisView*> (*i);
 388                         if (v && v->route()->route_group() == group) {
 389                                 tracks.insert (v);
 390                         }
 391                 }
 392         }
 393
 394         /* call the slots */
 395         uint32_t const sz = tracks.size ();
 396
 397         for (set<RouteTimeAxisView*>::iterator i = tracks.begin(); i != tracks.end(); ++i) {
 398                 sl (**i, sz);
 399         }
 400 }
 401
 402 void
 403 Editor::mapped_get_equivalent_regions (RouteTimeAxisView& tv, uint32_t, RegionView * basis, vector<RegionView*>* all_equivs) const
 404 {
 405         boost::shared_ptr<Playlist> pl;
 406         vector<boost::shared_ptr<Region> > results;
 407         RegionView* marv;
 408         boost::shared_ptr<Track> tr;
 409
 410         if ((tr = tv.track()) == 0) {
 411                 /* bus */
 412                 return;
 413         }
 414
 415         if (&tv == &basis->get_time_axis_view()) {
 416                 /* looking in same track as the original */
 417                 return;
 418         }
 419
 420         if ((pl = tr->playlist()) != 0) {
 421                 pl->get_equivalent_regions (basis->region(), results);
 422         }
 423
 424         for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
 425                 if ((marv = tv.view()->find_view (*ir)) != 0) {
 426                         all_equivs->push_back (marv);
 427                 }
 428         }
 429 }
 430
 431 void
 432 Editor::get_equivalent_regions (RegionView* basis, vector<RegionView*>& equivalent_regions, PBD::PropertyID property) const
 433 {
 434         mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_get_equivalent_regions), basis, &equivalent_regions), &basis->get_time_axis_view(), property);
 435
 436         /* add clicked regionview since we skipped all other regions in the same track as the one it was in */
 437
 438         equivalent_regions.push_back (basis);
 439 }
 440
 441 RegionSelection
 442 Editor::get_equivalent_regions (RegionSelection & basis, PBD::PropertyID prop) const
 443 {
 444         RegionSelection equivalent;
 445
 446         for (RegionSelection::const_iterator i = basis.begin(); i != basis.end(); ++i) {
 447
 448                 vector<RegionView*> eq;
 449
 450                 mapover_tracks (
 451                         sigc::bind (sigc::mem_fun (*this, &Editor::mapped_get_equivalent_regions), *i, &eq),
 452                         &(*i)->get_time_axis_view(), prop
 453                         );
 454
 455                 for (vector<RegionView*>::iterator j = eq.begin(); j != eq.end(); ++j) {
 456                         equivalent.add (*j);
 457                 }
 458
 459                 equivalent.add (*i);
 460         }
 461
 462         return equivalent;
 463 }
 464
 465
 466 int
 467 Editor::get_regionview_count_from_region_list (boost::shared_ptr<Region> region)
 468 {
 469         int region_count = 0;
 470
 471         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 472
 473                 RouteTimeAxisView* tatv;
 474
 475                 if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
 476
 477                         boost::shared_ptr<Playlist> pl;
 478                         vector<boost::shared_ptr<Region> > results;
 479                         RegionView* marv;
 480                         boost::shared_ptr<Track> tr;
 481
 482                         if ((tr = tatv->track()) == 0) {
 483                                 /* bus */
 484                                 continue;
 485                         }
 486
 487                         if ((pl = (tr->playlist())) != 0) {
 488                                 pl->get_region_list_equivalent_regions (region, results);
 489                         }
 490
 491                         for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
 492                                 if ((marv = tatv->view()->find_view (*ir)) != 0) {
 493                                         region_count++;
 494                                 }
 495                         }
 496
 497                 }
 498         }
 499
 500         return region_count;
 501 }
 502
 503
 504 bool
 505 Editor::set_selected_regionview_from_click (bool press, Selection::Operation op, bool /*no_track_remove*/)
 506 {
 507         vector<RegionView*> all_equivalent_regions;
 508         bool commit = false;
 509
 510         if (!clicked_regionview || !clicked_routeview) {
 511                 return false;
 512         }
 513
 514         if (press) {
 515                 button_release_can_deselect = false;
 516         }
 517
 518         if (op == Selection::Toggle || op == Selection::Set) {
 519
 520
 521                 switch (op) {
 522                 case Selection::Toggle:
 523
 524                         if (selection->selected (clicked_regionview)) {
 525                                 if (press) {
 526
 527                                         /* whatever was clicked was selected already; do nothing here but allow
 528                                            the button release to deselect it
 529                                         */
 530
 531                                         button_release_can_deselect = true;
 532
 533                                 } else {
 534
 535                                         if (button_release_can_deselect) {
 536
 537                                                 /* just remove this one region, but only on a permitted button release */
 538
 539                                                 selection->remove (clicked_regionview);
 540                                                 commit = true;
 541
 542                                                 /* no more deselect action on button release till a new press
 543                                                    finds an already selected object.
 544                                                 */
 545
 546                                                 button_release_can_deselect = false;
 547                                         }
 548                                 }
 549
 550                         } else {
 551
 552                                 if (press) {
 553
 554                                         if (selection->selected (clicked_routeview)) {
 555                                                 get_equivalent_regions (clicked_regionview, all_equivalent_regions, ARDOUR::Properties::select.property_id);
 556                                         } else {
 557                                                 all_equivalent_regions.push_back (clicked_regionview);
 558                                         }
 559
 560                                         /* add all the equivalent regions, but only on button press */
 561
 562                                         if (!all_equivalent_regions.empty()) {
 563                                                 commit = true;
 564                                         }
 565
 566                                         selection->add (all_equivalent_regions);
 567                                 }
 568                         }
 569                         break;
 570
 571                 case Selection::Set:
 572                         if (!selection->selected (clicked_regionview)) {
 573                                 get_equivalent_regions (clicked_regionview, all_equivalent_regions, ARDOUR::Properties::select.property_id);
 574                                 selection->set (all_equivalent_regions);
 575                                 commit = true;
 576                         } else {
 577                                 /* no commit necessary: clicked on an already selected region */
 578                                 goto out;
 579                         }
 580                         break;
 581
 582                 default:
 583                         /* silly compiler */
 584                         break;
 585                 }
 586
 587         } else if (op == Selection::Extend) {
 588
 589                 list<Selectable*> results;
 590                 framepos_t last_frame;
 591                 framepos_t first_frame;
 592                 bool same_track = false;
 593
 594                 /* 1. find the last selected regionview in the track that was clicked in */
 595
 596                 last_frame = 0;
 597                 first_frame = max_framepos;
 598
 599                 for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
 600                         if (&(*x)->get_time_axis_view() == &clicked_regionview->get_time_axis_view()) {
 601
 602                                 if ((*x)->region()->last_frame() > last_frame) {
 603                                         last_frame = (*x)->region()->last_frame();
 604                                 }
 605
 606                                 if ((*x)->region()->first_frame() < first_frame) {
 607                                         first_frame = (*x)->region()->first_frame();
 608                                 }
 609
 610                                 same_track = true;
 611                         }
 612                 }
 613
 614                 if (same_track) {
 615
 616                         /* 2. figure out the boundaries for our search for new objects */
 617
 618                         switch (clicked_regionview->region()->coverage (first_frame, last_frame)) {
 619                         case OverlapNone:
 620                                 if (last_frame < clicked_regionview->region()->first_frame()) {
 621                                         first_frame = last_frame;
 622                                         last_frame = clicked_regionview->region()->last_frame();
 623                                 } else {
 624                                         last_frame = first_frame;
 625                                         first_frame = clicked_regionview->region()->first_frame();
 626                                 }
 627                                 break;
 628
 629                         case OverlapExternal:
 630                                 if (last_frame < clicked_regionview->region()->first_frame()) {
 631                                         first_frame = last_frame;
 632                                         last_frame = clicked_regionview->region()->last_frame();
 633                                 } else {
 634                                         last_frame = first_frame;
 635                                         first_frame = clicked_regionview->region()->first_frame();
 636                                 }
 637                                 break;
 638
 639                         case OverlapInternal:
 640                                 if (last_frame < clicked_regionview->region()->first_frame()) {
 641                                         first_frame = last_frame;
 642                                         last_frame = clicked_regionview->region()->last_frame();
 643                                 } else {
 644                                         last_frame = first_frame;
 645                                         first_frame = clicked_regionview->region()->first_frame();
 646                                 }
 647                                 break;
 648
 649                         case OverlapStart:
 650                         case OverlapEnd:
 651                                 /* nothing to do except add clicked region to selection, since it
 652                                    overlaps with the existing selection in this track.
 653                                 */
 654                                 break;
 655                         }
 656
 657                 } else {
 658
 659                         /* click in a track that has no regions selected, so extend vertically
 660                            to pick out all regions that are defined by the existing selection
 661                            plus this one.
 662                         */
 663
 664
 665                         first_frame = clicked_regionview->region()->position();
 666                         last_frame = clicked_regionview->region()->last_frame();
 667
 668                         for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
 669                                 if ((*i)->region()->position() < first_frame) {
 670                                         first_frame = (*i)->region()->position();
 671                                 }
 672                                 if ((*i)->region()->last_frame() + 1 > last_frame) {
 673                                         last_frame = (*i)->region()->last_frame();
 674                                 }
 675                         }
 676                 }
 677
 678                 /* 2. find all the tracks we should select in */
 679
 680                 set<RouteTimeAxisView*> relevant_tracks;
 681
 682                 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
 683                         RouteTimeAxisView* r = dynamic_cast<RouteTimeAxisView*> (*i);
 684                         if (r) {
 685                                 relevant_tracks.insert (r);
 686                         }
 687                 }
 688
 689                 set<RouteTimeAxisView*> already_in_selection;
 690
 691                 if (relevant_tracks.empty()) {
 692
 693                         /* no tracks selected .. thus .. if the
 694                            regionview we're in isn't selected
 695                            (i.e. we're about to extend to it), then
 696                            find all tracks between the this one and
 697                            any selected ones.
 698                         */
 699
 700                         if (!selection->selected (clicked_regionview)) {
 701
 702                                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&clicked_regionview->get_time_axis_view());
 703
 704                                 if (rtv) {
 705
 706                                         /* add this track to the ones we will search */
 707
 708                                         relevant_tracks.insert (rtv);
 709
 710                                         /* find the track closest to this one that
 711                                            already a selected region.
 712                                         */
 713
 714                                         RouteTimeAxisView* closest = 0;
 715                                         int distance = INT_MAX;
 716                                         int key = rtv->route()->order_key ("editor");
 717
 718                                         for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
 719
 720                                                 RouteTimeAxisView* artv = dynamic_cast<RouteTimeAxisView*>(&(*x)->get_time_axis_view());
 721
 722                                                 if (artv && artv != rtv) {
 723
 724                                                         pair<set<RouteTimeAxisView*>::iterator,bool> result;
 725
 726                                                         result = already_in_selection.insert (artv);
 727
 728                                                         if (result.second) {
 729                                                                 /* newly added to already_in_selection */
 730
 731                                                                 int d = artv->route()->order_key ("editor");
 732
 733                                                                 d -= key;
 734
 735                                                                 if (abs (d) < distance) {
 736                                                                         distance = abs (d);
 737                                                                         closest = artv;
 738                                                                 }
 739                                                         }
 740                                                 }
 741                                         }
 742
 743                                         if (closest) {
 744
 745                                                 /* now add all tracks between that one and this one */
 746
 747                                                 int okey = closest->route()->order_key ("editor");
 748
 749                                                 if (okey > key) {
 750                                                         swap (okey, key);
 751                                                 }
 752
 753                                                 for (TrackViewList::iterator x = track_views.begin(); x != track_views.end(); ++x) {
 754                                                         RouteTimeAxisView* artv = dynamic_cast<RouteTimeAxisView*>(*x);
 755                                                         if (artv && artv != rtv) {
 756
 757                                                                 int k = artv->route()->order_key ("editor");
 758
 759                                                                 if (k >= okey && k <= key) {
 760
 761                                                                         /* in range but don't add it if
 762                                                                            it already has tracks selected.
 763                                                                            this avoids odd selection
 764                                                                            behaviour that feels wrong.
 765                                                                         */
 766
 767                                                                         if (find (already_in_selection.begin(),
 768                                                                                   already_in_selection.end(),
 769                                                                                   artv) == already_in_selection.end()) {
 770
 771                                                                                 relevant_tracks.insert (artv);
 772                                                                         }
 773                                                                 }
 774                                                         }
 775                                                 }
 776                                         }
 777                                 }
 778                         }
 779                 }
 780
 781                 /* 3. find all selectable objects (regionviews in this case) between that one and the end of the
 782                            one that was clicked.
 783                 */
 784
 785                 for (set<RouteTimeAxisView*>::iterator t = relevant_tracks.begin(); t != relevant_tracks.end(); ++t) {
 786                         (*t)->get_selectables (first_frame, last_frame, -1.0, -1.0, results);
 787                 }
 788
 789                 /* 4. convert to a vector of regions */
 790
 791                 vector<RegionView*> regions;
 792
 793                 for (list<Selectable*>::iterator x = results.begin(); x != results.end(); ++x) {
 794                         RegionView* arv;
 795
 796                         if ((arv = dynamic_cast<RegionView*>(*x)) != 0) {
 797                                 regions.push_back (arv);
 798                         }
 799                 }
 800
 801                 if (!regions.empty()) {
 802                         selection->add (regions);
 803                         commit = true;
 804                 }
 805         }
 806
 807   out:
 808         return commit;
 809 }
 810
 811
 812 void
 813 Editor::set_selected_regionview_from_region_list (boost::shared_ptr<Region> region, Selection::Operation op)
 814 {
 815         vector<RegionView*> all_equivalent_regions;
 816
 817         get_regions_corresponding_to (region, all_equivalent_regions);
 818
 819         if (all_equivalent_regions.empty()) {
 820                 return;
 821         }
 822
 823         begin_reversible_command (_("set selected regions"));
 824
 825         switch (op) {
 826         case Selection::Toggle:
 827                 /* XXX this is not correct */
 828                 selection->toggle (all_equivalent_regions);
 829                 break;
 830         case Selection::Set:
 831                 selection->set (all_equivalent_regions);
 832                 break;
 833         case Selection::Extend:
 834                 selection->add (all_equivalent_regions);
 835                 break;
 836         case Selection::Add:
 837                 selection->add (all_equivalent_regions);
 838                 break;
 839         }
 840
 841         commit_reversible_command () ;
 842 }
 843
 844 bool
 845 Editor::set_selected_regionview_from_map_event (GdkEventAny* /*ev*/, StreamView* sv, boost::weak_ptr<Region> weak_r)
 846 {
 847         RegionView* rv;
 848         boost::shared_ptr<Region> r (weak_r.lock());
 849
 850         if (!r) {
 851                 return true;
 852         }
 853
 854         if ((rv = sv->find_view (r)) == 0) {
 855                 return true;
 856         }
 857
 858         /* don't reset the selection if its something other than
 859            a single other region.
 860         */
 861
 862         if (selection->regions.size() > 1) {
 863                 return true;
 864         }
 865
 866         begin_reversible_command (_("set selected regions"));
 867
 868         selection->set (rv);
 869
 870         commit_reversible_command () ;
 871
 872         return true;
 873 }
 874
 875 void
 876 Editor::track_selection_changed ()
 877 {
 878         switch (selection->tracks.size()) {
 879         case 0:
 880                 break;
 881         default:
 882                 set_selected_mixer_strip (*(selection->tracks.front()));
 883                 break;
 884         }
 885
 886         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 887
 888                 bool yn = (find (selection->tracks.begin(), selection->tracks.end(), *i) != selection->tracks.end());
 889
 890                 (*i)->set_selected (yn);
 891
 892                 TimeAxisView::Children c = (*i)->get_child_list ();
 893                 for (TimeAxisView::Children::iterator j = c.begin(); j != c.end(); ++j) {
 894                         (*j)->set_selected (find (selection->tracks.begin(), selection->tracks.end(), j->get()) != selection->tracks.end());
 895                 }
 896
 897                 if (yn &&
 898                     ((mouse_mode == MouseRange) ||
 899                      ((mouse_mode == MouseObject) && (_join_object_range_state == JOIN_OBJECT_RANGE_OBJECT)))) {
 900                         (*i)->reshow_selection (selection->time);
 901                 } else {
 902                         (*i)->hide_selection ();
 903                 }
 904         }
 905
 906         ActionManager::set_sensitive (ActionManager::track_selection_sensitive_actions, !selection->tracks.empty());
 907 }
 908
 909 void
 910 Editor::time_selection_changed ()
 911 {
 912         if (Profile->get_sae()) {
 913                 return;
 914         }
 915
 916         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 917                 (*i)->hide_selection ();
 918         }
 919
 920         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
 921                 (*i)->show_selection (selection->time);
 922         }
 923
 924         if (selection->time.empty()) {
 925                 ActionManager::set_sensitive (ActionManager::time_selection_sensitive_actions, false);
 926         } else {
 927                 ActionManager::set_sensitive (ActionManager::time_selection_sensitive_actions, true);
 928         }
 929 }
 930
 931 /** Set all region actions to have a given sensitivity */
 932 void
 933 Editor::sensitize_all_region_actions (bool s)
 934 {
 935         Glib::ListHandle<Glib::RefPtr<Action> > all = _region_actions->get_actions ();
 936
 937         for (Glib::ListHandle<Glib::RefPtr<Action> >::iterator i = all.begin(); i != all.end(); ++i) {
 938                 (*i)->set_sensitive (s);
 939         }
 940
 941         _all_region_actions_sensitized = s;
 942 }
 943
 944 /** Sensitize region-based actions based on the selection ONLY, ignoring the entered_regionview.
 945  *  This method should be called just before displaying a Region menu.  When a Region menu is not
 946  *  currently being shown, all region actions are sensitized so that hotkey-triggered actions
 947  *  on entered_regionviews work without having to check sensitivity every time the selection or
 948  *  entered_regionview changes.
 949  *
 950  *  This method also sets up toggle action state as appropriate.
 951  */
 952 void
 953 Editor::sensitize_the_right_region_actions ()
 954 {
 955         RegionSelection rs = get_regions_from_selection_and_entered ();
 956         sensitize_all_region_actions (!rs.empty ());
 957
 958         _ignore_region_action = true;
 959
 960         /* Look through the regions that are selected and make notes about what we have got */
 961
 962         bool have_audio = false;
 963         bool have_midi = false;
 964         bool have_locked = false;
 965         bool have_unlocked = false;
 966         bool have_position_lock_style_audio = false;
 967         bool have_position_lock_style_music = false;
 968         bool have_muted = false;
 969         bool have_unmuted = false;
 970         bool have_opaque = false;
 971         bool have_non_opaque = false;
 972         bool have_not_at_natural_position = false;
 973         bool have_envelope_visible = false;
 974         bool have_envelope_invisible = false;
 975         bool have_envelope_active = false;
 976         bool have_envelope_inactive = false;
 977         bool have_non_unity_scale_amplitude = false;
 978
 979         for (list<RegionView*>::const_iterator i = rs.begin(); i != rs.end(); ++i) {
 980
 981                 boost::shared_ptr<Region> r = (*i)->region ();
 982                 boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> (r);
 983
 984                 if (ar) {
 985                         have_audio = true;
 986                 }
 987
 988                 if (boost::dynamic_pointer_cast<MidiRegion> (r)) {
 989                         have_midi = true;
 990                 }
 991
 992                 if (r->locked()) {
 993                         have_locked = true;
 994                 } else {
 995                         have_unlocked = true;
 996                 }
 997
 998                 if (r->position_lock_style() == MusicTime) {
 999                         have_position_lock_style_music = true;
1000                 } else {
1001                         have_position_lock_style_audio = true;
1002                 }
1003
1004                 if (r->muted()) {
1005                         have_muted = true;
1006                 } else {
1007                         have_unmuted = true;
1008                 }
1009
1010                 if (r->opaque()) {
1011                         have_opaque = true;
1012                 } else {
1013                         have_non_opaque = true;
1014                 }
1015
1016                 if (!r->at_natural_position()) {
1017                         have_not_at_natural_position = true;
1018                 }
1019
1020                 if (ar) {
1021                         /* its a bit unfortunate that "envelope visible" is a view-only
1022                            property. we have to find the regionview to able to check
1023                            its current setting.
1024                         */
1025
1026                         have_envelope_invisible = true;
1027
1028                         if (*i) {
1029                                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (*i);
1030                                 if (arv && arv->envelope_visible()) {
1031                                         have_envelope_visible = true;
1032                                 }
1033                         }
1034
1035                         if (ar->envelope_active()) {
1036                                 have_envelope_active = true;
1037                         } else {
1038                                 have_envelope_inactive = true;
1039                         }
1040
1041                         if (ar->scale_amplitude() != 1) {
1042                                 have_non_unity_scale_amplitude = true;
1043                         }
1044                 }
1045         }
1046
1047         if (rs.size() > 1) {
1048                 _region_actions->get_action("show-region-list-editor")->set_sensitive (false);
1049                 _region_actions->get_action("show-region-properties")->set_sensitive (false);
1050                 _region_actions->get_action("rename-region")->set_sensitive (false);
1051         } else if (rs.size() == 1) {
1052                 _region_actions->get_action("add-range-markers-from-region")->set_sensitive (false);
1053                 _region_actions->get_action("close-region-gaps")->set_sensitive (false);
1054         }
1055
1056         if (!have_midi) {
1057                 _region_actions->get_action("show-region-list-editor")->set_sensitive (false);
1058                 _region_actions->get_action("quantize-region")->set_sensitive (false);
1059                 _region_actions->get_action("fork-region")->set_sensitive (false);
1060         }
1061
1062         if (_edit_point == EditAtMouse) {
1063                 _region_actions->get_action("set-region-sync-position")->set_sensitive (false);
1064                 _region_actions->get_action("trim-front")->set_sensitive (false);
1065                 _region_actions->get_action("trim-back")->set_sensitive (false);
1066                 _region_actions->get_action("split-region")->set_sensitive (false);
1067                 _region_actions->get_action("place-transient")->set_sensitive (false);
1068         }
1069
1070         if (have_audio) {
1071
1072                 if (have_envelope_visible && !have_envelope_invisible) {
1073                         Glib::RefPtr<ToggleAction>::cast_dynamic (_region_actions->get_action("toggle-region-gain-envelope-visible"))->set_active ();
1074                 } else if (have_envelope_visible && have_envelope_invisible) {
1075 //                      _region_actions->get_action("toggle-region-gain-envelope-visible")->set_inconsistent ();
1076                 }
1077
1078                 if (have_envelope_active && !have_envelope_inactive) {
1079                         Glib::RefPtr<ToggleAction>::cast_dynamic (_region_actions->get_action("toggle-region-gain-envelope-active"))->set_active ();
1080                 } else if (have_envelope_active && have_envelope_inactive) {
1081 //                      _region_actions->get_action("toggle-region-gain-envelope-active")->set_inconsistent ();
1082                 }
1083
1084         } else {
1085
1086                 _region_actions->get_action("analyze-region")->set_sensitive (false);
1087                 _region_actions->get_action("reset-region-gain-envelopes")->set_sensitive (false);
1088                 _region_actions->get_action("toggle-region-gain-envelope-visible")->set_sensitive (false);
1089                 _region_actions->get_action("toggle-region-gain-envelope-active")->set_sensitive (false);
1090
1091         }
1092
1093         if (!have_non_unity_scale_amplitude || !have_audio) {
1094                 _region_actions->get_action("reset-region-scale-amplitude")->set_sensitive (false);
1095         }
1096
1097         Glib::RefPtr<ToggleAction>::cast_dynamic (_region_actions->get_action("toggle-region-lock"))->set_active (have_locked && !have_unlocked);
1098         if (have_locked && have_unlocked) {
1099 //              _region_actions->get_action("toggle-region-lock")->set_inconsistent ();
1100         }
1101
1102         Glib::RefPtr<ToggleAction>::cast_dynamic (_region_actions->get_action("toggle-region-lock-style"))->set_active (have_position_lock_style_music && !have_position_lock_style_audio);
1103
1104         if (have_position_lock_style_music && have_position_lock_style_audio) {
1105 //              _region_actions->get_action("toggle-region-lock-style")->set_inconsistent ();
1106         }
1107
1108         Glib::RefPtr<ToggleAction>::cast_dynamic (_region_actions->get_action("toggle-region-mute"))->set_active (have_muted && !have_unmuted);
1109         if (have_muted && have_unmuted) {
1110 //              _region_actions->get_action("toggle-region-mute")->set_inconsistent ();
1111         }
1112
1113         Glib::RefPtr<ToggleAction>::cast_dynamic (_region_actions->get_action("toggle-opaque-region"))->set_active (have_opaque && !have_non_opaque);
1114         if (have_opaque && have_non_opaque) {
1115 //                      _region_actions->get_action("toggle-opaque-region")->set_inconsistent ();
1116         }
1117
1118         if (!have_not_at_natural_position) {
1119                 _region_actions->get_action("naturalize-region")->set_sensitive (false);
1120         }
1121
1122         /* XXX: should also check that there is a track of the appropriate type for the selected region */
1123         if (_edit_point == EditAtMouse || _regions->get_single_selection() == 0 || selection->tracks.empty()) {
1124                 _region_actions->get_action("insert-region-from-region-list")->set_sensitive (false);
1125         } else {
1126                 _region_actions->get_action("insert-region-from-region-list")->set_sensitive (true);
1127         }
1128
1129         _ignore_region_action = false;
1130
1131         _all_region_actions_sensitized = false;
1132 }
1133
1134
1135 void
1136 Editor::region_selection_changed ()
1137 {
1138         _regions->block_change_connection (true);
1139         editor_regions_selection_changed_connection.block(true);
1140
1141         if (_region_selection_change_updates_region_list) {
1142                 _regions->unselect_all ();
1143         }
1144
1145         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
1146                 (*i)->set_selected_regionviews (selection->regions);
1147         }
1148
1149         if (_region_selection_change_updates_region_list) {
1150                 _regions->set_selected (selection->regions);
1151         }
1152
1153         _regions->block_change_connection (false);
1154         editor_regions_selection_changed_connection.block(false);
1155
1156         if (!_all_region_actions_sensitized) {
1157                 /* This selection change might have changed what region actions
1158                    are allowed, so sensitize them all in case a key is pressed.
1159                 */
1160                 sensitize_all_region_actions (true);
1161         }
1162 }
1163
1164 void
1165 Editor::point_selection_changed ()
1166 {
1167         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
1168                 (*i)->set_selected_points (selection->points);
1169         }
1170 }
1171
1172 void
1173 Editor::select_all_in_track (Selection::Operation op)
1174 {
1175         list<Selectable *> touched;
1176
1177         if (!clicked_routeview) {
1178                 return;
1179         }
1180
1181         clicked_routeview->get_selectables (0, max_framepos, 0, DBL_MAX, touched);
1182
1183         switch (op) {
1184         case Selection::Toggle:
1185                 selection->add (touched);
1186                 break;
1187         case Selection::Set:
1188                 selection->set (touched);
1189                 break;
1190         case Selection::Extend:
1191                 /* meaningless, because we're selecting everything */
1192                 break;
1193         case Selection::Add:
1194                 selection->add (touched);
1195                 break;
1196         }
1197 }
1198
1199 void
1200 Editor::select_all (Selection::Operation op)
1201 {
1202         list<Selectable *> touched;
1203
1204         for (TrackViewList::iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
1205                 if ((*iter)->hidden()) {
1206                         continue;
1207                 }
1208                 (*iter)->get_selectables (0, max_framepos, 0, DBL_MAX, touched);
1209         }
1210         begin_reversible_command (_("select all"));
1211         switch (op) {
1212         case Selection::Add:
1213                 selection->add (touched);
1214                 break;
1215         case Selection::Toggle:
1216                 selection->add (touched);
1217                 break;
1218         case Selection::Set:
1219                 selection->set (touched);
1220                 break;
1221         case Selection::Extend:
1222                 /* meaningless, because we're selecting everything */
1223                 break;
1224         }
1225         commit_reversible_command ();
1226 }
1227 void
1228 Editor::invert_selection_in_track ()
1229 {
1230         list<Selectable *> touched;
1231
1232         if (!clicked_routeview) {
1233                 return;
1234         }
1235
1236         clicked_routeview->get_inverted_selectables (*selection, touched);
1237         selection->set (touched);
1238 }
1239
1240 void
1241 Editor::invert_selection ()
1242 {
1243         list<Selectable *> touched;
1244
1245         for (TrackViewList::iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
1246                 if ((*iter)->hidden()) {
1247                         continue;
1248                 }
1249                 (*iter)->get_inverted_selectables (*selection, touched);
1250         }
1251
1252         selection->set (touched);
1253 }
1254
1255 /** @param start Start time in session frames.
1256  *  @param end End time in session frames.
1257  *  @param top Top (lower) y limit in trackview coordinates (ie 0 at the top of the track view)
1258  *  @param bottom Bottom (higher) y limit in trackview coordinates (ie 0 at the top of the track view)
1259  *  @param preserve_if_selected true to leave the current selection alone if we're adding to the selection and all of the selectables
1260  *  within the region are already selected.
1261  */
1262 bool
1263 Editor::select_all_within (
1264         framepos_t start, framepos_t end, double top, double bot, const TrackViewList& tracklist, Selection::Operation op, bool preserve_if_selected
1265         )
1266 {
1267         list<Selectable*> found;
1268
1269         for (TrackViewList::const_iterator iter = tracklist.begin(); iter != tracklist.end(); ++iter) {
1270
1271                 if ((*iter)->hidden()) {
1272                         continue;
1273                 }
1274
1275                 (*iter)->get_selectables (start, end, top, bot, found);
1276         }
1277
1278         if (found.empty()) {
1279                 return false;
1280         }
1281
1282         if (preserve_if_selected && op != Selection::Toggle) {
1283                 list<Selectable*>::iterator i = found.begin();
1284                 while (i != found.end() && (*i)->get_selected()) {
1285                         ++i;
1286                 }
1287
1288                 if (i == found.end()) {
1289                         return false;
1290                 }
1291         }
1292
1293         begin_reversible_command (_("select all within"));
1294         switch (op) {
1295         case Selection::Add:
1296                 selection->add (found);
1297                 break;
1298         case Selection::Toggle:
1299                 selection->toggle (found);
1300                 break;
1301         case Selection::Set:
1302                 selection->set (found);
1303                 break;
1304         case Selection::Extend:
1305                 /* not defined yet */
1306                 break;
1307         }
1308
1309         commit_reversible_command ();
1310
1311         return !found.empty();
1312 }
1313
1314 void
1315 Editor::set_selection_from_region ()
1316 {
1317         if (selection->regions.empty()) {
1318                 return;
1319         }
1320
1321         selection->set (selection->regions.start(), selection->regions.end_frame());
1322         if (!Profile->get_sae()) {
1323                 set_mouse_mode (Editing::MouseRange, false);
1324         }
1325 }
1326
1327 void
1328 Editor::set_selection_from_punch()
1329 {
1330         Location* location;
1331
1332         if ((location = _session->locations()->auto_punch_location()) == 0)  {
1333                 return;
1334         }
1335
1336         set_selection_from_range (*location);
1337 }
1338
1339 void
1340 Editor::set_selection_from_loop()
1341 {
1342         Location* location;
1343
1344         if ((location = _session->locations()->auto_loop_location()) == 0)  {
1345                 return;
1346         }
1347         set_selection_from_range (*location);
1348 }
1349
1350 void
1351 Editor::set_selection_from_range (Location& loc)
1352 {
1353         begin_reversible_command (_("set selection from range"));
1354         selection->set (loc.start(), loc.end());
1355         commit_reversible_command ();
1356
1357         if (!Profile->get_sae()) {
1358                 set_mouse_mode (Editing::MouseRange, false);
1359         }
1360 }
1361
1362 void
1363 Editor::select_all_selectables_using_time_selection ()
1364 {
1365         list<Selectable *> touched;
1366
1367         if (selection->time.empty()) {
1368                 return;
1369         }
1370
1371         framepos_t start = selection->time[clicked_selection].start;
1372         framepos_t end = selection->time[clicked_selection].end;
1373
1374         if (end - start < 1)  {
1375                 return;
1376         }
1377
1378         TrackViewList* ts;
1379
1380         if (selection->tracks.empty()) {
1381                 ts = &track_views;
1382         } else {
1383                 ts = &selection->tracks;
1384         }
1385
1386         for (TrackViewList::iterator iter = ts->begin(); iter != ts->end(); ++iter) {
1387                 if ((*iter)->hidden()) {
1388                         continue;
1389                 }
1390                 (*iter)->get_selectables (start, end - 1, 0, DBL_MAX, touched);
1391         }
1392
1393         begin_reversible_command (_("select all from range"));
1394         selection->set (touched);
1395         commit_reversible_command ();
1396 }
1397
1398
1399 void
1400 Editor::select_all_selectables_using_punch()
1401 {
1402         Location* location = _session->locations()->auto_punch_location();
1403         list<Selectable *> touched;
1404
1405         if (location == 0 || (location->end() - location->start() <= 1))  {
1406                 return;
1407         }
1408
1409
1410         TrackViewList* ts;
1411
1412         if (selection->tracks.empty()) {
1413                 ts = &track_views;
1414         } else {
1415                 ts = &selection->tracks;
1416         }
1417
1418         for (TrackViewList::iterator iter = ts->begin(); iter != ts->end(); ++iter) {
1419                 if ((*iter)->hidden()) {
1420                         continue;
1421                 }
1422                 (*iter)->get_selectables (location->start(), location->end() - 1, 0, DBL_MAX, touched);
1423         }
1424         begin_reversible_command (_("select all from punch"));
1425         selection->set (touched);
1426         commit_reversible_command ();
1427
1428 }
1429
1430 void
1431 Editor::select_all_selectables_using_loop()
1432 {
1433         Location* location = _session->locations()->auto_loop_location();
1434         list<Selectable *> touched;
1435
1436         if (location == 0 || (location->end() - location->start() <= 1))  {
1437                 return;
1438         }
1439
1440
1441         TrackViewList* ts;
1442
1443         if (selection->tracks.empty()) {
1444                 ts = &track_views;
1445         } else {
1446                 ts = &selection->tracks;
1447         }
1448
1449         for (TrackViewList::iterator iter = ts->begin(); iter != ts->end(); ++iter) {
1450                 if ((*iter)->hidden()) {
1451                         continue;
1452                 }
1453                 (*iter)->get_selectables (location->start(), location->end() - 1, 0, DBL_MAX, touched);
1454         }
1455         begin_reversible_command (_("select all from loop"));
1456         selection->set (touched);
1457         commit_reversible_command ();
1458
1459 }
1460
1461 void
1462 Editor::select_all_selectables_using_cursor (EditorCursor *cursor, bool after)
1463 {
1464         framepos_t start;
1465         framepos_t end;
1466         list<Selectable *> touched;
1467
1468         if (after) {
1469                 begin_reversible_command (_("select all after cursor"));
1470                 start = cursor->current_frame ;
1471                 end = _session->current_end_frame();
1472         } else {
1473                 if (cursor->current_frame > 0) {
1474                         begin_reversible_command (_("select all before cursor"));
1475                         start = 0;
1476                         end = cursor->current_frame - 1;
1477                 } else {
1478                         return;
1479                 }
1480         }
1481
1482
1483         TrackViewList* ts;
1484
1485         if (selection->tracks.empty()) {
1486                 ts = &track_views;
1487         } else {
1488                 ts = &selection->tracks;
1489         }
1490
1491         for (TrackViewList::iterator iter = ts->begin(); iter != ts->end(); ++iter) {
1492                 if ((*iter)->hidden()) {
1493                         continue;
1494                 }
1495                 (*iter)->get_selectables (start, end, 0, DBL_MAX, touched);
1496         }
1497         selection->set (touched);
1498         commit_reversible_command ();
1499 }
1500
1501 void
1502 Editor::select_all_selectables_using_edit (bool after)
1503 {
1504         framepos_t start;
1505         framepos_t end;
1506         list<Selectable *> touched;
1507
1508         if (after) {
1509                 begin_reversible_command (_("select all after edit"));
1510                 start = get_preferred_edit_position();
1511                 end = _session->current_end_frame();
1512         } else {
1513                 if ((end = get_preferred_edit_position()) > 1) {
1514                         begin_reversible_command (_("select all before edit"));
1515                         start = 0;
1516                         end -= 1;
1517                 } else {
1518                         return;
1519                 }
1520         }
1521
1522
1523         TrackViewList* ts;
1524
1525         if (selection->tracks.empty()) {
1526                 ts = &track_views;
1527         } else {
1528                 ts = &selection->tracks;
1529         }
1530
1531         for (TrackViewList::iterator iter = ts->begin(); iter != ts->end(); ++iter) {
1532                 if ((*iter)->hidden()) {
1533                         continue;
1534                 }
1535                 (*iter)->get_selectables (start, end, 0, DBL_MAX, touched);
1536         }
1537         selection->set (touched);
1538         commit_reversible_command ();
1539 }
1540
1541 void
1542 Editor::select_all_selectables_between (bool /*within*/)
1543 {
1544         framepos_t start;
1545         framepos_t end;
1546         list<Selectable *> touched;
1547
1548         if (!get_edit_op_range (start, end)) {
1549                 return;
1550         }
1551
1552         TrackViewList* ts;
1553
1554         if (selection->tracks.empty()) {
1555                 ts = &track_views;
1556         } else {
1557                 ts = &selection->tracks;
1558         }
1559
1560         for (TrackViewList::iterator iter = ts->begin(); iter != ts->end(); ++iter) {
1561                 if ((*iter)->hidden()) {
1562                         continue;
1563                 }
1564                 (*iter)->get_selectables (start, end, 0, DBL_MAX, touched);
1565         }
1566
1567         selection->set (touched);
1568 }
1569
1570 void
1571 Editor::select_range_between ()
1572 {
1573         framepos_t start;
1574         framepos_t end;
1575
1576         if (mouse_mode == MouseRange && !selection->time.empty()) {
1577                 selection->clear_time ();
1578         }
1579
1580         if (!get_edit_op_range (start, end)) {
1581                 return;
1582         }
1583
1584         set_mouse_mode (MouseRange);
1585         selection->set (start, end);
1586 }
1587
1588 bool
1589 Editor::get_edit_op_range (framepos_t& start, framepos_t& end) const
1590 {
1591         framepos_t m;
1592         bool ignored;
1593
1594         /* in range mode, use any existing selection */
1595
1596         if (mouse_mode == MouseRange && !selection->time.empty()) {
1597                 /* we know that these are ordered */
1598                 start = selection->time.start();
1599                 end = selection->time.end_frame();
1600                 return true;
1601         }
1602
1603         if (!mouse_frame (m, ignored)) {
1604                 /* mouse is not in a canvas, try playhead+selected marker.
1605                    this is probably most true when using menus.
1606                  */
1607
1608                 if (selection->markers.empty()) {
1609                         return false;
1610                 }
1611
1612                 start = selection->markers.front()->position();
1613                 end = _session->audible_frame();
1614
1615         } else {
1616
1617                 switch (_edit_point) {
1618                 case EditAtPlayhead:
1619                         if (selection->markers.empty()) {
1620                                 /* use mouse + playhead */
1621                                 start = m;
1622                                 end = _session->audible_frame();
1623                         } else {
1624                                 /* use playhead + selected marker */
1625                                 start = _session->audible_frame();
1626                                 end = selection->markers.front()->position();
1627                         }
1628                         break;
1629
1630                 case EditAtMouse:
1631                         /* use mouse + selected marker */
1632                         if (selection->markers.empty()) {
1633                                 start = m;
1634                                 end = _session->audible_frame();
1635                         } else {
1636                                 start = selection->markers.front()->position();
1637                                 end = m;
1638                         }
1639                         break;
1640
1641                 case EditAtSelectedMarker:
1642                         /* use mouse + selected marker */
1643                         if (selection->markers.empty()) {
1644
1645                                 MessageDialog win (_("No edit range defined"),
1646                                                    false,
1647                                                    MESSAGE_INFO,
1648                                                    BUTTONS_OK);
1649
1650                                 win.set_secondary_text (
1651                                         _("the edit point is Selected Marker\nbut there is no selected marker."));
1652
1653
1654                                 win.set_default_response (RESPONSE_CLOSE);
1655                                 win.set_position (Gtk::WIN_POS_MOUSE);
1656                                 win.show_all();
1657
1658                                 win.run ();
1659
1660                                 return false; // NO RANGE
1661                         }
1662                         start = selection->markers.front()->position();
1663                         end = m;
1664                         break;
1665                 }
1666         }
1667
1668         if (start == end) {
1669                 return false;
1670         }
1671
1672         if (start > end) {
1673                 swap (start, end);
1674         }
1675
1676         /* turn range into one delimited by start...end,
1677            not start...end-1
1678         */
1679
1680         end++;
1681
1682         return true;
1683 }
1684
1685 void
1686 Editor::deselect_all ()
1687 {
1688         selection->clear ();
1689 }
1690
1691 long
1692 Editor::select_range_around_region (RegionView* rv)
1693 {
1694         assert (rv);
1695
1696         selection->set (&rv->get_time_axis_view());
1697
1698         selection->time.clear ();
1699         boost::shared_ptr<Region> r = rv->region ();
1700         return selection->set (r->position(), r->position() + r->length());
1701 }