ChangeLog

2013-09-13  Eunmi Lee  <eunmi15.lee@samsung.com>

        [EFL][WK2] Implement pan and flick gesture.

        https://bugs.webkit.org/show_bug.cgi?id=107101

        Reviewed by NOBODY (OOPS!).

        Implement pan gesture to scroll page by movement of point and stop

        scrolling smoothly using ease-in-out-quad algorithm after touched

        point is removed from the screen.

        Use Ecore_Animator in order to process movement once per each framing

        time slot instead of processing all movement.

        * PlatformEfl.cmake:

        * UIProcess/API/efl/EwkView.cpp:

        (EwkView::scrollBy):

        * UIProcess/API/efl/EwkView.h:

        * UIProcess/API/efl/GestureRecognizer.cpp:

        (WebKit::GestureHandler::view):

        (WebKit::GestureHandler::GestureHandler):

        (WebKit::GestureHandler::~GestureHandler):

        (WebKit::GestureHandler::reset):

        (WebKit::GestureHandler::panAnimatorCallback):

        (WebKit::GestureHandler::handlePanStarted):

        (WebKit::GestureHandler::handlePan):

        (WebKit::GestureHandler::handlePanFinished):

        (WebKit::GestureHandler::flickAnimatorCallback):

        (WebKit::GestureHandler::handleFlick):

        (WebKit::GestureRecognizer::noGesture):

        (WebKit::GestureRecognizer::reset):

        * UIProcess/efl/EasingCurves.cpp: Added.

        (WebKit::easeInOutQuad):

        * UIProcess/efl/EasingCurves.h: Added.

2013-09-11  Simon Fraser  <simon.fraser@apple.com>

        Make sure that layout is up-to-date when moving a WKView into a window, to avoid !needsLayout() assertions in RenderView::paint()

Source/WebKit2/PlatformEfl.cmake

@@list(APPEND WebKit2_SOURCES

    UIProcess/efl/ContextHistoryClientEfl.cpp

    UIProcess/efl/ContextMenuClientEfl.cpp

    UIProcess/efl/DownloadManagerEfl.cpp

109 UIProcess/efl/EasingCurves.cpp

    UIProcess/efl/EwkTouchEvent.cpp

    UIProcess/efl/EwkTouchPoint.cpp

    UIProcess/efl/FindClientEfl.cpp

Source/WebKit2/UIProcess/API/efl/EwkView.cpp

@@void EwkView::didFindZoomableArea(const WKPoint& point, const WKRect& area)

    UNUSED_PARAM(area);

}

bool EwkView::scrollBy(const IntSize& offset)

{

    WKPoint oldPosition = WKViewGetContentPosition(wkView());

    FloatPoint newPosition(oldPosition.x + offset.width(), oldPosition.y + offset.height());

    // Update new position to the PageViewportController.

    float contentScale = WKViewGetContentScaleFactor(wkView());

    newPosition.scale(1 / contentScale, 1 / contentScale);

    newPosition = m_pageViewportController->boundContentsPositionAtScale(newPosition, contentScale);

    m_pageViewportController->didChangeContentsVisibility(newPosition, contentScale);

    // Update new position to the WKView.

    WKPoint position = WKPointMake(newPosition.x() * contentScale, newPosition.y() * contentScale);

    WKViewSetContentPosition(wkView(), position);

    // If the page position has not changed, notify the caller using the return value.

    return !(oldPosition == position);

}

Evas_Smart_Class EwkView::parentSmartClass = EVAS_SMART_CLASS_INIT_NULL;

// Free Ewk View functions.

Source/WebKit2/UIProcess/API/efl/EwkView.h

@@public:

    void informURLChange();

    PassRefPtr<cairo_surface_t> takeSnapshot();

205 bool scrollBy(const WebCore::IntSize&);

    void didFindZoomableArea(const WKPoint&, const WKRect&);

Source/WebKit2/UIProcess/API/efl/GestureRecognizer.cpp

#include "config.h"

#include "GestureRecognizer.h"

30#include "EasingCurves.h"

#include "EwkView.h"

#include "NotImplemented.h"

#include "WKSharedAPICast.h"

@@public:

    {

        return adoptPtr(new GestureHandler(ewkView));

    }

47 ~GestureHandler();

