Changeset 130545 in webkit

Timestamp:

Oct 5, 2012, 1:30:59 PM (13 years ago)

Author:

commit-queue@webkit.org

Message:

[chromium] Support zooming focused node for mobile devices
​https://bugs.webkit.org/show_bug.cgi?id=97958

Patch by Yusuf Ozuysal <​yusufo@google.com> on 2012-10-05
Reviewed by Adam Barth.

This unforks the Android version of scrollFocusedNodeIntoRect().A new setting
autoZoomFocusedNodeToLegibleScale was added to turn it on, since not all
platforms with ENABLE(GESTURE_EVENTS) want this.

Test: WebFrameTest.DivScrollIntoEditableTest

• public/WebSettings.h:
• src/WebSettingsImpl.cpp:

(WebKit::WebSettingsImpl::WebSettingsImpl):
(WebKit::WebSettingsImpl::setAutoZoomFocusedNodeToLegibleScale):
(WebKit):

• src/WebSettingsImpl.h:

(WebSettingsImpl):
(WebKit::WebSettingsImpl::autoZoomFocusedNodeToLegibleScale):

• src/WebViewImpl.cpp:

(WebKit::WebViewImpl::scrollFocusedNodeIntoRect):

• tests/WebFrameTest.cpp:
• tests/data/get_scale_for_zoom_into_editable_test.html: Added.

Location:

trunk/Source/WebKit/chromium

Files:

• ChangeLog (modified) (1 diff)
• public/WebSettings.h (modified) (1 diff)
• src/WebSettingsImpl.cpp (modified) (2 diffs)
• src/WebSettingsImpl.h (modified) (3 diffs)
• src/WebViewImpl.cpp (modified) (2 diffs)
• tests/WebFrameTest.cpp (modified) (1 diff)
• tests/data/get_scale_for_zoom_into_editable_test.html (added)

trunk/Source/WebKit/chromium/ChangeLog

@@ +1 @@
+2012-10-05  Yusuf Ozuysal  <yusufo@google.com>
+
+        [chromium] Support zooming focused node for mobile devices
+        https://bugs.webkit.org/show_bug.cgi?id=97958
+
+        Reviewed by Adam Barth.
+
+        This unforks the Android version of scrollFocusedNodeIntoRect().A new setting
+        autoZoomFocusedNodeToLegibleScale was added to turn it on, since not all
+        platforms with ENABLE(GESTURE_EVENTS) want this.
+
+        Test: WebFrameTest.DivScrollIntoEditableTest
+
+        * public/WebSettings.h:
+        * src/WebSettingsImpl.cpp:
+        (WebKit::WebSettingsImpl::WebSettingsImpl):
+        (WebKit::WebSettingsImpl::setAutoZoomFocusedNodeToLegibleScale):
+        (WebKit):
+        * src/WebSettingsImpl.h:
+        (WebSettingsImpl):
+        (WebKit::WebSettingsImpl::autoZoomFocusedNodeToLegibleScale):
+        * src/WebViewImpl.cpp:
+        (WebKit::WebViewImpl::scrollFocusedNodeIntoRect):
+        * tests/WebFrameTest.cpp:
+        * tests/data/get_scale_for_zoom_into_editable_test.html: Added.
+
 2012-10-05  W. James MacLean  <wjmaclean@chromium.org>
 

trunk/Source/WebKit/chromium/public/WebSettings.h

@@ -75 +75 @@
     virtual void setApplyPageScaleFactorInCompositor(bool) = 0;
     virtual void setAsynchronousSpellCheckingEnabled(bool) = 0;
+    virtual void setAutoZoomFocusedNodeToLegibleScale(bool) = 0;
     virtual void setAuthorAndUserStylesEnabled(bool) = 0;
     virtual void setCaretBrowsingEnabled(bool) = 0;

trunk/Source/WebKit/chromium/src/WebSettingsImpl.cpp

