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

equal deleted inserted replaced

-:dd21522fd290
+:7c90e6132015
 }
 // -----------------------------------------------------------------------------
-// CWebKitView::NewL
+// WebView::NewL
 // Public Class Method
 // Two-phased constructor.
 // -----------------------------------------------------------------------------
-WebView* WebView::NewL(
+WebView* WebView::NewL( CCoeControl& parent, CBrCtl* brctl )
-CCoeControl& parent, CBrCtl* brctl )
 {
 WebView* self = new (ELeave) WebView( brctl );
 CleanupStack::PushL( self );
 self->ConstructL( parent );
 return self;
 }
 // -----------------------------------------------------------------------------
-// CWebKitView::CWebKitView
+// WebView::CWebKitView
 // Private Class Method
 // C++ default constructor can NOT contain any code, that might leave.
 // -----------------------------------------------------------------------------
 WebView::WebView( CBrCtl* brctl ) :
 m_brctl(brctl)
 , m_isEditable(false)
 , m_currentEventKey(KNullKeyEvent)
+, m_currentEventCode(EEventNull)
 , m_scrollingSpeed(KNormalScrollRange*KZoomLevelDefaultValue/100)
 , m_focusedElementType(TBrCtlDefs::EElementNone)
 , m_pageScaler(NULL)
 , m_pageScalerEnabled(false)
 , m_inFindState(false)
 delete m_userAgent;
 delete m_pageFullScreenHandler;
 }
 // -----------------------------------------------------------------------------
-// CWebKitView::ConstructL
+// WebView::ConstructL
 // Private Class Method
 // Symbian 2nd phase constructor can leave.
 // -----------------------------------------------------------------------------
-void WebView::ConstructL(
+void WebView::ConstructL( CCoeControl& parent )
-CCoeControl& parent)
 {
 SetContainerWindowL(parent);
 CCoeControl::MakeVisible(ETrue);
 {
 CCoeEnv::Static()->SimulateKeyEventL(m_keyevent, m_eventcode);
 }
 //-------------------------------------------------------------------------------
-// Draw ( from CCoeControl )
+// WebView::Draw ( from CCoeControl )
 // BitBlts the offscreen bitmap to the GraphicsContext
 //-------------------------------------------------------------------------------
-void WebView::Draw(
+void WebView::Draw( const TRect& rect ) const
-const TRect& rect ) const
 {
 if (m_pluginFullscreen) return;
 CWindowGc& gc = SystemGc();
 CEikBorderedControl::Draw( rect );
 return NULL;
 return kit(m_page->mainFrame());
 }
 //-------------------------------------------------------------------------------
-// SyncRepaint
+// WebView::syncRepaint
 // Repaint the given rectangle synchronously
 //-------------------------------------------------------------------------------
-void WebView::syncRepaint(
+void WebView::syncRepaint( const TRect& rect)
-const TRect& rect)
 {
 m_repaints.AddRect( rect );
 syncRepaint();
 }
 rect.Move(-p);
 // draw to back buffer
 if(!(   m_widgetextension && m_widgetextension->IsWidgetPublising())) {
 mainFrame()->frameView()->draw( *m_webcorecontext, rect );
 if ( zoomLevel < m_minZoomLevel ) zoomLevel = m_minZoomLevel;
 zoomLevelChanged( zoomLevel );
 }
 }
 //-------------------------------------------------------------------------------
-// SyncRepaint
+// WebView::syncRepaint
 // Repaint the current repaint region synchronously and clear it
 //-------------------------------------------------------------------------------
 void WebView::syncRepaint()
 {
 if (m_pageScaler && m_pageScaler->FullScreenMode()) {
 static_cast<WebView*>(ptr)->doRepaint();
 return EFalse;
 }
 //-------------------------------------------------------------------------------
-// DoRepaint
+// WebView::doRepaint
 // Perform a scheduled repaint
 //-------------------------------------------------------------------------------
 void WebView::doRepaint()
 {
 // the timer must always be canceled here!
 syncRepaint( );
 }
 }
 //-------------------------------------------------------------------------------
-// CollectOffscreenbitmap
+// WebView::collectOffscreenbitmap
 // Get offscreen bitmap
 //-------------------------------------------------------------------------------
 void WebView::collectOffscreenbitmapL(CFbsBitmap& snapshot)
 {
 (snapshot).Create(m_brctl->Size(), StaticObjectsContainer::instance()->webSurface()->displayMode());
 CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( &snapshot);
 CleanupStack::PushL(device);
 CleanupStack::PopAndDestroy(2);
 }
 //-------------------------------------------------------------------------------
-// ScheduleRepaint
+// WebView::scheduleRepaint
 // Schedule an asynchronous repaint
 //-------------------------------------------------------------------------------
 void WebView::scheduleRepaint(
 const TRect& rect )
 {
 // Draw the miniview
 m_brctl->brCtlLayoutObserver()->NotifyLayoutChange(EOriginTopLeft);
 #endif
 }
 // if we are active, we'll repaint when timer fires
 if( !m_repainttimer->IsActive() && !m_pageZoomHandler->isActive() &&
 m_allowRepaints) {
 // no timer yet, repaint immediatly (but asynchronously)
 m_repainttimer->Start( 0, 0, TCallBack( &doRepaintCb, this ) );
 }
 }
 if ( m_webFormFillPopup && m_webFormFillPopup->IsVisible()) rv = m_webFormFillPopup;
 return rv;
 }
