[Qt] Find zoomable area using area-based hit-testing
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 30 Mar 2012 15:47:04 +0000 (15:47 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 30 Mar 2012 15:47:04 +0000 (15:47 +0000)
https://bugs.webkit.org/show_bug.cgi?id=82609

Patch by Allan Sandfeld Jensen <allan.jensen@nokia.com> on 2012-03-30
Reviewed by Kenneth Rohde Christiansen.

Source/WebCore:

Implement API for calculating the best zoomable area for a
tap-to-zoom gesture.
It picks the area with the largest intersection with the touch. In most
cases this will be all areas fully containing the area, and returns the
smallest inner-most of these.

* page/EventHandler.cpp:
(WebCore::EventHandler::bestZoomableAreaForTouchPoint):
* page/EventHandler.h:
* page/TouchAdjustment.cpp:
(WebCore::TouchAdjustment::nodeIsZoomTarget):
(WebCore::TouchAdjustment::appendZoomableSubtargets):
(WebCore::TouchAdjustment::compileZoomableSubtargets):
(WebCore::TouchAdjustment::areaOfIntersection):
(WebCore::TouchAdjustment::findAreaWithLargestIntersection):
(WebCore::findBestZoomableArea):
* page/TouchAdjustment.h:
* platform/graphics/IntSize.h:
(WebCore::IntSize::area):

Source/WebKit2:

Add area to findZoomableAreaForPoint and use new TOUCH_ADJUSTMENT
code-path to find the best zoomable area.

* UIProcess/WebPageProxy.cpp:
(WebKit::WebPageProxy::findZoomableAreaForPoint):
* UIProcess/WebPageProxy.h:
(WebPageProxy):
* UIProcess/qt/QtWebPageEventHandler.cpp:
(QtWebPageEventHandler::handleDoubleTapEvent):
* WebProcess/WebPage/WebPage.cpp:
(WebKit):
(WebKit::WebPage::findZoomableAreaForPoint):
* WebProcess/WebPage/WebPage.h:
(WebPage):
* WebProcess/WebPage/WebPage.messages.in:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@112669 268f45cc-cd09-0410-ab3c-d52691b4dbfc

18 files changed:
LayoutTests/touchadjustment/zoom-basic-expected.txt [new file with mode: 0644]
LayoutTests/touchadjustment/zoom-basic.html [new file with mode: 0644]
Source/WebCore/ChangeLog
Source/WebCore/page/EventHandler.cpp
Source/WebCore/page/EventHandler.h
Source/WebCore/page/TouchAdjustment.cpp
Source/WebCore/page/TouchAdjustment.h
Source/WebCore/platform/graphics/IntSize.h
Source/WebCore/testing/Internals.cpp
Source/WebCore/testing/Internals.h
Source/WebCore/testing/Internals.idl
Source/WebKit2/ChangeLog
Source/WebKit2/UIProcess/WebPageProxy.cpp
Source/WebKit2/UIProcess/WebPageProxy.h
Source/WebKit2/UIProcess/qt/QtWebPageEventHandler.cpp
Source/WebKit2/WebProcess/WebPage/WebPage.cpp
Source/WebKit2/WebProcess/WebPage/WebPage.h
Source/WebKit2/WebProcess/WebPage/WebPage.messages.in

diff --git a/LayoutTests/touchadjustment/zoom-basic-expected.txt b/LayoutTests/touchadjustment/zoom-basic-expected.txt
new file mode 100644 (file)
index 0000000..c638131
--- /dev/null
@@ -0,0 +1,25 @@
+Test basic cases of tap-to-zoom mechanics.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS zoomableArea.top is 100
+PASS zoomableArea.left is 100
+PASS zoomableArea.width is 200
+PASS zoomableArea.height is 100
+PASS zoomableArea.top is 210
+PASS zoomableArea.left is 110
+PASS zoomableArea.width is 180
+PASS zoomableArea.height is 80
+PASS zoomableArea.top is 200
+PASS zoomableArea.left is 100
+PASS zoomableArea.width is 200
+PASS zoomableArea.height is 100
+PASS zoomableArea.top is 50
+PASS zoomableArea.left is 50
+PASS zoomableArea.width is 300
+PASS zoomableArea.height is 300
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
diff --git a/LayoutTests/touchadjustment/zoom-basic.html b/LayoutTests/touchadjustment/zoom-basic.html
new file mode 100644 (file)
index 0000000..dd82455
--- /dev/null
@@ -0,0 +1,72 @@
+<html>
+<head>
+    <script src="../fast/js/resources/js-test-pre.js"></script>
+    <style>
+        #div0 { position: absolute; left: 50px; top: 50px; width: 300px; height: 300px; box-sizing: border-box; }
+        #div1 { position: absolute; left: 50px; top: 50
+px; width: 200px; height: 100px; box-sizing: border-box; }
+        #div2 { position: absolute; left: 50px; top: 150px; width: 200px; height: 100px; padding: 10px; box-sizing: border-box; }
+    </style>
+</head>
+<body onload="runTests()">
+
+<div id=div0>
+    <div id=div1></div>
+    <div id=div2></div>
+</div>
+
+<p id='description'></p>
+<div id='console'></div>
+
+<script>
+    function testRoundTouch(x, y, radius)
+    {
+        var x = x - radius;
+        var y = y - radius;
+        var width = radius * 2;
+        var height = radius * 2;
+        var zoomableRect = internals.bestZoomableAreaForTouchPoint(x, y, width, height, document);
+        return zoomableRect;
+    }
+
+    function testDirectTouches()
+    {
+        zoomableArea = testRoundTouch(130, 130, 10);
+        shouldEvaluateTo('zoomableArea.top', 100);
+        shouldEvaluateTo('zoomableArea.left', 100);
+        shouldEvaluateTo('zoomableArea.width', 200);
+        shouldEvaluateTo('zoomableArea.height', 100);
+
+        zoomableArea = testRoundTouch(130, 230, 10);
+        shouldEvaluateTo('zoomableArea.top', 210);
+        shouldEvaluateTo('zoomableArea.left', 110);
+        shouldEvaluateTo('zoomableArea.width', 180);
+        shouldEvaluateTo('zoomableArea.height', 80);
+
+        zoomableArea = testRoundTouch(120, 220, 20);
+        shouldEvaluateTo('zoomableArea.top', 200);
+        shouldEvaluateTo('zoomableArea.left', 100);
+        shouldEvaluateTo('zoomableArea.width', 200);
+        shouldEvaluateTo('zoomableArea.height', 100);
+
+        zoomableArea = testRoundTouch(80, 100, 20);
+        shouldEvaluateTo('zoomableArea.top', 50);
+        shouldEvaluateTo('zoomableArea.left', 50);
+        shouldEvaluateTo('zoomableArea.width', 300);
+        shouldEvaluateTo('zoomableArea.height',300);
+    }
+
+    function runTests()
+    {
+        if (window.layoutTestController && window.internals && internals.bestZoomableAreaForTouchPoint) {
+            description('Test basic cases of tap-to-zoom mechanics.');
+            layoutTestController.dumpAsText();
+            layoutTestController.waitUntilDone();
+            testDirectTouches();
+            isSuccessfullyParsed();
+            layoutTestController.notifyDone();
+        }
+    }
+</script>
+</body>
+</html>
\ No newline at end of file
index 910da5b..c2486ed 100644 (file)
@@ -1,3 +1,30 @@
+2012-03-30  Allan Sandfeld Jensen  <allan.jensen@nokia.com>
+
+        [Qt] Find zoomable area using area-based hit-testing
+        https://bugs.webkit.org/show_bug.cgi?id=82609
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Implement API for calculating the best zoomable area for a
+        tap-to-zoom gesture.
+        It picks the area with the largest intersection with the touch. In most
+        cases this will be all areas fully containing the area, and returns the
+        smallest inner-most of these.
+
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::bestZoomableAreaForTouchPoint):
+        * page/EventHandler.h:
+        * page/TouchAdjustment.cpp:
+        (WebCore::TouchAdjustment::nodeIsZoomTarget):
+        (WebCore::TouchAdjustment::appendZoomableSubtargets):
+        (WebCore::TouchAdjustment::compileZoomableSubtargets):
+        (WebCore::TouchAdjustment::areaOfIntersection):
+        (WebCore::TouchAdjustment::findAreaWithLargestIntersection):
+        (WebCore::findBestZoomableArea):
+        * page/TouchAdjustment.h:
+        * platform/graphics/IntSize.h:
+        (WebCore::IntSize::area):
+
 2012-03-30  Pavel Feldman  <pfeldman@chromium.org>
 
         Web Inspector: do not issue attributes modified event if actual values were not changed.
