make per-region note-tracking in MidiPlaylist work correctly, or something very close...
[ardour.git] / gtk2_ardour / region_selection.cc
index a418b1de23623944edcdc4f08fa74c7bcc9f645e..20dd8c1d24fbddccf3b9b73ee0d5af38f9d90ba4 100644 (file)
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2006 Paul Davis 
+    Copyright (C) 2006 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
 
 #include <algorithm>
 
-#include <ardour/region.h>
+#include "ardour/region.h"
 
 #include "region_view.h"
 #include "region_selection.h"
+#include "time_axis_view.h"
 
+using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 using namespace sigc;
 
-
-bool 
-RegionComparator::operator() (const RegionView* a, const RegionView* b) const
-{
-       if (a == b) {
-               return false;
-       } else {
-               return a < b;
-       }
-}
-
+/** Construct an empty RegionSelection.
+ */
 RegionSelection::RegionSelection ()
 {
+       RegionView::RegionViewGoingAway.connect (mem_fun(*this, &RegionSelection::remove_it));
+
        _current_start = 0;
        _current_end = 0;
 }
 
+/** Copy constructor.
+ *  @param other RegionSelection to copy.
+ */
 RegionSelection::RegionSelection (const RegionSelection& other)
+       : std::list<RegionView*>()
+       , sigc::trackable(other)
 {
+       RegionView::RegionViewGoingAway.connect (mem_fun(*this, &RegionSelection::remove_it));
 
-       for (RegionSelection::const_iterator i = other.begin(); i != other.end(); ++i) {
-               add (*i, false);
-       }
        _current_start = other._current_start;
        _current_end = other._current_end;
-}
-
 
+       for (RegionSelection::const_iterator i = other.begin(); i != other.end(); ++i) {
+               add (*i);
+       }
+}
 
+/** operator= to set a RegionSelection to be the same as another.
+ *  @param other Other RegionSelection.
+ */
 RegionSelection&
 RegionSelection::operator= (const RegionSelection& other)
 {
        if (this != &other) {
 
                clear_all();
-               
-               for (RegionSelection::const_iterator i = other.begin(); i != other.end(); ++i) {
-                       add (*i, false);
-               }
 
                _current_start = other._current_start;
                _current_end = other._current_end;
+
+               for (RegionSelection::const_iterator i = other.begin(); i != other.end(); ++i) {
+                       add (*i);
+               }
        }
 
        return *this;
 }
 
+/** Empty this RegionSelection.
+ */
 void
 RegionSelection::clear_all()
 {
@@ -83,101 +88,123 @@ RegionSelection::clear_all()
        _current_end = 0;
 }
 
-bool RegionSelection::contains (RegionView* rv)
+/**
+ *  @param rv RegionView.
+ *  @return true if this selection contains rv.
+ */
+bool RegionSelection::contains (RegionView* rv) const
 {
-       return this->find (rv) != end();
+       return find (begin(), end(), rv) != end();
 }
 
-void
-RegionSelection::add (RegionView* rv, bool dosort)
+/** Add a region to the selection.
+ *  @param rv Region to add.
+ *  @return false if we already had the region, otherwise true.
+ */
+bool
+RegionSelection::add (RegionView* rv)
 {
        if (contains (rv)) {
                /* we already have it */
-               return;
+               return false;
        }
 
-       rv->RegionViewGoingAway.connect (mem_fun(*this, &RegionSelection::remove_it));
-
        if (rv->region()->first_frame() < _current_start || empty()) {
                _current_start = rv->region()->first_frame();
        }
-       
+
        if (rv->region()->last_frame() > _current_end || empty()) {
                _current_end = rv->region()->last_frame();
        }
-       
-       insert (rv);
 
-       // add to layer sorted list
+       push_back (rv);
+
+       /* add to layer sorted list */
+
        add_to_layer (rv);
-       
+
+       return true;
 }
 
+/** Remove a region from the selection.
+ *  @param rv Region to remove.
+ */
 void
 RegionSelection::remove_it (RegionView *rv)
 {
        remove (rv);
 }
 