@@ -55 +55 @@
     , m_applyDefaultDeviceScaleFactorInCompositor(false)
     , m_gestureTapHighlightEnabled(true)
+    , m_autoZoomFocusedNodeToLegibleScale(false)
     , m_defaultTileSize(WebSize(256, 256))
     , m_maxUntiledLayerSize(WebSize(512, 512))
@@ -146 +147 @@
 }
 
+void WebSettingsImpl::setAutoZoomFocusedNodeToLegibleScale(bool autoZoomFocusedNodeToLegibleScale)
+{
+    m_autoZoomFocusedNodeToLegibleScale = autoZoomFocusedNodeToLegibleScale;
+}
+
 void WebSettingsImpl::setTextAutosizingEnabled(bool enabled)
 {

trunk/Source/WebKit/chromium/src/WebSettingsImpl.h

@@ -68 +68 @@
     virtual void setAsynchronousSpellCheckingEnabled(bool);
     virtual void setAuthorAndUserStylesEnabled(bool);
+    virtual void setAutoZoomFocusedNodeToLegibleScale(bool);
     virtual void setCaretBrowsingEnabled(bool);
     virtual void setCookieEnabled(bool);
@@ -163 +164 @@
     bool applyDefaultDeviceScaleFactorInCompositor() const { return m_applyDefaultDeviceScaleFactorInCompositor; }
     bool applyPageScaleFactorInCompositor() const;
+    bool autoZoomFocusedNodeToLegibleScale() const { return m_autoZoomFocusedNodeToLegibleScale; }
     bool gestureTapHighlightEnabled() { return m_gestureTapHighlightEnabled; }
     WebSize defaultTileSize() const { return m_defaultTileSize; }
@@ -176 +178 @@
     bool m_applyDefaultDeviceScaleFactorInCompositor;
     bool m_gestureTapHighlightEnabled;
+    bool m_autoZoomFocusedNodeToLegibleScale;
     WebSize m_defaultTileSize;
     WebSize m_maxUntiledLayerSize;

trunk/Source/WebKit/chromium/src/WebViewImpl.cpp

@@ -201 +201 @@
 // Constants for zooming in on a focused text field.
 static const double scrollAndScaleAnimationDurationInSeconds = 0.2;
+static const int minReadableCaretHeight = 18;
+static const float minScaleChangeToTriggerZoom = 1.05f;
+static const float leftBoxRatio = 0.3f;
+static const int caretPadding = 10;
 
 namespace WebKit {
@@ -2639 +2643 @@
     if (!frame || !frame->view() || !focusedNode || !focusedNode->isElementNode())
         return;
-    Element* elementNode = static_cast<Element*>(focusedNode);
-    frame->view()->scrollElementToRect(elementNode, IntRect(rect.x, rect.y, rect.width, rect.height));
+
+    if (!m_webSettings->autoZoomFocusedNodeToLegibleScale()) {
+        Element* elementNode = static_cast<Element*>(focusedNode);
+        frame->view()->scrollElementToRect(elementNode, IntRect(rect.x, rect.y, rect.width, rect.height));
+        return;
+    }
+
+#if ENABLE(GESTURE_EVENTS)
+    focusedNode->document()->updateLayoutIgnorePendingStylesheets();
+
+    // 'caret' is rect encompassing the blinking cursor.
+    IntRect textboxRect = focusedNode->document()->view()->contentsToWindow(pixelSnappedIntRect(focusedNode->Node::boundingBox()));
+    WebRect caret, end;
+    selectionBounds(caret, end);
+
+    // Pick a scale which is reasonably readable. This is the scale at which
+    // the caret height will become minReadableCaretHeight (adjusted for dpi
+    // and font scale factor).
+    float targetScale = deviceScaleFactor();
+#if ENABLE(TEXT_AUTOSIZING)
+    if (page() && page()->settings())
+        targetScale *= page()->settings()->textAutosizingFontScaleFactor();
+#endif
+    const float newScale = clampPageScaleFactorToLimits(pageScaleFactor() * minReadableCaretHeight * targetScale / caret.height);
+    const float deltaScale = newScale / pageScaleFactor();
+
+    // Convert the rects to absolute space in the new scale.
+    IntRect textboxRectInDocumentCoordinates = textboxRect;
+    textboxRectInDocumentCoordinates.move(mainFrame()->scrollOffset());
+    textboxRectInDocumentCoordinates.scale(deltaScale);
+    IntRect caretInDocumentCoordinates = caret;
+    caretInDocumentCoordinates.move(mainFrame()->scrollOffset());
+    caretInDocumentCoordinates.scale(deltaScale);
+
+    IntPoint newOffset;
+    if (textboxRectInDocumentCoordinates.width() <= m_size.width) {
+        // Field is narrower than screen. Try to leave padding on left so field's
+        // label is visible, but it's more important to ensure entire field is
+        // onscreen.
+        int idealLeftPadding = m_size.width * leftBoxRatio;
+        int maxLeftPaddingKeepingBoxOnscreen = m_size.width - textboxRectInDocumentCoordinates.width();
+        newOffset.setX(textboxRectInDocumentCoordinates.x() - min<int>(idealLeftPadding, maxLeftPaddingKeepingBoxOnscreen));
+    } else {
+        // Field is wider than screen. Try to left-align field, unless caret would
+        // be offscreen, in which case right-align the caret.
+        newOffset.setX(max<int>(textboxRectInDocumentCoordinates.x(), caretInDocumentCoordinates.x() + caretInDocumentCoordinates.width() + caretPadding - m_size.width));
+    }
+    if (textboxRectInDocumentCoordinates.height() <= m_size.height) {
+        // Field is shorter than screen. Vertically center it.
+        newOffset.setY(textboxRectInDocumentCoordinates.y() - (m_size.height - textboxRectInDocumentCoordinates.height()) / 2);
+    } else {
+        // Field is taller than screen. Try to top align field, unless caret would
+        // be offscreen, in which case bottom-align the caret.
+        newOffset.setY(max<int>(textboxRectInDocumentCoordinates.y(), caretInDocumentCoordinates.y() + caretInDocumentCoordinates.height() + caretPadding - m_size.height));
+    }
+
+    bool needAnimation = false;
+    // If we are at less than the target zoom level, zoom in.
+    if (deltaScale > minScaleChangeToTriggerZoom)
+        needAnimation = true;
+    // If the caret is offscreen, then animate.
+    IntRect sizeRect(0, 0, m_size.width, m_size.height);
+    if (!sizeRect.contains(caret))
+        needAnimation = true;
+    // If the box is partially offscreen and it's possible to bring it fully
+    // onscreen, then animate.
+    if (sizeRect.contains(textboxRectInDocumentCoordinates.width(), textboxRectInDocumentCoordinates.height()) && !sizeRect.contains(textboxRect))
+        needAnimation = true;
+
+    if (needAnimation)
+        startPageScaleAnimation(newOffset, false, newScale, scrollAndScaleAnimationDurationInSeconds);
+#endif
 }
 

trunk/Source/WebKit/chromium/tests/WebFrameTest.cpp

@@ -497 +497 @@
     EXPECT_FLOAT_EQ(webViewImpl->minimumPageScaleFactor(), scale);
 }