index 29364cd..1683c3d 100644 (file)
@@ -2475,6 +2475,16 @@ void EventHandler::bestClickableNodeForTouchPoint(const IntPoint& touchCenter, c
         targetNode = result.innerNonSharedNode();
     }
 }
+
+void EventHandler::bestZoomableAreaForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntRect& targetArea, Node*& targetNode)
+{
+    HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active;
+    HitTestResult result = hitTestResultAtPoint(touchCenter, /*allowShadowContent*/ false, /*ignoreClipping*/ false, DontHitTestScrollbars, hitType, touchRadius);
+
+    IntRect touchRect = result.rectForPoint(touchCenter);
+    RefPtr<StaticHashSetNodeList> nodeList = StaticHashSetNodeList::adopt(result.rectBasedTestResult());
+    findBestZoomableArea(targetNode, targetArea, touchCenter, touchRect, *nodeList.get());
+}
 #endif
 
 #if ENABLE(CONTEXT_MENUS)
index 701fa2b..e5a1a41 100644 (file)
@@ -169,6 +169,7 @@ public:
 
 #if ENABLE(TOUCH_ADJUSTMENT)
     void bestClickableNodeForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntPoint& targetPoint, Node*& targetNode);
+    void bestZoomableAreaForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntRect& targetArea, Node*& targetNode);
 #endif
 
 #if ENABLE(CONTEXT_MENUS)