+bool WebView::isNaviKey(const TKeyEvent& keyevent)
+{
+return (    keyevent.iCode == EKeyUpArrow         // North
+|| keyevent.iCode == EKeyRightUpArrow    // Northeast
+|| keyevent.iCode == EStdKeyDevice11     //   : Extra KeyEvent supports diagonal event simulator wedge
+|| keyevent.iCode == EKeyRightArrow      // East
+|| keyevent.iCode == EKeyRightDownArrow  // Southeast
+|| keyevent.iCode == EStdKeyDevice12     //   : Extra KeyEvent supports diagonal event simulator wedge
+|| keyevent.iCode == EKeyDownArrow       // South
+|| keyevent.iCode == EKeyLeftDownArrow   // Southwest
+|| keyevent.iCode == EStdKeyDevice13     //   : Extra KeyEvent supports diagonal event simulator wedge
+|| keyevent.iCode == EKeyLeftArrow       // West
+|| keyevent.iCode == EKeyLeftUpArrow     // Northwest
+|| keyevent.iCode == EStdKeyDevice10);
+}
+bool WebView::handleEditable(const TKeyEvent& keyevent, TEventCode eventcode, Frame* frame )
+{
+bool consumed = false;
+consumed = frame->eventHandler()->keyEvent(PlatformKeyboardEvent(keyevent,eventcode));
+// exit input on up/down key
+// EXCEPT on touch-enabled devices. We'll just consume in that case
+if ( !consumed && isNaviKey(keyevent) ) {
+if (m_webfeptexteditor->validateTextFormat() ) {
+setFocusNone();
+}
+else {
+consumed = true;
+}
+}
+return consumed;
+}
+bool WebView::handleEventKeyDown(const TKeyEvent& keyevent, TEventCode eventcode, Frame* frame)
+{
+m_currentEventKey = keyevent;
+m_currentEventCode = eventcode;
+return false; // not consumed
+}
+void WebView::sendMouseEventToEngine(TPointerEvent::TType eventType, TPoint pos, Frame* frame)
+{
+TPointerEvent event;
+event.iPosition = pos;
+event.iModifiers = 0;
+event.iType = eventType;
+switch (eventType) {
+case TPointerEvent::EButton1Down:
+{
+frame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(event));
+break;
+}
+case TPointerEvent::EButton1Up:
+{
+frame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(event));
+break;
+}
+case TPointerEvent::EMove:
+{
+frame->eventHandler()->handleMouseMoveEvent(PlatformMouseEvent(event));
+break;
+}
+};
+}
+void WebView::setFocusedNode(Frame* frame)
+{
+Node* node = frame->eventHandler()->mousePressNode();
+for (Node* n = node; n; n = n->parentNode()) {
+if ( n->isFocusable() ) {
+page()->focusController()->setFocusedNode(n, frame);
+}
+}
+}
+bool WebView::handleEventKeyL(const TKeyEvent& keyevent, TEventCode eventcode, Frame* frame)
+{
+WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
+bool consumed = false;
+TKeyEvent oldKeyEvent(m_currentEventKey);
+bool downEventConsumed = false;
+if (m_currentEventCode == EEventKeyDown &&
+	keyevent.iCode != EKeyDevice3 ){
+sendKeyEventToEngine(oldKeyEvent, EEventKeyDown, frame);
+}
+m_currentEventKey = keyevent;
+m_currentEventCode = eventcode;
+if (keyevent.iCode == EKeyDevice3) {
+// pass it to webcore
+sendMouseEventToEngine(TPointerEvent::EButton1Down,
+	                        cursor->position(), frame);
+// mimic ccb's behavior of onFocus
+setFocusedNode(frame);
+// Toolbar is activated on long key press only if the element
+// type is EElementNone during EEventKeyDown and EEventKey.
+// This prevents toolbar from popping up in DHTML pages. Also,
+// toolbar is activated when the user is not in fast scroll
+// mode, or in page overview mode, or on wml page.
+if ( ( m_focusedElementType == TBrCtlDefs::EElementNone ||
+m_focusedElementType == TBrCtlDefs::EElementBrokenImage ) &&
+keyevent.iRepeats && !m_brctl->wmlMode() ) {
+launchToolBarL();
+}
+consumed = true;
+}
+else if (isNaviKey(keyevent)) {
+if (m_brctl->settings()->getTabbedNavigation()) {
+consumed = downEventConsumed || handleTabbedNavigation(keyevent, eventcode);
+}
+else {
+consumed = handleKeyNavigation(keyevent, eventcode, frame);
+}
+} // if (m_brctl->settings()->getTabbedNavigation()
+else { // Not an arrow key..
+// activate hovered input element by just start typing
+consumed = handleInputElement(keyevent, eventcode, frame);
+}
+if (!consumed) {
+consumed = sendKeyEventToEngine(keyevent, eventcode, frame);
+}
+return consumed;
+}
+bool WebView::handleInputElement(const TKeyEvent& keyevent, TEventCode eventcode, Frame* frame)
+{
+WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
+if (m_focusedElementType == TBrCtlDefs::EElementInputBox ||
+m_focusedElementType == TBrCtlDefs::EElementSelectBox ||
+m_focusedElementType == TBrCtlDefs::EElementSelectMultiBox ||
+m_focusedElementType == TBrCtlDefs::EElementTextAreaBox) {
+sendMouseEventToEngine(TPointerEvent::EButton1Down, cursor->position(), frame);
+sendMouseEventToEngine(TPointerEvent::EButton1Up, cursor->position(), frame);
+if (m_focusedElementType == TBrCtlDefs::EElementInputBox ||
+m_focusedElementType == TBrCtlDefs::EElementTextAreaBox) {
+if (!m_fepTimer) {
+m_fepTimer = new WebCore::Timer<WebView>(this, &WebView::fepTimerFired);
+}
+m_fepTimer->startOneShot(0.2f);
+setEditable(true);
+}
+m_keyevent = keyevent;
+m_eventcode = eventcode;
+}
+return true;
+}
+bool WebView::handleKeyNavigation(const TKeyEvent& keyevent, TEventCode eventcode, Frame* frame)
+{
+WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
+bool consumed = false;
+bool fastscroll(m_fastScrollTimer->IsActive());
+// start fast scrolling
+m_showCursor = true;
+if (!cursor->isVisible()) {
+cursor->cursorUpdate(true);
+}
+m_savedPosition = mainFrame()->frameView()->contentPos();
+cursor->scrollAndMoveCursor(keyevent.iCode, m_scrollingSpeed, fastscroll);
+updateScrollbars();
+if (!fastscroll) {
+m_fastScrollTimer->Start(KCursorInitialDelay,KCursorUpdateFrquency,TCallBack(&scrollTimerCb,this));
+m_scrollingStartTime.HomeTime();
+}
+// and minimap comes on
+consumed = handleMinimapNavigation();
+if (!fastscroll) {
+sendMouseEventToEngine(TPointerEvent::EMove, cursor->position(), frame);
+}
+consumed = true;
+return consumed;
+}
+bool WebView::handleMinimapNavigation()
+{
+int scrollingTime = millisecondsScrolled();
+if (!AknLayoutUtils::PenEnabled() && m_pageScalerEnabled &&
+m_pageScaler && !isSmallPage() &&
+m_brctl->settings()->brctlSetting(TBrCtlDefs::ESettingsPageOverview) &&
+(scrollingTime > KPanningPageScalerStart || m_pageScaler->Visible())) {
+m_pageScaler->SetVisibleUntil(KScalerVisibilityTime);
+}
+return true;
+}
+bool WebView::handleTabbedNavigation(const TKeyEvent& keyevent, TEventCode eventcode)
+{
+int horizontal = 0;
+int vertical = 0;
+switch(keyevent.iCode) {
+case EKeyUpArrow:             // North
+vertical = -1;
+break;
+case EKeyRightUpArrow:        // Northeast
+case EStdKeyDevice11:         //   : Extra KeyEvent supports diagonal event simulator wedge
+vertical   = -1;
+horizontal = +1;
+break;
+case EKeyRightArrow:          // East
+horizontal = +1;
+break;
+case EKeyRightDownArrow:      // Southeast
+case EStdKeyDevice12:         //   : Extra KeyEvent supports diagonal event simulator wedge
+vertical   = +1;
+horizontal = +1;
+break;
+case EKeyDownArrow:           // South
+vertical   = +1;
+break;
+case EKeyLeftDownArrow:       // Southwest
+case EStdKeyDevice13:         //   : Extra KeyEvent supports diagonal event simulator wedge
+vertical   = +1;
+horizontal = -1;
+break;
+case EKeyLeftArrow:           // West
+horizontal = -1;
+break;
+case EKeyLeftUpArrow:         // Northwest
+case EStdKeyDevice10:         //   : Extra KeyEvent supports diagonal event simulator wedge
+vertical   = -1;
+horizontal = -1;
+break;
+default:                      // (Should never get here)
+break;
+}
+return m_tabbedNavigation->navigate(horizontal, vertical);
+}
+bool WebView::handleEventKeyUp(const TKeyEvent& keyevent, TEventCode eventcode, Frame* frame)
+{
+bool consumed = false;
+TInt delay = 2 * KCursorInitialDelay;
+WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
+m_fastScrollTimer->Cancel();
+m_scrollingSpeed = KNormalScrollRange*100/scalingFactor();
+if (viewIsFastScrolling()) {
+setViewIsFastScrolling(false);
+sendMouseEventToEngine(TPointerEvent::EMove, cursor->position(), frame);
+toggleRepaintTimer(true);
+if (!inPageViewMode()) {
+delay = 0;
+}
+}
+m_pageScrollHandler->scrollbarDrawer()->fadeScrollbar(delay);
+if ( (keyevent.iScanCode == EStdKeyDevice3) ||
+(keyevent.iScanCode == EStdKeyEnter) ) {
+// pass it to webcore
+if (m_focusedElementType == TBrCtlDefs::EElementInputBox ||
+m_focusedElementType == TBrCtlDefs::EElementTextAreaBox) {
+setEditable(true);
+}
+sendMouseEventToEngine(TPointerEvent::EButton1Up, cursor->position(), frame);
+consumed = true;
+}
+if (!consumed) {
+sendKeyEventToEngine(keyevent, eventcode, frame);
+}
+m_currentEventKey = KNullKeyEvent;
+m_currentEventCode = EEventNull;
+return consumed;
+}
+bool WebView::sendKeyEventToEngine(const TKeyEvent& keyevent,
+TEventCode eventcode, Frame* frame)
+{
+bool consumed = frame->eventHandler()->keyEvent(PlatformKeyboardEvent(keyevent,eventcode));
+if (!consumed && eventcode == EEventKey &&
+(m_brctl->capabilities() & TBrCtlDefs::ECapabilityAccessKeys)) {
+TKeyEvent ke = keyevent;
+TChar c(ke.iCode);
+// Not consumed by WebCore, is alphanumeric and does not have any modifier
+if (c.IsAlphaDigit() &&
+!(ke.iModifiers & (EModifierCtrl | EModifierAlt | EModifierShift))) {
+ke.iModifiers = EModifierCtrl;
+frame->eventHandler()->keyEvent(PlatformKeyboardEvent(ke,EEventKeyDown));
+consumed = true;
+}
+}
+return consumed;
+}
 TKeyResponse WebView::OfferKeyEventL(const TKeyEvent& keyevent, TEventCode eventcode )
 {
 WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
 //hijack
 if (isSynchRequestPending()) {
 return m_popupDrawer->handleOfferKeyEventL(keyevent, eventcode );
 if ( m_webFormFillPopup && m_webFormFillPopup->IsVisible() && AknLayoutUtils::PenEnabled() ) {
 	    if (EKeyWasConsumed == m_webFormFillPopup->HandleKeyEventL(keyevent, eventcode)) {
 return EKeyWasConsumed;
-	        }
+	    }
 }
 bool consumed = false;
 Frame* coreFrame = core(mainFrame());
 if (!coreFrame)
 return EKeyWasNotConsumed;
 coreFrame = page()->focusController()->focusedOrMainFrame();
 // edit events
 if (m_isEditable) {
-consumed = page()->focusController()->focusedOrMainFrame()->eventHandler()->keyEvent(PlatformKeyboardEvent(keyevent,eventcode));
+consumed = handleEditable(keyevent, eventcode, coreFrame);
-// exit input on up/down key
-// EXCEPT on touch-enabled devices. We'll just consume in that case
-if ( !consumed
-&& (    keyevent.iCode == EKeyUpArrow         // North
-|| keyevent.iCode == EKeyRightUpArrow    // Northeast
-|| keyevent.iCode == EStdKeyDevice11     //   : Extra KeyEvent supports diagonal event simulator wedge
-|| keyevent.iCode == EKeyRightArrow      // East
-|| keyevent.iCode == EKeyRightDownArrow  // Southeast
-|| keyevent.iCode == EStdKeyDevice12     //   : Extra KeyEvent supports diagonal event simulator wedge
-|| keyevent.iCode == EKeyDownArrow       // South
-|| keyevent.iCode == EKeyLeftDownArrow   // Southwest
-|| keyevent.iCode == EStdKeyDevice13     //   : Extra KeyEvent supports diagonal event simulator wedge
-|| keyevent.iCode == EKeyLeftArrow       // West
-|| keyevent.iCode == EKeyLeftUpArrow     // Northwest
-|| keyevent.iCode == EStdKeyDevice10 ) ) //   : Extra KeyEvent supports diagonal event simulator wedge
-{
-if (m_webfeptexteditor->validateTextFormat() ) {
-setFocusNone();
-} else {
-consumed = true;
-}
-}
 }
 // scroll events
 if (!consumed) {
 switch( eventcode ) {
 case EEventKeyDown:
-m_currentEventKey = keyevent;
+handleEventKeyDown(keyevent, eventcode, coreFrame);
-//page()->mainFrame()->setFocusedNodeIfNeeded();
-//coreFrame->eventHandler()->mousePressNode()->focus();
 break;
 case EEventKey:
 if (keyevent.iScanCode != m_currentEventKey.iScanCode ) return EKeyWasNotConsumed;
-//
+consumed = handleEventKeyL(keyevent, eventcode, coreFrame);
-m_currentEventKey = keyevent;
-if (keyevent.iCode == EKeyDevice3) {
-// pass it to webcore
-TPointerEvent event;
-event.iPosition = StaticObjectsContainer::instance()->webCursor()->position();
-event.iModifiers = 0;
-event.iType = TPointerEvent::EButton1Down ;
-coreFrame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(event));
-// mimic ccb's behavior of onFocus
-Node* node = page()->focusController()->focusedOrMainFrame()->eventHandler()->mousePressNode();
-for (Node* n = node; n; n = n->parentNode()) {
-if ( n->isFocusable() ) {
-page()->focusController()->setFocusedNode(n, page()->focusController()->focusedOrMainFrame());
-}
-}
-// Toolbar is activated on long key press only if the element
-// type is EElementNone during EEventKeyDown and EEventKey.
-// This prevents toolbar from popping up in DHTML pages. Also,
-// toolbar is activated when the user is not in fast scroll
-// mode, or in page overview mode, or on wml page.
-if ( ( m_focusedElementType == TBrCtlDefs::EElementNone ||
-m_focusedElementType == TBrCtlDefs::EElementBrokenImage ) &&
-keyevent.iRepeats && !m_brctl->wmlMode() )
-{
-launchToolBarL();
-}
-consumed = true;
-} else if (    keyevent.iCode == EKeyUpArrow              // North
-|| keyevent.iCode == EKeyRightUpArrow         // Northeast
-|| keyevent.iCode == EStdKeyDevice11          //   : Extra KeyEvent supports diagonal event simulator wedge
-|| keyevent.iCode == EKeyRightArrow           // East
-|| keyevent.iCode == EKeyRightDownArrow       // Southeast
-|| keyevent.iCode == EStdKeyDevice12          //   : Extra KeyEvent supports diagonal event simulator wedge
-|| keyevent.iCode == EKeyDownArrow            // South
-|| keyevent.iCode == EKeyLeftDownArrow        // Southwest
-|| keyevent.iCode == EStdKeyDevice13          //   : Extra KeyEvent supports diagonal event simulator wedge
-|| keyevent.iCode == EKeyLeftArrow            // West
-|| keyevent.iCode == EKeyLeftUpArrow          // Northwest
-|| keyevent.iCode == EStdKeyDevice10 )        //   : Extra KeyEvent supports diagonal event simulator wedge
-{
-if (m_brctl->settings()->getTabbedNavigation()) {
-int horizontal = 0;
-int vertical = 0;
-switch(keyevent.iCode)
-{
-case EKeyUpArrow:             // North
-vertical = -1;
-break;
-case EKeyRightUpArrow:        // Northeast
-case EStdKeyDevice11:         //   : Extra KeyEvent supports diagonal event simulator wedge
-vertical   = -1;
-horizontal = +1;
-break;
-case EKeyRightArrow:          // East
-horizontal = +1;
-break;
-case EKeyRightDownArrow:      // Southeast
-case EStdKeyDevice12:         //   : Extra KeyEvent supports diagonal event simulator wedge
-vertical   = +1;
-horizontal = +1;
-break;
-case EKeyDownArrow:           // South
-vertical   = +1;
-break;
-case EKeyLeftDownArrow:       // Southwest
-case EStdKeyDevice13:         //   : Extra KeyEvent supports diagonal event simulator wedge
-vertical   = +1;
-horizontal = -1;
-break;
-case EKeyLeftArrow:           // West
-horizontal = -1;
-break;
-case EKeyLeftUpArrow:         // Northwest
-case EStdKeyDevice10:         //   : Extra KeyEvent supports diagonal event simulator wedge
-vertical   = -1;
-horizontal = -1;
-break;
-default:                      // (Should never get here)
-break;
-}
-	consumed = m_tabbedNavigation->navigate(horizontal, vertical);
-}
-else {
-// start fast scrolling
-					m_showCursor = true;
-if (!cursor->isVisible()) {
-cursor->cursorUpdate(true);
-}
-bool fastscroll(m_fastScrollTimer->IsActive());
-m_savedPosition = mainFrame()->frameView()->contentPos();
-cursor->scrollAndMoveCursor(keyevent.iCode, m_scrollingSpeed, fastscroll);
-if (!fastscroll) {
-m_fastScrollTimer->Start(KCursorInitialDelay,KCursorUpdateFrquency,TCallBack(&scrollTimerCb,this));
-m_scrollingStartTime.HomeTime();
-}
-// and minimap comes on
-int scrollingTime = millisecondsScrolled();
-if (!AknLayoutUtils::PenEnabled() && m_pageScalerEnabled && m_pageScaler && !isSmallPage() &&
-m_brctl->settings()->brctlSetting(TBrCtlDefs::ESettingsPageOverview) &&
-(scrollingTime > KPanningPageScalerStart || m_pageScaler->Visible())) {
-m_pageScaler->SetVisibleUntil(KScalerVisibilityTime);
-					}
-//
-if (!fastscroll) {
-TPointerEvent event;
-event.iPosition = cursor->position();
-event.iModifiers = 0;
-event.iType = TPointerEvent::EMove;
-coreFrame->eventHandler()->handleMouseMoveEvent(PlatformMouseEvent(event));
-}
-consumed = true;
-} // if (m_brctl->settings()->getTabbedNavigation()
-} else {
-// activate hovered input element by just start typing
-if (m_focusedElementType == TBrCtlDefs::EElementInputBox || m_focusedElementType == TBrCtlDefs::EElementSelectBox
-|| m_focusedElementType == TBrCtlDefs::EElementSelectMultiBox || m_focusedElementType == TBrCtlDefs::EElementTextAreaBox) {
-TPointerEvent event;
-event.iModifiers = 0;
-event.iPosition = cursor->position();
-event.iType = TPointerEvent::EButton1Down ;
-coreFrame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(event));
-event.iType = TPointerEvent::EButton1Up;
-coreFrame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(event));
-if (m_focusedElementType == TBrCtlDefs::EElementInputBox || m_focusedElementType == TBrCtlDefs::EElementTextAreaBox) {
-if (!m_fepTimer)
-m_fepTimer = new WebCore::Timer<WebView>(this, &WebView::fepTimerFired);
-m_fepTimer->startOneShot(0.2f);
-setEditable(true);
-}
-m_keyevent = keyevent;
-m_eventcode = eventcode;
-consumed = true;
-}
-}
 break;
 case EEventKeyUp:
