Specs: Move default layout manager stuff from default styles to getLayoutManager()

sky/specs/style.md

 Sky Style Language
 ==================
 
 Planed changes
 --------------
 
 Add //-to-end-of-line comments to be consistent with the script
 language.
 
 
@@ skipping 215 matching lines @@
  +-- AbstractStyleValue
      |   
      +-- NumericStyleValue
      |    |
      |    +-- AnimatableNumericStyleValue*
      |   
      +-- LengthStyleValue
      |    |
      |    +-- AnimatableLengthStyleValue*
      |    |
+     |    +-- TransitionLengthStyleValue*
+     |    |
      |    +-- PixelLengthStyleValue
      |    |
      |    +-- EmLengthStyleValue*
      |    |
      |    +-- VHLengthStyleValue*
      |    |
      |    +-- CalcLengthStyleValue*
      |    
      +-- ColorStyleValue
      |    |
@@ skipping 14 matching lines @@
      |    +-- StringStyleValue*
      |    |    |
      |    |    +-- AnimatableStringStyleValue*
      |    |    
      |    +-- ObjectStyleValue
      |    
      +-- PrimitiveValuesListStyleValue*
 */
 ```
 
-The types marked with * in the list above are not part of sky:core.
+The types marked with * in the list above are not part of sky:core,
+and are only shown here to illustrate what kinds of extensions are
+possible and where they would fit.
 
 TODO(ianh): consider removing 'StyleValue' from these class names
 
 ```javascript
 abstract class StyleNode {
   abstract void markDirty();
 }
 
 dictionary StyleValueResolverSettingsSettings {
   Boolean firstTime = false;
   any state = null;
 }
 
 class StyleValueResolverSettings {
   // this is used as an "out" parameter for 'resolve()' below
   constructor(StyleValueResolverSettingsSettings initial);
   void reset(StyleValueResolverSettingsSettings initial);
     // sets firstTime and state to given values
     // sets layoutDependent to false
     // sets dependencies to empty set
 
   readonly attribute Boolean firstTime;
     // true if this is the first time this property is being resolved for this element,
     // or if the last time it was resolved, the value was a different object
 
-  attribute Boolean layoutDependent; // default to false
-    // set this if the value should be recomputed each time the ownerLayoutManager's dimensions change, rather than being cached
+  // attribute Boolean layoutDependent
+  void setLayoutDependent();
+    // call this if the value should be recomputed each time the ownerLayoutManager's dimensions change, rather than being cached
+  Boolean getLayoutDependent();
+    // returns true if setLayoutDependent has been called since the last reset()
 
   // attribute "BitField" dependencies; // defaults to no bits set
   void dependsOn(PropertyHandle property);
     // if the given property doesn't have a dependency bit assigned:
     //  - assign the next bit to the property
     //  - if there's no bits left, throw
     // set the bit on this StyleValueResolverSettings's dependencies bitfield
   Array<PropertyHandle> getDependencies();
     // returns an array of the PropertyHandle values for the bits that are set in dependencies
 
   attribute any state; // initially null, can be set to store value for this RenderNode/property pair
     // for example, TransitioningColorStyleValue would store
     //    {
     //      initial: /* color at time of transition */,
     //      target: /* color at end of transition */,
     //      start: /* time at start of transition */,
     //    }
     // ...which would enable it to update appropriately, and would also
     // let other transitions that come later know that you were half-way
     // through a transition so they can shorten their time accordingly
+    //
+    // best practices: if you're a style value that contains multiple
+    // style values, then before you call their resolve you should
+    // replace the state with a state that is specific to them, and
+    // when you get it back you should insert that value into your
+    // state somehow. For example, in a resolve()r with two child
+    // style values a and b:
+    //    let ourState;
+    //    if (settings.firstTime)
+    //      ourState = { a: null, b: null };
+    //    else
+    //      ourState = settings.state;
+    //    settings.state = ourState.a;
+    //    let aResult = a.resolve(node, settings);
+    //    ourState.a = settings.state;
+    //    settings.state = ourState.b;
+    //    let aResult = b.resolve(node, settings);
+    //    ourState.b = settings.state;
+    //    settings.state = ourState;
+    //    return a + b; // or whatever
 }
 
 class Property : StyleNode {
   constructor (AbstractStyleDeclaration parentNode, PropertyHandle property, AbstractStyleValue? initialValue = null);
   readonly attribute AbstractStyleDeclaration parentNode;
   readonly attribute PropertyHandle property;
   readonly attribute AbstractStyleValue value;
 
   void setValue(AbstractStyleValue? newValue);
     // updates value and calls markDirty()
@@ skipping 610 matching lines @@
 can call them from their paint() functions.
 
 
 
 Default Styles
 --------------
 
 In the constructors for the default elements, they add to themselves
 StyleDeclaration objects as follows:
 
-* ``import``
-* ``template``
-* ``style``
-* ``script``
-* ``content``
-* ``title``
-  These all add to themselves the same declaration as follows:
-```javascript
-let d = new StyleDeclaration();
-d[pDisplay] = new ObjectStyleValue(null);
-this.style.addStyles(d);
-```
-
-* ``img``
-  This adds to itself the declaration as follows:
-```javascript
-let d = new StyleDeclaration();
-d[pDisplay] = new ObjectStyleValue(ImageElementLayoutManager);
-this.style.addStyles(d);
-```
-
 * ``span``
 * ``a``
   These all add to themselves the same declaration as follows:
 ```javascript
 let d = new StyleDeclaration();
 d[pDisplay] = new ObjectStyleValue(InlineLayoutManager);
 this.style.addStyles(d);
 ```
 
-* ``iframe``
-  This adds to itself the declaration as follows:
-```javascript
-let d = new StyleDeclaration();
-d[pDisplay] = new ObjectStyleValue(IFrameElementLayoutManager);
-this.style.addStyles(d);
-```
-
 * ``t``
   This adds to itself the declaration as follows:
 ```javascript
 let d = new StyleDeclaration();
 d[pDisplay] = new ObjectStyleValue(ParagraphLayoutManager);
 this.style.addStyles(d);
 ```
 
-* ``error``
-  This adds to itself the declaration as follows:
-```javascript
-let d = new StyleDeclaration();
-d[pDisplay] = new ObjectStyleValue(ErrorLayoutManager);
-this.style.addStyles(d);
-```
-
-The ``div`` element doesn't have any default styles.
+The other elements doe'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``
+you reach in and change the declaration that was added to a ``span``
 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.)