juce/source/src/containers/juce_ValueTree.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_ValueTree.h"
  31 #include "../io/streams/juce_MemoryInputStream.h"
  32
  33
  34 //==============================================================================
  35 class ValueTree::SetPropertyAction  : public UndoableAction
  36 {
  37 public:
  38     SetPropertyAction (const SharedObjectPtr& target_, const Identifier& name_,
  39                        const var& newValue_, const var& oldValue_,
  40                        const bool isAddingNewProperty_, const bool isDeletingProperty_)
  41         : target (target_), name (name_), newValue (newValue_), oldValue (oldValue_),
  42           isAddingNewProperty (isAddingNewProperty_), isDeletingProperty (isDeletingProperty_)
  43     {
  44     }
  45
  46     bool perform()
  47     {
  48         jassert (! (isAddingNewProperty && target->hasProperty (name)));
  49
  50         if (isDeletingProperty)
  51             target->removeProperty (name, nullptr);
  52         else
  53             target->setProperty (name, newValue, nullptr);
  54
  55         return true;
  56     }
  57
  58     bool undo()
  59     {
  60         if (isAddingNewProperty)
  61             target->removeProperty (name, nullptr);
  62         else
  63             target->setProperty (name, oldValue, nullptr);
  64
  65         return true;
  66     }
  67
  68     int getSizeInUnits()
  69     {
  70         return (int) sizeof (*this); //xxx should be more accurate
  71     }
  72
  73     UndoableAction* createCoalescedAction (UndoableAction* nextAction)
  74     {
  75         if (! (isAddingNewProperty || isDeletingProperty))
  76         {
  77             SetPropertyAction* next = dynamic_cast <SetPropertyAction*> (nextAction);
  78
  79             if (next != nullptr && next->target == target && next->name == name
  80                  && ! (next->isAddingNewProperty || next->isDeletingProperty))
  81             {
  82                 return new SetPropertyAction (target, name, next->newValue, oldValue, false, false);
  83             }
  84         }
  85
  86         return nullptr;
  87     }
  88
  89 private:
  90     const SharedObjectPtr target;
  91     const Identifier name;
  92     const var newValue;
  93     var oldValue;
  94     const bool isAddingNewProperty : 1, isDeletingProperty : 1;
  95
  96     JUCE_DECLARE_NON_COPYABLE (SetPropertyAction);
  97 };
  98
  99 //==============================================================================
 100 class ValueTree::AddOrRemoveChildAction  : public UndoableAction
 101 {
 102 public:
 103     AddOrRemoveChildAction (const SharedObjectPtr& target_, const int childIndex_,
 104                             const SharedObjectPtr& newChild_)
 105         : target (target_),
 106           child (newChild_ != nullptr ? newChild_ : target_->children [childIndex_]),
 107           childIndex (childIndex_),
 108           isDeleting (newChild_ == nullptr)
 109     {
 110         jassert (child != nullptr);
 111     }
 112
 113     bool perform()
 114     {
 115         if (isDeleting)
 116             target->removeChild (childIndex, nullptr);
 117         else
 118             target->addChild (child, childIndex, nullptr);
 119
 120         return true;
 121     }
 122
 123     bool undo()
 124     {
 125         if (isDeleting)
 126         {
 127             target->addChild (child, childIndex, nullptr);
 128         }
 129         else
 130         {
 131             // If you hit this, it seems that your object's state is getting confused - probably
 132             // because you've interleaved some undoable and non-undoable operations?
 133             jassert (childIndex < target->children.size());
 134             target->removeChild (childIndex, nullptr);
 135         }
 136
 137         return true;
 138     }
 139
 140     int getSizeInUnits()
 141     {
 142         return (int) sizeof (*this); //xxx should be more accurate
 143     }
 144
 145 private:
 146     const SharedObjectPtr target, child;
 147     const int childIndex;
 148     const bool isDeleting;
 149
 150     JUCE_DECLARE_NON_COPYABLE (AddOrRemoveChildAction);
 151 };
 152
 153 //==============================================================================
 154 class ValueTree::MoveChildAction  : public UndoableAction
 155 {
 156 public:
 157     MoveChildAction (const SharedObjectPtr& parent_,
 158                      const int startIndex_, const int endIndex_)
 159         : parent (parent_),
 160           startIndex (startIndex_),
 161           endIndex (endIndex_)
 162     {
 163     }
 164
 165     bool perform()
 166     {
 167         parent->moveChild (startIndex, endIndex, nullptr);
 168         return true;
 169     }
 170
 171     bool undo()
 172     {
 173         parent->moveChild (endIndex, startIndex, nullptr);
 174         return true;
 175     }
 176
 177     int getSizeInUnits()
 178     {
 179         return (int) sizeof (*this); //xxx should be more accurate
 180     }
 181
 182     UndoableAction* createCoalescedAction (UndoableAction* nextAction)
 183     {
 184         MoveChildAction* next = dynamic_cast <MoveChildAction*> (nextAction);
 185
 186         if (next != nullptr && next->parent == parent && next->startIndex == endIndex)
 187             return new MoveChildAction (parent, startIndex, next->endIndex);
 188
 189         return nullptr;
 190     }
 191
 192 private:
 193     const SharedObjectPtr parent;
 194     const int startIndex, endIndex;
 195
 196     JUCE_DECLARE_NON_COPYABLE (MoveChildAction);
 197 };
 198
 199
 200 //==============================================================================
 201 ValueTree::SharedObject::SharedObject (const Identifier& type_)
 202     : type (type_), parent (nullptr)
 203 {
 204 }
 205
 206 ValueTree::SharedObject::SharedObject (const SharedObject& other)
 207     : type (other.type), properties (other.properties), parent (nullptr)
 208 {
 209     for (int i = 0; i < other.children.size(); ++i)
 210     {
 211         SharedObject* const child = new SharedObject (*other.children.getUnchecked(i));
 212         child->parent = this;
 213         children.add (child);
 214     }
 215 }
 216
 217 ValueTree::SharedObject::~SharedObject()
 218 {
 219     jassert (parent == nullptr); // this should never happen unless something isn't obeying the ref-counting!
 220
 221     for (int i = children.size(); --i >= 0;)
 222     {
 223         const SharedObjectPtr c (children.getUnchecked(i));
 224         c->parent = nullptr;
 225         children.remove (i);
 226         c->sendParentChangeMessage();
 227     }
 228 }
 229
 230 //==============================================================================
 231 void ValueTree::SharedObject::sendPropertyChangeMessage (ValueTree& tree, const Identifier& property)
 232 {
 233     for (int i = valueTreesWithListeners.size(); --i >= 0;)
 234     {
 235         ValueTree* const v = valueTreesWithListeners[i];
 236         if (v != nullptr)
 237             v->listeners.call (&ValueTree::Listener::valueTreePropertyChanged, tree, property);
 238     }
 239 }
 240
 241 void ValueTree::SharedObject::sendPropertyChangeMessage (const Identifier& property)
 242 {
 243     ValueTree tree (this);
 244
 245     for (ValueTree::SharedObject* t = this; t != nullptr; t = t->parent)
 246         t->sendPropertyChangeMessage (tree, property);
 247 }
 248
 249 void ValueTree::SharedObject::sendChildAddedMessage (ValueTree& tree, ValueTree& child)
 250 {
 251     for (int i = valueTreesWithListeners.size(); --i >= 0;)
 252     {
 253         ValueTree* const v = valueTreesWithListeners[i];
 254         if (v != nullptr)
 255             v->listeners.call (&ValueTree::Listener::valueTreeChildAdded, tree, child);
 256     }
 257 }
 258
 259 void ValueTree::SharedObject::sendChildAddedMessage (ValueTree child)
 260 {
 261     ValueTree tree (this);
 262
 263     for (ValueTree::SharedObject* t = this; t != nullptr; t = t->parent)
 264         t->sendChildAddedMessage (tree, child);
 265 }
 266
 267 void ValueTree::SharedObject::sendChildRemovedMessage (ValueTree& tree, ValueTree& child)
 268 {
 269     for (int i = valueTreesWithListeners.size(); --i >= 0;)
 270     {
 271         ValueTree* const v = valueTreesWithListeners[i];
 272         if (v != nullptr)
 273             v->listeners.call (&ValueTree::Listener::valueTreeChildRemoved, tree, child);
 274     }
 275 }
 276
 277 void ValueTree::SharedObject::sendChildRemovedMessage (ValueTree child)
 278 {
 279     ValueTree tree (this);
 280
 281     for (ValueTree::SharedObject* t = this; t != nullptr; t = t->parent)
 282         t->sendChildRemovedMessage (tree, child);
 283 }
 284
 285 void ValueTree::SharedObject::sendChildOrderChangedMessage (ValueTree& tree)
 286 {
 287     for (int i = valueTreesWithListeners.size(); --i >= 0;)
 288     {
 289         ValueTree* const v = valueTreesWithListeners[i];
 290         if (v != nullptr)
 291             v->listeners.call (&ValueTree::Listener::valueTreeChildOrderChanged, tree);
 292     }
 293 }
 294
 295 void ValueTree::SharedObject::sendChildOrderChangedMessage()
 296 {
 297     ValueTree tree (this);
 298
 299     for (ValueTree::SharedObject* t = this; t != nullptr; t = t->parent)
 300         t->sendChildOrderChangedMessage (tree);
 301 }
 302
 303 void ValueTree::SharedObject::sendParentChangeMessage()
 304 {
 305     ValueTree tree (this);
 306
 307     int i;
 308     for (i = children.size(); --i >= 0;)
 309     {
 310         SharedObject* const t = children[i];
 311         if (t != nullptr)
 312             t->sendParentChangeMessage();
 313     }
 314
 315     for (i = valueTreesWithListeners.size(); --i >= 0;)
 316     {
 317         ValueTree* const v = valueTreesWithListeners[i];
 318         if (v != nullptr)
 319             v->listeners.call (&ValueTree::Listener::valueTreeParentChanged, tree);
 320     }
 321 }
 322
 323 //==============================================================================
 324 const var& ValueTree::SharedObject::getProperty (const Identifier& name) const
 325 {
 326     return properties [name];
 327 }
 328
 329 var ValueTree::SharedObject::getProperty (const Identifier& name, const var& defaultReturnValue) const
 330 {
 331     return properties.getWithDefault (name, defaultReturnValue);
 332 }
 333
 334 void ValueTree::SharedObject::setProperty (const Identifier& name, const var& newValue, UndoManager* const undoManager)
 335 {
 336     if (undoManager == nullptr)
 337     {
 338         if (properties.set (name, newValue))
 339             sendPropertyChangeMessage (name);
 340     }
 341     else
 342     {
 343         const var* const existingValue = properties.getVarPointer (name);
 344
 345         if (existingValue != nullptr)
 346         {
 347             if (*existingValue != newValue)
 348                 undoManager->perform (new SetPropertyAction (this, name, newValue, *existingValue, false, false));
 349         }
 350         else
 351         {
 352             undoManager->perform (new SetPropertyAction (this, name, newValue, var::null, true, false));
 353         }
 354     }
 355 }
 356
 357 bool ValueTree::SharedObject::hasProperty (const Identifier& name) const
 358 {
 359     return properties.contains (name);
 360 }
 361
 362 void ValueTree::SharedObject::removeProperty (const Identifier& name, UndoManager* const undoManager)
 363 {
 364     if (undoManager == nullptr)
 365     {
 366         if (properties.remove (name))
 367             sendPropertyChangeMessage (name);
 368     }
 369     else
 370     {
 371         if (properties.contains (name))
 372             undoManager->perform (new SetPropertyAction (this, name, var::null, properties [name], false, true));
 373     }
 374 }
 375
 376 void ValueTree::SharedObject::removeAllProperties (UndoManager* const undoManager)
 377 {
 378     if (undoManager == nullptr)
 379     {
 380         while (properties.size() > 0)
 381         {
 382             const Identifier name (properties.getName (properties.size() - 1));
 383             properties.remove (name);
 384             sendPropertyChangeMessage (name);
 385         }
 386     }
 387     else
 388     {
 389         for (int i = properties.size(); --i >= 0;)
 390             undoManager->perform (new SetPropertyAction (this, properties.getName(i), var::null, properties.getValueAt(i), false, true));
 391     }
 392 }
 393
 394 ValueTree ValueTree::SharedObject::getChildWithName (const Identifier& typeToMatch) const
 395 {
 396     for (int i = 0; i < children.size(); ++i)
 397         if (children.getUnchecked(i)->type == typeToMatch)
 398             return ValueTree (children.getUnchecked(i).getObject());
 399
 400     return ValueTree::invalid;
 401 }
 402
 403 ValueTree ValueTree::SharedObject::getOrCreateChildWithName (const Identifier& typeToMatch, UndoManager* undoManager)
 404 {
 405     for (int i = 0; i < children.size(); ++i)
 406         if (children.getUnchecked(i)->type == typeToMatch)
 407             return ValueTree (children.getUnchecked(i).getObject());
 408
 409     SharedObject* const newObject = new SharedObject (typeToMatch);
 410     addChild (newObject, -1, undoManager);
 411     return ValueTree (newObject);
 412
 413 }
 414
 415 ValueTree ValueTree::SharedObject::getChildWithProperty (const Identifier& propertyName, const var& propertyValue) const
 416 {
 417     for (int i = 0; i < children.size(); ++i)
 418         if (children.getUnchecked(i)->getProperty (propertyName) == propertyValue)
 419             return ValueTree (children.getUnchecked(i).getObject());
 420
 421     return ValueTree::invalid;
 422 }
 423
 424 bool ValueTree::SharedObject::isAChildOf (const SharedObject* const possibleParent) const
 425 {
 426     const SharedObject* p = parent;
 427
 428     while (p != nullptr)
 429     {
 430         if (p == possibleParent)
 431             return true;
 432
 433         p = p->parent;
 434     }
 435
 436     return false;
 437 }
 438
 439 int ValueTree::SharedObject::indexOf (const ValueTree& child) const
 440 {
 441     return children.indexOf (child.object);
 442 }
 443
 444 void ValueTree::SharedObject::addChild (SharedObject* child, int index, UndoManager* const undoManager)
 445 {
 446     if (child != nullptr && child->parent != this)
 447     {
 448         if (child != this && ! isAChildOf (child))
 449         {
 450             // You should always make sure that a child is removed from its previous parent before
 451             // adding it somewhere else - otherwise, it's ambiguous as to whether a different
 452             // undomanager should be used when removing it from its current parent..
 453             jassert (child->parent == nullptr);
 454
 455             if (child->parent != nullptr)
 456             {
 457                 jassert (child->parent->children.indexOf (child) >= 0);
 458                 child->parent->removeChild (child->parent->children.indexOf (child), undoManager);
 459             }
 460
 461             if (undoManager == nullptr)
 462             {
 463                 children.insert (index, child);
 464                 child->parent = this;
 465                 sendChildAddedMessage (ValueTree (child));
 466                 child->sendParentChangeMessage();
 467             }
 468             else
 469             {
 470                 if (index < 0)
 471                     index = children.size();
 472
 473                 undoManager->perform (new AddOrRemoveChildAction (this, index, child));
 474             }
 475         }
 476         else
 477         {
 478             // You're attempting to create a recursive loop! A node
 479             // can't be a child of one of its own children!
 480             jassertfalse;
 481         }
 482     }
 483 }
 484
 485 void ValueTree::SharedObject::removeChild (const int childIndex, UndoManager* const undoManager)
 486 {
 487     const SharedObjectPtr child (children [childIndex]);
 488
 489     if (child != nullptr)
 490     {
 491         if (undoManager == nullptr)
 492         {
 493             children.remove (childIndex);
 494             child->parent = nullptr;
 495             sendChildRemovedMessage (ValueTree (child));
 496             child->sendParentChangeMessage();
 497         }
 498         else
 499         {
 500             undoManager->perform (new AddOrRemoveChildAction (this, childIndex, nullptr));
 501         }
 502     }
 503 }
 504
 505 void ValueTree::SharedObject::removeAllChildren (UndoManager* const undoManager)
 506 {
 507     while (children.size() > 0)
 508         removeChild (children.size() - 1, undoManager);
 509 }
 510
 511 void ValueTree::SharedObject::moveChild (int currentIndex, int newIndex, UndoManager* undoManager)
 512 {
 513     // The source index must be a valid index!
 514     jassert (isPositiveAndBelow (currentIndex, children.size()));
 515
 516     if (currentIndex != newIndex
 517          && isPositiveAndBelow (currentIndex, children.size()))
 518     {
 519         if (undoManager == nullptr)
 520         {
 521             children.move (currentIndex, newIndex);
 522             sendChildOrderChangedMessage();
 523         }
 524         else
 525         {
 526             if (! isPositiveAndBelow (newIndex, children.size()))
 527                 newIndex = children.size() - 1;
 528
 529             undoManager->perform (new MoveChildAction (this, currentIndex, newIndex));
 530         }
 531     }
 532 }
 533
 534 void ValueTree::SharedObject::reorderChildren (const ReferenceCountedArray <SharedObject>& newOrder, UndoManager* undoManager)
 535 {
 536     jassert (newOrder.size() == children.size());
 537
 538     if (undoManager == nullptr)
 539     {
 540         children = newOrder;
 541         sendChildOrderChangedMessage();
 542     }
 543     else
 544     {
 545         for (int i = 0; i < children.size(); ++i)
 546         {
 547             const SharedObjectPtr child (newOrder.getUnchecked(i));
 548
 549             if (children.getUnchecked(i) != child)
 550             {
 551                 const int oldIndex = children.indexOf (child);
 552                 jassert (oldIndex >= 0);
 553                 moveChild (oldIndex, i, undoManager);
 554             }
 555         }
 556     }
 557 }
 558
 559 bool ValueTree::SharedObject::isEquivalentTo (const SharedObject& other) const
 560 {
 561     if (type != other.type
 562          || properties.size() != other.properties.size()
 563          || children.size() != other.children.size()
 564          || properties != other.properties)
 565         return false;
 566
 567     for (int i = 0; i < children.size(); ++i)
 568         if (! children.getUnchecked(i)->isEquivalentTo (*other.children.getUnchecked(i)))
 569             return false;
 570
 571     return true;
 572 }
 573
 574
 575 //==============================================================================
 576 ValueTree::ValueTree() noexcept
 577 {
 578 }
 579
 580 const ValueTree ValueTree::invalid;
 581
 582 ValueTree::ValueTree (const Identifier& type_)
 583     : object (new ValueTree::SharedObject (type_))
 584 {
 585     jassert (type_.toString().isNotEmpty()); // All objects should be given a sensible type name!
 586 }
 587
 588 ValueTree::ValueTree (SharedObject* const object_)
 589     : object (object_)
 590 {
 591 }
 592
 593 ValueTree::ValueTree (const ValueTree& other)
 594     : object (other.object)
 595 {
 596 }
 597
 598 ValueTree& ValueTree::operator= (const ValueTree& other)
 599 {
 600     if (listeners.size() > 0)
 601     {
 602         if (object != nullptr)
 603             object->valueTreesWithListeners.removeValue (this);
 604
 605         if (other.object != nullptr)
 606             other.object->valueTreesWithListeners.add (this);
 607     }
 608
 609     object = other.object;
 610
 611     return *this;
 612 }
 613
 614 ValueTree::~ValueTree()
 615 {
 616     if (listeners.size() > 0 && object != nullptr)
 617         object->valueTreesWithListeners.removeValue (this);
 618 }
 619
 620 bool ValueTree::operator== (const ValueTree& other) const noexcept
 621 {
 622     return object == other.object;
 623 }
 624
 625 bool ValueTree::operator!= (const ValueTree& other) const noexcept
 626 {
 627     return object != other.object;
 628 }
 629
 630 bool ValueTree::isEquivalentTo (const ValueTree& other) const
 631 {
 632     return object == other.object
 633             || (object != nullptr && other.object != nullptr && object->isEquivalentTo (*other.object));
 634 }
 635
 636 ValueTree ValueTree::createCopy() const
 637 {
 638     return ValueTree (object != nullptr ? new SharedObject (*object) : nullptr);
 639 }
 640
 641 bool ValueTree::hasType (const Identifier& typeName) const
 642 {
 643     return object != nullptr && object->type == typeName;
 644 }
 645
 646 Identifier ValueTree::getType() const
 647 {
 648     return object != nullptr ? object->type : Identifier();
 649 }
 650
 651 ValueTree ValueTree::getParent() const
 652 {
 653     return ValueTree (object != nullptr ? object->parent : (SharedObject*) nullptr);
 654 }
 655
 656 ValueTree ValueTree::getSibling (const int delta) const
 657 {
 658     if (object == nullptr || object->parent == nullptr)
 659         return invalid;
 660
 661     const int index = object->parent->indexOf (*this) + delta;
 662     return ValueTree (object->parent->children [index].getObject());
 663 }
 664
 665 const var& ValueTree::operator[] (const Identifier& name) const
 666 {
 667     return object == nullptr ? var::null : object->getProperty (name);
 668 }
 669
 670 const var& ValueTree::getProperty (const Identifier& name) const
 671 {
 672     return object == nullptr ? var::null : object->getProperty (name);
 673 }
 674
 675 var ValueTree::getProperty (const Identifier& name, const var& defaultReturnValue) const
 676 {
 677     return object == nullptr ? defaultReturnValue : object->getProperty (name, defaultReturnValue);
 678 }
 679
 680 void ValueTree::setProperty (const Identifier& name, const var& newValue, UndoManager* const undoManager)
 681 {
 682     jassert (name.toString().isNotEmpty());
 683
 684     if (object != nullptr && name.toString().isNotEmpty())
 685         object->setProperty (name, newValue, undoManager);
 686 }
 687
 688 bool ValueTree::hasProperty (const Identifier& name) const
 689 {
 690     return object != nullptr && object->hasProperty (name);
 691 }
 692
 693 void ValueTree::removeProperty (const Identifier& name, UndoManager* const undoManager)
 694 {
 695     if (object != nullptr)
 696         object->removeProperty (name, undoManager);
 697 }
 698
 699 void ValueTree::removeAllProperties (UndoManager* const undoManager)
 700 {
 701     if (object != nullptr)
 702         object->removeAllProperties (undoManager);
 703 }
 704
 705 int ValueTree::getNumProperties() const
 706 {
 707     return object == nullptr ? 0 : object->properties.size();
 708 }
 709
 710 Identifier ValueTree::getPropertyName (const int index) const
 711 {
 712     return object == nullptr ? Identifier()
 713                              : object->properties.getName (index);
 714 }
 715
 716 //==============================================================================
 717 class ValueTreePropertyValueSource  : public Value::ValueSource,
 718                                       public ValueTree::Listener
 719 {
 720 public:
 721     ValueTreePropertyValueSource (const ValueTree& tree_,
 722                                   const Identifier& property_,
 723                                   UndoManager* const undoManager_)
 724         : tree (tree_),
 725           property (property_),
 726           undoManager (undoManager_)
 727     {
 728         tree.addListener (this);
 729     }
 730
 731     ~ValueTreePropertyValueSource()
 732     {
 733         tree.removeListener (this);
 734     }
 735
 736     var getValue() const
 737     {
 738         return tree [property];
 739     }
 740
 741     void setValue (const var& newValue)
 742     {
 743         tree.setProperty (property, newValue, undoManager);
 744     }
 745
 746     void valueTreePropertyChanged (ValueTree& treeWhosePropertyHasChanged, const Identifier& changedProperty)
 747     {
 748         if (tree == treeWhosePropertyHasChanged && property == changedProperty)
 749             sendChangeMessage (false);
 750     }
 751
 752     void valueTreeChildAdded (ValueTree&, ValueTree&) {}
 753     void valueTreeChildRemoved (ValueTree&, ValueTree&) {}
 754     void valueTreeChildOrderChanged (ValueTree&) {}
 755     void valueTreeParentChanged (ValueTree&) {}
 756
 757 private:
 758     ValueTree tree;
 759     const Identifier property;
 760     UndoManager* const undoManager;
 761
 762     ValueTreePropertyValueSource& operator= (const ValueTreePropertyValueSource&);
 763 };
 764
 765 Value ValueTree::getPropertyAsValue (const Identifier& name, UndoManager* const undoManager) const
 766 {
 767     return Value (new ValueTreePropertyValueSource (*this, name, undoManager));
 768 }
 769
 770 //==============================================================================
 771 int ValueTree::getNumChildren() const
 772 {
 773     return object == nullptr ? 0 : object->children.size();
 774 }
 775
 776 ValueTree ValueTree::getChild (int index) const
 777 {
 778     return ValueTree (object != nullptr ? (SharedObject*) object->children [index] : (SharedObject*) nullptr);
 779 }
 780
 781 ValueTree ValueTree::getChildWithName (const Identifier& type) const
 782 {
 783     return object != nullptr ? object->getChildWithName (type) : ValueTree::invalid;
 784 }
 785
 786 ValueTree ValueTree::getOrCreateChildWithName (const Identifier& type, UndoManager* undoManager)
 787 {
 788     return object != nullptr ? object->getOrCreateChildWithName (type, undoManager) : ValueTree::invalid;
 789 }
 790
 791 ValueTree ValueTree::getChildWithProperty (const Identifier& propertyName, const var& propertyValue) const
 792 {
 793     return object != nullptr ? object->getChildWithProperty (propertyName, propertyValue) : ValueTree::invalid;
 794 }
 795
 796 bool ValueTree::isAChildOf (const ValueTree& possibleParent) const
 797 {
 798     return object != nullptr && object->isAChildOf (possibleParent.object);
 799 }
 800
 801 int ValueTree::indexOf (const ValueTree& child) const
 802 {
 803     return object != nullptr ? object->indexOf (child) : -1;
 804 }
 805
 806 void ValueTree::addChild (const ValueTree& child, int index, UndoManager* const undoManager)
 807 {
 808     if (object != nullptr)
 809         object->addChild (child.object, index, undoManager);
 810 }
 811
 812 void ValueTree::removeChild (const int childIndex, UndoManager* const undoManager)
 813 {
 814     if (object != nullptr)
 815         object->removeChild (childIndex, undoManager);
 816 }
 817
 818 void ValueTree::removeChild (const ValueTree& child, UndoManager* const undoManager)
 819 {
 820     if (object != nullptr)
 821         object->removeChild (object->children.indexOf (child.object), undoManager);
 822 }
 823
 824 void ValueTree::removeAllChildren (UndoManager* const undoManager)
 825 {
 826     if (object != nullptr)
 827         object->removeAllChildren (undoManager);
 828 }
 829
 830 void ValueTree::moveChild (int currentIndex, int newIndex, UndoManager* undoManager)
 831 {
 832     if (object != nullptr)
 833         object->moveChild (currentIndex, newIndex, undoManager);
 834 }
 835
 836 //==============================================================================
 837 void ValueTree::addListener (Listener* listener)
 838 {
 839     if (listener != nullptr)
 840     {
 841         if (listeners.size() == 0 && object != nullptr)
 842             object->valueTreesWithListeners.add (this);
 843
 844         listeners.add (listener);
 845     }
 846 }
 847
 848 void ValueTree::removeListener (Listener* listener)
 849 {
 850     listeners.remove (listener);
 851
 852     if (listeners.size() == 0 && object != nullptr)
 853         object->valueTreesWithListeners.removeValue (this);
 854 }
 855
 856 //==============================================================================
 857 XmlElement* ValueTree::SharedObject::createXml() const
 858 {
 859     XmlElement* const xml = new XmlElement (type.toString());
 860     properties.copyToXmlAttributes (*xml);
 861
 862     for (int i = 0; i < children.size(); ++i)
 863         xml->addChildElement (children.getUnchecked(i)->createXml());
 864
 865     return xml;
 866 }
 867
 868 XmlElement* ValueTree::createXml() const
 869 {
 870     return object != nullptr ? object->createXml() : nullptr;
 871 }
 872
 873 ValueTree ValueTree::fromXml (const XmlElement& xml)
 874 {
 875     ValueTree v (xml.getTagName());
 876     v.object->properties.setFromXmlAttributes (xml);
 877
 878     forEachXmlChildElement (xml, e)
 879         v.addChild (fromXml (*e), -1, nullptr);
 880
 881     return v;
 882 }
 883
 884 //==============================================================================
 885 void ValueTree::writeToStream (OutputStream& output)
 886 {
 887     output.writeString (getType().toString());
 888
 889     const int numProps = getNumProperties();
 890     output.writeCompressedInt (numProps);
 891
 892     int i;
 893     for (i = 0; i < numProps; ++i)
 894     {
 895         const Identifier name (getPropertyName(i));
 896         output.writeString (name.toString());
 897         getProperty(name).writeToStream (output);
 898     }
 899
 900     const int numChildren = getNumChildren();
 901     output.writeCompressedInt (numChildren);
 902
 903     for (i = 0; i < numChildren; ++i)
 904         getChild (i).writeToStream (output);
 905 }
 906
 907 ValueTree ValueTree::readFromStream (InputStream& input)
 908 {
 909     const String type (input.readString());
 910
 911     if (type.isEmpty())
 912         return ValueTree::invalid;
 913
 914     ValueTree v (type);
 915
 916     const int numProps = input.readCompressedInt();
 917
 918     if (numProps < 0)
 919     {
 920         jassertfalse;  // trying to read corrupted data!
 921         return v;
 922     }
 923
 924     int i;
 925     for (i = 0; i < numProps; ++i)
 926     {
 927         const String name (input.readString());
 928         jassert (name.isNotEmpty());
 929         const var value (var::readFromStream (input));
 930         v.object->properties.set (name, value);
 931     }
 932
 933     const int numChildren = input.readCompressedInt();
 934
 935     for (i = 0; i < numChildren; ++i)
 936     {
 937         ValueTree child (readFromStream (input));
 938
 939         v.object->children.add (child.object);
 940         child.object->parent = v.object;
 941     }
 942
 943     return v;
 944 }
 945
 946 ValueTree ValueTree::readFromData (const void* const data, const size_t numBytes)
 947 {
 948     MemoryInputStream in (data, numBytes, false);
 949     return readFromStream (in);
 950 }
 951
 952 END_JUCE_NAMESPACE