Changeset 147744 in webkit


Ignore:
Timestamp:
Apr 5, 2013 7:45:19 AM (11 years ago)
Author:
commit-queue@webkit.org
Message:

[BlackBerry] Replace map{From,To}Transformed() with ViewportAccessor
​https://bugs.webkit.org/show_bug.cgi?id=113449

Patch by Jakob Petsovits <​jpetsovits@blackberry.com> on 2013-04-05
Reviewed by Rob Buis.

This removes the WebPage/BackingStoreClient family of coordinate
transformation functions, which were widely disliked for their
naming, with ViewportAccessor API that had previously been
introduced for limited use cases. This commit takes care of the
remaining call sites and leaves us with a single API to use.

No new tests, only a clean-up/refactor of existing code & functionality.

  • Api/BackingStore.cpp:

(BlackBerry::WebKit::BackingStorePrivate::repaint):
(BlackBerry::WebKit::BackingStorePrivate::slowScroll):
(BlackBerry::WebKit::BackingStorePrivate::visibleContentsRect):
(BlackBerry::WebKit::BackingStorePrivate::unclippedVisibleContentsRect):
(BlackBerry::WebKit::BackingStorePrivate::blitVisibleContents):
(BlackBerry::WebKit::BackingStorePrivate::expandedContentsSize):

  • Api/InRegionScroller.cpp:

(BlackBerry::WebKit::InRegionScrollerPrivate::clipToRect):

  • Api/WebPage.cpp:

(BlackBerry::WebKit::WebPagePrivate::WebPagePrivate):
(BlackBerry::WebKit::WebPagePrivate::init):
(BlackBerry::WebKit::WebPagePrivate::scrollPosition):
(BlackBerry::WebKit::WebPagePrivate::maximumScrollPosition):
(BlackBerry::WebKit::WebPagePrivate::setScrollPosition):
(BlackBerry::WebKit::WebPagePrivate::viewportSize):
(BlackBerry::WebKit::WebPagePrivate::actualVisibleSize):
(BlackBerry::WebKit::WebPagePrivate::layoutFinished):
(BlackBerry::WebKit::WebPagePrivate::notifyTransformedContentsSizeChanged):
(BlackBerry::WebKit::WebPagePrivate::updateCursor):
(BlackBerry::WebKit::WebPagePrivate::focusNodeRect):
(BlackBerry::WebKit::WebPagePrivate::contextNode):
(BlackBerry::WebKit::WebPagePrivate::blockZoomRectForNode):
(BlackBerry::WebKit::WebPagePrivate::zoomAnimationFinished):
(BlackBerry::WebKit::WebPagePrivate::handleMouseEvent):
(BlackBerry::WebKit::WebPage::blockZoom):

  • Api/WebPage_p.h:

(WebPagePrivate):

  • WebKitSupport/BackingStoreClient.cpp:

(BlackBerry::WebKit::BackingStoreClient::transformedScrollPosition):
(BlackBerry::WebKit::BackingStoreClient::transformedMaximumScrollPosition):
(BlackBerry::WebKit::BackingStoreClient::actualVisibleSize):
(BlackBerry::WebKit::BackingStoreClient::transformedActualVisibleSize):

  • WebKitSupport/BackingStoreClient.h:

(BackingStoreClient):

  • WebKitSupport/FatFingers.cpp:

(BlackBerry::WebKit::FatFingers::fingerRectForPoint):
(BlackBerry::WebKit::FatFingers::FatFingers):
(BlackBerry::WebKit::FatFingers::findBestPoint):
(BlackBerry::WebKit::FatFingers::findIntersectingRegions):
(BlackBerry::WebKit::FatFingers::getNodesFromRect):

  • WebKitSupport/InRegionScrollableArea.cpp:

(BlackBerry::WebKit::InRegionScrollableArea::InRegionScrollableArea):

  • WebKitSupport/InputHandler.cpp:

(BlackBerry::WebKit::InputHandler::ensureFocusTextElementVisible):

  • WebKitSupport/TouchEventHandler.cpp:

(BlackBerry::WebKit::TouchEventHandler::sendClickAtFatFingersPoint):
(BlackBerry::WebKit::TouchEventHandler::handleTouchPoint):
(BlackBerry::WebKit::TouchEventHandler::handleFatFingerPressed):

  • WebKitSupport/WebKitThreadViewportAccessor.cpp:

(BlackBerry::WebKit::WebKitThreadViewportAccessor::pixelContentsSize):
(BlackBerry::WebKit::WebKitThreadViewportAccessor::pixelScrollPosition):
(BlackBerry::WebKit::WebKitThreadViewportAccessor::documentViewportSize):