+
+TEST_F(WebFrameTest, DivScrollIntoEditableTest)
+{
+    registerMockedHttpURLLoad("get_scale_for_zoom_into_editable_test.html");
+
+    DivAutoZoomTestWebViewClient client;
+    int viewportWidth = 640;
+    int viewportHeight = 480;
+    float LeftBoxRatio = 0.3;
+    int caretPadding = 10;
+    int minReadableCaretHeight = 18;
+    client.m_windowRect = WebRect(0, 0, viewportWidth, viewportHeight);
+    WebKit::WebView* webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "get_scale_for_zoom_into_editable_test.html", true, 0, &client);
+    webView->enableFixedLayoutMode(true);
+    webView->resize(WebSize(viewportWidth, viewportHeight));
+    webView->setPageScaleFactorLimits(1, 10);
+    webView->layout();
+    webView->setDeviceScaleFactor(1.5f);
+    webView->settings()->setAutoZoomFocusedNodeToLegibleScale(true);
+
+    WebViewImpl* webViewImpl = static_cast<WebViewImpl*>(webView);
+    webViewImpl->shouldUseAnimateDoubleTapTimeZeroForTesting(true);
+
+    WebRect editBoxWithText(200, 200, 250, 20);
+    WebRect editBoxWithNoText(200, 250, 250, 20);
+
+    // Test scrolling the focused node
+    // The edit box is shorter and narrower than the viewport when legible.
+    setScaleAndScrollAndLayout(webView, WebPoint(0, 0), 1);
+    WebRect rect, caret;
+    webViewImpl->selectionBounds(caret, rect);
+    webView->scrollFocusedNodeIntoRect(rect);
+    // The edit box should be left aligned with a margin for possible label.
+    int hScroll = editBoxWithText.x * webView->pageScaleFactor() - LeftBoxRatio * viewportWidth;
+    EXPECT_EQ(hScroll, webView->mainFrame()->scrollOffset().width);
+    int vScroll = editBoxWithText.y * webView->pageScaleFactor() - (viewportHeight - editBoxWithText.height * webView->pageScaleFactor()) / 2;
+    EXPECT_EQ(vScroll, webView->mainFrame()->scrollOffset().height);
+    EXPECT_FLOAT_EQ(webView->deviceScaleFactor() * minReadableCaretHeight / caret.height, webView->pageScaleFactor());
+
+    // The edit box is wider than the viewport when legible.
+    webView->setDeviceScaleFactor(4);
+    setScaleAndScrollAndLayout(webView, WebPoint(0, 0), 1);
+    webViewImpl->selectionBounds(caret, rect);
+    webView->scrollFocusedNodeIntoRect(rect);
+    // The caret should be right aligned since the caret would be offscreen when the edit box is left aligned.
+    hScroll = (caret.x + caret.width) * webView->pageScaleFactor() + caretPadding - viewportWidth;
+    EXPECT_EQ(hScroll, webView->mainFrame()->scrollOffset().width);
+    EXPECT_FLOAT_EQ(webView->deviceScaleFactor() * minReadableCaretHeight / caret.height, webView->pageScaleFactor());
+
+    setScaleAndScrollAndLayout(webView, WebPoint(0, 0), 1);
+    // Move focus to edit box with text.
+    webView->advanceFocus(false);
+    webViewImpl->selectionBounds(caret, rect);
+    webView->scrollFocusedNodeIntoRect(rect);
+    // The edit box should be left aligned.
+    hScroll = editBoxWithNoText.x * webView->pageScaleFactor();
+    EXPECT_EQ(hScroll, webView->mainFrame()->scrollOffset().width);
+    vScroll = editBoxWithNoText.y * webView->pageScaleFactor() - (viewportHeight - editBoxWithNoText.height * webView->pageScaleFactor()) / 2;
+    EXPECT_EQ(vScroll, webView->mainFrame()->scrollOffset().height);
+    EXPECT_FLOAT_EQ(webView->deviceScaleFactor() * minReadableCaretHeight / caret.height, webView->pageScaleFactor());
+
+    // Move focus back to the first edit box.
+    webView->advanceFocus(true);
+    webViewImpl->selectionBounds(caret, rect);
+    // The position should have stayed the same since this box was already on screen with the right scale.
+    EXPECT_EQ(vScroll, webView->mainFrame()->scrollOffset().height);
+    EXPECT_EQ(hScroll, webView->mainFrame()->scrollOffset().width);
+}
 #endif