Do not notify editor state during executing command

[framework/web/webkit-efl.git] / Source / WebKit2 / WebProcess / WebPage / efl / WebPageEfl.cpp

diff --git a/Source/WebKit2/WebProcess/WebPage/efl/WebPageEfl.cpp b/Source/WebKit2/WebProcess/WebPage/efl/WebPageEfl.cpp
index 42798d2..4900176 100755 (executable)
--- a/Source/WebKit2/WebProcess/WebPage/efl/WebPageEfl.cpp
+++ b/Source/WebKit2/WebProcess/WebPage/efl/WebPageEfl.cpp
@@ -339,17 +339,23 @@ void WebPage::setComposition(const String& compositionString, const Vector<WebCo
                             newUnderlines.last().endOffset = availableLength;
                     }
                 }
+
+                m_page->editorClient()->lockRespondToChangedSelection();
                 targetFrame->editor()->setComposition(newCompositionString, newUnderlines, cursorPosition, 0);
+                m_page->editorClient()->unlockRespondToChangedSelection();
+
                 return;
             }
         }
     }
+
+    m_page->editorClient()->lockRespondToChangedSelection();
 #endif
 
     targetFrame->editor()->setComposition(compositionString, underlines, cursorPosition, 0);
 
 #if ENABLE(TIZEN_ISF_PORT)
-    m_page->editorClient()->respondToChangedSelection(targetFrame);
+    m_page->editorClient()->unlockRespondToChangedSelection();
 #endif
 }
 
@@ -661,7 +667,6 @@ void WebPage::didCancelComposition(Node* valueChangedNode)
 void WebPage::prepareKeyDownEvent()
 {
     m_prepareKeyDownEvent = true;
-    m_keyPressCommands.clear();
 }
 
 void WebPage::swapKeyPressCommands(Vector<OwnPtr<KeyPressCommand> >& commands)
@@ -698,7 +703,9 @@ void WebPage::updateEditorStateRect(const Frame* frame, EditorState& state) cons
     ASSERT(frame->selection()->rootEditableElement());
 
 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
-    state.editorRect = nodeRect(frame->selection()->rootEditableElement());
+    Vector<IntRect> rects;
+    calcFocusedRects(frame->selection()->rootEditableElement(), rects);
+    state.editorRect = unionRect(rects);
 #endif
 
     if (frame->selection()->isCaret())
@@ -869,16 +876,17 @@ static bool isClickableOrFocusable(Node* focusableNode)
 }
 
 #if ENABLE(TOUCH_ADJUSTMENT)
-static IntRect getFocusedRect(HitTestResult hitTestResult, Page* page, const IntPoint& point, const IntSize& area)
+void WebPage::getFocusedRect(HitTestResult hitTestResult, Page* page, bool setFocus, Vector<IntRect>& rects, const IntPoint& point, const IntSize& area)
 #else
-static IntRect getFocusedRect(HitTestResult hitTestResult, Page* page)
+void WebPage::getFocusedRect(HitTestResult hitTestResult, Page* page, bool setFocus, Vector<IntRect>& rects)
 #endif
 {
     Node* node = hitTestResult.innerNode();
 #if ENABLE(TOUCH_ADJUSTMENT)
-    Node* adjustedNode = 0;
     IntPoint adustedPoint;
     Frame* mainFrame = page->mainFrame();
+    Node* adjustedNode = 0;
+    mainFrame->eventHandler()->bestClickableNodeForTouchPoint(point, IntSize(area.width() / 2, area.height() / 2), adustedPoint, adjustedNode);
     if (!isClickableOrFocusable(node))
         mainFrame->eventHandler()->bestClickableNodeForTouchPoint(point, IntSize(area.width() / 2, area.height() / 2), adustedPoint, adjustedNode);
 
@@ -886,7 +894,7 @@ static IntRect getFocusedRect(HitTestResult hitTestResult, Page* page)
         node = adjustedNode;
 #endif
     if (!node)
-        return IntRect();
+        return;
 
     bool isFocusRingDrawable = false;
     Node* focusableNode = node;
@@ -911,20 +919,22 @@ static IntRect getFocusedRect(HitTestResult hitTestResult, Page* page)
                 || child->hasEventListeners(eventNames().clickEvent)
                 || child->hasEventListeners(eventNames().mousedownEvent)
                 || child->hasEventListeners(eventNames().mouseupEvent)) {
-                return IntRect();
+                return;
             }
             child = child->traverseNextNode(focusableNode);
         }
     }
 
     if (!isFocusRingDrawable) {
-        if (node->hasTagName(HTMLNames::imgTag))
-            return getNodeRect(node, node, !hitTestResult.absoluteImageURL().isEmpty());
-
-        return IntRect();
+        if (!node->hasTagName(HTMLNames::imgTag))
+            return;
+        focusableNode = node;
     }
 
