spatnav: Allow focus move to a close-by not-fully-aligned node over a distant but fully-aligned nod…

Source/core/page/SpatialNavigation.cpp

 /*
  * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Antonio Gomes <tonikitoo@webkit.org>
  *
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 41 matching lines @@
 static bool isRectInDirection(FocusType, const LayoutRect&, const LayoutRect&);
 static void deflateIfOverlapped(LayoutRect&, LayoutRect&);
 static LayoutRect rectToAbsoluteCoordinates(LocalFrame* initialFrame, const LayoutRect&);
 static bool isScrollableNode(const Node*);
 
 FocusCandidate::FocusCandidate(Node* node, FocusType type)
     : visibleNode(nullptr)
     , focusableNode(nullptr)
     , enclosingScrollableBox(nullptr)
     , distance(maxDistance())
-    , alignment(None)
     , isOffscreen(true)
     , isOffscreenAfterScrolling(true)
 {
     ASSERT(node);
     ASSERT(node->isElementNode());
 
     if (isHTMLAreaElement(*node)) {
         HTMLAreaElement& area = toHTMLAreaElement(*node);
         HTMLImageElement* image = area.imageElement();
         if (!image || !image->renderer())
@@ skipping 564 matching lines @@
         return false;
 
     return true;
 }
 
 void distanceDataForNode(FocusType type, const FocusCandidate& current, FocusCandidate& candidate)
 {
     if (areElementsOnSameLine(current, candidate)) {
         if ((type == FocusTypeUp && current.rect.y() > candidate.rect.y()) || (type == FocusTypeDown && candidate.rect.y() > current.rect.y())) {
             candidate.distance = 0;
-            candidate.alignment = Full;
             return;
         }
     }
 
     LayoutRect nodeRect = candidate.rect;
     LayoutRect currentRect = current.rect;
     deflateIfOverlapped(currentRect, nodeRect);
 
     if (!isRectInDirection(type, currentRect, nodeRect))
         return;
@@ skipping 25 matching lines @@
     }
 
     double euclidianDistancePow2 = (xAxis * xAxis + yAxis * yAxis).toDouble();
     LayoutRect intersectionRect = intersection(currentRect, nodeRect);
     double overlap = (intersectionRect.width() * intersectionRect.height()).toDouble();
 
     // Distance calculation is based on http://www.w3.org/TR/WICD/#focus-handling
     candidate.distance = sqrt(euclidianDistancePow2) + navigationAxisDistance+ orthogonalAxisDistance * 2 - sqrt(overlap);
 
     LayoutSize viewSize = LayoutSize(candidate.visibleNode->document().page()->deprecatedLocalMainFrame()->view()->visibleContentRect().size());
-    candidate.alignment = alignmentForRects(type, currentRect, nodeRect, viewSize);
+    RectsAlignment alignment = alignmentForRects(type, currentRect, nodeRect, viewSize);

[fs, 2014/12/15 11:36:09]

Should the weights be applied to (one of) the components of the distance
calculation (above) rather than to the "compound expression"?

[c.shu, 2014/12/15 18:17:37]

The distance calculation at L688 is based on the spec. Then I did the hack based
on alignment result. The weights are determined by some experimental tests. It
will be great if we can come up a better algorithm and integrate with the
calculation above.

[fs, 2014/12/16 13:15:42]

The link at L687 does not lead to a spec - it leads to a note =) (see red box
just at the top of it.) That being said, it doesn't hurt to read the section
about the distance calculation to see the motivation for the different parts -
it could probably even help in this case.

I.e you may change this calculation any way you want - we're after all pretty
far into heuristics-land here.
The WICD distance calculation includes a weight already as I understand - the
'2' that's applied to |orthogonalAxisDistance|, so it feels like that could be a
good starting point for further tweaking.

+    if (alignment == None) {
+        if (type == FocusTypeLeft || type == FocusTypeRight)
+            candidate.distance *= 4;
+        else
+            candidate.distance *= 1.5;
+    } else if (alignment == Partial) {
+        if (type == FocusTypeLeft || type == FocusTypeRight)
+            candidate.distance *= 2;
+        else
+            candidate.distance *= 1.2;
+    }
 }
 
 bool canBeScrolledIntoView(FocusType type, const FocusCandidate& candidate)
 {
     ASSERT(candidate.visibleNode && candidate.isOffscreen);
     LayoutRect candidateRect = candidate.rect;
     for (Node* parentNode = candidate.visibleNode->parentNode(); parentNode; parentNode = parentNode->parentNode()) {
         LayoutRect parentRect = nodeRectInAbsoluteCoordinates(parentNode);
         if (!candidateRect.intersects(parentRect)) {
             if (((type == FocusTypeLeft || type == FocusTypeRight) && parentNode->renderer()->style()->overflowX() == OHIDDEN)
@@ skipping 43 matching lines @@
     LayoutRect rect = virtualRectForDirection(type, rectToAbsoluteCoordinates(area.document().frame(), area.computeRect(area.imageElement()->renderer())), 1);
     return rect;
 }
 
 HTMLFrameOwnerElement* frameOwnerElement(FocusCandidate& candidate)
 {
     return candidate.isFrameOwnerElement() ? toHTMLFrameOwnerElement(candidate.visibleNode) : nullptr;
 };
 
 } // namespace blink