-m_fastScrollTimer->Cancel();
+consumed = handleEventKeyUp(keyevent, eventcode, coreFrame);
-m_scrollingSpeed = KNormalScrollRange*100/scalingFactor();
-if (viewIsFastScrolling()) {
-	      setViewIsFastScrolling(false);
-toggleRepaintTimer(true);
-if (AknLayoutUtils::PenEnabled() && !inPageViewMode()) {
-m_pageScrollHandler->scrollbarDrawer()->fadeScrollbar();
-}
-}
-m_currentEventKey = KNullKeyEvent;
-if ( (keyevent.iScanCode == EStdKeyDevice3) || (keyevent.iScanCode == EStdKeyEnter) ){
-// pass it to webcore
-TPointerEvent event;
-if (m_focusedElementType == TBrCtlDefs::EElementInputBox ||
-m_focusedElementType == TBrCtlDefs::EElementTextAreaBox)
-{
-setEditable(true);
-}
-event.iPosition = cursor->position();
-event.iType = TPointerEvent::EButton1Up;
-coreFrame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(event));
-consumed = true;
-}
 break;
 }
 }
-// keyevents
+return (consumed) ? EKeyWasConsumed : EKeyWasNotConsumed;
-if (!consumed) {
-consumed = coreFrame->eventHandler()->keyEvent(PlatformKeyboardEvent(keyevent,eventcode));
-if (!consumed && eventcode == EEventKey && (m_brctl->capabilities() & TBrCtlDefs::ECapabilityAccessKeys)) {
-TKeyEvent ke = keyevent;
-TChar c(ke.iCode);
-// Not consumed by WebCore, is alphanumeric and does not have any modifier
-if (c.IsAlphaDigit() && !(ke.iModifiers & (EModifierCtrl | EModifierAlt | EModifierShift))) {
-ke.iModifiers = EModifierCtrl;
-coreFrame->eventHandler()->keyEvent(PlatformKeyboardEvent(ke,EEventKeyDown));
-consumed = true;
-}
-}
-}
-//setEditable();
-return (consumed)?EKeyWasConsumed:EKeyWasNotConsumed;
 }
 void WebView::updateScrollbars(int documentHeight, int displayPosY, int documentWidth, int displayPosX)
 {
 m_brctl->updateScrollbars((documentHeight * scalingFactor()) / 100, Rect().Height(),
 (displayPosY * scalingFactor()) / 100, (documentWidth * scalingFactor()) / 100, Rect().Width(),
 (displayPosX * scalingFactor()) / 100);
+}
+void WebView::updateScrollbars()
+{
+TPoint scrollDelta = mainFrame()->frameView()->contentPos() - m_savedPosition;
+scrollDelta.iX *= 100;
+scrollDelta.iY *= 100;
+if (!inPageViewMode()) {
+if (scrollDelta.iX == 0 && scrollDelta.iY == 0) {
+m_pageScrollHandler->scrollbarDrawer()->drawScrollbar(this);
+}
+else {
+m_pageScrollHandler->scrollbarDrawer()->drawScrollbar(this, scrollDelta);
+}
+}
 }
 void WebView::openPageViewL()
 {
 // don't show pageview if we are in lite mode
 closePageView();
 }
 }
 //-------------------------------------------------------------------------------
