bool Scrollbar::mouseMoved(const PlatformMouseEvent& evt)
{
if (m_pressedPart == ThumbPart) {
if (theme()->shouldSnapBackToDragOrigin(this, evt)) {
if (m_scrollableArea)
m_scrollableArea->scrollToOffsetWithoutAnimation(m_orientation, m_dragOrigin);
} else {
moveThumb(m_orientation == HorizontalScrollbar ?
convertFromContainingWindow(evt.position()).x() :
convertFromContainingWindow(evt.position()).y(), theme()->shouldDragDocumentInsteadOfThumb(this, evt));
}
return true;
}
if (m_pressedPart != NoPart)
m_pressedPos = (orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y());
ScrollbarPart part = theme()->hitTest(this, evt.position());
if (part != m_hoveredPart) {
if (m_pressedPart != NoPart) {
if (part == m_pressedPart) {
// The mouse is moving back over the pressed part. We
// need to start up the timer action again.
startTimerIfNeeded(theme()->autoscrollTimerDelay());
theme()->invalidatePart(this, m_pressedPart);
} else if (m_hoveredPart == m_pressedPart) {
// The mouse is leaving the pressed part. Kill our timer
// if needed.
stopTimerIfNeeded();
theme()->invalidatePart(this, m_pressedPart);
}
}
setHoveredPart(part);
}
return true;
}
void AutoscrollController::handleMouseReleaseForPanScrolling(LocalFrame* frame, const PlatformMouseEvent& mouseEvent)
{
if (!frame->isMainFrame())
return;
switch (m_autoscrollType) {
case AutoscrollForPan:
if (mouseEvent.button() == MiddleButton)
m_autoscrollType = AutoscrollForPanCanStop;
break;
case AutoscrollForPanCanStop:
stopAutoscroll();
break;
}
}
bool InspectorOverlay::handleMouseMove(const PlatformMouseEvent& event) {
if (!shouldSearchForNode())
return false;
LocalFrame* frame = m_frameImpl->frame();
if (!frame || !frame->view() || frame->contentLayoutItem().isNull())
return false;
Node* node = hoveredNodeForEvent(frame, event, event.shiftKey());
// Do not highlight within user agent shadow root unless requested.
if (m_inspectMode != InspectorDOMAgent::SearchingForUAShadow) {
ShadowRoot* shadowRoot = InspectorDOMAgent::userAgentShadowRoot(node);
if (shadowRoot)
node = &shadowRoot->host();
}
// Shadow roots don't have boxes - use host element instead.
if (node && node->isShadowRoot())
node = node->parentOrShadowHostNode();
if (!node)
return true;
Node* eventTarget =
event.shiftKey() ? hoveredNodeForEvent(frame, event, false) : nullptr;
if (eventTarget == node)
eventTarget = nullptr;
if (node && m_inspectModeHighlightConfig) {
m_hoveredNodeForInspectMode = node;
if (m_domAgent)
m_domAgent->nodeHighlightedInOverlay(node);
highlightNode(node, eventTarget, *m_inspectModeHighlightConfig,
event.ctrlKey() || event.metaKey());
}
return true;
}
void Scrollbar::mouseMoved(const PlatformMouseEvent& evt)
{
if (m_pressedPart == ThumbPart) {
if (theme().shouldSnapBackToDragOrigin(*this, evt)) {
if (m_scrollableArea) {
m_scrollableArea->setScrollPositionSingleAxis(m_orientation, m_dragOrigin + m_scrollableArea->minimumScrollPosition(m_orientation), UserScroll);
}
} else {
moveThumb(m_orientation == HorizontalScrollbar
? convertFromRootFrame(evt.position()).x()
: convertFromRootFrame(evt.position()).y(), theme().shouldDragDocumentInsteadOfThumb(*this, evt));
}
return;
}
if (m_pressedPart != NoPart)
m_pressedPos = orientation() == HorizontalScrollbar ? convertFromRootFrame(evt.position()).x() : convertFromRootFrame(evt.position()).y();
ScrollbarPart part = theme().hitTest(*this, evt.position());
if (part != m_hoveredPart) {
if (m_pressedPart != NoPart) {
if (part == m_pressedPart) {
// The mouse is moving back over the pressed part. We
// need to start up the timer action again.
startTimerIfNeeded(theme().autoscrollTimerDelay());
} else if (m_hoveredPart == m_pressedPart) {
// The mouse is leaving the pressed part. Kill our timer
// if needed.
stopTimerIfNeeded();
}
}
setHoveredPart(part);
}
return;
}
void AutoscrollController::handleMouseReleaseForPanScrolling(Frame* frame, const PlatformMouseEvent& mouseEvent)
{
Page* page = frame->page();
if (!page || page->mainFrame() != frame)
return;
switch (m_autoscrollType) {
case AutoscrollForPan:
if (mouseEvent.button() == MiddleButton)
m_autoscrollType = AutoscrollForPanCanStop;
break;
case AutoscrollForPanCanStop:
stopAutoscrollTimer();
break;
}
}
bool PlatformScrollbar::handleMouseReleaseEvent(const PlatformMouseEvent& e)
{
ScrollView* parentView = parent();
if (!parentView)
return true;
IntPoint pos = convertFromContainingWindow(e.pos());
updateMousePosition(pos.x(), pos.y());
setCapturingMouse(false);
// FIXME: Invalidate only the portions that actually changed
invalidate();
return true;
}
void Scrollbar::mouseUp(const PlatformMouseEvent& mouseEvent)
{
setPressedPart(NoPart);
m_pressedPos = 0;
m_draggingDocument = false;
stopTimerIfNeeded();
if (m_scrollableArea) {
// m_hoveredPart won't be updated until the next mouseMoved or mouseDown, so we have to hit test
// to really know if the mouse has exited the scrollbar on a mouseUp.
ScrollbarPart part = theme()->hitTest(this, mouseEvent.position());
if (part == NoPart)
m_scrollableArea->mouseExitedScrollbar(this);
}
}
bool InspectorOverlay::handleInputEvent(const WebInputEvent& inputEvent)
{
bool handled = false;
if (isEmpty())
return false;
if (WebInputEvent::isGestureEventType(inputEvent.type) && inputEvent.type == WebInputEvent::GestureTap) {
// Only let GestureTab in (we only need it and we know PlatformGestureEventBuilder supports it).
PlatformGestureEvent gestureEvent = PlatformGestureEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebGestureEvent&>(inputEvent));
handled = handleGestureEvent(gestureEvent);
if (handled)
return true;
overlayMainFrame()->eventHandler().handleGestureEvent(gestureEvent);
}
if (WebInputEvent::isMouseEventType(inputEvent.type) && inputEvent.type != WebInputEvent::MouseEnter) {
// PlatformMouseEventBuilder does not work with MouseEnter type, so we filter it out manually.
PlatformMouseEvent mouseEvent = PlatformMouseEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebMouseEvent&>(inputEvent));
if (mouseEvent.type() == PlatformEvent::MouseMoved)
handled = handleMouseMove(mouseEvent);
else if (mouseEvent.type() == PlatformEvent::MousePressed)
handled = handleMousePress();
if (handled)
return true;
if (mouseEvent.type() == PlatformEvent::MouseMoved)
handled = overlayMainFrame()->eventHandler().handleMouseMoveEvent(mouseEvent) != WebInputEventResult::NotHandled;
if (mouseEvent.type() == PlatformEvent::MousePressed)
handled = overlayMainFrame()->eventHandler().handleMousePressEvent(mouseEvent) != WebInputEventResult::NotHandled;
if (mouseEvent.type() == PlatformEvent::MouseReleased)
handled = overlayMainFrame()->eventHandler().handleMouseReleaseEvent(mouseEvent) != WebInputEventResult::NotHandled;
}
if (WebInputEvent::isTouchEventType(inputEvent.type)) {
PlatformTouchEvent touchEvent = PlatformTouchEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebTouchEvent&>(inputEvent));
handled = handleTouchEvent(touchEvent);
if (handled)
return true;
overlayMainFrame()->eventHandler().handleTouchEvent(touchEvent);
}
if (WebInputEvent::isKeyboardEventType(inputEvent.type)) {
PlatformKeyboardEvent keyboardEvent = PlatformKeyboardEventBuilder(static_cast<const WebKeyboardEvent&>(inputEvent));
overlayMainFrame()->eventHandler().keyEvent(keyboardEvent);
}
if (inputEvent.type == WebInputEvent::MouseWheel) {
PlatformWheelEvent wheelEvent = PlatformWheelEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebMouseWheelEvent&>(inputEvent));
handled = overlayMainFrame()->eventHandler().handleWheelEvent(wheelEvent) != WebInputEventResult::NotHandled;
}
return handled;
}
void Scrollbar::mouseDown(const PlatformMouseEvent& evt)
{
// Early exit for right click
if (evt.button() == RightButton)
return;
// FIXME(sky): Do we still need setPressedPart now that we only set it to NoPart?
setPressedPart(NoPart);
int pressedPos = orientation() == HorizontalScrollbar ? convertFromContainingView(evt.position()).x() : convertFromContainingView(evt.position()).y();
if (m_pressedPart == ThumbPart)
m_dragOrigin = m_currentPos;
m_pressedPos = pressedPos;
autoscrollPressedPart(initialAutoscrollTimerDelay());
}
bool PlatformScrollbar::handleMouseMoveEvent(const PlatformMouseEvent& e)
{
if (!parent())
return true;
if (m_captureStart != None) {
handleMouseMoveEventWhenCapturing(e);
return true;
}
IntPoint pos = convertFromContainingWindow(e.pos());
updateMousePosition(pos.x(), pos.y());
// FIXME: Invalidate only the portions that actually changed
invalidate();
return true;
}
bool ScrollbarThemeWin::shouldSnapBackToDragOrigin(Scrollbar* scrollbar, const PlatformMouseEvent& evt)
{
// Find the rect within which we shouldn't snap, by expanding the track rect
// in both dimensions.
IntRect rect = trackRect(scrollbar);
const bool horz = scrollbar->orientation() == HorizontalScrollbar;
const int thickness = scrollbarThickness(scrollbar->controlSize());
rect.inflateX((horz ? kOffEndMultiplier : kOffSideMultiplier) * thickness);
rect.inflateY((horz ? kOffSideMultiplier : kOffEndMultiplier) * thickness);
// Convert the event to local coordinates.
IntPoint mousePosition = scrollbar->convertFromContainingWindow(evt.pos());
mousePosition.move(scrollbar->x(), scrollbar->y());
// We should snap iff the event is outside our calculated rect.
return !rect.contains(mousePosition);
}
void Scrollbar::mouseUp(const PlatformMouseEvent& mouseEvent) {
bool isCaptured = m_pressedPart == ThumbPart;
setPressedPart(NoPart);
m_pressedPos = 0;
m_draggingDocument = false;
stopTimerIfNeeded();
if (m_scrollableArea) {
if (isCaptured)
m_scrollableArea->mouseReleasedScrollbar();
// m_hoveredPart won't be updated until the next mouseMoved or mouseDown, so
// we have to hit test to really know if the mouse has exited the scrollbar
// on a mouseUp.
ScrollbarPart part = theme().hitTest(*this, mouseEvent.position());
if (part == NoPart)
m_scrollableArea->mouseExitedScrollbar(*this);
}
}
bool PlatformScrollbar::handleMouseReleaseEvent(const PlatformMouseEvent& evt)
{
const QPoint pos = convertFromContainingWindow(evt.pos());
const QPoint topLeft = m_opt.rect.topLeft();
m_opt.rect.moveTo(QPoint(0, 0));
QStyle::SubControl scAtMousePoint = QApplication::style()->hitTestComplexControl(QStyle::CC_ScrollBar, &m_opt, pos, 0);
m_opt.rect.moveTo(topLeft);
m_hoveredPart = scAtMousePoint;
if (m_hoveredPart == QStyle::SC_None)
m_opt.state &= ~QStyle::State_MouseOver;
m_opt.state &= ~QStyle::State_Sunken;
m_pressedPart = QStyle::SC_None;
m_pressedPos = 0;
stopTimerIfNeeded();
invalidate();
return true;
}
void WebPage::mouseEvent(const PlatformMouseEvent& event)
{
if (!m_mainFrame->coreFrame()->view())
return;
switch (event.eventType()) {
case WebCore::MouseEventPressed:
m_mainFrame->coreFrame()->eventHandler()->handleMousePressEvent(event);
break;
case WebCore::MouseEventReleased:
m_mainFrame->coreFrame()->eventHandler()->handleMouseReleaseEvent(event);
break;
case WebCore::MouseEventMoved:
m_mainFrame->coreFrame()->eventHandler()->mouseMoved(event);
break;
default:
ASSERT_NOT_REACHED();
break;
}
}
bool Scrollbar::mouseUp(const PlatformMouseEvent& mouseEvent)
{
setPressedPart(NoPart);
m_pressedPos = 0;
m_draggingDocument = false;
stopTimerIfNeeded();
if (m_scrollableArea) {
// m_hoveredPart won't be updated until the next mouseMoved or mouseDown, so we have to hit test
// to really know if the mouse has exited the scrollbar on a mouseUp.
ScrollbarPart part = theme()->hitTest(this, mouseEvent.position());
if (part == NoPart)
m_scrollableArea->mouseExitedScrollbar(this);
}
if (parent() && parent()->isFrameView())
static_cast<FrameView*>(parent())->frame()->eventHandler()->setMousePressed(false);
return true;
}
void AutoscrollController::handleMouseReleaseForMiddleClickAutoscroll(
LocalFrame* frame,
const PlatformMouseEvent& mouseEvent) {
DCHECK(RuntimeEnabledFeatures::middleClickAutoscrollEnabled());
if (!frame->isMainFrame())
return;
switch (m_autoscrollType) {
case AutoscrollForMiddleClick:
if (mouseEvent.pointerProperties().button ==
WebPointerProperties::Button::Middle)
m_autoscrollType = AutoscrollForMiddleClickCanStop;
break;
case AutoscrollForMiddleClickCanStop:
stopAutoscroll();
break;
case AutoscrollForDragAndDrop:
case AutoscrollForSelection:
case NoAutoscroll:
// Nothing to do.
break;
}
}
ScrollbarPart ScrollbarThemeComposite::hitTest(ScrollbarThemeClient* scrollbar, const PlatformMouseEvent& evt)
{
ScrollbarPart result = NoPart;
if (!scrollbar->enabled())
return result;
IntPoint mousePosition = scrollbar->convertFromContainingWindow(evt.position());
mousePosition.move(scrollbar->x(), scrollbar->y());
if (!scrollbar->frameRect().contains(mousePosition))
return NoPart;
result = ScrollbarBGPart;
IntRect track = trackRect(scrollbar);
if (track.contains(mousePosition)) {
IntRect beforeThumbRect;
IntRect thumbRect;
IntRect afterThumbRect;
splitTrack(scrollbar, track, beforeThumbRect, thumbRect, afterThumbRect);
if (thumbRect.contains(mousePosition))
result = ThumbPart;
else if (beforeThumbRect.contains(mousePosition))
result = BackTrackPart;
else if (afterThumbRect.contains(mousePosition))
result = ForwardTrackPart;
else
result = TrackBGPart;
} else if (backButtonRect(scrollbar, BackButtonStartPart).contains(mousePosition))
result = BackButtonStartPart;
else if (backButtonRect(scrollbar, BackButtonEndPart).contains(mousePosition))
result = BackButtonEndPart;
else if (forwardButtonRect(scrollbar, ForwardButtonStartPart).contains(mousePosition))
result = ForwardButtonStartPart;
else if (forwardButtonRect(scrollbar, ForwardButtonEndPart).contains(mousePosition))
result = ForwardButtonEndPart;
return result;
}
bool ScrollbarThemeWin::shouldCenterOnThumb(Scrollbar*, const PlatformMouseEvent& evt)
{
return evt.shiftKey() && evt.button() == LeftButton;
}
bool ScrollbarThemeQStyle::shouldCenterOnThumb(ScrollbarThemeClient*, const PlatformMouseEvent& evt)
{
// Middle click centers slider thumb (if supported).
return m_qStyle->scrollBarMiddleClickAbsolutePositionStyleHint() && evt.button() == MiddleButton;
}
bool PlatformScrollbar::handleMousePressEvent(const PlatformMouseEvent& evt)
{
m_pressedPart = hitTest(evt);
m_pressedPos = (m_orientation == HorizontalScrollbar ? convertFromContainingWindow(evt.pos()).x() : convertFromContainingWindow(evt.pos()).y());
invalidatePart(m_pressedPart);
autoscrollPressedPart(cInitialTimerDelay);
return true;
}
bool PlatformScrollbar::handleMouseMoveEvent(const PlatformMouseEvent& evt)
{
if (m_pressedPart == ThumbPart)
{
// Drag the thumb.
int thumbPos = thumbPosition();
int thumbLen = thumbLength();
int trackLen = trackLength();
int maxPos = trackLen - thumbLen;
int delta = 0;
if (m_orientation == HorizontalScrollbar)
delta = convertFromContainingWindow(evt.pos()).x() - m_pressedPos;
else
delta = convertFromContainingWindow(evt.pos()).y() - m_pressedPos;
if (delta > 0)
// The mouse moved down/right.
delta = min(maxPos - thumbPos, delta);
else if (delta < 0)
// The mouse moved up/left.
delta = max(-thumbPos, delta);
if (delta != 0)
{
setValue(static_cast<int>((float)(thumbPos + delta) * (m_totalSize - m_visibleSize) / (trackLen - thumbLen)));
m_pressedPos += thumbPosition() - thumbPos;
}
return true;
}
if (m_pressedPart != NoPart)
m_pressedPos = (m_orientation == HorizontalScrollbar ? convertFromContainingWindow(evt.pos()).x() : convertFromContainingWindow(evt.pos()).y());
ScrollbarPart part = hitTest(evt);
if (part != m_hoveredPart)
{
if (m_pressedPart != NoPart)
{
if (part == m_pressedPart)
{
// The mouse is moving back over the pressed part. We
// need to start up the timer action again.
startTimerIfNeeded(cNormalTimerDelay);
invalidatePart(m_pressedPart);
} else if (m_hoveredPart == m_pressedPart)
{
// The mouse is leaving the pressed part. Kill our timer
// if needed.
stopTimerIfNeeded();
invalidatePart(m_pressedPart);
}
}
else
{
invalidatePart(part);
invalidatePart(m_hoveredPart);
}
m_hoveredPart = part;
}
updateViewOnMouseHover();
return true;
}
PassRefPtr<MouseEvent> MouseEvent::create(const AtomicString& eventType, PassRefPtr<AbstractView> view, const PlatformMouseEvent& event, int detail, PassRefPtr<Node> relatedTarget)
{
ASSERT(event.type() == PlatformEvent::MouseMoved || event.button() != NoButton);
bool isMouseEnterOrLeave = eventType == EventTypeNames::mouseenter || eventType == EventTypeNames::mouseleave;
bool isCancelable = !isMouseEnterOrLeave;
bool isBubbling = !isMouseEnterOrLeave;
return MouseEvent::create(eventType, isBubbling, isCancelable, view,
detail, event.globalPosition().x(), event.globalPosition().y(), event.position().x(), event.position().y(),
event.movementDelta().x(), event.movementDelta().y(),
event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(), event.button(),
relatedTarget, nullptr, false);
}
bool ScrollbarTheme::shouldCenterOnThumb(const ScrollbarThemeClient* scrollbar, const PlatformMouseEvent& evt)
{
return Platform::current()->scrollbarBehavior()->shouldCenterOnThumb(static_cast<WebScrollbarBehavior::Button>(evt.button()), evt.shiftKey(), evt.altKey());
}
bool ScrollbarThemeGtk::shouldCenterOnThumb(ScrollbarThemeClient*, const PlatformMouseEvent& event)
{
return (event.shiftKey() && event.button() == LeftButton) || (event.button() == MiddleButton);
}
bool ScrollbarThemeChromiumLinux::shouldCenterOnThumb(Scrollbar*, const PlatformMouseEvent& evt)
{
return (evt.shiftKey() && evt.button() == LeftButton) || (evt.button() == MiddleButton);
}
Ref<MouseEvent> MouseEvent::create(const AtomicString& eventType, AbstractView* view, const PlatformMouseEvent& event, int detail, PassRefPtr<Node> relatedTarget)
{
bool isMouseEnterOrLeave = eventType == eventNames().mouseenterEvent || eventType == eventNames().mouseleaveEvent;
bool isCancelable = eventType != eventNames().mousemoveEvent && !isMouseEnterOrLeave;
bool canBubble = !isMouseEnterOrLeave;
return MouseEvent::create(eventType, canBubble, isCancelable, event.timestamp(), view,
detail, event.globalPosition().x(), event.globalPosition().y(), event.position().x(), event.position().y(),
#if ENABLE(POINTER_LOCK)
event.movementDelta().x(), event.movementDelta().y(),
#endif
event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(), event.button(),
relatedTarget, event.force(), event.syntheticClickType());
}
bool ScrollbarTheme::shouldSnapBackToDragOrigin(const ScrollbarThemeClient* scrollbar, const PlatformMouseEvent& evt)
{
IntPoint mousePosition = scrollbar->convertFromContainingWindow(evt.position());
mousePosition.move(scrollbar->x(), scrollbar->y());
return Platform::current()->scrollbarBehavior()->shouldSnapBackToDragOrigin(mousePosition, trackRect(scrollbar), scrollbar->orientation() == HorizontalScrollbar);
}
bool EventHandler::eventActivatedView(const PlatformMouseEvent& event) const
{
return event.didActivateWebView();
}
PassRefPtr<MouseEvent> MouseEvent::create(const AtomicString& eventType, PassRefPtr<AbstractView> view, const PlatformMouseEvent& event, int detail, PassRefPtr<Node> relatedTarget)
{
ASSERT(event.eventType() == MouseEventMoved || event.button() != NoButton);
bool isCancelable = eventType != eventNames().mousemoveEvent;
return MouseEvent::create(eventType, true, isCancelable, view,
detail, event.globalX(), event.globalY(), event.x(), event.y(),
event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(), event.button(),
relatedTarget, 0, false);
}
bool ScrollbarThemeQt::shouldCenterOnThumb(Scrollbar*, const PlatformMouseEvent& evt)
{
// Middle click centers slider thumb (if supported)
return QApplication::style()->styleHint(QStyle::SH_ScrollBar_MiddleClickAbsolutePosition) && evt.button() == MiddleButton;
}