diff --git a/src/containers/juce_ValueTree.cpp b/src/containers/juce_ValueTree.cpp
index e69a57ddb6..13ca7d806c 100644
--- a/src/containers/juce_ValueTree.cpp
+++ b/src/containers/juce_ValueTree.cpp
@@ -70,7 +70,7 @@ public:
 
     int getSizeInUnits()
     {
-        return 32; //xxx should be more accurate
+        return (int) sizeof (*this); //xxx should be more accurate
     }
 
 private:
@@ -122,7 +122,7 @@ public:
 
     int getSizeInUnits()
     {
-        return 32; //xxx should be more accurate
+        return (int) sizeof (*this); //xxx should be more accurate
     }
 
 private:
@@ -174,64 +174,84 @@ ValueTree::SharedObject::Property::Property (const var::identifier& name_, const
 }
 
 //==============================================================================
-void ValueTree::deliverPropertyChangeMessage (const var::identifier& property)
+void ValueTree::deliverPropertyChangeMessage (ValueTree& tree, const var::identifier& property)
 {
-    ValueTree v (object);
-
     for (int i = listeners.size(); --i >= 0;)
     {
         ValueTree::Listener* const l = listeners[i];
         if (l != 0)
-            l->valueTreePropertyChanged (v, property);
+            l->valueTreePropertyChanged (tree, property);
     }
 }
 
-void ValueTree::SharedObject::sendPropertyChangeMessage (const var::identifier& property)
+void ValueTree::SharedObject::sendPropertyChangeMessage (ValueTree& tree, const var::identifier& property)
 {
     for (int i = valueTreesWithListeners.size(); --i >= 0;)
     {
         ValueTree* const v = valueTreesWithListeners[i];
         if (v != 0)
-            v->deliverPropertyChangeMessage (property);
+            v->deliverPropertyChangeMessage (tree, property);
     }
 }
 
-void ValueTree::deliverChildChangeMessage()
+void ValueTree::SharedObject::sendPropertyChangeMessage (const var::identifier& property)
 {
-    ValueTree v (object);
+    ValueTree tree (this);
+    ValueTree::SharedObject* t = this;
+
+    while (t != 0)
+    {
+        t->sendPropertyChangeMessage (tree, property);
+        t = t->parent;
+    }
+}
 
+void ValueTree::deliverChildChangeMessage (ValueTree& tree)
+{
     for (int i = listeners.size(); --i >= 0;)
     {
         ValueTree::Listener* const l = listeners[i];
         if (l != 0)
-            l->valueTreeChildrenChanged (v);
+            l->valueTreeChildrenChanged (tree);
     }
 }
 
-void ValueTree::SharedObject::sendChildChangeMessage()
+void ValueTree::SharedObject::sendChildChangeMessage (ValueTree& tree)
 {
     for (int i = valueTreesWithListeners.size(); --i >= 0;)
     {
         ValueTree* const v = valueTreesWithListeners[i];
         if (v != 0)
-            v->deliverChildChangeMessage();
+            v->deliverChildChangeMessage (tree);
     }
 }
 
-void ValueTree::deliverParentChangeMessage()
+void ValueTree::SharedObject::sendChildChangeMessage()
 {
-    ValueTree v (object);
+    ValueTree tree (this);
+    ValueTree::SharedObject* t = this;
+
+    while (t != 0)
+    {
+        t->sendChildChangeMessage (tree);
+        t = t->parent;
+    }
+}
 
+void ValueTree::deliverParentChangeMessage (ValueTree& tree)
+{
     for (int i = listeners.size(); --i >= 0;)
     {
         ValueTree::Listener* const l = listeners[i];
         if (l != 0)
-            l->valueTreeParentChanged (v);
+            l->valueTreeParentChanged (tree);
     }
 }
 
 void ValueTree::SharedObject::sendParentChangeMessage()
 {
+    ValueTree tree (this);
+
     int i;
     for (i = children.size(); --i >= 0;)
     {
@@ -244,7 +264,7 @@ void ValueTree::SharedObject::sendParentChangeMessage()
     {
         ValueTree* const v = valueTreesWithListeners[i];
         if (v != 0)
-            v->deliverParentChangeMessage();
+            v->deliverParentChangeMessage (tree);
     }
 }
 
@@ -590,9 +610,9 @@ public:
         tree.setProperty (property, newValue, undoManager);
     }
 