-// launchToolBarL
+// WebView::launchToolBarL
 //-------------------------------------------------------------------------------
 void WebView::launchToolBarL()
 {
 if ( AknLayoutUtils::PenEnabled() || m_brctl->wmlMode() ) {
 return;
 m_brctl->reportStateChanged(TBrCtlDefs::EStateToolBarMode, ETrue);
 }
 //-------------------------------------------------------------------------------
-// closeToolBarL
+// WebView::closeToolBarL
 //-------------------------------------------------------------------------------
 void WebView::closeToolBarL()
 {
 delete m_toolbar;
 m_toolbar = 0;
 m_brctl->reportStateChanged(TBrCtlDefs::EStateToolBarMode, EFalse);
 }
 //-------------------------------------------------------------------------------
-// DrawDocumentPart ( from MPageScalerCallback )
+// WebView::DrawDocumentPart ( from MPageScalerCallback )
 //
 //
 //-------------------------------------------------------------------------------
 void WebView::DrawDocumentPart(
 CFbsBitGc& aGc,
 delete wcgc;
 }
 }
 //-------------------------------------------------------------------------------
-// DocumentViewport ( from MPageScalerCallback )
+// WebView::DocumentViewport ( from MPageScalerCallback )
 //
 //
 //-------------------------------------------------------------------------------
 TRect WebView::DocumentViewport()
 {
 return mainFrame()->frameView()->toViewCoords(mainFrame()->frameView()->visibleRect());
 }
 //-------------------------------------------------------------------------------
