libs/pbd/stateful.cc

   1 /*
   2     Copyright (C) 2000-2001 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18     $Id: stateful.cc 629 2006-06-21 23:01:03Z paul $
  19 */
  20
  21 #include <unistd.h>
  22
  23 #include "pbd/debug.h"
  24 #include "pbd/stateful.h"
  25 #include "pbd/property_list.h"
  26 #include "pbd/properties.h"
  27 #include "pbd/destructible.h"
  28 #include "pbd/filesystem.h"
  29 #include "pbd/xml++.h"
  30 #include "pbd/error.h"
  31
  32 #include "i18n.h"
  33
  34 using namespace std;
  35
  36 namespace PBD {
  37
  38 int Stateful::current_state_version = 0;
  39 int Stateful::loading_state_version = 0;
  40
  41 Stateful::Stateful ()
  42         : _frozen (0)
  43         , _no_property_changes (false)
  44         , _properties (new OwnedPropertyList)
  45 {
  46         _extra_xml = 0;
  47         _instant_xml = 0;
  48 }
  49
  50 Stateful::~Stateful ()
  51 {
  52         delete _properties;
  53
  54         // Do not delete _extra_xml.  The use of add_child_nocopy()
  55         // means it needs to live on indefinately.
  56
  57         delete _instant_xml;
  58 }
  59
  60 void
  61 Stateful::add_extra_xml (XMLNode& node)
  62 {
  63         if (_extra_xml == 0) {
  64                 _extra_xml = new XMLNode ("Extra");
  65         }
  66
  67         _extra_xml->remove_nodes (node.name());
  68         _extra_xml->add_child_nocopy (node);
  69 }
  70
  71 XMLNode *
  72 Stateful::extra_xml (const string& str)
  73 {
  74         if (_extra_xml == 0) {
  75                 return 0;
  76         }
  77
  78         const XMLNodeList& nlist = _extra_xml->children();
  79         XMLNodeConstIterator i;
  80
  81         for (i = nlist.begin(); i != nlist.end(); ++i) {
  82                 if ((*i)->name() == str) {
  83                         return (*i);
  84                 }
  85         }
  86
  87         return 0;
  88 }
  89
  90 void
  91 Stateful::add_instant_xml (XMLNode& node, const sys::path& directory_path)
  92 {
  93         sys::create_directories (directory_path); // may throw
  94
  95         if (_instant_xml == 0) {
  96                 _instant_xml = new XMLNode ("instant");
  97         }
  98
  99         _instant_xml->remove_nodes_and_delete (node.name());
 100         _instant_xml->add_child_copy (node);
 101
 102         sys::path instant_xml_path(directory_path);
 103
 104         instant_xml_path /= "instant.xml";
 105
 106         XMLTree tree;
 107         tree.set_filename(instant_xml_path.to_string());
 108
 109         /* Important: the destructor for an XMLTree deletes
 110            all of its nodes, starting at _root. We therefore
 111            cannot simply hand it our persistent _instant_xml
 112            node as its _root, because we will lose it whenever
 113            the Tree goes out of scope.
 114
 115            So instead, copy the _instant_xml node (which does
 116            a deep copy), and hand that to the tree.
 117         */
 118
 119         XMLNode* copy = new XMLNode (*_instant_xml);
 120         tree.set_root (copy);
 121
 122         if (!tree.write()) {
 123                 error << string_compose(_("Error: could not write %1"), instant_xml_path.to_string()) << endmsg;
 124         }
 125 }
 126
 127 XMLNode *
 128 Stateful::instant_xml (const string& str, const sys::path& directory_path)
 129 {
 130         if (_instant_xml == 0) {
 131
 132                 sys::path instant_xml_path(directory_path);
 133                 instant_xml_path /= "instant.xml";
 134
 135                 if (exists(instant_xml_path)) {
 136                         XMLTree tree;
 137                         if (tree.read(instant_xml_path.to_string())) {
 138                                 _instant_xml = new XMLNode(*(tree.root()));
 139                         } else {
 140                                 warning << string_compose(_("Could not understand XML file %1"), instant_xml_path.to_string()) << endmsg;
 141                                 return 0;
 142                         }
 143                 } else {
 144                         return 0;
 145                 }
 146         }
 147
 148         const XMLNodeList& nlist = _instant_xml->children();
 149         XMLNodeConstIterator i;
 150
 151         for (i = nlist.begin(); i != nlist.end(); ++i) {
 152                 if ((*i)->name() == str) {
 153                         return (*i);
 154                 }
 155         }
 156
 157         return 0;
 158 }
 159
 160 /** Forget about any old state for this object */
 161 void
 162 Stateful::clear_history ()
 163 {
 164         for (OwnedPropertyList::iterator i = _properties->begin(); i != _properties->end(); ++i) {
 165                 i->second->clear_history ();
 166         }
 167 }
 168
 169 void
 170 Stateful::diff (PropertyList& before, PropertyList& after, Command* cmd) const
 171 {
 172         for (OwnedPropertyList::const_iterator i = _properties->begin(); i != _properties->end(); ++i) {
 173                 i->second->diff (before, after, cmd);
 174         }
 175 }
 176
 177 /** Set state of some/all _properties from an XML node.
 178  *  @param owner_state Node.
 179  *  @return PropertyChanges made.
 180  */
 181 PropertyChange
 182 Stateful::set_properties (XMLNode const & owner_state)
 183 {
 184         PropertyChange c;
 185
 186         for (OwnedPropertyList::iterator i = _properties->begin(); i != _properties->end(); ++i) {
 187                 if (i->second->set_state_from_owner_state (owner_state)) {
 188                         c.add (i->first);
 189                 }
 190         }
 191
 192         post_set ();
 193
 194         return c;
 195 }
 196
 197 PropertyChange
 198 Stateful::set_properties (const PropertyList& property_list)
 199 {
 200         PropertyChange c;
 201         PropertyList::const_iterator p;
 202
 203         DEBUG_TRACE (DEBUG::Stateful, string_compose ("Stateful %1 setting properties from list of %2\n", this, property_list.size()));
 204
 205         for (PropertyList::const_iterator pp = property_list.begin(); pp != property_list.end(); ++pp) {
 206                 DEBUG_TRACE (DEBUG::Stateful, string_compose ("in plist: %1\n", pp->second->property_name()));
 207         }
 208
 209         for (PropertyList::const_iterator i = property_list.begin(); i != property_list.end(); ++i) {
 210                 if ((p = _properties->find (i->first)) != _properties->end()) {
 211                         DEBUG_TRACE (DEBUG::Stateful, string_compose ("actually setting property %1\n", p->second->property_name()));
 212                         if (set_property (*i->second)) {
 213                                 c.add (i->first);
 214                         }
 215                 } else {
 216                         DEBUG_TRACE (DEBUG::Stateful, string_compose ("passed in property %1 not found in own property list\n",
 217                                                                       i->second->property_name()));
 218                 }
 219         }
 220
 221         post_set ();
 222
 223         send_change (c);
 224
 225         return c;
 226 }
 227
 228 /** Add property states to an XML node.
 229  *  @param owner_state Node.
 230  */
 231 void
 232 Stateful::add_properties (XMLNode& owner_state)
 233 {
 234         for (OwnedPropertyList::iterator i = _properties->begin(); i != _properties->end(); ++i) {
 235                 i->second->add_state_to_owner_state (owner_state);
 236         }
 237 }
 238
 239 void
 240 Stateful::add_property (PropertyBase& s)
 241 {
 242         _properties->add (s);
 243 }
 244
 245 void
 246 Stateful::send_change (const PropertyChange& what_changed)
 247 {
 248         if (what_changed.empty()) {
 249                 return;
 250         }
 251
 252         {
 253                 Glib::Mutex::Lock lm (_lock);
 254                 if (_frozen) {
 255                         _pending_changed.add (what_changed);
 256                         return;
 257                 }
 258         }
 259
 260         PropertyChanged (what_changed);
 261 }
 262
 263 void
 264 Stateful::suspend_property_changes ()
 265 {
 266         _frozen++;
 267 }
 268
 269 void
 270 Stateful::resume_property_changes ()
 271 {
 272         PropertyChange what_changed;
 273
 274         {
 275                 Glib::Mutex::Lock lm (_lock);
 276
 277                 if (_frozen && --_frozen > 0) {
 278                         return;
 279                 }
 280
 281                 if (!_pending_changed.empty()) {
 282                         what_changed = _pending_changed;
 283                         _pending_changed.clear ();
 284                 }
 285         }
 286
 287         mid_thaw (what_changed);
 288
 289         send_change (what_changed);
 290 }
 291
 292 bool
 293 Stateful::changed() const
 294 {
 295         for (OwnedPropertyList::const_iterator i = _properties->begin(); i != _properties->end(); ++i) {
 296                 if (i->second->changed()) {
 297                         return true;
 298                 }
 299         }
 300
 301         return false;
 302 }
 303
 304 bool
 305 Stateful::set_property (const PropertyBase& prop)
 306 {
 307         OwnedPropertyList::iterator i = _properties->find (prop.property_id());
 308         if (i == _properties->end()) {
 309                 return false;
 310         }
 311
 312         i->second->set_state_from_property (&prop);
 313         return true;
 314 }
 315
 316 } // namespace PBD