Loading...
Searching...
No Matches
juce_ValueTree.cpp
/*
==============================================================================
This file is part of the JUCE library.
Copyright (c) 2022 - Raw Material Software Limited
JUCE is an open source library subject to commercial or open-source
licensing.
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
Agreement and JUCE Privacy Policy.
End User License Agreement: www.juce.com/juce-7-licence
Privacy Policy: www.juce.com/juce-privacy-policy
Or: You may also use this code under the terms of the GPL v3 (see
www.gnu.org/licenses).
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
DISCLAIMED.
==============================================================================
*/
namespace juce
{
class ValueTree::SharedObject final : public ReferenceCountedObject
{
public:
using Ptr = ReferenceCountedObjectPtr<SharedObject>;
explicit SharedObject (const Identifier& t) noexcept : type (t) {}
SharedObject (const SharedObject& other)
: ReferenceCountedObject(), type (other.type), properties (other.properties)
{
for (auto* c : other.children)
{
auto* child = new SharedObject (*c);
child->parent = this;
children.add (child);
}
}
SharedObject& operator= (const SharedObject&) = delete;
~SharedObject() override
{
jassert (parent == nullptr); // this should never happen unless something isn't obeying the ref-counting!
for (auto i = children.size(); --i >= 0;)
{
const Ptr c (children.getObjectPointerUnchecked (i));
c->parent = nullptr;
children.remove (i);
c->sendParentChangeMessage();
}
}
SharedObject& getRoot() noexcept
{
return parent == nullptr ? *this : parent->getRoot();
}
template <typename Function>
void callListeners (ValueTree::Listener* listenerToExclude, Function fn) const
{
auto numListeners = valueTreesWithListeners.size();
if (numListeners == 1)
{
valueTreesWithListeners.getUnchecked (0)->listeners.callExcluding (listenerToExclude, fn);
}
else if (numListeners > 0)
{
auto listenersCopy = valueTreesWithListeners;
for (int i = 0; i < numListeners; ++i)
{
auto* v = listenersCopy.getUnchecked (i);
if (i == 0 || valueTreesWithListeners.contains (v))
v->listeners.callExcluding (listenerToExclude, fn);
}
}
}
template <typename Function>
void callListenersForAllParents (ValueTree::Listener* listenerToExclude, Function fn) const
{
for (auto* t = this; t != nullptr; t = t->parent)
t->callListeners (listenerToExclude, fn);
}
void sendPropertyChangeMessage (const Identifier& property, ValueTree::Listener* listenerToExclude = nullptr)
{
ValueTree tree (*this);
callListenersForAllParents (listenerToExclude, [&] (Listener& l) { l.valueTreePropertyChanged (tree, property); });
}
void sendChildAddedMessage (ValueTree child)
{
ValueTree tree (*this);
callListenersForAllParents (nullptr, [&] (Listener& l) { l.valueTreeChildAdded (tree, child); });
}
void sendChildRemovedMessage (ValueTree child, int index)
{
ValueTree tree (*this);
callListenersForAllParents (nullptr, [=, &tree, &child] (Listener& l) { l.valueTreeChildRemoved (tree, child, index); });
}
void sendChildOrderChangedMessage (int oldIndex, int newIndex)
{
ValueTree tree (*this);
callListenersForAllParents (nullptr, [=, &tree] (Listener& l) { l.valueTreeChildOrderChanged (tree, oldIndex, newIndex); });
}
void sendParentChangeMessage()
{
ValueTree tree (*this);
for (auto j = children.size(); --j >= 0;)
if (auto* child = children.getObjectPointer (j))
child->sendParentChangeMessage();
callListeners (nullptr, [&] (Listener& l) { l.valueTreeParentChanged (tree); });
}
void setProperty (const Identifier& name, const var& newValue, UndoManager* undoManager,
ValueTree::Listener* listenerToExclude = nullptr)
{
if (undoManager == nullptr)
{
if (properties.set (name, newValue))
sendPropertyChangeMessage (name, listenerToExclude);
}
else
{
if (auto* existingValue = properties.getVarPointer (name))
{
if (*existingValue != newValue)
undoManager->perform (new SetPropertyAction (*this, name, newValue, *existingValue,
false, false, listenerToExclude));
}
else
{
undoManager->perform (new SetPropertyAction (*this, name, newValue, {},
true, false, listenerToExclude));
}
}
}
bool hasProperty (const Identifier& name) const noexcept
{
return properties.contains (name);
}
void removeProperty (const Identifier& name, UndoManager* undoManager)
{
if (undoManager == nullptr)
{
if (properties.remove (name))
sendPropertyChangeMessage (name);
}
else
{
if (properties.contains (name))
undoManager->perform (new SetPropertyAction (*this, name, {}, properties[name], false, true));
}
}
void removeAllProperties (UndoManager* undoManager)
{
if (undoManager == nullptr)
{
while (properties.size() > 0)
{
auto name = properties.getName (properties.size() - 1);
properties.remove (name);
sendPropertyChangeMessage (name);
}
}
else
{
for (auto i = properties.size(); --i >= 0;)
undoManager->perform (new SetPropertyAction (*this, properties.getName (i), {},
properties.getValueAt (i), false, true));
}
}
void copyPropertiesFrom (const SharedObject& source, UndoManager* undoManager)
{
for (auto i = properties.size(); --i >= 0;)
if (! source.properties.contains (properties.getName (i)))
removeProperty (properties.getName (i), undoManager);
for (int i = 0; i < source.properties.size(); ++i)
setProperty (source.properties.getName (i), source.properties.getValueAt (i), undoManager);
}
ValueTree getChildWithName (const Identifier& typeToMatch) const
{
for (auto* s : children)
if (s->type == typeToMatch)
return ValueTree (*s);
return {};
}
ValueTree getOrCreateChildWithName (const Identifier& typeToMatch, UndoManager* undoManager)
{
for (auto* s : children)
if (s->type == typeToMatch)
return ValueTree (*s);
auto newObject = new SharedObject (typeToMatch);
addChild (newObject, -1, undoManager);
return ValueTree (*newObject);
}
ValueTree getChildWithProperty (const Identifier& propertyName, const var& propertyValue) const
{
for (auto* s : children)
if (s->properties[propertyName] == propertyValue)
return ValueTree (*s);
return {};
}
bool isAChildOf (const SharedObject* possibleParent) const noexcept
{
for (auto* p = parent; p != nullptr; p = p->parent)
if (p == possibleParent)
return true;
return false;
}
int indexOf (const ValueTree& child) const noexcept
{
return children.indexOf (child.object);
}
void addChild (SharedObject* child, int index, UndoManager* undoManager)
{
if (child != nullptr && child->parent != this)
{
if (child != this && ! isAChildOf (child))
{
// You should always make sure that a child is removed from its previous parent before
// adding it somewhere else - otherwise, it's ambiguous as to whether a different
// undomanager should be used when removing it from its current parent..
jassert (child->parent == nullptr);
if (child->parent != nullptr)
{
jassert (child->parent->children.indexOf (child) >= 0);
child->parent->removeChild (child->parent->children.indexOf (child), undoManager);
}
if (undoManager == nullptr)
{
children.insert (index, child);
child->parent = this;
sendChildAddedMessage (ValueTree (*child));
child->sendParentChangeMessage();
}
else
{
if (! isPositiveAndBelow (index, children.size()))
index = children.size();
undoManager->perform (new AddOrRemoveChildAction (*this, index, child));
}
}
else
{
// You're attempting to create a recursive loop! A node
// can't be a child of one of its own children!
jassertfalse;
}
}
}
void removeChild (int childIndex, UndoManager* undoManager)
{
if (auto child = Ptr (children.getObjectPointer (childIndex)))
{
if (undoManager == nullptr)
{
children.remove (childIndex);
child->parent = nullptr;
sendChildRemovedMessage (ValueTree (child), childIndex);
child->sendParentChangeMessage();
}
else
{
undoManager->perform (new AddOrRemoveChildAction (*this, childIndex, {}));
}
}
}
void removeAllChildren (UndoManager* undoManager)
{
while (children.size() > 0)
removeChild (children.size() - 1, undoManager);
}
void moveChild (int currentIndex, int newIndex, UndoManager* undoManager)
{
// The source index must be a valid index!
jassert (isPositiveAndBelow (currentIndex, children.size()));
if (currentIndex != newIndex
&& isPositiveAndBelow (currentIndex, children.size()))
{
if (undoManager == nullptr)
{
children.move (currentIndex, newIndex);
sendChildOrderChangedMessage (currentIndex, newIndex);
}
else
{
if (! isPositiveAndBelow (newIndex, children.size()))
newIndex = children.size() - 1;
undoManager->perform (new MoveChildAction (*this, currentIndex, newIndex));
}
}
}
void reorderChildren (const OwnedArray<ValueTree>& newOrder, UndoManager* undoManager)
{
jassert (newOrder.size() == children.size());
for (int i = 0; i < children.size(); ++i)
{
auto* child = newOrder.getUnchecked (i)->object.get();
if (children.getObjectPointerUnchecked (i) != child)
{
auto oldIndex = children.indexOf (child);
jassert (oldIndex >= 0);
moveChild (oldIndex, i, undoManager);
}
}
}
bool isEquivalentTo (const SharedObject& other) const noexcept
{
if (type != other.type
|| properties.size() != other.properties.size()
|| children.size() != other.children.size()
|| properties != other.properties)
return false;
for (int i = 0; i < children.size(); ++i)
if (! children.getObjectPointerUnchecked (i)->isEquivalentTo (*other.children.getObjectPointerUnchecked (i)))
return false;
return true;
}
XmlElement* createXml() const
{
auto* xml = new XmlElement (type);
properties.copyToXmlAttributes (*xml);
// (NB: it's faster to add nodes to XML elements in reverse order)
for (auto i = children.size(); --i >= 0;)
xml->prependChildElement (children.getObjectPointerUnchecked (i)->createXml());
return xml;
}
void writeToStream (OutputStream& output) const
{
output.writeString (type.toString());
output.writeCompressedInt (properties.size());
for (int j = 0; j < properties.size(); ++j)
{
output.writeString (properties.getName (j).toString());
properties.getValueAt (j).writeToStream (output);
}
output.writeCompressedInt (children.size());
for (auto* c : children)
writeObjectToStream (output, c);
}
static void writeObjectToStream (OutputStream& output, const SharedObject* object)
{
if (object != nullptr)
{
object->writeToStream (output);
}
else
{
output.writeString ({});
output.writeCompressedInt (0);
output.writeCompressedInt (0);
}
}
//==============================================================================
struct SetPropertyAction final : public UndoableAction
{
SetPropertyAction (Ptr targetObject, const Identifier& propertyName,
const var& newVal, const var& oldVal, bool isAdding, bool isDeleting,
ValueTree::Listener* listenerToExclude = nullptr)
: target (std::move (targetObject)),
name (propertyName), newValue (newVal), oldValue (oldVal),
isAddingNewProperty (isAdding), isDeletingProperty (isDeleting),
excludeListener (listenerToExclude)
{
}
bool perform() override
{
jassert (! (isAddingNewProperty && target->hasProperty (name)));
if (isDeletingProperty)
target->removeProperty (name, nullptr);
else
target->setProperty (name, newValue, nullptr, excludeListener);
return true;
}
bool undo() override
{
if (isAddingNewProperty)
target->removeProperty (name, nullptr);
else
target->setProperty (name, oldValue, nullptr);
return true;
}
int getSizeInUnits() override
{
return (int) sizeof (*this); //xxx should be more accurate
}
UndoableAction* createCoalescedAction (UndoableAction* nextAction) override
{
if (! (isAddingNewProperty || isDeletingProperty))
{
if (auto* next = dynamic_cast<SetPropertyAction*> (nextAction))
if (next->target == target && next->name == name
&& ! (next->isAddingNewProperty || next->isDeletingProperty))
return new SetPropertyAction (*target, name, next->newValue, oldValue, false, false);
}
return nullptr;
}
private:
const Ptr target;
const Identifier name;
const var newValue;
var oldValue;
const bool isAddingNewProperty : 1, isDeletingProperty : 1;
ValueTree::Listener* excludeListener;
JUCE_DECLARE_NON_COPYABLE (SetPropertyAction)
};
//==============================================================================
struct AddOrRemoveChildAction final : public UndoableAction
{
AddOrRemoveChildAction (Ptr parentObject, int index, SharedObject* newChild)
: target (std::move (parentObject)),
child (newChild != nullptr ? newChild : target->children.getObjectPointer (index)),
childIndex (index),
isDeleting (newChild == nullptr)
{
jassert (child != nullptr);
}
bool perform() override
{
if (isDeleting)
target->removeChild (childIndex, nullptr);
else
target->addChild (child.get(), childIndex, nullptr);
return true;
}
bool undo() override
{
if (isDeleting)
{
target->addChild (child.get(), childIndex, nullptr);
}
else
{
// If you hit this, it seems that your object's state is getting confused - probably
// because you've interleaved some undoable and non-undoable operations?
jassert (childIndex < target->children.size());
target->removeChild (childIndex, nullptr);
}
return true;
}
int getSizeInUnits() override
{
return (int) sizeof (*this); //xxx should be more accurate
}
private:
const Ptr target, child;
const int childIndex;
const bool isDeleting;
JUCE_DECLARE_NON_COPYABLE (AddOrRemoveChildAction)
};
//==============================================================================
struct MoveChildAction final : public UndoableAction
{
MoveChildAction (Ptr parentObject, int fromIndex, int toIndex) noexcept
: parent (std::move (parentObject)), startIndex (fromIndex), endIndex (toIndex)
{
}
bool perform() override
{
parent->moveChild (startIndex, endIndex, nullptr);
return true;
}
bool undo() override
{
parent->moveChild (endIndex, startIndex, nullptr);
return true;
}
int getSizeInUnits() override
{
return (int) sizeof (*this); //xxx should be more accurate
}
UndoableAction* createCoalescedAction (UndoableAction* nextAction) override
{
if (auto* next = dynamic_cast<MoveChildAction*> (nextAction))
if (next->parent == parent && next->startIndex == endIndex)
return new MoveChildAction (parent, startIndex, next->endIndex);
return nullptr;
}
private:
const Ptr parent;
const int startIndex, endIndex;
JUCE_DECLARE_NON_COPYABLE (MoveChildAction)
};
//==============================================================================
const Identifier type;
NamedValueSet properties;
ReferenceCountedArray<SharedObject> children;
SortedSet<ValueTree*> valueTreesWithListeners;
SharedObject* parent = nullptr;
JUCE_LEAK_DETECTOR (SharedObject)
};
//==============================================================================
ValueTree::ValueTree() noexcept
{
}
ValueTree::ValueTree (const Identifier& type) : object (new ValueTree::SharedObject (type))
{
jassert (type.toString().isNotEmpty()); // All objects must be given a sensible type name!
}
ValueTree::ValueTree (const Identifier& type,
std::initializer_list<NamedValueSet::NamedValue> properties,
std::initializer_list<ValueTree> subTrees)
: ValueTree (type)
{
object->properties = NamedValueSet (std::move (properties));
for (auto& tree : subTrees)
addChild (tree, -1, nullptr);
}
ValueTree::ValueTree (SharedObject::Ptr so) noexcept : object (std::move (so)) {}
ValueTree::ValueTree (SharedObject& so) noexcept : object (so) {}
ValueTree::ValueTree (const ValueTree& other) noexcept : object (other.object)
{
}
ValueTree& ValueTree::operator= (const ValueTree& other)
{
if (object != other.object)
{
if (listeners.isEmpty())
{
object = other.object;
}
else
{
if (object != nullptr)
object->valueTreesWithListeners.removeValue (this);
if (other.object != nullptr)
other.object->valueTreesWithListeners.add (this);
object = other.object;
listeners.call ([this] (Listener& l) { l.valueTreeRedirected (*this); });
}
}
return *this;
}
ValueTree::ValueTree (ValueTree&& other) noexcept
: object (std::move (other.object))
{
if (object != nullptr)
object->valueTreesWithListeners.removeValue (&other);
}
ValueTree::~ValueTree()
{
if (! listeners.isEmpty() && object != nullptr)
object->valueTreesWithListeners.removeValue (this);
}
bool ValueTree::operator== (const ValueTree& other) const noexcept
{
return object == other.object;
}
bool ValueTree::operator!= (const ValueTree& other) const noexcept
{
return object != other.object;
}
bool ValueTree::isEquivalentTo (const ValueTree& other) const
{
return object == other.object
|| (object != nullptr && other.object != nullptr
&& object->isEquivalentTo (*other.object));
}
ValueTree ValueTree::createCopy() const
{
if (object != nullptr)
return ValueTree (*new SharedObject (*object));
return {};
}
void ValueTree::copyPropertiesFrom (const ValueTree& source, UndoManager* undoManager)
{
jassert (object != nullptr || source.object == nullptr); // Trying to add properties to a null ValueTree will fail!
if (source == *this)
return;
if (source.object == nullptr)
removeAllProperties (undoManager);
else if (object != nullptr)
object->copyPropertiesFrom (*(source.object), undoManager);
}
void ValueTree::copyPropertiesAndChildrenFrom (const ValueTree& source, UndoManager* undoManager)
{
jassert (object != nullptr || source.object == nullptr); // Trying to copy to a null ValueTree will fail!
if (source == *this)
return;
copyPropertiesFrom (source, undoManager);
removeAllChildren (undoManager);
if (object != nullptr && source.object != nullptr)
for (auto& child : source.object->children)
object->addChild (createCopyIfNotNull (child), -1, undoManager);
}
bool ValueTree::hasType (const Identifier& typeName) const noexcept
{
return object != nullptr && object->type == typeName;
}
Identifier ValueTree::getType() const noexcept
{
return object != nullptr ? object->type : Identifier();
}
ValueTree ValueTree::getParent() const noexcept
{
if (object != nullptr)
if (auto p = object->parent)
return ValueTree (*p);
return {};
}
ValueTree ValueTree::getRoot() const noexcept
{
if (object != nullptr)
return ValueTree (object->getRoot());
return {};
}
ValueTree ValueTree::getSibling (int delta) const noexcept
{
if (object != nullptr)
if (auto* p = object->parent)
if (auto* c = p->children.getObjectPointer (p->indexOf (*this) + delta))
return ValueTree (*c);
return {};
}
static const var& getNullVarRef() noexcept
{
static var nullVar;
return nullVar;
}
const var& ValueTree::operator[] (const Identifier& name) const noexcept
{
return object == nullptr ? getNullVarRef() : object->properties[name];
}
const var& ValueTree::getProperty (const Identifier& name) const noexcept
{
return object == nullptr ? getNullVarRef() : object->properties[name];
}
var ValueTree::getProperty (const Identifier& name, const var& defaultReturnValue) const
{
return object == nullptr ? defaultReturnValue
: object->properties.getWithDefault (name, defaultReturnValue);
}
const var* ValueTree::getPropertyPointer (const Identifier& name) const noexcept
{
return object == nullptr ? nullptr
: object->properties.getVarPointer (name);
}
ValueTree& ValueTree::setProperty (const Identifier& name, const var& newValue, UndoManager* undoManager)
{
return setPropertyExcludingListener (nullptr, name, newValue, undoManager);
}
ValueTree& ValueTree::setPropertyExcludingListener (Listener* listenerToExclude, const Identifier& name,
const var& newValue, UndoManager* undoManager)
{
jassert (name.toString().isNotEmpty()); // Must have a valid property name!
jassert (object != nullptr); // Trying to add a property to a null ValueTree will fail!
if (object != nullptr)
object->setProperty (name, newValue, undoManager, listenerToExclude);
return *this;
}
bool ValueTree::hasProperty (const Identifier& name) const noexcept
{
return object != nullptr && object->hasProperty (name);
}
void ValueTree::removeProperty (const Identifier& name, UndoManager* undoManager)
{
if (object != nullptr)
object->removeProperty (name, undoManager);
}
void ValueTree::removeAllProperties (UndoManager* undoManager)
{
if (object != nullptr)
object->removeAllProperties (undoManager);
}
int ValueTree::getNumProperties() const noexcept
{
return object == nullptr ? 0 : object->properties.size();
}
Identifier ValueTree::getPropertyName (int index) const noexcept
{
return object == nullptr ? Identifier()
: object->properties.getName (index);
}
int ValueTree::getReferenceCount() const noexcept
{
return object != nullptr ? object->getReferenceCount() : 0;
}
//==============================================================================
struct ValueTreePropertyValueSource final : public Value::ValueSource,
private ValueTree::Listener
{
ValueTreePropertyValueSource (const ValueTree& vt, const Identifier& prop, UndoManager* um, bool sync)
: tree (vt), property (prop), undoManager (um), updateSynchronously (sync)
{
tree.addListener (this);
}
~ValueTreePropertyValueSource() override
{
tree.removeListener (this);
}
var getValue() const override { return tree[property]; }
void setValue (const var& newValue) override { tree.setProperty (property, newValue, undoManager); }
private:
ValueTree tree;
const Identifier property;
UndoManager* const undoManager;
const bool updateSynchronously;
void valueTreePropertyChanged (ValueTree& changedTree, const Identifier& changedProperty) override
{
if (tree == changedTree && property == changedProperty)
sendChangeMessage (updateSynchronously);
}
void valueTreeChildAdded (ValueTree&, ValueTree&) override {}
void valueTreeChildRemoved (ValueTree&, ValueTree&, int) override {}
void valueTreeChildOrderChanged (ValueTree&, int, int) override {}
void valueTreeParentChanged (ValueTree&) override {}
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ValueTreePropertyValueSource)
};
Value ValueTree::getPropertyAsValue (const Identifier& name, UndoManager* undoManager, bool updateSynchronously)
{
return Value (new ValueTreePropertyValueSource (*this, name, undoManager, updateSynchronously));
}
//==============================================================================
int ValueTree::getNumChildren() const noexcept
{
return object == nullptr ? 0 : object->children.size();
}
ValueTree ValueTree::getChild (int index) const
{
if (object != nullptr)
if (auto* c = object->children.getObjectPointer (index))
return ValueTree (*c);
return {};
}
ValueTree::Iterator::Iterator (const ValueTree& v, bool isEnd)
: internal (v.object != nullptr ? (isEnd ? v.object->children.end() : v.object->children.begin()) : nullptr)
{
}
ValueTree::Iterator& ValueTree::Iterator::operator++()
{
++internal;
return *this;
}
bool ValueTree::Iterator::operator== (const Iterator& other) const { return internal == other.internal; }
bool ValueTree::Iterator::operator!= (const Iterator& other) const { return internal != other.internal; }
ValueTree ValueTree::Iterator::operator*() const
{
return ValueTree (SharedObject::Ptr (*internal));
}
ValueTree::Iterator ValueTree::begin() const noexcept { return Iterator (*this, false); }
ValueTree::Iterator ValueTree::end() const noexcept { return Iterator (*this, true); }
ValueTree ValueTree::getChildWithName (const Identifier& type) const
{
return object != nullptr ? object->getChildWithName (type) : ValueTree();
}
ValueTree ValueTree::getOrCreateChildWithName (const Identifier& type, UndoManager* undoManager)
{
return object != nullptr ? object->getOrCreateChildWithName (type, undoManager) : ValueTree();
}
ValueTree ValueTree::getChildWithProperty (const Identifier& propertyName, const var& propertyValue) const
{
return object != nullptr ? object->getChildWithProperty (propertyName, propertyValue) : ValueTree();
}
bool ValueTree::isAChildOf (const ValueTree& possibleParent) const noexcept
{
return object != nullptr && object->isAChildOf (possibleParent.object.get());
}
int ValueTree::indexOf (const ValueTree& child) const noexcept
{
return object != nullptr ? object->indexOf (child) : -1;
}
void ValueTree::addChild (const ValueTree& child, int index, UndoManager* undoManager)
{
jassert (object != nullptr); // Trying to add a child to a null ValueTree!
if (object != nullptr)
object->addChild (child.object.get(), index, undoManager);
}
void ValueTree::appendChild (const ValueTree& child, UndoManager* undoManager)
{
addChild (child, -1, undoManager);
}
void ValueTree::removeChild (int childIndex, UndoManager* undoManager)
{
if (object != nullptr)
object->removeChild (childIndex, undoManager);
}
void ValueTree::removeChild (const ValueTree& child, UndoManager* undoManager)
{
if (object != nullptr)
object->removeChild (object->children.indexOf (child.object), undoManager);
}
void ValueTree::removeAllChildren (UndoManager* undoManager)
{
if (object != nullptr)
object->removeAllChildren (undoManager);
}
void ValueTree::moveChild (int currentIndex, int newIndex, UndoManager* undoManager)
{
if (object != nullptr)
object->moveChild (currentIndex, newIndex, undoManager);
}
//==============================================================================
void ValueTree::createListOfChildren (OwnedArray<ValueTree>& list) const
{
if (object != nullptr)
for (auto* o : object->children)
if (o != nullptr)
list.add (new ValueTree (*o));
}
void ValueTree::reorderChildren (const OwnedArray<ValueTree>& newOrder, UndoManager* undoManager)
{
if (object != nullptr)
object->reorderChildren (newOrder, undoManager);
}
//==============================================================================
void ValueTree::addListener (Listener* listener)
{
if (listener != nullptr)
{
if (listeners.isEmpty() && object != nullptr)
object->valueTreesWithListeners.add (this);
listeners.add (listener);
}
}
void ValueTree::removeListener (Listener* listener)
{
listeners.remove (listener);
if (listeners.isEmpty() && object != nullptr)
object->valueTreesWithListeners.removeValue (this);
}
void ValueTree::sendPropertyChangeMessage (const Identifier& property)
{
if (object != nullptr)
object->sendPropertyChangeMessage (property);
}
//==============================================================================
std::unique_ptr<XmlElement> ValueTree::createXml() const
{
return std::unique_ptr<XmlElement> (object != nullptr ? object->createXml() : nullptr);
}
ValueTree ValueTree::fromXml (const XmlElement& xml)
{
if (! xml.isTextElement())
{
ValueTree v (xml.getTagName());
v.object->properties.setFromXmlAttributes (xml);
for (auto* e : xml.getChildIterator())
v.appendChild (fromXml (*e), nullptr);
return v;
}
// ValueTrees don't have any equivalent to XML text elements!
jassertfalse;
return {};
}
ValueTree ValueTree::fromXml (const String& xmlText)
{
if (auto xml = parseXML (xmlText))
return fromXml (*xml);
return {};
}
String ValueTree::toXmlString (const XmlElement::TextFormat& format) const
{
if (auto xml = createXml())
return xml->toString (format);
return {};
}
//==============================================================================
void ValueTree::writeToStream (OutputStream& output) const
{
SharedObject::writeObjectToStream (output, object.get());
}
ValueTree ValueTree::readFromStream (InputStream& input)
{
auto type = input.readString();
if (type.isEmpty())
return {};
ValueTree v (type);
auto numProps = input.readCompressedInt();
if (numProps < 0)
{
jassertfalse; // trying to read corrupted data!
return v;
}
for (int i = 0; i < numProps; ++i)
{
auto name = input.readString();
if (name.isNotEmpty())
v.object->properties.set (name, var::readFromStream (input));
else
jassertfalse; // trying to read corrupted data!
}
auto numChildren = input.readCompressedInt();
v.object->children.ensureStorageAllocated (numChildren);
for (int i = 0; i < numChildren; ++i)
{
auto child = readFromStream (input);
if (! child.isValid())
return v;
v.object->children.add (child.object);
child.object->parent = v.object.get();
}
return v;
}
ValueTree ValueTree::readFromData (const void* data, size_t numBytes)
{
MemoryInputStream in (data, numBytes, false);
return readFromStream (in);
}
ValueTree ValueTree::readFromGZIPData (const void* data, size_t numBytes)
{
MemoryInputStream in (data, numBytes, false);
GZIPDecompressorInputStream gzipStream (in);
return readFromStream (gzipStream);
}
void ValueTree::Listener::valueTreePropertyChanged (ValueTree&, const Identifier&) {}
void ValueTree::Listener::valueTreeChildAdded (ValueTree&, ValueTree&) {}
void ValueTree::Listener::valueTreeChildRemoved (ValueTree&, ValueTree&, int) {}
void ValueTree::Listener::valueTreeChildOrderChanged (ValueTree&, int, int) {}
void ValueTree::Listener::valueTreeParentChanged (ValueTree&) {}
void ValueTree::Listener::valueTreeRedirected (ValueTree&) {}
//==============================================================================
#if JUCE_ALLOW_STATIC_NULL_VARIABLES
JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")
JUCE_BEGIN_IGNORE_WARNINGS_MSVC (4996)
const ValueTree ValueTree::invalid;
JUCE_END_IGNORE_WARNINGS_GCC_LIKE
JUCE_END_IGNORE_WARNINGS_MSVC
#endif
//==============================================================================
//==============================================================================
#if JUCE_UNIT_TESTS
class ValueTreeTests final : public UnitTest
{
public:
ValueTreeTests()
: UnitTest ("ValueTrees", UnitTestCategories::values)
{}
static String createRandomIdentifier (Random& r)
{
char buffer[50] = { 0 };
const char chars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-:";
for (int i = 1 + r.nextInt (numElementsInArray (buffer) - 2); --i >= 0;)
buffer[i] = chars[r.nextInt (sizeof (chars) - 1)];
String result (buffer);
if (! XmlElement::isValidXmlName (result))
result = createRandomIdentifier (r);
return result;
}
static String createRandomWideCharString (Random& r)
{
juce_wchar buffer[50] = { 0 };
for (int i = r.nextInt (numElementsInArray (buffer) - 1); --i >= 0;)
{
if (r.nextBool())
{
do
{
buffer[i] = (juce_wchar) (1 + r.nextInt (0x10ffff - 1));
}
while (! CharPointer_UTF16::canRepresent (buffer[i]));
}
else
buffer[i] = (juce_wchar) (1 + r.nextInt (0x7e));
}
return CharPointer_UTF32 (buffer);
}
static ValueTree createRandomTree (UndoManager* undoManager, int depth, Random& r)
{
ValueTree v (createRandomIdentifier (r));
for (int i = r.nextInt (10); --i >= 0;)
{
switch (r.nextInt (5))
{
case 0: v.setProperty (createRandomIdentifier (r), createRandomWideCharString (r), undoManager); break;
case 1: v.setProperty (createRandomIdentifier (r), r.nextInt(), undoManager); break;
case 2: if (depth < 5) v.addChild (createRandomTree (undoManager, depth + 1, r), r.nextInt (v.getNumChildren() + 1), undoManager); break;
case 3: v.setProperty (createRandomIdentifier (r), r.nextBool(), undoManager); break;
case 4: v.setProperty (createRandomIdentifier (r), r.nextDouble(), undoManager); break;
default: break;
}
}
return v;
}
void runTest() override
{
{
beginTest ("ValueTree");
auto r = getRandom();
for (int i = 10; --i >= 0;)
{
MemoryOutputStream mo;
auto v1 = createRandomTree (nullptr, 0, r);
v1.writeToStream (mo);
MemoryInputStream mi (mo.getData(), mo.getDataSize(), false);
auto v2 = ValueTree::readFromStream (mi);
expect (v1.isEquivalentTo (v2));
MemoryOutputStream zipped;
{
GZIPCompressorOutputStream zippedOut (zipped);
v1.writeToStream (zippedOut);
}
expect (v1.isEquivalentTo (ValueTree::readFromGZIPData (zipped.getData(), zipped.getDataSize())));
auto xml1 = v1.createXml();
auto xml2 = v2.createCopy().createXml();
expect (xml1->isEquivalentTo (xml2.get(), false));
auto v4 = v2.createCopy();
expect (v1.isEquivalentTo (v4));
}
}
{
beginTest ("Float formatting");
ValueTree testVT ("Test");
Identifier number ("number");
std::map<double, String> tests;
tests[1] = "1.0";
tests[1.1] = "1.1";
tests[1.01] = "1.01";
tests[0.76378] = "0.76378";
tests[-10] = "-10.0";
tests[10.01] = "10.01";
tests[0.0123] = "0.0123";
tests[-3.7e-27] = "-3.7e-27";
tests[1e+40] = "1.0e40";
tests[-12345678901234567.0] = "-1.234567890123457e16";
tests[192000] = "192000.0";
tests[1234567] = "1.234567e6";
tests[0.00006] = "0.00006";
tests[0.000006] = "6.0e-6";
for (auto& test : tests)
{
testVT.setProperty (number, test.first, nullptr);
auto lines = StringArray::fromLines (testVT.toXmlString());
lines.removeEmptyStrings();
auto numLines = lines.size();
expect (numLines > 1);
expectEquals (lines[numLines - 1], "<Test number=\"" + test.second + "\"/>");
}
}
}
};
static ValueTreeTests valueTreeTests;
#endif
} // namespace juce
juce::GZIPDecompressorInputStream
Definition juce_GZIPDecompressorInputStream.h:39
juce::Identifier
Definition juce_Identifier.h:39
juce::Identifier::toString
const String & toString() const noexcept
Definition juce_Identifier.h:102
juce::InputStream
Definition juce_InputStream.h:37
juce::InputStream::readCompressedInt
virtual int readCompressedInt()
Definition juce_InputStream.cpp:108
juce::InputStream::readString
virtual String readString()
Definition juce_InputStream.cpp:182
juce::MemoryInputStream
Definition juce_MemoryInputStream.h:36
juce::NamedValueSet
Definition juce_NamedValueSet.h:35
juce::OutputStream
Definition juce_OutputStream.h:38
juce::OwnedArray
Definition juce_OwnedArray.h:50
juce::OwnedArray::add
ObjectClass * add(ObjectClass *newObject)
Definition juce_OwnedArray.h:293
juce::Random
Definition juce_Random.h:35
juce::Random::nextInt
int nextInt() noexcept
Definition juce_Random.cpp:74
juce::ReferenceCountedObjectPtr::get
ReferencedType * get() const noexcept
Definition juce_ReferenceCountedObject.h:381
juce::ReferenceCountedObject
Definition juce_ReferenceCountedObject.h:66
juce::ReferenceCountedObject::ReferenceCountedObject
ReferenceCountedObject()=default
juce::String
Definition juce_String.h:53
juce::String::isNotEmpty
bool isNotEmpty() const noexcept
Definition juce_String.h:316
juce::UndoManager
Definition juce_UndoManager.h:52
juce::UndoableAction::undo
virtual bool undo()=0
juce::UndoableAction::UndoableAction
UndoableAction()=default
juce::UndoableAction::perform
virtual bool perform()=0
juce::UndoableAction::getSizeInUnits
virtual int getSizeInUnits()
Definition juce_UndoableAction.h:88
juce::UnitTest
Definition juce_UnitTest.h:70
juce::ValueTree::Listener
Definition juce_ValueTree.h:481
juce::ValueTree::Listener::valueTreeRedirected
virtual void valueTreeRedirected(ValueTree &treeWhichHasBeenChanged)
Definition juce_ValueTree.cpp:1102
juce::ValueTree::Listener::valueTreeChildRemoved
virtual void valueTreeChildRemoved(ValueTree &parentTree, ValueTree &childWhichHasBeenRemoved, int indexFromWhichChildWasRemoved)
Definition juce_ValueTree.cpp:1099
juce::ValueTree::Listener::valueTreeChildOrderChanged
virtual void valueTreeChildOrderChanged(ValueTree &parentTreeWhoseChildrenHaveMoved, int oldIndex, int newIndex)
Definition juce_ValueTree.cpp:1100
juce::ValueTree::Listener::valueTreeParentChanged
virtual void valueTreeParentChanged(ValueTree &treeWhoseParentHasChanged)
Definition juce_ValueTree.cpp:1101
juce::ValueTree::Listener::valueTreePropertyChanged
virtual void valueTreePropertyChanged(ValueTree &treeWhosePropertyHasChanged, const Identifier &property)
Definition juce_ValueTree.cpp:1097
juce::ValueTree::Listener::valueTreeChildAdded
virtual void valueTreeChildAdded(ValueTree &parentTree, ValueTree &childWhichHasBeenAdded)
Definition juce_ValueTree.cpp:1098
juce::ValueTree
Definition juce_ValueTree.h:72
juce::ValueTree::getPropertyAsValue
Value getPropertyAsValue(const Identifier &name, UndoManager *undoManager, bool shouldUpdateSynchronously=false)
Definition juce_ValueTree.cpp:849
juce::ValueTree::getPropertyName
Identifier getPropertyName(int index) const noexcept
Definition juce_ValueTree.cpp:800
juce::ValueTree::begin
Iterator begin() const noexcept
Definition juce_ValueTree.cpp:888
juce::ValueTree::operator!=
bool operator!=(const ValueTree &) const noexcept
Definition juce_ValueTree.cpp:648
juce::ValueTree::createXml
std::unique_ptr< XmlElement > createXml() const
Definition juce_ValueTree.cpp:995
juce::ValueTree::hasType
bool hasType(const Identifier &typeName) const noexcept
Definition juce_ValueTree.cpp:696
juce::ValueTree::readFromStream
static ValueTree readFromStream(InputStream &input)
Definition juce_ValueTree.cpp:1040
juce::ValueTree::removeChild
void removeChild(const ValueTree &child, UndoManager *undoManager)
Definition juce_ValueTree.cpp:935
juce::ValueTree::toXmlString
String toXmlString(const XmlElement::TextFormat &format={}) const
Definition juce_ValueTree.cpp:1026
juce::ValueTree::readFromGZIPData
static ValueTree readFromGZIPData(const void *data, size_t numBytes)
Definition juce_ValueTree.cpp:1090
juce::ValueTree::getChild
ValueTree getChild(int index) const
Definition juce_ValueTree.cpp:860
juce::ValueTree::getNumProperties
int getNumProperties() const noexcept
Definition juce_ValueTree.cpp:795
juce::ValueTree::getNumChildren
int getNumChildren() const noexcept
Definition juce_ValueTree.cpp:855
juce::ValueTree::copyPropertiesFrom
void copyPropertiesFrom(const ValueTree &source, UndoManager *undoManager)
Definition juce_ValueTree.cpp:668
juce::ValueTree::~ValueTree
~ValueTree()
Definition juce_ValueTree.cpp:637
juce::ValueTree::getReferenceCount
int getReferenceCount() const noexcept
Definition juce_ValueTree.cpp:806
juce::ValueTree::getPropertyPointer
const var * getPropertyPointer(const Identifier &name) const noexcept
Definition juce_ValueTree.cpp:755
juce::ValueTree::setProperty
ValueTree & setProperty(const Identifier &name, const var &newValue, UndoManager *undoManager)
Definition juce_ValueTree.cpp:761
juce::ValueTree::removeAllChildren
void removeAllChildren(UndoManager *undoManager)
Definition juce_ValueTree.cpp:941
juce::ValueTree::isAChildOf
bool isAChildOf(const ValueTree &possibleParent) const noexcept
Definition juce_ValueTree.cpp:906
juce::ValueTree::removeAllProperties
void removeAllProperties(UndoManager *undoManager)
Definition juce_ValueTree.cpp:789
juce::ValueTree::addListener
void addListener(Listener *listener)
Definition juce_ValueTree.cpp:969
juce::ValueTree::appendChild
void appendChild(const ValueTree &child, UndoManager *undoManager)
Definition juce_ValueTree.cpp:924
juce::ValueTree::indexOf
int indexOf(const ValueTree &child) const noexcept
Definition juce_ValueTree.cpp:911
juce::ValueTree::operator==
bool operator==(const ValueTree &) const noexcept
Definition juce_ValueTree.cpp:643
juce::ValueTree::setPropertyExcludingListener
ValueTree & setPropertyExcludingListener(Listener *listenerToExclude, const Identifier &name, const var &newValue, UndoManager *undoManager)
Definition juce_ValueTree.cpp:766
juce::ValueTree::addChild
void addChild(const ValueTree &child, int index, UndoManager *undoManager)
Definition juce_ValueTree.cpp:916
juce::ValueTree::getParent
ValueTree getParent() const noexcept
Definition juce_ValueTree.cpp:706
juce::ValueTree::getProperty
const var & getProperty(const Identifier &name) const noexcept
Definition juce_ValueTree.cpp:744
juce::ValueTree::ValueTree
ValueTree() noexcept
Definition juce_ValueTree.cpp:578
juce::ValueTree::fromXml
static ValueTree fromXml(const XmlElement &xml)
Definition juce_ValueTree.cpp:1000
juce::ValueTree::createCopy
ValueTree createCopy() const
Definition juce_ValueTree.cpp:660
juce::ValueTree::getType
Identifier getType() const noexcept
Definition juce_ValueTree.cpp:701
juce::ValueTree::getChildWithName
ValueTree getChildWithName(const Identifier &type) const
Definition juce_ValueTree.cpp:891
juce::ValueTree::end
Iterator end() const noexcept
Definition juce_ValueTree.cpp:889
juce::ValueTree::operator=
ValueTree & operator=(const ValueTree &)
Definition juce_ValueTree.cpp:605
juce::ValueTree::removeListener
void removeListener(Listener *listener)
Definition juce_ValueTree.cpp:980
juce::ValueTree::writeToStream
void writeToStream(OutputStream &output) const
Definition juce_ValueTree.cpp:1035
juce::ValueTree::isEquivalentTo
bool isEquivalentTo(const ValueTree &) const
Definition juce_ValueTree.cpp:653
juce::ValueTree::getOrCreateChildWithName
ValueTree getOrCreateChildWithName(const Identifier &type, UndoManager *undoManager)
Definition juce_ValueTree.cpp:896
juce::ValueTree::moveChild
void moveChild(int currentIndex, int newIndex, UndoManager *undoManager)
Definition juce_ValueTree.cpp:947
juce::ValueTree::sendPropertyChangeMessage
void sendPropertyChangeMessage(const Identifier &property)
Definition juce_ValueTree.cpp:988
juce::ValueTree::removeProperty
void removeProperty(const Identifier &name, UndoManager *undoManager)
Definition juce_ValueTree.cpp:783
juce::ValueTree::operator[]
const var & operator[](const Identifier &name) const noexcept
Definition juce_ValueTree.cpp:739
juce::ValueTree::getSibling
ValueTree getSibling(int delta) const noexcept
Definition juce_ValueTree.cpp:723
juce::ValueTree::getChildWithProperty
ValueTree getChildWithProperty(const Identifier &propertyName, const var &propertyValue) const
Definition juce_ValueTree.cpp:901
juce::ValueTree::copyPropertiesAndChildrenFrom
void copyPropertiesAndChildrenFrom(const ValueTree &source, UndoManager *undoManager)
Definition juce_ValueTree.cpp:681
juce::ValueTree::getRoot
ValueTree getRoot() const noexcept
Definition juce_ValueTree.cpp:715
juce::ValueTree::readFromData
static ValueTree readFromData(const void *data, size_t numBytes)
Definition juce_ValueTree.cpp:1084
juce::ValueTree::hasProperty
bool hasProperty(const Identifier &name) const noexcept
Definition juce_ValueTree.cpp:778
juce::Value::ValueSource
Definition juce_Value.h:180
juce::Value::ValueSource::getValue
virtual var getValue() const =0
juce::Value::ValueSource::sendChangeMessage
void sendChangeMessage(bool dispatchSynchronously)
Definition juce_Value.cpp:43
juce::Value
Definition juce_Value.h:51
juce::XmlElement
Definition juce_XmlElement.h:83
juce::XmlElement::isTextElement
bool isTextElement() const noexcept
Definition juce_XmlElement.cpp:904
juce::XmlElement::getChildIterator
Iterator< GetNextElement > getChildIterator() const
Definition juce_XmlElement.h:715
juce::XmlElement::getTagName
const String & getTagName() const noexcept
Definition juce_XmlElement.h:173
juce::var
Definition juce_Variant.h:42
juce::var::readFromStream
static var readFromStream(InputStream &input)
Definition juce_Variant.cpp:826
juce::ValueTree::Iterator
Definition juce_ValueTree.h:403
juce::XmlElement::TextFormat
Definition juce_XmlElement.h:136