-// ScaledPageChanged ( from MPageScalerCallback )
+// WebView::ScaledPageChanged ( from MPageScalerCallback )
 //
 //
 //-------------------------------------------------------------------------------
 void WebView::ScaledPageChanged(
 const TRect& aRect,
 // ignore err since we will use the default image
 }
 }
 //-------------------------------------------------------------------------------
-// DocumentSize ( from MPageScalerCallback )
+// WebView::DocumentSize ( from MPageScalerCallback )
 //
 //
 //-------------------------------------------------------------------------------
 TSize WebView::DocumentSize()
 {
 return mainFrame()->frameView()->toViewCoords(mainFrame()->frameView()->contentSize());
 }
 //-------------------------------------------------------------------------------
-// TouchScrolling ( from MPageScalerCallback )
+// WebView::TouchScrolling ( from MPageScalerCallback )
 //
 //
 //-------------------------------------------------------------------------------
 TBool WebView::TouchScrolling()
 {
 int milli = millisecondsScrolled();
 setViewIsFastScrolling(true);
 toggleRepaintTimer(false);
 m_scrollingSpeed = milli>=KPanningMaxTime ? KPanningMaxSpeed : KPanningStartSpeed+(KPanningMaxSpeed-KPanningStartSpeed)*Max(milli-KPanningStartTime,0)/KPanningMaxTime;
 m_scrollingSpeed = m_scrollingSpeed*100/scalingFactor();
-TPoint scrollDelta = mainFrame()->frameView()->contentPos() - m_savedPosition;
-scrollDelta.iX *= 100;
-scrollDelta.iY *= 100;
-if (AknLayoutUtils::PenEnabled() && !inPageViewMode()) {
-m_pageScrollHandler->scrollbarDrawer()->drawScrollbar(this, scrollDelta);
-}
 OfferKeyEventL(m_currentEventKey, EEventKey);
 }
 int WebView::millisecondsScrolled() const
 {
 int WebView::searchAgain(bool forward)
 {
 if (!m_findKeyword) {
 WebFrame* frame = mainFrame()->findFrameWithSelection();
-if(frame) {
+if (frame) {
-			frame->clearSelection();
+frame->clearSelection();
 }
 return TBrCtlDefs::EFindNoMatches;
 }
 return search(*m_findKeyword, forward, true);
 }
 if (frame != startFrame)
 startFrame->clearSelection();
 return TBrCtlDefs::EFindMatch;
 }
 if (onlyOneFrame) {
-			startFrame->clearSelection();
+startFrame->clearSelection();
 return TBrCtlDefs::EFindNoMatches;
 }
 frame = nextFrame;
 } while (frame && frame != startFrame);
 if (wrapFlag && lastFrame) {
 if (frame->bridge()->searchFor(keyword, forward, false, true, false))
 return TBrCtlDefs::EFindMatch;
 }
