Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1072 lines
34KB

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