1/*
2 * Copyright (C) 2013 Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *
8 *     * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *     * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 *     * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31#include "config.h"
32#include "web/ViewportAnchor.h"
33
34#include "core/dom/ContainerNode.h"
35#include "core/dom/Node.h"
36#include "core/page/EventHandler.h"
37#include "core/rendering/HitTestResult.h"
38#include "platform/scroll/ScrollView.h"
39
40namespace blink {
41
42namespace {
43
44static const float viewportAnchorRelativeEpsilon = 0.1f;
45static const int viewportToNodeMaxRelativeArea = 2;
46
47template <typename RectType>
48int area(const RectType& rect) {
49    return rect.width() * rect.height();
50}
51
52Node* findNonEmptyAnchorNode(const IntPoint& point, const IntRect& viewRect, EventHandler* eventHandler)
53{
54    Node* node = eventHandler->hitTestResultAtPoint(point, HitTestRequest::ReadOnly | HitTestRequest::Active).innerNode();
55
56    // If the node bounding box is sufficiently large, make a single attempt to
57    // find a smaller node; the larger the node bounds, the greater the
58    // variability under resize.
59    const int maxNodeArea = area(viewRect) * viewportToNodeMaxRelativeArea;
60    if (node && area(node->boundingBox()) > maxNodeArea) {
61        IntSize pointOffset = viewRect.size();
62        pointOffset.scale(viewportAnchorRelativeEpsilon);
63        node = eventHandler->hitTestResultAtPoint(point + pointOffset, HitTestRequest::ReadOnly | HitTestRequest::Active).innerNode();
64    }
65
66    while (node && node->boundingBox().isEmpty())
67        node = node->parentNode();
68
69    return node;
70}
71
72void moveToEncloseRect(IntRect& outer, const FloatRect& inner)
73{
74    IntPoint minimumPosition = ceiledIntPoint(inner.location() + inner.size() - FloatSize(outer.size()));
75    IntPoint maximumPosition = flooredIntPoint(inner.location());
76
77    IntPoint outerOrigin = outer.location();
78    outerOrigin = outerOrigin.expandedTo(minimumPosition);
79    outerOrigin = outerOrigin.shrunkTo(maximumPosition);
80
81    outer.setLocation(outerOrigin);
82}
83
84void moveIntoRect(FloatRect& inner, const IntRect& outer)
85{
86    FloatPoint minimumPosition = FloatPoint(outer.location());
87    FloatPoint maximumPosition = minimumPosition + outer.size() - inner.size();
88
89    // Adjust maximumPosition to the nearest lower integer because
90    // PinchViewport::maximumScrollPosition() does the same.
91    // The value of minumumPosition is already adjusted since it is
92    // constructed from an integer point.
93    maximumPosition = flooredIntPoint(maximumPosition);
94
95    FloatPoint innerOrigin = inner.location();
96    innerOrigin = innerOrigin.expandedTo(minimumPosition);
97    innerOrigin = innerOrigin.shrunkTo(maximumPosition);
98
99    inner.setLocation(innerOrigin);
100}
101
102} // namespace
103
104ViewportAnchor::ViewportAnchor(EventHandler* eventHandler)
105    : m_eventHandler(eventHandler) { }
106
107void ViewportAnchor::setAnchor(const IntRect& outerViewRect, const IntRect& innerViewRect,
108    const FloatSize& anchorInInnerViewCoords)
109{
110    // Preserve the inner viewport position in document in case we won't find the anchor
111    m_pinchViewportInDocument = innerViewRect.location();
112
113    m_anchorNode.clear();
114    m_anchorNodeBounds = LayoutRect();
115    m_anchorInNodeCoords = FloatSize();
116    m_anchorInInnerViewCoords = anchorInInnerViewCoords;
117    m_normalizedPinchViewportOffset = FloatSize();
118
119    if (innerViewRect.isEmpty())
120        return;
121
122    // Preserve origins at the absolute screen origin
123    if (innerViewRect.location() == IntPoint::zero())
124        return;
125
126    // Inner rectangle should be within the outer one.
127    ASSERT(outerViewRect.contains(innerViewRect));
128
129    // Outer rectangle is used as a scale, we need positive width and height.
130    ASSERT(!outerViewRect.isEmpty());
131
132    m_normalizedPinchViewportOffset = innerViewRect.location() - outerViewRect.location();
133
134    // Normalize by the size of the outer rect
135    m_normalizedPinchViewportOffset.scale(1.0 / outerViewRect.width(), 1.0 / outerViewRect.height());
136
137    FloatSize anchorOffset = innerViewRect.size();
138    anchorOffset.scale(anchorInInnerViewCoords.width(), anchorInInnerViewCoords.height());
139    const FloatPoint anchorPoint = FloatPoint(innerViewRect.location()) + anchorOffset;
140
141    Node* node = findNonEmptyAnchorNode(flooredIntPoint(anchorPoint), innerViewRect, m_eventHandler);
142    if (!node)
143        return;
144
145    m_anchorNode = node;
146    m_anchorNodeBounds = node->boundingBox();
147    m_anchorInNodeCoords = anchorPoint - m_anchorNodeBounds.location();
148    m_anchorInNodeCoords.scale(1.f / m_anchorNodeBounds.width(), 1.f / m_anchorNodeBounds.height());
149}
150
151void ViewportAnchor::computeOrigins(const ScrollView& scrollView, const FloatSize& innerSize,
152    IntPoint& mainFrameOffset, FloatPoint& pinchViewportOffset) const
153{
154    IntSize outerSize = scrollView.visibleContentRect().size();
155
156    // Compute the viewport origins in CSS pixels relative to the document.
157    FloatSize absPinchViewportOffset = m_normalizedPinchViewportOffset;
158    absPinchViewportOffset.scale(outerSize.width(), outerSize.height());
159
160    FloatPoint innerOrigin = getInnerOrigin(innerSize);
161    FloatPoint outerOrigin = innerOrigin - absPinchViewportOffset;
162
163    IntRect outerRect = IntRect(flooredIntPoint(outerOrigin), outerSize);
164    FloatRect innerRect = FloatRect(innerOrigin, innerSize);
165
166    moveToEncloseRect(outerRect, innerRect);
167
168    outerRect.setLocation(scrollView.adjustScrollPositionWithinRange(outerRect.location()));
169
170    moveIntoRect(innerRect, outerRect);
171
172    mainFrameOffset = outerRect.location();
173    pinchViewportOffset = FloatPoint(innerRect.location() - outerRect.location());
174}
175
176FloatPoint ViewportAnchor::getInnerOrigin(const FloatSize& innerSize) const
177{
178    if (!m_anchorNode || !m_anchorNode->inDocument())
179        return m_pinchViewportInDocument;
180
181    const LayoutRect currentNodeBounds = m_anchorNode->boundingBox();
182    if (m_anchorNodeBounds == currentNodeBounds)
183        return m_pinchViewportInDocument;
184
185    // Compute the new anchor point relative to the node position
186    FloatSize anchorOffsetFromNode = currentNodeBounds.size();
187    anchorOffsetFromNode.scale(m_anchorInNodeCoords.width(), m_anchorInNodeCoords.height());
188    FloatPoint anchorPoint = currentNodeBounds.location() + anchorOffsetFromNode;
189
190    // Compute the new origin point relative to the new anchor point
191    FloatSize anchorOffsetFromOrigin = innerSize;
192    anchorOffsetFromOrigin.scale(m_anchorInInnerViewCoords.width(), m_anchorInInnerViewCoords.height());
193    return anchorPoint - anchorOffsetFromOrigin;
194}
195
196} // namespace blink
197