index da63afa..9a1efbb 100644 (file)
@@ -91,6 +91,15 @@ bool nodeRespondsToTapGesture(Node* node)
     return false;
 }
 
+bool nodeIsZoomTarget(Node* node)
+{
+    if (node->isTextNode() || node->isShadowRoot())
+        return false;
+
+    ASSERT(node->renderer());
+    return node->renderer()->isBox();
+}
+
 static inline void appendSubtargetsForNodeToList(Node* node, SubtargetGeometryList& subtargets)
 {
     // Since the node is a result of a hit test, we are already ensured it has a renderer.
@@ -105,6 +114,25 @@ static inline void appendSubtargetsForNodeToList(Node* node, SubtargetGeometryLi
         subtargets.append(SubtargetGeometry(node, *it));
 }
 
+static inline void appendZoomableSubtargets(Node* node, SubtargetGeometryList& subtargets)
+{
+    RenderBox* renderer = toRenderBox(node->renderer());
+    ASSERT(renderer);
+
+    Vector<FloatQuad> quads;
+    FloatRect borderBoxRect = renderer->borderBoxRect();
+    FloatRect contentBoxRect = renderer->contentBoxRect();
+    quads.append(renderer->localToAbsoluteQuad(borderBoxRect));
+    if (borderBoxRect != contentBoxRect)
+        quads.append(renderer->localToAbsoluteQuad(contentBoxRect));
+    // FIXME: For RenderBlocks, add column boxes and content boxes cleared for floats.
+
+    Vector<FloatQuad>::const_iterator it = quads.begin();
+    const Vector<FloatQuad>::const_iterator end = quads.end();
+    for (; it != end; ++it)
+        subtargets.append(SubtargetGeometry(node, *it));
+}
+
 // Compiles a list of subtargets of all the relevant target nodes.
 void compileSubtargetList(const NodeList& intersectedNodes, SubtargetGeometryList& subtargets, NodeFilter nodeFilter)
 {
@@ -163,6 +191,18 @@ void compileSubtargetList(const NodeList& intersectedNodes, SubtargetGeometryLis
     }
 }
 
+// Compiles a list of zoomable subtargets.
+void compileZoomableSubtargets(const NodeList& intersectedNodes, SubtargetGeometryList& subtargets)
+{
+    unsigned length = intersectedNodes.length();
+    for (unsigned i = 0; i < length; ++i) {
+        Node* const candidate = intersectedNodes.item(i);
+        if (nodeIsZoomTarget(candidate))
+            appendZoomableSubtargets(candidate, subtargets);
+    }
+}
+
+
 float distanceSquaredToTargetCenterLine(const IntPoint& touchHotspot, const IntRect& touchArea, const SubtargetGeometry& subtarget)
 {
     UNUSED_PARAM(touchArea);
@@ -179,6 +219,19 @@ float distanceSquaredToTargetCenterLine(const IntPoint& touchHotspot, const IntR
     return rect.distanceSquaredFromCenterLineToPoint(touchHotspot);
 }
 
+float areaOfIntersection(const IntPoint& touchHotspot, const IntRect& touchArea, const SubtargetGeometry& subtarget)
+{
+    UNUSED_PARAM(touchHotspot);
+    IntRect rect = subtarget.boundingBox();
+
+    // Convert from frame coordinates to window coordinates.
+    rect = subtarget.node()->document()->view()->contentsToWindow(rect);
+    rect.intersect(touchArea);
+
+    return rect.size().area();
+}
+
+
 // A generic function for finding the target node with the lowest distance metric. A distance metric here is the result
 // of a distance-like function, that computes how well the touch hits the node.
 // Distance functions could for instance be distance squared or area of intersection.
@@ -205,6 +258,36 @@ bool findNodeWithLowestDistanceMetric(Node*& targetNode, IntPoint& targetPoint,
     return (targetNode);
 }
 
+// Similar generic function as findNodeWithLowestDistanceMetric, except this finds the innermost area with the largest intersection.
+bool findAreaWithLargestIntersection(Node*& targetNode, IntRect& targetArea, const IntPoint& touchHotspot, const IntRect& touchArea, SubtargetGeometryList& subtargets)
+{
+    targetNode = 0;
+    float bestDistanceMetric = 0.;
+    SubtargetGeometryList::const_iterator it = subtargets.begin();
+    const SubtargetGeometryList::const_iterator end = subtargets.end();
+    for (; it != end; ++it) {
+        Node* node = it->node();
+        float distanceMetric = areaOfIntersection(touchHotspot, touchArea, *it);
+        if (distanceMetric > bestDistanceMetric) {
+            targetArea = it->boundingBox();
+            targetNode = node;
+            bestDistanceMetric = distanceMetric;
+        } else if (distanceMetric == bestDistanceMetric) {
+            // Try to return the smallest inner-most subtarget.
+            if (node == targetNode) {
+                if (it->boundingBox().size().area() < targetArea.size().area())
+                    targetArea = it->boundingBox();
+            } else if (node->isDescendantOf(targetNode)) {
+                targetArea = it->boundingBox();
+                targetNode = node;
+            }
+        }
+    }
+
+    return (targetNode);
+}
+
+
 } // namespace TouchAdjustment
 
 bool findBestClickableCandidate(Node*& targetNode, IntPoint &targetPoint, const IntPoint &touchHotspot, const IntRect &touchArea, const NodeList& nodeList)
@@ -214,4 +297,11 @@ bool findBestClickableCandidate(Node*& targetNode, IntPoint &targetPoint, const
     return TouchAdjustment::findNodeWithLowestDistanceMetric(targetNode, targetPoint, touchHotspot, touchArea, subtargets, TouchAdjustment::distanceSquaredToTargetCenterLine);
 }
 
+bool findBestZoomableArea(Node*& targetNode, IntRect& targetArea, const IntPoint& touchHotspot, const IntRect& touchArea, const NodeList& nodeList)
+{
+    TouchAdjustment::SubtargetGeometryList subtargets;
+    TouchAdjustment::compileZoomableSubtargets(nodeList, subtargets);
+    return TouchAdjustment::findAreaWithLargestIntersection(targetNode, targetArea, touchHotspot, touchArea, subtargets);
+}
+
 } // namespace WebCore
