PageViewportController.cpp [plain text]
#include "config.h"
#include "PageViewportController.h"
#include "CoordinatedDrawingAreaProxy.h"
#include "PageViewportControllerClient.h"
#include "WebPageProxy.h"
#include <WebCore/FloatRect.h>
#include <WebCore/FloatSize.h>
#include <wtf/MathExtras.h>
using namespace WebCore;
namespace WebKit {
PageViewportController::PageViewportController(WebKit::WebPageProxy* proxy, PageViewportControllerClient& client)
: m_webPageProxy(proxy)
, m_client(client)
, m_allowsUserScaling(false)
, m_minimumScaleToFit(1)
, m_initiallyFitToViewport(true)
, m_hadUserInteraction(false)
, m_pageScaleFactor(1)
, m_pendingPositionChange(false)
, m_pendingScaleChange(false)
, m_layerTreeStateIsFrozen(false)
{
m_rawAttributes.minimumScale = 1;
m_rawAttributes.maximumScale = 1;
m_rawAttributes.userScalable = m_allowsUserScaling;
m_rawAttributes.initialScale = -1;
}
float PageViewportController::innerBoundedViewportScale(float viewportScale) const
{
return clampTo(viewportScale, m_minimumScaleToFit, m_rawAttributes.maximumScale);
}
float PageViewportController::outerBoundedViewportScale(float viewportScale) const
{
if (m_allowsUserScaling) {
float hardMin = std::max<float>(0.1, 0.5 * m_minimumScaleToFit);
float hardMax = std::min<float>(10, 2 * m_rawAttributes.maximumScale);
return clampTo(viewportScale, hardMin, hardMax);
}
return innerBoundedViewportScale(viewportScale);
}
float PageViewportController::deviceScaleFactor() const
{
return m_webPageProxy->deviceScaleFactor();
}
static inline bool isIntegral(float value)
{
return static_cast<int>(value) == value;
}
FloatPoint PageViewportController::pixelAlignedFloatPoint(const FloatPoint& framePosition)
{
#if PLATFORM(EFL)
float effectiveScale = m_pageScaleFactor * deviceScaleFactor();
if (!isIntegral(effectiveScale)) {
FloatPoint scaledPos(framePosition);
scaledPos.scale(effectiveScale, effectiveScale);
FloatPoint alignedPos = roundedIntPoint(scaledPos);
alignedPos.scale(1 / effectiveScale, 1 / effectiveScale);
return alignedPos;
}
#endif
return framePosition;
}
FloatPoint PageViewportController::boundContentsPositionAtScale(const WebCore::FloatPoint& framePosition, float scale)
{
FloatRect bounds;
bounds.setWidth(std::max(0.f, m_contentsSize.width() - floorf(m_viewportSize.width() / scale)));
bounds.setHeight(std::max(0.f, m_contentsSize.height() - floorf(m_viewportSize.height() / scale)));
FloatPoint position;
position.setX(clampTo(framePosition.x(), bounds.x(), bounds.width()));
position.setY(clampTo(framePosition.y(), bounds.y(), bounds.height()));
return position;
}
FloatPoint PageViewportController::boundContentsPosition(const WebCore::FloatPoint& framePosition)
{
return boundContentsPositionAtScale(framePosition, m_pageScaleFactor);
}
void PageViewportController::didCommitLoad()
{
m_lastFrameCoveredRect = FloatRect();
m_contentsSize = IntSize();
m_contentsPosition = FloatPoint();
m_layerTreeStateIsFrozen = true;
m_initiallyFitToViewport = true;
applyPositionAfterRenderingContents(FloatPoint());
}
void PageViewportController::didChangeContentsSize(const IntSize& newSize)
{
m_contentsSize = newSize;
bool minimumScaleUpdated = updateMinimumScaleToFit(false);
if (m_initiallyFitToViewport) {
ASSERT(m_minimumScaleToFit > 0);
m_rawAttributes.initialScale = m_minimumScaleToFit;
WebCore::restrictScaleFactorToInitialScaleIfNotUserScalable(m_rawAttributes);
}
if (minimumScaleUpdated)
m_client.didChangeViewportAttributes();
syncVisibleContents();
}
void PageViewportController::didRenderFrame(const IntSize& contentsSize, const IntRect& coveredRect)
{
if (m_clientContentsSize != contentsSize) {
m_clientContentsSize = contentsSize;
m_client.didChangeContentsSize(contentsSize);
}
m_lastFrameCoveredRect = coveredRect;
if (m_pendingScaleChange) {
m_pendingScaleChange = false;
m_client.setPageScaleFactor(m_pageScaleFactor);
m_pendingPositionChange = true;
FloatPoint currentDiscretePos = roundedIntPoint(m_contentsPosition);
FloatPoint pixelAlignedPos = pixelAlignedFloatPoint(currentDiscretePos);
m_contentsPosition = boundContentsPosition(pixelAlignedPos);
m_webPageProxy->scalePage(m_pageScaleFactor, roundedIntPoint(m_contentsPosition));
}
FloatRect endVisibleContentRect(m_contentsPosition, visibleContentsSize());
if (m_pendingPositionChange && endVisibleContentRect.intersects(coveredRect)) {
m_client.setViewportPosition(m_contentsPosition);
m_pendingPositionChange = false;
}
m_layerTreeStateIsFrozen = false;
}
void PageViewportController::pageTransitionViewportReady()
{
if (!m_rawAttributes.layoutSize.isEmpty() && m_initiallyFitToViewport) {
m_hadUserInteraction = false;
float initialScale = m_initiallyFitToViewport ? m_minimumScaleToFit : m_rawAttributes.initialScale;
applyScaleAfterRenderingContents(innerBoundedViewportScale(initialScale));
}
m_webPageProxy->commitPageTransitionViewport();
}
void PageViewportController::pageDidRequestScroll(const IntPoint& cssPosition)
{
if (m_webPageProxy->areActiveDOMObjectsAndAnimationsSuspended())
return;
FloatPoint boundPosition = boundContentsPosition(FloatPoint(cssPosition));
FloatPoint alignedPosition = pixelAlignedFloatPoint(boundPosition);
FloatRect endVisibleContentRect(alignedPosition, visibleContentsSize());
if (m_lastFrameCoveredRect.intersects(endVisibleContentRect))
m_client.setViewportPosition(alignedPosition);
else {
FloatPoint position = pixelAlignedFloatPoint(FloatPoint(cssPosition));
applyPositionAfterRenderingContents(position);
}
}
void PageViewportController::didChangeViewportSize(const FloatSize& newSize)
{
if (newSize.isEmpty())
return;
m_viewportSize = newSize;
}
void PageViewportController::didChangeContentsVisibility(const FloatPoint& position, float scale, const FloatPoint& trajectoryVector)
{
if (!m_pendingPositionChange)
m_contentsPosition = position;
if (!m_pendingScaleChange)
applyScaleAfterRenderingContents(scale);
syncVisibleContents(trajectoryVector);
}
bool PageViewportController::syncVisibleContents(const FloatPoint& trajectoryVector)
{
CoordinatedDrawingAreaProxy* drawingArea = static_cast<CoordinatedDrawingAreaProxy*>(m_webPageProxy->drawingArea());
if (!drawingArea || m_viewportSize.isEmpty() || m_contentsSize.isEmpty())
return false;
FloatRect visibleContentsRect(boundContentsPosition(m_contentsPosition), visibleContentsSize());
visibleContentsRect.intersect(FloatRect(FloatPoint::zero(), m_contentsSize));
drawingArea->setVisibleContentsRect(visibleContentsRect, trajectoryVector);
if (!m_layerTreeStateIsFrozen)
m_client.didChangeVisibleContents();
return true;
}
void PageViewportController::didChangeViewportAttributes(const WebCore::ViewportAttributes& newAttributes)
{
if (!m_initiallyFitToViewport)
return;
if (newAttributes.layoutSize.isEmpty())
return;
m_rawAttributes = newAttributes;
m_allowsUserScaling = !!m_rawAttributes.userScalable;
m_initiallyFitToViewport = (m_rawAttributes.initialScale < 0);
if (!m_initiallyFitToViewport)
WebCore::restrictScaleFactorToInitialScaleIfNotUserScalable(m_rawAttributes);
updateMinimumScaleToFit(true);
m_pendingPositionChange = true;
m_pendingScaleChange = true;
m_client.didChangeViewportAttributes();
}
FloatSize PageViewportController::visibleContentsSize() const
{
return FloatSize(m_viewportSize.width() / m_pageScaleFactor, m_viewportSize.height() / m_pageScaleFactor);
}
void PageViewportController::applyScaleAfterRenderingContents(float scale)
{
if (m_pageScaleFactor == scale)
return;
float oldPageScaleFactor = m_pageScaleFactor;
m_pageScaleFactor = scale;
m_pendingScaleChange = true;
if (!syncVisibleContents()) {
m_pageScaleFactor = oldPageScaleFactor;
m_webPageProxy->scalePage(m_pageScaleFactor, roundedIntPoint(m_contentsPosition));
}
}
void PageViewportController::applyPositionAfterRenderingContents(const FloatPoint& pos)
{
if (m_contentsPosition == pos)
return;
m_contentsPosition = pos;
m_pendingPositionChange = true;
syncVisibleContents();
}
bool PageViewportController::updateMinimumScaleToFit(bool userInitiatedUpdate)
{
if (m_viewportSize.isEmpty() || m_contentsSize.isEmpty() || !m_initiallyFitToViewport || m_hadUserInteraction)
return false;
bool currentlyScaledToFit = WTF::areEssentiallyEqual(m_pageScaleFactor, m_minimumScaleToFit, 0.0001f);
float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), WebCore::roundedIntSize(m_contentsSize));
if (minimumScale <= 0)
return false;
if (!WTF::areEssentiallyEqual(minimumScale, m_minimumScaleToFit, 0.0001f)) {
m_minimumScaleToFit = minimumScale;
if (!m_webPageProxy->areActiveDOMObjectsAndAnimationsSuspended()) {
if (!m_hadUserInteraction || (userInitiatedUpdate && currentlyScaledToFit))
applyScaleAfterRenderingContents(m_minimumScaleToFit);
else {
float boundedScale = innerBoundedViewportScale(m_pageScaleFactor);
if (!WTF::areEssentiallyEqual(boundedScale, m_pageScaleFactor, 0.0001f))
applyScaleAfterRenderingContents(boundedScale);
}
}
return true;
}
return false;
}
}