ensure_xml_node ();
- set_state (*xml_node);
+ set_state (*xml_node, Stateful::loading_state_version);
/* if set_state above didn't create a gain automation child, we need to make one */
if (automation_track (GainAutomation) == 0) {
AutomationLine::set_state (const XMLNode &node, int version)
{
/* function as a proxy for the model */
- return alist->set_state (node);
+ return alist->set_state (node, version);
}
void
bool is_first_point (ControlPoint &);
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
void set_colors();
void modify_point_y (ControlPoint&, double);
_control->parameter());
if (xml_node) {
- set_state (*xml_node);
+ set_state (*xml_node, Stateful::loading_state_version);
}
/* ask for notifications of any new RegionViews */
int
AutomationTimeAxisView::set_state (const XMLNode& node, int version)
{
- TimeAxisView::set_state (node);
+ TimeAxisView::set_state (node, version);
XMLProperty const * type = node.property ("automation-id");
if (type && type->value () == ARDOUR::EventTypeMap::instance().to_symbol (_control->parameter())) {
bool paste (nframes_t, float times, Selection&, size_t nth);
void reset_objects (PointSelection&);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
guint32 show_at (double y, int& nth, Gtk::VBox *parent);
void hide ();
set_edit_point_preference (EditAtMouse, true);
XMLNode* node = ARDOUR_UI::instance()->editor_settings();
- set_state (*node);
+ set_state (*node, Stateful::loading_state_version);
_playlist_selector = new PlaylistSelector();
_playlist_selector->signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), static_cast<Window *> (_playlist_selector)));
sensitize_the_right_region_actions (false);
XMLNode* node = ARDOUR_UI::instance()->editor_settings();
- set_state (*node);
+ set_state (*node, Stateful::loading_state_version);
/* catch up with the playhead */
/* check if the track still exists - it could have been deleted */
if ((t = find (track_views.begin(), track_views.end(), i->first)) != track_views.end()) {
- (*t)->set_state (*(i->second));
+ (*t)->set_state (*(i->second), Stateful::loading_state_version);
}
}
void redo (uint32_t n = 1);
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
void set_mouse_mode (Editing::MouseMode, bool force=true);
void step_mouse_mode (bool next);
snooper_id = gtk_key_snooper_install (_snooper, (gpointer) this);
XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
- set_state (*node);
+ set_state (*node, Stateful::loading_state_version);
}
Keyboard::~Keyboard ()
~Keyboard ();
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
typedef std::vector<uint32_t> State;
typedef uint32_t ModifierMask;
ensure_xml_node ();
- set_state (*xml_node);
+ set_state (*xml_node, Stateful::loading_state_version);
_route->processors_changed.connect (mem_fun(*this, &MidiTimeAxisView::processors_changed));
int
RouteTimeAxisView::set_state (const XMLNode& node, int version)
{
- TimeAxisView::set_state (node);
+ TimeAxisView::set_state (node, version);
XMLNodeList kids = node.children();
XMLNodeConstIterator iter;
void remove_underlay (StreamView*);
void build_underlay_menu(Gtk::Menu*);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
/* This is a bit nasty to expose :/ */
struct RouteAutomationNode {
return;
}
+ /* XXX GET VERSION FROM TREE */
+ int version = 3000;
+
XMLNode * node = session_tree.root()->child ("Metadata");
if (!node) {
}
ARDOUR::SessionMetadata data;
- data.set_state (*node);
+ data.set_state (*node, version);
init_data ();
load_extra_data (data);
virtual ~TimeAxisView ();
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
/** @return index of this TimeAxisView within its parent */
int order () const { return _order; }
return -1;
}
- if (set_state (*tree.root())) {
+ if (set_state (*tree.root(), Stateful::loading_state_version)) {
error << string_compose(_("Ardour: default ui configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
return -1;
}
return -1;
}
- if (set_state (*tree.root())) {
+ if (set_state (*tree.root(), Stateful::loading_state_version)) {
error << string_compose(_("Ardour: default ui configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
return -1;
}
return -1;
}
- if (set_state (*tree.root())) {
+ if (set_state (*tree.root(), Stateful::loading_state_version)) {
error << string_compose(_("Ardour: user ui configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
return -1;
}
int save_state ();
int load_defaults ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
XMLNode& get_state (void);
XMLNode& get_variables (std::string);
void set_variables (const XMLNode&);
{
const XMLProperty* prop;
- Processor::set_state (node);
+ Processor::set_state (node, version);
prop = node.property ("gain");
if (prop) {
void apply_gain_automation(bool yn) { _apply_gain_automation = yn; }
XMLNode& state (bool full);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
static void apply_gain (BufferSet& bufs, nframes_t nframes, gain_t initial, gain_t target);
static void apply_simple_gain(BufferSet& bufs, nframes_t nframes, gain_t target);
/* stateful */
XMLNode& get_state(void);
- int set_state(const XMLNode& node, int version = 3000);
+ int set_state(const XMLNode& node, int version);
void monitor_input (bool);
boost::shared_ptr<Region> bounce (InterThreadInfo&);
boost::shared_ptr<Region> bounce_range (nframes_t start, nframes_t end, InterThreadInfo&, bool enable_processing);
- int set_state(const XMLNode&, int version = 3000);
+ int set_state(const XMLNode&, int version);
protected:
XMLNode& state (bool full);
int setup_peakfile ();
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
bool can_truncate_peaks() const { return !destructive(); }
bool can_be_analysed() const { return _length > 0; }
nframes_t read (Sample *dst, Sample *mixdown, float *gain_buffer, nframes_t start, nframes_t cnt, uint32_t chan_n=0);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
sigc::signal<void,boost::shared_ptr<Crossfade> > NewCrossfade;
virtual nframes_t read_raw_internal (Sample*, sframes_t, nframes_t, int channel) const;
XMLNode& state (bool);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
static void set_default_fade (float steepness, nframes_t len);
bool fade_in_is_default () const;
AudioRegion (Session& s, nframes_t, nframes_t, std::string name);
- int set_live_state (const XMLNode&, Change&, bool send);
+ int set_live_state (const XMLNode&, int version, Change&, bool send);
};
} /* namespace ARDOUR */
mutable sigc::signal<void,nframes_t,nframes_t> PeakRangeReady;
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
int rename_peakfile (Glib::ustring newpath);
void touch_peakfile ();
bool touching() const { return _touching; }
XMLNode& get_state ();
- int set_state (const XMLNode &, int version = 3000);
+ int set_state (const XMLNode &, int version);
XMLNode& state (bool full);
XMLNode& serialize_events ();
void set_protocol_states (const XMLNode&);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
XMLNode& get_state (void);
private:
bool operator== (const ARDOUR::Crossfade&);
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
boost::shared_ptr<ARDOUR::AudioRegion> in() const { return _in; }
boost::shared_ptr<ARDOUR::AudioRegion> out() const { return _out; }
static sigc::signal<void,nframes_t> CycleStart;
XMLNode& state (bool full);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
/* Panning */
/* Stateful */
virtual XMLNode& get_state(void) = 0;
- virtual int set_state(const XMLNode&, int version = 3000) = 0;
+ virtual int set_state(const XMLNode&, int version) = 0;
virtual void monitor_input (bool) {}
bool is_embedded () const { return _is_embedded; }
uint16_t channel() const { return _channel; }
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
int set_source_name (const Glib::ustring& newname, bool destructive);
XMLNode& state(bool full);
XMLNode& get_state(void);
- int set_state(const XMLNode&, int version = 3000);
+ int set_state(const XMLNode&, int version);
void run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes);
bool configure_io (ChanCount in, ChanCount out);
XMLNode& state(bool full);
XMLNode& get_state(void);
- int set_state(const XMLNode& node, int version = 3000);
+ int set_state(const XMLNode& node, int version);
void run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes);
bool feeds (boost::shared_ptr<Route> other) const;
virtual XMLNode& state (bool full);
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
int set_state_2X (const XMLNode&, int, bool);
static int disable_connecting (void);
sigc::signal<void,IOProcessor*,uint32_t> AutomationChanged;
XMLNode& state (bool full_state);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
protected:
boost::shared_ptr<IO> _input;
bool parameter_is_toggled(uint32_t) const;
XMLNode& get_state();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
bool save_preset(std::string name);
bool has_editor() const { return false; }
void init (void *mod, uint32_t index, nframes_t rate);
void run_in_place (nframes_t nsamples);
void latency_compute_run ();
- int set_state_2X (const XMLNode&, int version = 3000);
+ int set_state_2X (const XMLNode&, int version);
};
class LadspaPluginInfo : public PluginInfo {
}
Location (const Location& other);
- Location (const XMLNode&, int version = 3000);
+ Location (const XMLNode&);
Location* operator= (const Location& other);
bool locked() const { return _locked; }
XMLNode& cd_info_node (const std::string &, const std::string &);
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
std::string _name;
void clear_ranges ();
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
Location *get_location_by_id(PBD::ID);
Location* auto_loop_location () const;
static uint32_t midi_event_type() { return _midi_event_type; }
XMLNode& get_state();
- int set_state(const XMLNode& node);
+ int set_state(const XMLNode& node, int version);
bool save_preset(std::string uri);
bool load_preset(const std::string uri);
virtual std::vector<Plugin::PresetRecord> get_presets();
/* stateful */
XMLNode& get_state(void);
- int set_state(const XMLNode&, int version = 3000);
+ int set_state(const XMLNode&, int version);
void monitor_input (bool);
void operator()();
void undo();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
XMLNode& get_state ();
void add(const boost::shared_ptr< Evoral::Note<TimeType> > note);
void operator()();
void undo();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
XMLNode& get_state ();
void change (const boost::shared_ptr<Evoral::Note<TimeType> > note,
nframes_t read (MidiRingBuffer<nframes_t>& buf,
nframes_t start, nframes_t cnt, uint32_t chan_n=0);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
bool destroy_region (boost::shared_ptr<Region>);
NoteMode mode = Sustained) const;
XMLNode& state (bool);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
int separate_by_channel (ARDOUR::Session&, std::vector< boost::shared_ptr<Region> >&) const;
protected:
- int set_live_state (const XMLNode&, Change&, bool send);
+ int set_live_state (const XMLNode&, int version, Change&, bool send);
};
} /* namespace ARDOUR */
mutable sigc::signal<void,sframes_t,nframes_t> ViewDataRangeReady;
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
bool length_mutable() const { return true; }
boost::shared_ptr<Region> bounce_range (
nframes_t start, nframes_t end, InterThreadInfo&, bool enable_processing);
- int set_state(const XMLNode&, int version = 3000);
+ int set_state(const XMLNode&, int version);
void midi_panic(void);
bool write_immediate_event(size_t size, const uint8_t* buf);
sigc::signal<void> MutePointChanged;
XMLNode& get_state();
- int set_state(const XMLNode&, int version = 3000);
+ int set_state(const XMLNode&, int version);
private:
AutomationList* _automation;
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
static sigc::signal<void,NamedSelection*> NamedSelectionCreated;
};
sigc::signal<void> Changed; /* for position */
sigc::signal<void> StateChanged; /* for mute */
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
virtual XMLNode& state (bool full_state) = 0;
Panner & get_parent() { return parent; }
XMLNode& state (bool full_state);
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
void update ();
XMLNode& state (bool full_state);
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
/* old school automation loading */
XMLNode& get_state (void);
XMLNode& state (bool full);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
static bool equivalent (pan_t a, pan_t b) {
return fabsf (a - b) < 0.002; // about 1 degree of arc for a stereo panner
void foreach_region (sigc::slot<void, boost::shared_ptr<Region> >);
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
XMLNode& get_template ();
sigc::signal<void,bool> InUse;
{
public:
PluginInsert (Session&, boost::shared_ptr<Plugin>);
- PluginInsert (Session&, const XMLNode&, int version = 3000);
+ PluginInsert (Session&, const XMLNode&);
~PluginInsert ();
static const std::string port_automation_node_name;
XMLNode& state(bool);
XMLNode& get_state(void);
- int set_state(const XMLNode&, int version = 3000);
+ int set_state(const XMLNode&, int version);
void run (BufferSet& in, sframes_t start_frame, sframes_t end_frame, nframes_t nframes);
void silence (nframes_t nframes);
{
public:
PortInsert (Session&, boost::shared_ptr<MuteMaster> mm);
- PortInsert (Session&, boost::shared_ptr<MuteMaster> mm, const XMLNode&, int version = 3000);
+ PortInsert (Session&, boost::shared_ptr<MuteMaster> mm, const XMLNode&);
~PortInsert ();
XMLNode& state(bool full);
XMLNode& get_state(void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
void run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes);
virtual XMLNode& state (bool full);
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
void *get_gui () const { return _gui; }
void set_gui (void *p) { _gui = p; }
RCConfiguration();
void map_parameters (sigc::slot<void, std::string>);
- int set_state (XMLNode const &, int version = 3000);
+ int set_state (XMLNode const &, int version);
XMLNode& get_state ();
XMLNode& get_variables ();
void set_variables (XMLNode const &);
XMLNode& get_state ();
virtual XMLNode& state (bool);
- virtual int set_state (const XMLNode&, int version = 3000);
- virtual int set_live_state (const XMLNode&, Change&, bool send);
+ virtual int set_state (const XMLNode&, int version);
+ virtual int set_live_state (const XMLNode&, int version, Change&, bool send);
virtual boost::shared_ptr<Region> get_parent() const;
XMLNode& state(bool full);
XMLNode& get_state(void);
- int set_state(const XMLNode&, int version = 3000);
+ int set_state(const XMLNode&, int version);
uint32_t pans_required() const { return _configured_input.n_audio(); }
ControlOut = 0x4
};
- Route (Session&, std::string name, Flag flags = Flag(0),
- DataType default_type = DataType::AUDIO);
- Route (Session&, const XMLNode&, int, DataType default_type = DataType::AUDIO);
+ Route (Session&, std::string name, Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
+ Route (Session&, const XMLNode&, DataType default_type = DataType::AUDIO);
virtual ~Route();
boost::shared_ptr<IO> input() const { return _input; }
/* stateful */
XMLNode& get_state();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
virtual XMLNode& get_template();
XMLNode& get_processor_state ();
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
Session& _session;
XMLNode& state(bool full);
XMLNode& get_state(void);
- int set_state(const XMLNode&, int version = 3000);
+ int set_state(const XMLNode&, int version);
uint32_t pans_required() const { return _configured_input.n_audio(); }
static std::vector<std::string*>* possible_states (std::string path);
XMLNode& get_state();
- int set_state(const XMLNode& node, int version = 3000); // not idempotent
+ int set_state(const XMLNode& node, int version); // not idempotent
XMLNode& get_template();
/// The instant xml file is written to the session directory
public:
GlobalRouteStateCommand (Session&, void*);
GlobalRouteStateCommand (Session&, const XMLNode& node);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
XMLNode& get_state ();
protected:
void operator()();
void undo();
XMLNode &get_state();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
void mark();
protected:
std::string _current_snapshot_name;
- XMLTree* state_tree;
- bool state_was_pending;
+ XMLTree* state_tree;
+ bool state_was_pending;
StateOfTheState _state_of_the_state;
void auto_save();
SessionConfiguration ();
void map_parameters (sigc::slot<void, std::string>);
- int set_state (XMLNode const &, int version = 3000);
+ int set_state (XMLNode const &, int version);
XMLNode& get_state ();
XMLNode& get_variables ();
void set_variables (XMLNode const &);
/*** Serialization ***/
XMLNode & get_state ();
- int set_state (const XMLNode &, int version = 3000);
+ int set_state (const XMLNode &, int version);
private:
void mark_streaming_write_completed ();
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
void load_model (bool lock=true, bool force_reload=false);
void destroy_model ();
virtual void session_saved() {}
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
bool destructive() const { return (_flags & Destructive); }
bool writable () const { return (_flags & Writable); }
void set_length (nframes_t frames);
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
void dump (std::ostream&) const;
void clear ();
XMLNode& get_state();
XMLNode& get_template();
- virtual int set_state (const XMLNode&, int version = 3000) = 0;
+ virtual int set_state (const XMLNode&, int version) = 0;
static void zero_diskstream_id_in_xml (XMLNode&);
boost::shared_ptr<PBD::Controllable> rec_enable_control() { return _rec_enable_control; }
sigc::signal<void> FreezeChange;
protected:
- Track (Session& sess, const XMLNode& node, int, DataType default_type = DataType::AUDIO);
+ Track (Session& sess, const XMLNode& node, DataType default_type = DataType::AUDIO);
virtual XMLNode& state (bool full) = 0;
XMLNode& get_state ();
private:
- int set_state (XMLNode const &, int version = 3000);
+ int set_state (XMLNode const &, int version);
};
}
in_set_state = true;
init (Recordable);
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
in_set_state = false;
throw failed_constructor();
}
assert(!prop || DataType(prop->value()) == DataType::AUDIO);
in_set_state++;
- set_state (node);
+ set_state (node, Stateful::loading_state_version);
in_set_state--;
}
in_set_state++;
- Playlist::set_state (node);
+ Playlist::set_state (node, version);
freeze ();
}
AudioTrack::AudioTrack (Session& sess, const XMLNode& node, int version)
- : Track (sess, node, version)
+ : Track (sess, node)
{
- _set_state (node, version, false);
+ _set_state (node, Stateful::loading_state_version, false);
}
AudioTrack::~AudioTrack ()
child = *niter;
if (child->name() == X_("recenable")) {
- _rec_enable_control->set_state (*child);
+ _rec_enable_control->set_state (*child, version);
_session.add_controllable (_rec_enable_control);
}
}
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
for (vector<FreezeRecordProcessorInfo*>::iterator ii = _freeze_record.processor_info.begin(); ii != _freeze_record.processor_info.end(); ++ii) {
if ((*ii)->id == (*i)->id()) {
- (*i)->set_state (((*ii)->state));
+ (*i)->set_state (((*ii)->state), Stateful::current_state_version);
break;
}
}
, AudioSource (s, node)
, FileSource (s, node, must_exist)
{
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor ();
}
int
AudioFileSource::set_state (const XMLNode& node, int version)
{
- if (Source::set_state (node)) {
+ if (Source::set_state (node, version)) {
return -1;
}
- if (AudioSource::set_state (node)) {
+ if (AudioSource::set_state (node, version)) {
return -1;
}
- if (FileSource::set_state (node)) {
+ if (FileSource::set_state (node, version)) {
return -1;
}
init ();
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
{
init ();
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
int
-AudioRegion::set_live_state (const XMLNode& node, Change& what_changed, bool send)
+AudioRegion::set_live_state (const XMLNode& node, int version, Change& what_changed, bool send)
{
const XMLNodeList& nlist = node.children();
const XMLProperty *prop;
LocaleGuard lg (X_("POSIX"));
- Region::set_live_state (node, what_changed, false);
+ Region::set_live_state (node, version, what_changed, false);
uint32_t old_flags = _flags;
_envelope->clear ();
- if ((prop = child->property ("default")) != 0 || _envelope->set_state (*child)) {
+ if ((prop = child->property ("default")) != 0 || _envelope->set_state (*child, version)) {
set_default_envelope ();
}
} else {
XMLNode* grandchild = child->child ("AutomationList");
if (grandchild) {
- _fade_in->set_state (*grandchild);
+ _fade_in->set_state (*grandchild, version);
}
}
} else {
XMLNode* grandchild = child->child ("AutomationList");
if (grandchild) {
- _fade_out->set_state (*grandchild);
+ _fade_out->set_state (*grandchild, version);
}
}
to handle the relevant stuff.
*/
- return Region::set_state (node);
+ return Region::set_state (node, version);
}
void
peak_leftover_size = 0;
peak_leftovers = 0;
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
_state = Off;
_style = Absolute;
- set_state (node);
+ set_state (node, Stateful::loading_state_version);
if (id) {
_parameter = id;
if ((nsos = node.child (X_("AutomationList")))) {
/* new school in old school clothing */
- return set_state (*nsos);
+ return set_state (*nsos, version);
}
/* old school */
(*i)->requested = false;
if ((*i)->protocol && (*i)->state) {
- (*i)->protocol->set_state (*(*i)->state);
+ (*i)->protocol->set_state (*(*i)->state, Stateful::loading_state_version);
}
}
}
initialize();
_active = true;
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
{
_panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor ();
}
{
_panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor ();
}
{
const XMLProperty* prop;
- if (IOProcessor::set_state (node)) {
+ if (IOProcessor::set_state (node, version)) {
return -1;
}
XMLNode* pan_node = node.child (X_("Panner"));
if (pan_node) {
- _panner->set_state (*pan_node);
+ _panner->set_state (*pan_node, version);
}
reset_panner ();
(void) bindtextdomain(PACKAGE, LOCALEDIR);
+ /* provide a state version for the few cases that need it and are not
+ driven by reading state from disk (e.g. undo/redo)
+ */
+
+ Stateful::current_state_version = CURRENT_SESSION_FILE_VERSION;
+
setup_enum_writer ();
// allow ardour the absolute maximum number of open files
XMLNode* node;
if ((node = Config->control_protocol_state()) != 0) {
- ControlProtocolManager::instance().set_state (*node);
+ ControlProtocolManager::instance().set_state (*node, Stateful::loading_state_version);
}
}
int
InternalReturn::set_state (const XMLNode& node, int version)
{
- return Return::set_state (node);
+ return Return::set_state (node, version);
}
bool
InternalSend::InternalSend (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
: Send (s, mm, node, Delivery::Aux /* will be reset in set_state() */)
{
- set_state (node);
+ set_state (node, Stateful::loading_state_version);
}
InternalSend::~InternalSend ()
{
const XMLProperty* prop;
- Send::set_state (node);
+ Send::set_state (node, version);
if ((prop = node.property ("target")) != 0) {
_active = true;
pending_state_node = 0;
- set_state (node);
+ set_state (node, Stateful::loading_state_version);
setup_bundles ();
}
const XMLProperty *prop;
const XMLNode *io_node = 0;
- Processor::set_state(node);
+ Processor::set_state(node, version);
if ((prop = node.property ("own-input")) != 0) {
_own_input = string_is_affirmative (prop->value());
}
if (io_node) {
- _input->set_state(*io_node);
+ _input->set_state(*io_node, version);
// legacy sessions: use IO name
if ((prop = node.property ("name")) == 0) {
}
if (io_node) {
- _output->set_state(*io_node);
+ _output->set_state(*io_node, version);
// legacy sessions: use IO name
if ((prop = node.property ("name")) == 0) {
_locked = false;
}
-Location::Location (const XMLNode& node, int version)
+Location::Location (const XMLNode& node)
{
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor ();
}
}
}
int
-LV2Plugin::set_state(const XMLNode& node)
+LV2Plugin::set_state(const XMLNode& node, int version)
{
XMLNodeList nodes;
XMLProperty *prop;
in_set_state = true;
init (Recordable);
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
in_set_state = false;
throw failed_constructor();
}
: _model(m)
{
assert(_model);
- set_state(node);
+ set_state(node, Stateful::loading_state_version);
}
void
: _model(m)
{
assert(_model);
- set_state(node);
+ set_state(node, Stateful::loading_state_version);
}
void
assert(prop && DataType(prop->value()) == DataType::MIDI);
in_set_state++;
- set_state (node);
+ set_state (node, Stateful::loading_state_version);
in_set_state--;
}
in_set_state++;
freeze ();
- Playlist::set_state (node);
+ Playlist::set_state (node, version);
thaw();
in_set_state--;
MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, const XMLNode& node)
: Region (src, node)
{
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
MidiRegion::MidiRegion (const SourceList& srcs, const XMLNode& node)
: Region (srcs, node)
{
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
int
-MidiRegion::set_live_state (const XMLNode& node, Change& what_changed, bool send)
+MidiRegion::set_live_state (const XMLNode& node, int version, Change& what_changed, bool send)
{
const XMLProperty *prop;
LocaleGuard lg (X_("POSIX"));
- Region::set_live_state (node, what_changed, false);
+ Region::set_live_state (node, version, what_changed, false);
uint32_t old_flags = _flags;
to handle the relevant stuff.
*/
- return Region::set_state (node);
+ return Region::set_state (node, version);
}
void
_read_data_count = 0;
_write_data_count = 0;
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
}
MidiTrack::MidiTrack (Session& sess, const XMLNode& node, int version)
- : Track (sess, node, version, DataType::MIDI)
+ : Track (sess, node, DataType::MIDI)
, _immediate_events(1024) // FIXME: size?
, _step_edit_ring_buffer(64) // FIXME: size?
, _note_mode(Sustained)
, _default_channel (0)
, _midi_thru (true)
{
- _set_state (node, version, false);
+ _set_state (node, Stateful::loading_state_version, false);
}
MidiTrack::~MidiTrack ()
child = *niter;
if (child->name() == X_("recenable")) {
- _rec_enable_control->set_state (*child);
+ _rec_enable_control->set_state (*child, version);
_session.add_controllable (_rec_enable_control);
}
}
set_position (pos, true);
}
- StreamPanner::set_state (node);
+ StreamPanner::set_state (node, version);
for (XMLNodeConstIterator iter = node.children().begin(); iter != node.children().end(); ++iter) {
if ((*iter)->name() == X_("Controllable")) {
if ((prop = (*iter)->property("name")) != 0 && prop->value() == "panner") {
- _control->set_state (**iter);
+ _control->set_state (**iter, version);
}
} else if ((*iter)->name() == X_("Automation")) {
- _control->alist()->set_state (*((*iter)->children().front()));
+ _control->alist()->set_state (*((*iter)->children().front()), version);
if (_control->alist()->automation_state() != Off) {
set_position (_control->list()->eval (parent.session().transport_frame()));
sp = pan_plugins[i].factory (*this, Evoral::Parameter(PanAutomation, 0, num_panners));
num_panners++;
- if (sp->set_state (**niter) == 0) {
+ if (sp->set_state (**niter, version) == 0) {
_streampanners.push_back (sp);
}
Change what_changed = Change (0);
- if (region->set_live_state (*child, what_changed, true)) {
+ if (region->set_live_state (*child, version, what_changed, true)) {
error << _("Playlist: cannot reset region state from XML") << endmsg;
continue;
}
ProcessorCreated (this); /* EMIT SIGNAL */
}
-PluginInsert::PluginInsert (Session& s, const XMLNode& node, int version)
+PluginInsert::PluginInsert (Session& s, const XMLNode& node)
: Processor (s, "unnamed plugin insert"),
_signal_analysis_collected_nframes(0),
_signal_analysis_collect_nframes_max(0)
{
- if (set_state (node, version)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
data().control(Evoral::Parameter(PluginAutomation, 0, port_id), true));
if (!child->children().empty()) {
- c->alist()->set_state (*child->children().front());
+ c->alist()->set_state (*child->children().front(), version);
} else {
if ((cprop = child->property("auto")) != 0) {
ProcessorCreated (this); /* EMIT SIGNAL */
}
-PortInsert::PortInsert (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node, int version)
+PortInsert::PortInsert (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
: IOProcessor (s, true, true, "unnamed port insert")
, _out (new Delivery (s, _output, mm, _name, Delivery::Insert))
{
- if (set_state (node, version)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
}
- Processor::set_state (*insert_node);
+ Processor::set_state (*insert_node, version);
return 0;
}
, _configured(false)
, _gui(0)
{
- set_state (node);
+ set_state (node, Stateful::loading_state_version);
_pending_active = _active;
}
return -1;
}
- if (set_state (*tree.root())) {
+ if (set_state (*tree.root(), Stateful::current_state_version)) {
error << string_compose(_("Ardour: system configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
return -1;
}
return -1;
}
- if (set_state (*tree.root())) {
+ if (set_state (*tree.root(), Stateful::current_state_version)) {
error << string_compose(_("Ardour: user configuration file \"%1\" not loaded successfully."), rcfile) << endmsg;
return -1;
}
{
use_sources (srcs);
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
{
_sources.push_back (src);
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
int
-Region::set_live_state (const XMLNode& node, Change& what_changed, bool send)
+Region::set_live_state (const XMLNode& node, int version, Change& what_changed, bool send)
{
const XMLNodeList& nlist = node.children();
const XMLProperty *prop;
_first_edit = EditChangesNothing;
- set_live_state (node, what_changed, true);
+ set_live_state (node, version, what_changed, true);
return 0;
}
_amp.reset (new Amp (_session, boost::shared_ptr<MuteMaster>()));
_meter.reset (new PeakMeter (_session));
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
}
- IOProcessor::set_state (*insert_node);
+ IOProcessor::set_state (*insert_node, version);
return 0;
}
_meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
}
-Route::Route (Session& sess, const XMLNode& node, int version, DataType default_type)
+Route::Route (Session& sess, const XMLNode& node, DataType default_type)
: SessionObject (sess, "toBeReset")
, AutomatableControls (sess)
, _solo_control (new SoloControllable (X_("solo"), *this))
{
init ();
- _set_state (node, version, false);
+ _set_state (node, Stateful::loading_state_version, false);
/* now that we have _meter, its safe to connect to this */
} else if (prop->value() == "meter") {
if (_meter) {
- if (_meter->set_state (node)) {
+ if (_meter->set_state (node, Stateful::loading_state_version)) {
return false;
} else {
return true;
/* amp always exists */
processor = _amp;
- if (processor->set_state (node)) {
+ if (processor->set_state (node, Stateful::loading_state_version)) {
return false;
} else {
/* never any reason to add it */
} else if (prop->value() == "intreturn") {
if (_intreturn) {
- if (_intreturn->set_state (node)) {
+ if (_intreturn->set_state (node, Stateful::loading_state_version)) {
return false;
} else {
return true;
} else if (prop->value() == "main-outs") {
if (_main_outs) {
- if (_main_outs->set_state (node)) {
+ if (_main_outs->set_state (node, Stateful::loading_state_version)) {
return false;
} else {
return true;
prop->value() == "vst" ||
prop->value() == "audiounit") {
- processor.reset (new PluginInsert (_session, node, version));
+ processor.reset (new PluginInsert (_session, node));
} else {
- processor.reset (new PortInsert (_session, _mute_master, node, version));
+ processor.reset (new PortInsert (_session, _mute_master, node));
}
}
}
if (prop->value() == "Input") {
- _input->set_state (*child);
+ _input->set_state (*child, version);
} else if (prop->value() == "Output") {
- _output->set_state (*child);
+ _output->set_state (*child, version);
}
}
} else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
if (prop->value() == "solo") {
- _solo_control->set_state (*child);
+ _solo_control->set_state (*child, version);
_session.add_controllable (_solo_control);
}
}
} else if (child->name() == X_("MuteMaster")) {
- _mute_master->set_state (*child);
+ _mute_master->set_state (*child, version);
}
}
child = *niter;
if (child->name() == IO::state_node_name) {
+
+ /* there is a note in IO::set_state_2X() about why we have to call
+ this directly.
+ */
+
_input->set_state_2X (*child, version, true);
_output->set_state_2X (*child, version, false);
} else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
if (prop->value() == "solo") {
- _solo_control->set_state (*child);
+ _solo_control->set_state (*child, version);
_session.add_controllable (_solo_control);
}
// and make it (just) so
- (*i)->set_state (**niter);
+ (*i)->set_state (**niter, Stateful::current_state_version);
}
}
/* XXX need to load automation state & data for amp */
- Delivery::set_state (*insert_node);
+ Delivery::set_state (*insert_node, version);
return 0;
}
delete state_tree;
+ /* reset dynamic state version back to default */
+
+ Stateful::loading_state_version = 0;
+
terminate_butler_thread ();
//terminate_midi_thread ();
/* existing state for Click */
- if (_click_io->set_state (*child->children().front()) == 0) {
+ if (_click_io->set_state (*child->children().front(), Stateful::loading_state_version) == 0) {
_clicking = Config->get_clicking ();
Session::GlobalRouteStateCommand::GlobalRouteStateCommand (Session& s, const XMLNode& node)
: sess (s), src (this)
{
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor ();
}
}
Session::GlobalMeteringStateCommand::GlobalMeteringStateCommand (Session& s, const XMLNode& node)
: sess (s), src (this)
{
- if (set_state (node)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor();
}
}
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
- This program is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
// to call setup_raid_path() here.
if (state_tree) {
- if (set_state (*state_tree->root())) {
+ if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
return -1;
}
} else {
Session::restore_state (string snapshot_name)
{
if (load_state (snapshot_name) == 0) {
- set_state (*state_tree->root());
+ set_state (*state_tree->root(), Stateful::loading_state_version);
}
return 0;
}
const XMLProperty* prop;
- bool is_old = false; // session is _very_ old (pre-2.0)
if ((prop = root.property ("version")) == 0) {
/* no version implies very old version of Ardour */
- is_old = true;
+ Stateful::loading_state_version = 1000;
} else {
- int major_version;
- major_version = atoi (prop->value().c_str()); // grab just the first number before the period
- if (major_version < 2) {
- is_old = true;
- }
- }
+ int major;
+ int minor;
+ int micro;
- if (is_old) {
+ sscanf (prop->value().c_str(), "%d.%d.%d", &major, &minor, µ);
+ Stateful::loading_state_version = (major * 1000) + minor;
+ }
+
+ if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION) {
sys::path backup_path(_session_dir->root_path());
if (version >= 3000) {
if ((child = find_named_node (node, "Metadata")) == 0) {
warning << _("Session: XML state has no metadata section") << endmsg;
- } else if (_metadata->set_state (*child)) {
+ } else if (_metadata->set_state (*child, version)) {
goto out;
}
}
if ((child = find_named_node (node, "Locations")) == 0) {
error << _("Session: XML state has no locations section") << endmsg;
goto out;
- } else if (_locations.set_state (*child)) {
+ } else if (_locations.set_state (*child, version)) {
goto out;
}
if ((child = find_named_node (node, "TempoMap")) == 0) {
error << _("Session: XML state has no Tempo Map section") << endmsg;
goto out;
- } else if (_tempo_map->set_state (*child)) {
+ } else if (_tempo_map->set_state (*child, version)) {
goto out;
}
if ((child = find_named_node (node, "Click")) == 0) {
warning << _("Session: XML state has no click section") << endmsg;
} else if (_click_io) {
- _click_io->set_state (*child);
+ _click_io->set_state (*child, version);
}
if ((child = find_named_node (node, "ControlProtocols")) != 0) {
return ret;
}
} else {
- boost::shared_ptr<Route> ret (new Route (*this, node, version));
+ boost::shared_ptr<Route> ret (new Route (*this, node));
return ret;
}
}
, _last_ev_time_frames(0)
, _smf_last_read_end (0)
{
- if (set_state(node)) {
+ if (set_state(node, Stateful::loading_state_version)) {
throw failed_constructor ();
}
int
SMFSource::set_state (const XMLNode& node, int version)
{
- if (Source::set_state (node)) {
+ if (Source::set_state (node, version)) {
return -1;
}
- if (MidiSource::set_state (node)) {
+ if (MidiSource::set_state (node, version)) {
return -1;
}
- if (FileSource::set_state (node)) {
+ if (FileSource::set_state (node, version)) {
return -1;
}
_analysed = false;
_in_use = 0;
- if (set_state (node) || _type == DataType::NIL) {
+ if (set_state (node, Stateful::loading_state_version) || _type == DataType::NIL) {
throw failed_constructor();
}
void
TempoMapImporter::_move ()
{
- session.tempo_map().set_state (xml_tempo_map);
+ session.tempo_map().set_state (xml_tempo_map, Stateful::current_state_version);
}
_mode = mode;
}
-Track::Track (Session& sess, const XMLNode& node, int version, DataType default_type)
- : Route (sess, node, version, default_type)
+Track::Track (Session& sess, const XMLNode& node, DataType default_type)
+ : Route (sess, node, default_type)
, _rec_enable_control (new RecEnableControllable(*this))
{
_freeze_record.state = NoFreeze;
}
-ARDOUR::UserBundle::UserBundle (XMLNode const & x, bool i)
+ARDOUR::UserBundle::UserBundle (XMLNode const & node, bool i)
: Bundle (i)
{
- if (set_state (x)) {
+ if (set_state (node, Stateful::loading_state_version)) {
throw failed_constructor ();
}
}
# micro increment <=> no interface changes
LIBARDOUR_LIB_VERSION = '3.0.0'
+# default state file version for this build
+CURRENT_SESSION_FILE_VERSION = 3000
+
# Variables for 'waf dist'
APPNAME = 'libardour'
VERSION = LIBARDOUR_VERSION
conf.define('HAVE_RUBBERBAND', 1) # controls whether we think we have it
conf.define('USE_RUBBERBAND', 1) # controls whether we actually use it
+ conf.define('CURRENT_SESSION_FILE_VERSION', CURRENT_SESSION_FILE_VERSION)
+
conf.check(header_name='sys/vfs.h', define_name='HAVE_SYS_VFS_H')
conf.check(header_name='wordexp.h', define_name='HAVE_WORDEXP')
const PatchPrimaryKey& patch_primary_key() const { return _id; }
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
std::string _number;
const PatchPrimaryKey* patch_primary_key() const { return _id; }
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
std::string _name;
}
XMLNode& get_state (void);
- int set_state (const XMLNode& a_node, int version = 3000);
+ int set_state (const XMLNode& a_node, int version);
private:
std::string _name;
void set_number(const std::string a_number) { _number = a_number; }
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
std::string _number;
const Notes& notes() const { return _notes; }
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
std::string _name;
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
std::string channel_name_set_name_by_channel(uint8_t channel) {
assert(channel <= 15);
}
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
std::string _manufacturer;
// Maps Model names to MasterDeviceNames
typedef std::map<std::string, boost::shared_ptr<MasterDeviceNames> > MasterDeviceNamesList;
- MIDINameDocument() {};
- MIDINameDocument(const std::string &filename) : _document(XMLTree(filename)) { set_state(*_document.root()); };
+ MIDINameDocument() {}
+ MIDINameDocument(const std::string &filename);
virtual ~MIDINameDocument() {};
const std::string& author() const { return _author; }
const MasterDeviceNames::Models& all_models() const { return _all_models; }
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
std::string _author;
node.find("//Note");
for (XMLSharedNodeList::const_iterator i = notes->begin(); i != notes->end(); ++i) {
boost::shared_ptr<Note> note(new Note());
- note->set_state(*(*i));
+ note->set_state(*(*i), version);
_notes.push_back(note);
}
const XMLNodeList patches = patch_name_list->children();
for (XMLNodeList::const_iterator i = patches.begin(); i != patches.end(); ++i) {
boost::shared_ptr<Patch> patch(new Patch(this));
- patch->set_state(*(*i));
+ patch->set_state(*(*i), version);
_patch_name_list.push_back(patch);
}
if (node->name() == "PatchBank") {
// cerr << "got PatchBank" << endl;
boost::shared_ptr<PatchBank> bank(new PatchBank());
- bank->set_state(*node);
+ bank->set_state(*node, version);
_patch_banks.push_back(bank);
const PatchBank::PatchNameList& patches = bank->patch_name_list();
for (PatchBank::PatchNameList::const_iterator patch = patches.begin();
i != custom_device_modes->end();
++i) {
boost::shared_ptr<CustomDeviceMode> custom_device_mode(new CustomDeviceMode());
- custom_device_mode->set_state(*(*i));
+ custom_device_mode->set_state(*(*i), version);
_custom_device_modes[custom_device_mode->name()] = custom_device_mode;
_custom_device_mode_names.push_back(custom_device_mode->name());
++i) {
boost::shared_ptr<ChannelNameSet> channel_name_set(new ChannelNameSet());
// cerr << "MasterDeviceNames::set_state ChannelNameSet before set_state" << endl;
- channel_name_set->set_state(*(*i));
+ channel_name_set->set_state(*(*i), version);
_channel_name_sets[channel_name_set->name()] = channel_name_set;
}
i != note_name_lists->end();
++i) {
boost::shared_ptr<NoteNameList> note_name_list(new NoteNameList());
- note_name_list->set_state(*(*i));
+ note_name_list->set_state(*(*i), version);
_note_name_lists.push_back(note_name_list);
}
return nothing;
}
+MIDINameDocument::MIDINameDocument (const string& filename)
+ : _document(XMLTree(filename))
+{
+ set_state(*_document.root(), 0);
+}
+
int
MIDINameDocument::set_state(const XMLNode& a_node, int version)
{
++i) {
boost::shared_ptr<MasterDeviceNames> master_device_names(new MasterDeviceNames());
// cerr << "MIDINameDocument::set_state before masterdevicenames->set_state" << endl;
- master_device_names->set_state(*(*i));
+ master_device_names->set_state(*(*i), version);
// cerr << "MIDINameDocument::set_state after masterdevicenames->set_state" << endl;
for (MasterDeviceNames::Models::const_iterator model = master_device_names->models().begin();
virtual void redo() { (*this)(); }
virtual XMLNode &get_state();
- virtual int set_state(const XMLNode&, int version = 3000) { /* noop */ return 0; }
+ virtual int set_state(const XMLNode&, int version) { /* noop */ return 0; }
protected:
Command() {}
sigc::signal<void> Changed;
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
XMLNode& get_state ();
std::string name() const { return _name; }
void operator() () {
if (after) {
- obj.set_state(*after);
+ obj.set_state(*after, Stateful::current_state_version);
}
}
void undo() {
if (before) {
- obj.set_state(*before);
+ obj.set_state(*before, Stateful::current_state_version);
}
}
virtual XMLNode& get_state (void) = 0;
- virtual int set_state (const XMLNode&, int version = 3000) = 0;
+ virtual int set_state (const XMLNode&, int version) = 0;
/* Extra XML nodes */
const PBD::ID& id() const { return _id; }
+ static int current_state_version;
+ static int loading_state_version;
+
protected:
void add_instant_xml (XMLNode&, const sys::path& directory_path);
namespace PBD {
+int Stateful::current_state_version = 0;
+int Stateful::loading_state_version = 0;
+
Stateful::Stateful ()
{
_extra_xml = 0;
if (c) {
MIDIControllable* mc = new MIDIControllable (*_port, *c);
- if (mc->set_state (**niter) == 0) {
+ if (mc->set_state (**niter, version) == 0) {
controllables.insert (mc);
}
bool get_feedback () const;
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
MIDI::Port* _port;
std::string control_description() const { return _control_description; }
XMLNode& get_state (void);
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
void bind_midi (MIDI::channel_t, MIDI::eventType, MIDI::byte);
MIDI::channel_t get_control_channel () { return control_channel; }
int set_active (bool yn);
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
static bool probe();
virtual ~OSC();
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
int set_active (bool yn);
bool get_active () const;
lo_address address() const { return addr; }
XMLNode& get_state ();
- int set_state (const XMLNode& node, int version = 3000);
+ int set_state (const XMLNode& node, int version);
protected:
boost::shared_ptr<PBD::Controllable> controllable;
static bool probe ();
XMLNode& get_state ();
- int set_state (const XMLNode&, int version = 3000);
+ int set_state (const XMLNode&, int version);
private:
projects / ardour.git / commitdiff