michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "PositionedEventTargeting.h"
michael@0: 
michael@0: #include "mozilla/EventListenerManager.h"
michael@0: #include "mozilla/EventStates.h"
michael@0: #include "mozilla/MouseEvents.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: #include "nsLayoutUtils.h"
michael@0: #include "nsGkAtoms.h"
michael@0: #include "nsPrintfCString.h"
michael@0: #include "mozilla/dom/Element.h"
michael@0: #include "nsRegion.h"
michael@0: #include "nsDeviceContext.h"
michael@0: #include "nsIFrame.h"
michael@0: #include <algorithm>
michael@0: 
michael@0: namespace mozilla {
michael@0: 
michael@0: /*
michael@0:  * The basic goal of FindFrameTargetedByInputEvent() is to find a good
michael@0:  * target element that can respond to mouse events. Both mouse events and touch
michael@0:  * events are targeted at this element. Note that even for touch events, we
michael@0:  * check responsiveness to mouse events. We assume Web authors
michael@0:  * designing for touch events will take their own steps to account for
michael@0:  * inaccurate touch events.
michael@0:  *
michael@0:  * IsElementClickable() encapsulates the heuristic that determines whether an
michael@0:  * element is expected to respond to mouse events. An element is deemed
michael@0:  * "clickable" if it has registered listeners for "click", "mousedown" or
michael@0:  * "mouseup", or is on a whitelist of element tags (<a>, <button>, <input>,
michael@0:  * <select>, <textarea>, <label>), or has role="button", or is a link, or
michael@0:  * is a suitable XUL element.
michael@0:  * Any descendant (in the same document) of a clickable element is also
michael@0:  * deemed clickable since events will propagate to the clickable element from its
michael@0:  * descendant.
michael@0:  *
michael@0:  * If the element directly under the event position is clickable (or
michael@0:  * event radii are disabled), we always use that element. Otherwise we collect
michael@0:  * all frames intersecting a rectangle around the event position (taking CSS
michael@0:  * transforms into account) and choose the best candidate in GetClosest().
michael@0:  * Only IsElementClickable() candidates are considered; if none are found,
michael@0:  * then we revert to targeting the element under the event position.
michael@0:  * We ignore candidates outside the document subtree rooted by the
michael@0:  * document of the element directly under the event position. This ensures that
michael@0:  * event listeners in ancestor documents don't make it completely impossible
michael@0:  * to target a non-clickable element in a child document.
michael@0:  *
michael@0:  * When both a frame and its ancestor are in the candidate list, we ignore
michael@0:  * the ancestor. Otherwise a large ancestor element with a mouse event listener
michael@0:  * and some descendant elements that need to be individually targetable would
michael@0:  * disable intelligent targeting of those descendants within its bounds.
michael@0:  *
michael@0:  * GetClosest() computes the transformed axis-aligned bounds of each
michael@0:  * candidate frame, then computes the Manhattan distance from the event point
michael@0:  * to the bounds rect (which can be zero). The frame with the
michael@0:  * shortest distance is chosen. For visited links we multiply the distance
michael@0:  * by a specified constant weight; this can be used to make visited links
michael@0:  * more or less likely to be targeted than non-visited links.
michael@0:  */
michael@0: 
michael@0: struct EventRadiusPrefs
michael@0: {
michael@0:   uint32_t mVisitedWeight; // in percent, i.e. default is 100
michael@0:   uint32_t mSideRadii[4]; // TRBL order, in millimetres
michael@0:   bool mEnabled;
michael@0:   bool mRegistered;
michael@0:   bool mTouchOnly;
michael@0: };
michael@0: 
michael@0: static EventRadiusPrefs sMouseEventRadiusPrefs;
michael@0: static EventRadiusPrefs sTouchEventRadiusPrefs;
michael@0: 
michael@0: static const EventRadiusPrefs*
michael@0: GetPrefsFor(nsEventStructType aEventStructType)
michael@0: {
michael@0:   EventRadiusPrefs* prefs = nullptr;
michael@0:   const char* prefBranch = nullptr;
michael@0:   if (aEventStructType == NS_TOUCH_EVENT) {
michael@0:     prefBranch = "touch";
michael@0:     prefs = &sTouchEventRadiusPrefs;
michael@0:   } else if (aEventStructType == NS_MOUSE_EVENT) {
michael@0:     // Mostly for testing purposes
michael@0:     prefBranch = "mouse";
michael@0:     prefs = &sMouseEventRadiusPrefs;
michael@0:   } else {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   if (!prefs->mRegistered) {
michael@0:     prefs->mRegistered = true;
michael@0: 
michael@0:     nsPrintfCString enabledPref("ui.%s.radius.enabled", prefBranch);
michael@0:     Preferences::AddBoolVarCache(&prefs->mEnabled, enabledPref.get(), false);
michael@0: 
michael@0:     nsPrintfCString visitedWeightPref("ui.%s.radius.visitedWeight", prefBranch);
michael@0:     Preferences::AddUintVarCache(&prefs->mVisitedWeight, visitedWeightPref.get(), 100);
michael@0: 
michael@0:     static const char prefNames[4][9] =
michael@0:       { "topmm", "rightmm", "bottommm", "leftmm" };
michael@0:     for (int32_t i = 0; i < 4; ++i) {
michael@0:       nsPrintfCString radiusPref("ui.%s.radius.%s", prefBranch, prefNames[i]);
michael@0:       Preferences::AddUintVarCache(&prefs->mSideRadii[i], radiusPref.get(), 0);
michael@0:     }
michael@0: 
michael@0:     if (aEventStructType == NS_MOUSE_EVENT) {
michael@0:       Preferences::AddBoolVarCache(&prefs->mTouchOnly,
michael@0:           "ui.mouse.radius.inputSource.touchOnly", true);
michael@0:     } else {
michael@0:       prefs->mTouchOnly = false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return prefs;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: HasMouseListener(nsIContent* aContent)
michael@0: {
michael@0:   if (EventListenerManager* elm = aContent->GetExistingListenerManager()) {
michael@0:     return elm->HasListenersFor(nsGkAtoms::onclick) ||
michael@0:            elm->HasListenersFor(nsGkAtoms::onmousedown) ||
michael@0:            elm->HasListenersFor(nsGkAtoms::onmouseup);
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: static bool gTouchEventsRegistered = false;
michael@0: static int32_t gTouchEventsEnabled = 0;
michael@0: 
michael@0: static bool
michael@0: HasTouchListener(nsIContent* aContent)
michael@0: {
michael@0:   EventListenerManager* elm = aContent->GetExistingListenerManager();
michael@0:   if (!elm) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (!gTouchEventsRegistered) {
michael@0:     Preferences::AddIntVarCache(&gTouchEventsEnabled,
michael@0:       "dom.w3c_touch_events.enabled", gTouchEventsEnabled);
michael@0:     gTouchEventsRegistered = true;
michael@0:   }
michael@0: 
michael@0:   if (!gTouchEventsEnabled) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return elm->HasListenersFor(nsGkAtoms::ontouchstart) ||
michael@0:          elm->HasListenersFor(nsGkAtoms::ontouchend);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: IsElementClickable(nsIFrame* aFrame, nsIAtom* stopAt = nullptr)
michael@0: {
michael@0:   // Input events propagate up the content tree so we'll follow the content
michael@0:   // ancestors to look for elements accepting the click.
michael@0:   for (nsIContent* content = aFrame->GetContent(); content;
michael@0:        content = content->GetFlattenedTreeParent()) {
michael@0:     nsIAtom* tag = content->Tag();
michael@0:     if (content->IsHTML() && stopAt && tag == stopAt) {
michael@0:       break;
michael@0:     }
michael@0:     if (HasTouchListener(content) || HasMouseListener(content)) {
michael@0:       return true;
michael@0:     }
michael@0:     if (content->IsHTML()) {
michael@0:       if (tag == nsGkAtoms::button ||
michael@0:           tag == nsGkAtoms::input ||
michael@0:           tag == nsGkAtoms::select ||
michael@0:           tag == nsGkAtoms::textarea ||
michael@0:           tag == nsGkAtoms::label) {
michael@0:         return true;
michael@0:       }
michael@0:       // Bug 921928: we don't have access to the content of remote iframe.
michael@0:       // So fluffing won't go there. We do an optimistic assumption here:
michael@0:       // that the content of the remote iframe needs to be a target.
michael@0:       if (tag == nsGkAtoms::iframe &&
michael@0:           content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::mozbrowser,
michael@0:                                nsGkAtoms::_true, eIgnoreCase) &&
michael@0:           content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::Remote,
michael@0:                                nsGkAtoms::_true, eIgnoreCase)) {
michael@0:         return true;
michael@0:       }
michael@0:     } else if (content->IsXUL()) {
michael@0:       nsIAtom* tag = content->Tag();
michael@0:       // See nsCSSFrameConstructor::FindXULTagData. This code is not
michael@0:       // really intended to be used with XUL, though.
michael@0:       if (tag == nsGkAtoms::button ||
michael@0:           tag == nsGkAtoms::checkbox ||
michael@0:           tag == nsGkAtoms::radio ||
michael@0:           tag == nsGkAtoms::autorepeatbutton ||
michael@0:           tag == nsGkAtoms::menu ||
michael@0:           tag == nsGkAtoms::menubutton ||
michael@0:           tag == nsGkAtoms::menuitem ||
michael@0:           tag == nsGkAtoms::menulist ||
michael@0:           tag == nsGkAtoms::scrollbarbutton ||
michael@0:           tag == nsGkAtoms::resizer) {
michael@0:         return true;
michael@0:       }
michael@0:     }
michael@0:     static nsIContent::AttrValuesArray clickableRoles[] =
michael@0:       { &nsGkAtoms::button, &nsGkAtoms::key, nullptr };
michael@0:     if (content->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::role,
michael@0:                                  clickableRoles, eIgnoreCase) >= 0) {
michael@0:       return true;
michael@0:     }
michael@0:     if (content->IsEditable()) {
michael@0:       return true;
michael@0:     }
michael@0:     nsCOMPtr<nsIURI> linkURI;
michael@0:     if (content->IsLink(getter_AddRefs(linkURI))) {
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: static nscoord
michael@0: AppUnitsFromMM(nsIFrame* aFrame, uint32_t aMM, bool aVertical)
michael@0: {
michael@0:   nsPresContext* pc = aFrame->PresContext();
michael@0:   float result = float(aMM) *
michael@0:     (pc->DeviceContext()->AppUnitsPerPhysicalInch() / MM_PER_INCH_FLOAT);
michael@0:   return NSToCoordRound(result);
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Clip aRect with the bounds of aFrame in the coordinate system of
michael@0:  * aRootFrame. aRootFrame is an ancestor of aFrame.
michael@0:  */
michael@0: static nsRect
michael@0: ClipToFrame(nsIFrame* aRootFrame, nsIFrame* aFrame, nsRect& aRect)
michael@0: {
michael@0:   nsRect bound = nsLayoutUtils::TransformFrameRectToAncestor(
michael@0:     aFrame, nsRect(nsPoint(0, 0), aFrame->GetSize()), aRootFrame);
michael@0:   nsRect result = bound.Intersect(aRect);
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: static nsRect
michael@0: GetTargetRect(nsIFrame* aRootFrame, const nsPoint& aPointRelativeToRootFrame,
michael@0:               nsIFrame* aRestrictToDescendants, const EventRadiusPrefs* aPrefs)
michael@0: {
michael@0:   nsMargin m(AppUnitsFromMM(aRootFrame, aPrefs->mSideRadii[0], true),
michael@0:              AppUnitsFromMM(aRootFrame, aPrefs->mSideRadii[1], false),
michael@0:              AppUnitsFromMM(aRootFrame, aPrefs->mSideRadii[2], true),
michael@0:              AppUnitsFromMM(aRootFrame, aPrefs->mSideRadii[3], false));
michael@0:   nsRect r(aPointRelativeToRootFrame, nsSize(0,0));
michael@0:   r.Inflate(m);
michael@0:   return ClipToFrame(aRootFrame, aRestrictToDescendants, r);
michael@0: }
michael@0: 
michael@0: static float
michael@0: ComputeDistanceFromRect(const nsPoint& aPoint, const nsRect& aRect)
michael@0: {
michael@0:   nscoord dx = std::max(0, std::max(aRect.x - aPoint.x, aPoint.x - aRect.XMost()));
michael@0:   nscoord dy = std::max(0, std::max(aRect.y - aPoint.y, aPoint.y - aRect.YMost()));
michael@0:   return float(NS_hypot(dx, dy));
michael@0: }
michael@0: 
michael@0: static float
michael@0: ComputeDistanceFromRegion(const nsPoint& aPoint, const nsRegion& aRegion)
michael@0: {
michael@0:   MOZ_ASSERT(!aRegion.IsEmpty(), "can't compute distance between point and empty region");
michael@0:   nsRegionRectIterator iter(aRegion);
michael@0:   const nsRect* r;
michael@0:   float minDist = -1;
michael@0:   while ((r = iter.Next()) != nullptr) {
michael@0:     float dist = ComputeDistanceFromRect(aPoint, *r);
michael@0:     if (dist < minDist || minDist < 0) {
michael@0:       minDist = dist;
michael@0:     }
michael@0:   }
michael@0:   return minDist;
michael@0: }
michael@0: 
michael@0: // Subtract aRegion from aExposedRegion as long as that doesn't make the
michael@0: // exposed region get too complex or removes a big chunk of the exposed region.
michael@0: static void
michael@0: SubtractFromExposedRegion(nsRegion* aExposedRegion, const nsRegion& aRegion)
michael@0: {
michael@0:   if (aRegion.IsEmpty())
michael@0:     return;
michael@0: 
michael@0:   nsRegion tmp;
michael@0:   tmp.Sub(*aExposedRegion, aRegion);
michael@0:   // Don't let *aExposedRegion get too complex, but don't let it fluff out to
michael@0:   // its bounds either. Do let aExposedRegion get more complex if by doing so
michael@0:   // we reduce its area by at least half.
michael@0:   if (tmp.GetNumRects() <= 15 || tmp.Area() <= aExposedRegion->Area()/2) {
michael@0:     *aExposedRegion = tmp;
michael@0:   }
michael@0: }
michael@0: 
michael@0: static nsIFrame*
michael@0: GetClosest(nsIFrame* aRoot, const nsPoint& aPointRelativeToRootFrame,
michael@0:            const nsRect& aTargetRect, const EventRadiusPrefs* aPrefs,
michael@0:            nsIFrame* aRestrictToDescendants, nsTArray<nsIFrame*>& aCandidates)
michael@0: {
michael@0:   nsIFrame* bestTarget = nullptr;
michael@0:   // Lower is better; distance is in appunits
michael@0:   float bestDistance = 1e6f;
michael@0:   nsRegion exposedRegion(aTargetRect);
michael@0:   for (uint32_t i = 0; i < aCandidates.Length(); ++i) {
michael@0:     nsIFrame* f = aCandidates[i];
michael@0: 
michael@0:     bool preservesAxisAlignedRectangles = false;
michael@0:     nsRect borderBox = nsLayoutUtils::TransformFrameRectToAncestor(f,
michael@0:         nsRect(nsPoint(0, 0), f->GetSize()), aRoot, &preservesAxisAlignedRectangles);
michael@0:     nsRegion region;
michael@0:     region.And(exposedRegion, borderBox);
michael@0: 
michael@0:     if (region.IsEmpty()) {
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     if (preservesAxisAlignedRectangles) {
michael@0:       // Subtract from the exposed region if we have a transform that won't make
michael@0:       // the bounds include a bunch of area that we don't actually cover.
michael@0:       SubtractFromExposedRegion(&exposedRegion, region);
michael@0:     }
michael@0: 
michael@0:     if (!IsElementClickable(f)) {
michael@0:       continue;
michael@0:     }
michael@0:     // If our current closest frame is a descendant of 'f', skip 'f' (prefer
michael@0:     // the nested frame).
michael@0:     if (bestTarget && nsLayoutUtils::IsProperAncestorFrameCrossDoc(f, bestTarget, aRoot)) {
michael@0:       continue;
michael@0:     }
michael@0:     if (!nsLayoutUtils::IsAncestorFrameCrossDoc(aRestrictToDescendants, f, aRoot)) {
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     // distance is in appunits
michael@0:     float distance = ComputeDistanceFromRegion(aPointRelativeToRootFrame, region);
michael@0:     nsIContent* content = f->GetContent();
michael@0:     if (content && content->IsElement() &&
michael@0:         content->AsElement()->State().HasState(
michael@0:                                         EventStates(NS_EVENT_STATE_VISITED))) {
michael@0:       distance *= aPrefs->mVisitedWeight / 100.0f;
michael@0:     }
michael@0:     if (distance < bestDistance) {
michael@0:       bestDistance = distance;
michael@0:       bestTarget = f;
michael@0:     }
michael@0:   }
michael@0:   return bestTarget;
michael@0: }
michael@0: 
michael@0: nsIFrame*
michael@0: FindFrameTargetedByInputEvent(const WidgetGUIEvent* aEvent,
michael@0:                               nsIFrame* aRootFrame,
michael@0:                               const nsPoint& aPointRelativeToRootFrame,
michael@0:                               uint32_t aFlags)
michael@0: {
michael@0:   uint32_t flags = (aFlags & INPUT_IGNORE_ROOT_SCROLL_FRAME) ?
michael@0:      nsLayoutUtils::IGNORE_ROOT_SCROLL_FRAME : 0;
michael@0:   nsIFrame* target =
michael@0:     nsLayoutUtils::GetFrameForPoint(aRootFrame, aPointRelativeToRootFrame, flags);
michael@0: 
michael@0:   const EventRadiusPrefs* prefs = GetPrefsFor(aEvent->eventStructType);
michael@0:   if (!prefs || !prefs->mEnabled || (target && IsElementClickable(target, nsGkAtoms::body))) {
michael@0:     return target;
michael@0:   }
michael@0: 
michael@0:   // Do not modify targeting for actual mouse hardware; only for mouse
michael@0:   // events generated by touch-screen hardware.
michael@0:   if (aEvent->eventStructType == NS_MOUSE_EVENT &&
michael@0:       prefs->mTouchOnly &&
michael@0:       aEvent->AsMouseEvent()->inputSource !=
michael@0:         nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) {
michael@0:     return target;
michael@0:   }
michael@0: 
michael@0:   // If the exact target is non-null, only consider candidate targets in the same
michael@0:   // document as the exact target. Otherwise, if an ancestor document has
michael@0:   // a mouse event handler for example, targets that are !IsElementClickable can
michael@0:   // never be targeted --- something nsSubDocumentFrame in an ancestor document
michael@0:   // would be targeted instead.
michael@0:   nsIFrame* restrictToDescendants = target ?
michael@0:     target->PresContext()->PresShell()->GetRootFrame() : aRootFrame;
michael@0: 
michael@0:   nsRect targetRect = GetTargetRect(aRootFrame, aPointRelativeToRootFrame,
michael@0:                                     restrictToDescendants, prefs);
michael@0:   nsAutoTArray<nsIFrame*,8> candidates;
michael@0:   nsresult rv = nsLayoutUtils::GetFramesForArea(aRootFrame, targetRect, candidates, flags);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     return target;
michael@0:   }
michael@0: 
michael@0:   nsIFrame* closestClickable =
michael@0:     GetClosest(aRootFrame, aPointRelativeToRootFrame, targetRect, prefs,
michael@0:                restrictToDescendants, candidates);
michael@0:   return closestClickable ? closestClickable : target;
michael@0: }
michael@0: 
michael@0: }