4648

    void handleSingleTap(const WebCore::IntPoint&);

    void handleDoubleTap(const WebCore::IntPoint&);

    void handleTapAndHold(const WebCore::IntPoint&);

    void handlePanStarted(const WebCore::IntPoint&);

    void handlePan(const WebCore::IntPoint&);

    EwkView* view() { return m_ewkView; }

    void reset();

    void handleSingleTap(const IntPoint&);

    void handleDoubleTap(const IntPoint&);

    void handleTapAndHold(const IntPoint&);

    void handlePanStarted(const IntPoint&);

    void handlePan(const IntPoint&);

5257 void handlePanFinished();

53 void handlePinchStarted(const Vector<WebCore::IntPoint>&);

54 void handlePinch(const Vector<WebCore::IntPoint>&);

    void handleFlick(const IntSize&);

    void handlePinchStarted(const Vector<IntPoint>&);

    void handlePinch(const Vector<IntPoint>&);

    void handlePinchFinished();

private:

    explicit GestureHandler(EwkView*);

    static Eina_Bool panAnimatorCallback(void*);

    static Eina_Bool flickAnimatorCallback(void*);

    static const int s_historyCapacity = 5;

6071 EwkView* m_ewkView;

    IntPoint m_lastPoint;

    IntPoint m_currentPoint;

    bool m_isCurrentPointUpdated;

    Ecore_Animator* m_panAnimator;

    Ecore_Animator* m_flickAnimator;

    IntSize m_flickOffset;

    unsigned m_flickDuration;

    unsigned m_flickIndex;

    struct HistoryItem {

        IntPoint point;

        double timestamp;

    };

    Vector<HistoryItem> m_history;

    size_t m_oldestHistoryItemIndex;

};

GestureHandler::GestureHandler(EwkView* ewkView)

    : m_ewkView(ewkView)

    , m_isCurrentPointUpdated(false)

    , m_panAnimator(0)

    , m_flickAnimator(0)

    , m_flickDuration(0)

    , m_flickIndex(0)

    , m_oldestHistoryItemIndex(0)

6597{

    m_history.reserveInitialCapacity(s_historyCapacity);

}

GestureHandler::~GestureHandler()

{

    reset();

}

void GestureHandler::reset()

{

    if (m_panAnimator) {

        ecore_animator_del(m_panAnimator);

        m_panAnimator = 0;

        m_oldestHistoryItemIndex = 0;

        m_history.resize(0);

    }

    if (m_flickAnimator) {

        ecore_animator_del(m_flickAnimator);

        m_flickAnimator = 0;

    }

}

void GestureHandler::handleSingleTap(const IntPoint&)

@@void GestureHandler::handleTapAndHold(const IntPoint&)

    notImplemented();

}

83 v~~oid~~ GestureHandler::han~~dlePanStarted(const IntPoint&~~)

137Eina_Bool GestureHandler::panAnimatorCallback(void* data)

84138{

85 notImplemented();

    GestureHandler* gestureHandler = static_cast<GestureHandler*>(data);

    if (!gestureHandler->m_isCurrentPointUpdated || gestureHandler->m_lastPoint == gestureHandler->m_currentPoint)

        return ECORE_CALLBACK_RENEW;

    gestureHandler->view()->scrollBy(gestureHandler->m_lastPoint - gestureHandler->m_currentPoint);

    gestureHandler->m_lastPoint = gestureHandler->m_currentPoint;

    gestureHandler->m_isCurrentPointUpdated = false;

    return ECORE_CALLBACK_RENEW;

86148}

87149

88 void GestureHandler::handlePan(const IntPoint&)

150void GestureHandler::handlePanStarted(const IntPoint& point)

89151{

90 notImplemented();

    ASSERT(!m_panAnimator);

    m_panAnimator = ecore_animator_add(panAnimatorCallback, this);

    m_lastPoint = m_currentPoint = point;

}

void GestureHandler::handlePan(const IntPoint& point)

{

    m_currentPoint = point;

    m_isCurrentPointUpdated = true;

    // Save current point to use to calculate offset of flick.

    HistoryItem item = { m_currentPoint, ecore_time_get() };

    if (m_history.size() < m_history.capacity())

        m_history.uncheckedAppend(item);

    else {

        m_history[m_oldestHistoryItemIndex++] = item;

        if (m_oldestHistoryItemIndex == m_history.capacity())

            m_oldestHistoryItemIndex = 0;

    }

}

