MCL/sf/mw/web: comparison webengine/osswebengine/WebKit/s60/webview/WebPointerEventHandler.cpp

equal deleted inserted replaced

-:6297cdf66332
+:d39add9822e2
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */
 #include <browser_platform_variant.hrh>
 #include "config.h"
 #include "RenderStyle.h"
 #include "RenderObject.h"
 #include "CSSStyleSelector.h"
 #include "CSSValueKeywords.h"
 #include "Settings.h"
+#include "WebGestureInterface.h"
+#include "WebPagePinchZoomHandler.h"
 #include "WebKitLogger.h"
 using namespace WebCore;
 using namespace EventNames;
-using namespace RT_GestureHelper;
 static const int KMinScrollAndTapInterval = 200000;				// 200 ms
 static const int KDoubleTapMinActivationInterval = 100000;     // 100 ms
 static const int KDoubleTapMaxActivationInterval = 500000;     // 500 ms
 static const int KDoubleTapIdleInterval = 700000;			// 700 ms, to prevent triple-tap effects
 WebPointerEventHandler::WebPointerEventHandler(WebView* view)
 : m_webview(view),
 m_isHighlighted(false),
 m_highlightedNode(NULL),
 m_buttonDownTimer( this, &WebPointerEventHandler::buttonDownTimerCB ),
-m_ignoreTap(false)
+m_ignoreTap(false),
+m_gestureInterface(NULL)
 {
 }
 //-----------------------------------------------------------------------------
 // WebPointerEventHandler::~WebPointerEventHandler
 //-----------------------------------------------------------------------------
 WebPointerEventHandler::~WebPointerEventHandler()
 {
-delete m_gestureHelper;
+delete m_gestureInterface;
 delete m_waiter;
 }
 //-----------------------------------------------------------------------------
 // WebPointerEventHandler::ConstructL
 //-----------------------------------------------------------------------------
 void WebPointerEventHandler::ConstructL()
 {
 #ifdef BRDO_USE_GESTURE_HELPER
-m_gestureHelper = CGestureHelper::NewL( *this );
+m_gestureInterface = WebGestureInterface::NewL(m_webview);
-m_gestureHelper->SetDoubleTapEnabled(true);
-m_gestureHelper->SetHoldingEnabled(false);
 #else
-m_gestureHelper = NULL;
+m_gestureInterface = NULL;
 #endif
 m_waiter = new(ELeave) CActiveSchedulerWait();
 }
