Make hit testing work in layout2.dart

sky/sdk/lib/framework/layout2.dart

 library layout;
 
 // This version of layout.dart is an update to the other one, this one using new APIs.
 // It will not work in a stock Sky setup currently.
 
 import 'node.dart';
 
 import 'dart:sky' as sky;
 
 // ABSTRACT LAYOUT
@@ skipping 200 matching lines @@
 
   void rotate({
     int oldAngle, // 0..3
     int newAngle, // 0..3
     Duration time
   }) { }
 
 
   // HIT TESTING  
 
-  void handlePointer(sky.PointerEvent event) {
+  bool handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {

[Hixie, 2015/05/21 19:31:42]

Remove the x/y arguments here.

     // override this if you have children, to hand it to the appropriate child
     // override this if you want to do anything with the pointer event
   }

[Hixie, 2015/05/21 19:31:42]

Add the following (or something like it):

// The parent will call this if the pointer is within the bounds of the child.
For
// RenderBox, the bounds are defined by the height and width; other RenderNode
// subclasses may define this differently.
// If the child does not cover its entire bounds, for example if it has a hole
in
// the middle, then it can decide that the pointer in fact did not hit it, and
// should be propagated to any siblings that are below it in the stack.
// handlePointer() should return true if the pointer hit the child, and false if
// it missed (because the child doesn't cover its entire bounds).
// Note that the return value is _not_ whether the pointer was handled!

Also, add "return true" here. (Or false. I don't know what the right default is.
Probably true.)

 
 
   // PAINTING
 
   static bool _debugDoingPaint = false;
   void markNeedsPaint() {
     assert(!_debugDoingPaint);
+    // TODO(abarth): It's very redunant to call this for every node in the
+    // render tree during layout. We should instead compute a summary bit and
+    // call it once at the end of layout.
+    sky.view.scheduleFrame();
   }
   void paint(RenderNodeDisplayList canvas) { }
 
 }
 
 
 // GENERIC MIXIN FOR RENDER NODES THAT TAKE A LIST OF CHILDREN
 
 abstract class ContainerParentDataMixin<ChildType extends RenderNode> {
   ChildType previousSibling;
@@ skipping 219 matching lines @@
 
 class BoxDecoration {
   BoxDecoration({
     this.backgroundColor
   });
 
   final int backgroundColor;
 }
 
 class RenderDecoratedBox extends RenderBox {
-  BoxDecoration decoration;
+  BoxDecoration _decoration;
 
-  RenderDecoratedBox(this.decoration);
+  RenderDecoratedBox(BoxDecoration decoration) : _decoration = decoration;
+
+  void setBoxDecoration(BoxDecoration decoration) {
+    if (_decoration == decoration)
+      return;
+    _decoration = decoration;
+    markNeedsPaint();
+  }
 
   void paint(RenderNodeDisplayList canvas) {
     assert(width != null);
     assert(height != null);
 
-    if (decoration == null)
+    if (_decoration == null)
       return;
 
-    if (decoration.backgroundColor != null) {
-      sky.Paint paint = new sky.Paint()..color = decoration.backgroundColor;
+    if (_decoration.backgroundColor != null) {
+      sky.Paint paint = new sky.Paint()..color = _decoration.backgroundColor;
       canvas.drawRect(new sky.Rect()..setLTRB(0.0, 0.0, width, height), paint);
     }
   }
 }
 
 
 // RENDER VIEW LAYOUT MANAGER
 
 class RenderView extends RenderNode {
 
@@ skipping 46 matching lines @@
     root.layout(new BoxConstraints(
         minWidth: width, maxWidth: width, minHeight: height, maxHeight: height));
     assert(root.width == width);
     assert(root.height == height);
   }
 
   void rotate({ int oldAngle, int newAngle, Duration time }) {
     assert(false); // nobody tells the screen to rotate, the whole rotate() dance is started from our layout()
   }
 
+  bool handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
+    if (x < 0.0 || x >= root.width || y < 0.0 || y >= root.height)
+      return false;
+    return root.handlePointer(event, x: x, y: y);
+  }
+
   void paint(RenderNodeDisplayList canvas) {
     canvas.paintChild(root, 0.0, 0.0);
   }
 
   void paintFrame() {
     RenderNode._debugDoingPaint = true;
     var canvas = new RenderNodeDisplayList(sky.view.width, sky.view.height);
     paint(canvas);
     sky.view.picture = canvas.endRecording();
-    sky.view.schedulePaint();
     RenderNode._debugDoingPaint = false;
   }
 
 }
 
 
 // BLOCK LAYOUT MANAGER
 
 class EdgeDims {
   // used for e.g. padding
@@ skipping 92 matching lines @@
       assert(child.parentData is BlockParentData);
       child.parentData.x = 0.0; // TODO(abarth): Shouldn't this be _padding.left?
       child.parentData.y = y;
       y += child.height;
       child = child.parentData.nextSibling;
     }
     height = clamp(min: _minHeight, value: y + _padding.bottom, max: _maxHeight);
     layoutDone();
   }
 
