SimpleViewportController.cpp [plain text]
#include "config.h"
#include "SimpleViewportController.h"
#if USE(COORDINATED_GRAPHICS_THREADED)
using namespace WebCore;
namespace WebKit {
SimpleViewportController::SimpleViewportController()
{
resetViewportToDefaultState();
}
void SimpleViewportController::didChangeViewportSize(const IntSize& newSize)
{
if (newSize.isEmpty())
return;
m_viewportSize = newSize;
updateMinimumScaleToFit();
}
void SimpleViewportController::didChangeContentsSize(const IntSize& newSize)
{
m_contentsSize = newSize;
updateMinimumScaleToFit();
if (m_initiallyFitToViewport) {
ASSERT(m_minimumScaleToFit > 0);
m_rawAttributes.initialScale = m_minimumScaleToFit;
restrictScaleFactorToInitialScaleIfNotUserScalable(m_rawAttributes);
}
}
void SimpleViewportController::didChangeViewportAttributes(const ViewportAttributes& newAttributes)
{
if (newAttributes.layoutSize.isEmpty()) {
resetViewportToDefaultState();
return;
}
m_hasViewportAttribute = true;
m_rawAttributes = newAttributes;
m_allowsUserScaling = m_rawAttributes.userScalable;
m_initiallyFitToViewport = m_rawAttributes.initialScale < 0;
if (!m_initiallyFitToViewport)
restrictScaleFactorToInitialScaleIfNotUserScalable(m_rawAttributes);
updateMinimumScaleToFit();
}
void SimpleViewportController::didScroll(const IntPoint& position)
{
m_contentsPosition = position;
}
FloatRect SimpleViewportController::visibleContentsRect() const
{
if (m_viewportSize.isEmpty() || m_contentsSize.isEmpty())
return { };
FloatRect visibleContentsRect(boundContentsPosition(m_contentsPosition), visibleContentsSize());
visibleContentsRect.intersect(FloatRect(FloatPoint::zero(), m_contentsSize));
return visibleContentsRect;
}
FloatSize SimpleViewportController::visibleContentsSize() const
{
return FloatSize(m_viewportSize.width() / m_pageScaleFactor, m_viewportSize.height() / m_pageScaleFactor);
}
FloatPoint SimpleViewportController::boundContentsPositionAtScale(const FloatPoint& framePosition, float scale) const
{
return FloatPoint(
clampTo(framePosition.x(), .0f, std::max(.0f, m_contentsSize.width() - floorf(m_viewportSize.width() / scale))),
clampTo(framePosition.y(), .0f, std::max(.0f, m_contentsSize.height() - floorf(m_viewportSize.height() / scale))));
}
FloatPoint SimpleViewportController::boundContentsPosition(const FloatPoint& framePosition) const
{
return boundContentsPositionAtScale(framePosition, m_pageScaleFactor);
}
bool fuzzyCompare(float a, float b, float epsilon)
{
return std::abs(a - b) < epsilon;
}
bool SimpleViewportController::updateMinimumScaleToFit()
{
if (m_viewportSize.isEmpty() || m_contentsSize.isEmpty() || !m_hasViewportAttribute)
return false;
bool currentlyScaledToFit = fuzzyCompare(m_pageScaleFactor, m_minimumScaleToFit, 0.0001);
float minimumScale = computeMinimumScaleFactorForContentContained(m_rawAttributes, roundedIntSize(m_viewportSize), roundedIntSize(m_contentsSize));
if (minimumScale <= 0)
return false;
if (!fuzzyCompare(minimumScale, m_minimumScaleToFit, 0.0001)) {
m_minimumScaleToFit = minimumScale;
if (currentlyScaledToFit)
m_pageScaleFactor = m_minimumScaleToFit;
else {
float boundedScale = innerBoundedViewportScale(m_pageScaleFactor);
if (!fuzzyCompare(boundedScale, m_pageScaleFactor, 0.0001))
m_pageScaleFactor = boundedScale;
}
return true;
}
return false;
}
float SimpleViewportController::innerBoundedViewportScale(float viewportScale) const
{
return clampTo(viewportScale, m_minimumScaleToFit, m_rawAttributes.maximumScale);
}
void SimpleViewportController::resetViewportToDefaultState()
{
m_hasViewportAttribute = false;
m_pageScaleFactor = 1;
m_minimumScaleToFit = 1;
m_rawAttributes.minimumScale = 1;
m_rawAttributes.maximumScale = 1;
m_rawAttributes.userScalable = m_allowsUserScaling;
m_rawAttributes.initialScale = -1;
}
}
#endif // USE(COORDINATED_GRAPHICS_THREADED)