Rationalise hit testing in the new RenderNode world

sky/sdk/lib/framework/layout2.dart

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
 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 199 matching lines @@
   // pixel, on the output device. Then, the layout() method or
   // equivalent will be invoked.
 
   void rotate({
     int oldAngle, // 0..3
     int newAngle, // 0..3
     Duration time
   }) { }
 
 
-  // HIT TESTING  
-
-  bool handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
-    // 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
-    return false;
-  }
-
-
   // 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) { }
 
+
+  // HIT TESTING  
+
+  void handlePointer(sky.PointerEvent event) {
+    // override this if you have a client, to hand it to the client
+    // override this if you want to do anything with the pointer event
+  }
+
+  // RenderNode subclasses are expected to have a method like the
+  // following (with the signature being whatever passes for coordinates
+  // for this particular class):
+  // bool hitTest(HitTestResult result, { double x, double y }) {
+  //   // If (x,y) is not inside this node, then return false.
+  //   // Otherwise:
+  //   // For each child that intersects x,y, in z-order starting from the top,
+  //   // call hitTest() for that child, passing it /result/, and the coordinates
+  //   // converted to the child's coordinate origin, and stop at the first child
+  //   // that returns true.
+  //   // Then, add yourself to /result/, and return true.
+  // }
+  // You must not add yourself to /result/ if you return false.
+
 }
 
+class HitTestResult {
+  final List<RenderNode> path = new List<RenderNode>();
+
+  RenderNode get result => path.first;
+
+  void add(RenderNode node) {
+    path.add(node);
+  }
+}
 
 // GENERIC MIXIN FOR RENDER NODES THAT TAKE A LIST OF CHILDREN
 
 abstract class ContainerParentDataMixin<ChildType extends RenderNode> {
   ChildType previousSibling;
   ChildType nextSibling;
   void detachSiblings() {
     if (previousSibling != null) {
       assert(previousSibling.parentData is ContainerParentDataMixin<ChildType>);
       assert(previousSibling != this);
@@ skipping 205 matching lines @@
   BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
     return new BoxDimensions.withConstraints(constraints);
   }
 
   void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
     width = constraints.constrainWidth(0.0);
     height = constraints.constrainHeight(0.0);
     layoutDone();
   }
 
+  bool hitTest(HitTestResult result, { double x, double y }) {
+    if (x < 0.0 || x >= width || y < 0.0 || y >= height)

[eseidel, 2015/05/26 19:38:23]

If we had a Rect class it could abstract this away.  rect.contains(point).

+      return false;
+    hitTestChildren(result, x: x, y: y);
+    result.add(this);
+    return true;
+  }
+  void hitTestChildren(HitTestResult result, { double x, double y }) { }
+
   double width;
   double height;
 }
 
 class BoxDecoration {
   const BoxDecoration({
     this.backgroundColor
   });
 
   final int backgroundColor;
@@ skipping 79 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)
+  bool hitTest(HitTestResult result, { double x, double y }) {
+    assert(root != null);
+    if (x < 0.0 || x >= width || y < 0.0 || y >= height)
       return false;
-    return root.handlePointer(event, x: x, y: y);
+    if (x >= 0.0 && x < root.width && y >= 0.0 && y < root.height)
+      root.hitTest(result, x: x, y: y);
+    result.add(this);
+    return true;
   }
 
   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();
     RenderNode._debugDoingPaint = false;
   }
 
 }
 
 // DEFAULT BEHAVIORS FOR RENDERBOX CONTAINERS
 abstract class RenderBoxContainerDefaultsMixin<ChildType extends RenderBox, ParentDataType extends ContainerParentDataMixin<ChildType>> implements ContainerRenderNodeMixin<ChildType, ParentDataType> {
-  bool defaultHandlePointer(sky.PointerEvent event, double x, double y) {
+
+  void defaultHitTestChildren(HitTestResult result, { double x, double y }) {
     // the x, y parameters have the top left of the node's box as the origin
     ChildType child = lastChild;
     while (child != null) {
       assert(child.parentData is BoxParentData);
       if ((x >= child.parentData.x) && (x < child.parentData.x + child.width) &&
           (y >= child.parentData.y) && (y < child.parentData.y + child.height)) {
-        if (child.handlePointer(event, x: x-child.parentData.x, y: y-child.parentData.y))
-          return true;
-        break;
+        if (child.hitTest(result, x: x-child.parentData.x, y: y-child.parentData.y))
+          break;
       }
       child = child.parentData.previousSibling;
     }
-    return false;
   }
 
   void defaultPaint(RenderNodeDisplayList canvas) {
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is BoxParentData);
       canvas.paintChild(child, child.parentData.x, child.parentData.y);
       child = child.parentData.nextSibling;
     }
   }
@@ skipping 94 matching lines @@
       assert(child.parentData is BlockParentData);
       child.parentData.x = _padding.left;
       child.parentData.y = y;
       y += child.height;
       child = child.parentData.nextSibling;
     }
     height = clamp(min: _minHeight, value: y + _padding.bottom, max: _maxHeight);
     layoutDone();
   }
 
-  bool handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
-    return defaultHandlePointer(event, x, y) || super.handlePointer(event, x: x, y: y);
+  void hitTestChildren(HitTestResult result, { double x, double y }) {
+    defaultHitTestChildren(result, x: x, y: y);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     defaultPaint(canvas);
   }
 
 }
 
 // FLEXBOX LAYOUT MANAGER
@@ skipping 110 matching lines @@
           child.parentData.y = usedSpace;
           usedSpace += child.height;
           child.parentData.x = width / 2 - child.width / 2;
           break;
       }
       child = child.parentData.nextSibling;
     }
     layoutDone();
   }
 
-  bool handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
-    return defaultHandlePointer(event, x, y) || super.handlePointer(event, x: x, y: y);
+  void hitTestChildren(HitTestResult result, { double x, double y }) {
+    defaultHitTestChildren(result, x: x, y: y);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     defaultPaint(canvas);
   }
 }
 
 // SCAFFOLD LAYOUT MANAGER
 
@@ skipping 34 matching lines @@
       statusbar.parentData.x = 0.0;
       statusbar.parentData.y = height - kStatusbarHeight;
       bodyHeight -= kStatusbarHeight;
     }
     body.layout(new BoxConstraints.tight(width: width, height: bodyHeight));
     if (drawer != null)
       drawer.layout(new BoxConstraints(minWidth: 0.0, maxWidth: width, minHeight: height, maxHeight: height));
     layoutDone();
   }
 
-  bool handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
+  void hitTestChildren(HitTestResult result, { double x, double y }) {
     if ((drawer != null) && (x < drawer.width)) {
-      if (drawer.handlePointer(event, x: x, y: y))
-        return true;
+      drawer.hitTest(result, x: x, y: y);
     } else if ((toolbar != null) && (y < toolbar.height)) {
-      if (toolbar.handlePointer(event, x: x, y: y))
-        return true;
+      toolbar.hitTest(result, x: x, y: y);
     } else if ((statusbar != null) && (y > (statusbar.parentData as BoxParentData).y)) {
-      if (statusbar.handlePointer(event, x: x, y: y-(statusbar.parentData as BoxParentData).y))
-        return true;
+      statusbar.hitTest(result, x: x, y: y-(statusbar.parentData as BoxParentData).y);
     } else {
-      if (body.handlePointer(event, x: x, y: y-(body.parentData as BoxParentData).y))
-        return true;
+      body.hitTest(result, x: x, y: y-(body.parentData as BoxParentData).y);
     }
-    return super.handlePointer(event, x: x, y: y);
   }
 
   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);
   }
 
 }