Location:
trunk/Source/WebKit/blackberry
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/blackberry/Api/BackingStore.cpp

    r147136 r147744  
    437437
    438438    if (contentChanged && !windowRect.isEmpty()) {
    439         // This windowRect is in untransformed coordinates relative to the viewport, but
    440         // it needs to be transformed coordinates relative to the transformed contents.
    441         Platform::IntRect rect = m_webPage->d->mapToTransformed(m_client->mapFromViewportToContents(windowRect));
    442         rect.inflate(1 /*dx*/, 1 /*dy*/); // Account for anti-aliasing of previous rendering runs.
    443 
    444         // FIXME: This should not explicitely depend on WebCore::.
    445         WebCore::IntRect tmpRect = rect;
    446         m_client->clipToTransformedContentsRect(tmpRect);
    447 
    448         rect = tmpRect;
     439        // This windowRect is in document coordinates relative to the viewport,
     440        // but we need it in pixel contents coordinates.
     441        const Platform::ViewportAccessor* viewportAccessor = m_webPage->webkitThreadViewportAccessor();
     442        Platform::IntRect rect = viewportAccessor->roundToPixelFromDocumentContents(viewportAccessor->documentContentsFromViewport(windowRect));
     443        rect.intersect(viewportAccessor->pixelContentsRect());
     444
    449445        if (rect.isEmpty())
    450446            return;
    … …  
    476472    scrollingStartedHelper(delta);
    477473
    478     // This windowRect is in untransformed coordinates relative to the viewport, but
    479     // it needs to be transformed coordinates relative to the transformed contents.
    480     Platform::IntRect rect = m_webPage->d->mapToTransformed(m_client->mapFromViewportToContents(windowRect));
     474    // This windowRect is in document coordinates relative to the viewport,
     475    // but we need it in pixel contents coordinates.
     476    const Platform::ViewportAccessor* viewportAccessor = m_webPage->webkitThreadViewportAccessor();
     477    const Platform::IntRect rect = viewportAccessor->roundToPixelFromDocumentContents(viewportAccessor->documentContentsFromViewport(windowRect));
    481478
    482479    if (immediate)
    … …  
    595592Platform::IntRect BackingStorePrivate::visibleContentsRect() const
    596593{
    597     return intersection(m_client->transformedVisibleContentsRect(),
    598                         Platform::IntRect(Platform::IntPoint(0, 0), m_client->transformedContentsSize()));
     594    const Platform::ViewportAccessor* viewportAccessor = m_webPage->webkitThreadViewportAccessor();
     595    Platform::IntRect rect = viewportAccessor->pixelViewportRect();
     596    rect.intersect(viewportAccessor->pixelContentsRect());
     597    return rect;
    599598}
    600599
    601600Platform::IntRect BackingStorePrivate::unclippedVisibleContentsRect() const
    602601{
    603     return m_client->transformedVisibleContentsRect();
     602    const Platform::ViewportAccessor* viewportAccessor = m_webPage->webkitThreadViewportAccessor();
     603    return viewportAccessor->pixelViewportRect();
    604604}
    605605
    … …  
    12421242        double currentScale = geometry->scale();
    12431243
    1244         const Platform::IntRect transformedContentsRect = Platform::IntRect(Platform::IntPoint(0, 0), m_client->transformedContentsSize());
     1244        const Platform::IntRect transformedContentsRect = currentScale == viewportAccessor->scale()
     1245            ? viewportAccessor->pixelContentsRect()
     1246            : viewportAccessor->roundFromDocumentContents(viewportAccessor->documentContentsRect(), currentScale);
    12451247
    12461248        // For blitting backingstore tiles, we need the srcRect to be specified
    … …  
    18021804Platform::IntSize BackingStorePrivate::expandedContentsSize() const
    18031805{
    1804     return m_client->transformedContentsSize().expandedTo(m_client->transformedViewportSize());
     1806    const Platform::ViewportAccessor* viewportAccessor = m_webPage->webkitThreadViewportAccessor();
     1807    return m_client->transformedViewportSize().expandedTo(viewportAccessor->pixelContentsSize());
    18051808}
    18061809

  • trunk/Source/WebKit/blackberry/Api/InRegionScroller.cpp

    r145720 r147744  
    3636#include "RenderView.h"
    3737#include "SelectionHandler.h"
     38#include "WebKitThreadViewportAccessor.h"
    3839#include "WebPage_p.h"
     40
     41#include <BlackBerryPlatformViewportAccessor.h>
    3942
    4043using namespace WebCore;
    … …  
    210213        return clippingRect;
    211214
     215    const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     216
    212217    if (layer->renderer()->isRenderView()) { // #document case
    213218        FrameView* view = toRenderView(layer->renderer())->frameView();
    … …  
    215220        ASSERT(canScrollInnerFrame(view->frame()));
    216221
    217         WebCore::IntRect frameWindowRect = m_webPage->mapToTransformed(m_webPage->getRecursiveVisibleWindowRect(view));
     222        WebCore::IntRect frameWindowRect = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatRect(m_webPage->getRecursiveVisibleWindowRect(view)));
    218223        frameWindowRect.intersect(clippingRect);
    219224        return frameWindowRect;
    … …  
    227232    WebCore::IntRect visibleWindowRect = enclosingIntRect(box->absoluteClippedOverflowRect());
    228233    visibleWindowRect = box->frame()->view()->contentsToWindow(visibleWindowRect);
    229     visibleWindowRect = m_webPage->mapToTransformed(visibleWindowRect);
     234    visibleWindowRect = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatRect(visibleWindowRect));
    230235    visibleWindowRect.intersect(clippingRect);
    231236    return visibleWindowRect;

  • trunk/Source/WebKit/blackberry/Api/WebPage.cpp

    r147687 r147744  
    176176#include <JavaScriptCore/JSStringRef.h>
    177177#include <SharedPointer.h>
     178#include <cmath>
    178179#include <sys/keycodes.h>
    179180#include <unicode/ustring.h> // platform ICU
    … …  
    388389    , m_backingStore(0) // Initialized by init.
    389390    , m_backingStoreClient(0) // Initialized by init.
    390     , m_webkitThreadViewportAccessor(0) // Initialized by init.
     391    , m_webkitThreadViewportAccessor(new WebKitThreadViewportAccessor(this))
    391392    , m_inPageSearchManager(new InPageSearchManager(this))
    392393    , m_inputHandler(new InputHandler(this))
    … …  
    630631    m_backingStore = m_backingStoreClient->backingStore();
    631632
    632     m_webkitThreadViewportAccessor = new WebKitThreadViewportAccessor(this);
    633 
    634633    blockClickRadius = int(roundf(0.35 * Platform::Graphics::Screen::primaryScreen()->pixelsPerInch(0).width())); // The clicked rectangle area should be a fixed unit of measurement.
    635634
    … …  
    13351334IntPoint WebPagePrivate::scrollPosition() const
    13361335{
     1336    if (!m_backingStoreClient)
     1337        return IntPoint();
     1338
    13371339    return m_backingStoreClient->scrollPosition();
    13381340}
    … …  
    13401342IntPoint WebPagePrivate::maximumScrollPosition() const
    13411343{
     1344    if (!m_backingStoreClient)
     1345        return IntPoint();
     1346
    13421347    return m_backingStoreClient->maximumScrollPosition();
    13431348}
    … …  
    13451350void WebPagePrivate::setScrollPosition(const IntPoint& pos)
    13461351{
     1352    ASSERT(m_backingStoreClient);
    13471353    m_backingStoreClient->setScrollPosition(pos);
    13481354}
    … …  
    14491455IntSize WebPagePrivate::viewportSize() const
    14501456{
    1451     return mapFromTransformed(transformedViewportSize());
     1457    return m_webkitThreadViewportAccessor->roundToDocumentFromPixelContents(Platform::IntRect(Platform::IntPoint::zero(), transformedViewportSize())).size();
    14521458}
    14531459
    14541460IntSize WebPagePrivate::actualVisibleSize() const
    14551461{
    1456     return mapFromTransformed(transformedActualVisibleSize());
     1462    return m_webkitThreadViewportAccessor->documentViewportSize();
    14571463}
    14581464
    … …  
    16131619            }
    16141620
     1621            const Platform::IntSize pixelContentsSize = m_webkitThreadViewportAccessor->pixelContentsSize();
     1622
    16151623            // If the content size is too small, zoom it to fit the viewport.
    1616             if ((loadState() == Finished || loadState() == Committed)
    1617                 && (transformedContentsSize().width() < transformedActualVisibleSize().width() || transformedContentsSize().height() < transformedActualVisibleSize().height()))
    1618                     zoomAboutPoint(initialScale(), newScrollPosition);
    1619 
     1624            if ((loadState() == Finished || loadState() == Committed) && (pixelContentsSize.width() < m_actualVisibleWidth || pixelContentsSize.height() < m_actualVisibleHeight))
     1625                zoomAboutPoint(initialScale(), newScrollPosition);
    16201626        }
    16211627    }
    … …  
    18231829}
    18241830
    1825 IntRect WebPagePrivate::transformedVisibleContentsRect() const
    1826 {
    1827     // Usually this would be mapToTransformed(visibleContentsRect()), but
    1828     // that results in rounding errors because we already set the WebCore
    1829     // viewport size from our original transformedViewportSize().
    1830     // Instead, we only transform the scroll position and take the
    1831     // viewport size as it is, which ensures that e.g. blitting operations
    1832     // always cover the whole widget/screen.
    1833     return IntRect(transformedScrollPosition(), transformedViewportSize());
    1834 }
    1835 
    1836 IntSize WebPagePrivate::transformedContentsSize() const
    1837 {
    1838     // mapToTransformed() functions use this method to crop their results,
    1839     // so we can't make use of them here. While we want rounding inside page
    1840     // boundaries to extend rectangles and round points, we need to crop the
    1841     // contents size to the floored values so that we don't try to display
    1842     // or report points that are not fully covered by the actual float-point
    1843     // contents rectangle.
    1844     const IntSize untransformedContentsSize = contentsSize();
    1845     const FloatPoint transformedBottomRight = m_transformationMatrix->mapPoint(
    1846         FloatPoint(untransformedContentsSize.width(), untransformedContentsSize.height()));
    1847     return IntSize(floorf(transformedBottomRight.x()), floorf(transformedBottomRight.y()));
    1848 }
    1849 
    1850 IntPoint WebPagePrivate::mapFromContentsToViewport(const IntPoint& point) const
    1851 {
    1852     return m_backingStoreClient->mapFromContentsToViewport(point);
    1853 }
    1854 
    1855 IntPoint WebPagePrivate::mapFromViewportToContents(const IntPoint& point) const
    1856 {
    1857     return m_backingStoreClient->mapFromViewportToContents(point);
    1858 }
    1859 
    1860 IntRect WebPagePrivate::mapFromContentsToViewport(const IntRect& rect) const
    1861 {
    1862     return m_backingStoreClient->mapFromContentsToViewport(rect);
    1863 }
    1864 
    1865 IntRect WebPagePrivate::mapFromViewportToContents(const IntRect& rect) const
    1866 {
    1867     return m_backingStoreClient->mapFromViewportToContents(rect);
    1868 }
    1869 
    1870 IntPoint WebPagePrivate::mapFromTransformedContentsToTransformedViewport(const IntPoint& point) const
    1871 {
    1872     return m_backingStoreClient->mapFromTransformedContentsToTransformedViewport(point);
    1873 }
    1874 
    1875 IntPoint WebPagePrivate::mapFromTransformedViewportToTransformedContents(const IntPoint& point) const
    1876 {
    1877     return m_backingStoreClient->mapFromTransformedViewportToTransformedContents(point);
    1878 }
    1879 
    1880 IntRect WebPagePrivate::mapFromTransformedContentsToTransformedViewport(const IntRect& rect) const
    1881 {
    1882     return m_backingStoreClient->mapFromTransformedContentsToTransformedViewport(rect);
    1883 }
    1884 
    1885 IntRect WebPagePrivate::mapFromTransformedViewportToTransformedContents(const IntRect& rect) const
    1886 {
    1887     return m_backingStoreClient->mapFromTransformedViewportToTransformedContents(rect);
    1888 }
    1889 
    1890 // NOTE: PIXEL ROUNDING!
    1891 // Accurate back-and-forth rounding is not possible with information loss
    1892 // by integer points and sizes, so we always expand the resulting mapped
    1893 // float rectangles to the nearest integer. For points, we always use
    1894 // floor-rounding in mapToTransformed() so that we don't have to crop to
    1895 // the (floor'd) transformed contents size.
    1896 static inline IntPoint roundTransformedPoint(const FloatPoint &point)
    1897 {
    1898     // Maps by rounding half towards zero.
    1899     return IntPoint(static_cast<int>(floorf(point.x())), static_cast<int>(floorf(point.y())));
    1900 }
    1901 
    1902 static inline IntPoint roundUntransformedPoint(const FloatPoint &point)
    1903 {
    1904     // Maps by rounding half away from zero.
    1905     return IntPoint(static_cast<int>(ceilf(point.x())), static_cast<int>(ceilf(point.y())));
    1906 }
    1907 
    1908 IntPoint WebPagePrivate::mapToTransformed(const IntPoint& point) const
    1909 {
    1910     return roundTransformedPoint(m_transformationMatrix->mapPoint(FloatPoint(point)));
    1911 }
    1912 
    1913 FloatPoint WebPagePrivate::mapToTransformedFloatPoint(const FloatPoint& point) const
    1914 {
    1915     return m_transformationMatrix->mapPoint(point);
    1916 }
    1917 
    1918 IntPoint WebPagePrivate::mapFromTransformed(const IntPoint& point) const
    1919 {
    1920     return roundUntransformedPoint(m_transformationMatrix->inverse().mapPoint(FloatPoint(point)));
    1921 }
    1922 
    1923 FloatPoint WebPagePrivate::mapFromTransformedFloatPoint(const FloatPoint& point) const
    1924 {
    1925     return m_transformationMatrix->inverse().mapPoint(point);
    1926 }
    1927 
    1928 FloatRect WebPagePrivate::mapFromTransformedFloatRect(const FloatRect& rect) const
    1929 {
    1930     return m_transformationMatrix->inverse().mapRect(rect);
    1931 }
    1932 
    1933 IntSize WebPagePrivate::mapToTransformed(const IntSize& size) const
    1934 {
    1935     return mapToTransformed(IntRect(IntPoint::zero(), size)).size();
    1936 }
    1937 
    1938 IntSize WebPagePrivate::mapFromTransformed(const IntSize& size) const
    1939 {
    1940     return mapFromTransformed(IntRect(IntPoint::zero(), size)).size();
    1941 }
    1942 
    1943 IntRect WebPagePrivate::mapToTransformed(const IntRect& rect) const
    1944 {
    1945     return enclosingIntRect(m_transformationMatrix->mapRect(FloatRect(rect)));
    1946 }
    1947 
    1948 // Use this in conjunction with mapToTransformed(IntRect), in most cases.
    1949 void WebPagePrivate::clipToTransformedContentsRect(IntRect& rect) const
    1950 {
    1951     rect.intersect(IntRect(IntPoint::zero(), transformedContentsSize()));
    1952 }
    1953 
    1954 IntRect WebPagePrivate::mapFromTransformed(const IntRect& rect) const
    1955 {
    1956     return enclosingIntRect(m_transformationMatrix->inverse().mapRect(FloatRect(rect)));
    1957 }
    1958 
    1959 bool WebPagePrivate::transformedPointEqualsUntransformedPoint(const IntPoint& transformedPoint, const IntPoint& untransformedPoint)
    1960 {
    1961     // Scaling down is always more accurate than scaling up.
    1962     if (m_transformationMatrix->a() > 1.0)
    1963         return transformedPoint == mapToTransformed(untransformedPoint);
    1964 
    1965     return mapFromTransformed(transformedPoint) == untransformedPoint;
    1966 }
    1967 
    19681831void WebPagePrivate::notifyTransformChanged()
    19691832{
    … …  
    19791842    m_previousContentsSize = contentsSize();
    19801843
    1981     const IntSize size = transformedContentsSize();
     1844    const IntSize size = m_webkitThreadViewportAccessor->pixelContentsSize();
    19821845    m_backingStore->d->contentsSizeChanged(size);
    19831846    m_client->contentsSizeChanged();
    … …  
    24362299        m_lastMouseEvent.altKey() ? 0 : KEYMOD_ALT;
    24372300
    2438     BlackBerry::Platform::MouseEvent event(buttonMask, buttonMask, mapToTransformed(m_lastMouseEvent.position()), mapToTransformed(m_lastMouseEvent.globalPosition()), 0, modifiers,  0);
     2301    const Platform::ViewportAccessor* viewportAccessor = m_webkitThreadViewportAccessor;
     2302
     2303    BlackBerry::Platform::MouseEvent event(buttonMask, buttonMask,
     2304        viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatPoint(m_lastMouseEvent.position())),
     2305        viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatPoint(m_lastMouseEvent.globalPosition())),
     2306        0, modifiers, 0);
    24392307
    24402308    // We have added document viewport position and document content position as members of the mouse event. When we create the event, we should initialize them as well.
    2441     event.populateDocumentPosition(m_lastMouseEvent.position(), mapFromViewportToContents(m_lastMouseEvent.position()));
     2309    event.populateDocumentPosition(m_lastMouseEvent.position(), viewportAccessor->documentContentsFromViewport(m_lastMouseEvent.position()));
    24422310
    24432311    m_webPage->mouseEvent(event);
    … …  
    26812549        return Platform::IntRect();
    26822550
     2551    const Platform::ViewportAccessor* viewportAccessor = m_webkitThreadViewportAccessor;
     2552
    26832553    IntRect focusRect = rectForNode(doc->focusedNode());
    26842554    focusRect = adjustRectOffsetForFrameOffset(focusRect, doc->focusedNode());
    2685     focusRect = mapToTransformed(focusRect);
    2686     clipToTransformedContentsRect(focusRect);
     2555    focusRect = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatRect(focusRect));
     2556    focusRect.intersect(viewportAccessor->pixelContentsRect());
    26872557    return focusRect;
    26882558}
    … …  
    27212591        contentPos = lastFatFingersResult.adjustedPosition();
    27222592    else
    2723         contentPos = mapFromViewportToContents(m_lastMouseEvent.position());
     2593        contentPos = m_webkitThreadViewportAccessor->documentContentsFromViewport(m_lastMouseEvent.position());
    27242594
    27252595    HitTestResult result = eventHandler->hitTestResultAtPoint(contentPos);
    … …  
    29932863    }
    29942864
     2865    const Platform::ViewportAccessor* viewportAccessor = m_webkitThreadViewportAccessor;
     2866
    29952867    blockRect = adjustRectOffsetForFrameOffset(blockRect, node);
    2996     blockRect = mapToTransformed(blockRect);
    2997     clipToTransformedContentsRect(blockRect);
     2868    blockRect = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatRect(blockRect));
     2869    blockRect.intersect(viewportAccessor->pixelContentsRect());
    29982870
    29992871    return blockRect;
    … …  
    30072879        return;
    30082880
    3009     IntPoint anchor(roundUntransformedPoint(finalAnimationDocumentScrollPosition));
     2881    const Platform::ViewportAccessor* viewportAccessor = m_webkitThreadViewportAccessor;
     2882
     2883    IntPoint anchor(viewportAccessor->roundedDocumentContents(finalAnimationDocumentScrollPosition));
    30102884    bool willUseTextReflow = false;
    30112885
    … …  
    30342908    requestLayoutIfNeeded();
    30352909    if (willUseTextReflow && m_shouldReflowBlock) {
     2910        Platform::IntPoint roundedReflowOffset(
     2911            std::floorf(m_finalAnimationDocumentScrollPositionReflowOffset.x()),
     2912            std::floorf(m_finalAnimationDocumentScrollPositionReflowOffset.y()));
     2913
    30362914        IntRect reflowedRect = rectForNode(m_currentBlockZoomAdjustedNode.get());
    30372915        reflowedRect = adjustRectOffsetForFrameOffset(reflowedRect, m_currentBlockZoomAdjustedNode.get());
    3038         reflowedRect.move(roundTransformedPoint(m_finalAnimationDocumentScrollPositionReflowOffset).x(), roundTransformedPoint(m_finalAnimationDocumentScrollPositionReflowOffset).y());
     2916        reflowedRect.move(roundedReflowOffset.x(), roundedReflowOffset.y());
     2917
    30392918        RenderObject* renderer = m_currentBlockZoomAdjustedNode->renderer();
    30402919        IntPoint topLeftPoint(reflowedRect.location());
    … …  
    40523931
    40533932    if (!node) {
    4054         HitTestResult result = eventHandler->hitTestResultAtPoint(mapFromViewportToContents(mouseEvent.position()));
     3933        IntPoint documentContentsPoint = m_webkitThreadViewportAccessor->documentContentsFromViewport(mouseEvent.position());
     3934        HitTestResult result = eventHandler->hitTestResultAtPoint(documentContentsPoint);
    40553935        node = result.innerNode();
    40563936    }
    … …  
    46104490    bool isFirstZoom = false;
    46114491
     4492    const Platform::ViewportAccessor* viewportAccessor = webkitThreadViewportAccessor();
     4493
    46124494    if (endOfBlockZoomMode) {
    46134495        // End of block zoom mode
    4614         IntRect rect = d->blockZoomRectForNode(node);
    4615         blockRect = IntRect(0, rect.y(), d->transformedContentsSize().width(), d->transformedContentsSize().height() - rect.y());
     4496        const Platform::IntSize pixelContentsSize = viewportAccessor->pixelContentsSize();
     4497        const IntRect rect = d->blockZoomRectForNode(node);
     4498        blockRect = IntRect(0, rect.y(), pixelContentsSize.width(), pixelContentsSize.height() - rect.y());
    46164499        d->m_shouldReflowBlock = false;
    46174500    } else {
    … …  
    46234506        // We allow this for images only so that they can be zoomed tight to the screen.
    46244507        if (!node->hasTagName(HTMLNames::imgTag)) {
    4625             IntRect tRect = d->mapFromTransformed(blockRect);
     4508            const IntRect tRect = viewportAccessor->roundToDocumentFromPixelContents(WebCore::FloatRect(blockRect));
    46264509            int blockArea = tRect.width() * tRect.height();
    46274510            int pageArea = d->contentsSize().width() * d->contentsSize().height();
    … …  
    46664549
    46674550    // Align the zoomed block in the screen.
    4668     double newBlockHeight = d->mapFromTransformed(blockRect).height();
    4669     double newBlockWidth = d->mapFromTransformed(blockRect).width();
    4670     double scaledViewportWidth = static_cast<double>(d->actualVisibleSize().width()) * oldScale / newScale;
    4671     double scaledViewportHeight = static_cast<double>(d->actualVisibleSize().height()) * oldScale / newScale;
    4672     double dx = std::max(0.0, (scaledViewportWidth - newBlockWidth) / 2.0);
    4673     double dy = std::max(0.0, (scaledViewportHeight - newBlockHeight) / 2.0);
    4674 
    4675     RenderObject* renderer = d->m_currentBlockZoomAdjustedNode->renderer();
     4551    const Platform::FloatRect newBlockRect = viewportAccessor->documentFromPixelContents(WebCore::FloatRect(blockRect));
     4552    float scaledViewportWidth = static_cast<double>(d->actualVisibleSize().width()) * oldScale / newScale;
     4553    float scaledViewportHeight = static_cast<double>(d->actualVisibleSize().height()) * oldScale / newScale;
     4554    float dx = std::max(0.0f, (scaledViewportWidth - newBlockRect.width()) / 2.0f);
     4555    float dy = std::max(0.0f, (scaledViewportHeight - newBlockRect.height()) / 2.0f);
     4556
     4557    const RenderObject* renderer = d->m_currentBlockZoomAdjustedNode->renderer();
     4558    const FloatPoint topLeftPoint = newBlockRect.location();
    46764559    FloatPoint anchor;
    4677     FloatPoint topLeftPoint(d->mapFromTransformed(blockRect).location());
     4560
    46784561    if (renderer && renderer->isText()) {
    46794562        ETextAlign textAlign = renderer->style()->textAlign();
    … …  
    47054588    WebCore::FloatPoint finalAnimationDocumentScrollPosition;
    47064589
    4707     if (newBlockHeight <= scaledViewportHeight) {
     4590    if (newBlockRect.height() <= scaledViewportHeight) {
    47084591        // The block fits in the viewport so center it.
    47094592        finalAnimationDocumentScrollPosition = FloatPoint(anchor.x() - dx, anchor.y() - dy);
    … …  
    47504633    // that the zoom level is the minimumScale.
    47514634    if (!endOfBlockZoomMode && abs(newScale - oldScale) / oldScale < minimumExpandingRatio) {
    4752         const double minimumDisplacement = minimumExpandingRatio * webkitThreadViewportAccessor()->documentViewportSize().width();
    4753         if (oldScale == d->minimumScale() || (distanceBetweenPoints(d->scrollPosition(), roundUntransformedPoint(finalAnimationDocumentScrollPosition)) < minimumDisplacement && abs(newScale - oldScale) / oldScale < 0.10)) {
     4635        const double minimumDisplacement = minimumExpandingRatio * viewportAccessor->documentViewportSize().width();
     4636        const int scrollPositionDisplacement = distanceBetweenPoints(viewportAccessor->documentScrollPosition(), viewportAccessor->roundedDocumentContents(finalAnimationDocumentScrollPosition));
     4637
     4638        if (oldScale == d->minimumScale() || (scrollPositionDisplacement < minimumDisplacement && abs(newScale - oldScale) / oldScale < 0.10)) {
    47544639            if (isFirstZoom) {
    47554640                d->resetBlockZoom();

  • trunk/Source/WebKit/blackberry/Api/WebPage_p.h

    r147740 r147744  
    265265    WebCore::IntSize transformedActualVisibleSize() const;
    266266    WebCore::IntSize transformedViewportSize() const;
    267     WebCore::IntRect transformedVisibleContentsRect() const;
    268     WebCore::IntSize transformedContentsSize() const;
    269 
    270     // Generic conversions of points, rects, relative to and from contents and viewport.
    271     WebCore::IntPoint mapFromContentsToViewport(const WebCore::IntPoint&) const;
    272     WebCore::IntPoint mapFromViewportToContents(const WebCore::IntPoint&) const;
    273     WebCore::IntRect mapFromContentsToViewport(const WebCore::IntRect&) const;
    274     WebCore::IntRect mapFromViewportToContents(const WebCore::IntRect&) const;
    275 
    276     // Generic conversions of points, rects, relative to and from transformed contents and transformed viewport.
    277     WebCore::IntPoint mapFromTransformedContentsToTransformedViewport(const WebCore::IntPoint&) const;
    278     WebCore::IntPoint mapFromTransformedViewportToTransformedContents(const WebCore::IntPoint&) const;
    279     WebCore::IntRect mapFromTransformedContentsToTransformedViewport(const WebCore::IntRect&) const;
    280     WebCore::IntRect mapFromTransformedViewportToTransformedContents(const WebCore::IntRect&) const;
    281 
    282     // Generic conversions of points, rects, and sizes to and from transformed coordinates.
    283     WebCore::IntPoint mapToTransformed(const WebCore::IntPoint&) const;
    284     WebCore::FloatPoint mapToTransformedFloatPoint(const WebCore::FloatPoint&) const;
    285     WebCore::IntPoint mapFromTransformed(const WebCore::IntPoint&) const;
    286     WebCore::FloatPoint mapFromTransformedFloatPoint(const WebCore::FloatPoint&) const;
    287     WebCore::FloatRect mapFromTransformedFloatRect(const WebCore::FloatRect&) const;
    288     WebCore::IntSize mapToTransformed(const WebCore::IntSize&) const;
    289     WebCore::IntSize mapFromTransformed(const WebCore::IntSize&) const;
    290     WebCore::IntRect mapToTransformed(const WebCore::IntRect&) const;
    291     void clipToTransformedContentsRect(WebCore::IntRect&) const;
    292     WebCore::IntRect mapFromTransformed(const WebCore::IntRect&) const;
    293     bool transformedPointEqualsUntransformedPoint(const WebCore::IntPoint& transformedPoint, const WebCore::IntPoint& untransformedPoint);
    294267
    295268    // Notification methods that deliver changes to the real geometry of the device as specified above.

  • trunk/Source/WebKit/blackberry/ChangeLog

    r147740 r147744  
     12013-04-05  Jakob Petsovits  <jpetsovits@blackberry.com>
     2
     3        [BlackBerry] Replace map{From,To}Transformed() with ViewportAccessor
     4        https://bugs.webkit.org/show_bug.cgi?id=113449
     5
     6        Reviewed by Rob Buis.
     7
     8        This removes the WebPage/BackingStoreClient family of coordinate
     9        transformation functions, which were widely disliked for their
     10        naming, with ViewportAccessor API that had previously been
     11        introduced for limited use cases. This commit takes care of the
     12        remaining call sites and leaves us with a single API to use.
     13
     14        No new tests, only a clean-up/refactor of existing code & functionality.
     15
     16        * Api/BackingStore.cpp:
     17        (BlackBerry::WebKit::BackingStorePrivate::repaint):
     18        (BlackBerry::WebKit::BackingStorePrivate::slowScroll):
     19        (BlackBerry::WebKit::BackingStorePrivate::visibleContentsRect):
     20        (BlackBerry::WebKit::BackingStorePrivate::unclippedVisibleContentsRect):
     21        (BlackBerry::WebKit::BackingStorePrivate::blitVisibleContents):
     22        (BlackBerry::WebKit::BackingStorePrivate::expandedContentsSize):
     23        * Api/InRegionScroller.cpp:
     24        (BlackBerry::WebKit::InRegionScrollerPrivate::clipToRect):
     25        * Api/WebPage.cpp:
     26        (BlackBerry::WebKit::WebPagePrivate::WebPagePrivate):
     27        (BlackBerry::WebKit::WebPagePrivate::init):
     28        (BlackBerry::WebKit::WebPagePrivate::scrollPosition):
     29        (BlackBerry::WebKit::WebPagePrivate::maximumScrollPosition):
     30        (BlackBerry::WebKit::WebPagePrivate::setScrollPosition):
     31        (BlackBerry::WebKit::WebPagePrivate::viewportSize):
     32        (BlackBerry::WebKit::WebPagePrivate::actualVisibleSize):
     33        (BlackBerry::WebKit::WebPagePrivate::layoutFinished):
     34        (BlackBerry::WebKit::WebPagePrivate::notifyTransformedContentsSizeChanged):
     35        (BlackBerry::WebKit::WebPagePrivate::updateCursor):
     36        (BlackBerry::WebKit::WebPagePrivate::focusNodeRect):
     37        (BlackBerry::WebKit::WebPagePrivate::contextNode):
     38        (BlackBerry::WebKit::WebPagePrivate::blockZoomRectForNode):
     39        (BlackBerry::WebKit::WebPagePrivate::zoomAnimationFinished):
     40        (BlackBerry::WebKit::WebPagePrivate::handleMouseEvent):
     41        (BlackBerry::WebKit::WebPage::blockZoom):
     42        * Api/WebPage_p.h:
     43        (WebPagePrivate):
     44        * WebKitSupport/BackingStoreClient.cpp:
     45        (BlackBerry::WebKit::BackingStoreClient::transformedScrollPosition):
     46        (BlackBerry::WebKit::BackingStoreClient::transformedMaximumScrollPosition):
     47        (BlackBerry::WebKit::BackingStoreClient::actualVisibleSize):
     48        (BlackBerry::WebKit::BackingStoreClient::transformedActualVisibleSize):
     49        * WebKitSupport/BackingStoreClient.h:
     50        (BackingStoreClient):
     51        * WebKitSupport/FatFingers.cpp:
     52        (BlackBerry::WebKit::FatFingers::fingerRectForPoint):
     53        (BlackBerry::WebKit::FatFingers::FatFingers):
     54        (BlackBerry::WebKit::FatFingers::findBestPoint):
     55        (BlackBerry::WebKit::FatFingers::findIntersectingRegions):
     56        (BlackBerry::WebKit::FatFingers::getNodesFromRect):
     57        * WebKitSupport/InRegionScrollableArea.cpp:
     58        (BlackBerry::WebKit::InRegionScrollableArea::InRegionScrollableArea):
     59        * WebKitSupport/InputHandler.cpp:
     60        (BlackBerry::WebKit::InputHandler::ensureFocusTextElementVisible):
     61        * WebKitSupport/TouchEventHandler.cpp:
     62        (BlackBerry::WebKit::TouchEventHandler::sendClickAtFatFingersPoint):
     63        (BlackBerry::WebKit::TouchEventHandler::handleTouchPoint):
     64        (BlackBerry::WebKit::TouchEventHandler::handleFatFingerPressed):
     65        * WebKitSupport/WebKitThreadViewportAccessor.cpp:
     66        (BlackBerry::WebKit::WebKitThreadViewportAccessor::pixelContentsSize):
     67        (BlackBerry::WebKit::WebKitThreadViewportAccessor::pixelScrollPosition):
     68        (BlackBerry::WebKit::WebKitThreadViewportAccessor::documentViewportSize):
     69
    1702013-04-05  Alberto Garcia  <agarcia@igalia.com>
    271

  • trunk/Source/WebKit/blackberry/WebKitSupport/BackingStoreClient.cpp

    r146051 r147744  
    3131#include "WebPage_p.h"
    3232
     33#include <BlackBerryPlatformViewportAccessor.h>
     34
    3335// FIXME: Leaving the below lines commented out as a reference for us to soon be sure if we need these
    3436// methods and class variables be moved from WebPage to BackingStoreClient.
    … …  
    7476}
    7577
    76 IntRect BackingStoreClient::absoluteRect() const
    77 {
    78     IntRect rect = IntRect(IntPoint::zero(), viewportSize());
    79 
    80     // FIXME: Speed it up!
    81     Frame* frame = m_frame;
    82     while (frame) {
    83         if (Element* element = frame->ownerElement()) {
    84             do {
    85                 rect.move(element->offsetLeft(), element->offsetTop());
    86             } while ((element = element->offsetParent()));
    87         }
    88 
    89         if ((frame = frame->tree()->parent()))
    90             rect.move((-frame->view()->scrollOffset()));
    91     }
    92 
    93     return rect;
    94 }
    95 
    96 IntRect BackingStoreClient::transformedAbsoluteRect() const
    97 {
    98     return m_webPage->d->mapToTransformed(absoluteRect());
    99 }
    100 
    101 IntPoint BackingStoreClient::absoluteLocation() const
    102 {
    103     return absoluteRect().location();
    104 }
    105 
    106 IntPoint BackingStoreClient::transformedAbsoluteLocation() const
    107 {
    108     return m_webPage->d->mapToTransformed(transformedAbsoluteRect()).location();
    109 }
    110 
    11178IntPoint BackingStoreClient::scrollPosition() const
    11279{
    … …  
    12087IntPoint BackingStoreClient::transformedScrollPosition() const
    12188{
    122     return m_webPage->d->mapToTransformed(scrollPosition());
     89    return m_webPage->webkitThreadViewportAccessor()->pixelScrollPosition();
    12390}
    12491
    … …  
    155122IntPoint BackingStoreClient::transformedMaximumScrollPosition() const
    156123{
    157     return m_webPage->d->mapToTransformed(maximumScrollPosition());
     124    return m_webPage->webkitThreadViewportAccessor()->roundToPixelFromDocumentContents(WebCore::FloatPoint(maximumScrollPosition()));
    158125}
    159126
    160127IntSize BackingStoreClient::actualVisibleSize() const
    161128{
    162     return m_webPage->d->mapFromTransformed(transformedActualVisibleSize());
     129    return m_webPage->webkitThreadViewportAccessor()->documentViewportSize();
    163130}
    164131
    … …  
    166133{
    167134    ASSERT(isMainFrame());
    168     return m_webPage->d->transformedActualVisibleSize();
     135    return m_webPage->webkitThreadViewportAccessor()->pixelViewportSize();
    169136}
    170137
    … …  
    200167}
    201168
    202 IntRect BackingStoreClient::transformedVisibleContentsRect() const
    203 {
    204     // Usually this would be mapToTransformed(visibleContentsRect()), but
    205     // that results in rounding errors because we already set the WebCore
    206     // viewport size from our original transformedViewportSize().
    207     // Instead, we only transform the scroll position and take the
    208     // viewport size as it is, which ensures that e.g. blitting operations
    209     // always cover the whole widget/screen.
    210     IntRect visibleContentsRect = IntRect(transformedScrollPosition(), transformedViewportSize());
    211     ASSERT(isMainFrame());
    212     return visibleContentsRect;
    213 }
    214 
    215169IntSize BackingStoreClient::contentsSize() const
    216170{
    … …  
    220174
    221175    return m_frame->view()->contentsSize();
    222 }
    223 
    224 IntSize BackingStoreClient::transformedContentsSize() const
    225 {
    226     // mapToTransformed() functions use this method to crop their results,
    227     // so we can't make use of them here. While we want rounding inside page
    228     // boundaries to extend rectangles and round points, we need to crop the
    229     // contents size to the floored values so that we don't try to display
    230     // or report points that are not fully covered by the actual float-point
    231     // contents rectangle.
    232     const IntSize untransformedContentsSize = contentsSize();
    233     const FloatPoint transformedBottomRight = m_webPage->d->m_transformationMatrix->mapPoint(
    234         FloatPoint(untransformedContentsSize.width(), untransformedContentsSize.height()));
    235     return IntSize(floorf(transformedBottomRight.x()), floorf(transformedBottomRight.y()));
    236 }
    237 
    238 void BackingStoreClient::clipToTransformedContentsRect(IntRect& rect) const
    239 {
    240     // FIXME: Needs to proper translate coordinates here?
    241     rect.intersect(IntRect(IntPoint::zero(), transformedContentsSize()));
    242 }
    243 
    244 IntPoint BackingStoreClient::mapFromContentsToViewport(const IntPoint& point) const
    245 {
    246     const IntPoint scrollPosition = this->scrollPosition();
    247     return IntPoint(point.x() - scrollPosition.x(), point.y() - scrollPosition.y());
    248 }
    249 
    250 IntPoint BackingStoreClient::mapFromViewportToContents(const IntPoint& point) const
    251 {
    252     const IntPoint scrollPosition = this->scrollPosition();
    253     return IntPoint(point.x() + scrollPosition.x(), point.y() + scrollPosition.y());
    254 }
    255 
    256 IntRect BackingStoreClient::mapFromContentsToViewport(const IntRect& rect) const
    257 {
    258     return IntRect(mapFromContentsToViewport(rect.location()), rect.size());
    259 }
    260 
    261 IntRect BackingStoreClient::mapFromViewportToContents(const IntRect& rect) const
    262 {
    263     return IntRect(mapFromViewportToContents(rect.location()), rect.size());
    264 }
    265 
    266 IntPoint BackingStoreClient::mapFromTransformedContentsToTransformedViewport(const IntPoint& point) const
    267 {
    268     const IntPoint scrollPosition = transformedScrollPosition();
    269     return IntPoint(point.x() - scrollPosition.x(), point.y() - scrollPosition.y());
    270 }
    271 
    272 IntPoint BackingStoreClient::mapFromTransformedViewportToTransformedContents(const IntPoint& point) const
    273 {
    274     const IntPoint scrollPosition = transformedScrollPosition();
    275     return IntPoint(point.x() + scrollPosition.x(), point.y() + scrollPosition.y());
    276 }
    277 
    278 IntRect BackingStoreClient::mapFromTransformedContentsToTransformedViewport(const IntRect& rect) const
    279 {
    280     return IntRect(mapFromTransformedContentsToTransformedViewport(rect.location()), rect.size());
    281 }
    282 
    283 IntRect BackingStoreClient::mapFromTransformedViewportToTransformedContents(const IntRect& rect) const
    284 {
    285     return IntRect(mapFromTransformedViewportToTransformedContents(rect.location()), rect.size());
    286176}
    287177

  • trunk/Source/WebKit/blackberry/WebKitSupport/BackingStoreClient.h

    r137908 r147744  
    4747    bool isMainFrame() const { return m_frame == m_webPage->d->m_mainFrame; }
    4848
    49     WebCore::IntPoint absoluteLocation() const;
    50     WebCore::IntPoint transformedAbsoluteLocation() const;
    51     WebCore::IntRect absoluteRect() const;
    52     WebCore::IntRect transformedAbsoluteRect() const;
    53 
    5449    // scroll position returned is in transformed coordinates
    5550    WebCore::IntPoint scrollPosition() const;
    … …  
    6863
    6964    WebCore::IntRect visibleContentsRect() const;
    70     WebCore::IntRect transformedVisibleContentsRect() const;
    7165
    7266    WebCore::IntSize contentsSize() const;
    73     WebCore::IntSize transformedContentsSize() const;
    74 
    75     /* Generic conversions of points, rects, relative to and from contents and viewport*/
    76     WebCore::IntPoint mapFromContentsToViewport(const WebCore::IntPoint&) const;
    77     WebCore::IntPoint mapFromViewportToContents(const WebCore::IntPoint&) const;
    78     WebCore::IntRect mapFromContentsToViewport(const WebCore::IntRect&) const;
    79     WebCore::IntRect mapFromViewportToContents(const WebCore::IntRect&) const;
    80 
    81     /* Generic conversions of points, rects, relative to and from transformed contents and transformed viewport*/
    82     WebCore::IntPoint mapFromTransformedContentsToTransformedViewport(const WebCore::IntPoint&) const;
    83     WebCore::IntPoint mapFromTransformedViewportToTransformedContents(const WebCore::IntPoint&) const;
    84     WebCore::IntRect mapFromTransformedContentsToTransformedViewport(const WebCore::IntRect&) const;
    85     WebCore::IntRect mapFromTransformedViewportToTransformedContents(const WebCore::IntRect&) const;
    86 
    87     void clipToTransformedContentsRect(WebCore::IntRect&) const;
    8867
    8968    bool isLoading() const;

  • trunk/Source/WebKit/blackberry/WebKitSupport/FatFingers.cpp

    r147687 r147744  
    11/*
    2  * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved.
     2 * Copyright (C) 2010, 2011, 2012, 2013 Research In Motion Limited. All rights reserved.
    33 *
    44 * This library is free software; you can redistribute it and/or
    … …  
    4242#include "Text.h"
    4343#include "TextBreakIterator.h"
     44#include "WebKitThreadViewportAccessor.h"
    4445#include "WebPage_p.h"
    4546
    … …  
    6667IntRect FatFingers::fingerRectForPoint(const IntPoint& point) const
    6768{
     69    const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     70
    6871    unsigned topPadding, rightPadding, bottomPadding, leftPadding;
    69     IntPoint contentViewportPos = m_webPage->mapFromContentsToViewport(point);
     72    IntPoint contentViewportPos = viewportAccessor->documentViewportFromContents(point);
    7073    getAdjustedPaddings(contentViewportPos, topPadding, rightPadding, bottomPadding, leftPadding);
    7174
    … …  
    138141
    139142#if DEBUG_FAT_FINGERS
     143    const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     144
    140145    m_debugFatFingerRect = IntRect(0, 0, 0, 0);
    141     m_debugFatFingerClickPosition = m_webPage->mapToTransformed(m_webPage->mapFromContentsToViewport(contentPos));
    142     m_debugFatFingerAdjustedPosition = m_webPage->mapToTransformed(m_webPage->mapFromContentsToViewport(contentPos));
     146    m_debugFatFingerClickPosition = viewportAccessor->pixelViewportFromContents(viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatPoint(contentPos)));
     147    m_debugFatFingerAdjustedPosition = m_debugFatFingerClickPosition;
    143148#endif
    144149}
    … …  
    226231
    227232#if DEBUG_FAT_FINGERS
    228     m_debugFatFingerAdjustedPosition = m_webPage->mapToTransformed(m_webPage->mapFromContentsToViewport(largestIntersectionRegion.rects()[0].center()));
     233    const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     234
     235    m_debugFatFingerAdjustedPosition = viewportAccessor->pixelViewportFromContents(
     236        viewportAccessor->roundToPixelFromDocumentContents(largestIntersectionRegion.rects()[0].center()));
    229237#endif
    230238
    … …  
    293301
    294302#if DEBUG_FAT_FINGERS
    295     IntRect fingerRect(fingerRectForPoint(frameContentPos));
    296     Platform::IntRect screenFingerRect = m_webPage->mapToTransformed(fingerRect);
     303    const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     304
     305    Platform::IntRect fingerRect(fingerRectForPoint(frameContentPos));
     306    Platform::IntRect screenFingerRect = viewportAccessor->roundToPixelFromDocumentContents(fingerRect);
    297307    Platform::logAlways(Platform::LogLevelInfo, "fat finger rect now %s", screenFingerRect.toString().c_str());
    298308
    299309    // only record the first finger rect
    300310    if (document == m_webPage->m_mainFrame->document())
    301         m_debugFatFingerRect = m_webPage->mapToTransformed(m_webPage->mapFromContentsToViewport(fingerRect));
     311        m_debugFatFingerRect = viewportAccessor->pixelViewportFromContents(screenFingerRect);
    302312#endif
    303313
    … …  
    460470void FatFingers::getNodesFromRect(Document* document, const IntPoint& contentPos, ListHashSet<RefPtr<Node> >& intersectedNodes)
    461471{
     472    const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     473
    462474    unsigned topPadding, rightPadding, bottomPadding, leftPadding;
    463     IntPoint contentViewportPos = m_webPage->mapFromContentsToViewport(m_contentPos);
     475    IntPoint contentViewportPos = viewportAccessor->documentViewportFromContents(m_contentPos);
    464476    // Do not allow fat fingers detect anything not visible(ie outside of the viewport)
    465477    getAdjustedPaddings(contentViewportPos, topPadding, rightPadding, bottomPadding, leftPadding);

  • trunk/Source/WebKit/blackberry/WebKitSupport/InRegionScrollableArea.cpp

    r145792 r147744  
    11/*
    2  * Copyright (C) 2011, 2012 Research In Motion Limited. All rights reserved.
     2 * Copyright (C) 2011, 2012, 2013 Research In Motion Limited. All rights reserved.
    33 *
    44 * This library is free software; you can redistribute it and/or
    … …  
    3030#include "RenderObject.h"
    3131#include "RenderView.h"
     32#include "WebKitThreadViewportAccessor.h"
    3233#include "WebPage_p.h"
     34
     35#include <BlackBerryPlatformViewportAccessor.h>
    3336
    3437using namespace WebCore;
    … …  
    8083        ASSERT_UNUSED(frame, frame);
    8184
    82         m_scrollPosition = m_webPage->mapToTransformed(view->scrollPosition());
    83         m_contentsSize = m_webPage->mapToTransformed(view->contentsSize());
    84         m_viewportSize = m_webPage->mapToTransformed(view->visibleContentRect(ScrollableArea::ExcludeScrollbars)).size();
     85        const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     86        m_scrollPosition = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatPoint(view->scrollPosition()));
     87        m_contentsSize = viewportAccessor->roundToPixelFromDocumentContents(Platform::FloatRect(Platform::FloatPoint::zero(), WebCore::FloatSize(view->contentsSize()))).size();
     88        m_viewportSize = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatRect(view->visibleContentRect(ScrollableArea::ExcludeScrollbars))).size();
    8589        m_documentViewportRect = view->frameRect();
    8690
    … …  
    103107        ASSERT(InRegionScrollerPrivate::canScrollRenderBox(box));
    104108
     109        const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
    105110        ScrollableArea* scrollableArea = static_cast<ScrollableArea*>(m_layer);
    106         m_scrollPosition = m_webPage->mapToTransformed(scrollableArea->scrollPosition());
    107         m_contentsSize = m_webPage->mapToTransformed(scrollableArea->contentsSize());
    108         m_viewportSize = m_webPage->mapToTransformed(scrollableArea->visibleContentRect(ScrollableArea::ExcludeScrollbars)).size();
     111
     112        m_scrollPosition = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatPoint(scrollableArea->scrollPosition()));
     113        m_contentsSize = viewportAccessor->roundToPixelFromDocumentContents(Platform::FloatRect(Platform::FloatPoint::zero(), WebCore::FloatSize(scrollableArea->contentsSize()))).size();
     114        m_viewportSize = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatRect(scrollableArea->visibleContentRect(ScrollableArea::ExcludeScrollbars))).size();
    109115        m_documentViewportRect = enclosingIntRect(box->absoluteClippedOverflowRect());
    110116

  • trunk/Source/WebKit/blackberry/WebKitSupport/InputHandler.cpp

    r147135 r147744  
    6363#include "VisiblePosition.h"
    6464#include "VisibleUnits.h"
     65#include "WebKitThreadViewportAccessor.h"
    6566#include "WebPageClient.h"
    6667#include "WebPage_p.h"
    … …  
    7475#include <BlackBerryPlatformScreen.h>
    7576#include <BlackBerryPlatformSettings.h>
     77#include <cmath>
    7678#include <sys/keycodes.h>
    7779#include <wtf/text/CString.h>
    … …  
    13681370            // zoom level as controls do not zoom.
    13691371            static const int s_focusRectPaddingSize = Graphics::Screen::primaryScreen()->heightInMMToPixels(3);
    1370             selectionFocusRect.inflate(m_webPage->mapFromTransformed(WebCore::IntSize(0, s_focusRectPaddingSize)).height());
     1372            const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     1373            selectionFocusRect.inflate(std::ceilf(viewportAccessor->documentFromPixelContents(Platform::FloatSize(0, s_focusRectPaddingSize)).height()));
    13711374
    13721375            WebCore::IntRect revealRect(layer->getRectToExpose(actualScreenRect, selectionFocusRect,

  • trunk/Source/WebKit/blackberry/WebKitSupport/TouchEventHandler.cpp

    r147687 r147744  
    11/*
    2  * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved.
     2 * Copyright (C) 2010, 2011, 2012, 2013 Research In Motion Limited. All rights reserved.
    33 *
    44 * This library is free software; you can redistribute it and/or
    … …  
    4545#include "RenderView.h"
    4646#include "SelectionHandler.h"
     47#include "WebKitThreadViewportAccessor.h"
    4748#include "WebPage_p.h"
    4849#include "WebTapHighlight.h"
    4950
     51#include <BlackBerryPlatformViewportAccessor.h>
    5052#include <wtf/MathExtras.h>
    5153
    … …  
    9092
    9193    handleFatFingerPressed(shiftActive, altActive, ctrlActive);
    92     PlatformMouseEvent mouseRelease(m_webPage->mapFromContentsToViewport(m_lastFatFingersResult.adjustedPosition()), m_lastScreenPoint, PlatformEvent::MouseReleased, 1, LeftButton, shiftActive, ctrlActive, altActive, TouchScreen);
     94
     95    const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     96    IntPoint documentViewportAdjustedPosition = viewportAccessor->documentViewportFromContents(m_lastFatFingersResult.adjustedPosition());
     97    PlatformMouseEvent mouseRelease(documentViewportAdjustedPosition, m_lastScreenPoint, PlatformEvent::MouseReleased, 1, LeftButton, shiftActive, ctrlActive, altActive, TouchScreen);
     98
    9399    m_webPage->handleMouseEvent(mouseRelease);
    94100}
    … …  
    139145            m_webPage->m_selectionHighlight->hide();
    140146
    141             IntPoint adjustedPoint = m_webPage->mapFromContentsToViewport(m_lastFatFingersResult.adjustedPosition());
    142             PlatformMouseEvent mouseEvent(adjustedPoint, m_lastScreenPoint, PlatformEvent::MouseReleased, 1, LeftButton, shiftActive, ctrlActive, altActive, TouchScreen);
     147            const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     148            IntPoint documentViewportAdjustedPosition = viewportAccessor->documentViewportFromContents(m_lastFatFingersResult.adjustedPosition());
     149            PlatformMouseEvent mouseEvent(documentViewportAdjustedPosition, m_lastScreenPoint, PlatformEvent::MouseReleased, 1, LeftButton, shiftActive, ctrlActive, altActive, TouchScreen);
    143150
    144151            m_webPage->handleMouseEvent(mouseEvent);
    145152
    146153            if (m_shouldRequestSpellCheckOptions) {
    147                 IntPoint pixelPositionRelativeToViewport = m_webPage->mapToTransformed(adjustedPoint);
     154                IntPoint pixelPositionRelativeToViewport = viewportAccessor->pixelViewportFromContents(
     155                    viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatPoint(m_lastFatFingersResult.adjustedPosition())));
    148156                IntSize screenOffset(m_lastScreenPoint - pixelPositionRelativeToViewport);
    149157                m_webPage->m_inputHandler->requestSpellingCheckingOptions(m_spellCheckOptionRequest, screenOffset);
    … …  
    172180void TouchEventHandler::handleFatFingerPressed(bool shiftActive, bool altActive, bool ctrlActive)
    173181{
     182    const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
     183    IntPoint documentViewportAdjustedPosition = viewportAccessor->documentViewportFromContents(m_lastFatFingersResult.adjustedPosition());
     184
    174185    // First update the mouse position with a MouseMoved event.
    175     PlatformMouseEvent mouseMoveEvent(m_webPage->mapFromContentsToViewport(m_lastFatFingersResult.adjustedPosition()), m_lastScreenPoint, PlatformEvent::MouseMoved, 0, LeftButton, shiftActive, ctrlActive, altActive, TouchScreen);
     186    PlatformMouseEvent mouseMoveEvent(documentViewportAdjustedPosition, m_lastScreenPoint, PlatformEvent::MouseMoved, 0, LeftButton, shiftActive, ctrlActive, altActive, TouchScreen);
    176187    m_webPage->handleMouseEvent(mouseMoveEvent);
    177188
    178189    // Then send the MousePressed event.
    179     PlatformMouseEvent mousePressedEvent(m_webPage->mapFromContentsToViewport(m_lastFatFingersResult.adjustedPosition()), m_lastScreenPoint, PlatformEvent::MousePressed, 1, LeftButton, shiftActive, ctrlActive, altActive, TouchScreen);
     190    PlatformMouseEvent mousePressedEvent(documentViewportAdjustedPosition, m_lastScreenPoint, PlatformEvent::MousePressed, 1, LeftButton, shiftActive, ctrlActive, altActive, TouchScreen);
    180191    m_webPage->handleMouseEvent(mousePressedEvent);
    181192}

  • trunk/Source/WebKit/blackberry/WebKitSupport/WebKitThreadViewportAccessor.cpp

    r131257 r147744  
    11/*
    2  * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
     2 * Copyright (C) 2012, 2013 Research In Motion Limited. All rights reserved.
    33 */
    44
    … …  
    2828    ASSERT(Platform::webKitThreadMessageClient()->isCurrentThread());
    2929
    30     return m_webPagePrivate->transformedContentsSize();
     30    double scaleFactor = scale();
     31
     32    if (scaleFactor != 1.0) {
     33        // Round down to avoid showing partially rendered pixels.
     34        IntSize size = documentContentsSize();
     35        return IntSize(
     36            floorf(size.width() * scaleFactor),
     37            floorf(size.height() * scaleFactor));
     38    }
     39
     40    return documentContentsSize();
    3141}
    3242
    … …  
    4252    ASSERT(Platform::webKitThreadMessageClient()->isCurrentThread());
    4353
    44     return m_webPagePrivate->transformedScrollPosition();
     54    return roundToPixelFromDocumentContents(documentScrollPosition());
    4555}
    4656
    … …  
    6373    ASSERT(Platform::webKitThreadMessageClient()->isCurrentThread());
    6474
    65     return m_webPagePrivate->actualVisibleSize();
     75    return roundToDocumentFromPixelContents(pixelViewportRect()).size();
    6676}
    6777
Note: See TracChangeset for help on using the changeset viewer.