#include <WebCore/Pasteboard.h>
#endif
-#if ENABLE(TIZEN_WEBKIT2_REMOTE_WEB_INSPECTOR)
-#include "WebInspectorServerEfl.h"
+#if ENABLE(TIZEN_REMOTE_WEB_INSPECTOR)
+#include "WebInspectorServerTizen.h"
#endif
#if ENABLE(TIZEN_WEB_STORAGE)
#include "WebEventConversion.h"
#endif
+#if ENABLE(TIZEN_SCREEN_READER) || ENABLE(TIZEN_FOCUS_UI) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+#include <WebCore/HTMLAreaElement.h>
+#endif
+
#if ENABLE(TIZEN_CSP)
#include <WebCore/ContentSecurityPolicy.h>
#endif
#if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
#include "WebPageSerializerTizen.h"
#endif
+
+#if ENABLE(TIZEN_USE_SETTINGS_FONT)
+#include "fontconfig/fontconfig.h"
+#include <WebCore/FontCache.h>
+#endif
+
+#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+#include "visible_units.h"
+#endif
#endif // #if OS(TIZEN)
using namespace WebCore;
#if ENABLE(TIZEN_LOAD_REMOTE_IMAGES)
settings->setLoadRemoteImages(store.getBoolValueForKey(WebPreferencesKey::loadRemoteImagesKey()));
#endif
+#if ENABLE(TIZEN_LINK_EFFECT)
+ settings->setLinkEffectEnabled(store.getBoolValueForKey(WebPreferencesKey::linkEffectEnabledKey()));
+#endif
#if ENABLE(TIZEN_ISF_PORT)
settings->setEnableDefaultKeypad(store.getBoolValueForKey(WebPreferencesKey::defaultKeypadEnabledKey()));
#endif
if (!targetFrame)
return;
+#if ENABLE(TIZEN_ISF_PORT)
+ if (m_prepareKeyDownEvent) {
+ m_keyPressCommands.append(adoptPtr(new ConfirmCompositionKeyPressCommand(compositionString)));
+ return;
+ }
+#endif
+
targetFrame->editor()->confirmComposition(compositionString);
+
+#if ENABLE(TIZEN_ISF_PORT)
+ m_page->editorClient()->respondToChangedSelection(targetFrame);
+#endif
}
void WebPage::setComposition(const String& compositionString, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition)
return;
#if ENABLE(TIZEN_ISF_PORT)
+ if (!targetFrame->editor()->hasComposition() && compositionString.isEmpty())
+ return;
+
+ if (m_prepareKeyDownEvent) {
+ m_keyPressCommands.append(adoptPtr(new SetCompositionKeyPressCommand(compositionString, underlines, cursorPosition)));
+ return;
+ }
+
if (targetFrame->selection()->rootEditableElement()) {
HTMLTextFormControlElement* textFormControl = toTextFormControl(targetFrame->selection()->rootEditableElement()->shadowAncestorNode());
if (textFormControl && textFormControl->maxLength() >= 0) {
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()->unlockRespondToChangedSelection();
+#endif
}
void WebPage::cancelComposition()
if (!node || !node->renderer())
return false;
+ Element* currentRootEditableElement = node->rootEditableElement();
+ Element* newRootEditableElement = innerNode->rootEditableElement();
+ if (currentRootEditableElement != newRootEditableElement)
+ return false;
+
IntRect rect = controller->caretRenderer()->absoluteBoundingBoxRect(true);
// The below wirtten code is not correct way to implement. Presntly the is no
return true;
}
-
-void WebPage::getCaretPosition(IntRect& rect)
-{
- Frame* frame = m_page->focusController()->focusedOrMainFrame();
- if (!frame)
- return;
-
- FrameSelection* controller = frame->selection();
- if (!controller)
- return;
-
- Node* node = controller->start().deprecatedNode();
- if (!node || !node->renderer() || !node->isContentEditable())
- return;
-
- if (controller->isCaret()) {
- FrameView* frameView = frame->view();
- if (!frameView)
- return;
-
- rect = frameView->contentsToWindow(controller->absoluteCaretBounds());
- }
-}
#endif
#if ENABLE(TIZEN_ISF_PORT)
send(Messages::WebPageProxy::DidCancelComposition());
}
-void WebPage::getCursorOffset(int& offset)
+void WebPage::prepareKeyDownEvent()
{
- offset = 0;
- Frame* frame = m_page->focusController()->focusedOrMainFrame();
- if (!frame || !frame->editor()->canEdit())
- return;
-
- Position base = frame->selection()->base();
- Node* baseNode = base.containerNode();
- if (baseNode)
- offset = baseNode->isTextNode() ? base.offsetInContainerNode() : 0;
+ m_prepareKeyDownEvent = true;
}
-void WebPage::getSurroundingTextAndCursorOffset(String& text, int& offset)
+void WebPage::swapKeyPressCommands(Vector<OwnPtr<KeyPressCommand> >& commands)
{
- text = String();
- offset = 0;
-
- Frame* frame = m_page->focusController()->focusedOrMainFrame();
- if (!frame || !frame->editor()->canEdit())
- return;
-
- Position base = frame->selection()->base();
- Node* baseNode = base.containerNode();
- if (baseNode && baseNode->isTextNode()) {
- text = baseNode->textContent();
- offset = base.offsetInContainerNode();
- }
-}
-
-void WebPage::getSelectionRect(bool isOnlyEditable, IntRect& rect)
-{
- rect = IntRect();
-
- Frame* frame = m_page->focusController()->focusedFrame();
- if (!frame || !frame->view())
- return;
-
- FrameSelection* selection = frame->selection();
- Node* node = selection->start().deprecatedNode();
- if (!node || !node->renderer() || (isOnlyEditable && !node->isContentEditable()))
- return;
-
- if (selection->isCaret())
- rect = frame->view()->contentsToWindow(selection->absoluteCaretBounds());
- else if (selection->isRange())
- rect = frame->view()->contentsToWindow(enclosingIntRect(selection->bounds(false)));
+ m_keyPressCommands.swap(commands);
}
void WebPage::deleteSurroundingText(int offset, int count)
if (!frame || !frame->editor()->canEdit())
return;
+ if (m_prepareKeyDownEvent) {
+ m_keyPressCommands.append(adoptPtr(new DeleteTextKeyPressCommand(offset, count)));
+ return;
+ }
+
Position base(frame->selection()->base());
offset += base.offsetInContainerNode();
base.moveToOffset(offset);
frame->selection()->setSelection(selection);
frame->editor()->deleteWithDirection(DirectionBackward, CharacterGranularity, false, true);
}
+
+void WebPage::updateEditorStateRect(const Frame* frame, EditorState& state) const
+{
+ ASSERT(frame->selection()->rootEditableElement());
+
+#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+ Vector<IntRect> rects;
+ calcFocusedRects(frame->selection()->rootEditableElement(), rects);
+ state.editorRect = unionRect(rects);
+#endif
+
+ if (frame->selection()->isCaret())
+ state.selectionRect = frame->view()->contentsToWindow(frame->selection()->absoluteCaretBounds());
+ else if (frame->selection()->isRange())
+ state.selectionRect = frame->view()->contentsToWindow(enclosingIntRect(frame->selection()->bounds(false)));
+}
#endif
#if ENABLE(TIZEN_INPUT_TAG_EXTENSION) || ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
#if ENABLE(TIZEN_WEBKIT2_HIT_TEST)
#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
-static IntRect getFocusedRect(HitTestResult hitTestResult, Page* page)
+static bool isClickableOrFocusable(Node* focusableNode)
+{
+
+ if (!focusableNode)
+ return false;
+ if (focusableNode->disabled())
+ return false;
+ if (!focusableNode->inDocument())
+ return false;
+ if (!focusableNode->renderer() || focusableNode->renderer()->style()->visibility() != VISIBLE)
+ return false;
+ if (focusableNode->isFocusable()) {
+ if (focusableNode->isLink()
+ || focusableNode->hasTagName(HTMLNames::inputTag)
+ || focusableNode->hasTagName(HTMLNames::selectTag)
+ || focusableNode->hasTagName(HTMLNames::buttonTag))
+ return true;
+ }
+ if (focusableNode->supportsFocus()
+ || focusableNode->hasEventListeners(eventNames().clickEvent)
+ || focusableNode->hasEventListeners(eventNames().mousedownEvent)
+ || focusableNode->hasEventListeners(eventNames().mouseupEvent)) {
+ return true;
+ }
+ return false;
+}
+
+#if ENABLE(TOUCH_ADJUSTMENT)
+void WebPage::getFocusedRect(HitTestResult hitTestResult, Page* page, bool setFocus, Vector<IntRect>& rects, const IntPoint& point, const IntSize& area)
+#else
+void WebPage::getFocusedRect(HitTestResult hitTestResult, Page* page, bool setFocus, Vector<IntRect>& rects)
+#endif
{
Node* node = hitTestResult.innerNode();
+#if ENABLE(TOUCH_ADJUSTMENT)
+ 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);
+
+ if (adjustedNode)
+ node = adjustedNode;
+#endif
+ if (!node)
+ return;
+
bool isFocusRingDrawable = false;
Node* focusableNode = node;
while (focusableNode) {
RenderObject* renderer = focusableNode->renderer();
- if (renderer && renderer->isRoot())
+ if (renderer && (renderer->isBody() || renderer->isRenderView() || renderer->isRoot()))
break;
- if (focusableNode->isFocusable()) {
- if (focusableNode->isLink()
- || focusableNode->hasTagName(HTMLNames::inputTag)
- || focusableNode->hasTagName(HTMLNames::selectTag)
- || focusableNode->hasTagName(HTMLNames::buttonTag))
- isFocusRingDrawable = true;
+ if (isClickableOrFocusable(focusableNode)) {
+ isFocusRingDrawable = true;
break;
}
focusableNode = focusableNode->parentNode();
}
- if (!isFocusRingDrawable) {
- if (node->hasTagName(HTMLNames::imgTag))
- return getNodeRect(node, node, !hitTestResult.absoluteImageURL().isEmpty());
+ // Don't draw focus ring if child is focusable or has trigger
+ if (focusableNode && focusableNode->isContainerNode() && !focusableNode->isLink()) {
+ WebCore::Node *child = static_cast<const ContainerNode*>(focusableNode)->firstChild();
+ while(child) {
+ if( child->supportsFocus()
+ || child->hasEventListeners(eventNames().clickEvent)
+ || child->hasEventListeners(eventNames().mousedownEvent)
+ || child->hasEventListeners(eventNames().mouseupEvent)) {
+ return;
+ }
+ child = child->traverseNextNode(focusableNode);
+ }
+ }
- return IntRect();
+ if (!isFocusRingDrawable) {
+ if (!node->hasTagName(HTMLNames::imgTag))
+ return;
+ focusableNode = node;
}
- return getNodeRect(node, focusableNode, !hitTestResult.absoluteImageURL().isEmpty());
+ if (setFocus)
+ setFocusedNode(focusableNode);
+
+ calcFocusedRects(focusableNode, rects);
}
#endif
+#if ENABLE(TOUCH_ADJUSTMENT)
+void WebPage::hitTestResultAtPoint(const IntPoint& point, int hitTestMode, const IntSize& area, WebHitTestResult::Data& hitTestResultData)
+#else
void WebPage::hitTestResultAtPoint(const IntPoint& point, int hitTestMode, WebHitTestResult::Data& hitTestResultData)
+#endif
{
Frame* frame = m_page->mainFrame();
FrameView* frameView = frame->view();
hitTestResultData.hitTestMode = hitTestMode;
#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
- hitTestResultData.focusedRect = getFocusedRect(hitTestResult, m_page.get());
+ bool setFocus = hitTestResultData.hitTestMode & WebHitTestResult::HitTestModeSetFocus;
+#if ENABLE(TOUCH_ADJUSTMENT)
+ getFocusedRect(hitTestResult, m_page.get(), setFocus, hitTestResultData.focusedRects, point, area);
+#else
+ getFocusedRect(hitTestResult, m_page.get(), setFocus, hitTestResultData.focusedRects);
+#endif
+
+ // Don't display FocusRect if the size is too big..
+ IntRect framerect = frameView->visibleContentRect(true);
+ 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()) {
hitTestResultData.focusedColor = hitTestResult.innerNode()->renderer()->style()->tapHighlightColor();
if (!hitTestResultData.focusedColor.hasAlpha())
}
#endif
-#if ENABLE(TIZEN_RECORDING_SURFACE_SET)
-void WebPage::recordingSurfaceSetEnableSet(bool enable)
-{
- m_recordingSurfaceSetSettings = enable;
-}
-#endif
-
#if ENABLE(TIZEN_CLIPBOARD) || ENABLE(TIZEN_PASTEBOARD)
void WebPage::setClipboardDataForPaste(const String& data, const String& type)
{
mainFrame->loader()->resumeAllLoaders();
}
+void WebPage::suspendAnimations()
+{
+ Frame* mainFrame = m_page->mainFrame();
+ if (!mainFrame)
+ return;
+
+ for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
+ frame->animation()->suspendAnimationsForDocument(frame->document());
+}
+
+void WebPage::resumeAnimations()
+{
+ Frame* mainFrame = m_page->mainFrame();
+ if (!mainFrame)
+ return;
+
+ for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
+ frame->animation()->resumeAnimationsForDocument(frame->document());
+}
+
#if ENABLE(TIZEN_SYNC_REQUEST_ANIMATION_FRAME)
void WebPage::suspendAnimationController()
{
}
#endif
-#if ENABLE(TIZEN_WEBKIT2_REMOTE_WEB_INSPECTOR)
+#if ENABLE(TIZEN_REMOTE_WEB_INSPECTOR)
void WebPage::startInspectorServer(uint32_t port, uint32_t& allocatedPort)
{
- bool ret = WebInspectorServerEfl::server()->startServer(port);
+ bool ret = WebInspectorServerTizen::server()->startServer(port);
if (ret)
- allocatedPort = WebInspectorServerEfl::server()->getServerPort();
+ allocatedPort = WebInspectorServerTizen::server()->getServerPort();
else
allocatedPort = 0;
}
void WebPage::stopInspectorServer(bool& result)
{
- result = WebInspectorServerEfl::server()->stopServer();
+ result = WebInspectorServerTizen::server()->stopServer();
}
#endif
}
#endif
-#if ENABLE(TIZEN_WEBKIT2_GET_TEXT_STYLE_FOR_SELECTION)
-void WebPage::getTextStyleStateForSelection()
-{
- Frame* frame = m_page->focusController()->focusedOrMainFrame();
-
- int underlineState = frame->editor()->selectionHasStyle(CSSPropertyWebkitTextDecorationsInEffect, "underline");
- int italicState = frame->editor()->selectionHasStyle(CSSPropertyFontStyle, "italic");
- int boldState = frame->editor()->selectionHasStyle(CSSPropertyFontWeight, "bold");
-
- send(Messages::WebPageProxy::DidGetTextStyleStateForSelection(underlineState, italicState, boldState));
-}
-#endif
-
#if ENABLE(TIZEN_MULTIPLE_SELECT)
void WebPage::didChangeSelectedIndexForActivePopupMenuMultiple(Vector<int32_t> newIndex)
{
#endif
#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
-void WebPage::selectClosestWord(const IntPoint& point, bool isStartedTextSelectionFromOutside, bool& result)
+void WebPage::selectClosestWord(const IntPoint& point, bool& result)
{
result = false;
focusedFrame = newFocusFrame;
}
-#if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
HTMLInputElement* inputElement = node->toInputElement();
-#endif
if (hitTestResult.isContentEditable()) {
-#if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
- if (!inputElement || (inputElement
- && !inputElement->isDateField() && !inputElement->isDateTimeField() && !inputElement->isDateTimeLocalField()
- && !inputElement->isMonthField() && !inputElement->isTimeField() && !inputElement->isWeekField())) {
- result = setCaretPosition(point);
- return;
- }
-#else
result = setCaretPosition(point);
return;
-#endif
}
#if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
#endif
return;
- if (!isStartedTextSelectionFromOutside) {
- for (Node* node = hitTestResult.innerNonSharedNode(); node; node = node->parentNode()) {
- if (node->isFocusable()) {
- // Text selection shoud not be started when text of <button> tag is selected.
- if (node->hasTagName(HTMLNames::buttonTag))
- return;
- break;
- }
+#if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
+ if (inputElement
+ && (inputElement->isDateField() || inputElement->isDateTimeField() || inputElement->isDateTimeLocalField()
+ || inputElement->isMonthField() || inputElement->isTimeField() || inputElement->isWeekField())) {
+ if (inputElement->value().isEmpty())
+ return;
+ }
+#endif
+
+ for (Node* node = hitTestResult.innerNonSharedNode(); node; node = node->parentNode()) {
+ if (node->isFocusable()) {
+ // Text selection shoud not be started when text of <button> tag is selected.
+ if (node->hasTagName(HTMLNames::buttonTag))
+ return;
+
+ if (inputElement && inputElement->isTextButton())
+ return;
+
+ break;
}
}
result = true;
}
-void WebPage::setLeftSelection(const IntPoint& point, bool& result)
+void WebPage::setLeftSelection(const IntPoint& point, const int direction, int& result)
{
- result = false;
+ result = HandleMovingDirectionNone;
Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
FrameSelection* frameSelection = focusedFrame->selection();
IntPoint pos = frameView->windowToContents(point);
IntRect leftRect, rightRect;
getSelectionHandlers(leftRect, rightRect);
- if ((rightRect.y() + rightRect.height()) < pos.y())
- pos.setY(rightRect.y() + (rightRect.height()/2));
if (selectionEndNode->rendererIsEditable() && !selectionEndNode->rendererIsRichlyEditable()) {
const int boundariesWidth = 2;
}
OwnPtr<VisiblePosition> position = adoptPtr(new VisiblePosition(focusedFrame->visiblePositionForPoint(pos)));
+ Position base = frameSelection->base();
Position extent = frameSelection->extent();
Node* newSelectionStartNode = position->deepEquivalent().deprecatedNode();
// both start and end nodes should be in the same area type: both should be editable or both should be not editable
// Check if the new position is before the extent's position
if (newSelectionStartNode
- && selectionEndNode->isContentEditable() == newSelectionStartNode->isContentEditable()
- && comparePositions(position->deepEquivalent(), extent) < 0) {
+ && selectionEndNode->isContentEditable() == newSelectionStartNode->isContentEditable()) {
// Change the 'base' and 'extent' positions to 'start' and 'end' positions.
// We do it, because without this, the other modification of the selection
// would destroy the 'start' and/or 'end' positions and set them to
bool oldProhibitsScrolling = focusedFrame->view()->prohibitsScrolling();
focusedFrame->view()->setProhibitsScrolling(true);
- frameSelection->setBase(*position);
+ if (direction == HandleMovingDirectionNormal) {
+ if (comparePositions(position->deepEquivalent(), extent) < 0) {
+ frameSelection->setBase(*position);
+ result = HandleMovingDirectionNormal;
+ } else if (comparePositions(position->deepEquivalent(), extent) > 0) {
+ frameSelection->setExtent(*position);
+ frameSelection->setBase(extent);
+ result = HandleMovingDirectionReverse;
+ }
+ } else if (direction == HandleMovingDirectionReverse) {
+ if (comparePositions(position->deepEquivalent(), base) > 0) {
+ frameSelection->setExtent(*position);
+ result = HandleMovingDirectionReverse;
+ } else if (comparePositions(position->deepEquivalent(), base) < 0) {
+ frameSelection->setBase(*position);
+ frameSelection->setExtent(base);
+ result = HandleMovingDirectionNormal;
+ }
+ }
focusedFrame->view()->setProhibitsScrolling(oldProhibitsScrolling);
// This forces webkit to show selection
// m_coreFrame->invalidateSelection();
-
- result = true;
}
}
-
-void WebPage::setRightSelection(const IntPoint& point, bool& result)
+void WebPage::setRightSelection(const IntPoint& point, const int direction, int& result)
{
- result = false;
+ result = HandleMovingDirectionNone;
Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
FrameSelection* frameSelection = focusedFrame->selection();
OwnPtr<VisiblePosition> position = adoptPtr(new VisiblePosition(focusedFrame->visiblePositionForPoint(pos)));
Position base = frameSelection->base();
+ Position extent = frameSelection->extent();
Node* newSelectionEndNode = position->deepEquivalent().deprecatedNode();
// both start and end nodes should be in the same area type: both should be editable or both should be not editable
// Check if the new position is after the base's position
if (newSelectionEndNode
- && selectionStartNode->isContentEditable() == newSelectionEndNode->isContentEditable()
- && comparePositions(position->deepEquivalent(), base) > 0) {
+ && selectionStartNode->isContentEditable() == newSelectionEndNode->isContentEditable()) {
// Change the 'base' and 'extent' positions to 'start' and 'end' positions.
// We do it, because without this, the other modifications of the selection
// would destroy the 'start' and/or 'end' positions and set them to
bool oldProhibitsScrolling = focusedFrame->view()->prohibitsScrolling();
focusedFrame->view()->setProhibitsScrolling(true);
- frameSelection->setExtent(*position);
+ if (direction == HandleMovingDirectionNormal) {
+ if (comparePositions(position->deepEquivalent(), base) > 0) {
+ frameSelection->setExtent(*position);
+ result = HandleMovingDirectionNormal;
+ } else if (comparePositions(position->deepEquivalent(), base) < 0) {
+ frameSelection->setBase(*position);
+ frameSelection->setExtent(base);
+ result = HandleMovingDirectionReverse;
+ }
+ } else if (direction == HandleMovingDirectionReverse) {
+ if (comparePositions(position->deepEquivalent(), extent) < 0) {
+ frameSelection->setBase(*position);
+ result = HandleMovingDirectionReverse;
+ } else if (comparePositions(position->deepEquivalent(), extent) > 0) {
+ frameSelection->setExtent(*position);
+ frameSelection->setBase(extent);
+ result = HandleMovingDirectionNormal;
+ }
+ }
focusedFrame->view()->setProhibitsScrolling(oldProhibitsScrolling);
-
- result = true;
}
}
// If selection rect size is greater than editor rect size because of round operation,
// selection rect size should be changed to editor rect size.
if (size == 1) {
- Element* selectionRoot = focusedFrame->selection()->rootEditableElement();
- if (selectionRoot) {
- IntRect editorRect = focusedFrame->view()->contentsToWindow(selectionRoot->getPixelSnappedRect());
+ Element* rootEditableElement = focusedFrame->selection()->rootEditableElement();
+ if (rootEditableElement) {
+ Vector<IntRect> rects;
+ calcFocusedRects(rootEditableElement, rects);
+ IntRect editorRect = unionRect(rects);
#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
if (m_editorState.editorRect != editorRect) {
EditorState state = editorState();
state.updateEditorRectOnly = true;
+ setEditorState(state);
send(Messages::WebPageProxy::EditorStateChanged(state));
}
#endif
result = false;
Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
- if (direction)
- result = focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionBackward, CharacterGranularity, UserTriggered);
- else
- result = focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity, UserTriggered);
+ if (!focusedFrame)
+ return;
+
+ FrameSelection* frameSelection = focusedFrame->selection();
+ if (!frameSelection)
+ return;
+
+ VisiblePosition currentPosition = frameSelection->selection().visibleStart();
+ if (direction) {
+ if (isStartOfLine(currentPosition))
+ return;
+
+ focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionBackward, CharacterGranularity, UserTriggered);
+ } else {
+ if (isEndOfLine(currentPosition))
+ return;
+
+ focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity, UserTriggered);
+ }
+}
+
+void WebPage::scrollContentByLine(const IntPoint&, int direction, bool& result)
+{
+ result = false;
+
+ Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
+ if (!focusedFrame)
+ return;
+
+ FrameSelection* frameSelection = focusedFrame->selection();
+ if (!frameSelection)
+ return;
+
+ VisiblePosition currentPosition = frameSelection->selection().visibleStart();
+ if (direction) {
+ if (inSameLine(currentPosition, previousLinePosition(currentPosition, 0)))
+ return;
+
+ focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionBackward, LineGranularity, UserTriggered);
+ } else {
+ if (inSameLine(currentPosition, nextLinePosition(currentPosition, 0)))
+ return;
+
+ focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionForward, LineGranularity, UserTriggered);
+ }
}
#endif
#endif
#if ENABLE(TIZEN_SCREEN_READER)
-void WebPage::raiseTapEvent(const IntPoint& position, const IntPoint& globalPosition)
+void WebPage::moveScreenReaderFocus(bool forward, bool& result)
{
+ if (!m_screenReader)
+ m_screenReader = ScreenReader::create(this);
+
+ result = m_screenReader->moveFocus(forward);
+}
+
+void WebPage::moveScreenReaderFocusByPoint(const IntPoint& point)
+{
+ if (!m_screenReader)
+ m_screenReader = ScreenReader::create(this);
+
+ if (!m_screenReader->moveFocus(point))
+ return;
+}
+
+void WebPage::clearScreenReaderFocus()
+{
+ if (!m_screenReader)
+ return;
+
+ m_screenReader->clearFocus();
+}
+
+void WebPage::raiseTapEvent(const IntPoint& position, const IntPoint& globalPosition, bool& result)
+{
+ result = false;
+
+#if ENABLE(GESTURE_EVENTS)
Frame* frame = m_page->mainFrame();
if (!frame->view())
return;
touchPoints.append(WebPlatformTouchPoint(0, WebPlatformTouchPoint::TouchPressed, globalPosition, position));
WebTouchEvent touchStartEvent(WebEvent::TouchStart, touchPoints, WebEvent::Modifiers(0), ecore_time_get());
- if (!frame->eventHandler()->handleTouchEvent(platform(touchStartEvent))) {
- WebGestureEvent gestureEvent(WebEvent::GestureSingleTap, position, globalPosition, WebEvent::Modifiers(0), ecore_time_get());
- frame->eventHandler()->handleGestureEvent(platform(gestureEvent));
- }
+ bool handled = frame->eventHandler()->handleTouchEvent(platform(touchStartEvent));
touchPoints.at(0).setState(WebPlatformTouchPoint::TouchReleased);
+
WebTouchEvent touchEndEvent(WebEvent::TouchEnd, touchPoints, WebEvent::Modifiers(0), ecore_time_get());
- frame->eventHandler()->handleTouchEvent(platform(touchEndEvent));
+ handled |= frame->eventHandler()->handleTouchEvent(platform(touchEndEvent));
+
+ if (!handled) {
+ WebGestureEvent gestureEvent(WebEvent::GestureSingleTap, position, globalPosition, WebEvent::Modifiers(0), ecore_time_get());
+ frame->eventHandler()->handleGestureEvent(platform(gestureEvent));
+ result = true;
+ }
+#endif
}
-static void sendScreenReaderFocusRect(WebPage* page, Node* node)
+void WebPage::adjustScreenReaderFocusedObjectValue(bool up)
{
- bool isImage = false;
- if (node->isElementNode()) {
- Element* element = static_cast<Element*>(node);
- isImage = !element->getAttribute(element->imageSourceAttributeName()).isEmpty();
- }
+ if (!m_screenReader || !m_focusedNode || !m_focusedNode->toInputElement())
+ return;
- page->send(Messages::WebPageProxy::DidScreenReaderFocusRectChanged(getNodeRect(node, node, isImage)));
+ ExceptionCode ec;
+ if (up)
+ m_focusedNode->toInputElement()->stepUp(ec);
+ else
+ m_focusedNode->toInputElement()->stepDown(ec);
}
-void WebPage::moveScreenReaderFocus(bool forward, bool& result)
+void WebPage::updateScreenReaderFocus(RenderObject* object)
{
if (!m_screenReader)
- m_screenReader = ScreenReader::create(this);
+ return;
- if (!m_screenReader->moveFocus(forward)) {
- result = false;
- send(Messages::WebPageProxy::DidScreenReaderFocusRectChanged(IntRect()));
+ if (!object)
+ m_screenReader->clearFocus();
+ else if (!m_screenReader->rendererWillBeDestroyed(object))
return;
- } else {
- result = true;
- sendScreenReaderFocusRect(this, m_screenReader->getFocusedNode());
- }
}
-void WebPage::moveScreenReaderFocusByPoint(const IntPoint& point)
+void WebPage::clearScreenReader()
{
- if (!m_screenReader)
- m_screenReader = ScreenReader::create(this);
-
- if (!m_screenReader->moveFocus(point))
- return;
+ m_screenReader.clear();
+}
+#endif
- sendScreenReaderFocusRect(this, m_screenReader->getFocusedNode());
+#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+static LayoutRect rectToAbsoluteCoordinates(Frame* initialFrame, const LayoutRect& initialRect)
+{
+ LayoutRect rect = initialRect;
+ for (Frame* frame = initialFrame; frame; frame = frame->tree()->parent()) {
+ RenderBoxModelObject* renderer;
+ if (frame->ownerElement() && (renderer = frame->ownerElement()->renderBoxModelObject())) {
+ do {
+ rect.move(renderer->offsetLeft(), renderer->offsetTop());
+ } while ((renderer = renderer->offsetParent()));
+ rect.move(-frame->view()->scrollOffset());
+ }
+ }
+ return rect;
}
-void WebPage::recalcScreenReaderFocusRect()
+void WebPage::calcFocusedRects(Node* node, Vector<IntRect>& rects) const
{
- if (!m_screenReader || !m_screenReader->getFocusedNode())
+ if (!node || !node->renderer())
return;
- sendScreenReaderFocusRect(this, m_screenReader->getFocusedNode());
+ 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;
+
+ rect = rectToAbsoluteCoordinates(area->document()->frame(), area->computeRect(area->imageElement()->renderer()));
+ } else if (node->renderer()) {
+ if (node->isDocumentNode())
+ rect = rectToAbsoluteCoordinates(static_cast<Document*>(node)->frame(), static_cast<Document*>(node)->frame()->view()->visibleContentRect());
+ else {
+ rect = node->getRect();
+ rect.intersect(node->renderer()->absoluteClippedOverflowRect());
+ rect = rectToAbsoluteCoordinates(node->document()->frame(), rect);
+
+ rect.move(node->renderer()->style()->borderLeftWidth(), node->renderer()->style()->borderTopWidth());
+ rect.setWidth(rect.width() - node->renderer()->style()->borderLeftWidth() - node->renderer()->style()->borderRightWidth());
+ rect.setHeight(rect.height() - node->renderer()->style()->borderTopWidth() - node->renderer()->style()->borderBottomWidth());
+ }
+ }
+
+ rects.append(pixelSnappedIntRect(rect));
}
+#endif
-void WebPage::updateScreenReaderFocus(RenderObject* object)
+#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
+void WebPage::setFocusedNode(Node* node)
{
- if (!m_screenReader)
- return;
+ m_focusedNode = node;
+ didChangeFocusedRects();
+}
- if (!object)
- m_screenReader->clearFocus();
- else if (!m_screenReader->rendererWillBeDestroyed(object))
+void WebPage::didChangeFocusedRects()
+{
+ Vector<IntRect> rects;
+ calcFocusedRects(m_focusedNode.get(), rects);
+ if (m_focusedRects == rects)
return;
- send(Messages::WebPageProxy::DidScreenReaderFocusRectChanged(IntRect()));
+ m_focusedRects = rects;
+ send(Messages::WebPageProxy::DidChangeFocusedRects(m_focusedRects));
}
-void WebPage::clearScreenReader()
+void WebPage::recalcFocusedRects()
{
- m_screenReader.clear();
+ if (!m_focusedNode)
+ return;
+
+ didChangeFocusedRects();
}
#endif
m_page->settings()->setLocalStorageDatabasePath(path);
}
#endif
+
+#if ENABLE(TIZEN_USE_SETTINGS_FONT)
+void WebPage::useSettingsFont()
+{
+ if (!WebCore::fontCache()->isFontFamliyTizen())
+ return;
+
+ FcInitReinitialize();
+ WebCore::fontCache()->invalidate();
+
+ FrameView* frameView = m_mainFrame->coreFrame()->view();
+ if (!frameView)
+ return;
+
+ frameView->forceLayout();
+}
+#endif
+
+void WebPage::didChangeContents(const IntRect& rect)
+{
+ if (!m_page)
+ return;
+
+ Frame* frame = m_page->focusController()->focusedOrMainFrame();
+ if (!frame || !frame->view() || frame->view()->needsLayout())
+ return;
+
+#if ENABLE(TIZEN_ISF_PORT) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+ if (m_editorState.isContentEditable && rect.intersects(m_editorState.editorRect) && frame->selection()->rootEditableElement()) {
+ IntRect previousEditorRect = m_editorState.editorRect;
+ updateEditorStateRect(frame, m_editorState);
+
+ if (m_editorState.editorRect != previousEditorRect) {
+ m_editorState.updateEditorRectOnly = true;
+ send(Messages::WebPageProxy::EditorStateChanged(m_editorState));
+ }
+ }
+#endif
+
+#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
+ didChangeFocusedRects();
+#endif
+}
+
+#if ENABLE(TIZEN_FOCUS_UI)
+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)
} // namespace WebKit
projects / framework / web / webkit-efl.git / blobdiff