2 Copyright (C) 2016 Paul Davis
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2 of the License, or (at your option)
9 This program is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 You should have received a copy of the GNU General Public License along
15 with this program; if not, write to the Free Software Foundation, Inc.,
16 675 Mass Ave, Cambridge, MA 02139, USA.
19 #ifndef __libardour_slavable_automation_control_h__
20 #define __libardour_slavable_automation_control_h__
22 #include "pbd/enumwriter.h"
24 #include "ardour/slavable_automation_control.h"
25 #include "ardour/session.h"
28 using namespace ARDOUR;
31 SlavableAutomationControl::SlavableAutomationControl(ARDOUR::Session& s,
32 const Evoral::Parameter& parameter,
33 const ParameterDescriptor& desc,
34 boost::shared_ptr<ARDOUR::AutomationList> l,
35 const std::string& name)
36 : AutomationControl (s, parameter, desc, l, name)
41 SlavableAutomationControl::get_masters_value_locked () const
43 double v = _desc.normal;
46 for (Masters::const_iterator mr = _masters.begin(); mr != _masters.end(); ++mr) {
47 if (mr->second.master()->get_value()) {
54 for (Masters::const_iterator mr = _masters.begin(); mr != _masters.end(); ++mr) {
55 /* get current master value, scale by our current ratio with that master */
56 v *= mr->second.master()->get_value () * mr->second.ratio();
59 return min ((double) _desc.upper, v);
63 SlavableAutomationControl::get_value_locked() const
65 /* read or write masters lock must be held */
67 if (_masters.empty()) {
68 return Control::get_double (false, _session.transport_frame());
72 /* for boolean/toggle controls, if this slave OR any master is
73 * enabled, this slave is enabled. So check our own value
74 * first, because if we are enabled, we can return immediately.
76 if (Control::get_double (false, _session.transport_frame())) {
81 return get_masters_value_locked ();
84 /** Get the current effective `user' value based on automation state */
86 SlavableAutomationControl::get_value() const
88 bool from_list = _list && boost::dynamic_pointer_cast<AutomationList>(_list)->automation_playback();
91 Glib::Threads::RWLock::ReaderLock lm (master_lock);
92 return get_value_locked ();
94 return Control::get_double (from_list, _session.transport_frame());
99 SlavableAutomationControl::actually_set_value (double val, Controllable::GroupControlDisposition group_override)
101 val = std::max (std::min (val, (double)_desc.upper), (double)_desc.lower);
104 Glib::Threads::RWLock::WriterLock lm (master_lock);
106 if (!_masters.empty()) {
107 recompute_masters_ratios (val);
111 /* this sets the Evoral::Control::_user_value for us, which will
112 be retrieved by AutomationControl::get_value ()
114 AutomationControl::actually_set_value (val, group_override);
116 _session.set_dirty ();
120 SlavableAutomationControl::add_master (boost::shared_ptr<AutomationControl> m)
122 std::pair<Masters::iterator,bool> res;
125 Glib::Threads::RWLock::WriterLock lm (master_lock);
126 const double current_value = get_value_locked ();
128 /* ratio will be recomputed below */
130 pair<PBD::ID,MasterRecord> newpair (m->id(), MasterRecord (m, 1.0));
131 res = _masters.insert (newpair);
135 recompute_masters_ratios (current_value);
137 /* note that we bind @param m as a weak_ptr<AutomationControl>, thus
138 avoiding holding a reference to the control in the binding
142 m->DropReferences.connect_same_thread (masters_connections, boost::bind (&SlavableAutomationControl::master_going_away, this, m));
144 /* Store the connection inside the MasterRecord, so that when we destroy it, the connection is destroyed
145 and we no longer hear about changes to the AutomationControl.
147 Note that we fix the "from_self" argument that will
148 be given to our own Changed signal to "false",
149 because the change came from the master.
152 m->Changed.connect_same_thread (res.first->second.connection, boost::bind (&SlavableAutomationControl::master_changed, this, _1, _2, m));
153 cerr << this << enum_2_string ((AutomationType) _parameter.type()) << " now listening to Changed from " << m << endl;
158 /* this will notify everyone that we're now slaved to the master */
159 MasterStatusChange (); /* EMIT SIGNAL */
164 update_boolean_masters_records (m);
168 SlavableAutomationControl::get_boolean_masters () const
173 Glib::Threads::RWLock::ReaderLock lm (master_lock);
174 for (Masters::const_iterator mr = _masters.begin(); mr != _masters.end(); ++mr) {
175 if (mr->second.yn()) {
185 SlavableAutomationControl::update_boolean_masters_records (boost::shared_ptr<AutomationControl> m)
188 /* We may modify a MasterRecord, but we not modify the master
189 * map, so we use a ReaderLock
191 Glib::Threads::RWLock::ReaderLock lm (master_lock);
192 Masters::iterator mi = _masters.find (m->id());
193 if (mi != _masters.end()) {
194 /* update MasterRecord to show whether the master is
195 on/off. We need to store this because the master
196 may change (in the sense of emitting Changed())
197 several times without actually changing the result
198 of ::get_value(). This is a feature of
199 AutomationControls (or even just Controllables,
200 really) which have more than a simple scalar
201 value. For example, the master may be a mute control
202 which can be muted_by_self() and/or
203 muted_by_masters(). When either of those two
204 conditions changes, Changed() will be emitted, even
205 though ::get_value() will return the same value each
206 time (1.0 if either are true, 0.0 if neither is).
208 This provides a way for derived types to check
209 the last known state of a Master when the Master
210 changes. We update it after calling
211 ::master_changed() (though derived types must do
214 mi->second.set_yn (m->get_value());
220 SlavableAutomationControl::master_changed (bool /*from_self*/, GroupControlDisposition gcd, boost::shared_ptr<AutomationControl> m)
222 update_boolean_masters_records (m);
223 Changed (false, Controllable::NoGroup); /* EMIT SIGNAL */
227 SlavableAutomationControl::master_going_away (boost::weak_ptr<AutomationControl> wm)
229 boost::shared_ptr<AutomationControl> m = wm.lock();
236 SlavableAutomationControl::remove_master (boost::shared_ptr<AutomationControl> m)
238 double current_value;
241 Masters::size_type erased = 0;
243 pre_remove_master (m);
246 Glib::Threads::RWLock::WriterLock lm (master_lock);
247 current_value = get_value_locked ();
248 erased = _masters.erase (m->id());
250 recompute_masters_ratios (current_value);
252 masters_left = _masters.size ();
253 new_value = get_value_locked ();
257 MasterStatusChange (); /* EMIT SIGNAL */
260 if (new_value != current_value) {
261 if (masters_left == 0) {
262 /* no masters left, make sure we keep the same value
265 actually_set_value (current_value, Controllable::UseGroup);
269 /* no need to update boolean masters records, since the MR will have
270 * been removed already.
275 SlavableAutomationControl::clear_masters ()
277 double current_value;
279 bool had_masters = false;
281 /* null ptr means "all masters */
282 pre_remove_master (boost::shared_ptr<AutomationControl>());
285 Glib::Threads::RWLock::WriterLock lm (master_lock);
286 current_value = get_value_locked ();
287 if (!_masters.empty()) {
291 new_value = get_value_locked ();
295 MasterStatusChange (); /* EMIT SIGNAL */
298 if (new_value != current_value) {
299 actually_set_value (current_value, Controllable::UseGroup);
302 /* no need to update boolean masters records, since all MRs will have
303 * been removed already.
308 SlavableAutomationControl::slaved_to (boost::shared_ptr<AutomationControl> m) const
310 Glib::Threads::RWLock::ReaderLock lm (master_lock);
311 return _masters.find (m->id()) != _masters.end();
315 SlavableAutomationControl::slaved () const
317 Glib::Threads::RWLock::ReaderLock lm (master_lock);
318 return !_masters.empty();
321 #endif /* __libardour_slavable_automation_control_h__ */