void GestureHandler::handlePanFinished()

{

95 notImplemented();

    ASSERT(m_panAnimator);

    ecore_animator_del(m_panAnimator);

    m_panAnimator = 0;

    if (!m_history.isEmpty()) {

        // Calculate offset to move during one frame.

        const HistoryItem& firstHistoryItem = m_history[m_oldestHistoryItemIndex];

        double frame = (ecore_time_get() - firstHistoryItem.timestamp) / ecore_animator_frametime_get();

        IntSize offset = firstHistoryItem.point - m_currentPoint;

        offset.scale(1 / frame);

        handleFlick(offset);

    }

    m_oldestHistoryItemIndex = 0;

    m_history.resize(0);

}

Eina_Bool GestureHandler::flickAnimatorCallback(void* data)

{

    GestureHandler* gestureHandler = static_cast<GestureHandler*>(data);

    float multiplier = easeInOutQuad(gestureHandler->m_flickIndex, 0, 1.0, gestureHandler->m_flickDuration);

    float offsetWidth = gestureHandler->m_flickOffset.width() * multiplier;

    float offsetHeight = gestureHandler->m_flickOffset.height() * multiplier;

    offsetWidth = (offsetWidth > 0) ? ceilf(offsetWidth) : floorf(offsetWidth);

    offsetHeight = (offsetHeight > 0) ? ceilf(offsetHeight) : floorf(offsetHeight);

    IntSize offset(offsetWidth, offsetHeight);

    gestureHandler->m_flickIndex--;

    if (offset.isZero() || !gestureHandler->view()->scrollBy(offset) || !gestureHandler->m_flickIndex) {

        gestureHandler->m_flickAnimator = 0;

        return ECORE_CALLBACK_CANCEL;

    }

    return ECORE_CALLBACK_RENEW;

}

void GestureHandler::handleFlick(const IntSize& offset)

{

    m_flickOffset = offset;

    m_flickIndex = m_flickDuration = 1 / ecore_animator_frametime_get();

    m_flickAnimator = ecore_animator_add(flickAnimatorCallback, this);

}

void GestureHandler::handlePinchStarted(const Vector<IntPoint>&)

@@void GestureRecognizer::noGesture(WKEventType type, WKArrayRef touchPoints)

{

    switch (type) {

    case kWKEventTypeTouchStart:

319 m_gestureHandler->reset();

320

        m_recognizerFunction = &GestureRecognizer::singleTapGesture;

        m_firstPressedPoint = toIntPoint(getPointAtIndex(touchPoints, 0));

        ASSERT(!m_tapAndHoldTimer);

@@void GestureRecognizer::pinchGesture(WKEventType type, WKArrayRef touchPoints)

void GestureRecognizer::reset()

{

    stopTapTimers();

465 m_gestureHandler->reset();

    m_recognizerFunction = &GestureRecognizer::noGesture;

}

Source/WebKit2/UIProcess/efl/EasingCurves.cpp

/*

 * Copyright (C) 2001 Robert Penner. All rights reserved.

 * Copyright (C) 2013 Samsung Electronics. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the author nor the names of contributors may be

 *    used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

/*

 * Robert Penner's easing equations. http://www.robertpenner.com/easing/

 * static function easeInOutQuad (t:Number, b:Number, c:Number, d:Number):Number {

 *     if ((t/=d/2) < 1) return c/2*t*t + b;

 *     return -c/2 * ((--t)*(t-2) - 1) + b;

 * }

 */

namespace WebKit {

float easeInOutQuad(float time, const float base, const float constant, const unsigned duration)

{

    if (time > duration || time < 0)

        return 0;

    if ((time /= (duration / 2)) < 1)

        return (constant / 2) * time * time + base;

    time -= 1;

    return -1 * (constant / 2) * (time * (time - 2) - 1) + base;

}

} // namespace WebKit

Source/WebKit2/UIProcess/efl/EasingCurves.h

/*

 * Copyright (C) 2001 Robert Penner. All rights reserved.

 * Copyright (C) 2013 Samsung Electronics. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the author nor the names of contributors may be

 *    used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef EasingCurves_h

#define EasingCurves_h

namespace WebKit {

float easeInOutQuad(float time, const float base, const float constant, const unsigned duration);

} // namespace WebKit

#endif // EasingCurves_h