void EventDispatcher::dispatchSimulatedClick(Node* node, Event* underlyingEvent, SimulatedClickMouseEventOptions mouseEventOptions, SimulatedClickVisualOptions visualOptions) { if (isDisabledFormControl(node)) return; if (!gNodesDispatchingSimulatedClicks) gNodesDispatchingSimulatedClicks = new HashSet<Node*>; else if (gNodesDispatchingSimulatedClicks->contains(node)) return; gNodesDispatchingSimulatedClicks->add(node); if (mouseEventOptions == SendMouseOverUpDownEvents) EventDispatcher(node, SimulatedMouseEvent::create(eventNames().mouseoverEvent, node->document()->defaultView(), underlyingEvent)).dispatch(); if (mouseEventOptions != SendNoEvents) EventDispatcher(node, SimulatedMouseEvent::create(eventNames().mousedownEvent, node->document()->defaultView(), underlyingEvent)).dispatch(); node->setActive(true, visualOptions == ShowPressedLook); if (mouseEventOptions != SendNoEvents) EventDispatcher(node, SimulatedMouseEvent::create(eventNames().mouseupEvent, node->document()->defaultView(), underlyingEvent)).dispatch(); node->setActive(false); // always send click EventDispatcher(node, SimulatedMouseEvent::create(eventNames().clickEvent, node->document()->defaultView(), underlyingEvent)).dispatch(); gNodesDispatchingSimulatedClicks->remove(node); }
void EventDispatcher::dispatchSimulatedClick(Node& node, Event* underlyingEvent, SimulatedClickMouseEventOptions mouseEventOptions, SimulatedClickCreationScope creationScope) { // This persistent vector doesn't cause leaks, because added Nodes are removed // before dispatchSimulatedClick() returns. This vector is here just to prevent // the code from running into an infinite recursion of dispatchSimulatedClick(). DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WillBeHeapHashSet<RawPtrWillBeMember<Node>>>, nodesDispatchingSimulatedClicks, (adoptPtrWillBeNoop(new WillBeHeapHashSet<RawPtrWillBeMember<Node>>()))); if (isDisabledFormControl(&node)) return; if (nodesDispatchingSimulatedClicks->contains(&node)) return; nodesDispatchingSimulatedClicks->add(&node); if (mouseEventOptions == SendMouseOverUpDownEvents) EventDispatcher(node, MouseEvent::create(EventTypeNames::mouseover, node.document().domWindow(), underlyingEvent, creationScope)).dispatch(); if (mouseEventOptions != SendNoEvents) { EventDispatcher(node, MouseEvent::create(EventTypeNames::mousedown, node.document().domWindow(), underlyingEvent, creationScope)).dispatch(); node.setActive(true); EventDispatcher(node, MouseEvent::create(EventTypeNames::mouseup, node.document().domWindow(), underlyingEvent, creationScope)).dispatch(); } // Some elements (e.g. the color picker) may set active state to true before // calling this method and expect the state to be reset during the call. node.setActive(false); // always send click EventDispatcher(node, MouseEvent::create(EventTypeNames::click, node.document().domWindow(), underlyingEvent, creationScope)).dispatch(); nodesDispatchingSimulatedClicks->remove(&node); }
void EventDispatcher::dispatchSimulatedClick(Node* node, Event* underlyingEvent, SimulatedClickMouseEventOptions mouseEventOptions) { if (isDisabledFormControl(node)) return; if (!gNodesDispatchingSimulatedClicks) gNodesDispatchingSimulatedClicks = new HashSet<Node*>; else if (gNodesDispatchingSimulatedClicks->contains(node)) return; gNodesDispatchingSimulatedClicks->add(node); if (mouseEventOptions == SendMouseOverUpDownEvents) EventDispatcher(node, SimulatedMouseEvent::create(EventTypeNames::mouseover, node->document().domWindow(), underlyingEvent)).dispatch(); if (mouseEventOptions != SendNoEvents) EventDispatcher(node, SimulatedMouseEvent::create(EventTypeNames::mousedown, node->document().domWindow(), underlyingEvent)).dispatch(); node->setActive(true); if (mouseEventOptions != SendNoEvents) EventDispatcher(node, SimulatedMouseEvent::create(EventTypeNames::mouseup, node->document().domWindow(), underlyingEvent)).dispatch(); node->setActive(false); // always send click EventDispatcher(node, SimulatedMouseEvent::create(EventTypeNames::click, node->document().domWindow(), underlyingEvent)).dispatch(); gNodesDispatchingSimulatedClicks->remove(node); }
bool HTMLPlugInElement::willRespondToMouseClickEvents() { if (isDisabledFormControl()) return false; RenderObject* r = renderer(); return r && (r->isEmbeddedObject() || r->isWidget()); }
bool GestureEventDispatchMediator::dispatchEvent(EventDispatcher* dispatcher) const { if (isDisabledFormControl(dispatcher->node())) return true; dispatcher->dispatch(); ASSERT(!event()->defaultPrevented()); return event()->defaultHandled() || event()->defaultPrevented(); }
DispatchEventResult MouseEventDispatchMediator::dispatchEvent( EventDispatcher& dispatcher) const { MouseEvent& mouseEvent = event(); mouseEvent.eventPath().adjustForRelatedTarget(dispatcher.node(), mouseEvent.relatedTarget()); if (!mouseEvent.isTrusted()) return dispatcher.dispatch(); if (isDisabledFormControl(&dispatcher.node())) return DispatchEventResult::CanceledBeforeDispatch; if (mouseEvent.type().isEmpty()) return DispatchEventResult::NotCanceled; // Shouldn't happen. DCHECK(!mouseEvent.target() || mouseEvent.target() != mouseEvent.relatedTarget()); EventTarget* relatedTarget = mouseEvent.relatedTarget(); DispatchEventResult dispatchResult = dispatcher.dispatch(); if (mouseEvent.type() != EventTypeNames::click || mouseEvent.detail() != 2) return dispatchResult; // Special case: If it's a double click event, we also send the dblclick // event. This is not part of the DOM specs, but is used for compatibility // with the ondblclick="" attribute. This is treated as a separate event in // other DOM-compliant browsers like Firefox, and so we do the same. MouseEvent* doubleClickEvent = MouseEvent::create(); doubleClickEvent->initMouseEventInternal( EventTypeNames::dblclick, mouseEvent.bubbles(), mouseEvent.cancelable(), mouseEvent.view(), mouseEvent.detail(), mouseEvent.screenX(), mouseEvent.screenY(), mouseEvent.clientX(), mouseEvent.clientY(), mouseEvent.modifiers(), mouseEvent.button(), relatedTarget, mouseEvent.sourceCapabilities(), mouseEvent.buttons()); doubleClickEvent->setComposed(mouseEvent.composed()); // Inherit the trusted status from the original event. doubleClickEvent->setTrusted(mouseEvent.isTrusted()); if (mouseEvent.defaultHandled()) doubleClickEvent->setDefaultHandled(); DispatchEventResult doubleClickDispatchResult = EventDispatcher::dispatchEvent( dispatcher.node(), MouseEventDispatchMediator::create(doubleClickEvent)); if (doubleClickDispatchResult != DispatchEventResult::NotCanceled) return doubleClickDispatchResult; return dispatchResult; }
DispatchEventResult PointerEventDispatchMediator::dispatchEvent( EventDispatcher& dispatcher) const { if (isDisabledFormControl(&dispatcher.node())) return DispatchEventResult::CanceledBeforeDispatch; if (event().type().isEmpty()) return DispatchEventResult::NotCanceled; // Shouldn't happen. DCHECK(!event().target() || event().target() != event().relatedTarget()); event().eventPath().adjustForRelatedTarget(dispatcher.node(), event().relatedTarget()); return dispatcher.dispatch(); }
void HTMLButtonElement::defaultEventHandler(Event* event) { if (event->type() == eventNames().DOMActivateEvent && !isDisabledFormControl()) { if (form() && m_type == SUBMIT) { m_isActivatedSubmit = true; form()->prepareForSubmission(event); event->setDefaultHandled(); m_isActivatedSubmit = false; // Do this in case submission was canceled. } if (form() && m_type == RESET) { form()->reset(); event->setDefaultHandled(); } } if (is<KeyboardEvent>(*event)) { KeyboardEvent& keyboardEvent = downcast<KeyboardEvent>(*event); if (keyboardEvent.type() == eventNames().keydownEvent && keyboardEvent.keyIdentifier() == "U+0020") { setActive(true, true); // No setDefaultHandled() - IE dispatches a keypress in this case. return; } if (keyboardEvent.type() == eventNames().keypressEvent) { switch (keyboardEvent.charCode()) { case '\r': dispatchSimulatedClick(&keyboardEvent); keyboardEvent.setDefaultHandled(); return; case ' ': // Prevent scrolling down the page. keyboardEvent.setDefaultHandled(); return; } } if (keyboardEvent.type() == eventNames().keyupEvent && keyboardEvent.keyIdentifier() == "U+0020") { if (active()) dispatchSimulatedClick(&keyboardEvent); keyboardEvent.setDefaultHandled(); return; } } HTMLFormControlElement::defaultEventHandler(event); }
void HTMLButtonElement::defaultEventHandler(Event* event) { if (event->type() == EventTypeNames::DOMActivate && !isDisabledFormControl()) { if (form() && m_type == SUBMIT) { m_isActivatedSubmit = true; form()->prepareForSubmission(event); event->setDefaultHandled(); m_isActivatedSubmit = false; // Do this in case submission was canceled. } if (form() && m_type == RESET) { form()->reset(); event->setDefaultHandled(); } } if (event->isKeyboardEvent()) { if (event->type() == EventTypeNames::keydown && toKeyboardEvent(event)->keyIdentifier() == "U+0020") { setActive(true); // No setDefaultHandled() - IE dispatches a keypress in this case. return; } if (event->type() == EventTypeNames::keypress) { switch (toKeyboardEvent(event)->charCode()) { case '\r': dispatchSimulatedClick(event); event->setDefaultHandled(); return; case ' ': // Prevent scrolling down the page. event->setDefaultHandled(); return; } } if (event->type() == EventTypeNames::keyup && toKeyboardEvent(event)->keyIdentifier() == "U+0020") { if (active()) dispatchSimulatedClick(event); event->setDefaultHandled(); return; } } HTMLFormControlElement::defaultEventHandler(event); }
bool MouseEventDispatchMediator::dispatchEvent(EventDispatcher& dispatcher) const { MouseEvent& mouseEvent = event(); if (!mouseEvent.isTrusted()) { mouseEvent.eventPath().adjustForRelatedTarget(dispatcher.node(), mouseEvent.relatedTarget()); return dispatcher.dispatch(); } if (isDisabledFormControl(&dispatcher.node())) return false; if (mouseEvent.type().isEmpty()) return true; // Shouldn't happen. ASSERT(!mouseEvent.target() || mouseEvent.target() != mouseEvent.relatedTarget()); EventTarget* relatedTarget = mouseEvent.relatedTarget(); mouseEvent.eventPath().adjustForRelatedTarget(dispatcher.node(), relatedTarget); dispatcher.dispatch(); bool swallowEvent = mouseEvent.defaultHandled() || mouseEvent.defaultPrevented(); if (mouseEvent.type() != EventTypeNames::click || mouseEvent.detail() != 2) return !swallowEvent; // Special case: If it's a double click event, we also send the dblclick event. This is not part // of the DOM specs, but is used for compatibility with the ondblclick="" attribute. This is treated // as a separate event in other DOM-compliant browsers like Firefox, and so we do the same. RefPtrWillBeRawPtr<MouseEvent> doubleClickEvent = MouseEvent::create(); doubleClickEvent->initMouseEventInternal(EventTypeNames::dblclick, mouseEvent.bubbles(), mouseEvent.cancelable(), mouseEvent.view(), mouseEvent.detail(), mouseEvent.screenX(), mouseEvent.screenY(), mouseEvent.clientX(), mouseEvent.clientY(), mouseEvent.modifiers(), mouseEvent.button(), relatedTarget, mouseEvent.sourceCapabilities(), mouseEvent.buttons()); // Inherit the trusted status from the original event. doubleClickEvent->setTrusted(mouseEvent.isTrusted()); if (mouseEvent.defaultHandled()) doubleClickEvent->setDefaultHandled(); EventDispatcher::dispatchEvent(dispatcher.node(), MouseEventDispatchMediator::create(doubleClickEvent)); if (doubleClickEvent->defaultHandled() || doubleClickEvent->defaultPrevented()) return false; return !swallowEvent; }
bool MouseEventDispatchMediator::dispatchEvent(EventDispatcher* dispatcher) const { if (isSyntheticMouseEvent()) { event()->eventPath().adjustForRelatedTarget(dispatcher->node(), event()->relatedTarget()); return dispatcher->dispatch(); } if (isDisabledFormControl(dispatcher->node())) return false; if (event()->type().isEmpty()) return true; // Shouldn't happen. ASSERT(!event()->target() || event()->target() != event()->relatedTarget()); EventTarget* relatedTarget = event()->relatedTarget(); event()->eventPath().adjustForRelatedTarget(dispatcher->node(), relatedTarget); dispatcher->dispatch(); bool swallowEvent = event()->defaultHandled() || event()->defaultPrevented(); if (event()->type() != EventTypeNames::click || event()->detail() != 2) return !swallowEvent; // Special case: If it's a double click event, we also send the dblclick event. This is not part // of the DOM specs, but is used for compatibility with the ondblclick="" attribute. This is treated // as a separate event in other DOM-compliant browsers like Firefox, and so we do the same. RefPtr<MouseEvent> doubleClickEvent = MouseEvent::create(); doubleClickEvent->initMouseEvent(EventTypeNames::dblclick, event()->bubbles(), event()->cancelable(), event()->view(), event()->detail(), event()->screenX(), event()->screenY(), event()->clientX(), event()->clientY(), event()->ctrlKey(), event()->altKey(), event()->shiftKey(), event()->metaKey(), event()->button(), relatedTarget); if (event()->defaultHandled()) doubleClickEvent->setDefaultHandled(); EventDispatcher::dispatchEvent(dispatcher->node(), MouseEventDispatchMediator::create(doubleClickEvent)); if (doubleClickEvent->defaultHandled() || doubleClickEvent->defaultPrevented()) return false; return !swallowEvent; }
bool SliderThumbElement::shouldAcceptTouchEvents() { return renderer() && !isDisabledFormControl(); }
bool HTMLButtonElement::isSuccessfulSubmitButton() const { // HTML spec says that buttons must have names to be considered successful. // However, other browsers do not impose this constraint. return m_type == SUBMIT && !isDisabledFormControl(); }
bool HTMLButtonElement::willRespondToMouseClickEvents() { return !isDisabledFormControl(); }
bool HTMLFieldSetElement::supportsFocus() const { return HTMLElement::supportsFocus() && !isDisabledFormControl(); }
bool HTMLButtonElement::willRespondToMouseClickEvents() { if (!isDisabledFormControl() && form() && (m_type == SUBMIT || m_type == RESET)) return true; return HTMLFormControlElement::willRespondToMouseClickEvents(); }