-    return getNodeRect(node, focusableNode, !hitTestResult.absoluteImageURL().isEmpty());
+    if (setFocus)
+        setFocusedNode(focusableNode);
+
+    calcFocusedRects(focusableNode, rects);
 }
 #endif
 
@@ -969,17 +979,19 @@ void WebPage::hitTestResultAtPoint(const IntPoint& point, int hitTestMode, WebHi
     hitTestResultData.hitTestMode = hitTestMode;
 
 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
+    bool setFocus = hitTestResultData.hitTestMode & WebHitTestResult::HitTestModeSetFocus;
 #if ENABLE(TOUCH_ADJUSTMENT)
-    hitTestResultData.focusedRect = getFocusedRect(hitTestResult, m_page.get(), point, area);
+    getFocusedRect(hitTestResult, m_page.get(), setFocus, hitTestResultData.focusedRects, point, area);
 #else
-    hitTestResultData.focusedRect = getFocusedRect(hitTestResult, m_page.get());
+    getFocusedRect(hitTestResult, m_page.get(), setFocus, hitTestResultData.focusedRects);
 #endif
 
     // Don't display FocusRect if the size is too big..
     IntRect framerect = frameView->visibleContentRect(true);
-    if (hitTestResultData.focusedRect.width() > (0.8 * framerect.width())
-        && hitTestResultData.focusedRect.height() > (0.8 * framerect.height())) {
-        hitTestResultData.focusedRect = IntRect();
+    for (size_t i = 0; i < hitTestResultData.focusedRects.size(); ++i) {
+        if (hitTestResultData.focusedRects[i].width() > (0.8 * framerect.width())
+            && hitTestResultData.focusedRects[i].height() > (0.8 * framerect.height()))
+            hitTestResultData.focusedRects.clear();
     }
 
     if (hitTestResult.innerNode() && hitTestResult.innerNode()->renderer() && hitTestResult.innerNode()->renderer()->style()) {
@@ -1511,7 +1523,9 @@ void WebPage::getSelectionHandlers(IntRect& leftRect, IntRect& rightRect)
         if (size == 1) {
             Element* rootEditableElement = focusedFrame->selection()->rootEditableElement();
             if (rootEditableElement) {
-                IntRect editorRect = nodeRect(rootEditableElement);
+                Vector<IntRect> rects;
+                calcFocusedRects(rootEditableElement, rects);
+                IntRect editorRect = unionRect(rects);
 
 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
                 if (m_editorState.editorRect != editorRect) {
@@ -1662,7 +1676,6 @@ void WebPage::moveScreenReaderFocus(bool forward, bool& result)
         m_screenReader = ScreenReader::create(this);
 
     result = m_screenReader->moveFocus(forward);
-    didChangeFocusedRect(m_screenReader->getFocusedNode());
 }
 
 void WebPage::moveScreenReaderFocusByPoint(const IntPoint& point)
@@ -1672,8 +1685,6 @@ void WebPage::moveScreenReaderFocusByPoint(const IntPoint& point)
 
     if (!m_screenReader->moveFocus(point))
         return;
-
-    didChangeFocusedRect(m_screenReader->getFocusedNode());
 }
 
 void WebPage::clearScreenReaderFocus()
@@ -1714,22 +1725,14 @@ void WebPage::raiseTapEvent(const IntPoint& position, const IntPoint& globalPosi
 
 void WebPage::adjustScreenReaderFocusedObjectValue(bool up)
 {
-    if (!m_screenReader || !m_screenReader->getFocusedNode() || !m_screenReader->getFocusedNode()->toInputElement())
+    if (!m_screenReader || !m_focusedNode || !m_focusedNode->toInputElement())
         return;
 
     ExceptionCode ec;
     if (up)
-        m_screenReader->getFocusedNode()->toInputElement()->stepUp(ec);
+        m_focusedNode->toInputElement()->stepUp(ec);
     else
-        m_screenReader->getFocusedNode()->toInputElement()->stepDown(ec);
-}
-
-void WebPage::recalcScreenReaderFocusRect()
-{
-    if (!m_screenReader || !m_screenReader->getFocusedNode())
-        return;
-
-    didChangeFocusedRect(m_screenReader->getFocusedNode());
+        m_focusedNode->toInputElement()->stepDown(ec);
 }
 
 void WebPage::updateScreenReaderFocus(RenderObject* object)
@@ -1741,9 +1744,6 @@ void WebPage::updateScreenReaderFocus(RenderObject* object)
         m_screenReader->clearFocus();
     else if (!m_screenReader->rendererWillBeDestroyed(object))
         return;
-
-    m_focusedRect = IntRect();
-    didChangeFocusedRect(m_screenReader->getFocusedNode());
 }
 
 void WebPage::clearScreenReader()
@@ -1752,7 +1752,7 @@ void WebPage::clearScreenReader()
 }
 #endif
 
-#if ENABLE(TIZEN_SCREEN_READER) || ENABLE(TIZEN_FOCUS_UI) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 static LayoutRect rectToAbsoluteCoordinates(Frame* initialFrame, const LayoutRect& initialRect)
 {
     LayoutRect rect = initialRect;
@@ -1768,17 +1768,27 @@ static LayoutRect rectToAbsoluteCoordinates(Frame* initialFrame, const LayoutRec
     return rect;
 }
 
-IntRect WebPage::nodeRect(Node* node) const
+void WebPage::calcFocusedRects(Node* node, Vector<IntRect>& rects) const
 {
-    if (!node)
-        return IntRect();
+    if (!node || !node->renderer())
+        return;
+
+    RenderObject* renderer = node->renderer();
+    FrameView* view = node->document()->frame()->view();
+
+    IntPoint absolutePoint;
+    absolutePoint = view->convertToContainingWindow(view->convertFromRenderer(renderer, absolutePoint));
+    renderer->addFocusRingRects(rects, absolutePoint);
+
+    if (!rects.isEmpty())
+        return;
 
     LayoutRect rect;
     if (node->hasTagName(HTMLNames::areaTag)) {
         HTMLAreaElement* area = static_cast<HTMLAreaElement*>(node);
         HTMLImageElement* image = area->imageElement();
         if (!image || !image->renderer())
-            return IntRect();
+            return;
 
         rect = rectToAbsoluteCoordinates(area->document()->frame(), area->computeRect(area->imageElement()->renderer()));
     } else if (node->renderer()) {
@@ -1795,15 +1805,34 @@ IntRect WebPage::nodeRect(Node* node) const
         }
     }
 
-    return pixelSnappedIntRect(rect);
+    rects.append(pixelSnappedIntRect(rect));
 }
 #endif
 
-#if ENABLE(TIZEN_SCREEN_READER) || ENABLE(TIZEN_FOCUS_UI)
-void WebPage::didChangeFocusedRect(WebCore::Node* node)
+#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
+void WebPage::setFocusedNode(Node* node)
 {
-    m_focusedRect = nodeRect(node);
-    send(Messages::WebPageProxy::DidChangeFocusedRect(m_focusedRect));
+    m_focusedNode = node;
+    didChangeFocusedRects();
+}
+
+void WebPage::didChangeFocusedRects()
+{
+    Vector<IntRect> rects;
+    calcFocusedRects(m_focusedNode.get(), rects);
+    if (m_focusedRects == rects)
+        return;
+
+    m_focusedRects = rects;
+    send(Messages::WebPageProxy::DidChangeFocusedRects(m_focusedRects));
+}
+
+void WebPage::recalcFocusedRects()
+{
+    if (!m_focusedNode)
+        return;
+
+    didChangeFocusedRects();
 }
 #endif
 
@@ -1887,13 +1916,8 @@ void WebPage::didChangeContents(const IntRect& rect)
     }
 #endif
 
-#if ENABLE(TIZEN_SCREEN_READER) || ENABLE(TIZEN_FOCUS_UI)
-    if (rect.intersects(m_focusedRect)) {
-        if (m_screenReader)
-            didChangeFocusedRect(m_screenReader->getFocusedNode());
-        else if (m_page->settings()->isSpatialNavigationEnabled())
-            didChangeFocusedRect(frame->document()->focusedNode());
-    }
+#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
+    didChangeFocusedRects();
 #endif
 }
 
@@ -1901,6 +1925,12 @@ void WebPage::didChangeContents(const IntRect& rect)
 void WebPage::setSpatialNavigationEnabled(bool enabled)
 {
     m_page->settings()->setSpatialNavigationEnabled(enabled);
+
+    if (m_focusedNode && m_focusedNode->renderer())
+        m_focusedNode->renderer()->repaint();
+
+    if (!enabled)
+        setFocusedNode(0);
 }
 #endif
 #endif // #if OS(TIZEN)