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
}
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())
}
#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);
node = adjustedNode;
#endif
if (!node)
- return IntRect();
+ return;
bool isFocusRingDrawable = false;
Node* focusableNode = node;
|| 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
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()) {
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) {
m_screenReader = ScreenReader::create(this);
result = m_screenReader->moveFocus(forward);
- didChangeFocusedRect(m_screenReader->getFocusedNode());
}
void WebPage::moveScreenReaderFocusByPoint(const IntPoint& point)
if (!m_screenReader->moveFocus(point))
return;
-
- didChangeFocusedRect(m_screenReader->getFocusedNode());
}
void WebPage::clearScreenReaderFocus()
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)
m_screenReader->clearFocus();
else if (!m_screenReader->rendererWillBeDestroyed(object))
return;
-
- m_focusedRect = IntRect();
- didChangeFocusedRect(m_screenReader->getFocusedNode());
}
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;
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()) {
}
}
- 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
}
#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
}
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)