Method hit_test

consumer/src/node.rs:327–368

(
        &self,
        point: Point,
        filter: &impl Fn(&Node) -> FilterResult,
    )

    }

    pub(crate) fn hit_test(
        &self,
        point: Point,
        filter: &impl Fn(&Node) -> FilterResult,
    ) -> Option<(Node<'a>, Point)> {
        // A node's `Test` frame is pushed before its children, then children in
        // forward order, so that children are searched last-to-first and the
        // node's own bounds are tested only after all descendants miss.
        enum Frame<'n> {
            Visit(Node<'n>, Point),
            Test(Node<'n>, Point),
        }

        let mut stack = Vec::with_capacity(self.children().len() + 1);
        stack.push(Frame::Visit(*self, point));
        while let Some(frame) = stack.pop() {
            match frame {
                Frame::Test(node, point) => {
                    if let Some(rect) = &node.raw_bounds() {
                        if rect.contains(point) {
                            return Some((node, point));
                        }
                    }
                }
                Frame::Visit(node, point) => {
                    let filter_result = filter(&node);
                    if filter_result == FilterResult::ExcludeSubtree {
                        continue;
                    }
                    if filter_result == FilterResult::Include {
                        stack.push(Frame::Test(node, point));
                    }
                    for child in node.children() {
                        let child_point = child.direct_transform().inverse() * point;
                        stack.push(Frame::Visit(child, child_point));
                    }
                }
            }
        }

        None
    }

    /// Returns the deepest filtered node, either this node or a descendant,
    /// at the given point in this node's coordinate space.