-	if(frame) {
+if (frame) {
-		frame->clearSelection();
+frame->clearSelection();
-	}
+}
 return TBrCtlDefs::EFindNoMatches;
 }
 void WebView::exitFindState()
 {
 }
 }
 //-------------------------------------------------------------------------------
-// HandlePointerBufferReadyL
+// WebView::HandlePointerBufferReadyL
-// Handles Pointer Move Events
+// Handles pointer move events
 //-------------------------------------------------------------------------------
 void WebView::HandlePointerBufferReadyL()
 {
 memset(m_ptrbuffer,0,256*sizeof(TPoint));
 TPtr8 ptr((TUint8 *)m_ptrbuffer,256*sizeof(TPoint));
 m_webpointerEventHandler->HandlePointerEventL(pe);
 }
 }
 //-------------------------------------------------------------------------------
-// HandlePointerEventL
+// WebView::HandlePointerEventL
-// Handles Pointer Events
+// Handles pointer events
 //-------------------------------------------------------------------------------
 void WebView::HandlePointerEventL(const TPointerEvent& aPointerEvent)
 {
 m_webpointerEventHandler->HandlePointerEventL(aPointerEvent);
 }
 }
 }
 }
 //-------------------------------------------------------------------------------
-// HandleShowAnchorHref()
+// WebView::handleShowAnchorHrefL
 // Display a popup with the url of an anchor
 //-------------------------------------------------------------------------------
 void WebView::handleShowAnchorHrefL()
 {
 HBufC* url = NULL;
 CleanupStack::PopAndDestroy(); // url
 }
 //-------------------------------------------------------------------------------
