RegionList tmp;
other.copy_regions (tmp);
- in_set_state = true;
+ in_set_state++;
for (list<boost::shared_ptr<Region> >::iterator x = tmp.begin(); x != tmp.end(); ++x) {
add_region_internal( (*x), (*x)->position() );
}
- in_set_state = false;
+ in_set_state--;
_splicing = other._splicing;
_nudging = other._nudging;
_edit_mode = other._edit_mode;
- in_set_state = false;
+ in_set_state = 0;
in_flush = false;
in_partition = false;
subcnt = 0;
_read_data_count = 0;
_frozen = other._frozen;
- save_on_thaw = false;
layer_op_counter = other.layer_op_counter;
freeze_length = other.freeze_length;
_hidden = hide;
_splicing = false;
_nudging = false;
- in_set_state = false;
+ in_set_state = 0;
_edit_mode = Config->get_edit_mode();
in_flush = false;
in_partition = false;
subcnt = 0;
_read_data_count = 0;
_frozen = false;
- save_on_thaw = false;
layer_op_counter = 0;
freeze_length = 0;
Playlist::notify_region_removed (boost::shared_ptr<Region> r)
{
if (holding_state ()) {
- pending_removals.insert (pending_removals.end(), r);
+ pending_removes.insert (r);
+ pending_modified = true;
+ pending_length = true;
} else {
- RegionRemoved (r); /* EMIT SIGNAL */
/* this might not be true, but we have to act
as though it could be.
*/
void
Playlist::notify_region_added (boost::shared_ptr<Region> r)
{
+ /* the length change might not be true, but we have to act
+ as though it could be.
+ */
+
if (holding_state()) {
- pending_adds.insert (pending_adds.end(), r);
+ pending_adds.insert (r);
+ pending_modified = true;
+ pending_length = true;
} else {
- RegionAdded (r); /* EMIT SIGNAL */
- /* this might not be true, but we have to act
- as though it could be.
- */
LengthChanged (); /* EMIT SIGNAL */
Modified (); /* EMIT SIGNAL */
}
void
Playlist::flush_notifications ()
{
- RegionList::iterator r;
- RegionList::iterator a;
set<boost::shared_ptr<Region> > dependent_checks_needed;
+ set<boost::shared_ptr<Region> >::iterator s;
uint32_t n = 0;
if (in_flush) {
/* don't increment n again - its the same list */
}
- for (a = pending_adds.begin(); a != pending_adds.end(); ++a) {
- dependent_checks_needed.insert (*a);
- RegionAdded (*a); /* EMIT SIGNAL */
+ for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+ dependent_checks_needed.insert (*s);
n++;
}
- for (set<boost::shared_ptr<Region> >::iterator x = dependent_checks_needed.begin(); x != dependent_checks_needed.end(); ++x) {
- check_dependents (*x, false);
+ for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) {
+ check_dependents (*s, false);
}
- for (r = pending_removals.begin(); r != pending_removals.end(); ++r) {
- remove_dependents (*r);
- RegionRemoved (*r); /* EMIT SIGNAL */
+ for (s = pending_removes.begin(); s != pending_removes.end(); ++s) {
+ remove_dependents (*s);
n++;
}
}
pending_adds.clear ();
- pending_removals.clear ();
+ pending_removes.clear ();
pending_bounds.clear ();
- if (save_on_thaw) {
- save_on_thaw = false;
- save_state (last_save_reason);
- }
-
in_flush = false;
}
*************************************************************/
void
-Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times, bool with_save)
+Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times)
{
RegionLock rlock (this);
boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
add_region_internal (sub, pos, true);
}
-
- if (with_save) {
- maybe_save_state (_("add region"));
- }
}
void
timestamp_layer_op (region);
regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
+ all_regions.insert (region);
if (!holding_state () && !in_set_state) {
/* layers get assigned from XML state */
if (!holding_state ()) {
possibly_splice_unlocked ();
}
-
- maybe_save_state (_("replace region"));
}
void
if (!holding_state ()) {
possibly_splice_unlocked ();
}
-
- maybe_save_state (_("remove region"));
}
int
RegionList::iterator i;
nframes_t old_length = 0;
- // cerr << "removing region " << region->name() << endl;
+ cerr << "removing region " << region->name() << " holding = " << holding_state() << endl;
if (!holding_state()) {
old_length = _get_maximum_extent();
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
(*i)->thaw ("separation");
}
-
- maybe_save_state (_("separate"));
}
void
(*i)->thaw ("playlist cut");
}
- maybe_save_state (_("cut"));
-
return the_copy;
}
}
- maybe_save_state (_("paste"));
-
return 0;
}
boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
add_region_internal (sub, pos, true);
}
-
- maybe_save_state (_("duplicate"));
}
void
if (remove_region_internal (region, true)) {
return;
}
-
- maybe_save_state (_("split"));
}
void
}
void
-Playlist::clear (bool with_save)
+Playlist::clear (bool with_signals)
{
- RegionList::iterator i;
- RegionList tmp;
-
{
RegionLock rl (this);
- tmp = regions;
+ for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+ pending_removes.insert (*i);
+ }
regions.clear ();
}
-
- for (i = tmp.begin(); i != tmp.end(); ++i) {
- notify_region_removed (*i);
- }
- if (with_save) {
- maybe_save_state (_("clear"));
+ if (with_signals) {
+ LengthChanged ();
+ Modified ();
}
+
}
/***********************************************************************
int
Playlist::set_state (const XMLNode& node)
{
- in_set_state = true;
-
XMLNode *child;
XMLNodeList nlist;
XMLNodeConstIterator niter;
boost::shared_ptr<Region> region;
string region_name;
- clear (false);
+ in_set_state++;
if (node.name() != "Playlist") {
- in_set_state = false;
+ in_set_state--;
return -1;
}
+ freeze ();
+
plist = node.properties();
for (piter = plist.begin(); piter != plist.end(); ++piter) {
}
}
+ clear (false);
+
nlist = node.children();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
continue;
}
- if ((region = RegionFactory::create (_session, *child, true)) == 0) {
- error << _("Playlist: cannot create region from state file") << endmsg;
+ ID id = prop->value ();
+
+ if ((region = region_by_id (id))) {
+
+ Change what_changed = Change (0);
+
+ if (region->set_live_state (*child, what_changed, true)) {
+ error << _("Playlist: cannot reset region state from XML") << endmsg;
+ continue;
+ }
+
+ } else if ((region = RegionFactory::create (_session, *child, true)) == 0) {
+ error << _("Playlist: cannot create region from XML") << endmsg;
continue;
}
- add_region (region, region->position(), 1.0, false);
+ add_region (region, region->position(), 1.0);
// So that layer_op ordering doesn't get screwed up
region->set_last_layer_op( region->layer());
}
}
-
/* update dependents, which was not done during add_region_internal
due to in_set_state being true
for (RegionList::iterator r = regions.begin(); r != regions.end(); ++r) {
check_dependents (*r, false);
}
-
- in_set_state = false;
+
+ notify_modified ();
+
+ thaw ();
+
+ in_set_state--;
return 0;
}
if (full_state) {
RegionLock rlock (this, false);
-
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
node->add_child_nocopy ((*i)->get_state());
}
if (moved) {
_nudging = false;
- maybe_save_state (_("nudged"));
notify_length_changed ();
}
Playlist::find_region (const ID& id) const
{
RegionLock rlock (const_cast<Playlist*> (this));
- RegionList::const_iterator i;
- boost::shared_ptr<Region> ret;
- for (i = regions.begin(); i != regions.end(); ++i) {
+ /* searches all regions currently in use by the playlist */
+
+ for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
if ((*i)->id() == id) {
- ret = *i;
+ return *i;
}
}
- return ret;
+ return boost::shared_ptr<Region> ();
}
-
-void
-Playlist::save_state (std::string why)
+
+boost::shared_ptr<Region>
+Playlist::region_by_id (ID id)
{
- if (!in_set_state) {
- StateManager::save_state (why);
+ /* searches all regions ever added to this playlist */
+
+ for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
+ if ((*i)->id() == id) {
+ return *i;
+ }
}
+ return boost::shared_ptr<Region> ();
}
-
+
void
Playlist::dump () const
{
region->set_last_layer_op (++layer_op_counter);
}
-void
-Playlist::maybe_save_state (string why)
-{
- if (holding_state ()) {
- save_on_thaw = true;
- last_save_reason = why;
- } else {
- save_state (why);
- }
-}