-  void handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
+  bool handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
     // the x, y parameters have the top left of the node's box as the origin
     RenderBox child = _lastChild;
     while (child != null) {
       assert(child.parentData is BlockParentData);
       if ((x >= child.parentData.x) && (x < child.parentData.x + child.width) &&
           (y >= child.parentData.y) && (y < child.parentData.y + child.height)) {
-        child.handlePointer(event, x: x-child.parentData.x, y: y-child.parentData.y);
+        if (child.handlePointer(event, x: x-child.parentData.x, y: y-child.parentData.y))
+          return true;
         break;
       }
       child = child.parentData.previousSibling;
     }
-    super.handlePointer(event);
+    return super.handlePointer(event, x: x, y: y);

[Hixie, 2015/05/21 19:31:42]

Render block should always return true, by definition it always covers its
entire bounds.

   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     RenderBox child = _firstChild;
     while (child != null) {
       assert(child.parentData is BlockParentData);
       canvas.paintChild(child, child.parentData.x, child.parentData.y);
       child = child.parentData.nextSibling;
     }
@@ skipping 54 matching lines @@
       statusbar.parentData.x = 0.0;
       statusbar.parentData.y = height - kStatusbarHeight;
       bodyHeight -= kStatusbarHeight;
     }
     body.layout(new BoxConstraints(minWidth: width, maxWidth: width, minHeight: bodyHeight, maxHeight: bodyHeight));
     if (drawer != null)
       drawer.layout(new BoxConstraints(minWidth: 0.0, maxWidth: width, minHeight: height, maxHeight: height));
     layoutDone();
   }
 
-  void handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
+  bool handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
     if ((drawer != null) && (x < drawer.width)) {
-      drawer.handlePointer(event, x: x, y: y);
+      if (drawer.handlePointer(event, x: x, y: y))
+        return true;
     } else if ((toolbar != null) && (y < toolbar.height)) {
-      toolbar.handlePointer(event, x: x, y: y);
+      if (toolbar.handlePointer(event, x: x, y: y))
+        return true;
     } else if ((statusbar != null) && (y > (statusbar.parentData as BoxParentData).y)) {
-      statusbar.handlePointer(event, x: x, y: y-(statusbar.parentData as BoxParentData).y);
+      if (statusbar.handlePointer(event, x: x, y: y-(statusbar.parentData as BoxParentData).y))
+        return true;
     } else {
-      body.handlePointer(event, x: x, y: y-(body.parentData as BoxParentData).y);
+      if (body.handlePointer(event, x: x, y: y-(body.parentData as BoxParentData).y))
+        return true;
     }
-    super.handlePointer(event, x: x, y: y);
+    return super.handlePointer(event, x: x, y: y);

[Hixie, 2015/05/21 19:31:42]

I think ScaffoldBox.handlePointer should always return true (it's always
rectangular with no holes) and should always call super.handlePointer().

ScaffoldBox knows that its children never overlap, so it can just ignore the
return value.

   }
 
   void paint(RenderNodeDisplayList canvas) {
     canvas.paintChild(body, (body.parentData as BoxParentData).x, (body.parentData as BoxParentData).y);
     if (statusbar != null)
       canvas.paintChild(statusbar, (statusbar.parentData as BoxParentData).x, (statusbar.parentData as BoxParentData).y);
     if (toolbar != null)
       canvas.paintChild(toolbar, (toolbar.parentData as BoxParentData).x, (toolbar.parentData as BoxParentData).y);
     if (drawer != null)
       canvas.paintChild(drawer, (drawer.parentData as BoxParentData).x, (drawer.parentData as BoxParentData).y);
   }
 
 }