mirror/JUCE
1
0
Fork 0
mirror of https://github.com/juce-framework/JUCE.git synced 2026-01-10 23:44:24 +00:00
Code Activity

Tidied up some ValueTree code.

Browse source
This commit is contained in:
jules 2013-09-19 11:21:46 +01:00
parent 085e453f10
commit 6cd2f43afa
4 changed files with 38 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

10
modules/juce_audio_basics/midi/juce_MidiFile.h
View file

@ -52,28 +52,23 @@ public:
//==============================================================================
/** Returns the number of tracks in the file.
@see getTrack, addTrack
*/
int getNumTracks() const noexcept;
/** Returns a pointer to one of the tracks in the file.
@returns a pointer to the track, or nullptr if the index is out-of-range
@see getNumTracks, addTrack
*/
const MidiMessageSequence* getTrack (int index) const noexcept;
/** Adds a midi track to the file.
This will make its own internal copy of the sequence that is passed-in.
@see getNumTracks, getTrack
*/
void addTrack (const MidiMessageSequence& trackSequence);
/** Removes all midi tracks from the file.
@see getNumTracks
*/
void clear();
@ -156,7 +151,6 @@ public:
bool readFrom (InputStream& sourceStream);
/** Writes the midi tracks as a standard midi file.
@returns true if the operation succeeded.
*/
bool writeTo (OutputStream& destStream);
@ -174,8 +168,8 @@ private:
OwnedArray<MidiMessageSequence> tracks;
short timeFormat;
void readNextTrack (const uint8* data, int size);
void writeTrack (OutputStream& mainOut, int trackNum);
void readNextTrack (const uint8*, int size);
void writeTrack (OutputStream&, int trackNum);
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MidiFile)
};

86
modules/juce_data_structures/values/juce_ValueTree.cpp
View file

