void QtViewportHandler::setCSSScale(qreal scale)
{
ViewportUpdateDeferrer guard(this);
qreal newScale = innerBoundedCSSScale(scale);
m_pageItem->setContentsScale(itemScaleFromCSS(newScale));
}
void QtViewportInteractionEngine::setCSSScale(qreal scale)
{
ViewportUpdateDeferrer guard(this);
qreal newScale = innerBoundedCSSScale(scale);
m_content->setContentsScale(itemScaleFromCSS(newScale));
}
void QtViewportInteractionEngine::focusEditableArea(const QRectF& caretArea, const QRectF& targetArea)
{
QRectF endArea = itemRectFromCSS(targetArea);
qreal endItemScale = itemScaleFromCSS(innerBoundedCSSScale(2.0));
const QRectF viewportRect = m_viewport->boundingRect();
qreal x;
const qreal borderOffset = 10;
if ((endArea.width() + borderOffset) * endItemScale <= viewportRect.width()) {
// Center the input field in the middle of the view, if it is smaller than
// the view at the scale target.
x = viewportRect.center().x() - endArea.width() * endItemScale / 2.0;
} else {
// Ensure that the caret always has borderOffset contents pixels to the right
// of it, and secondarily (if possible), that the area has borderOffset
// contents pixels to the left of it.
qreal caretOffset = itemCoordFromCSS(caretArea.x()) - endArea.x();
x = qMin(viewportRect.width() - (caretOffset + borderOffset) * endItemScale, borderOffset * endItemScale);
}
const QPointF hotspot = QPointF(endArea.x(), endArea.center().y());
const QPointF viewportHotspot = QPointF(x, /* FIXME: visibleCenter */ viewportRect.center().y());
QPointF endPosition = hotspot * endItemScale - viewportHotspot;
QRectF endPosRange = computePosRangeForItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
QRectF endVisibleContentRect(endPosition / endItemScale, viewportRect.size() / endItemScale);
animateItemRectVisible(endVisibleContentRect);
}
bool QtViewportInteractionEngine::ensureContentWithinViewportBoundary(bool immediate)
{
ASSERT(m_suspendCount);
if (scrollAnimationActive() || scaleAnimationActive())
return false;
qreal endItemScale = itemScaleFromCSS(innerBoundedCSSScale(currentCSSScale()));
const QRectF viewportRect = m_viewport->boundingRect();
QPointF viewportHotspot = viewportRect.center();
QPointF endPosition = m_viewport->mapToWebContent(viewportHotspot) * endItemScale - viewportHotspot;
QRectF endPosRange = computePosRangeForItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
QRectF endVisibleContentRect(endPosition / endItemScale, viewportRect.size() / endItemScale);
if (immediate) {
setItemRectVisible(endVisibleContentRect);
return true;
}
return !animateItemRectVisible(endVisibleContentRect);
}
void QtViewportInteractionEngine::zoomToAreaGestureEnded(const QPointF& touchPoint, const QRectF& targetArea)
{
if (!targetArea.isValid())
return;
if (scrollAnimationActive() || scaleAnimationActive())
return;
const int margin = 10; // We want at least a little bit or margin.
QRectF endArea = itemRectFromCSS(targetArea.adjusted(-margin, -margin, margin, margin));
const QRectF viewportRect = m_viewport->boundingRect();
qreal targetCSSScale = cssScaleFromItem(viewportRect.size().width() / endArea.size().width());
qreal endItemScale = itemScaleFromCSS(innerBoundedCSSScale(qMin(targetCSSScale, qreal(2.5))));
// We want to end up with the target area filling the whole width of the viewport (if possible),
// and centralized vertically where the user requested zoom. Thus our hotspot is the center of
// the targetArea x-wise and the requested zoom position, y-wise.
const QPointF hotspot = QPointF(endArea.center().x(), touchPoint.y() * m_constraints.devicePixelRatio);
const QPointF viewportHotspot = viewportRect.center();
QPointF endPosition = hotspot * endItemScale - viewportHotspot;
QRectF endPosRange = computePosRangeForItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
QRectF endVisibleContentRect(endPosition / endItemScale, viewportRect.size() / endItemScale);
animateItemRectVisible(endVisibleContentRect);
}
void QtViewportInteractionEngine::scaleContent(const QPointF& centerInCSSCoordinates, qreal cssScale)
{
QPointF oldPinchCenterOnViewport = m_viewport->mapFromWebContent(centerInCSSCoordinates);
m_content->setContentsScale(itemScaleFromCSS(cssScale));
QPointF newPinchCenterOnViewport = m_viewport->mapFromWebContent(centerInCSSCoordinates);
m_content->setPos(m_content->pos() - (newPinchCenterOnViewport - oldPinchCenterOnViewport));
}
void QtViewportHandler::scaleContent(const QPointF& centerInCSSCoordinates, qreal cssScale)
{
QPointF oldPinchCenterOnViewport = m_viewportItem->mapFromWebContent(centerInCSSCoordinates);
m_pageItem->setContentsScale(itemScaleFromCSS(cssScale));
QPointF newPinchCenterOnViewport = m_viewportItem->mapFromWebContent(centerInCSSCoordinates);
m_viewportItem->setContentPos(m_viewportItem->contentPos() + (newPinchCenterOnViewport - oldPinchCenterOnViewport));
}
QRectF QtViewportHandler::initialRect() const
{
ASSERT(m_rawAttributes.initialScale > 0);
qreal endItemScale = itemScaleFromCSS(innerBoundedCSSScale(m_rawAttributes.initialScale));
const QRectF viewportRect = m_viewportItem->boundingRect();
QRectF endVisibleContentRect(QPointF(0, 0), viewportRect.size() / endItemScale);
return endVisibleContentRect;
}
QRectF QtViewportHandler::nearestValidBounds() const
{
qreal endItemScale = itemScaleFromCSS(innerBoundedCSSScale(currentCSSScale()));
const QRectF viewportRect = m_viewportItem->boundingRect();
QPointF viewportHotspot = viewportRect.center();
QPointF endPosition = m_viewportItem->mapToWebContent(viewportHotspot) * endItemScale - viewportHotspot;
QRectF endPosRange = computePosRangeForPageItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
QRectF endVisibleContentRect(endPosition / endItemScale, viewportRect.size() / endItemScale);
return endVisibleContentRect;
}
void QtViewportInteractionEngine::applyConstraints(const Constraints& constraints)
{
// We always have to apply the constrains even if they didn't change, as
// the initial scale might need to be applied.
ViewportUpdateDeferrer guard(this);
m_constraints = constraints;
if (!m_hadUserInteraction) {
qreal initialScale = innerBoundedCSSScale(m_constraints.initialScale);
m_content->setContentsScale(itemScaleFromCSS(initialScale));
}
// If the web app changes successively changes the viewport on purpose
// it wants to be in control and we should disable animations.
ensureContentWithinViewportBoundary(/* immediate */ true);
}
void QtViewportHandler::zoomToAreaGestureEnded(const QPointF& touchPoint, const QRectF& targetArea)
{
// This can only happen as a result of a user interaction.
ASSERT(m_hadUserInteraction);
if (!targetArea.isValid())
return;
if (m_suspendCount)
return;
const int margin = 10; // We want at least a little bit of margin.
QRectF endArea = itemRectFromCSS(targetArea.adjusted(-margin, -margin, margin, margin));
const QRectF viewportRect = m_viewportItem->boundingRect();
qreal targetCSSScale = viewportRect.size().width() / endArea.size().width();
qreal endCSSScale = innerBoundedCSSScale(qMin(targetCSSScale, qreal(2.5)));
qreal endItemScale = itemScaleFromCSS(endCSSScale);
qreal currentScale = m_pageItem->contentsScale();
// We want to end up with the target area filling the whole width of the viewport (if possible),
// and centralized vertically where the user requested zoom. Thus our hotspot is the center of
// the targetArea x-wise and the requested zoom position, y-wise.
const QPointF hotspot = QPointF(endArea.center().x(), itemCoordFromCSS(touchPoint.y()));
const QPointF viewportHotspot = viewportRect.center();
QPointF endPosition = hotspot * endCSSScale - viewportHotspot;
QRectF endPosRange = computePosRangeForPageItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
QRectF endVisibleContentRect(endPosition / endItemScale, viewportRect.size() / endItemScale);
enum { ZoomIn, ZoomBack, ZoomOut, NoZoom } zoomAction = ZoomIn;
if (!m_scaleStack.isEmpty()) {
// Zoom back out if attempting to scale to the same current scale, or
// attempting to continue scaling out from the inner most level.
// Use fuzzy compare with a fixed error to be able to deal with largish differences due to pixel rounding.
if (fuzzyCompare(endItemScale, currentScale, 0.01)) {
// If moving the viewport would expose more of the targetRect and move at least 40 pixels, update position but do not scale out.
QRectF currentContentRect(m_viewportItem->contentPos() / currentScale, viewportRect.size() / currentScale);
QRectF targetIntersection = endVisibleContentRect.intersected(targetArea);
if (!currentContentRect.contains(targetIntersection) && (qAbs(endVisibleContentRect.top() - currentContentRect.top()) >= 40 || qAbs(endVisibleContentRect.left() - currentContentRect.left()) >= 40))
zoomAction = NoZoom;
else
zoomAction = ZoomBack;
} else if (fuzzyCompare(endItemScale, m_zoomOutScale, 0.01))
zoomAction = ZoomBack;
else if (endItemScale < currentScale)
zoomAction = ZoomOut;
}
switch (zoomAction) {
case ZoomIn:
m_scaleStack.append(ScaleStackItem(currentScale, m_viewportItem->contentPos().x()));
m_zoomOutScale = endItemScale;
break;
case ZoomBack: {
ScaleStackItem lastScale = m_scaleStack.takeLast();
endItemScale = lastScale.scale;
endCSSScale = cssScaleFromItem(lastScale.scale);
// Recalculate endPosition and bound it according to new scale.
endPosition.setY(hotspot.y() * endCSSScale - viewportHotspot.y());
endPosition.setX(lastScale.xPosition);
endPosRange = computePosRangeForPageItemAtScale(endItemScale);
endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight());
endVisibleContentRect = QRectF(endPosition / endItemScale, viewportRect.size() / endItemScale);
break;
}
case ZoomOut:
// Unstack all scale-levels deeper than the new level, so a zoom-back won't end up zooming in.
while (!m_scaleStack.isEmpty() && m_scaleStack.last().scale >= endItemScale)
m_scaleStack.removeLast();
m_zoomOutScale = endItemScale;
break;
case NoZoom:
break;
}
animatePageItemRectVisible(endVisibleContentRect);
}