-    void valueTreePropertyChanged (ValueTree& tree, const var::identifier& changedProperty)
+    void valueTreePropertyChanged (ValueTree& treeWhosePropertyHasChanged, const var::identifier& changedProperty)
     {
-        if (property == changedProperty)
+        if (tree == treeWhosePropertyHasChanged && property == changedProperty)
             sendChangeMessage (false);
     }
 
diff --git a/src/containers/juce_ValueTree.h b/src/containers/juce_ValueTree.h
index 4b60b035f0..38b862524b 100644
--- a/src/containers/juce_ValueTree.h
+++ b/src/containers/juce_ValueTree.h
@@ -287,14 +287,38 @@ public:
         /** Destructor. */
         virtual ~Listener() {}
 
-        /** This method is called when one of the properties of this node has been changed. */
-        virtual void valueTreePropertyChanged (ValueTree& tree, const var::identifier& property) = 0;
-
-        /** This method is called when one or more of the children of this node have been added or removed. */
-        virtual void valueTreeChildrenChanged (ValueTree& tree) = 0;
-
-        /** This method is called when this node has been added or removed from a parent node. */
-        virtual void valueTreeParentChanged (ValueTree& tree) = 0;
+        /** This method is called when a property of this node (or of one of its sub-nodes) has
+            changed.
+
+            The tree parameter indicates which tree has had its property changed, and the property
+            parameter indicates the property.
+
+            Note that when you register a listener to a tree, it will receive this callback for
+            property changes in that tree, and also for any of its children, (recursively, at any depth).
+            If your tree has sub-trees but you only want to know about changes to the top level tree,
+            simply check the tree parameter in this callback to make sure it's the tree you're interested in.
+        */
+        virtual void valueTreePropertyChanged (ValueTree& treeWhosePropertyHasChanged,
+                                               const var::identifier& property) = 0;
+
+        /** This method is called when a child sub-tree is added or removed.
+
+            The tree parameter indicates the tree whose child was added or removed.
+
+            Note that when you register a listener to a tree, it will receive this callback for
+            child changes in that tree, and also in any of its children, (recursively, at any depth).
+            If your tree has sub-trees but you only want to know about changes to the top level tree,
+            simply check the tree parameter in this callback to make sure it's the tree you're interested in.
+        */
+        virtual void valueTreeChildrenChanged (ValueTree& treeWhoseChildHasChanged) = 0;
+
+        /** This method is called when a tree has been added or removed from a parent node.
+
+            This callback happens when the tree to which the listener was registered is added or
+            removed from a parent. Unlike the other callbacks, it applies only to the tree to which
+            the listener is registered, and not to any of its children.
+        */
+        virtual void valueTreeParentChanged (ValueTree& treeWhoseParentHasChanged) = 0;
     };
 
     /** Adds a listener to receive callbacks when this node is changed.
@@ -345,7 +369,9 @@ private:
         SharedObject* parent;
 
         void sendPropertyChangeMessage (const var::identifier& property);
+        void sendPropertyChangeMessage (ValueTree& tree, const var::identifier& property);
         void sendChildChangeMessage();
+        void sendChildChangeMessage (ValueTree& tree);
         void sendParentChangeMessage();
         const var getProperty (const var::identifier& name) const;
         void setProperty (const var::identifier& name, const var& newValue, UndoManager* const undoManager);
@@ -373,9 +399,9 @@ private:
     ReferenceCountedObjectPtr <SharedObject> object;
     SortedSet <Listener*> listeners;
 
-    void deliverPropertyChangeMessage (const var::identifier& property);
-    void deliverChildChangeMessage();
-    void deliverParentChangeMessage();
+    void deliverPropertyChangeMessage (ValueTree& tree, const var::identifier& property);
+    void deliverChildChangeMessage (ValueTree& tree);
+    void deliverParentChangeMessage (ValueTree& tree);
 
     ValueTree (SharedObject* const object_);
 };