-// FocusedImageLC()
+// WebView::focusedImageLC
 // Return the image that is under the cursor
 //-------------------------------------------------------------------------------
 TBrCtlImageCarrier* WebView::focusedImageLC()
 {
 if (m_focusedElementType != TBrCtlDefs::EElementImageBox && m_focusedElementType != TBrCtlDefs::EElementAreaBox) {
 CleanupStack::PushL(imageCarrier);
 return imageCarrier;
 }
 //-------------------------------------------------------------------------------
-// LoadFocusedImageL()
+// WebView::loadFocusedImageL
 // Load the image that is under the cursor
 //-------------------------------------------------------------------------------
 void WebView::loadFocusedImageL()
 {
 // Ensure cursor is on a broken image and image loading is disabled
 }
 loadFocusedImage(this);
 }
 //-------------------------------------------------------------------------------
-// RemovePopup()
+// WebView::removePopup
 // Delete the popupDrawer
 //-------------------------------------------------------------------------------
 void WebView::removePopup()
 {
 if (m_popupDrawer) {
 DrawNow();
 }
 }
 //-------------------------------------------------------------------------------
+// WebView::zoomLevels
 //-------------------------------------------------------------------------------
 RArray<TUint>* WebView::zoomLevels()
 {
 return &m_zoomLevelArray;
 }
 //-------------------------------------------------------------------------------
+// WebView::setZoomLevel
 //-------------------------------------------------------------------------------
 void WebView::setZoomLevel(int zoomLevel)
 {
 m_dirtyZoomMode = false;
 if (zoomLevel < KZoomLevelMinValue ||
 return;
 zoomLevelChanged(zoomLevel);
 }
 //-------------------------------------------------------------------------------
+// WebView::setBitmapZoomLevel
 //-------------------------------------------------------------------------------
 void WebView::setBitmapZoomLevel(int zoomLevel)
 {
 m_zoomLevelChangedByUser = true;
 WebFrameView* view = mainFrame()->frameView();
 DrawNow();
 }
 //-------------------------------------------------------------------------------
+// WebView::restoreZoomLevel
 //-------------------------------------------------------------------------------
 void WebView::restoreZoomLevel(int zoomLevel)
 {
 m_dirtyZoomMode = false;
 clearOffScreenBitmap();
 mainFrame()->makeVisiblePlugins(true);
 m_isPluginsVisible = true;
 }
 //-------------------------------------------------------------------------------
+// WebView::resetZoomLevel
 //-------------------------------------------------------------------------------
 void WebView::resetZoomLevel(void)
 {
 if(   m_widgetextension && m_widgetextension->IsWidgetPublising()) {
 return ;
 mainFrame()->frameView()->setRect(mainFrame()->frameView()->toDocCoords(Rect()));
 m_startZoomLevel = m_currentZoomLevel;
 }
 //-------------------------------------------------------------------------------
+// WebView::updateMinZoomLevel
 //-------------------------------------------------------------------------------
 void WebView::updateMinZoomLevel(TSize size)
 {
 int newMinZoomLevel;
 if (size.iWidth && size.iHeight) {
 }
 } //endof if (m_minZoomLevel != newMinZoomLevel)
 }
 //-------------------------------------------------------------------------------
+// WebView::UpdateZoomArray
 //-------------------------------------------------------------------------------
 void WebView::UpdateZoomArray()
 {
 //only for non-touch device
 if (m_pageZoomHandler->isActive())
 }
 }
 //-------------------------------------------------------------------------------
+// WebView::zoomLevelChanged
 //-------------------------------------------------------------------------------
 void WebView::zoomLevelChanged(int newZoomLevel)
 {
 int currZoomLevel = m_startZoomLevel;
 m_dirtyZoomMode = false;
 int zoomLevel = m_brctl->historyHandler()->historyController()->currentEntryZoomLevel();
 if (zoomLevel != m_currentZoomLevel) m_brctl->historyHandler()->historyController()->updateCurrentEntryZoomLevelIfNeeded();
 }
 //-------------------------------------------------------------------------------
+// WebView:::resetLastZoomLevelIfNeeded
 //-------------------------------------------------------------------------------
 void WebView::resetLastZoomLevelIfNeeded()
 {
 if (m_lastZoomLevel == m_maxZoomLevel)
 m_lastZoomLevel = 100;
 }
 //-----------------------------------------------------------------------------
-// setZoomLevelAdaptively()
+// WebView::setZoomLevelAdaptively()
 //-----------------------------------------------------------------------------
 void WebView::setZoomLevelAdaptively()
 {
 int zoomLevel = KZoomLevelDefaultValue;
 // Double Tap Zooming: it toggles between default, maxiZoomLevel.
 // Depending on the current zoom level:
 //   A. If the current is already the max, it zooms to the max
 //   B. If the current is bigger than/equal to the default zoom level zooms to the default, it zooms to the max
 //   C. Otherwise it zooms to the default level first.
 // For the mobile pages, such as google.com and cnn.com, minimum zoom level equals
 // to the default zoom level. Zooming is only possible between default and maximum
 // zoom level, double tap only won't reach logic C
 //
 // For both mobile and non-mobile pages, it creates the same end user double tap
 // experiences
 if (m_currentZoomLevel == m_maxZoomLevel ) {
 zoomLevel = KZoomLevelDefaultValue;
 }
 else if (m_currentZoomLevel >= KZoomLevelDefaultValue ) {
 zoomLevel = m_maxZoomLevel;
 }
 else {
 zoomLevel = KZoomLevelDefaultValue;
 }
 // move the content
 WebFrameView* view = mainFrame()->frameView();
 if (!view) return;
 WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
 setZoomLevel(zoomLevel);
 mainFrame()->notifyPluginsOfScrolling();
 }
 //-------------------------------------------------------------------------------
