#include "bindings/core/v8/ExceptionStatePlaceholder.h"
#include "core/HTMLNames.h"
+#include "core/InputTypeNames.h"
#include "core/SVGNames.h"
#include "core/clipboard/DataObject.h"
#include "core/clipboard/DataTransfer.h"
#include "core/dom/Document.h"
#include "core/dom/DocumentMarkerController.h"
-#include "core/dom/FullscreenElementStack.h"
+#include "core/dom/Fullscreen.h"
#include "core/dom/NodeRenderingTraversal.h"
#include "core/dom/TouchList.h"
#include "core/dom/shadow/ShadowRoot.h"
#include "core/page/DragController.h"
#include "core/page/DragState.h"
#include "core/page/EditorClient.h"
-#include "core/page/EventWithHitTestResults.h"
#include "core/page/FocusController.h"
#include "core/page/FrameTree.h"
#include "core/page/Page.h"
// event target node can't still be the shadow node.
static inline bool shouldRefetchEventTarget(const MouseEventWithHitTestResults& mev)
{
- Node* targetNode = mev.targetNode();
+ Node* targetNode = mev.innerNode();
if (!targetNode || !targetNode->parentNode())
return true;
return targetNode->isShadowRoot() && isHTMLInputElement(*toShadowRoot(targetNode)->host());
visitor->trace(m_capturingMouseEventsNode);
visitor->trace(m_nodeUnderMouse);
visitor->trace(m_lastNodeUnderMouse);
+ visitor->trace(m_lastMouseMoveEventSubframe);
visitor->trace(m_clickNode);
visitor->trace(m_dragTarget);
visitor->trace(m_frameSetBeingResized);
void EventHandler::selectClosestWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
{
- Node* innerNode = result.targetNode();
+ Node* innerNode = result.innerNode();
VisibleSelection newSelection;
if (innerNode && innerNode->renderer()) {
void EventHandler::selectClosestMisspellingFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
{
- Node* innerNode = result.targetNode();
+ Node* innerNode = result.innerNode();
VisibleSelection newSelection;
if (innerNode && innerNode->renderer()) {
if (!result.hitTestResult().isLiveLink())
return selectClosestWordFromMouseEvent(result);
- Node* innerNode = result.targetNode();
+ Node* innerNode = result.innerNode();
if (innerNode && innerNode->renderer() && m_mouseDownMayStartSelect) {
VisibleSelection newSelection;
if (event.event().button() != LeftButton)
return false;
- Node* innerNode = event.targetNode();
+ Node* innerNode = event.innerNode();
if (!(innerNode && innerNode->renderer() && m_mouseDownMayStartSelect))
return false;
TRACE_EVENT0("blink", "EventHandler::handleMousePressEventSingleClick");
m_frame->document()->updateLayoutIgnorePendingStylesheets();
- Node* innerNode = event.targetNode();
+ Node* innerNode = event.innerNode();
if (!(innerNode && innerNode->renderer() && m_mouseDownMayStartSelect))
return false;
// If we got the event back, that must mean it wasn't prevented,
// so it's allowed to start a drag or selection if it wasn't in a scrollbar.
- m_mouseDownMayStartSelect = canMouseDownStartSelect(event.targetNode()) && !event.scrollbar();
+ m_mouseDownMayStartSelect = canMouseDownStartSelect(event.innerNode()) && !event.scrollbar();
m_mouseDownMayStartDrag = singleClick;
if (singleClick)
focusDocumentView();
- Node* innerNode = event.targetNode();
+ Node* innerNode = event.innerNode();
m_mousePressNode = innerNode;
m_dragStartPos = event.event().position();
bool swallowEvent = false;
m_mousePressed = true;
- m_selectionInitiationState = HaveNotStartedSelection;
if (event.event().clickCount() == 2)
swallowEvent = handleMousePressEventDoubleClick(event);
if (handleDrag(event, ShouldCheckDragHysteresis))
return true;
- Node* targetNode = event.targetNode();
+ Node* targetNode = event.innerNode();
if (event.event().button() != LeftButton || !targetNode)
return false;
if (!m_mouseDownMayStartSelect)
return;
- Node* target = hitTestResult.targetNode();
+ Node* target = hitTestResult.innerNode();
if (!target)
return;
&& m_frame->selection().isRange()
&& event.event().button() != RightButton) {
VisibleSelection newSelection;
- Node* node = event.targetNode();
+ Node* node = event.innerNode();
bool caretBrowsing = m_frame->settings() && m_frame->settings()->caretBrowsingEnabled();
if (node && node->renderer() && (caretBrowsing || node->hasEditableStyle())) {
VisiblePosition pos = VisiblePosition(node->renderer()->positionForPoint(event.localPoint()));
{
if (!hitTestResult.isOverWidget())
return 0;
- return subframeForTargetNode(hitTestResult.targetNode());
+ return subframeForTargetNode(hitTestResult.innerNode());
}
static bool isSubmitImage(Node* node)
{
- return isHTMLInputElement(node) && toHTMLInputElement(node)->isImageButton();
+ return isHTMLInputElement(node) && toHTMLInputElement(node)->type() == InputTypeNames::image;
}
bool EventHandler::useHandCursor(Node* node, bool isOverLink)
}
m_mouseDownWasInSubframe = false;
- // Mouse events simulated from touch should not hit-test again.
- ASSERT(!mouseEvent.fromTouch());
-
HitTestRequest request(HitTestRequest::Active);
// Save the document point we generate in case the window coordinate is invalidated by what happens
// when we dispatch the event.
LayoutPoint documentPoint = documentPointForWindowPoint(m_frame, mouseEvent.position());
MouseEventWithHitTestResults mev = m_frame->document()->prepareMouseEvent(request, documentPoint, mouseEvent);
- if (!mev.targetNode()) {
+ if (!mev.innerNode()) {
invalidateClick();
return false;
}
- m_mousePressNode = mev.targetNode();
+ m_mousePressNode = mev.innerNode();
- RefPtr<LocalFrame> subframe = subframeForHitTestResult(mev);
+ RefPtrWillBeRawPtr<LocalFrame> subframe = subframeForHitTestResult(mev);
if (subframe && passMousePressEventToSubframe(mev, subframe.get())) {
// Start capturing future events for this frame. We only do this if we didn't clear
// the m_mousePressed flag, which may happen if an AppKit widget entered a modal event loop.
m_capturesDragging = subframe->eventHandler().capturesDragging();
if (m_mousePressed && m_capturesDragging) {
- m_capturingMouseEventsNode = mev.targetNode();
+ m_capturingMouseEventsNode = mev.innerNode();
m_eventHandlerWillResetCapturingMouseEventsNode = true;
}
invalidateClick();
#endif
m_clickCount = mouseEvent.clickCount();
- m_clickNode = mev.targetNode()->isTextNode() ? NodeRenderingTraversal::parent(mev.targetNode()) : mev.targetNode();
+ m_clickNode = mev.innerNode()->isTextNode() ? NodeRenderingTraversal::parent(mev.innerNode()) : mev.innerNode();
if (FrameView* view = m_frame->view()) {
- RenderLayer* layer = mev.targetNode()->renderer() ? mev.targetNode()->renderer()->enclosingLayer() : 0;
+ RenderLayer* layer = mev.innerNode()->renderer() ? mev.innerNode()->renderer()->enclosingLayer() : 0;
IntPoint p = view->windowToContents(mouseEvent.position());
if (layer && layer->scrollableArea() && layer->scrollableArea()->isPointInResizeControl(p, ResizerForPointer)) {
m_resizeScrollableArea = layer->scrollableArea();
m_frame->selection().setCaretBlinkingSuspended(true);
- bool swallowEvent = !dispatchMouseEvent(EventTypeNames::mousedown, mev.targetNode(), m_clickCount, mouseEvent, true);
+ bool swallowEvent = !dispatchMouseEvent(EventTypeNames::mousedown, mev.innerNode(), m_clickCount, mouseEvent, true);
+ // m_selectionInitiationState is initialized after dispatching mousedown event in order not to keep the selection by DOM APIs
+ // Because we can't give the user the chance to handle the selection by user action like dragging if we keep the selection in case of mousedown.
+ // FireFox also has the same behavior and it's more compatible with other browsers.
+ m_selectionInitiationState = HaveNotStartedSelection;
swallowEvent = swallowEvent || handleMouseFocus(mouseEvent);
m_capturesDragging = !swallowEvent || mev.scrollbar();
if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode())
m_resizeScrollableArea->resize(mouseEvent, m_offsetFromResizeCorner);
else {
- if (FrameView* view = m_frame->view())
- scrollbar = view->scrollbarAtPoint(mouseEvent.position());
-
if (!scrollbar)
scrollbar = mev.scrollbar();
}
bool swallowEvent = false;
- RefPtr<LocalFrame> newSubframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
+ RefPtrWillBeRawPtr<LocalFrame> newSubframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
// We want mouseouts to happen first, from the inside out. First send a move event to the last subframe so that it will fire mouseouts.
if (m_lastMouseMoveEventSubframe && m_lastMouseMoveEventSubframe->tree().isDescendantOf(m_frame) && m_lastMouseMoveEventSubframe != newSubframe)
if (newSubframe) {
// Update over/out state before passing the event to the subframe.
- updateMouseEventTargetNode(mev.targetNode(), mouseEvent, true);
+ updateMouseEventTargetNode(mev.innerNode(), mouseEvent, true);
// Event dispatch in updateMouseEventTargetNode may have caused the subframe of the target
// node to be detached from its FrameView, in which case the event should not be passed.
if (swallowEvent)
return true;
- swallowEvent = !dispatchMouseEvent(EventTypeNames::mousemove, mev.targetNode(), 0, mouseEvent, true);
+ swallowEvent = !dispatchMouseEvent(EventTypeNames::mousemove, mev.innerNode(), 0, mouseEvent, true);
if (!swallowEvent)
swallowEvent = handleMouseDraggedEvent(mev);
if (subframe && passMouseReleaseEventToSubframe(mev, subframe))
return true;
- bool swallowMouseUpEvent = !dispatchMouseEvent(EventTypeNames::mouseup, mev.targetNode(), m_clickCount, mouseEvent, false);
+ bool swallowMouseUpEvent = !dispatchMouseEvent(EventTypeNames::mouseup, mev.innerNode(), m_clickCount, mouseEvent, false);
bool contextMenuEvent = mouseEvent.button() == RightButton;
#if OS(MACOSX)
#endif
bool swallowClickEvent = false;
- if (m_clickCount > 0 && !contextMenuEvent && mev.targetNode() && m_clickNode) {
- if (Node* clickTargetNode = mev.targetNode()->commonAncestor(*m_clickNode, parentForClickEvent))
+ if (m_clickCount > 0 && !contextMenuEvent && mev.innerNode() && m_clickNode) {
+ if (Node* clickTargetNode = mev.innerNode()->commonAncestor(*m_clickNode, parentForClickEvent))
swallowClickEvent = !dispatchMouseEvent(EventTypeNames::click, clickTargetNode, m_clickCount, mouseEvent, true);
}
MouseEventWithHitTestResults mev = prepareMouseEvent(request, event);
// Drag events should never go to text nodes (following IE, and proper mouseover/out dispatch)
- RefPtrWillBeRawPtr<Node> newTarget = mev.targetNode();
+ RefPtrWillBeRawPtr<Node> newTarget = mev.innerNode();
if (newTarget && newTarget->isTextNode())
newTarget = NodeRenderingTraversal::parent(newTarget.get());
{
// If clicking on a frame scrollbar, do not mess up with content focus.
if (FrameView* view = m_frame->view()) {
- if (view->scrollbarAtPoint(mouseEvent.position()))
+ if (view->scrollbarAtWindowPoint(mouseEvent.position()))
return false;
}
bool EventHandler::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
{
- TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
-
// Propagation to inner frames is handled below this function.
ASSERT(m_frame == m_frame->localFrameRoot());
// Scrolling-related gesture events invoke EventHandler recursively for each frame down
// the chain, doing a single-frame hit-test per frame. This matches handleWheelEvent.
- // Perhaps we could simplify things by rewriting scroll handling to work inner frame
- // out, and then unify with other gesture events.
+ // FIXME: Add a test that traverses this path, e.g. for devtools overlay.
if (gestureEvent.isScrollEvent())
return handleGestureScrollEvent(gestureEvent);
- // Non-scrolling related gesture events instead do a single cross-frame hit-test and
- // jump directly to the inner most frame. This matches handleMousePressEvent etc.
-
// Hit test across all frames and do touch adjustment as necessary for the event type.
GestureEventWithHitTestResults targetedEvent = targetGestureEvent(gestureEvent);
+ return handleGestureEvent(targetedEvent);
+}
+
+bool EventHandler::handleGestureEvent(const GestureEventWithHitTestResults& targetedEvent)
+{
+ TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
+
+ // Propagation to inner frames is handled below this function.
+ ASSERT(m_frame == m_frame->localFrameRoot());
+
+ // Non-scrolling related gesture events do a single cross-frame hit-test and jump
+ // directly to the inner most frame. This matches handleMousePressEvent etc.
+ ASSERT(!targetedEvent.event().isScrollEvent());
+
// Route to the correct frame.
if (LocalFrame* innerFrame = targetedEvent.hitTestResult().innerNodeFrame())
return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
{
ASSERT(!targetedEvent.event().isScrollEvent());
- RefPtrWillBeRawPtr<Node> eventTarget = targetedEvent.hitTestResult().targetNode();
+ RefPtrWillBeRawPtr<Node> eventTarget = targetedEvent.hitTestResult().innerNode();
RefPtr<Scrollbar> scrollbar = targetedEvent.hitTestResult().scrollbar();
const PlatformGestureEvent& gestureEvent = targetedEvent.event();
bool EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
{
+ TRACE_EVENT0("input", "EventHandler::handleGestureScrollEvent");
+
RefPtrWillBeRawPtr<Node> eventTarget = nullptr;
RefPtr<Scrollbar> scrollbar;
if (gestureEvent.type() != PlatformEvent::GestureScrollBegin) {
m_previousGestureScrolledNode = nullptr;
if (!scrollbar)
- scrollbar = view->scrollbarAtPoint(gestureEvent.position());
- if (!scrollbar)
scrollbar = result.scrollbar();
}
{
RefPtr<FrameView> protector(m_frame->view());
const PlatformGestureEvent& gestureEvent = targetedEvent.event();
+ HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
// could have seen the event anyway).
// FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
if (currentHitTest.innerNode())
- currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, HitTestRequest::ReadOnly);
+ currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
m_clickNode = currentHitTest.innerNode();
if (m_clickNode && m_clickNode->isTextNode())
m_clickNode = NodeRenderingTraversal::parent(m_clickNode.get());
// FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
if (currentHitTest.innerNode())
- currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, HitTestRequest::ReadOnly);
+ currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
PlatformMouseEvent fakeMouseUp(adjustedPoint, gestureEvent.globalPosition(),
LeftButton, PlatformEvent::MouseReleased, gestureEvent.tapCount(),
modifiers, PlatformMouseEvent::FromTouch, gestureEvent.timestamp());
m_longTapShouldInvokeContextMenu = false;
if (m_frame->settings() && m_frame->settings()->touchDragDropEnabled() && m_frame->view()) {
PlatformMouseEvent mouseDownEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MousePressed, 1,
- gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), WTF::currentTime());
+ gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), PlatformMouseEvent::FromTouch, WTF::currentTime());
m_mouseDown = mouseDownEvent;
PlatformMouseEvent mouseDragEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MouseMoved, 1,
- gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), WTF::currentTime());
+ gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), PlatformMouseEvent::FromTouch, WTF::currentTime());
HitTestRequest request(HitTestRequest::ReadOnly);
MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseDragEvent);
m_didStartDrag = false;
if (shouldLongPressSelectWord) {
IntPoint hitTestPoint = m_frame->view()->windowToContents(gestureEvent.position());
HitTestResult result = hitTestResultAtPoint(hitTestPoint);
- Node* innerNode = result.targetNode();
+ Node* innerNode = result.innerNode();
if (!result.isLiveLink() && innerNode && (innerNode->isContentEditable() || innerNode->isTextNode())) {
selectClosestWordFromHitTestResult(result, DontAppendTrailingWhitespace);
if (m_frame->selection().isRange()) {
GestureEventWithHitTestResults EventHandler::targetGestureEvent(const PlatformGestureEvent& gestureEvent, bool readOnly)
{
+ TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
+
ASSERT(m_frame == m_frame->localFrameRoot());
// Scrolling events get hit tested per frame (like wheel events do).
ASSERT(!gestureEvent.isScrollEvent());
hitType |= HitTestRequest::ReadOnly;
}
- // Perform the rect-based hit-test. Note that we don't yet apply hover/active state here
- // because we need to resolve touch adjustment first so that we apply hover/active it to
- // the final adjusted node.
+ // Perform the rect-based hit-test (or point-based if adjustment is disabled). Note that
+ // we don't yet apply hover/active state here because we need to resolve touch adjustment
+ // first so that we apply hover/active it to the final adjusted node.
IntPoint hitTestPoint = m_frame->view()->windowToContents(gestureEvent.position());
- IntSize touchRadius = gestureEvent.area();
- touchRadius.scale(1.f / 2);
- // FIXME: We should not do a rect-based hit-test if touch adjustment is disabled.
- HitTestResult hitTestResult = hitTestResultAtPoint(hitTestPoint, hitType | HitTestRequest::ReadOnly, touchRadius);
-
- // Hit-test the main frame scrollbars (in addition to the child-frame and RenderLayer
- // scroll bars checked by the hit-test code.
- if (!hitTestResult.scrollbar()) {
- if (FrameView* view = m_frame->view()) {
- hitTestResult.setScrollbar(view->scrollbarAtPoint(gestureEvent.position()));
- }
+ LayoutSize padding;
+ if (shouldApplyTouchAdjustment(gestureEvent)) {
+ padding = gestureEvent.area();
+ padding.scale(1.f / 2);
}
+ HitTestResult hitTestResult = hitTestResultAtPoint(hitTestPoint, hitType | HitTestRequest::ReadOnly, padding);
// Adjust the location of the gesture to the most likely nearby node, as appropriate for the
// type of event.
if (!hitFrame)
hitFrame = m_frame;
hitTestResult = hitTestResultInFrame(hitFrame, hitFrame->view()->windowToContents(adjustedEvent.position()), hitType | HitTestRequest::ReadOnly);
- // FIXME: HitTest entry points should really check for main frame scrollbars themselves.
- if (!hitTestResult.scrollbar()) {
- if (FrameView* view = m_frame->view()) {
- hitTestResult.setScrollbar(view->scrollbarAtPoint(gestureEvent.position()));
- }
- }
}
+ // If we did a rect-based hit test it must be resolved to the best single node by now to
+ // ensure consumers don't accidentally use one of the other candidates.
+ ASSERT(!hitTestResult.isRectBasedTest());
+
// Now apply hover/active state to the final target.
// FIXME: This is supposed to send mouseenter/mouseleave events, but doesn't because we
// aren't passing a PlatformMouseEvent.
HitTestRequest::HitTestRequestType EventHandler::getHitTypeForGestureType(PlatformEvent::Type type)
{
- HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent | HitTestRequest::AllowFrameScrollbars;
+ HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent;
switch (type) {
case PlatformEvent::GestureShowPress:
case PlatformEvent::GestureTapUnconfirmed:
// FIXME: In the editable case, word selection sometimes selects content that isn't underneath the mouse.
// If the selection is non-editable, we do word selection to make it easier to use the contextual menu items
// available for text selections. But only if we're above text.
- && (m_frame->selection().isContentEditable() || (mev.targetNode() && mev.targetNode()->isTextNode()))) {
+ && (m_frame->selection().isContentEditable() || (mev.innerNode() && mev.innerNode()->isTextNode()))) {
m_mouseDownMayStartSelect = true; // context menu events are always allowed to perform a selection
if (mev.hitTestResult().isMisspelled())
selectClosestWordOrLinkFromMouseEvent(mev);
}
- return !dispatchMouseEvent(EventTypeNames::contextmenu, mev.targetNode(), 0, event, false);
+ return !dispatchMouseEvent(EventTypeNames::contextmenu, mev.innerNode(), 0, event, false);
}
bool EventHandler::sendContextMenuEventForKey()
PlatformEvent::Type eventType = PlatformEvent::MousePressed;
#endif
- PlatformMouseEvent mouseEvent(position, globalPosition, RightButton, eventType, 1, false, false, false, false, WTF::currentTime());
+ PlatformMouseEvent mouseEvent(position, globalPosition, RightButton, eventType, 1, false, false, false, false, PlatformMouseEvent::RealOrIndistinguishable, WTF::currentTime());
handleMousePressEvent(mouseEvent);
return sendContextMenuEvent(mouseEvent);
PlatformEvent::Type eventType = PlatformEvent::MousePressed;
#endif
- PlatformMouseEvent mouseEvent(targetedEvent.event().position(), targetedEvent.event().globalPosition(), RightButton, eventType, 1, false, false, false, false, WTF::currentTime());
+ PlatformMouseEvent mouseEvent(targetedEvent.event().position(), targetedEvent.event().globalPosition(), RightButton, eventType, 1, false, false, false, false, PlatformMouseEvent::FromTouch, WTF::currentTime());
// To simulate right-click behavior, we send a right mouse down and then
// context menu event.
// FIXME: Send HitTestResults to avoid redundant hit tests.
bool altKey;
bool metaKey;
PlatformKeyboardEvent::getCurrentModifierState(shiftKey, ctrlKey, altKey, metaKey);
- PlatformMouseEvent fakeMouseMoveEvent(m_lastKnownMousePosition, m_lastKnownMouseGlobalPosition, NoButton, PlatformEvent::MouseMoved, 0, shiftKey, ctrlKey, altKey, metaKey, currentTime());
+ PlatformMouseEvent fakeMouseMoveEvent(m_lastKnownMousePosition, m_lastKnownMouseGlobalPosition, NoButton, PlatformEvent::MouseMoved, 0, shiftKey, ctrlKey, altKey, metaKey, PlatformMouseEvent::RealOrIndistinguishable, currentTime());
handleMouseMoveEvent(fakeMouseMoveEvent);
}
m_lastDeferredTapElement = nullptr;
}
+void EventHandler::notifySelectionChanged()
+{
+ m_selectionInitiationState = ExtendedSelection;
+}
+
bool EventHandler::handleAccessKey(const PlatformKeyboardEvent& evt)
{
// FIXME: Ignoring the state of Shift key is what neither IE nor Firefox do.
return true;
}
-bool EventHandler::isKeyEventAllowedInFullScreen(FullscreenElementStack* fullscreen, const PlatformKeyboardEvent& keyEvent) const
+bool EventHandler::isKeyEventAllowedInFullScreen(Fullscreen* fullscreen, const PlatformKeyboardEvent& keyEvent) const
{
if (fullscreen->webkitFullScreenKeyboardInputAllowed())
return true;
RefPtr<FrameView> protector(m_frame->view());
ASSERT(m_frame->document());
- if (FullscreenElementStack* fullscreen = FullscreenElementStack::fromIfExists(*m_frame->document())) {
- if (fullscreen->webkitIsFullScreen() && !isKeyEventAllowedInFullScreen(fullscreen, initialKeyEvent)) {
+ if (Fullscreen* fullscreen = Fullscreen::fromIfExists(*m_frame->document())) {
+ if (fullscreen->webkitCurrentFullScreenElement() && !isKeyEventAllowedInFullScreen(fullscreen, initialKeyEvent)) {
UseCounter::count(*m_frame->document(), UseCounter::KeyEventNotAllowedInFullScreen);
return false;
}
DragController& dragController = m_frame->page()->dragController();
if (!dragController.populateDragDataTransfer(m_frame, dragState(), m_mouseDownPos))
return false;
+
+ // If dispatching dragstart brings about another mouse down -- one way
+ // this will happen is if a DevTools user breaks within a dragstart
+ // handler and then clicks on the suspended page -- the drag state is
+ // reset. Hence, need to check if this particular drag operation can
+ // continue even if dispatchEvent() indicates no (direct) cancellation.
+ // Do that by checking if m_dragSrc is still set.
m_mouseDownMayStartDrag = dispatchDragSrcEvent(EventTypeNames::dragstart, m_mouseDown)
- && !m_frame->selection().isInPasswordField();
+ && !m_frame->selection().isInPasswordField() && dragState().m_dragSrc;
// Invalidate clipboard here against anymore pasteboard writing for security. The drag
// image can still be changed as we drag, but not the pasteboard data.
bool EventHandler::passMousePressEventToScrollbar(MouseEventWithHitTestResults& mev)
{
- // First try to use the frame scrollbar.
- FrameView* view = m_frame->view();
- Scrollbar* scrollbar = view ? view->scrollbarAtPoint(mev.event().position()) : 0;
-
- // Then try the scrollbar in the hit test.
- if (!scrollbar)
- scrollbar = mev.scrollbar();
-
+ Scrollbar* scrollbar = mev.scrollbar();
updateLastScrollbarUnderMouse(scrollbar, true);
if (!scrollbar || !scrollbar->enabled())
if (!frame || !frame->contentRenderer())
return result;
if (frame->view()) {
- IntRect rect = frame->view()->visibleContentRect();
+ IntRect rect = frame->view()->visibleContentRect(IncludeScrollbars);
if (!rect.contains(roundedIntPoint(point)))
return result;
}
IntPoint p = m_frame->view()->windowToContents(mev.event().position());
if (m_frame->selection().contains(p)) {
VisiblePosition visiblePos(
- mev.targetNode()->renderer()->positionForPoint(mev.localPoint()));
+ mev.innerNode()->renderer()->positionForPoint(mev.localPoint()));
VisibleSelection newSelection(visiblePos);
m_frame->selection().setSelection(newSelection);
}
bool EventHandler::passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults& event)
{
// Figure out which view to send the event to.
- if (!event.targetNode() || !event.targetNode()->renderer() || !event.targetNode()->renderer()->isWidget())
+ if (!event.innerNode() || !event.innerNode()->renderer() || !event.innerNode()->renderer()->isWidget())
return false;
return false;
}
projects / platform / framework / web / crosswalk.git / blobdiff