@ -27,7 +27,7 @@ class ValueTree::SharedObject : public ReferenceCountedObject
public:
typedef ReferenceCountedObjectPtr<SharedObject> Ptr;
explicit SharedObject (const Identifier t) noexcept
explicit SharedObject (Identifier t) noexcept
: type (t), parent (nullptr)
{
}
@ -57,11 +57,20 @@ public:
}
}
void sendPropertyChangeMessage (ValueTree& tree, const Identifier property)
template <typename Method>
void callListeners (Method method, ValueTree& tree)
{
for (int i = valueTreesWithListeners.size(); --i >= 0;)
if (ValueTree* const v = valueTreesWithListeners[i])
v->listeners.call (&ValueTree::Listener::valueTreePropertyChanged, tree, property);
v->listeners.call (method, tree);
}
template <typename Method, typename ParamType>
void callListeners (Method method, ValueTree& tree, ParamType& param2)
{
for (int i = valueTreesWithListeners.size(); --i >= 0;)
if (ValueTree* const v = valueTreesWithListeners[i])
v->listeners.call (method, tree, param2);
}
void sendPropertyChangeMessage (const Identifier property)
@ -69,14 +78,7 @@ public:
ValueTree tree (this);
for (ValueTree::SharedObject* t = this; t != nullptr; t = t->parent)
t->sendPropertyChangeMessage (tree, property);
}
void sendChildAddedMessage (ValueTree& tree, ValueTree& child)
{
for (int i = valueTreesWithListeners.size(); --i >= 0;)
if (ValueTree* const v = valueTreesWithListeners[i])
v->listeners.call (&ValueTree::Listener::valueTreeChildAdded, tree, child);
t->callListeners (&ValueTree::Listener::valueTreePropertyChanged, tree, property);
}
void sendChildAddedMessage (ValueTree child)
@ -84,14 +86,7 @@ public:
ValueTree tree (this);
for (ValueTree::SharedObject* t = this; t != nullptr; t = t->parent)
t->sendChildAddedMessage (tree, child);
}
void sendChildRemovedMessage (ValueTree& tree, ValueTree& child)
{
for (int i = valueTreesWithListeners.size(); --i >= 0;)
if (ValueTree* const v = valueTreesWithListeners[i])
v->listeners.call (&ValueTree::Listener::valueTreeChildRemoved, tree, child);
t->callListeners (&ValueTree::Listener::valueTreeChildAdded, tree, child);
}
void sendChildRemovedMessage (ValueTree child)
@ -99,14 +94,7 @@ public:
ValueTree tree (this);
for (ValueTree::SharedObject* t = this; t != nullptr; t = t->parent)
t->sendChildRemovedMessage (tree, child);
}
void sendChildOrderChangedMessage (ValueTree& tree)
{
for (int i = valueTreesWithListeners.size(); --i >= 0;)
if (ValueTree* const v = valueTreesWithListeners[i])
v->listeners.call (&ValueTree::Listener::valueTreeChildOrderChanged, tree);
t->callListeners (&ValueTree::Listener::valueTreeChildRemoved, tree, child);
}
void sendChildOrderChangedMessage()
@ -114,7 +102,7 @@ public:
ValueTree tree (this);
for (ValueTree::SharedObject* t = this; t != nullptr; t = t->parent)
t->sendChildOrderChangedMessage (tree);
t->callListeners (&ValueTree::Listener::valueTreeChildOrderChanged, tree);
}
void sendParentChangeMessage()
@ -125,19 +113,7 @@ public:
if (SharedObject* const child = children.getObjectPointer (j))
child->sendParentChangeMessage();
for (int i = valueTreesWithListeners.size(); --i >= 0;)
if (ValueTree* const v = valueTreesWithListeners[i])
v->listeners.call (&ValueTree::Listener::valueTreeParentChanged, tree);
}
const var& getProperty (const Identifier name) const noexcept
{
return properties [name];
}
var getProperty (const Identifier name, const var& defaultReturnValue) const
{
return properties.getWithDefault (name, defaultReturnValue);
callListeners (&ValueTree::Listener::valueTreeParentChanged, tree);
}
void setProperty (const Identifier name, const var& newValue, UndoManager* const undoManager)
@ -241,7 +217,7 @@ public:
for (int i = 0; i < children.size(); ++i)
{
SharedObject* const s = children.getObjectPointerUnchecked (i);
if (s->getProperty (propertyName) == propertyValue)
if (s->properties[propertyName] == propertyValue)
return ValueTree (s);
}
@ -305,9 +281,7 @@ public:
void removeChild (const int childIndex, UndoManager* const undoManager)
{
const Ptr child (children.getObjectPointer (childIndex));
if (child != nullptr)
if (const Ptr child = children.getObjectPointer (childIndex))
{
if (undoManager == nullptr)
{
@ -615,19 +589,16 @@ ValueTree::ValueTree() noexcept
const ValueTree ValueTree::invalid;
ValueTree::ValueTree (const Identifier type_)
: object (new ValueTree::SharedObject (type_))
ValueTree::ValueTree (Identifier type) : object (new ValueTree::SharedObject (type))
{
jassert (type_.toString().isNotEmpty()); // All objects should be given a sensible type name!
jassert (type.toString().isNotEmpty()); // All objects must be given a sensible type name!
}
ValueTree::ValueTree (SharedObject* const object_)
: object (object_)
ValueTree::ValueTree (SharedObject* so) : object (so)
{
}
ValueTree::ValueTree (const ValueTree& other)
: object (other.object)
ValueTree::ValueTree (const ValueTree& other) : object (other.object)
{
}
@ -710,18 +681,18 @@ ValueTree ValueTree::getSibling (const int delta) const
const var& ValueTree::operator[] (const Identifier name) const
{
return object == nullptr ? var::null : object->getProperty (name);
return object == nullptr ? var::null : object->properties[name];
}
const var& ValueTree::getProperty (const Identifier name) const
{
return object == nullptr ? var::null : object->getProperty (name);
return object == nullptr ? var::null : object->properties[name];
}
var ValueTree::getProperty (const Identifier name, const var& defaultReturnValue) const
{
return object == nullptr ? defaultReturnValue
: object->getProperty (name, defaultReturnValue);
: object->properties.getWithDefault (name, defaultReturnValue);
}
ValueTree& ValueTree::setProperty (const Identifier name, const var& newValue,
@ -798,10 +769,9 @@ private:
const Identifier property;
UndoManager* const undoManager;
void valueTreePropertyChanged (ValueTree& treeWhosePropertyHasChanged,
const Identifier& changedProperty) override
void valueTreePropertyChanged (ValueTree& changedTree, const Identifier& changedProperty) override
{
if (tree == treeWhosePropertyHasChanged && property == changedProperty)
if (tree == changedTree && property == changedProperty)
sendChangeMessage (false);
}

14
modules/juce_data_structures/values/juce_ValueTree.h
View file

@ -79,16 +79,16 @@ public:
Like an XmlElement, each ValueTree node has a type, which you can access with
getType() and hasType().
*/
explicit ValueTree (const Identifier type);
explicit ValueTree (Identifier type);
/** Creates a reference to another ValueTree. */
ValueTree (const ValueTree& other);
ValueTree (const ValueTree&);
/** Makes this object reference another node. */
ValueTree& operator= (const ValueTree& other);
ValueTree& operator= (const ValueTree&);
#if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS
ValueTree (ValueTree&& other) noexcept;
ValueTree (ValueTree&&) noexcept;
#endif
/** Destructor. */
@ -98,13 +98,13 @@ public:
Note that this isn't a value comparison - two independently-created trees which
contain identical data are not considered equal.
*/
bool operator== (const ValueTree& other) const noexcept;
bool operator== (const ValueTree&) const noexcept;
/** Returns true if this and the other node refer to different underlying structures.
Note that this isn't a value comparison - two independently-created trees which
contain identical data are not considered equal.
*/
bool operator!= (const ValueTree& other) const noexcept;
bool operator!= (const ValueTree&) const noexcept;
/** Performs a deep comparison between the properties and children of two trees.
If all the properties and children of the two trees are the same (recursively), this
@ -112,7 +112,7 @@ public:
The normal operator==() only checks whether two trees refer to the same shared data
structure, so use this method if you need to do a proper value comparison.
*/
bool isEquivalentTo (const ValueTree& other) const;
bool isEquivalentTo (const ValueTree&) const;
//==============================================================================
/** Returns true if this node refers to some valid data.

2
modules/juce_events/broadcasters/juce_ListenerList.h
View file

@ -65,7 +65,7 @@
ListenerList::DummyBailOutChecker, which is a dummy checker that always returns false.
*/
template <class ListenerClass,
class ArrayType = Array <ListenerClass*> >
class ArrayType = Array<ListenerClass*> >
class ListenerList
{
// Horrible macros required to support VC7..