bool EventHandler::passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults& event)
{
// Figure out which view to send the event to.
if (!targetNode(event) || !targetNode(event)->renderer() || !targetNode(event)->renderer()->isWidget())
return false;
return passMouseDownEventToWidget(toRenderWidget(targetNode(event)->renderer())->widget());
}
/******************************************************************************
* Computes the largest time interval containing the given time during which the
* controller's value is constant.
******************************************************************************/
TimeInterval LookAtController::validityInterval(TimePoint time)
{
TimeInterval iv(TimeInterval::infinite());
if(rollController())
iv.intersect(rollController()->validityInterval(time));
if(targetNode())
targetNode()->getWorldTransform(time, iv);
return iv;
}
bool EventHandler::passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults& event)
{
RenderObject* target = targetNode(event) ? targetNode(event)->renderer() : 0;
if (!target || !target->isWidget())
return false;
return passMouseDownEventToWidget(static_cast<RenderWidget*>(target)->widget());
}
bool HitTestResult::isMisspelled() const
{
if (!targetNode() || !targetNode()->renderer())
return false;
VisiblePosition pos(targetNode()->renderer()->positionForPoint(localPoint()));
if (pos.isNull())
return false;
return m_innerNonSharedNode->document().markers().markersInRange(
makeRange(pos, pos).get(), DocumentMarker::MisspellingMarkers()).size() > 0;
}
void
FocusManager::NotifyOfDOMBlur(nsISupports* aTarget)
{
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eFocus))
logging::FocusNotificationTarget("DOM blur", "Target", aTarget);
#endif
mActiveItem = nullptr;
// If DOM document stays focused then fire accessible focus event to process
// the case when no element within this DOM document will be focused.
nsCOMPtr<nsINode> targetNode(do_QueryInterface(aTarget));
if (targetNode && targetNode->OwnerDoc() == FocusedDOMDocument()) {
nsIDocument* DOMDoc = targetNode->OwnerDoc();
DocAccessible* document =
GetAccService()->GetDocAccessible(DOMDoc);
if (document) {
// Clear selection listener for previously focused element.
if (targetNode->IsElement())
SelectionMgr()->ClearControlSelectionListener();
document->HandleNotification<FocusManager, nsINode>
(this, &FocusManager::ProcessDOMFocus, DOMDoc);
}
}
}
void QmlAnchors::beautify()
{
return;
if ((instanceHasAnchor(AnchorLine::Left) &&
instanceHasAnchor(AnchorLine::Right) &&
instanceHasAnchor(AnchorLine::Top) &&
instanceHasAnchor(AnchorLine::Bottom)) &&
(instanceAnchor(AnchorLine::Left).type() == AnchorLine::Left &&
instanceAnchor(AnchorLine::Right).type() == AnchorLine::Right &&
instanceAnchor(AnchorLine::Top).type() == AnchorLine::Top &&
instanceAnchor(AnchorLine::Bottom).type() == AnchorLine::Bottom) &&
(instanceAnchor(AnchorLine::Left).qmlItemNode() ==
instanceAnchor(AnchorLine::Right).qmlItemNode() &&
instanceAnchor(AnchorLine::Top).qmlItemNode() ==
instanceAnchor(AnchorLine::Bottom).qmlItemNode()) &&
(instanceAnchor(AnchorLine::Left).qmlItemNode() ==
instanceAnchor(AnchorLine::Bottom).qmlItemNode())) {
if (instanceHasAnchor(AnchorLine::Fill))
return; //avoid recursion
QmlItemNode targetNode(instanceAnchor(AnchorLine::Left).qmlItemNode());
removeAnchors();
setAnchor(AnchorLine::Fill, targetNode, AnchorLine::Fill);
}
if ((instanceHasAnchor(AnchorLine::VerticalCenter) &&
instanceHasAnchor(AnchorLine::HorizontalCenter)) &&
(instanceAnchor(AnchorLine::VerticalCenter).type() == AnchorLine::VerticalCenter &&
instanceAnchor(AnchorLine::HorizontalCenter).type() == AnchorLine::HorizontalCenter) &&
(instanceAnchor(AnchorLine::VerticalCenter).qmlItemNode() ==
instanceAnchor(AnchorLine::HorizontalCenter).qmlItemNode())) {
if (instanceHasAnchor(AnchorLine::Center))
return; //avoid recursion
QmlItemNode targetNode(instanceAnchor(AnchorLine::VerticalCenter).qmlItemNode());
removeAnchors();
setAnchor(AnchorLine::Center, targetNode, AnchorLine::Center);
}
}
void RecursiveCFGBuilder::visit(ShPtr<GotoStmt> stmt) {
cfg->stmtNodeMapping[stmt] = currNode;
currNode->stmts.push_back(stmt);
if (ShPtr<Statement> gotoTarget = stmt->getTarget()) {
ShPtr<CFG::Node> currNodeBackup(currNode);
ShPtr<CFG::Node> targetNode(addNode(gotoTarget));
cfg->addEdge(currNodeBackup, targetNode);
}
}
NS_IMETHODIMP
nsXULTooltipListener::MouseOut(nsIDOMEvent* aMouseEvent)
{
// Clear the cached mouse event as it might hold a window alive too long, see
// bug 420803.
mCachedMouseEvent = nsnull;
// if the timer is running and no tooltip is shown, we
// have to cancel the timer here so that it doesn't
// show the tooltip if we move the mouse out of the window
nsCOMPtr<nsIContent> currentTooltip = do_QueryReferent(mCurrentTooltip);
if (mTooltipTimer && !currentTooltip) {
mTooltipTimer->Cancel();
mTooltipTimer = nsnull;
return NS_OK;
}
#ifdef DEBUG_crap
if (mNeedTitletip)
return NS_OK;
#endif
// check to see if the mouse left the targetNode, and if so,
// hide the tooltip
if (currentTooltip) {
// which node did the mouse leave?
nsCOMPtr<nsIDOMEventTarget> eventTarget;
aMouseEvent->GetTarget(getter_AddRefs(eventTarget));
nsCOMPtr<nsIDOMNode> targetNode(do_QueryInterface(eventTarget));
// which node is our tooltip on?
nsCOMPtr<nsIDOMXULDocument> xulDoc(do_QueryInterface(currentTooltip->GetDocument()));
if (!xulDoc) // remotely possible someone could have
return NS_OK; // removed tooltip from dom while it was open
nsCOMPtr<nsIDOMNode> tooltipNode;
xulDoc->TrustedGetTooltipNode (getter_AddRefs(tooltipNode));
// if they're the same, the mouse left the node the tooltip appeared on,
// close the tooltip.
if (tooltipNode == targetNode) {
HideTooltip();
#ifdef MOZ_XUL
// reset special tree tracking
if (mIsSourceTree) {
mLastTreeRow = -1;
mLastTreeCol = nsnull;
}
#endif
}
}
return NS_OK;
}
void AnchorTool::checkIfStillHovering()
{
AnchorLineHandleItem *anchorLineHandleItem = topAnchorLineHandleItem(scene()->items(m_lastMousePosition));
if (anchorLineHandleItem && anchorLineHandleItem == m_lastAnchorLineHandleItem) {
FormEditorItem *sourceFormEditItem = anchorLineHandleItem->anchorLineController().formEditorItem();
QmlAnchors anchors(sourceFormEditItem->qmlItemNode().anchors());
if (anchors.instanceHasAnchor(anchorLineHandleItem->anchorLine())) {
QmlItemNode targetNode(anchors.instanceAnchor(anchorLineHandleItem->anchorLine()).qmlItemNode());
FormEditorItem *targetFormEditorItem = scene()->itemForQmlItemNode(targetNode);
targetFormEditorItem->showAttention();
}
}
}
bool EventHandler::passMousePressEventToSubframe(MouseEventWithHitTestResults& mev, Frame* subframe)
{
// If we're clicking into a frame that is selected, the frame will appear
// greyed out even though we're clicking on the selection. This looks
// really strange (having the whole frame be greyed out), so we deselect the
// selection.
IntPoint p = m_frame->view()->windowToContents(mev.event().pos());
if (m_frame->selection()->contains(p)) {
VisiblePosition visiblePos(
targetNode(mev)->renderer()->positionForPoint(mev.localPoint()));
VisibleSelection newSelection(visiblePos);
if (m_frame->selection()->shouldChangeSelection(newSelection))
m_frame->selection()->setSelection(newSelection);
}
subframe->eventHandler()->handleMousePressEvent(mev.event());
return true;
}
NS_IMETHODIMP
nsXFormsHintHelpListener::HandleEvent(nsIDOMEvent* aEvent)
{
if (!aEvent)
return NS_ERROR_UNEXPECTED;
nsCOMPtr<nsIDOMEventTarget> target;
aEvent->GetCurrentTarget(getter_AddRefs(target));
nsCOMPtr<nsIDOMNode> targetNode(do_QueryInterface(target));
if (nsXFormsUtils::EventHandlingAllowed(aEvent, targetNode)) {
nsCOMPtr<nsIDOMKeyEvent> keyEvent(do_QueryInterface(aEvent));
if (keyEvent) {
PRUint32 code = 0;
keyEvent->GetKeyCode(&code);
if (code == nsIDOMKeyEvent::DOM_VK_F1) {
PRBool defaultEnabled = PR_TRUE;
nsresult rv = nsXFormsUtils::DispatchEvent(targetNode, eEvent_Help,
&defaultEnabled);
// If the xforms event's default behavior was disabled, prevent the DOM
// event's default action as well. This means that the F1 key was
// handled (a help dialog was shown) and we don't want the browser to
// show it's help dialog.
if (NS_SUCCEEDED(rv) && !defaultEnabled)
aEvent->PreventDefault();
}
} else {
nsAutoString type;
aEvent->GetType(type);
nsXFormsUtils::DispatchEvent(targetNode,
(type.EqualsLiteral("mouseover") ||
type.EqualsLiteral("focus"))
? eEvent_Hint : eEvent_MozHintOff);
}
}
return NS_OK;
}
void
FocusManager::NotifyOfDOMFocus(nsISupports* aTarget)
{
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eFocus))
logging::FocusNotificationTarget("DOM focus", "Target", aTarget);
#endif
mActiveItem = nullptr;
nsCOMPtr<nsINode> targetNode(do_QueryInterface(aTarget));
if (targetNode) {
DocAccessible* document =
GetAccService()->GetDocAccessible(targetNode->OwnerDoc());
if (document) {
// Set selection listener for focused element.
if (targetNode->IsElement())
SelectionMgr()->SetControlSelectionListener(targetNode->AsElement());
document->HandleNotification<FocusManager, nsINode>
(this, &FocusManager::ProcessDOMFocus, targetNode);
}
}
}
bool
TouchManager::PreHandleEvent(WidgetEvent* aEvent,
nsEventStatus* aStatus,
bool& aTouchIsNew,
bool& aIsHandlingUserInput,
nsCOMPtr<nsIContent>& aCurrentEventContent)
{
switch (aEvent->mMessage) {
case eTouchStart: {
aIsHandlingUserInput = true;
WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
// if there is only one touch in this touchstart event, assume that it is
// the start of a new touch session and evict any old touches in the
// queue
if (touchEvent->mTouches.Length() == 1) {
WidgetTouchEvent::AutoTouchArray touches;
AppendToTouchList(&touches);
for (uint32_t i = 0; i < touches.Length(); ++i) {
EvictTouchPoint(touches[i]);
}
}
// Add any new touches to the queue
for (uint32_t i = 0; i < touchEvent->mTouches.Length(); ++i) {
Touch* touch = touchEvent->mTouches[i];
int32_t id = touch->Identifier();
if (!sCaptureTouchList->Get(id, nullptr)) {
// If it is not already in the queue, it is a new touch
touch->mChanged = true;
}
touch->mMessage = aEvent->mMessage;
TouchInfo info = { touch, GetNonAnonymousAncestor(touch->mTarget) };
sCaptureTouchList->Put(id, info);
}
break;
}
case eTouchMove: {
// Check for touches that changed. Mark them add to queue
WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
bool haveChanged = false;
for (int32_t i = touches.Length(); i; ) {
--i;
Touch* touch = touches[i];
if (!touch) {
continue;
}
int32_t id = touch->Identifier();
touch->mMessage = aEvent->mMessage;
TouchInfo info;
if (!sCaptureTouchList->Get(id, &info)) {
touches.RemoveElementAt(i);
continue;
}
RefPtr<Touch> oldTouch = info.mTouch;
if (!touch->Equals(oldTouch)) {
touch->mChanged = true;
haveChanged = true;
}
nsCOMPtr<EventTarget> targetPtr = oldTouch->mTarget;
if (!targetPtr) {
touches.RemoveElementAt(i);
continue;
}
nsCOMPtr<nsINode> targetNode(do_QueryInterface(targetPtr));
if (!targetNode->IsInComposedDoc()) {
targetPtr = do_QueryInterface(info.mNonAnonymousTarget);
}
touch->SetTarget(targetPtr);
info.mTouch = touch;
// info.mNonAnonymousTarget is still valid from above
sCaptureTouchList->Put(id, info);
// if we're moving from touchstart to touchmove for this touch
// we allow preventDefault to prevent mouse events
if (oldTouch->mMessage != touch->mMessage) {
aTouchIsNew = true;
}
}
// is nothing has changed, we should just return
if (!haveChanged) {
if (aTouchIsNew) {
// however, if this is the first touchmove after a touchstart,
// it is special in that preventDefault is allowed on it, so
// we must dispatch it to content even if nothing changed. we
// arbitrarily pick the first touch point to be the "changed"
// touch because firing an event with no changed events doesn't
// work.
for (uint32_t i = 0; i < touchEvent->mTouches.Length(); ++i) {
if (touchEvent->mTouches[i]) {
touchEvent->mTouches[i]->mChanged = true;
break;
}
}
} else {
return false;
}
}
break;
}
case eTouchEnd:
aIsHandlingUserInput = true;
// Fall through to touchcancel code
MOZ_FALLTHROUGH;
case eTouchCancel: {
// Remove the changed touches
// need to make sure we only remove touches that are ending here
WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
for (uint32_t i = 0; i < touches.Length(); ++i) {
Touch* touch = touches[i];
if (!touch) {
continue;
}
touch->mMessage = aEvent->mMessage;
touch->mChanged = true;
int32_t id = touch->Identifier();
TouchInfo info;
if (!sCaptureTouchList->Get(id, &info)) {
continue;
}
nsCOMPtr<EventTarget> targetPtr = info.mTouch->mTarget;
nsCOMPtr<nsINode> targetNode(do_QueryInterface(targetPtr));
if (targetNode && !targetNode->IsInComposedDoc()) {
targetPtr = do_QueryInterface(info.mNonAnonymousTarget);
}
aCurrentEventContent = do_QueryInterface(targetPtr);
touch->SetTarget(targetPtr);
sCaptureTouchList->Remove(id);
}
// add any touches left in the touch list, but ensure changed=false
AppendToTouchList(&touches);
break;
}
default:
break;
}
return true;
}
