Specs: Change from the every-frame-walk for animations on dead nodes to just relying on actual anim…

sky/specs/style.md

 Sky Style Language
 ==================
 
 Planed changes
 --------------
 
 Add //-to-end-of-line comments to be consistent with the script
 language.
 
 
@@ skipping 478 matching lines @@
 
 
 Cascade
 -------
 
 Simultaneously walk the tree rooted at the application Document,
 taking into account shadow trees and child distribution, and the tree
 rooted at the document's RenderNode.
 
 If you come across a node that doesn't have an assigned RenderNode,
-then create one and mark it "isNew", and place it in the appropriate
-place in the RenderTree tree, after any nodes marked isGhost.
+then create one, placing it in the appropriate place in the RenderTree
+tree, after any nodes marked isGhost=true, with ownerLayoutManager
+pointing to the parent RenderNode's layoutManager, and then, if
+autoreap is false on the ownerLayoutManager, mark it "isNew".
 
 For each element, if the node's needsManager is true, call
 getLayoutManager() on the element, and if that's not null, and if the
 returned class isn't the same class as the current layoutManager, if
 any, construct the given class and assign it to the RenderNode's
 layoutManager, then set all the child RenderNodes' ownerLayoutManager
 to that object; if it returns null, and that node already has a
 layoutManager, then set isGhost=true for that node and all its
 children (without changing the layoutManager). Otherwise, if it
 returned null and there's already no layoutManager, remove the node
 from the tree. Then, in any case, clear the needsManager bit.
 
 When an Element or Text node is to be removed from its parent, and it
 has a renderNode, and that renderNode has an ownerLayoutManager with
 autoreap=false, then before actually removing the node, the node's
 renderNode should be marked isGhost=true, and the relevant
 ElementStyleDeclarationList should be flattened and the values stored on
 the RenderNode's overrideStyles for use later. (Or we can just clone the
 StyleDeclarations directly without flattening. That would probably
 be faster.)
 
 When an Element is to be removed from its parent, regardless of the
 above, the node's renderNode attribute should be nulled out.
 
+When a RenderNode is added with isNew=true, call its parent
+RenderNode's LayoutManager's childAdded() callback. When a a
+RenderNode has its isGhost property set to true, then call it's parent
+RenderNode's LayoutManager's childRemoved() callback.
+
 
 ```javascript
 callback any ValueResolver (any value, String propertyName, RenderNode node, Float containerWidth, Float containerHeight);
 
 class RenderNode { // implemented in C++ with no virtual tables
   // this is generated before layout
   readonly attribute String text;
   readonly attribute Node? parentNode;
   readonly attribute Node? firstChild;
   readonly attribute Node? nextSibling;
@@ skipping 126 matching lines @@
     // replaces the value that getProperty() would return on that node with /value/
 
   void take(RenderNode victim); // sets victim.ownerLayoutManager = this;
     // assert: victim hasn't been take()n yet during this layout
     // assert: victim.needsLayout == true
     // assert: an ancestor of victim has node.layoutManager == this (aka, victim is a descendant of this.node)
 
   virtual void release(RenderNode victim);
     // called when the RenderNode was removed from the tree
 
+  virtual void childAdded(RenderNode child);
+  virtual void childRemoved(RenderNode child);
+    // called when a child has its isNew or isGhost attributes set respectively
+
   void setChildPosition(child, x, y); // sets child.x, child.y
   void setChildX(child, y); // sets child.x
   void setChildY(child, y); // sets child.y
   void setChildSize(child, width, height); // sets child.width, child.height
   void setChildWidth(child, width); // sets child.width
   void setChildHeight(child, height); // sets child.height
     // for setChildSize/Width/Height: if the new dimension is different than the last assumed dimensions, and
     // any RenderNodes with an ownerLayoutManager==this have cached values for getProperty() that are marked
     // as layout-dependent, clear them
   void welcomeChild(child); // resets child.isNew
@@ skipping 230 matching lines @@
 ```
 
 The ``div`` element doesn't have any default styles.
 
 These declarations are all shared between all the elements (so e.g. if
 you reach in and change the declaration that was added to a ``title``
 element, you're going to change the styles of all the other
 default-hidden elements). (In other words, in the code snippets above,
 the ``d`` variable is initialised in shared code, and only the
 addStyles() call is per-element.)