*/
#include "pbd/memento_command.h"
+#include "pbd/stateful_diff_command.h"
#include "ardour/session.h"
#include "ardour/audioregion.h"
boost::shared_ptr<Playlist> pl = _region->playlist();
if (pl) {
- XMLNode &before = pl->get_state();
+ _region->clear_history ();
_region->set_position (position_clock.current_time(), this);
- XMLNode &after = pl->get_state();
- _session->add_command(new MementoCommand<Playlist>(*pl, &before, &after));
+ _session->add_command(new StatefulDiffCommand (_region));
}
_session->commit_reversible_command ();
boost::shared_ptr<Playlist> pl = _region->playlist();
if (pl) {
- XMLNode &before = pl->get_state();
+ _region->clear_history ();
_region->trim_end (end_clock.current_time(), this);
- XMLNode &after = pl->get_state();
- _session->add_command(new MementoCommand<Playlist>(*pl, &before, &after));
+ _session->add_command(new StatefulDiffCommand (_region));
}
_session->commit_reversible_command ();
boost::shared_ptr<Playlist> pl = _region->playlist();
if (pl) {
- XMLNode &before = pl->get_state();
+ _region->clear_history ();
_region->trim_end (_region->position() + frames - 1, this);
- XMLNode &after = pl->get_state();
- _session->add_command(new MementoCommand<Playlist>(*pl, &before, &after));
+ _session->add_command(new StatefulDiffCommand (_region));
}
_session->commit_reversible_command ();
{
_session->begin_reversible_command (_("change region sync point"));
- XMLNode& before = _region->get_state ();
+ _region->clear_history ();
_region->set_sync_position (sync_offset_absolute_clock.current_time());
- XMLNode& after = _region->get_state ();
- _session->add_command (new MementoCommand<AudioRegion> (*_region.get(), &before, &after));
+ _session->add_command (new StatefulDiffCommand (_region));
_session->commit_reversible_command ();
}
{
_session->begin_reversible_command (_("change region sync point"));
- XMLNode& before = _region->get_state ();
+ _region->clear_history ();
_region->set_sync_position (sync_offset_relative_clock.current_time() + _region->position ());
- XMLNode& after = _region->get_state ();
- _session->add_command (new MementoCommand<AudioRegion> (*_region.get(), &before, &after));
+ _session->add_command (new StatefulDiffCommand (_region));
_session->commit_reversible_command ();
}
void
AudioRegionView::region_changed (const PropertyChange& what_changed)
{
- ENSURE_GUI_THREAD (*this, &AudioRegionView::region_changed, what_changed)
- //cerr << "AudioRegionView::region_changed() called" << endl;
+ ENSURE_GUI_THREAD (*this, &AudioRegionView::region_changed, what_changed);
+ // cerr << "AudioRegionView::region_changed() called" << endl;
RegionView::region_changed (what_changed);
region_scale_amplitude_changed ();
}
if (what_changed.contains (ARDOUR::Properties::fade_in)) {
- fade_in_changed ();
+ fade_in_changed ();
}
if (what_changed.contains (ARDOUR::Properties::fade_out)) {
fade_out_changed ();
gain_line->view_to_model_coord (x, y);
+ /* XXX STATEFUL: can't convert to stateful diff until we
+ can represent automation data with it.
+ */
+
trackview.session()->begin_reversible_command (_("add gain control point"));
XMLNode &before = audio_region()->envelope()->get_state();
if (nlen != region->length()) {
- region->freeze ();
+ region->suspend_property_changes ();
region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
region->set_length (nlen, this);
- region->thaw ();
+ region->resume_property_changes ();
if (origlen == 1) {
/* our special initial length */
if (region->source_length(0) >= region->start() + nlen) {
- region->freeze ();
+ region->suspend_property_changes ();
region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
region->set_length (nlen, this);
- region->thaw ();
+ region->resume_property_changes ();
if (origlen == 1) {
/* our special initial length */
#include "pbd/pthread_utils.h"
#include "pbd/basename.h"
#include "pbd/shortpath.h"
+#include "pbd/stateful_diff_command.h"
#include <gtkmm2ext/choice.h>
boost::shared_ptr<Playlist> playlist = existing_track->diskstream()->playlist();
boost::shared_ptr<Region> copy (RegionFactory::create (region, region->properties()));
begin_reversible_command (_("insert file"));
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->add_region (copy, pos);
- _session->add_command (new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
+ _session->add_command (new StatefulDiffCommand (playlist));
commit_reversible_command ();
break;
}
boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
_editor->begin_reversible_command (_("insert region"));
- XMLNode& before = playlist->get_state ();
+ playlist->clear_history ();
playlist->add_region (_primary->region (), _last_frame_position);
- _editor->session()->add_command (new MementoCommand<Playlist> (*playlist, &before, &playlist->get_state()));
+ _editor->session()->add_command (new StatefulDiffCommand (playlist));
_editor->commit_reversible_command ();
delete _primary;
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
(*i)->fake_set_opaque(false);
- (*i)->region()->freeze ();
+ (*i)->region()->clear_history ();
+ (*i)->region()->suspend_property_changes ();
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
insert_result = _editor->motion_frozen_playlists.insert (pl);
if (insert_result.second) {
- _editor->session()->add_command(new MementoCommand<Playlist>(*pl, &pl->get_state(), 0));
pl->freeze();
}
}
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
_editor->thaw_region_after_trim (**i);
(*i)->fake_set_opaque (true);
+ if (_have_transaction) {
+ _editor->session()->add_command (new StatefulDiffCommand ((*i)->region()));
+ }
}
}
for (set<boost::shared_ptr<Playlist> >::iterator p = _editor->motion_frozen_playlists.begin(); p != _editor->motion_frozen_playlists.end(); ++p) {
(*p)->thaw ();
- if (_have_transaction) {
- _editor->session()->add_command (new MementoCommand<Playlist>(*(*p).get(), 0, &(*p)->get_state()));
- }
}
_editor->motion_frozen_playlists.clear ();
*/
+#include "pbd/memento_command.h"
+#include "pbd/stateful_diff_command.h"
+
#include "ardour/audioregion.h"
#include "ardour/playlist.h"
#include "ardour/session.h"
#include "ardour/location.h"
-#include "pbd/memento_command.h"
-
#include "editor.h"
#include "region_view.h"
#include "selection.h"
#include "i18n.h"
using namespace ARDOUR;
+using namespace PBD;
void
Editor::kbd_driver (sigc::slot<void,GdkEvent*> theslot, bool use_track_canvas, bool use_time_canvas, bool can_select)
for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
- XMLNode &before = (*i)->region()->playlist()->get_state ();
+ (*i)->region()->playlist()->clear_history ();
(*i)->region()->set_muted (!(*i)->region()->muted ());
- XMLNode &after = (*i)->region()->playlist()->get_state ();
-
- _session->add_command (new MementoCommand<ARDOUR::Playlist>(*((*i)->region()->playlist()), &before, &after));
+ _session->add_command (new StatefulDiffCommand ((*i)->region()->playlist()));
}
} else if (entered_regionview) {
begin_reversible_command (_("mute region"));
- XMLNode &before = entered_regionview->region()->playlist()->get_state();
-
+ entered_regionview->region()->playlist()->clear_history ();
entered_regionview->region()->set_muted (!entered_regionview->region()->muted());
-
- XMLNode &after = entered_regionview->region()->playlist()->get_state();
- _session->add_command (new MementoCommand<ARDOUR::Playlist>(*(entered_regionview->region()->playlist()), &before, &after));
+ _session->add_command (new StatefulDiffCommand (entered_regionview->region()->playlist()));
commit_reversible_command();
}
#include <gtkmm2ext/tearoff.h>
#include "pbd/memento_command.h"
#include "pbd/basename.h"
+#include "pbd/stateful_diff_command.h"
#include "ardour_ui.h"
#include "actions.h"
}
if (!(*i)->region()->locked()) {
- boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
- XMLNode &before = pl->get_state();
-
+ (*i)->region()->clear_history ();
(*i)->region()->trim_front (new_bound, this);
-
- XMLNode &after = pl->get_state();
- _session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
+ _session->add_command(new StatefulDiffCommand ((*i)->region()));
}
}
} else {
if (!rv->region()->locked()) {
- boost::shared_ptr<Playlist> pl = rv->region()->playlist();
- XMLNode &before = pl->get_state();
+ rv->region()->clear_history ();
rv->region()->trim_front (new_bound, this);
- XMLNode &after = pl->get_state();
- _session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
+ _session->add_command(new StatefulDiffCommand (rv->region()));
}
}
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i)
{
if (!(*i)->region()->locked()) {
- boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
- XMLNode &before = pl->get_state();
+ (*i)->region()->clear_history();
(*i)->region()->trim_end (new_bound, this);
- XMLNode &after = pl->get_state();
- _session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
+ _session->add_command(new StatefulDiffCommand ((*i)->region()));
}
}
} else {
if (!rv->region()->locked()) {
- boost::shared_ptr<Playlist> pl = rv->region()->playlist();
- XMLNode &before = pl->get_state();
+ rv->region()->clear_history ();
rv->region()->trim_end (new_bound, this);
- XMLNode &after = pl->get_state();
- _session->add_command (new MementoCommand<Playlist>(*pl.get(), &before, &after));
+ _session->add_command (new StatefulDiffCommand (rv->region()));
}
}
return;
}
- region->thaw ();
+ region->resume_property_changes ();
AudioRegionView* arv = dynamic_cast<AudioRegionView*>(&rv);
boost::shared_ptr<Playlist> playlist = rtv->playlist();
double speed = rtv->get_diskstream()->speed();
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
boost::shared_ptr<Region> new_region (RegionFactory::create (rv->region()));
- playlist->add_region (new_region, (nframes64_t) (pos * speed));
- XMLNode &after = playlist->get_state();
- _session->add_command(new MementoCommand<Playlist>(*playlist.get(), &before, &after));
+ playlist->add_region (new_region, (nframes64_t) (pos * speed));
+ _session->add_command (new StatefulDiffCommand (playlist));
// playlist is frozen, so we have to update manually XXX this is disgusting
boost::shared_ptr<Playlist> playlist = clicked_axisview->playlist();
- XMLNode *before = &(playlist->get_state());
+ playlist->clear_history ();
clicked_routeview->playlist()->add_region (region, selection->time[clicked_selection].start);
- XMLNode *after = &(playlist->get_state());
- _session->add_command(new MementoCommand<Playlist>(*playlist, before, after));
+ _session->add_command(new StatefulDiffCommand (playlist));
commit_reversible_command ();
distance = next_distance;
}
- XMLNode &before = r->playlist()->get_state();
+ r->clear_history ();
r->set_position (r->position() + distance, this);
- XMLNode &after = r->playlist()->get_state();
- _session->add_command (new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
+ _session->add_command (new StatefulDiffCommand (r));
}
commit_reversible_command ();
if (next) {
distance = next_distance;
}
-
- XMLNode &before = r->playlist()->get_state();
+
+ r->clear_history ();
if (r->position() > distance) {
r->set_position (r->position() - distance, this);
} else {
r->set_position (0, this);
}
- XMLNode &after = r->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
+ _session->add_command (new StatefulDiffCommand (r));
}
commit_reversible_command ();
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
boost::shared_ptr<Region> r ((*i)->region());
- XMLNode &before = r->playlist()->get_state();
+ r->clear_history ();
r->set_position (r->position() + distance, this);
- XMLNode &after = r->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand (r));
}
commit_reversible_command ();
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
boost::shared_ptr<Region> r ((*i)->region());
- XMLNode &before = r->playlist()->get_state();
+ r->clear_history ();
if (r->position() > distance) {
r->set_position (r->position() - distance, this);
} else {
r->set_position (0, this);
}
- XMLNode &after = r->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand (r));
}
commit_reversible_command ();
snap_to (where);
begin_reversible_command (_("insert dragged region"));
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->add_region (RegionFactory::create (region), where, 1.0);
- _session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
+ _session->add_command(new StatefulDiffCommand (playlist));
commit_reversible_command ();
}
}
begin_reversible_command (_("insert region"));
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->add_region ((RegionFactory::create (region)), get_preferred_edit_position(), times);
- _session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
+ _session->add_command(new StatefulDiffCommand (playlist));
commit_reversible_command ();
}
if ((playlist = rtv->playlist()) != 0) {
- XMLNode *before;
- bool got_some;
-
- before = &(playlist->get_state());
- got_some = false;
+ playlist->clear_history ();
/* XXX need to consider musical time selections here at some point */
if (!latest_regionviews.empty()) {
- got_some = true;
-
rtv->view()->foreach_regionview (sigc::bind (
sigc::ptr_fun (add_if_covered),
&(*t), &new_selection));
-
+
if (!in_command) {
begin_reversible_command (_("separate"));
in_command = true;
}
- _session->add_command(new MementoCommand<Playlist>(
- *playlist, before, &playlist->get_state()));
+ _session->add_command(new StatefulDiffCommand (playlist));
}
}
-
- if (!got_some) {
- delete before;
- }
}
}
}
the_end = min (end, the_end);
cnt = the_end - the_start + 1;
- XMLNode &before = (*i)->get_state();
+ region->clear_history ();
region->trim_to (the_start, cnt, this);
- XMLNode &after = (*i)->get_state();
- _session->add_command (new MementoCommand<Playlist>(*(*i), &before, &after));
+ _session->add_command (new StatefulDiffCommand (region));
}
commit_reversible_command ();
return;
}
- XMLNode &before = pl->get_state();
+ pl->clear_history ();
pl->add_region (RegionFactory::create (region), region->last_frame(), times);
- _session->add_command (new MementoCommand<Playlist>(*pl, &before, &pl->get_state()));
+ _session->add_command (new StatefulDiffCommand (pl));
}
commit_reversible_command ();
continue;
}
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->add_region (RegionFactory::create (region), start, times);
- _session->add_command (new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
+ _session->add_command (new StatefulDiffCommand (playlist));
}
commit_reversible_command ();
in_command = true;
}
- XMLNode &before = region->playlist()->get_state();
+ region->clear_history ();
region->set_sync_position (where);
- XMLNode &after = region->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand (region));
}
if (in_command) {
begin_reversible_command (_("remove sync"));
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
- XMLNode &before = (*i)->region()->playlist()->get_state();
+ (*i)->region()->clear_history ();
(*i)->region()->clear_sync_position ();
- XMLNode &after = (*i)->region()->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(*((*i)->region()->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand ((*i)->region()));
}
commit_reversible_command ();
}
/* move first one specially */
- XMLNode &before = r->playlist()->get_state();
+ r->clear_history ();
r->set_position (pos, this);
- XMLNode &after = r->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(*(r->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand (r));
/* move rest by the same amount */
boost::shared_ptr<Region> region ((*i)->region());
- XMLNode &before = region->playlist()->get_state();
+ region->clear_history ();
if (dir > 0) {
region->set_position (region->position() + distance, this);
} else {
region->set_position (region->position() - distance, this);
}
-
- XMLNode &after = region->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
+
+ _session->add_command(new StatefulDiffCommand (region));
}
void
Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, nframes64_t position)
{
- XMLNode &before = region->playlist()->get_state();
+ region->clear_history ();
switch (point) {
case SyncPoint:
break;
}
- XMLNode &after = region->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(*(region->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand (region));
}
void
for (list<RegionView*>::const_iterator i = rs.by_layer().begin(); i != rs.by_layer().end(); ++i) {
if (!(*i)->region()->locked()) {
- boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
- XMLNode &before = pl->get_state();
+ (*i)->region()->clear_history ();
if (front) {
(*i)->region()->trim_front (where, this);
} else {
(*i)->region()->trim_end (where, this);
}
- XMLNode &after = pl->get_state();
- _session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
+ _session->add_command (new StatefulDiffCommand ((*i)->region()));
}
}
start = session_frame_to_track_frame (loc.start(), speed);
end = session_frame_to_track_frame (loc.end(), speed);
-
- XMLNode &before = rv->region()->playlist()->get_state();
+
+ rv->region()->clear_history ();
rv->region()->trim_to (start, (end - start), this);
- XMLNode &after = rv->region()->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(
- *(rv->region()->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand (rv->region()));
}
commit_reversible_command ();
speed = tav->get_diskstream()->speed();
}
- XMLNode &before = rv->region()->playlist()->get_state();
+ rv->region()->clear_history ();
rv->region()->trim_end (session_frame_to_track_frame(where, speed), this);
- XMLNode &after = rv->region()->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(
- *(rv->region()->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand (rv->region()));
}
commit_reversible_command ();
speed = tav->get_diskstream()->speed();
}
- XMLNode &before = rv->region()->playlist()->get_state();
+ rv->region()->clear_history ();
rv->region()->trim_front (session_frame_to_track_frame(where, speed), this);
- XMLNode &after = rv->region()->playlist()->get_state();
- _session->add_command(new MementoCommand<Playlist>(
- *(rv->region()->playlist()), &before, &after));
+ _session->add_command(new StatefulDiffCommand (rv->region()));
}
commit_reversible_command ();
boost::shared_ptr<Region> region = arv->region();
boost::shared_ptr<Playlist> playlist (region->playlist());
- XMLNode &before = playlist->get_state();
+ region->clear_history ();
if(forward){
arv->region_changed (ARDOUR::bounds_change);
}
- XMLNode &after = playlist->get_state();
- _session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
+ _session->add_command(new StatefulDiffCommand (region));
}
commit_reversible_command ();
void*
Editor::freeze_thread ()
{
- clicked_routeview->audio_track()->freeze (*current_interthread_info);
+ clicked_routeview->audio_track()->freeze_me (*current_interthread_info);
current_interthread_info->done = true;
return 0;
}
itt.cancel = false;
itt.progress = false;
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
boost::shared_ptr<Region> r = rtv->track()->bounce_range (start, start+cnt, itt, enable_processing);
if (replace) {
playlist->add_region (r, start);
}
- XMLNode &after = playlist->get_state();
- _session->add_command (new MementoCommand<Playlist> (*playlist, &before, &after));
+ _session->add_command (new StatefulDiffCommand (playlist));
}
commit_reversible_command ();
boost::shared_ptr<Playlist> playlist = clicked_routeview->playlist();
begin_reversible_command (_("remove region"));
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->remove_region (clicked_regionview->region());
- XMLNode &after = playlist->get_state();
- _session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
+ _session->add_command(new StatefulDiffCommand (playlist));
commit_reversible_command ();
}
regions_to_remove.push_back ((*i)->region());
}
- vector<PlaylistState> playlists;
+ vector<boost::shared_ptr<Playlist> > playlists;
for (list<boost::shared_ptr<Region> >::iterator rl = regions_to_remove.begin(); rl != regions_to_remove.end(); ++rl) {
continue;
}
- vector<PlaylistState>::iterator i;
+ vector<boost::shared_ptr<Playlist> >::iterator i;
- //only take state if this is a new playlist.
+ //only prep history if this is a new playlist.
for (i = playlists.begin(); i != playlists.end(); ++i) {
- if ((*i).playlist == playlist) {
+ if ((*i) == playlist) {
break;
}
}
if (i == playlists.end()) {
- PlaylistState before;
- before.playlist = playlist;
- before.before = &playlist->get_state();
-
+ playlist->clear_history ();
playlist->freeze ();
- playlists.push_back(before);
+
+ playlists.push_back (playlist);
}
playlist->remove_region (*rl);
}
- vector<PlaylistState>::iterator pl;
+ vector<boost::shared_ptr<Playlist> >::iterator pl;
for (pl = playlists.begin(); pl != playlists.end(); ++pl) {
- (*pl).playlist->thaw ();
- _session->add_command(new MementoCommand<Playlist>(*(*pl).playlist, (*pl).before, &(*pl).playlist->get_state()));
+ (*pl)->thaw ();
+ _session->add_command(new StatefulDiffCommand (*pl));
}
commit_reversible_command ();
sigc::connection c = rtv->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view));
playlist = (*i)->region()->playlist();
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->duplicate (r, end_frame + (r->first_frame() - start_frame) + 1, times);
- _session->add_command(new MementoCommand<Playlist>(*playlist, &before, &playlist->get_state()));
+ _session->add_command(new StatefulDiffCommand (playlist));
c.disconnect ();
if ((playlist = (*i)->playlist()) == 0) {
continue;
}
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->duplicate (*ri, selection->time[clicked_selection].end, times);
- XMLNode &after = playlist->get_state();
- _session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
+ _session->add_command (new StatefulDiffCommand (playlist));
++ri;
if (ri == new_regions.end()) {
Editor::clear_playlist (boost::shared_ptr<Playlist> playlist)
{
begin_reversible_command (_("clear playlist"));
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->clear ();
- XMLNode &after = playlist->get_state();
- _session->add_command (new MementoCommand<Playlist>(*playlist.get(), &before, &after));
+ _session->add_command (new StatefulDiffCommand (playlist));
commit_reversible_command ();
}
continue;
}
+ /* XXX STATEFUL this won't capture region moves if don't as a stateful diff
+ */
+
XMLNode &before = playlist->get_state();
playlist->nudge_after (start, distance, forwards);
XMLNode &after = playlist->get_state();
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
if (!arv)
continue;
- XMLNode &before = arv->region()->get_state();
+ arv->region()->clear_history ();
arv->audio_region()->normalize_to (spin.get_value());
- _session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
+ _session->add_command (new StatefulDiffCommand (arv->region()));
+
}
commit_reversible_command ();
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
if (!arv)
continue;
- XMLNode &before = arv->region()->get_state();
+ arv->region()->clear_history ();
arv->audio_region()->set_scale_amplitude (1.0f);
- _session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
+ _session->add_command (new StatefulDiffCommand (arv->region()));
}
commit_reversible_command ();
for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*r);
- if (!arv)
+ if (!arv) {
continue;
- XMLNode &before = arv->region()->get_state();
+ }
+ arv->region()->clear_history ();
+
double fraction = gain_to_slider_position (arv->audio_region()->scale_amplitude ());
if (up) {
}
arv->audio_region()->set_scale_amplitude (fraction);
- _session->add_command (new MementoCommand<Region>(*(arv->region().get()), &before, &arv->region()->get_state()));
+ _session->add_command (new StatefulDiffCommand (arv->region()));
}
commit_reversible_command ();
if (arv->audio_region()->apply (filter) == 0) {
- XMLNode &before = playlist->get_state();
-
+ playlist->clear_history ();
+
if (filter.results.empty ()) {
/* no regions returned; remove the old one */
}
- XMLNode &after = playlist->get_state();
- _session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
+ _session->add_command(new StatefulDiffCommand (playlist));
} else {
goto out;
}
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
if (arv) {
- XMLNode &before = arv->region()->get_state ();
+ arv->region()->clear_history ();
arv->set_envelope_visible (!arv->envelope_visible());
- XMLNode &after = arv->region()->get_state ();
- _session->add_command (new MementoCommand<Region> (*(arv->region().get()), &before, &after));
+ _session->add_command (new StatefulDiffCommand (arv->region()));
}
}
_session->begin_reversible_command (_("region lock style"));
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
- XMLNode &before = (*i)->region()->get_state ();
+ (*i)->region()->clear_history ();
(*i)->region()->set_position_lock_style (ps);
- XMLNode &after = (*i)->region()->get_state ();
- _session->add_command (new MementoCommand<Region> (*((*i)->region().get()), &before, &after));
+ _session->add_command (new StatefulDiffCommand ((*i)->region()));
}
_session->commit_reversible_command ();
have_switch = true;
}
- XMLNode &before = region->get_state();
+ region->clear_history ();
+
if (in) {
region->set_fade_in_active (!yn);
} else {
region->set_fade_out_active (!yn);
}
- XMLNode &after = region->get_state();
- _session->add_command(new MementoCommand<AudioRegion>(*region.get(), &before, &after));
+
+ _session->add_command(new StatefulDiffCommand (region));
}
commit_reversible_command ();
boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
-
- XMLNode &before = ar->get_state();
-
+
+ ar->clear_history ();
ar->set_fade_in_active (yn);
-
- XMLNode &after = ar->get_state();
- _session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
+ _session->add_command (new StatefulDiffCommand (ar));
}
commit_reversible_command ();
boost::shared_ptr<AudioRegion> ar (tmp->audio_region());
- XMLNode &before = ar->get_state();
-
+ ar->clear_history ();
ar->set_fade_out_active (yn);
-
- XMLNode &after = ar->get_state();
- _session->add_command(new MementoCommand<AudioRegion>(*ar, &before, &after));
+ _session->add_command(new StatefulDiffCommand (ar));
}
commit_reversible_command ();
nframes64_t pos = r->position();
- XMLNode& before (pl->get_state());
+ pl->clear_history ();
x = positions.begin();
pl->thaw ();
- XMLNode& after (pl->get_state());
-
- _session->add_command (new MementoCommand<Playlist>(*pl, &before, &after));
+ _session->add_command (new StatefulDiffCommand (pl));
}
void
if (pl) {
+ /* XXX STATEFUL this won't capture region motion if done as stateful diff
+ */
+
XMLNode &before = pl->get_state();
if (opt == SplitIntersected) {
#include "pbd/error.h"
#include "pbd/pthread_utils.h"
#include "pbd/memento_command.h"
+#include "pbd/stateful_diff_command.h"
#include <gtkmm2ext/utils.h>
MidiStretch stretch(*_session, request);
begin_reversible_command ("midi stretch");
stretch.run(regions.front()->region());
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->replace_region (regions.front()->region(), stretch.results[0],
regions.front()->region()->position());
- XMLNode &after = playlist->get_state();
- _session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
+ _session->add_command (new StatefulDiffCommand (playlist));
commit_reversible_command ();
}
in_command = true;
}
- XMLNode &before = playlist->get_state();
+ playlist->clear_history ();
playlist->replace_region (region, new_region, region->position());
- XMLNode &after = playlist->get_state();
- _session->add_command (new MementoCommand<Playlist>(*playlist, &before, &after));
+ _session->add_command (new StatefulDiffCommand (playlist));
}
i = tmp;
#include <sigc++/signal.h>
#include "pbd/memento_command.h"
+#include "pbd/stateful_diff_command.h"
#include "ardour/playlist.h"
#include "ardour/tempo.h"
trackview.session()->begin_reversible_command (_("paste"));
- XMLNode& before (_region->get_state());
+ _region->clear_history ();
_region->set_length (end_frame, this);
- trackview.session()->add_command (new MementoCommand<Region>(*_region, &before, &_region->get_state()));
+ trackview.session()->add_command (new StatefulDiffCommand (_region));
}
apply_delta ();
if (nlen != region->length()) {
- region->freeze ();
+ region->suspend_property_changes ();
region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
region->set_length (start + dur - region->position(), this);
- region->thaw ();
+ region->resume_property_changes ();
if (origlen == 1) {
/* our special initial length */
if (region->source_length(0) >= region->position() + nlen) {
- region->freeze ();
+ region->suspend_property_changes ();
region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
region->set_length (nlen, this);
- region->thaw ();
+ region->resume_property_changes ();
if (origlen == 1) {
/* our special initial length */
#include "pbd/basename.h"
#include "pbd/enumwriter.h"
#include "pbd/memento_command.h"
+#include "pbd/stateful_diff_command.h"
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/selector.h>
Editor* real_editor = dynamic_cast<Editor*> (&_editor);
real_editor->begin_reversible_command (_("create region"));
- XMLNode &before = playlist()->get_state();
+ playlist()->clear_history ();
framepos_t start = pos;
real_editor->snap_to (start, -1);
boost::shared_ptr<Region> region = (RegionFactory::create (src, plist));
playlist()->add_region (region, start);
- XMLNode &after = playlist()->get_state();
- _session->add_command (new MementoCommand<Playlist> (*playlist().get(), &before, &after));
+ _session->add_command (new StatefulDiffCommand (playlist()));
real_editor->commit_reversible_command();
#include "evoral/Curve.hpp"
#include "pbd/memento_command.h"
+#include "pbd/stateful_diff_command.h"
#include "ardour/audioregion.h"
#include "ardour/session.h"
AudioRegionGainLine::start_drag_single (ControlPoint* cp, double x, float fraction)
{
AutomationLine::start_drag_single (cp, x, fraction);
+
+ // XXX Stateful need to capture automation curve data
if (!rv.audio_region()->envelope_active()) {
trackview.session()->add_command(new MementoCommand<AudioRegion>(*(rv.audio_region().get()), &rv.audio_region()->get_state(), 0));
XMLNode &before = alist->get_state();
if (!rv.audio_region()->envelope_active()) {
- XMLNode ®ion_before = rv.audio_region()->get_state();
+ rv.audio_region()->clear_history ();
rv.audio_region()->set_envelope_active(true);
- XMLNode ®ion_after = rv.audio_region()->get_state();
- trackview.session()->add_command(new MementoCommand<AudioRegion>(*(rv.audio_region().get()), ®ion_before, ®ion_after));
+ trackview.session()->add_command(new StatefulDiffCommand (rv.audio_region()));
}
alist->erase (mr.start, mr.end);
int export_stuff (BufferSet& bufs, sframes_t start_frame, nframes_t nframes, bool enable_processing = true);
- void freeze (InterThreadInfo&);
+ void freeze_me (InterThreadInfo&);
void unfreeze ();
boost::shared_ptr<Region> bounce (InterThreadInfo&);
AutomationList& operator= (const AutomationList&);
bool operator== (const AutomationList&);
- void freeze();
void thaw ();
void mark_dirty () const;
int export_stuff (BufferSet& bufs, nframes_t nframes, sframes_t end_frame);
- void freeze (InterThreadInfo&);
+ void freeze_me (InterThreadInfo&);
void unfreeze ();
boost::shared_ptr<Region> bounce (InterThreadInfo&);
PBD::PropertyList* property_factory (const XMLNode&) const;
- void unlock_property_changes () { _no_property_changes = false; }
- void block_property_changes () { _no_property_changes = true; }
-
virtual ~Region();
/** Note: changing the name of a Region does not constitute an edit */
void set_position_lock_style (PositionLockStyle ps);
void recompute_position_from_lock_style ();
- void freeze ();
- void thaw ();
+ void suspend_property_changes ();
bool covers (framepos_t frame) const {
return first_frame() <= frame && frame <= last_frame();
protected:
void send_change (const PBD::PropertyChange&);
+ void mid_thaw (const PBD::PropertyChange&);
void trim_to_internal (framepos_t position, framecnt_t length, void *src);
virtual void set_position_internal (framepos_t pos, bool allow_bbt_recompute);
virtual void recompute_at_end () = 0;
DataType _type;
- bool _no_property_changes;
PBD::Property<bool> _muted;
PBD::Property<bool> _opaque;
framepos_t _last_position;
PositionLockStyle _positional_lock_style;
mutable RegionEditState _first_edit;
- int _frozen;
BBT_Time _bbt_time;
AnalysisFeatureList _transients;
bool _valid_transients;
mutable uint64_t _read_data_count; ///< modified in read()
- PBD::PropertyChange _pending_changed;
uint64_t _last_layer_op; ///< timestamp
- Glib::Mutex _lock;
SourceList _sources;
/** Used when timefx are applied, so we can always use the original source */
SourceList _master_sources;
boost::shared_ptr<Region> write_one_track (AudioTrack&, nframes_t start, nframes_t end,
bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
bool enable_processing = true);
- int freeze (InterThreadInfo&);
+ int freeze_all (InterThreadInfo&);
/* session-wide solo/mute/rec-enable */
FreezeState freeze_state() const;
- virtual void freeze (InterThreadInfo&) = 0;
+ virtual void freeze_me (InterThreadInfo&) = 0;
virtual void unfreeze () = 0;
virtual boost::shared_ptr<Region> bounce (InterThreadInfo&) = 0;
#include "pbd/xml++.h"
#include "pbd/memento_command.h"
#include "pbd/enumwriter.h"
-#include "pbd/stacktrace.h"
+#include "pbd/stateful_diff_command.h"
#include "ardour/analyser.h"
#include "ardour/ardour.h"
// cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
- XMLNode &before = _playlist->get_state();
+ _playlist->clear_history ();
_playlist->freeze ();
for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
}
_playlist->thaw ();
- XMLNode &after = _playlist->get_state();
- _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
+ _session.add_command (new StatefulDiffCommand (_playlist));
}
mark_write_completed = true;
}
void
-AudioTrack::freeze (InterThreadInfo& itt)
+AudioTrack::freeze_me (InterThreadInfo& itt)
{
vector<boost::shared_ptr<Source> > srcs;
string new_playlist_name;
LocaleGuard lg (X_("POSIX"));
boost::shared_ptr<Playlist> the_playlist (_playlist.lock());
- freeze ();
+ suspend_property_changes ();
if (the_playlist) {
the_playlist->freeze ();
/* Now find envelope description and other related child items */
- _envelope->freeze ();
+ _envelope->freeze ();
for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
XMLNode *child;
}
}
- _envelope->thaw ();
- thaw ();
-
+ _envelope->thaw ();
+ resume_property_changes ();
+
if (send) {
send_change (what_changed);
}
void
AudioRegion::set_fade_in (boost::shared_ptr<AutomationList> f)
{
- _fade_in->freeze ();
+ _fade_in->freeze ();
*_fade_in = *f;
- _fade_in->thaw ();
+ _fade_in->thaw ();
send_change (PropertyChange (Properties::fade_in));
}
void
AudioRegion::set_fade_in (FadeShape shape, framecnt_t len)
{
- _fade_in->freeze ();
+ _fade_in->freeze ();
_fade_in->clear ();
switch (shape) {
break;
}
- _fade_in->thaw ();
+ _fade_in->thaw ();
}
void
AudioRegion::set_fade_out (boost::shared_ptr<AutomationList> f)
{
- _fade_out->freeze ();
+ _fade_out->freeze ();
*_fade_out = *f;
- _fade_out->thaw ();
+ _fade_out->thaw ();
send_change (PropertyChange (Properties::fade_in));
}
void
AudioRegion::set_fade_out (FadeShape shape, framecnt_t len)
{
- _fade_out->freeze ();
+ _fade_out->freeze ();
_fade_out->clear ();
switch (shape) {
break;
}
- _fade_out->thaw ();
+ _fade_out->thaw ();
}
void
void
AudioRegion::set_default_envelope ()
{
- _envelope->freeze ();
+ _envelope->freeze ();
_envelope->clear ();
_envelope->fast_simple_add (0, 1.0f);
_envelope->fast_simple_add (_length, 1.0f);
- _envelope->thaw ();
+ _envelope->thaw ();
}
void
based on the the existing curve.
*/
- _envelope->freeze ();
+ _envelope->freeze ();
_envelope->truncate_end (_length);
_envelope->set_max_xval (_length);
- _envelope->thaw ();
+ _envelope->thaw ();
if (_fade_in->back()->when > _length) {
_fade_in->extend_to (_length);
{
ControlList::maybe_signal_changed ();
- if (!_frozen) {
+ if (!ControlList::frozen()) {
StateChanged (); /* EMIT SIGNAL */
}
}
_new_value = false;
}
-void
-AutomationList::freeze ()
-{
- _frozen++;
-}
-
void
AutomationList::thaw ()
{
return -1;
}
- freeze ();
+ ControlList::freeze ();
clear ();
stringstream str (content_node->content());
maybe_signal_changed ();
}
- thaw ();
-
+ ControlList::thaw ();
+
return 0;
}
nframes_t x;
double y;
- freeze ();
+ ControlList::freeze ();
clear ();
for (i = elist.begin(); i != elist.end(); ++i) {
fast_simple_add (x, y);
}
- thaw ();
+ ControlList::thaw ();
return 0;
}
#include "pbd/xml++.h"
#include "pbd/memento_command.h"
#include "pbd/enumwriter.h"
+#include "pbd/stateful_diff_command.h"
#include "ardour/ardour.h"
#include "ardour/audioengine.h"
// cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
- XMLNode &before = _playlist->get_state();
+ _playlist->clear_history ();
_playlist->freeze ();
uint32_t buffer_position = 0;
}
_playlist->thaw ();
- XMLNode &after = _playlist->get_state();
- _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
+ _session.add_command (new StatefulDiffCommand(_playlist));
}
}
void
-MidiTrack::freeze (InterThreadInfo& /*itt*/)
+MidiTrack::freeze_me (InterThreadInfo& /*itt*/)
{
}
partition_internal (start, end, cut, thawlist);
for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
- (*i)->thaw ();
+ (*i)->resume_property_changes ();
}
}
/* "front" ***** */
- current->freeze ();
+ current->suspend_property_changes ();
thawlist.push_back (current);
current->trim_end (pos2, this);
/* front ****** */
- current->freeze ();
+ current->suspend_property_changes ();
thawlist.push_back (current);
current->trim_end (pos2, this);
/* 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;
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;
// So that layer_op ordering doesn't get screwed up
region->set_last_layer_op( region->layer());
- region->thaw ();
+ region->resume_property_changes ();
}
}
Region::Region (Session& s, framepos_t start, framecnt_t length, const string& name, DataType type)
: SessionObject(s, name)
, _type(type)
- , _no_property_changes (true)
, REGION_DEFAULT_STATE(start,length)
, _last_length (length)
, _last_position (0)
, _positional_lock_style(AudioTime)
, _first_edit (EditChangesNothing)
- , _frozen(0)
, _read_data_count(0)
, _last_layer_op(0)
, _pending_explicit_relayer (false)
Region::Region (const SourceList& srcs)
: SessionObject(srcs.front()->session(), "toBeRenamed")
, _type (srcs.front()->type())
- , _no_property_changes (true)
, REGION_DEFAULT_STATE(0,0)
, _last_length (0)
, _last_position (0)
, _positional_lock_style (_type == DataType::AUDIO ? AudioTime : MusicTime)
, _first_edit (EditChangesNothing)
- , _frozen (0)
, _valid_transients(false)
, _read_data_count(0)
, _last_layer_op (0)
Region::Region (boost::shared_ptr<const Region> other, frameoffset_t offset, bool offset_relative)
: SessionObject(other->session(), other->name())
, _type (other->data_type())
- , _no_property_changes (true)
, REGION_COPY_STATE (other)
, _last_length (other->_last_length)
, _last_position(other->_last_position) \
, _positional_lock_style(other->_positional_lock_style) \
, _first_edit (EditChangesNothing)
- , _frozen (0)
, _valid_transients(false)
, _read_data_count(0)
, _last_layer_op (0)
Region::Region (boost::shared_ptr<const Region> other, const SourceList& srcs)
: SessionObject (other->session(), other->name())
, _type (srcs.front()->type())
- , _no_property_changes (true)
, REGION_COPY_STATE (other)
, _last_length (other->_last_length)
, _last_position (other->_last_position)
, _positional_lock_style (other->_positional_lock_style)
, _first_edit (EditChangesID)
- , _frozen (0)
, _valid_transients (false)
, _read_data_count (0)
, _last_layer_op (other->_last_layer_op)
Region::Region (boost::shared_ptr<const Region> other)
: SessionObject(other->session(), other->name())
, _type(other->data_type())
- , _no_property_changes (true)
, REGION_COPY_STATE (other)
, _last_length (other->_last_length)
, _last_position (other->_last_position)
, _positional_lock_style (other->_positional_lock_style)
, _first_edit (EditChangesID)
- , _frozen(0)
, _valid_transients(false)
, _read_data_count(0)
, _last_layer_op(other->_last_layer_op)
maybe_uncopy ();
invalidate_transients ();
- if (!_frozen) {
+ if (!property_changes_suspended()) {
recompute_at_end ();
}
}
trim_to_internal (new_position, newlen, src);
- if (!_frozen) {
+ if (!property_changes_suspended()) {
recompute_at_start ();
}
}
if (new_endpoint > _position) {
trim_to_internal (_position, new_endpoint - _position + 1, this);
- if (!_frozen) {
+ if (!property_changes_suspended()) {
recompute_at_end ();
}
}
trim_to_internal (position, length, src);
- if (!_frozen) {
+ if (!property_changes_suspended()) {
recompute_at_start ();
recompute_at_end ();
}
what_changed.add (Properties::start);
}
if (_length != length) {
- if (!_frozen) {
+ if (!property_changes_suspended()) {
_last_length = _length;
}
_length = length;
what_changed.add (Properties::length);
}
if (_position != position) {
- if (!_frozen) {
+ if (!property_changes_suspended()) {
_last_position = _position;
}
_position = position;
if (file_pos != _sync_position) {
_sync_marked = true;
_sync_position = file_pos;
- if (!_frozen) {
+ if (!property_changes_suspended()) {
maybe_uncopy ();
}
send_change (Properties::sync_position);
{
if (sync_marked()) {
_sync_marked = false;
- if (!_frozen) {
+ if (!property_changes_suspended()) {
maybe_uncopy ();
}
send_change (Properties::sync_position);
}
void
-Region::freeze ()
+Region::suspend_property_changes ()
{
- _frozen++;
+ Stateful::suspend_property_changes ();
_last_length = _length;
_last_position = _position;
}
void
-Region::thaw ()
+Region::mid_thaw (const PropertyChange& what_changed)
{
- PropertyChange what_changed;
-
- {
- Glib::Mutex::Lock lm (_lock);
-
- if (_frozen && --_frozen > 0) {
- return;
- }
-
- if (!_pending_changed.empty()) {
- what_changed = _pending_changed;
- _pending_changed.clear ();
- }
- }
-
- if (what_changed.empty()) {
- return;
- }
-
if (what_changed.contains (Properties::length)) {
if (what_changed.contains (Properties::position)) {
recompute_at_start ();
}
recompute_at_end ();
}
-
- send_change (what_changed);
}
void
return;
}
- {
- Glib::Mutex::Lock lm (_lock);
- if (_frozen) {
- _pending_changed.add (what_changed);
- return;
- }
- }
-
- PropertyChanged (what_changed);
+ Stateful::send_change (what_changed);
if (!_no_property_changes) {
try {
boost::shared_ptr<Region> rptr = shared_from_this();
RegionPropertyChanged (rptr, what_changed);
-
} catch (...) {
/* no shared_ptr available, relax; */
}
}
-
}
void
} else if (prop == Properties::position_locked.property_id) {
_position_locked = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
} else if (prop == Properties::start.property_id) {
- _start = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
+ framepos_t val = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
+ if (val != _start) {
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 start changed from %2 to %3",
+ _name.val(), _start, val));
+ _start = val;
+ return true;
+ }
} else if (prop == Properties::length.property_id) {
framecnt_t val = dynamic_cast<const PropertyTemplate<framecnt_t>* > (&prop)->val();
if (val != _length) {
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 length changed from %2 to %3",
+ _name.val(), _length, val));
_length = val;
return true;
}
} else if (prop == Properties::position.property_id) {
framepos_t val = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
if (val != _position) {
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 position changed from %2 to %3",
+ _name.val(), _position, val));
_position = val;
return true;
}
}
if (ret) {
- ret->unlock_property_changes ();
map_add (ret);
/* pure copy constructor - no property list */
}
if (ret) {
-
ret->set_properties (plist);
- ret->unlock_property_changes ();
-
map_add (ret);
if (announce) {
}
if (ret) {
-
ret->set_properties (plist);
- ret->unlock_property_changes ();
-
map_add (ret);
if (announce) {
if (ret) {
ret->set_properties (plist);
- ret->unlock_property_changes ();
-
map_add (ret);
if (announce) {
if (ret) {
ret->set_properties (plist);
- ret->unlock_property_changes ();
-
map_add (ret);
if (announce) {
if (ret->set_state (node, Stateful::loading_state_version)) {
ret.reset ();
} else {
- ret->unlock_property_changes ();
map_add (ret);
CheckNewRegion (ret);
}
}
int
-Session::freeze (InterThreadInfo& itt)
+Session::freeze_all (InterThreadInfo& itt)
{
shared_ptr<RouteList> r = routes.reader ();
/* XXX this is wrong because itt.progress will keep returning to zero at the start
of every track.
*/
- t->freeze (itt);
+ t->freeze_me (itt);
}
}
ControlList& operator= (const ControlList&);
bool operator== (const ControlList&);
- void freeze();
- void thaw ();
+ virtual void freeze();
+ virtual void thaw ();
+ bool frozen() const { return _frozen; }
const Parameter& parameter() const { return _parameter; }
void set_parameter(const Parameter& p) { _parameter = p; }
{}
void set (T const& v) {
- _old = _current;
- _have_old = true;
+ if (!_have_old) {
+ _old = _current;
+ _have_old = true;
+ }
_current = v;
}
static int current_state_version;
static int loading_state_version;
+ virtual void suspend_property_changes ();
+ virtual void resume_property_changes ();
+
+ void unlock_property_changes () { _no_property_changes = false; }
+ void block_property_changes () { _no_property_changes = true; }
+
protected:
void add_instant_xml (XMLNode&, const sys::path& directory_path);
XMLNode *_extra_xml;
XMLNode *_instant_xml;
- PBD::ID _id;
+ PBD::ID _id;
+ int32_t _frozen;
+ bool _no_property_changes;
+ PBD::PropertyChange _pending_changed;
+ Glib::Mutex _lock;
std::string _xml_node_name; ///< name of node to use for this object in XML
OwnedPropertyList* _properties;
+
+ virtual void send_change (const PropertyChange&);
+ /** derived classes can implement this in order to process a property change
+ within thaw() just before send_change() is called.
+ */
+ virtual void mid_thaw (const PropertyChange&) { }
+ bool property_changes_suspended() const { return g_atomic_int_get (&_frozen) > 0; }
};
} // namespace PBD
int Stateful::loading_state_version = 0;
Stateful::Stateful ()
- : _properties (new OwnedPropertyList)
+ : _frozen (0)
+ , _no_property_changes (false)
+ , _properties (new OwnedPropertyList)
{
_extra_xml = 0;
_instant_xml = 0;
_properties->add (s);
}
+void
+Stateful::send_change (const PropertyChange& what_changed)
+{
+ if (what_changed.empty()) {
+ return;
+ }
+
+ {
+ Glib::Mutex::Lock lm (_lock);
+ if (_frozen) {
+ _pending_changed.add (what_changed);
+ return;
+ }
+ }
+
+ PropertyChanged (what_changed);
+}
+
+void
+Stateful::suspend_property_changes ()
+{
+ _frozen++;
+}
+
+void
+Stateful::resume_property_changes ()
+{
+ PropertyChange what_changed;
+
+ {
+ Glib::Mutex::Lock lm (_lock);
+
+ if (_frozen && --_frozen > 0) {
+ return;
+ }
+
+ if (!_pending_changed.empty()) {
+ what_changed = _pending_changed;
+ _pending_changed.clear ();
+ }
+ }
+
+ mid_thaw (what_changed);
+
+ send_change (what_changed);
+}
+
+
} // namespace PBD
, addr (a)
, path (p)
{
- c->Changed.connect (changed_connection, boost::bind (&OSCControllable::send_change, this), OSC::instance());
+ c->Changed.connect (changed_connection, boost::bind (&OSCControllable::send_change_message, this), OSC::instance());
}
OSCControllable::~OSCControllable ()
}
void
-OSCControllable::send_change ()
+OSCControllable::send_change_message ()
{
lo_message msg = lo_message_new ();
}
void
-OSCRouteControllable::send_change ()
+OSCRouteControllable::send_change_message ()
{
lo_message msg = lo_message_new ();
lo_address addr;
std::string path;
- virtual void send_change ();
+ virtual void send_change_message ();
};
class OSCRouteControllable : public OSCControllable
private:
boost::shared_ptr<ARDOUR::Route> _route;
- void send_change ();
+ void send_change_message ();
};
#endif /* __osc_osccontrollable_h__ */
projects / ardour.git / commitdiff