*/
+#include <stdint.h>
#include <set>
#include <fstream>
#include <algorithm>
#include <string>
#include <climits>
+#include <boost/lexical_cast.hpp>
+#include "pbd/convert.h"
#include "pbd/failed_constructor.h"
-#include "pbd/stl_delete.h"
+#include "pbd/stateful_diff_command.h"
#include "pbd/xml++.h"
-#include "pbd/stacktrace.h"
#include "ardour/debug.h"
#include "ardour/playlist.h"
#include "ardour/playlist_factory.h"
#include "ardour/transient_detector.h"
#include "ardour/session_playlists.h"
+#include "ardour/source_factory.h"
#include "i18n.h"
using namespace ARDOUR;
using namespace PBD;
+namespace ARDOUR {
+namespace Properties {
+PBD::PropertyDescriptor<bool> regions;
+}
+}
+
struct ShowMeTheList {
ShowMeTheList (boost::shared_ptr<Playlist> pl, const string& n) : playlist (pl), name (n) {}
~ShowMeTheList () {
}
};
+void
+Playlist::make_property_quarks ()
+{
+ Properties::regions.property_id = g_quark_from_static_string (X_("regions"));
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for regions = %1\n",
+ Properties::regions.property_id));
+}
+
+RegionListProperty::RegionListProperty (Playlist& pl)
+ : SequenceProperty<std::list<boost::shared_ptr<Region> > > (Properties::regions.property_id, boost::bind (&Playlist::update, &pl, _1))
+ , _playlist (pl)
+{
+
+}
+
+RegionListProperty::RegionListProperty (RegionListProperty const & p)
+ : PBD::SequenceProperty<std::list<boost::shared_ptr<Region> > > (p)
+ , _playlist (p._playlist)
+{
+
+}
+
+RegionListProperty *
+RegionListProperty::clone () const
+{
+ return new RegionListProperty (*this);
+}
+
+RegionListProperty *
+RegionListProperty::create () const
+{
+ return new RegionListProperty (_playlist);
+}
+
+void
+RegionListProperty::get_content_as_xml (boost::shared_ptr<Region> region, XMLNode & node) const
+{
+ /* All regions (even those which are deleted) have their state saved by other
+ code, so we can just store ID here.
+ */
+
+ node.add_property ("id", region->id().to_s ());
+}
+
+boost::shared_ptr<Region>
+RegionListProperty::get_content_from_xml (XMLNode const & node) const
+{
+ XMLProperty const * prop = node.property ("id");
+ assert (prop);
+
+ PBD::ID id (prop->value ());
+
+ boost::shared_ptr<Region> ret = _playlist.region_by_id (id);
+
+ if (!ret) {
+ ret = RegionFactory::region_by_id (id);
+ }
+
+ return ret;
+}
Playlist::Playlist (Session& sess, string nom, DataType type, bool hide)
: SessionObject(sess, nom)
+ , regions (*this)
, _type(type)
{
init (hide);
first_set_state = false;
_name = nom;
-
+ _set_sort_id ();
}
Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide)
: SessionObject(sess, "unnamed playlist")
+ , regions (*this)
, _type(type)
{
+#ifndef NDEBUG
const XMLProperty* prop = node.property("type");
assert(!prop || DataType(prop->value()) == _type);
+#endif
init (hide);
_name = "unnamed"; /* reset by set_state */
+ _set_sort_id ();
/* set state called by derived class */
}
Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, bool hide)
: SessionObject(other->_session, namestr)
+ , regions (*this)
, _type(other->_type)
- , _orig_diskstream_id(other->_orig_diskstream_id)
+ , _orig_diskstream_id (other->_orig_diskstream_id)
{
init (hide);
Playlist::Playlist (boost::shared_ptr<const Playlist> other, framepos_t start, framecnt_t cnt, string str, bool hide)
: SessionObject(other->_session, str)
+ , regions (*this)
, _type(other->_type)
- , _orig_diskstream_id(other->_orig_diskstream_id)
+ , _orig_diskstream_id (other->_orig_diskstream_id)
{
RegionLock rlock2 (const_cast<Playlist*> (other.get()));
in_set_state++;
- for (RegionList::const_iterator i = other->regions.begin(); i != other->regions.end(); i++) {
+ for (RegionList::const_iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
boost::shared_ptr<Region> region;
boost::shared_ptr<Region> new_region;
break;
}
- _session.region_name (new_name, region->name(), false);
+ RegionFactory::region_name (new_name, region->name(), false);
PropertyList plist;
- plist.add (Properties::start, offset);
+ plist.add (Properties::start, region->start() + offset);
plist.add (Properties::length, len);
plist.add (Properties::name, new_name);
plist.add (Properties::layer, region->layer());
RegionLock rlock (const_cast<Playlist *> (this));
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
- newlist.push_back (RegionFactory::RegionFactory::create (*i));
+ newlist.push_back (RegionFactory::RegionFactory::create (*i, true));
}
}
void
Playlist::init (bool hide)
{
+ add_property (regions);
+ _xml_node_name = X_("Playlist");
+
g_atomic_int_set (&block_notifications, 0);
g_atomic_int_set (&ignore_state_changes, 0);
pending_contents_change = false;
_shuffling = false;
_nudging = false;
in_set_state = 0;
+ in_update = false;
_edit_mode = Config->get_edit_mode();
in_flush = false;
in_partition = false;
layer_op_counter = 0;
freeze_length = 0;
_explicit_relayering = false;
+ _combine_ops = 0;
+ _session.history().BeginUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::begin_undo, this));
+ _session.history().EndUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::end_undo, this));
+
ContentsChanged.connect_same_thread (*this, boost::bind (&Playlist::mark_session_dirty, this));
}
/* GoingAway must be emitted by derived classes */
}
+void
+Playlist::_set_sort_id ()
+{
+ /*
+ Playlists are given names like <track name>.<id>
+ or <track name>.<edit group name>.<id> where id
+ is an integer. We extract the id and sort by that.
+ */
+
+ size_t dot_position = _name.val().find_last_of(".");
+
+ if (dot_position == string::npos) {
+ _sort_id = 0;
+ } else {
+ string t = _name.val().substr(dot_position + 1);
+
+ try {
+ _sort_id = boost::lexical_cast<int>(t);
+ }
+
+ catch (boost::bad_lexical_cast e) {
+ _sort_id = 0;
+ }
+ }
+}
+
bool
Playlist::set_name (const string& str)
{
if (_refcnt > 2) {
return false;
- } else {
- return SessionObject::set_name(str);
+ }
+
+ bool ret = SessionObject::set_name(str);
+ if (ret) {
+ _set_sort_id ();
}
+ return ret;
}
/***********************************************************************
the lock (e.g. to read from the playlist).
***********************************************************************/
+void
+Playlist::begin_undo ()
+{
+ in_update = true;
+ freeze ();
+}
+
+void
+Playlist::end_undo ()
+{
+ thaw (true);
+ in_update = false;
+}
+
void
Playlist::freeze ()
{
g_atomic_int_inc (&ignore_state_changes);
}
+/** @param from_undo true if this thaw is triggered by the end of an undo on this playlist */
void
-Playlist::thaw ()
+Playlist::thaw (bool from_undo)
{
g_atomic_int_dec_and_test (&ignore_state_changes);
- release_notifications ();
+ release_notifications (from_undo);
}
Playlist::delay_notifications ()
{
g_atomic_int_inc (&block_notifications);
- freeze_length = _get_maximum_extent();
+ freeze_length = _get_extent().second;
}
+/** @param from_undo true if this release is triggered by the end of an undo on this playlist */
void
-Playlist::release_notifications ()
+Playlist::release_notifications (bool from_undo)
{
if (g_atomic_int_dec_and_test (&block_notifications)) {
- flush_notifications ();
+ flush_notifications (from_undo);
}
}
pending_contents_change = true;
} else {
pending_contents_change = false;
- cerr << _name << "send contents change @ " << get_microseconds() << endl;
ContentsChanged(); /* EMIT SIGNAL */
- cerr << _name << "done with cc @ " << get_microseconds() << endl;
}
}
pending_layering = true;
} else {
pending_layering = false;
- cerr << _name << "send layering @ " << get_microseconds() << endl;
LayeringChanged(); /* EMIT SIGNAL */
- cerr << _name << "done with layering @ " << get_microseconds() << endl;
}
}
list< Evoral::RangeMove<framepos_t> > m;
m.push_back (move);
- RangesMoved (m);
+ RangesMoved (m, false);
+ }
+
+}
+
+void
+Playlist::notify_region_start_trimmed (boost::shared_ptr<Region> r)
+{
+ if (r->position() >= r->last_position()) {
+ /* trimmed shorter */
+ return;
}
+ Evoral::Range<framepos_t> const extra (r->position(), r->last_position());
+
+ if (holding_state ()) {
+
+ pending_region_extensions.push_back (extra);
+
+ } else {
+
+ list<Evoral::Range<framepos_t> > r;
+ r.push_back (extra);
+ RegionsExtended (r);
+
+ }
}
+void
+Playlist::notify_region_end_trimmed (boost::shared_ptr<Region> r)
+{
+ if (r->length() < r->last_length()) {
+ /* trimmed shorter */
+ }
+
+ Evoral::Range<framepos_t> const extra (r->position() + r->last_length(), r->position() + r->length());
+
+ if (holding_state ()) {
+
+ pending_region_extensions.push_back (extra);
+
+ } else {
+
+ list<Evoral::Range<framepos_t> > r;
+ r.push_back (extra);
+ RegionsExtended (r);
+ }
+}
+
+
void
Playlist::notify_region_added (boost::shared_ptr<Region> r)
{
pending_contents_change = true;
pending_length = true;
} else {
+ r->clear_changes ();
pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
pending_contents_change = false;
RegionAdded (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
- cerr << _name << "send3 contents changed @ " << get_microseconds() << endl;
ContentsChanged (); /* EMIT SIGNAL */
- cerr << _name << "done contents changed @ " << get_microseconds() << endl;
}
}
pending_length = false;
LengthChanged(); /* EMIT SIGNAL */
pending_contents_change = false;
- cerr << _name << "send4 contents change @ " << get_microseconds() << endl;
ContentsChanged (); /* EMIT SIGNAL */
- cerr << _name << "done contents change @ " << get_microseconds() << endl;
}
}
+/** @param from_undo true if this flush is triggered by the end of an undo on this playlist */
void
-Playlist::flush_notifications ()
+Playlist::flush_notifications (bool from_undo)
{
set<boost::shared_ptr<Region> > dependent_checks_needed;
set<boost::shared_ptr<Region> >::iterator s;
if (!pending_bounds.empty() || !pending_removes.empty() || !pending_adds.empty()) {
regions_changed = true;
if (!pending_length) {
- old_length = _get_maximum_extent ();
+ old_length = _get_extent ().second;
check_length = true;
}
}
for (s = pending_removes.begin(); s != pending_removes.end(); ++s) {
remove_dependents (*s);
- cerr << _name << " sends RegionRemoved\n";
+ // cerr << _name << " sends RegionRemoved\n";
RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
}
for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
- cerr << _name << " sends RegionAdded\n";
- RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
+ // cerr << _name << " sends RegionAdded\n";
+ /* don't emit RegionAdded signal until relayering is done,
+ so that the region is fully setup by the time
+ anyone hear's that its been added
+ */
dependent_checks_needed.insert (*s);
}
if (check_length) {
- if (old_length != _get_maximum_extent()) {
+ if (old_length != _get_extent().second) {
pending_length = true;
- cerr << _name << " length has changed\n";
+ // cerr << _name << " length has changed\n";
}
}
- if (pending_length || (freeze_length != _get_maximum_extent())) {
+ if (pending_length || (freeze_length != _get_extent().second)) {
pending_length = false;
- cerr << _name << " sends LengthChanged\n";
+ // cerr << _name << " sends LengthChanged\n";
LengthChanged(); /* EMIT SIGNAL */
}
relayer ();
}
pending_contents_change = false;
- cerr << _name << " sends 5 contents change @ " << get_microseconds() << endl;
+ // cerr << _name << " sends 5 contents change @ " << get_microseconds() << endl;
ContentsChanged (); /* EMIT SIGNAL */
- cerr << _name << "done contents change @ " << get_microseconds() << endl;
+ // cerr << _name << "done contents change @ " << get_microseconds() << endl;
+ }
+
+ for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+ (*s)->clear_changes ();
+ RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
}
for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) {
}
if (!pending_range_moves.empty ()) {
- cerr << _name << " sends RangesMoved\n";
- RangesMoved (pending_range_moves);
+ RangesMoved (pending_range_moves, from_undo);
+ }
+
+ if (!pending_region_extensions.empty ()) {
+ RegionsExtended (pending_region_extensions);
}
clear_pending ();
pending_removes.clear ();
pending_bounds.clear ();
pending_range_moves.clear ();
+ pending_region_extensions.clear ();
pending_contents_change = false;
pending_length = false;
}
framepos_t pos = position;
if (times == 1 && auto_partition){
- partition(pos, (pos + region->length()), true);
+ partition(pos - 1, (pos + region->length()), true);
}
if (itimes >= 1) {
*/
for (int i = 0; i < itimes; ++i) {
- boost::shared_ptr<Region> copy = RegionFactory::create (region);
+ boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
add_region_internal (copy, pos);
pos += region->length();
}
if (floor (times) != times) {
length = (framecnt_t) floor (region->length() * (times - floor (times)));
string name;
- _session.region_name (name, region->name(), false);
+ RegionFactory::region_name (name, region->name(), false);
{
PropertyList plist;
- plist.add (Properties::start, 0);
+ plist.add (Properties::start, region->start());
plist.add (Properties::length, length);
plist.add (Properties::name, name);
plist.add (Properties::layer, region->layer());
framecnt_t old_length = 0;
if (!holding_state()) {
- old_length = _get_maximum_extent();
+ old_length = _get_extent().second;
}
if (!first_set_state) {
possibly_splice_unlocked (position, region->length(), region);
- if (!holding_state () && !in_set_state) {
- /* layers get assigned from XML state */
+ if (!holding_state ()) {
+ /* layers get assigned from XML state, and are not reset during undo/redo */
relayer ();
}
check_dependents (region, false);
- if (old_length != _get_maximum_extent()) {
+ if (old_length != _get_extent().second) {
notify_length_changed ();
}
}
- region->StateChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
+ region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
return true;
}
int ret = -1;
if (!holding_state()) {
- old_length = _get_maximum_extent();
+ old_length = _get_extent().second;
}
if (!in_set_state) {
relayer ();
remove_dependents (region);
- if (old_length != _get_maximum_extent()) {
+ if (old_length != _get_extent().second) {
notify_length_changed ();
}
}
}
}
- /* XXX and thaw ... */
-
- return ret;
+ return -1;
}
void
partition_internal (start, end, cut, thawlist);
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
- (*i)->thaw ();
+ (*i)->resume_property_changes ();
}
}
get operated on as well.
*/
- RegionList copy = regions;
+ RegionList copy = regions.rlist();
for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
if (!cutting) {
/* "middle" ++++++ */
- _session.region_name (new_name, current->name(), false);
+ RegionFactory::region_name (new_name, current->name(), false);
PropertyList plist;
- plist.add (Properties::start, pos2 - pos1);
+ plist.add (Properties::start, current->start() + (pos2 - pos1));
plist.add (Properties::length, pos3 - pos2);
plist.add (Properties::name, new_name);
plist.add (Properties::layer, regions.size());
/* "end" ====== */
- _session.region_name (new_name, current->name(), false);
+ RegionFactory::region_name (new_name, current->name(), false);
PropertyList plist;
- plist.add (Properties::start, pos3 - pos1);
+ plist.add (Properties::start, current->start() + (pos3 - pos1));
plist.add (Properties::length, pos4 - pos3);
plist.add (Properties::name, new_name);
plist.add (Properties::layer, regions.size());
/* "front" ***** */
- current->freeze ();
+ current->suspend_property_changes ();
thawlist.push_back (current);
- current->trim_end (pos2, this);
+ current->cut_end (pos2 - 1, this);
} else if (overlap == OverlapEnd) {
/* end +++++ */
- _session.region_name (new_name, current->name(), false);
+ RegionFactory::region_name (new_name, current->name(), false);
PropertyList plist;
- plist.add (Properties::start, pos2 - pos1);
+ plist.add (Properties::start, current->start() + (pos2 - pos1));
plist.add (Properties::length, pos4 - pos2);
plist.add (Properties::name, new_name);
plist.add (Properties::layer, regions.size());
/* front ****** */
- current->freeze ();
+ current->suspend_property_changes ();
thawlist.push_back (current);
- current->trim_end (pos2, this);
+ current->cut_end (pos2 - 1, this);
} else if (overlap == OverlapStart) {
if (!cutting) {
/* front **** */
- _session.region_name (new_name, current->name(), false);
+ RegionFactory::region_name (new_name, current->name(), false);
PropertyList plist;
- plist.add (Properties::start, 0);
+ plist.add (Properties::start, current->start());
plist.add (Properties::length, pos3 - pos1);
plist.add (Properties::name, new_name);
plist.add (Properties::layer, regions.size());
/* end */
- current->freeze ();
+ current->suspend_property_changes ();
thawlist.push_back (current);
current->trim_front (pos3, this);
} else if (overlap == OverlapExternal) {
partition_internal (start, start+cnt-1, true, thawlist);
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
- (*i)->thaw ();
+ (*i)->resume_property_changes();
}
return the_copy;
new_name += '.';
new_name += buf;
- cnt = min (_get_maximum_extent() - start, cnt);
+ cnt = min (_get_extent().second - start, cnt);
return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
}
Playlist::paste (boost::shared_ptr<Playlist> other, framepos_t position, float times)
{
times = fabs (times);
- framecnt_t old_length;
{
RegionLock rl1 (this);
RegionLock rl2 (other.get());
- old_length = _get_maximum_extent();
+ framecnt_t const old_length = _get_extent().second;
int itimes = (int) floor (times);
framepos_t pos = position;
- framecnt_t shift = other->_get_maximum_extent();
+ framecnt_t const shift = other->_get_extent().second;
layer_t top_layer = regions.size();
while (itimes--) {
for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
- boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i);
+ boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i, true);
/* put these new regions on top of all existing ones, but preserve
the ordering they had in the original playlist.
*/
copy_of_region->set_layer (copy_of_region->layer() + top_layer);
- add_region_internal (copy_of_region, copy_of_region->position() + pos);
+ add_region_internal (copy_of_region, (*i)->position() + pos);
}
pos += shift;
}
/* XXX shall we handle fractional cases at some point? */
- if (old_length != _get_maximum_extent()) {
+ if (old_length != _get_extent().second) {
notify_length_changed ();
}
RegionLock rl (this);
int itimes = (int) floor (times);
- framepos_t pos = position;
+ framepos_t pos = position + 1;
while (itimes--) {
- boost::shared_ptr<Region> copy = RegionFactory::create (region);
+ boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
add_region_internal (copy, pos);
pos += region->length();
}
if (floor (times) != times) {
framecnt_t length = (framecnt_t) floor (region->length() * (times - floor (times)));
string name;
- _session.region_name (name, region->name(), false);
+ RegionFactory::region_name (name, region->name(), false);
{
PropertyList plist;
- plist.add (Properties::start, 0);
+ plist.add (Properties::start, region->start());
plist.add (Properties::length, length);
plist.add (Properties::name, name);
Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
{
RegionLock rlock (this);
- RegionList copy (regions);
+ RegionList copy (regions.rlist());
RegionList fixup;
for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) {
has to be done separately.
*/
- if (!ignore_music_glue && (*r)->positional_lock_style() != Region::AudioTime) {
+ if (!ignore_music_glue && (*r)->position_lock_style() != AudioTime) {
fixup.push_back (*r);
continue;
}
Playlist::split (framepos_t at)
{
RegionLock rlock (this);
- RegionList copy (regions);
+ RegionList copy (regions.rlist());
/* use a copy since this operation can modify the region list
*/
before = playlist_position - region->position();
after = region->length() - before;
- _session.region_name (before_name, region->name(), false);
+ RegionFactory::region_name (before_name, region->name(), false);
{
PropertyList plist;
-
- plist.add (Properties::start, 0);
+
+ plist.add (Properties::position, region->position ());
plist.add (Properties::length, before);
plist.add (Properties::name, before_name);
plist.add (Properties::left_of_split, true);
-
- left = RegionFactory::create (region, plist);
+
+ /* note: we must use the version of ::create with an offset here,
+ since it supplies that offset to the Region constructor, which
+ is necessary to get audio region gain envelopes right.
+ */
+ left = RegionFactory::create (region, 0, plist);
}
- _session.region_name (after_name, region->name(), false);
+ RegionFactory::region_name (after_name, region->name(), false);
{
PropertyList plist;
-
- plist.add (Properties::start, before);
+
+ plist.add (Properties::position, region->position() + before);
plist.add (Properties::length, after);
plist.add (Properties::name, after_name);
plist.add (Properties::right_of_split, true);
- right = RegionFactory::create (region, plist);
+ /* same note as above */
+ right = RegionFactory::create (region, before, plist);
}
add_region_internal (left, region->position());
framepos_t new_pos = (*i)->position() + distance;
if (new_pos < 0) {
new_pos = 0;
- } else if (new_pos >= max_frames - (*i)->length()) {
- new_pos = max_frames - (*i)->length();
+ } else if (new_pos >= max_framepos - (*i)->length()) {
+ new_pos = max_framepos - (*i)->length();
}
(*i)->set_position (new_pos, this);
}
void
-Playlist::region_bounds_changed (PropertyChange what_changed, boost::shared_ptr<Region> region)
+Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
{
if (in_set_state || _splicing || _nudging || _shuffling) {
return;
}
- if (what_changed & ARDOUR::PositionChanged) {
+ if (what_changed.contains (Properties::position)) {
/* remove it from the list then add it back in
the right place again.
RegionList::iterator i = find (regions.begin(), regions.end(), region);
if (i == regions.end()) {
- warning << string_compose (_("%1: bounds changed received for region (%2)not in playlist"),
- _name, region->name())
- << endmsg;
+ /* the region bounds are being modified but its not currently
+ in the region list. we will use its bounds correctly when/if
+ it is added
+ */
return;
}
regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
}
- if (what_changed & PropertyChange (ARDOUR::PositionChanged|ARDOUR::LengthChanged)) {
+ if (what_changed.contains (Properties::position) || what_changed.contains (Properties::length)) {
frameoffset_t delta = 0;
- if (what_changed & ARDOUR::PositionChanged) {
+ if (what_changed.contains (Properties::position)) {
delta = region->position() - region->last_position();
}
- if (what_changed & ARDOUR::LengthChanged) {
+ if (what_changed.contains (Properties::length)) {
delta += region->length() - region->last_length();
}
}
void
-Playlist::region_changed_proxy (PropertyChange what_changed, boost::weak_ptr<Region> weak_region)
+Playlist::region_changed_proxy (const PropertyChange& what_changed, boost::weak_ptr<Region> weak_region)
{
boost::shared_ptr<Region> region (weak_region.lock());
}
bool
-Playlist::region_changed (PropertyChange what_changed, boost::shared_ptr<Region> region)
+Playlist::region_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
{
- PropertyChange our_interests = PropertyChange (Region::MuteChanged|Region::LayerChanged|Region::OpacityChanged);
+ PropertyChange our_interests;
+ PropertyChange bounds;
+ PropertyChange pos_and_length;
bool save = false;
if (in_set_state || in_flush) {
return false;
}
- if (what_changed & BoundsChanged) {
+ our_interests.add (Properties::muted);
+ our_interests.add (Properties::layer);
+ our_interests.add (Properties::opaque);
+
+ bounds.add (Properties::start);
+ bounds.add (Properties::position);
+ bounds.add (Properties::length);
+
+ pos_and_length.add (Properties::position);
+ pos_and_length.add (Properties::length);
+
+ if (what_changed.contains (bounds)) {
region_bounds_changed (what_changed, region);
save = !(_splicing || _nudging);
}
- if ((what_changed & our_interests) &&
- !(what_changed & PropertyChange (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
+ if (what_changed.contains (our_interests) && !what_changed.contains (pos_and_length)) {
check_dependents (region, false);
}
- if (what_changed & PropertyChange (ARDOUR::PositionChanged)) {
+ if (what_changed.contains (Properties::position) && !what_changed.contains (Properties::length)) {
notify_region_moved (region);
+ } else if (!what_changed.contains (Properties::position) && what_changed.contains (Properties::length)) {
+ notify_region_end_trimmed (region);
+ } else if (what_changed.contains (Properties::position) && what_changed.contains (Properties::length)) {
+ notify_region_start_trimmed (region);
}
-
/* don't notify about layer changes, since we are the only object that can initiate
them, and we notify in ::relayer()
*/
- if (what_changed & our_interests) {
+ if (what_changed.contains (our_interests)) {
save = true;
}
all_regions.clear ();
}
+void
+Playlist::sync_all_regions_with_regions ()
+{
+ RegionLock rl (this);
+
+ all_regions.clear ();
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ all_regions.insert (*i);
+ }
+}
+
void
Playlist::clear (bool with_signals)
{
}
regions.clear ();
+
+ for (set<boost::shared_ptr<Region> >::iterator s = pending_removes.begin(); s != pending_removes.end(); ++s) {
+ remove_dependents (*s);
+ }
}
if (with_signals) {
+
+ for (set<boost::shared_ptr<Region> >::iterator s = pending_removes.begin(); s != pending_removes.end(); ++s) {
+ RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
+ }
+
+ pending_removes.clear ();
pending_length = false;
LengthChanged ();
pending_contents_change = false;
- cerr << _name << "send2 contents change @ " << get_microseconds() << endl;
ContentsChanged ();
- cerr << _name << "done with contents changed @ " << get_microseconds() << endl;
}
}
return find_regions_at (frame);
}
+uint32_t
+Playlist::count_regions_at (framepos_t frame) const
+{
+ RegionLock rlock (const_cast<Playlist*>(this));
+ uint32_t cnt = 0;
+
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i)->covers (frame)) {
+ cnt++;
+ }
+ }
+
+ return cnt;
+}
+
boost::shared_ptr<Region>
Playlist::top_region_at (framepos_t frame)
RegionList covering;
set<framepos_t> to_check;
set<boost::shared_ptr<Region> > unique;
- RegionList here;
to_check.insert (start);
to_check.insert (end);
+ DEBUG_TRACE (DEBUG::AudioPlayback, ">>>>> REGIONS TO READ\n");
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
/* find all/any regions that span start+end */
case OverlapInternal:
covering.push_back (*i);
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OInternal)\n", (*i)->name()));
break;
case OverlapStart:
to_check.insert ((*i)->position());
+ if ((*i)->position() != 0) {
+ to_check.insert ((*i)->position()-1);
+ }
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will check %1 for %2\n", (*i)->position(), (*i)->name()));
covering.push_back (*i);
break;
case OverlapEnd:
to_check.insert ((*i)->last_frame());
+ to_check.insert ((*i)->last_frame()+1);
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OEnd)\n", (*i)->name()));
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
covering.push_back (*i);
break;
case OverlapExternal:
covering.push_back (*i);
to_check.insert ((*i)->position());
+ if ((*i)->position() != 0) {
+ to_check.insert ((*i)->position()-1);
+ }
to_check.insert ((*i)->last_frame());
+ to_check.insert ((*i)->last_frame()+1);
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OExt)\n", (*i)->name()));
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->position(), (*i)->name()));
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name()));
break;
}
if (covering.size() == 1) {
rlist->push_back (covering.front());
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("Just one covering region (%1)\n", covering.front()->name()));
} else {
+ RegionList here;
for (set<framepos_t>::iterator t = to_check.begin(); t != to_check.end(); ++t) {
here.clear ();
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("++++ Considering %1\n", *t));
+
for (RegionList::iterator x = covering.begin(); x != covering.end(); ++x) {
if ((*x)->covers (*t)) {
here.push_back (*x);
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("region %1 covers %2\n",
+ (*x)->name(),
+ (*t)));
+ } else {
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("region %1 does NOT covers %2\n",
+ (*x)->name(),
+ (*t)));
}
+
}
RegionSortByLayer cmp;
if ((*c)->opaque()) {
/* the other regions at this position are hidden by this one */
-
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("%1 is opaque, ignore all others\n",
+ (*c)->name()));
break;
}
}
}
}
+ DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("<<<<< REGIONS TO READ returns %1\n", rlist->size()));
+
return rlist;
}
{
RegionLock rlock (this);
boost::shared_ptr<Region> ret;
- framepos_t closest = max_frames;
+ framepos_t closest = max_framepos;
bool end_iter = false;
break;
case SyncPoint:
pos = r->sync_position ();
- // r->adjust_to_sync (r->first_frame());
break;
}
{
RegionLock rlock (this);
- framepos_t closest = max_frames;
+ framepos_t closest = max_framepos;
framepos_t ret = -1;
if (dir > 0) {
return ret;
}
+
/***********************************************************************/
}
}
+void
+Playlist::rdiff (vector<Command*>& cmds) const
+{
+ RegionLock rlock (const_cast<Playlist *> (this));
+ Stateful::rdiff (cmds);
+}
+
+void
+Playlist::clear_owned_changes ()
+{
+ RegionLock rlock (this);
+ Stateful::clear_owned_changes ();
+}
+
+void
+Playlist::update (const RegionListProperty::ChangeRecord& change)
+{
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("Playlist %1 updates from a change record with %2 adds %3 removes\n",
+ name(), change.added.size(), change.removed.size()));
+
+ freeze ();
+ /* add the added regions */
+ for (RegionListProperty::ChangeContainer::iterator i = change.added.begin(); i != change.added.end(); ++i) {
+ add_region ((*i), (*i)->position());
+ }
+ /* remove the removed regions */
+ for (RegionListProperty::ChangeContainer::iterator i = change.removed.begin(); i != change.removed.end(); ++i) {
+ remove_region (*i);
+ }
+
+ thaw ();
+}
+
+void
+Playlist::load_nested_sources (const XMLNode& node)
+{
+ XMLNodeList nlist;
+ XMLNodeConstIterator niter;
+
+ nlist = node.children();
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == "Source") {
+ try {
+ SourceFactory::create (_session, **niter, true);
+ }
+ catch (failed_constructor& err) {
+ error << string_compose (_("Cannot reconstruct nested source for playlist %1"), name()) << endmsg;
+ }
+ }
+ }
+}
+
int
Playlist::set_state (const XMLNode& node, int version)
{
if (prop->name() == X_("name")) {
_name = prop->value();
+ _set_sort_id ();
+ } else if (prop->name() == X_("id")) {
+ _id = prop->value();
} else if (prop->name() == X_("orig_diskstream_id")) {
_orig_diskstream_id = prop->value ();
} else if (prop->name() == X_("frozen")) {
_frozen = string_is_affirmative (prop->value());
+ } else if (prop->name() == X_("combine-ops")) {
+ _combine_ops = atoi (prop->value());
}
}
- clear (false);
+ clear (true);
nlist = node.children();
+ /* find the "Nested" node, if any, and recreate the PlaylistSources
+ listed there
+ */
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ child = *niter;
+
+ if (child->name() == "Nested") {
+ load_nested_sources (*child);
+ break;
+ }
+ }
+
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
child = *niter;
error << _("region state node has no ID, ignored") << endmsg;
continue;
}
-
+
ID id = prop->value ();
if ((region = region_by_id (id))) {
- region->freeze ();
+ region->suspend_property_changes ();
if (region->set_state (*child, version)) {
- region->thaw ();
+ region->resume_property_changes ();
continue;
}
} else if ((region = RegionFactory::create (_session, *child, true)) != 0) {
- region->freeze ();
+ region->suspend_property_changes ();
} else {
error << _("Playlist: cannot create region from XML") << endmsg;
continue;
}
+
add_region (region, region->position(), 1.0);
// So that layer_op ordering doesn't get screwed up
region->set_last_layer_op( region->layer());
- region->thaw ();
+ region->resume_property_changes ();
}
}
check_dependents (*r, false);
}
- clear_pending (); // this makes thaw() do nothing
thaw ();
notify_contents_changed ();
XMLNode *node = new XMLNode (X_("Playlist"));
char buf[64];
+ node->add_property (X_("id"), id().to_s());
node->add_property (X_("name"), _name);
node->add_property (X_("type"), _type.to_string());
if (full_state) {
RegionLock rlock (this, false);
+ XMLNode* nested_node = 0;
+
+ snprintf (buf, sizeof (buf), "%u", _combine_ops);
+ node->add_property ("combine-ops", buf);
+
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i)->max_source_level() > 0) {
+
+ if (!nested_node) {
+ nested_node = new XMLNode (X_("Nested"));
+ }
+
+ /* region is compound - get its playlist and
+ store that before we list the region that
+ needs it ...
+ */
+
+ const SourceList& sl ((*i)->sources());
+
+ for (SourceList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
+ nested_node->add_child_nocopy ((*s)->get_state ());
+ }
+ }
+ }
+
+ if (nested_node) {
+ node->add_child_nocopy (*nested_node);
+ }
+
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
node->add_child_nocopy ((*i)->get_state());
}
return regions.size();
}
-framecnt_t
-Playlist::get_maximum_extent () const
+pair<framepos_t, framepos_t>
+Playlist::get_extent () const
{
RegionLock rlock (const_cast<Playlist *>(this), false);
- return _get_maximum_extent ();
+ return _get_extent ();
}
-framecnt_t
-Playlist::_get_maximum_extent () const
+pair<framepos_t, framepos_t>
+Playlist::_get_extent () const
{
- RegionList::const_iterator i;
- framecnt_t max_extent = 0;
- framepos_t end = 0;
+ pair<framepos_t, framepos_t> ext (max_framepos, 0);
- for (i = regions.begin(); i != regions.end(); ++i) {
- if ((end = (*i)->position() + (*i)->length()) > max_extent) {
- max_extent = end;
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+ pair<framepos_t, framepos_t> const e ((*i)->position(), (*i)->position() + (*i)->length());
+ if (e.first < ext.first) {
+ ext.first = e.first;
+ }
+ if (e.second > ext.second) {
+ ext.second = e.second;
}
}
- return max_extent;
+ return ext;
}
string
string newname = name;
do {
- newname = bump_name_once (newname);
+ newname = bump_name_once (newname, '.');
} while (session.playlists->by_name (newname)!=NULL);
return newname;
void
Playlist::relayer ()
{
+ /* never compute layers when changing state for undo/redo or setting from XML */
+
+ if (in_update || in_set_state) {
+ return;
+ }
+
bool changed = false;
/* Build up a new list of regions on each layer, stored in a set of lists
int const divisions = 512;
/* find the start and end positions of the regions on this playlist */
- framepos_t start = UINT_MAX;
+ framepos_t start = INT64_MAX;
framepos_t end = 0;
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
start = min (start, (*i)->position());
which depends on the layer model
*/
- RegionList copy = regions;
+ RegionList copy = regions.rlist();
/* sort according to the model and the layering mode that we're in */
}
+
for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
/* reset the pending explicit relayer flag for every region, now that we're relayering */
(*i)->set_pending_explicit_relayer (false);
- /* find the time divisions that this region covers */
- int const start_division = floor ( ((*i)->position() - start) / division_size);
- int end_division = floor ( ((*i)->position() + (*i)->length() - start) / division_size );
- if (end_division == divisions) {
- end_division--;
+ /* find the time divisions that this region covers; if there are no regions on the list,
+ division_size will equal 0 and in this case we'll just say that
+ start_division = end_division = 0.
+ */
+ int start_division = 0;
+ int end_division = 0;
+
+ if (division_size > 0) {
+ start_division = floor ( ((*i)->position() - start) / division_size);
+ end_division = floor ( ((*i)->position() + (*i)->length() - start) / division_size );
+ if (end_division == divisions) {
+ end_division--;
+ }
}
- assert (end_division < divisions);
+ assert (divisions == 0 || end_division < divisions);
/* find the lowest layer that this region can go on */
size_t j = layers.size();
void
Playlist::raise_region (boost::shared_ptr<Region> region)
{
- uint32_t rsz = regions.size();
+ uint32_t top = regions.size() - 1;
layer_t target = region->layer() + 1U;
- if (target >= rsz) {
+ if (target >= top) {
/* its already at the effective top */
return;
}
Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((_session.config.get_layer_model() == MoveAddHigher) ||
- (_session.config.get_layer_model() == AddHigher)) {
- timestamp_layer_op (region);
- relayer ();
+ switch (_session.config.get_layer_model()) {
+ case LaterHigher:
+ return;
+ default:
+ break;
}
+
+ layer_t top = regions.size() - 1;
+
+ if (region->layer() >= top) {
+ /* already on the top */
+ return;
+ }
+
+ move_region_to_layer (top, region, 1);
+ /* mark the region's last_layer_op as now, so that it remains on top when
+ doing future relayers (until something else takes over)
+ */
+ timestamp_layer_op (region);
}
void
Playlist::lower_region_to_bottom (boost::shared_ptr<Region> region)
{
/* does nothing useful if layering mode is later=higher */
- if ((_session.config.get_layer_model() == MoveAddHigher) ||
- (_session.config.get_layer_model() == AddHigher)) {
- region->set_last_layer_op (0);
- relayer ();
+ switch (_session.config.get_layer_model()) {
+ case LaterHigher:
+ return;
+ default:
+ break;
+ }
+
+ if (region->layer() == 0) {
+ /* already on the bottom */
+ return;
}
+
+ move_region_to_layer (0, region, -1);
+ /* force region's last layer op to zero so that it stays at the bottom
+ when doing future relayers
+ */
+ region->set_last_layer_op (0);
}
int
RegionList::iterator i;
typedef pair<boost::shared_ptr<Region>,layer_t> LayerInfo;
list<LayerInfo> layerinfo;
- layer_t dest;
{
RegionLock rlock (const_cast<Playlist *> (this));
continue;
}
+ layer_t dest;
+
if (dir > 0) {
/* region is moving up, move all regions on intermediate layers
}
}
+ freeze ();
+
/* now reset the layers without holding the region lock */
for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
region->set_layer (target_layer);
-#if 0
- /* now check all dependents */
+ /* now check all dependents, since we changed the layering */
for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
check_dependents (x->first, false);
}
check_dependents (region, false);
-#endif
+ notify_layering_changed ();
+
+ thaw ();
return 0;
}
Playlist::nudge_after (framepos_t start, framecnt_t distance, bool forwards)
{
RegionList::iterator i;
- framepos_t new_pos;
bool moved = false;
_nudging = true;
if ((*i)->position() >= start) {
+ framepos_t new_pos;
+
if (forwards) {
- if ((*i)->last_frame() > max_frames - distance) {
- new_pos = max_frames - (*i)->length();
+ if ((*i)->last_frame() > max_framepos - distance) {
+ new_pos = max_framepos - (*i)->length();
} else {
new_pos = (*i)->position() + distance;
}
}
+bool
+Playlist::uses_source (boost::shared_ptr<const Source> src) const
+{
+ RegionLock rlock (const_cast<Playlist*> (this));
+
+ for (set<boost::shared_ptr<Region> >::iterator r = all_regions.begin(); r != all_regions.end(); ++r) {
+ if ((*r)->uses_source (src)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
boost::shared_ptr<Region>
Playlist::find_region (const ID& id) const
{
return boost::shared_ptr<Region> ();
}
+uint32_t
+Playlist::region_use_count (boost::shared_ptr<Region> r) const
+{
+ RegionLock rlock (const_cast<Playlist*> (this));
+ uint32_t cnt = 0;
+
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i) == r) {
+ cnt++;
+ }
+ }
+
+ return cnt;
+}
+
boost::shared_ptr<Region>
-Playlist::region_by_id (ID id)
+Playlist::region_by_id (const ID& id) const
{
/* searches all regions ever added to this playlist */
void
Playlist::timestamp_layer_op (boost::shared_ptr<Region> region)
{
-// struct timeval tv;
-// gettimeofday (&tv, 0);
region->set_last_layer_op (++layer_op_counter);
}
Playlist::shuffle (boost::shared_ptr<Region> region, int dir)
{
bool moved = false;
- framepos_t new_pos;
if (region->locked()) {
return;
break;
}
+ framepos_t new_pos;
+
if ((*next)->position() != region->last_frame() + 1) {
/* they didn't used to touch, so after shuffle,
just have them swap positions.
break;
}
+ framepos_t new_pos;
if (region->position() != (*prev)->last_frame() + 1) {
/* they didn't used to touch, so after shuffle,
just have them swap positions.
Playlist::update_after_tempo_map_change ()
{
RegionLock rlock (const_cast<Playlist*> (this));
- RegionList copy (regions);
+ RegionList copy (regions.rlist());
freeze ();
return (i != regions.end());
}
+
+/** Remove any region that uses a given source */
+void
+Playlist::remove_region_by_source (boost::shared_ptr<Source> s)
+{
+ RegionLock rl (this);
+
+ RegionList::iterator i = regions.begin();
+ while (i != regions.end()) {
+ RegionList::iterator j = i;
+ ++j;
+
+ if ((*i)->uses_source (s)) {
+ remove_region_internal (*i);
+ }
+
+ i = j;
+ }
+}
+
+/** Look from a session frame time and find the start time of the next region
+ * which is on the top layer of this playlist.
+ * @param t Time to look from.
+ * @return Position of next top-layered region, or max_framepos if there isn't one.
+ */
+framepos_t
+Playlist::find_next_top_layer_position (framepos_t t) const
+{
+ RegionLock rlock (const_cast<Playlist *> (this));
+
+ layer_t const top = top_layer ();
+
+ RegionList copy = regions.rlist ();
+ copy.sort (RegionSortByPosition ());
+
+ for (RegionList::const_iterator i = copy.begin(); i != copy.end(); ++i) {
+ if ((*i)->position() >= t && (*i)->layer() == top) {
+ return (*i)->position();
+ }
+ }
+
+ return max_framepos;
+}
+
+void
+Playlist::join (const RegionList& r, const std::string& name)
+{
+ PropertyList plist;
+ uint32_t channels = 0;
+ uint32_t layer = 0;
+ framepos_t earliest_position = max_framepos;
+ vector<TwoRegions> old_and_new_regions;
+
+ boost::shared_ptr<Playlist> pl = PlaylistFactory::create (_type, _session, name, true);
+
+ for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) {
+ earliest_position = min (earliest_position, (*i)->position());
+ }
+
+ /* enable this so that we do not try to create xfades etc. as we add
+ * regions
+ */
+
+ pl->in_partition = true;
+
+ for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) {
+
+ /* copy the region */
+
+ boost::shared_ptr<Region> original_region = (*i);
+ boost::shared_ptr<Region> copied_region = RegionFactory::create (original_region, false);
+
+ old_and_new_regions.push_back (TwoRegions (original_region,copied_region));
+
+ /* make position relative to zero */
+
+ pl->add_region (copied_region, original_region->position() - earliest_position);
+
+ /* use the maximum number of channels for any region */
+
+ channels = max (channels, original_region->n_channels());
+
+ /* it will go above the layer of the highest existing region */
+
+ layer = max (layer, original_region->layer());
+ }
+
+ pl->in_partition = false;
+
+ /* now create a new PlaylistSource for each channel in the new playlist */
+
+ SourceList sources;
+ pair<framepos_t,framepos_t> extent = pl->get_extent();
+
+ for (uint32_t chn = 0; chn < channels; ++chn) {
+ sources.push_back (SourceFactory::createFromPlaylist (_type, _session, pl, name, chn, 0, extent.second, false, false));
+ }
+
+ /* now a new region using the list of sources */
+
+ plist.add (Properties::start, 0);
+ plist.add (Properties::length, extent.second);
+ plist.add (Properties::name, name);
+ plist.add (Properties::layer, layer+1);
+
+ boost::shared_ptr<Region> compound_region = RegionFactory::create (sources, plist, true);
+
+ /* add any dependent regions to the new playlist */
+
+ copy_dependents (old_and_new_regions, pl);
+
+ /* remove all the selected regions from the current playlist
+ */
+
+ freeze ();
+
+ for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) {
+ remove_region (*i);
+ }
+
+ /* add the new region at the right location */
+
+ add_region (compound_region, earliest_position);
+
+ _combine_ops++;
+
+ thaw ();
+}
+
+uint32_t
+Playlist::max_source_level () const
+{
+ RegionLock rlock (const_cast<Playlist *> (this));
+ uint32_t lvl = 0;
+
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+ lvl = max (lvl, (*i)->max_source_level());
+ }
+
+ return lvl;
+}
+
+
+uint32_t
+Playlist::count_joined_regions () const
+{
+ RegionLock rlock (const_cast<Playlist *> (this));
+ uint32_t cnt = 0;
+
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+ if ((*i)->max_source_level() > 0) {
+ cnt++;
+ }
+ }
+
+ return cnt;
+}
+
projects / ardour.git / blobdiff