index d5dfc10..bd4cb95 100644 (file)
@@ -29,6 +29,7 @@
 namespace WebCore {
 
 bool findBestClickableCandidate(Node*& targetNode, IntPoint& targetPoint, const IntPoint& touchHotspot, const IntRect& touchArea, const NodeList&);
+bool findBestZoomableArea(Node*& targetNode, IntRect& targetArea, const IntPoint& touchHotspot, const IntRect& touchArea, const NodeList&);
 // FIXME: Implement the similar functions for other gestures here as well.
 
 } // namespace WebCore
index f11f815..8ec6539 100644 (file)
@@ -104,6 +104,11 @@ public:
         *this = expandedTo(IntSize());
     }
 
+    int area() const
+    {
+        return m_width * m_height;
+    }
+
     int diagonalLengthSquared() const
     {
         return m_width * m_width + m_height * m_height;
index ddd10ab..2a7244c 100644 (file)
@@ -654,6 +654,23 @@ Node* Internals::touchNodeAdjustedToBestClickableNode(long x, long y, long width
     document->frame()->eventHandler()->bestClickableNodeForTouchPoint(point, radius, adjustedPoint, targetNode);
     return targetNode;
 }
+
+PassRefPtr<ClientRect> Internals::bestZoomableAreaForTouchPoint(long x, long y, long width, long height, Document* document, ExceptionCode& ec)
+{
+    if (!document || !document->frame()) {
+        ec = INVALID_ACCESS_ERR;
+        return 0;
+    }
+
+    IntSize radius(width / 2, height / 2);
+    IntPoint point(x + radius.width(), y + radius.height());
+
+
+    Node* targetNode;
+    IntRect zoomableArea;
+    document->frame()->eventHandler()->bestZoomableAreaForTouchPoint(point, radius, zoomableArea, targetNode);
+    return ClientRect::create(zoomableArea);
+}
 #endif
 
 
index ead0e19..05f949c 100644 (file)
@@ -121,6 +121,7 @@ public:
 #if ENABLE(TOUCH_ADJUSTMENT)
     PassRefPtr<WebKitPoint> touchPositionAdjustedToBestClickableNode(long x, long y, long width, long height, Document*, ExceptionCode&);
     Node* touchNodeAdjustedToBestClickableNode(long x, long y, long width, long height, Document*, ExceptionCode&);
+    PassRefPtr<ClientRect> bestZoomableAreaForTouchPoint(long x, long y, long width, long height, Document*, ExceptionCode&);
 #endif
 
     int lastSpellCheckRequestSequence(Document*, ExceptionCode&);
index 0735b16..ba73634 100644 (file)
@@ -95,6 +95,7 @@ module window {
 #if defined(ENABLE_TOUCH_ADJUSTMENT) && ENABLE_TOUCH_ADJUSTMENT
         WebKitPoint touchPositionAdjustedToBestClickableNode(in long x, in long y, in long width, in long height, in Document document) raises (DOMException);
         Node touchNodeAdjustedToBestClickableNode(in long x, in long y, in long width, in long height, in Document document) raises (DOMException);
+        ClientRect bestZoomableAreaForTouchPoint(in long x, in long y, in long width, in long height, in Document document) raises (DOMException);
 #endif
 
         long lastSpellCheckRequestSequence(in Document document) raises (DOMException);
index 272c65f..1ac371b 100644 (file)
@@ -1,3 +1,26 @@
+2012-03-30  Allan Sandfeld Jensen  <allan.jensen@nokia.com>
+
+        [Qt] Find zoomable area using area-based hit-testing
+        https://bugs.webkit.org/show_bug.cgi?id=82609
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Add area to findZoomableAreaForPoint and use new TOUCH_ADJUSTMENT
+        code-path to find the best zoomable area.
+
+        * UIProcess/WebPageProxy.cpp:
+        (WebKit::WebPageProxy::findZoomableAreaForPoint):
+        * UIProcess/WebPageProxy.h:
+        (WebPageProxy):
+        * UIProcess/qt/QtWebPageEventHandler.cpp:
+        (QtWebPageEventHandler::handleDoubleTapEvent):
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit):
+        (WebKit::WebPage::findZoomableAreaForPoint):
+        * WebProcess/WebPage/WebPage.h:
+        (WebPage):
+        * WebProcess/WebPage/WebPage.messages.in:
+
 2012-03-30  Keishi Hattori  <keishi@webkit.org>
 
         Change ENABLE_INPUT_COLOR to ENABLE_INPUT_TYPE_COLOR and enable it for chromium
index 3e632ab..0aeda0e 100644 (file)
@@ -2435,12 +2435,12 @@ void WebPageProxy::didFindZoomableArea(const IntPoint& target, const IntRect& ar
     m_pageClient->didFindZoomableArea(target, area);
 }
 
-void WebPageProxy::findZoomableAreaForPoint(const IntPoint& point)
+void WebPageProxy::findZoomableAreaForPoint(const IntPoint& point, const IntSize& area)
 {
     if (!isValid())
         return;
 
-    process()->send(Messages::WebPage::FindZoomableAreaForPoint(point), m_pageID);
+    process()->send(Messages::WebPage::FindZoomableAreaForPoint(point, area), m_pageID);
 }
 
 void WebPageProxy::didReceiveMessageFromNavigatorQtObject(const String& contents)
index b409f04..6831f39 100644 (file)
@@ -576,7 +576,7 @@ public:
     WebPageCreationParameters creationParameters() const;
 
 #if PLATFORM(QT)
-    void findZoomableAreaForPoint(const WebCore::IntPoint&);
+    void findZoomableAreaForPoint(const WebCore::IntPoint&, const WebCore::IntSize&);
     void didReceiveMessageFromNavigatorQtObject(const String&);
     void handleDownloadRequest(DownloadProxy*);
 #endif
index 10dad7a..3e78ca2 100644 (file)
@@ -255,7 +255,7 @@ void QtWebPageEventHandler::handleSingleTapEvent(const QTouchEvent::TouchPoint&
 void QtWebPageEventHandler::handleDoubleTapEvent(const QTouchEvent::TouchPoint& point)
 {
     QTransform fromItemTransform = m_webPage->transformFromItem();
-    m_webPageProxy->findZoomableAreaForPoint(fromItemTransform.map(point.pos()).toPoint());
+    m_webPageProxy->findZoomableAreaForPoint(fromItemTransform.map(point.pos()).toPoint(), IntSize(point.rect().size().toSize()));
 }
 
 void QtWebPageEventHandler::timerEvent(QTimerEvent* ev)
index 9f8fb8e..8ebd81c 100644 (file)
@@ -2510,9 +2510,28 @@ InjectedBundleBackForwardList* WebPage::backForwardList()
 }
 
 #if PLATFORM(QT)
-void WebPage::findZoomableAreaForPoint(const WebCore::IntPoint& point)
+#if ENABLE(TOUCH_ADJUSTMENT)
+void WebPage::findZoomableAreaForPoint(const WebCore::IntPoint& point, const WebCore::IntSize& area)
 {
     Frame* mainframe = m_mainFrame->coreFrame();
+    Node* node = 0;
+    IntRect zoomableArea;
+    mainframe->eventHandler()->bestZoomableAreaForTouchPoint(point, area, zoomableArea, node);
+
+    ASSERT(node);
+    if (node->document() && node->document()->frame() && node->document()->frame()->view()) {
+        const ScrollView* view = node->document()->frame()->view();
+        zoomableArea = view->contentsToWindow(zoomableArea);
+    }
+
+    send(Messages::WebPageProxy::DidFindZoomableArea(point, zoomableArea));
+}
+
+#else
+void WebPage::findZoomableAreaForPoint(const WebCore::IntPoint& point, const WebCore::IntSize& area)
+{
+    UNUSED_PARAM(area);
+    Frame* mainframe = m_mainFrame->coreFrame();
     HitTestResult result = mainframe->eventHandler()->hitTestResultAtPoint(mainframe->view()->windowToContents(point), /*allowShadowContent*/ false, /*ignoreClipping*/ true);
 
     Node* node = result.innerNode();
@@ -2547,6 +2566,7 @@ void WebPage::findZoomableAreaForPoint(const WebCore::IntPoint& point)
     send(Messages::WebPageProxy::DidFindZoomableArea(point, zoomableArea));
 }
 #endif
+#endif
 
 WebPage::SandboxExtensionTracker::~SandboxExtensionTracker()
 {
index e9de2ed..6a852d4 100644 (file)
@@ -627,7 +627,7 @@ private:
     void countStringMatches(const String&, uint32_t findOptions, uint32_t maxMatchCount);
 
 #if PLATFORM(QT)
-    void findZoomableAreaForPoint(const WebCore::IntPoint&);
+    void findZoomableAreaForPoint(const WebCore::IntPoint&, const WebCore::IntSize& area);
 #endif
 
     void didChangeSelectedIndexForActivePopupMenu(int32_t newIndex);
index 1935fe3..899e759 100644 (file)
@@ -254,7 +254,7 @@ messages -> WebPage {
     GestureDidEnd()
 #endif
 #if PLATFORM(QT)
-    FindZoomableAreaForPoint(WebCore::IntPoint point)
+    FindZoomableAreaForPoint(WebCore::IntPoint point, WebCore::IntSize area)
 #endif
 
 #if PLATFORM(MAC) && !defined(BUILDING_ON_SNOW_LEOPARD)