+// WebView::openPluginPlayer
 // Called when user clicks a plugin which is able to accept user input,
 // this feature is only used in US build
 //-------------------------------------------------------------------------------
 void WebView::openPluginPlayer(PluginWin* plugin)
 {
 void WebView::setFocusNone()
 {
 page()->focusController()->setFocusedNode(NULL, page()->focusController()->focusedOrMainFrame());
 }
 //-------------------------------------------------------------------------------
+// WebView::closePluginPlayer
 //-------------------------------------------------------------------------------
 void WebView::closePluginPlayer()
 {
 // stop playing
 m_pluginplayer->stop();
 // redraw the control
 m_brctl->DrawNow();
 }
 //-------------------------------------------------------------------------------
+// WebView::createWidgetExtension
 //-------------------------------------------------------------------------------
 CWidgetExtension* WebView::createWidgetExtension(MWidgetCallback &aWidgetCallback)
 {
 if (!m_widgetextension) {
 m_widgetextension = CWidgetExtension::NewL(*this, aWidgetCallback);
 return m_widgetextension;
 }
 //-------------------------------------------------------------------------------
+// WebView::forceLayoutAndResize
 //-------------------------------------------------------------------------------
 void WebView::forceLayoutAndResize(WebFrame* frame)
 {
 if (frame) {
 Frame* f = core(frame);
 }
 }
 }
 //-------------------------------------------------------------------------------
+// WebView::showZoomSliderL
 //-------------------------------------------------------------------------------
 void WebView::showZoomSliderL()
 {
 if ( !inPageViewMode()) {
 m_pageZoomHandler->showZoomSliderL();
 }
 m_startZoomLevel = m_currentZoomLevel;
 }
 //-------------------------------------------------------------------------------
+// WebView::hideZoomSliderL
 //-------------------------------------------------------------------------------
 void WebView::hideZoomSliderL()
 {
 if ( !inPageViewMode()) {
 m_pageZoomHandler->hideZoomSliderL();
 }
 }
 //-------------------------------------------------------------------------------
+// WebView::notifyZoomSliderModeChangeL
 //-------------------------------------------------------------------------------
 void WebView::notifyZoomSliderModeChangeL( bool mode )
 {
 m_dirtyZoomMode = false;
 clearOffScreenBitmap();
 zoomLevelChanged( m_currentZoomLevel );
 m_brctl->reportStateChanged(TBrCtlDefs::EStateZoomSliderMode, mode );
 }
 //-------------------------------------------------------------------------------
+// WebView::maxZoomLevel
 //-------------------------------------------------------------------------------
 int WebView::maxZoomLevel()
 {
 return m_maxZoomLevel;
 }
 //-------------------------------------------------------------------------------
+// WebView::minZoomLevel
 //-------------------------------------------------------------------------------
 int WebView::minZoomLevel()
 {
 return m_minZoomLevel;
 }
 //-------------------------------------------------------------------------------
+// WebView::updateZoomLevel
 //-------------------------------------------------------------------------------
 void WebView::updateZoomLevel( TBrCtlDefs::TBrCtlSettings setting, unsigned int value)
 {
 switch( setting ) {
 case TBrCtlDefs::ESettingsZoomLevelMax:
 break;   // should not occur
 }
 }
 //-------------------------------------------------------------------------------
+// WebView::EnterFullscreenBrowsingL
 //-------------------------------------------------------------------------------
 void WebView::EnterFullscreenBrowsingL()
 {
 if (m_pageFullScreenHandler) {
 m_pageFullScreenHandler->showEscBtnL();
 StaticObjectsContainer::instance()->setFullScreenMode(true);
 }
 }
 //-------------------------------------------------------------------------------
+// WebView::LeaveFullscreenBrowsingL
 //-------------------------------------------------------------------------------
 void WebView::LeaveFullscreenBrowsingL()
 {
 if (m_pageFullScreenHandler) {
 m_pageFullScreenHandler->hideEscBtnL();
 StaticObjectsContainer::instance()->setFullScreenMode(false);
 }
 }
 //-------------------------------------------------------------------------------
+// WebView::notifyFullscreenModeChangeL
 //-------------------------------------------------------------------------------
 void WebView::notifyFullscreenModeChangeL(bool mode)
 {
 if (m_pageFullScreenHandler )
 m_brctl->reportStateChanged(TBrCtlDefs::EStateFullscreenBrowsing, mode );
 }
 //-------------------------------------------------------------------------------
+// WebView::checkForZoomChange
 //-------------------------------------------------------------------------------
 void WebView::checkForZoomChange()
 {
 zoomLevelChanged(m_currentZoomLevel);
 }
 }
 void WebView::setRedirectWithLockedHistory(bool value) {
 m_redirectWithLockedHistory = value;
 }
 //-------------------------------------------------------------------------------
+// WebView::notifyPlugins
 // Webview notifies plugins to handle play/pause of .swf files when user switches to menu/another application
 //-------------------------------------------------------------------------------
 void WebView::notifyPlugins(TBool focus)
 {
 Frame* coreFrame =core(mainFrame());
 m_allowRepaints = on;
 }
 //-----------------------------------------------------------------------------
-// setZoomCursorPosition(TBool)
+// WebView::setZoomCursorPosition
 // Set the cursor position while zooming, this is only for non-touch device
 //-----------------------------------------------------------------------------
 void WebView::setZoomCursorPosition(TBool isZoomIn)
 {
 int zoomLevel = m_currentZoomLevel;
 mainFrame()->notifyPluginsOfScrolling();
 }
 // ---------------------------------------------------------------------------
-// FindCurrentZoomIndex
+// WebView::FindCurrentZoomIndex
 // ---------------------------------------------------------------------------
 TInt WebView::FindCurrentZoomIndex(TInt aCurrentZoomLevel)
 {
 TInt aIndex = -1;
 TInt WebView::getWidgetId()
 {
 return m_widgetextension ? m_widgetextension->GetWidgetId():0;
 }
 void WebView::setShowCursor(TBool showCursor)
 {
 m_showCursor = showCursor;
 StaticObjectsContainer::instance()->webCursor()->setCursorVisible(showCursor);
 }

changeset 1	7c90e6132015
parent 0	dd21522fd290
child 5	10e98eab6f85