+/** Remove a region from the selection.
+ *  @param rv Region to remove.
+ *  @return true if the region was in the selection, false if not.
+ */
 bool
 RegionSelection::remove (RegionView* rv)
 {
-       RegionSelection::iterator i;
+       RegionSelection::iterator r;
 
-       if ((i = this->find (rv)) != end()) {
-
-               erase (i);
+       if ((r = find (begin(), end(), rv)) != end()) {
 
                // remove from layer sorted list
                _bylayer.remove (rv);
-               
-               if (empty()) {
+
+               if (size() == 1) {
+
+                       /* this is the last one, so when we delete it
+                          we will be empty.
+                       */
 
                        _current_start = 0;
                        _current_end = 0;
 
                } else {
-                       
-                       boost::shared_ptr<Region> region ((*i)->region());
+
+                       boost::shared_ptr<Region> region ((*r)->region());
 
                        if (region->first_frame() == _current_start) {
-                               
+
                                /* reset current start */
-                               
+
                                nframes_t ref = max_frames;
-                               
-                               for (i = begin (); i != end(); ++i) {
+
+                               for (RegionSelection::iterator i = begin (); i != end(); ++i) {
                                        if (region->first_frame() < ref) {
                                                ref = region->first_frame();
                                        }
                                }
-                               
+
                                _current_start = ref;
-                               
+
                        }
-                       
+
                        if (region->last_frame() == _current_end) {
 
                                /* reset current end */
-                               
+
                                nframes_t ref = 0;
-                               
-                               for (i = begin (); i != end(); ++i) {
+
+                               for (RegionSelection::iterator i = begin (); i != end(); ++i) {
                                        if (region->first_frame() > ref) {
                                                ref = region->first_frame();
                                        }
                                }
-                               
+
                                _current_end = ref;
                        }
                }
 
+               erase (r);
+
                return true;
        }
 
        return false;
 }
 
+/** Add a region to the list sorted by layer.
+ *  @param rv Region to add.
+ */
 void
 RegionSelection::add_to_layer (RegionView * rv)
 {
@@ -198,12 +225,16 @@ RegionSelection::add_to_layer (RegionView * rv)
 }
 
 struct RegionSortByTime {
-    bool operator() (const RegionView* a, const RegionView* b) {
+    bool operator() (const RegionView* a, const RegionView* b) const {
            return a->region()->position() < b->region()->position();
     }
 };
 
 
+/**
+ *  @param foo List which will be filled with the selection's regions
+ *  sorted by position.
+ */
 void
 RegionSelection::by_position (list<RegionView*>& foo) const
 {
@@ -217,3 +248,61 @@ RegionSelection::by_position (list<RegionView*>& foo) const
        foo.sort (sorter);
        return;
 }
+
+struct RegionSortByTrack {
+    bool operator() (const RegionView* a, const RegionView* b) const {
+
+           /* really, track and position */
+
+           if (a->get_trackview().order() == b->get_trackview().order()) {
+                   return a->region()->position() < b->region()->position();
+           } else {
+                   return a->get_trackview().order() < b->get_trackview().order();
+           }
+    }
+};
+
+
+/**
+ *  @param List which will be filled with the selection's regions
+ *  sorted by track and position.
+ */
+void
+RegionSelection::by_track (list<RegionView*>& foo) const
+{
+       list<RegionView*>::const_iterator i;
+       RegionSortByTrack sorter;
+
+       for (i = _bylayer.begin(); i != _bylayer.end(); ++i) {
+               foo.push_back (*i);
+       }
+
+       foo.sort (sorter);
+       return;
+}
+
+/**
+ *  @param Sort the selection by position and track.
+ */
+void
+RegionSelection::sort_by_position_and_track ()
+{
+       RegionSortByTrack sorter;
+       sort (sorter);
+}
+
+/**
+ *  @param tv Track.
+ *  @return true if any of the selection's regions are on tv.
+ */
+bool
+RegionSelection::involves (const TimeAxisView& tv) const
+{
+       for (RegionSelection::const_iterator i = begin(); i != end(); ++i) {
+               if (&(*i)->get_trackview() == &tv) {
+                       return true;
+               }
+       }
+       return false;
+}
+