}
};
+
Playlist::Playlist (Session& sess, string nom, DataType type, bool hide)
- : _session (sess)
+ : SessionObject(sess, nom)
, _type(type)
{
init (hide);
+ first_set_state = false;
_name = nom;
}
Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide)
- : _session (sess)
+ : SessionObject(sess, "unnamed playlist")
, _type(type)
{
const XMLProperty* prop = node.property("type");
}
Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, bool hide)
- : _name (namestr), _session (other->_session), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
+ : SessionObject(other->_session, namestr), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
{
init (hide);
_edit_mode = other->_edit_mode;
in_set_state = 0;
+ first_set_state = false;
in_flush = false;
in_partition = false;
subcnt = 0;
}
Playlist::Playlist (boost::shared_ptr<const Playlist> other, nframes_t start, nframes_t cnt, string str, bool hide)
- : _name (str), _session (other->_session), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
+ : SessionObject(other->_session, str), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
{
RegionLock rlock2 (const_cast<Playlist*> (other.get()));
}
in_set_state--;
+ first_set_state = false;
/* this constructor does NOT notify others (session) */
}
g_atomic_int_set (&ignore_state_changes, 0);
pending_modified = false;
pending_length = false;
+ first_set_state = true;
_refcnt = 0;
_hidden = hide;
_splicing = false;
}
Playlist::Playlist (const Playlist& pl)
- : _session (pl._session)
+ : SessionObject(pl._session, pl._name)
, _type(pl.data_type())
{
fatal << _("playlist const copy constructor called") << endmsg;
}
Playlist::Playlist (Playlist& pl)
- : _session (pl._session)
+ : SessionObject(pl._session, pl._name)
, _type(pl.data_type())
{
fatal << _("playlist non-const copy constructor called") << endmsg;
/* GoingAway must be emitted by derived classes */
}
-void
-Playlist::set_name (string str)
+bool
+Playlist::set_name (const string& str)
{
/* in a typical situation, a playlist is being used
by one diskstream and also is referenced by the
*/
if (_refcnt > 2) {
- return;
+ return false;
+ } else {
+ return SessionObject::set_name(str);
}
-
- _name = str;
- NameChanged(); /* EMIT SIGNAL */
}
/***********************************************************************
/* this might not be true, but we have to act
as though it could be.
*/
+ pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
pending_modified = true;
pending_length = true;
} else {
+ pending_length = false;
LengthChanged (); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
if (holding_state ()) {
pending_length = true;
} else {
+ pending_length = false;
LengthChanged(); /* EMIT SIGNAL */
+ pending_modified = false;
Modified (); /* EMIT SIGNAL */
}
}
}
pending_modified = false;
Modified (); /* EMIT SIGNAL */
+
}
for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) {
Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times)
{
RegionLock rlock (this);
-
+ delay_notifications();
times = fabs (times);
int itimes = (int) floor (times);
boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
add_region_internal (sub, pos);
}
+
+ release_notifications ();
}
void
old_length = _get_maximum_extent();
}
- if (!in_set_state) {
+ if (!first_set_state) {
boost::shared_ptr<Playlist> foo (shared_from_this());
region->set_playlist (boost::weak_ptr<Playlist>(foo));
- }
+ }
region->set_position (position, this);
old_length = _get_maximum_extent();
}
+ if (!in_set_state) {
+ /* unset playlist */
+ region->set_playlist (boost::weak_ptr<Playlist>());
+ }
+
for (i = regions.begin(); i != regions.end(); ++i) {
if (*i == region) {
void
Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist)
{
- RegionLock rlock (this);
boost::shared_ptr<Region> region;
boost::shared_ptr<Region> current;
string new_name;
OverlapType overlap;
nframes_t pos1, pos2, pos3, pos4;
RegionList new_regions;
+ RegionList copy;
in_partition = true;
+ delay_notifications();
+
/* need to work from a copy, because otherwise the regions we add during the process
get operated on as well.
*/
-
- RegionList copy = regions;
+ {
+ RegionLock rlock (this);
+ copy = regions;
+ }
for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
++tmp;
current = *i;
-
+
if (current->first_frame() == start && current->last_frame() == end) {
if (cutting) {
+ RegionLock rlock (this);
remove_region_internal (current);
}
continue;
if ((overlap = current->coverage (start, end)) == OverlapNone) {
continue;
}
-
+
pos1 = current->position();
pos2 = start;
pos3 = end;
pos4 = current->last_frame();
if (overlap == OverlapInternal) {
-
+
/* split: we need 3 new regions, the front, middle and end.
cut: we need 2 regions, the front and end.
*/
/* "middle" ++++++ */
- _session.region_name (new_name, current->name(), false);
+ _session.region_name (new_name, current->name(), false); //takes the session-wide region lock
region = RegionFactory::create (current, pos2 - pos1, pos3 - pos2, new_name,
regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit));
+ RegionLock rlock (this);
add_region_internal (region, start);
new_regions.push_back (region);
}
_session.region_name (new_name, current->name(), false);
region = RegionFactory::create (current, pos3 - pos1, pos4 - pos3, new_name,
regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
-
- add_region_internal (region, end);
- new_regions.push_back (region);
-
+ {
+ RegionLock rlock (this);
+ add_region_internal (region, end);
+ new_regions.push_back (region);
+ }
/* "front" ***** */
current->freeze ();
/* end +++++ */
_session.region_name (new_name, current->name(), false);
- region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, (layer_t) regions.size(),
+ region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, regions.size(),
Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit));
+ RegionLock rlock (this);
add_region_internal (region, start);
new_regions.push_back (region);
}
_session.region_name (new_name, current->name(), false);
region = RegionFactory::create (current, 0, pos3 - pos1, new_name,
regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
+ RegionLock rlock (this);
add_region_internal (region, pos1);
new_regions.push_back (region);
}
*/
if (cutting) {
+ RegionLock rlock (this);
remove_region_internal (current);
}
new_regions.push_back (current);
for (RegionList::iterator i = new_regions.begin(); i != new_regions.end(); ++i) {
check_dependents (*i, false);
}
+
+ release_notifications ();
}
boost::shared_ptr<Playlist>
save = !(_splicing || _nudging);
}
- if ((what_changed & Region::MuteChanged) &&
- !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
+ if ((what_changed & our_interests) &&
+ !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
check_dependents (region, false);
}
return save;
}
+void
+Playlist::drop_regions ()
+{
+ RegionLock rl (this);
+ regions.clear ();
+ all_regions.clear ();
+}
+
void
Playlist::clear (bool with_signals)
{
}
if (with_signals) {
+ pending_length = false;
LengthChanged ();
+ pending_modified = false;
Modified ();
}
}
in_set_state--;
-
+ first_set_state = false;
return 0;
}
if (full_state) {
RegionLock rlock (this, false);
-
- cerr << _name << " getting region state for " << regions.size() << endl;
-
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- cerr << "\t" << " now at " << (*i) << endl;
- cerr << "\t\t" << (*i)->name() << endl;
node->add_child_nocopy ((*i)->get_state());
}
}
void
Playlist::relayer ()
{
- RegionList::iterator i;
- uint32_t layer = 0;
-
/* don't send multiple Modified notifications
when multiple regions are relayered.
*/
-
+
freeze ();
- if (Config->get_layer_model() == MoveAddHigher ||
- Config->get_layer_model() == AddHigher) {
+ /* build up a new list of regions on each layer */
- RegionSortByLastLayerOp cmp;
- RegionList copy = regions;
+ std::vector<RegionList> layers;
+
+ /* we want to go through regions from desired lowest to desired highest layer,
+ which depends on the layer model
+ */
+
+ RegionList copy = regions;
+
+ /* sort according to the model */
+ if (Config->get_layer_model() == MoveAddHigher || Config->get_layer_model() == AddHigher) {
+ RegionSortByLastLayerOp cmp;
copy.sort (cmp);
+ }
+
+ for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
+
+ /* find the lowest layer that this region can go on */
+ size_t j = layers.size();
+ while (j > 0) {
+ /* try layer j - 1; it can go on if it overlaps no other region
+ that is already on that layer
+ */
+ RegionList::iterator k = layers[j - 1].begin();
+ while (k != layers[j - 1].end()) {
+ if ((*k)->overlap_equivalent (*i)) {
+ break;
+ }
+ k++;
+ }
- for (i = copy.begin(); i != copy.end(); ++i) {
- (*i)->set_layer (layer++);
+ if (k != layers[j - 1].end()) {
+ /* no overlap, so we can use this layer */
+ break;
+ }
+
+ j--;
}
- } else {
-
- /* Session::LaterHigher model */
+ if (j == layers.size()) {
+ /* we need a new layer for this region */
+ layers.push_back (RegionList ());
+ }
- for (i = regions.begin(); i != regions.end(); ++i) {
- (*i)->set_layer (layer++);
+ layers[j].push_back (*i);
+ }
+
+ /* first pass: set up the layer numbers in the regions */
+ for (size_t j = 0; j < layers.size(); ++j) {
+ for (RegionList::iterator i = layers[j].begin(); i != layers[j].end(); ++i) {
+ (*i)->set_layer (j);
}
}
/* XXX these layer functions are all deprecated */
-void
-Playlist::raise_region (boost::shared_ptr<Region> region)
-{
- uint32_t rsz = regions.size();
- layer_t target = region->layer() + 1U;
-
- if (target >= rsz) {
- /* its already at the effective top */
- return;
- }
-
- move_region_to_layer (target, region, 1);
-}
-
-void
-Playlist::lower_region (boost::shared_ptr<Region> region)
-{
- if (region->layer() == 0) {
- /* its already at the bottom */
- return;
- }
-
- layer_t target = region->layer() - 1U;
-
- move_region_to_layer (target, region, -1);
-}
-
void
Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
{
}
}
-int
-Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr<Region> region, int dir)
-{
- RegionList::iterator i;
- typedef pair<boost::shared_ptr<Region>,layer_t> LayerInfo;
- list<LayerInfo> layerinfo;
- layer_t dest;
-
- {
- RegionLock rlock (const_cast<Playlist *> (this));
-
- for (i = regions.begin(); i != regions.end(); ++i) {
-
- if (region == *i) {
- continue;
- }
-
- if (dir > 0) {
-
- /* region is moving up, move all regions on intermediate layers
- down 1
- */
-
- if ((*i)->layer() > region->layer() && (*i)->layer() <= target_layer) {
- dest = (*i)->layer() - 1;
- } else {
- /* not affected */
- continue;
- }
- } else {
-
- /* region is moving down, move all regions on intermediate layers
- up 1
- */
-
- if ((*i)->layer() < region->layer() && (*i)->layer() >= target_layer) {
- dest = (*i)->layer() + 1;
- } else {
- /* not affected */
- continue;
- }
- }
-
- LayerInfo newpair;
-
- newpair.first = *i;
- newpair.second = dest;
-
- layerinfo.push_back (newpair);
- }
- }
-
- /* now reset the layers without holding the region lock */
-
- for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
- x->first->set_layer (x->second);
- }
-
- region->set_layer (target_layer);
-
-#if 0
- /* now check all dependents */
-
- for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
- check_dependents (x->first, false);
- }
-
- check_dependents (region, false);
-#endif
-
- return 0;
-}
-
void
Playlist::nudge_after (nframes_t start, nframes_t distance, bool forwards)
{
projects / ardour.git / blobdiff