| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "core/dom/IntersectionGeometry.h" | |
| 6 | |
| 7 #include "core/dom/Element.h" | |
| 8 #include "core/dom/ElementRareData.h" | |
| 9 #include "core/frame/FrameView.h" | |
| 10 #include "core/frame/LocalFrame.h" | |
| 11 #include "core/layout/LayoutBox.h" | |
| 12 #include "core/layout/LayoutView.h" | |
| 13 #include "core/layout/api/LayoutAPIShim.h" | |
| 14 #include "core/layout/api/LayoutViewItem.h" | |
| 15 #include "core/paint/PaintLayer.h" | |
| 16 | |
| 17 namespace blink { | |
| 18 | |
| 19 namespace { | |
| 20 | |
| 21 bool isContainingBlockChainDescendant(LayoutObject* descendant, | |
| 22 LayoutObject* ancestor) { | |
| 23 LocalFrame* ancestorFrame = ancestor->document().frame(); | |
| 24 LocalFrame* descendantFrame = descendant->document().frame(); | |
| 25 | |
| 26 if (ancestor->isLayoutView()) | |
| 27 return descendantFrame && descendantFrame->tree().top() == ancestorFrame; | |
| 28 | |
| 29 if (ancestorFrame != descendantFrame) | |
| 30 return false; | |
| 31 | |
| 32 while (descendant && descendant != ancestor) | |
| 33 descendant = descendant->containingBlock(); | |
| 34 return descendant; | |
| 35 } | |
| 36 | |
| 37 void mapRectUpToDocument(LayoutRect& rect, | |
| 38 const LayoutObject& layoutObject, | |
| 39 const Document& document) { | |
| 40 FloatQuad mappedQuad = layoutObject.localToAbsoluteQuad( | |
| 41 FloatQuad(FloatRect(rect)), UseTransforms | ApplyContainerFlip); | |
| 42 rect = LayoutRect(mappedQuad.boundingBox()); | |
| 43 } | |
| 44 | |
| 45 void mapRectDownToDocument(LayoutRect& rect, | |
| 46 LayoutBoxModelObject& layoutObject, | |
| 47 const Document& document) { | |
| 48 FloatQuad mappedQuad = document.layoutView()->ancestorToLocalQuad( | |
| 49 &layoutObject, FloatQuad(FloatRect(rect)), | |
| 50 UseTransforms | ApplyContainerFlip | TraverseDocumentBoundaries); | |
| 51 rect = LayoutRect(mappedQuad.boundingBox()); | |
| 52 } | |
| 53 | |
| 54 LayoutUnit computeMargin(const Length& length, LayoutUnit referenceLength) { | |
| 55 if (length.type() == Percent) { | |
| 56 return LayoutUnit( | |
| 57 static_cast<int>(referenceLength.toFloat() * length.percent() / 100.0)); | |
| 58 } | |
| 59 DCHECK_EQ(length.type(), Fixed); | |
| 60 return LayoutUnit(length.intValue()); | |
| 61 } | |
| 62 | |
| 63 } // namespace | |
| 64 | |
| 65 IntersectionGeometry::IntersectionGeometry( | |
| 66 Node* root, | |
| 67 Element* target, | |
| 68 const Vector<Length>& rootMargin, | |
| 69 ReportRootBounds shouldReportRootBounds) | |
| 70 : m_root(root), | |
| 71 m_target(target), | |
| 72 m_rootMargin(rootMargin), | |
| 73 m_shouldReportRootBounds(shouldReportRootBounds) { | |
| 74 DCHECK(m_target); | |
| 75 DCHECK(rootMargin.isEmpty() || rootMargin.size() == 4); | |
| 76 } | |
| 77 | |
| 78 IntersectionGeometry::~IntersectionGeometry() {} | |
| 79 | |
| 80 Element* IntersectionGeometry::root() const { | |
| 81 if (m_root && !m_root->isDocumentNode()) | |
| 82 return toElement(m_root); | |
| 83 return nullptr; | |
| 84 } | |
| 85 | |
| 86 LayoutObject* IntersectionGeometry::getRootLayoutObject() const { | |
| 87 DCHECK(m_root); | |
| 88 if (m_root->isDocumentNode()) { | |
| 89 return LayoutAPIShim::layoutObjectFrom( | |
| 90 toDocument(m_root)->layoutViewItem()); | |
| 91 } | |
| 92 return toElement(m_root)->layoutObject(); | |
| 93 } | |
| 94 | |
| 95 void IntersectionGeometry::initializeGeometry() { | |
| 96 initializeTargetRect(); | |
| 97 m_intersectionRect = m_targetRect; | |
| 98 initializeRootRect(); | |
| 99 m_doesIntersect = true; | |
| 100 } | |
| 101 | |
| 102 void IntersectionGeometry::initializeTargetRect() { | |
| 103 LayoutObject* targetLayoutObject = m_target->layoutObject(); | |
| 104 DCHECK(targetLayoutObject && targetLayoutObject->isBoxModelObject()); | |
| 105 m_targetRect = LayoutRect( | |
| 106 toLayoutBoxModelObject(targetLayoutObject)->borderBoundingBox()); | |
| 107 } | |
| 108 | |
| 109 void IntersectionGeometry::initializeRootRect() { | |
| 110 LayoutObject* rootLayoutObject = getRootLayoutObject(); | |
| 111 if (rootLayoutObject->isLayoutView()) { | |
| 112 m_rootRect = LayoutRect( | |
| 113 toLayoutView(rootLayoutObject)->frameView()->visibleContentRect()); | |
| 114 } else if (rootLayoutObject->isBox() && rootLayoutObject->hasOverflowClip()) { | |
| 115 m_rootRect = LayoutRect(toLayoutBox(rootLayoutObject)->contentBoxRect()); | |
| 116 } else { | |
| 117 m_rootRect = LayoutRect( | |
| 118 toLayoutBoxModelObject(rootLayoutObject)->borderBoundingBox()); | |
| 119 } | |
| 120 applyRootMargin(); | |
| 121 } | |
| 122 | |
| 123 void IntersectionGeometry::applyRootMargin() { | |
| 124 if (m_rootMargin.isEmpty()) | |
| 125 return; | |
| 126 | |
| 127 // TODO(szager): Make sure the spec is clear that left/right margins are | |
| 128 // resolved against width and not height. | |
| 129 LayoutUnit topMargin = computeMargin(m_rootMargin[0], m_rootRect.height()); | |
| 130 LayoutUnit rightMargin = computeMargin(m_rootMargin[1], m_rootRect.width()); | |
| 131 LayoutUnit bottomMargin = computeMargin(m_rootMargin[2], m_rootRect.height()); | |
| 132 LayoutUnit leftMargin = computeMargin(m_rootMargin[3], m_rootRect.width()); | |
| 133 | |
| 134 m_rootRect.setX(m_rootRect.x() - leftMargin); | |
| 135 m_rootRect.setWidth(m_rootRect.width() + leftMargin + rightMargin); | |
| 136 m_rootRect.setY(m_rootRect.y() - topMargin); | |
| 137 m_rootRect.setHeight(m_rootRect.height() + topMargin + bottomMargin); | |
| 138 } | |
| 139 | |
| 140 void IntersectionGeometry::clipToRoot() { | |
| 141 // Map and clip rect into root element coordinates. | |
| 142 // TODO(szager): the writing mode flipping needs a test. | |
| 143 LayoutBox* rootLayoutObject = toLayoutBox(getRootLayoutObject()); | |
| 144 LayoutObject* targetLayoutObject = m_target->layoutObject(); | |
| 145 | |
| 146 m_doesIntersect = targetLayoutObject->mapToVisualRectInAncestorSpace( | |
| 147 rootLayoutObject, m_intersectionRect, EdgeInclusive); | |
| 148 if (rootLayoutObject->hasOverflowClip()) | |
| 149 m_intersectionRect.move(-rootLayoutObject->scrolledContentOffset()); | |
| 150 | |
| 151 if (!m_doesIntersect) | |
| 152 return; | |
| 153 LayoutRect rootClipRect(m_rootRect); | |
| 154 rootLayoutObject->flipForWritingMode(rootClipRect); | |
| 155 m_doesIntersect &= m_intersectionRect.inclusiveIntersect(rootClipRect); | |
| 156 } | |
| 157 | |
| 158 void IntersectionGeometry::mapTargetRectToTargetFrameCoordinates() { | |
| 159 LayoutObject& targetLayoutObject = *m_target->layoutObject(); | |
| 160 Document& targetDocument = m_target->document(); | |
| 161 LayoutSize scrollPosition = | |
| 162 LayoutSize(targetDocument.view()->getScrollOffset()); | |
| 163 mapRectUpToDocument(m_targetRect, targetLayoutObject, targetDocument); | |
| 164 m_targetRect.move(-scrollPosition); | |
| 165 } | |
| 166 | |
| 167 void IntersectionGeometry::mapRootRectToRootFrameCoordinates() { | |
| 168 LayoutObject& rootLayoutObject = *getRootLayoutObject(); | |
| 169 Document& rootDocument = rootLayoutObject.document(); | |
| 170 LayoutSize scrollPosition = | |
| 171 LayoutSize(rootDocument.view()->getScrollOffset()); | |
| 172 mapRectUpToDocument(m_rootRect, rootLayoutObject, | |
| 173 rootLayoutObject.document()); | |
| 174 m_rootRect.move(-scrollPosition); | |
| 175 } | |
| 176 | |
| 177 void IntersectionGeometry::mapRootRectToTargetFrameCoordinates() { | |
| 178 LayoutObject& rootLayoutObject = *getRootLayoutObject(); | |
| 179 Document& targetDocument = m_target->document(); | |
| 180 LayoutSize scrollPosition = | |
| 181 LayoutSize(targetDocument.view()->getScrollOffset()); | |
| 182 | |
| 183 if (&targetDocument == &rootLayoutObject.document()) { | |
| 184 mapRectUpToDocument(m_intersectionRect, rootLayoutObject, targetDocument); | |
| 185 } else { | |
| 186 mapRectDownToDocument(m_intersectionRect, | |
| 187 toLayoutBoxModelObject(rootLayoutObject), | |
| 188 targetDocument); | |
| 189 } | |
| 190 | |
| 191 m_intersectionRect.move(-scrollPosition); | |
| 192 } | |
| 193 | |
| 194 void IntersectionGeometry::computeGeometry() { | |
| 195 // In the first few lines here, before initializeGeometry is called, "return | |
| 196 // true" effectively means "if the previous observed state was that root and | |
| 197 // target were intersecting, then generate a notification indicating that they | |
| 198 // are no longer intersecting." This happens, for example, when root or | |
| 199 // target is removed from the DOM tree and not reinserted before the next | |
| 200 // frame is generated, or display:none is set on the root or target. | |
| 201 if (!m_target->isConnected()) | |
| 202 return; | |
| 203 Element* rootElement = root(); | |
| 204 if (rootElement && !rootElement->isConnected()) | |
| 205 return; | |
| 206 | |
| 207 LayoutObject* rootLayoutObject = getRootLayoutObject(); | |
| 208 if (!rootLayoutObject || !rootLayoutObject->isBoxModelObject()) | |
| 209 return; | |
| 210 // TODO(szager): Support SVG | |
| 211 LayoutObject* targetLayoutObject = m_target->layoutObject(); | |
| 212 if (!targetLayoutObject) | |
| 213 return; | |
| 214 if (!targetLayoutObject->isBoxModelObject() && !targetLayoutObject->isText()) | |
| 215 return; | |
| 216 if (!isContainingBlockChainDescendant(targetLayoutObject, rootLayoutObject)) | |
| 217 return; | |
| 218 | |
| 219 initializeGeometry(); | |
| 220 | |
| 221 clipToRoot(); | |
| 222 | |
| 223 mapTargetRectToTargetFrameCoordinates(); | |
| 224 | |
| 225 if (m_doesIntersect) | |
| 226 mapRootRectToTargetFrameCoordinates(); | |
| 227 else | |
| 228 m_intersectionRect = LayoutRect(); | |
| 229 | |
| 230 // Small optimization: if we're not going to report root bounds, don't bother | |
| 231 // transforming them to the frame. | |
| 232 if (m_shouldReportRootBounds == ReportRootBounds::kShouldReportRootBounds) | |
| 233 mapRootRectToRootFrameCoordinates(); | |
| 234 } | |
| 235 | |
| 236 DEFINE_TRACE(IntersectionGeometry) { | |
| 237 visitor->trace(m_root); | |
| 238 visitor->trace(m_target); | |
| 239 } | |
| 240 | |
| 241 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2553103004:
Refactor IntersectionGeometry class and move it to core/layout. (Closed)
