| // Copyright 2019 The Cobalt Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "cobalt/layout/intersection_observer_target.h" |
| |
| #include <algorithm> |
| #include <vector> |
| |
| #include "base/trace_event/trace_event.h" |
| #include "cobalt/cssom/computed_style_utils.h" |
| #include "cobalt/cssom/keyword_value.h" |
| #include "cobalt/layout/box.h" |
| #include "cobalt/layout/container_box.h" |
| #include "cobalt/layout/intersection_observer_root.h" |
| #include "cobalt/layout/used_style.h" |
| |
| namespace cobalt { |
| namespace layout { |
| namespace { |
| |
| int32 GetUsedLengthOfRootMarginPropertyValue( |
| const scoped_refptr<cssom::PropertyValue>& length_property_value, |
| LayoutUnit percentage_base) { |
| UsedLengthValueProvider used_length_provider(percentage_base); |
| length_property_value->Accept(&used_length_provider); |
| // Not explicitly stated in web spec, but has been observed that Chrome |
| // truncates root margin decimal values. |
| return static_cast<int32>( |
| used_length_provider.used_length().value_or(LayoutUnit(0.0f)).toFloat()); |
| } |
| |
| // Rules for determining the root intersection rectangle bounds. |
| // https://www.w3.org/TR/intersection-observer/#intersectionobserver-root-intersection-rectangle |
| math::RectF GetRootBounds( |
| const ContainerBox* root_box, |
| scoped_refptr<cssom::PropertyListValue> root_margin_property_value) { |
| math::RectF root_bounds_without_margins; |
| if (IsOverflowCropped(root_box->computed_style())) { |
| // If the intersection root has an overflow clip, it's the element's content |
| // area. |
| Vector2dLayoutUnit content_edge_offset = |
| root_box->GetContentBoxOffsetFromRoot(false /*transform_forms_root*/); |
| root_bounds_without_margins = math::RectF( |
| content_edge_offset.x().toFloat(), content_edge_offset.y().toFloat(), |
| root_box->width().toFloat(), root_box->height().toFloat()); |
| } else { |
| // Otherwise, it's the result of running the getBoundingClientRect() |
| // algorithm on the intersection root. |
| RectLayoutUnit root_transformed_border_box( |
| root_box->GetTransformedBoxFromRoot( |
| root_box->GetBorderBoxFromMarginBox())); |
| root_bounds_without_margins = |
| math::RectF(root_transformed_border_box.x().toFloat(), |
| root_transformed_border_box.y().toFloat(), |
| root_transformed_border_box.width().toFloat(), |
| root_transformed_border_box.height().toFloat()); |
| } |
| int32 top_margin = GetUsedLengthOfRootMarginPropertyValue( |
| root_margin_property_value->value()[0], |
| LayoutUnit(root_bounds_without_margins.height())); |
| int32 right_margin = GetUsedLengthOfRootMarginPropertyValue( |
| root_margin_property_value->value()[1], |
| LayoutUnit(root_bounds_without_margins.width())); |
| int32 bottom_margin = GetUsedLengthOfRootMarginPropertyValue( |
| root_margin_property_value->value()[2], |
| LayoutUnit(root_bounds_without_margins.height())); |
| int32 left_margin = GetUsedLengthOfRootMarginPropertyValue( |
| root_margin_property_value->value()[3], |
| LayoutUnit(root_bounds_without_margins.width())); |
| |
| // Remember to grow or shrink the root intersection rectangle bounds based |
| // on the root margin property. |
| math::RectF root_bounds = math::RectF( |
| root_bounds_without_margins.x() - left_margin, |
| root_bounds_without_margins.y() - top_margin, |
| root_bounds_without_margins.width() + left_margin + right_margin, |
| root_bounds_without_margins.height() + top_margin + bottom_margin); |
| return root_bounds; |
| } |
| |
| // Similar to the IntersectRects function in math::RectF, but handles edge |
| // adjacent intersections as valid intersections (instead of returning a |
| // rectangle with zero dimensions) |
| math::RectF IntersectIntersectionObserverRects(const math::RectF& a, |
| const math::RectF& b) { |
| float rx = std::max(a.x(), b.x()); |
| float ry = std::max(a.y(), b.y()); |
| float rr = std::min(a.right(), b.right()); |
| float rb = std::min(a.bottom(), b.bottom()); |
| |
| if (rx > rr || ry > rb) { |
| return math::RectF(0.0f, 0.0f, 0.0f, 0.0f); |
| } |
| |
| return math::RectF(rx, ry, rr - rx, rb - ry); |
| } |
| |
| // Compute the intersection between a target and the observer's intersection |
| // root. |
| // https://www.w3.org/TR/intersection-observer/#calculate-intersection-rect-algo |
| math::RectF ComputeIntersectionBetweenTargetAndRoot( |
| const ContainerBox* root_box, const math::RectF& root_bounds, |
| const math::RectF& target_rect, const ContainerBox* target_box) { |
| // Let intersectionRect be target's bounding border box. |
| math::RectF intersection_rect = target_rect; |
| |
| // Let container be the containing block of the target. |
| const ContainerBox* prev_container = target_box; |
| const ContainerBox* container = prev_container->GetContainingBlock(); |
| RectLayoutUnit box_from_containing_block = |
| target_box->GetTransformedBoxFromContainingBlock( |
| container, target_box->GetBorderBoxFromMarginBox()); |
| math::Vector2dF total_offset_from_containing_block = |
| math::Vector2dF(box_from_containing_block.x().toFloat(), |
| box_from_containing_block.y().toFloat()); |
| |
| // While container is not the intersection root: |
| while (container != root_box) { |
| // Map intersectionRect to the coordinate space of container. |
| intersection_rect.set_x(total_offset_from_containing_block.x()); |
| intersection_rect.set_y(total_offset_from_containing_block.y()); |
| |
| // If container has overflow clipping or a css clip-path property, update |
| // intersectionRect by applying container's clip. (Note: The containing |
| // block of an element with 'position: absolute' is formed by the padding |
| // edge of the ancestor. https://www.w3.org/TR/CSS2/visudet.html) |
| if (IsOverflowCropped(container->computed_style())) { |
| Vector2dLayoutUnit container_clip_dimensions = |
| prev_container->computed_style()->position() == |
| cssom::KeywordValue::GetAbsolute() |
| ? Vector2dLayoutUnit(container->GetPaddingBoxWidth(), |
| container->GetPaddingBoxHeight()) |
| : Vector2dLayoutUnit(container->width(), container->height()); |
| math::RectF container_clip(0.0f, 0.0f, |
| container_clip_dimensions.x().toFloat(), |
| container_clip_dimensions.y().toFloat()); |
| intersection_rect = |
| IntersectIntersectionObserverRects(intersection_rect, container_clip); |
| } |
| |
| // If container is the root element of a nested browsing context, update |
| // container to be the browsing context container of container, and update |
| // intersectionRect by clipping to the viewport of the nested browsing |
| // context. Otherwise, update container to be the containing block of |
| // container. (Note: The containing block of an element with 'position: |
| // absolute' is formed by the padding edge of the ancestor. |
| // https://www.w3.org/TR/CSS2/visudet.html) |
| RectLayoutUnit next_box_from_containing_block = |
| prev_container->computed_style()->position() == |
| cssom::KeywordValue::GetAbsolute() |
| ? container->GetTransformedBoxFromContainingBlock( |
| container->GetContainingBlock(), |
| container->GetPaddingBoxFromMarginBox()) |
| : container->GetTransformedBoxFromContainingBlockContentBox( |
| container->GetContainingBlock(), |
| container->GetContentBoxFromMarginBox()); |
| math::Vector2dF next_offset_from_containing_block = |
| math::Vector2dF(next_box_from_containing_block.x().toFloat(), |
| next_box_from_containing_block.y().toFloat()); |
| total_offset_from_containing_block += next_offset_from_containing_block; |
| |
| prev_container = container; |
| container = prev_container->GetContainingBlock(); |
| } |
| |
| // Map intersectionRect to the coordinate space of the viewport of the |
| // Document containing the target. |
| // (Note: The containing block of an element with 'position: absolute' |
| // is formed by the padding edge of the ancestor. |
| // https://www.w3.org/TR/CSS2/visudet.html) |
| RectLayoutUnit containing_block_box_from_origin = |
| prev_container->computed_style()->position() == |
| cssom::KeywordValue::GetAbsolute() && |
| !IsOverflowCropped(container->computed_style()) |
| ? container->GetTransformedBoxFromRoot( |
| container->GetPaddingBoxFromMarginBox()) |
| : container->GetTransformedBoxFromRoot( |
| container->GetContentBoxFromMarginBox()); |
| math::Vector2dF containing_block_offset_from_origin = |
| math::Vector2dF(containing_block_box_from_origin.x().toFloat(), |
| containing_block_box_from_origin.y().toFloat()); |
| |
| intersection_rect.set_x(total_offset_from_containing_block.x() + |
| containing_block_offset_from_origin.x()); |
| intersection_rect.set_y(total_offset_from_containing_block.y() + |
| containing_block_offset_from_origin.y()); |
| |
| // Update intersectionRect by intersecting it with the root intersection |
| // rectangle, which is already in this coordinate space. |
| intersection_rect = |
| IntersectIntersectionObserverRects(intersection_rect, root_bounds); |
| return intersection_rect; |
| } |
| |
| } // namespace |
| |
| void IntersectionObserverTarget::UpdateIntersectionObservationsForTarget( |
| ContainerBox* target_box) { |
| TRACE_EVENT0( |
| "cobalt::layout", |
| "IntersectionObserverTarget::UpdateIntersectionObservationsForTarget()"); |
| // Walk up the containing block chain looking for the box referencing the |
| // IntersectionObserverRoot corresponding to this IntersectionObserverTarget. |
| // Skip further processing for the target if it is not a descendant of the |
| // root in the containing block chain. |
| const ContainerBox* root_box = target_box->GetContainingBlock(); |
| while (!root_box->ContainsIntersectionObserverRoot( |
| intersection_observer_root_)) { |
| if (!root_box->parent()) { |
| return; |
| } |
| root_box = root_box->GetContainingBlock(); |
| } |
| |
| // Let targetRect be target's bounding border box. |
| RectLayoutUnit target_transformed_border_box( |
| target_box->GetTransformedBoxFromRoot( |
| target_box->GetBorderBoxFromMarginBox())); |
| const math::RectF target_rect = |
| math::RectF(target_transformed_border_box.x().toFloat(), |
| target_transformed_border_box.y().toFloat(), |
| target_transformed_border_box.width().toFloat(), |
| target_transformed_border_box.height().toFloat()); |
| |
| // Let intersectionRect be the result of running the compute the intersection |
| // algorithm on target. |
| const math::RectF root_bounds = GetRootBounds( |
| root_box, intersection_observer_root_->root_margin_property_value()); |
| const math::RectF intersection_rect = ComputeIntersectionBetweenTargetAndRoot( |
| root_box, root_bounds, target_rect, target_box); |
| |
| // Let targetArea be targetRect's area. |
| float target_area = target_rect.size().GetArea(); |
| |
| // Let intersectionArea be intersectionRect's area. |
| float intersection_area = intersection_rect.size().GetArea(); |
| |
| // Let isIntersecting be true if targetRect and rootBounds intersect or are |
| // edge-adjacent, even if the intersection has zero area (because rootBounds |
| // or targetRect have zero area); otherwise, let isIntersecting be false. |
| bool is_intersecting = |
| intersection_rect.width() != 0 || intersection_rect.height() != 0 || |
| (target_rect.width() == 0 && target_rect.height() == 0 && |
| root_bounds.Contains(target_rect)); |
| |
| // If targetArea is non-zero, let intersectionRatio be intersectionArea |
| // divided by targetArea. Otherwise, let intersectionRatio be 1 if |
| // isIntersecting is true, or 0 if isIntersecting is false. |
| float intersection_ratio = target_area > 0 ? intersection_area / target_area |
| : is_intersecting ? 1.0f : 0.0f; |
| |
| // Let thresholdIndex be the index of the first entry in observer.thresholds |
| // whose value is greater than intersectionRatio, or the length of |
| // observer.thresholds if intersectionRatio is greater than or equal to the |
| // last entry in observer.thresholds. |
| const std::vector<double>& thresholds = |
| intersection_observer_root_->thresholds_vector(); |
| size_t threshold_index; |
| for (threshold_index = 0; threshold_index < thresholds.size(); |
| ++threshold_index) { |
| if (thresholds.at(threshold_index) > intersection_ratio) { |
| // isIntersecting is false if intersectionRatio is less than all |
| // thresholds, sorted ascending. Not in spec but follows Chrome behavior. |
| if (threshold_index == 0) { |
| is_intersecting = false; |
| } |
| break; |
| } |
| } |
| |
| // If thresholdIndex does not equal previousThresholdIndex or if |
| // isIntersecting does not equal previousIsIntersecting, queue an |
| // IntersectionObserverEntry, passing in observer, time, rootBounds, |
| // boundingClientRect, intersectionRect, isIntersecting, and target. |
| if (static_cast<int32>(threshold_index) != previous_threshold_index_ || |
| is_intersecting != previous_is_intersecting_) { |
| on_intersection_callback_.Run(root_bounds, target_rect, intersection_rect, |
| is_intersecting, intersection_ratio); |
| } |
| |
| // Update the previousThresholdIndex and previousIsIntersecting properties. |
| previous_threshold_index_ = static_cast<int32>(threshold_index); |
| previous_is_intersecting_ = is_intersecting; |
| } |
| |
| } // namespace layout |
| } // namespace cobalt |