-/**
-* EGestureStart is sent on touch down
-* EGestureReleased is sent on touch up
+// ======================================================================
-* EGestureTap = touch down + touch up - events sent: EGestureStart, EGestureTap
+// WebPointerEventHandler::HandleGestureEventL
-*                EGestureReleased
+// ======================================================================
-* EGestureDrag = touch down + "move" - events sent: EGestureStart, EGestureDrag
+void  WebPointerEventHandler::HandleGestureEventL(const TStmGestureEvent& aGesture)
-* EGestureDoubleTap = 2 * (touch down + touch up) - events sent EGestureStart,
+{
-*                     EGestureDoubleTap, EGestureReleased
+TStmGestureUid uid = aGesture.Code();
-* EGestureLongTap = touch down + "long touch" - events sent: EGestureStart,
-*                   EGestureLongTap
+if (m_webview->pinchZoomHandler()->isPinchActive() && uid != stmGesture::EGestureUidPinch)
-* EGestureSwipe<Up/Down/Left/Right> - drag + touch up, where movements is
+return;
-*                   close to particular direction - event sent: EGestureSwipe,
-*                   EGestureReleased
-* EGestureFlick - "fast" drag + touch up - events sent: EGestureFlick,
-*                  EGestureReleased
-* EGestureDrop -  drag + touch up, !(EGestureSwipe || EGestureFlick) - events
-*                 sent: EGestureDrop, EGestureReleased
-*/
-void WebPointerEventHandler::HandleGestureL( const TGestureEvent& aEvent )
-{
-TGestureCode gtype = aEvent.Code(EAxisBoth);
 TBrCtlDefs::TBrCtlElementType elType = m_webview->focusedElementType();
 PluginSkin* plugin = m_webview->mainFrame()->focusedPlugin();
 if (plugin && plugin->pluginWin()) {
-if (plugin->pluginWin()->HandleGesture(aEvent)) {
+if (plugin->pluginWin()->HandleGesture(aGesture)) {
 if(!plugin->isActive())
 plugin->activate();
 return;
 }
 }
-updateCursor(aEvent.CurrentPos());
+updateCursor(aGesture.CurrentPos());
 if (IS_TABBED_NAVIGATION) {
-m_webview->tabbedNavigation()->updateCursorPosition(aEvent.CurrentPos());
+m_webview->tabbedNavigation()->updateCursorPosition(aGesture.CurrentPos());
 }
-switch (gtype) {
-// sent on touch down
-case EGestureStart:
+switch(uid) {
-{
+case stmGesture::EGestureUidTouch:
-if (m_webview->viewIsScrolling()) {
+{
-m_ignoreTap = true;
+if (m_webview->viewIsScrolling()) {
-m_webview->pageScrollHandler()->handleTouchDownGH(aEvent);
+m_ignoreTap = true;
-}
+m_webview->pageScrollHandler()->handleTouchDownGH(aGesture);
-else {
+}
-handleTouchDownL(aEvent);
+else {
-}
+handleTouchDownL(aGesture);
-break;
+}
-}
+break;
+}
-// sent on tap
-case EGestureTap:
-{
+case stmGesture::EGestureUidTap:
-if (!m_ignoreTap) {
+{
-handleTapL(aEvent);
+if (aGesture.Type() == stmGesture::ETapTypeSingle) {
-}
+if (!m_ignoreTap) {
-break;
+handleTapL(aGesture);
 }
+}
-// sent on double tap
+else {
-case EGestureDoubleTap:
+handleDoubleTap(aGesture);
-{
+}
-handleDoubleTap(aEvent);
 break;
 }
-// sent on long tap
+case stmGesture::EGestureUidRelease:
-case EGestureLongTap:
+{
-{
+m_ignoreTap = false;
-break;
+handleTouchUp(aGesture);
-}
+break;
+}
-// sent on touch up after drag
-case EGestureDrop:
+case stmGesture::EGestureUidPan:
-case EGestureFlick:
+{
-case EGestureSwipeLeft:
+handleMove(aGesture);
-case EGestureSwipeRight:
+break;
-case EGestureSwipeUp:
+}
-case EGestureSwipeDown:
+case stmGesture::EGestureUidFlick:
 {
 m_ignoreTap = false;
 if (!IS_NAVIGATION_NONE) {
-handleTouchUp(aEvent);
+handleTouchUp(aGesture);
 }
 else {
 Frame* frm = m_webview->page()->focusController()->focusedOrMainFrame();
 m_webview->sendMouseEventToEngine(TPointerEvent::EButton1Up, m_highlightPos, frm);
 }
 break;
 }
-// sent on move
-case EGestureDrag:
+case stmGesture::EGestureUidPinch:
 {
-handleMove(aEvent);
+handlePinchZoomL(aGesture);
 break;
 }
+default:
-// sent on touch up after tap double tap and long tap
+break;
-case EGestureReleased:
-{
+}
-m_ignoreTap = false;
+return;
-handleTouchUp(aEvent);
-break;
-}
-}
 }
 // ======================================================================
 // WebPointerEventHandler::handleTap
 // ======================================================================
-void WebPointerEventHandler::handleTapL(const TGestureEvent& aEvent)
+void WebPointerEventHandler::handleTapL(const TStmGestureEvent& aGesture)
 {
 m_buttonDownTimer.stop();
 m_lastTapEvent = m_currentEvent;
 if(!m_webview->inPageViewMode()){
 	doTapL();
 }
 }
 // ======================================================================
 //  WebPointerEventHandler::handleDoubleTap
 //======================================================================
-void WebPointerEventHandler::handleDoubleTap(const TGestureEvent& aEvent)
+void WebPointerEventHandler::handleDoubleTap(const TStmGestureEvent& aGesture)
 {
 if ( !m_webview->viewIsScrolling() &&
 (m_webview->brCtl()->capabilities() & TBrCtlDefs::ECapabilityFitToScreen)) {
 if (m_isHighlighted){
 dehighlight();
 }
 m_webview->setZoomLevelAdaptively();
 }
 else {
 m_webview->resetLastZoomLevelIfNeeded();
 }
 // ======================================================================
 // WebPointerEventHandler::handleTouchDownL
 //======================================================================
-void WebPointerEventHandler::handleTouchDownL(const TGestureEvent& aEvent)
+void WebPointerEventHandler::handleTouchDownL(const TStmGestureEvent& aGesture)
 {
 TBrCtlDefs::TBrCtlElementType elType = m_webview->focusedElementType();
 PluginHandler* pluginHandler = WebCore::StaticObjectsContainer::instance()->pluginHandler();
 PluginSkin* pluginToActivate = pluginHandler->pluginToActivate();
 m_buttonDownEvent = m_currentEvent;
-m_highlightPos = aEvent.CurrentPos();
+m_highlightPos = aGesture.CurrentPos();
 if ( !m_buttonDownTimer.isActive() && !m_webview->inPageViewMode()){
 m_buttonDownTimer.startOneShot(0.1f);
 }
 if (!IS_NAVIGATION_NONE) {
-m_webview->pageScrollHandler()->handleTouchDownGH(aEvent);
+m_webview->pageScrollHandler()->handleTouchDownGH(aGesture);
 }
 if ( TBrCtlDefs::EElementActivatedObjectBox == elType) {
 PluginSkin* plugin = m_webview->mainFrame()->focusedPlugin();
 if (plugin && plugin->pluginWin()) {
 else {
 plugin->pluginWin()->HandlePointerEventL(m_buttonDownEvent);
 }
 }
 }
 /*
 * After introducing "link selection" pointer down action is done in
 * buttondown timer callback. When "down" gesture event is arrived we start
 * timer end exit, so gesture helper is ready to deliver next gesture event.
 * Meanwhile the processing of the first gesture event hasn't been finished yet.
 * The gesture helper doesn't "know" about our plans to handle the event inside
 * timer callback and only way for us to "tell" about this is to stop RunL()
 * of CGestureEventSender (HandleGestureL() is inside it) and finish buttondown
 * timer callback first.
 */
 if ( m_buttonDownTimer.isActive()){
 m_waiter->Start();
 }
 }
 // ======================================================================
 // WebPointerEventHandler::handleTouchUp
 // ======================================================================
-void WebPointerEventHandler::handleTouchUp(const TGestureEvent& aEvent)
+void WebPointerEventHandler::handleTouchUp(const TStmGestureEvent& aGesture)
 {
 m_highlightPos = TPoint(-1,-1);
 m_highlightedNode = NULL;
 PluginHandler* pluginHandler = WebCore::StaticObjectsContainer::instance()->pluginHandler();
 pluginHandler->setPluginToActivate(NULL);
 if (!IS_NAVIGATION_NONE) {
-m_webview->pageScrollHandler()->handleTouchUpGH(aEvent);
+m_webview->pageScrollHandler()->handleTouchUpGH(aGesture);
 }
 }
 // ======================================================================
 // WebPointerEventHandler::handleMoveL
 // ======================================================================
-void WebPointerEventHandler::handleMove(const TGestureEvent& aEvent)
+void WebPointerEventHandler::handleMove(const TStmGestureEvent& aGesture)
 {
 TBrCtlDefs::TBrCtlElementType elType = m_webview->focusedElementType();
-TPoint curPos = aEvent.CurrentPos();
+TPoint curPos =  aGesture.CurrentPos();
 PluginHandler* pluginHandler = WebCore::StaticObjectsContainer::instance()->pluginHandler();
 pluginHandler->setPluginToActivate(NULL);
 m_buttonDownTimer.stop();
 if (IS_NAVIGATION_NONE) {
 Frame* frm = m_webview->page()->focusController()->focusedOrMainFrame();
 m_webview->sendMouseEventToEngine(TPointerEvent::EMove, curPos, frm);
 }
 else {
 HandleHighlightChange(curPos);
-m_webview->pageScrollHandler()->handleScrollingGH(aEvent);
+m_webview->pageScrollHandler()->handleScrollingGH(aGesture);
 }
 }
 // ======================================================================
 // WebPointerEventHandler::HandlePointerEventL
 // ======================================================================
 void WebPointerEventHandler::HandlePointerEventL(const TPointerEvent& aPointerEvent)
 {
 m_currentEvent = aPointerEvent;
 if (m_webview->isSynchRequestPending()) {
 return;
 }
 // Handle graphical history - should never happen, as HistoryView handles this event by itself
 if ( m_webview->brCtl()->historyHandler()->historyController()->historyView()) {
 return;
 }
 // Handle FormFill popup
 if (m_webview->formFillPopup() && m_webview->formFillPopup()->IsVisible()) {
 m_webview->formFillPopup()->HandlePointerEventL(aPointerEvent);
 return;
 }
-if (!m_webview->inPageViewMode()) {
-if (aPointerEvent.iType == TPointerEvent::EButton1Down) {
-m_webview->GetContainerWindow().EnablePointerMoveBuffer();
-}
-else if (aPointerEvent.iType == TPointerEvent::EButton1Up) {
-m_webview->GetContainerWindow().DisablePointerMoveBuffer();
-}
-}
 #ifdef BRDO_USE_GESTURE_HELPER
-m_gestureHelper->HandlePointerEventL(aPointerEvent);
+m_gestureInterface->HandlePointerEventL(aPointerEvent);
 #endif
 }
 //-----------------------------------------------------------------------------
 // WebPointerEventHandler::HandleHighlightChange
 //-----------------------------------------------------------------------------
 {
 TRect elRect;
 TBrCtlDefs::TBrCtlElementType elType = TBrCtlDefs::EElementNone;
 Frame* coreFrame = core(m_webview->mainFrame());
 WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
 TPointerEvent event;
 TPoint pos = cursor->position();
 WebFrame* wfrm = cursor->getFrameAtPoint(pos);
 Frame* frm = core(wfrm);
 TPoint pt(wfrm->frameView()->viewCoordsInFrameCoords(pos));
 TPoint nodePoint;
 Element* eventNode = frm->document()->elementFromPoint(pt.iX, pt.iY);
 if (m_isHighlighted){
 dehighlight();
 }
 m_highlightedNode = NULL;
 Node* retNode = 0;
 frm->bridge()->getTypeFromElement(eventNode, elType, elRect, retNode);
 if (elType == TBrCtlDefs::EElementNone) {
 Node* n = wfrm->getClosestAnchorElement(cursor->position(), pos);
 if (n) {
 wfrm = cursor->getFrameAtPoint(pos);
 frm = core(wfrm);
-eventNode = frm->document()->elementFromPoint(pos.iX, pos.iY);
+//eventNode = frm->document()->elementFromPoint(pos.iX, pos.iY);
+TPoint newPos(wfrm->frameView()->viewCoordsInFrameCoords(pos));
+eventNode = frm->document()->elementFromPoint(newPos.iX, newPos.iY);
 frm->bridge()->getTypeFromElement(eventNode, elType, elRect, retNode);
 TPoint nodePoint = n->getRect().Rect().Center();
 m_offset = (pt.iX- nodePoint.iX)*(pt.iX- nodePoint.iX) +
 (pt.iY- nodePoint.iY)*(pt.iY- nodePoint.iY);
 }
 //-----------------------------------------------------------------------------
 void WebPointerEventHandler::doTapL()
 {
 TBrCtlDefs::TBrCtlElementType elType = m_webview->focusedElementType();
 Frame* coreFrame = core(m_webview->mainFrame());
 #ifdef BRDO_TOUCH_ENABLED_FF
 if (m_isHighlighted)
 {
 MTouchFeedback* feedback = MTouchFeedback::Instance();
 if (feedback)
 {
 feedback->InstantFeedback(ETouchFeedbackBasic);
 }
 }
 #endif // BRDO_TOUCH_ENABLED_FF
 if (!IS_NAVIGATION_NONE) {
 m_webview->sendMouseEventToEngine(TPointerEvent::EMove, m_highlightPos, coreFrame);
 }
 /*
 * We assume that if element visibility has been changed
 * between "up" and "down" that means that some node event
 * listener (onMouseOver etc) handling happened and we don't
 * want to send a click (mouse press + mouse release) event.
 * The exception is editable element, since we want VKB anyway
 */
 if (!IS_NAVIGATION_NONE &&
 elType != TBrCtlDefs::EElementActivatedInputBox &&
 elType != TBrCtlDefs::EElementTextAreaBox &&
 m_webview->page()->chrome()->client()->elementVisibilityChangedByMouse()) {
 return;
 }
 m_lastTapEvent.iPosition = m_buttonDownEvent.iPosition;
 m_lastTapEvent.iType = TPointerEvent::EButton1Up;
 m_lastTapEvent.iModifiers = 0;
 // don't pass the event if the text input is not in valid format
 m_isHighlighted = EFalse;
 Frame* frm = m_webview->page()->focusController()->focusedOrMainFrame();
 m_webview->sendMouseEventToEngine(TPointerEvent::EMove, m_highlightPos, frm);
 m_highlightedNode = NULL;
 m_webview->syncRepaint();
 }
 //-----------------------------------------------------------------------------
 // WebPointerEventHandler::canDehighlight
 // WebPointerEventHandler::buttonDownTimerCallback
 //-----------------------------------------------------------------------------
 void WebPointerEventHandler::buttonDownTimerCB(Timer<WebPointerEventHandler>* t)
 {
 m_buttonDownTimer.stop();
 Frame* coreFrame = core(m_webview->mainFrame());
 TPointerEvent event;
 TBrCtlDefs::TBrCtlElementType elType = highlitableElement();
 if (!isHighlitableElement(elType)) {
 elType = TBrCtlDefs::EElementNone;
 }
 m_isHighlighted = (m_highlightedNode != NULL) && (elType != TBrCtlDefs::EElementNone) ;
 /*
 * Tabbed navigation might already set the focused node.
 * If it's the same as m_highlightedNode FocuseController::setFocusedNode()
 * wouldn't do anything and setEditable won't be called.
 * So we are setting focused node to NULL here and let mouse event handler
 * set it through FocuseController::setFocusedNode()
 */
 if (IS_TABBED_NAVIGATION &&
 elType == TBrCtlDefs::EElementInputBox ||
 elType == TBrCtlDefs::EElementTextAreaBox) {
 coreFrame->document()->setFocusedNode(NULL);
 }
 if (!IS_NAVIGATION_NONE) {
 m_webview->page()->chrome()->client()->setElementVisibilityChanged(false);
 //to initiate hover
 if (m_isHighlighted) {
 setFocusRing();
 }
 }
 else {
 m_webview->sendMouseEventToEngine(TPointerEvent::EButton1Down, m_highlightPos, coreFrame);
 }
 if (m_waiter->IsStarted()) {
 m_waiter->AsyncStop();
 }
 }
 cursor->setPosition(pos);
 }
 if (m_webview->showCursor()) {
 cursor->resetTransparency();
 m_webview->setShowCursor(false);
 cursor->cursorUpdate(false);
 }
 }
 }
 //-----------------------------------------------------------------------------
 Element* e = static_cast<Element*>(m_highlightedNode);
 RenderStyle* rs = e->renderStyle();
 RenderStyle* style = new (e->document()->renderArena()) RenderStyle(*rs);
 Color col(0xffaaaaff);
 style->ref();
 style->setOutlineColor(col);
 style->setOutlineStyle(DOTTED, true);
 style->setOutlineWidth(4);
 style->setOutlineOffset(2);
 e->setRenderStyle(style);
 style->deref(e->document()->renderArena());
 e->setChanged();
 }
+//-----------------------------------------------------------------------------
+// WebPointerEventHandler::handlePinchZoom
+//----------------------------------------------------------------------------
+void  WebPointerEventHandler::handlePinchZoomL(const TStmGestureEvent& aGesture)
+{
+//dehighlight anything which is highlighted already
+if (m_isHighlighted){
+dehighlight();
+}
+m_webview->pinchZoomHandler()->handlePinchGestureEventL(aGesture);
+}

changeset 28	d39add9822e2
parent 27	6297cdf66332
child 34	220a17280356