You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- $Id$
+
*/
#include <set>
#include <algorithm>
#include <sigc++/bind.h>
#include <ardour/automation_event.h>
+#include <pbd/stacktrace.h>
#include "i18n.h"
sigc::signal<void,AutomationList *> AutomationList::AutomationListCreated;
+static bool sort_events_by_time (ControlEvent* a, ControlEvent* b)
+{
+ return a->when < b->when;
+}
+
#if 0
static void dumpit (const AutomationList& al, string prefix = "")
{
AutomationList::AutomationList (double defval)
{
- _frozen = false;
+ _frozen = 0;
changed_when_thawed = false;
_state = Off;
_style = Absolute;
rt_insertion_point = events.end();
lookup_cache.left = -1;
lookup_cache.range.first = events.end();
+ sort_pending = false;
AutomationListCreated(this);
}
AutomationList::AutomationList (const AutomationList& other)
{
- _frozen = false;
+ _frozen = 0;
changed_when_thawed = false;
_style = other._style;
min_yval = other.min_yval;
rt_insertion_point = events.end();
lookup_cache.left = -1;
lookup_cache.range.first = events.end();
+ sort_pending = false;
for (const_iterator i = other.events.begin(); i != other.events.end(); ++i) {
/* we have to use other point_factory() because
AutomationList::AutomationList (const AutomationList& other, double start, double end)
{
- _frozen = false;
+ _frozen = 0;
changed_when_thawed = false;
_style = other._style;
min_yval = other.min_yval;
rt_insertion_point = events.end();
lookup_cache.left = -1;
lookup_cache.range.first = events.end();
+ sort_pending = false;
/* now grab the relevant points, and shift them back if necessary */
AutomationList::AutomationList (const XMLNode& node)
{
- _frozen = false;
+ _frozen = 0;
changed_when_thawed = false;
_touching = false;
min_yval = FLT_MIN;
rt_insertion_point = events.end();
lookup_cache.left = -1;
lookup_cache.range.first = events.end();
+ sort_pending = false;
set_state (node);
max_yval = other.max_yval;
max_xval = other.max_xval;
default_value = other.default_value;
-
+
+ rt_insertion_point = events.end();
+ lookup_cache.range.first = events.end();
+
mark_dirty ();
maybe_signal_changed ();
}
if (_frozen) {
changed_when_thawed = true;
} else {
- StateChanged (Change (0));
+ StateChanged ();
}
}
if (!done) {
last_rt_insertion_point = events.insert (where, point_factory (when, value));
+ // cerr << "\tINSERTED\n";
}
_new_touch = false;
}
if (insert) {
-
+
events.insert (insertion_point, point_factory (when, value));
reposition_for_rt_add (0);
while (start != end) {
(*start)->when += xdelta;
(*start)->value += ydelta;
+ if (isnan ((*start)->value)) {
+ abort ();
+ }
++start;
}
+ if (!_frozen) {
+ events.sort (sort_events_by_time);
+ } else {
+ sort_pending = true;
+ }
+
mark_dirty ();
}
maybe_signal_changed ();
}
+void
+AutomationList::slide (iterator before, double distance)
+{
+ {
+ Glib::Mutex::Lock lm (lock);
+
+ if (before == events.end()) {
+ return;
+ }
+
+ while (before != events.end()) {
+ (*before)->when += distance;
+ ++before;
+ }
+ }
+
+ maybe_signal_changed ();
+}
+
void
AutomationList::modify (iterator iter, double when, double val)
{
{
Glib::Mutex::Lock lm (lock);
+
(*iter)->when = when;
(*iter)->value = val;
+
+ if (isnan (val)) {
+ abort ();
+ }
+
+ if (!_frozen) {
+ events.sort (sort_events_by_time);
+ } else {
+ sort_pending = true;
+ }
+
mark_dirty ();
}
-
+
maybe_signal_changed ();
}
void
AutomationList::freeze ()
{
- _frozen = true;
+ _frozen++;
}
void
AutomationList::thaw ()
{
- _frozen = false;
+ if (_frozen == 0) {
+ PBD::stacktrace (cerr);
+ fatal << string_compose (_("programming error: %1"), X_("AutomationList::thaw() called while not frozen")) << endmsg;
+ /*NOTREACHED*/
+ }
+
+ if (--_frozen > 0) {
+ return;
+ }
+
+ {
+ Glib::Mutex::Lock lm (lock);
+
+ if (sort_pending) {
+ events.sort (sort_events_by_time);
+ sort_pending = false;
+ }
+ }
+
if (changed_when_thawed) {
- StateChanged(Change(0)); /* EMIT SIGNAL */
+ StateChanged(); /* EMIT SIGNAL */
}
}
{
Glib::Mutex::Lock lm (lock);
ControlEvent cp (last_coordinate, 0);
- list<ControlEvent*>::reverse_iterator i;
+ AutomationList::reverse_iterator i;
double last_val;
if (events.empty()) {
uint32_t sz = events.size();
while (i != events.rend() && sz > 2) {
- list<ControlEvent*>::reverse_iterator tmp;
+ AutomationList::reverse_iterator tmp;
tmp = i;
++tmp;
i = events.begin();
while (i != events.end() && !events.empty()) {
- list<ControlEvent*>::iterator tmp;
+ AutomationList::iterator tmp;
tmp = i;
++tmp;
return multipoint_eval (x);
break;
}
+
+ /*NOTREACHED*/ /* stupid gcc */
+ return 0.0;
}
double
{
XMLNode* node = new XMLNode (X_("events"));
stringstream str;
+
+ str.precision(15); //10 digits is enough digits for 24 hours at 96kHz
for (iterator xx = events.begin(); xx != events.end(); ++xx) {
str << (double) (*xx)->when;
}
thaw ();
+
return 0;
}
AutomationList::set_state (const XMLNode& node)
{
XMLNodeList nlist = node.children();
+ XMLNode* nsos;
XMLNodeIterator niter;
const XMLProperty* prop;
if (node.name() == X_("Envelope") || node.name() == X_("FadeOut") || node.name() == X_("FadeIn")) {
+ if ((nsos = node.child (X_("AutomationList")))) {
+ /* new school in old school clothing */
+ return set_state (*nsos);
+ }
+
/* old school */
const XMLNodeList& elist = node.children();
jack_nframes_t x;
double y;
+ freeze ();
clear ();
for (i = elist.begin(); i != elist.end(); ++i) {
}
y = atof (prop->value().c_str());
- add (x, y);
+ fast_simple_add (x, y);
}
+ thaw ();
+
return 0;
}
deserialize_events (*(*niter));
}
}
-
+
return 0;
}
+void
+AutomationList::shift (nframes64_t pos, nframes64_t frames)
+{
+ {
+ Glib::Mutex::Lock lm (lock);
+
+ for (iterator i = begin (); i != end (); ++i) {
+ if ((*i)->when >= pos) {
+ (*i)->when += frames;
+ }
+ }
+
+ mark_dirty ();
+ }
+
+ maybe_signal_changed ();
+}
projects / ardour.git / blobdiff