Changeset 93270 in webkit


Ignore:
Timestamp:
Aug 17, 2011 5:49:01 PM (13 years ago)
Author:
eae@chromium.org
Message:

Switch focus handling to to new layout types
​https://bugs.webkit.org/show_bug.cgi?id=66331

Reviewed by Eric Seidel.

Convert FocusController and SpatialNavigation to new layout abstraction
as a part of the ongoing conversion work.

No new tests, no new functionality.

  • page/FocusController.cpp:

(WebCore::updateFocusCandidateIfNeeded):
(WebCore::FocusController::findFocusCandidateInContainer):
(WebCore::FocusController::advanceFocusDirectionallyInContainer):
(WebCore::FocusController::advanceFocusDirectionally):

  • page/FocusController.h:
  • page/SpatialNavigation.cpp:

(WebCore::alignmentForRects):
(WebCore::start):
(WebCore::middle):
(WebCore::end):
(WebCore::areRectsFullyAligned):
(WebCore::areRectsPartiallyAligned):
(WebCore::areRectsMoreThanFullScreenApart):
(WebCore::below):
(WebCore::rightOf):
(WebCore::isRectInDirection):
(WebCore::hasOffscreenRect):
(WebCore::scrollInDirection):
(WebCore::deflateIfOverlapped):
(WebCore::canScrollInDirection):
(WebCore::rectToAbsoluteCoordinates):
(WebCore::nodeRectInAbsoluteCoordinates):
(WebCore::frameRectInAbsoluteCoordinates):
(WebCore::entryAndExitPointsForDirection):
(WebCore::distanceDataForNode):
(WebCore::canBeScrolledIntoView):
(WebCore::virtualRectForDirection):
(WebCore::virtualRectForAreaElementAndDirection):

  • page/SpatialNavigation.h:
Location:
trunk/Source/WebCore
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r93269 r93270  
     12011-08-17  Emil A Eklund  <eae@chromium.org>
     2
     3        Switch focus handling to to new layout types
     4        https://bugs.webkit.org/show_bug.cgi?id=66331
     5
     6        Reviewed by Eric Seidel.
     7
     8        Convert FocusController and SpatialNavigation to new layout abstraction
     9        as a part of the ongoing conversion work.
     10
     11        No new tests, no new functionality.
     12
     13        * page/FocusController.cpp:
     14        (WebCore::updateFocusCandidateIfNeeded):
     15        (WebCore::FocusController::findFocusCandidateInContainer):
     16        (WebCore::FocusController::advanceFocusDirectionallyInContainer):
     17        (WebCore::FocusController::advanceFocusDirectionally):
     18        * page/FocusController.h:
     19        * page/SpatialNavigation.cpp:
     20        (WebCore::alignmentForRects):
     21        (WebCore::start):
     22        (WebCore::middle):
     23        (WebCore::end):
     24        (WebCore::areRectsFullyAligned):
     25        (WebCore::areRectsPartiallyAligned):
     26        (WebCore::areRectsMoreThanFullScreenApart):
     27        (WebCore::below):
     28        (WebCore::rightOf):
     29        (WebCore::isRectInDirection):
     30        (WebCore::hasOffscreenRect):
     31        (WebCore::scrollInDirection):
     32        (WebCore::deflateIfOverlapped):
     33        (WebCore::canScrollInDirection):
     34        (WebCore::rectToAbsoluteCoordinates):
     35        (WebCore::nodeRectInAbsoluteCoordinates):
     36        (WebCore::frameRectInAbsoluteCoordinates):
     37        (WebCore::entryAndExitPointsForDirection):
     38        (WebCore::distanceDataForNode):
     39        (WebCore::canBeScrolledIntoView):
     40        (WebCore::virtualRectForDirection):
     41        (WebCore::virtualRectForAreaElementAndDirection):
     42        * page/SpatialNavigation.h:
     43
    1442011-08-17  Levi Weintraub  <leviw@chromium.org>
    245

  • trunk/Source/WebCore/page/FocusController.cpp

    r90004 r93270  
    612612    }
    613613
    614     IntRect intersectionRect = intersection(candidate.rect, closest.rect);
     614    LayoutRect intersectionRect = intersection(candidate.rect, closest.rect);
    615615    if (!intersectionRect.isEmpty() && !areElementsOnSameLine(closest, candidate)) {
    616616        // If 2 nodes are intersecting, do hit test to find which node in on top.
    617         int x = intersectionRect.x() + intersectionRect.width() / 2;
    618         int y = intersectionRect.y() + intersectionRect.height() / 2;
     617        LayoutUnit x = intersectionRect.x() + intersectionRect.width() / 2;
     618        LayoutUnit y = intersectionRect.y() + intersectionRect.height() / 2;
    619619        HitTestResult result = candidate.visibleNode->document()->page()->mainFrame()->eventHandler()->hitTestResultAtPoint(IntPoint(x, y), false, true);
    620620        if (candidate.visibleNode->contains(result.innerNode())) {
    … …  
    636636}
    637637
    638 void FocusController::findFocusCandidateInContainer(Node* container, const IntRect& startingRect, FocusDirection direction, KeyboardEvent* event, FocusCandidate& closest)
     638void FocusController::findFocusCandidateInContainer(Node* container, const LayoutRect& startingRect, FocusDirection direction, KeyboardEvent* event, FocusCandidate& closest)
    639639{
    640640    ASSERT(container);
    … …  
    666666}
    667667
    668 bool FocusController::advanceFocusDirectionallyInContainer(Node* container, const IntRect& startingRect, FocusDirection direction, KeyboardEvent* event)
     668bool FocusController::advanceFocusDirectionallyInContainer(Node* container, const LayoutRect& startingRect, FocusDirection direction, KeyboardEvent* event)
    669669{
    670670    if (!container || !container->document())
    671671        return false;
    672672
    673     IntRect newStartingRect = startingRect;
     673    LayoutRect newStartingRect = startingRect;
    674674
    675675    if (startingRect.isEmpty())
    … …  
    698698        }
    699699        // Navigate into a new frame.
    700         IntRect rect;
     700        LayoutRect rect;
    701701        Node* focusedNode = focusedOrMainFrame()->document()->focusedNode();
    702702        if (focusedNode && !hasOffscreenRect(focusedNode))
    … …  
    716716        }
    717717        // Navigate into a new scrollable container.
    718         IntRect startingRect;
     718        LayoutRect startingRect;
    719719        Node* focusedNode = focusedOrMainFrame()->document()->focusedNode();
    720720        if (focusedNode && !hasOffscreenRect(focusedNode))
    … …  
    752752       
    753753    // Figure out the starting rect.
    754     IntRect startingRect;
     754    LayoutRect startingRect;
    755755    if (focusedNode) {
    756756        if (!hasOffscreenRect(focusedNode)) {

  • trunk/Source/WebCore/page/FocusController.h

    r90004 r93270  
    2828
    2929#include "FocusDirection.h"
     30#include "LayoutTypes.h"
    3031#include <wtf/Forward.h>
    3132#include <wtf/Noncopyable.h>
    … …  
    8687    Node* previousFocusableNode(TreeScope*, Node* start, KeyboardEvent*);
    8788
    88     bool advanceFocusDirectionallyInContainer(Node* container, const IntRect& startingRect, FocusDirection, KeyboardEvent*);
    89     void findFocusCandidateInContainer(Node* container, const IntRect& startingRect, FocusDirection, KeyboardEvent*, FocusCandidate& closest);
     89    bool advanceFocusDirectionallyInContainer(Node* container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*);
     90    void findFocusCandidateInContainer(Node* container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*, FocusCandidate& closest);
    9091
    9192    Page* m_page;

  • trunk/Source/WebCore/page/SpatialNavigation.cpp

    r87616 r93270  
    4646namespace WebCore {
    4747
    48 static RectsAlignment alignmentForRects(FocusDirection, const IntRect&, const IntRect&, const IntSize& viewSize);
    49 static bool areRectsFullyAligned(FocusDirection, const IntRect&, const IntRect&);
    50 static bool areRectsPartiallyAligned(FocusDirection, const IntRect&, const IntRect&);
    51 static bool areRectsMoreThanFullScreenApart(FocusDirection direction, const IntRect& curRect, const IntRect& targetRect, const IntSize& viewSize);
    52 static bool isRectInDirection(FocusDirection, const IntRect&, const IntRect&);
    53 static void deflateIfOverlapped(IntRect&, IntRect&);
    54 static IntRect rectToAbsoluteCoordinates(Frame* initialFrame, const IntRect&);
    55 static void entryAndExitPointsForDirection(FocusDirection direction, const IntRect& startingRect, const IntRect& potentialRect, IntPoint& exitPoint, IntPoint& entryPoint);
     48static RectsAlignment alignmentForRects(FocusDirection, const LayoutRect&, const LayoutRect&, const LayoutSize& viewSize);
     49static bool areRectsFullyAligned(FocusDirection, const LayoutRect&, const LayoutRect&);
     50static bool areRectsPartiallyAligned(FocusDirection, const LayoutRect&, const LayoutRect&);
     51static bool areRectsMoreThanFullScreenApart(FocusDirection, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize);
     52static bool isRectInDirection(FocusDirection, const LayoutRect&, const LayoutRect&);
     53static void deflateIfOverlapped(LayoutRect&, LayoutRect&);
     54static LayoutRect rectToAbsoluteCoordinates(Frame* initialFrame, const LayoutRect&);
     55static void entryAndExitPointsForDirection(FocusDirection, const LayoutRect& startingRect, const LayoutRect& potentialRect, LayoutPoint& exitPoint, LayoutPoint& entryPoint);
    5656static bool isScrollableNode(const Node*);
    5757
    … …  
    9696}
    9797
    98 static RectsAlignment alignmentForRects(FocusDirection direction, const IntRect& curRect, const IntRect& targetRect, const IntSize& viewSize)
     98static RectsAlignment alignmentForRects(FocusDirection direction, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize)
    9999{
    100100    // If we found a node in full alignment, but it is too far away, ignore it.
    … …  
    116116}
    117117
    118 static inline int start(FocusDirection direction, const IntRect& rect)
     118static inline LayoutUnit start(FocusDirection direction, const LayoutRect& rect)
    119119{
    120120    return isHorizontalMove(direction) ? rect.y() : rect.x();
    121121}
    122122
    123 static inline int middle(FocusDirection direction, const IntRect& rect)
    124 {
    125     IntPoint center(rect.center());
     123static inline LayoutUnit middle(FocusDirection direction, const LayoutRect& rect)
     124{
     125    LayoutPoint center(rect.center());
    126126    return isHorizontalMove(direction) ? center.y(): center.x();
    127127}
    128128
    129 static inline int end(FocusDirection direction, const IntRect& rect)
     129static inline LayoutUnit end(FocusDirection direction, const LayoutRect& rect)
    130130{
    131131    return isHorizontalMove(direction) ? rect.maxY() : rect.maxX();
    … …  
    139139// * a = Current focused node's rect.
    140140// * b = Focus candidate node's rect.
    141 static bool areRectsFullyAligned(FocusDirection direction, const IntRect& a, const IntRect& b)
    142 {
    143     int aStart, bStart, aEnd, bEnd;
     141static bool areRectsFullyAligned(FocusDirection direction, const LayoutRect& a, const LayoutRect& b)
     142{
     143    LayoutUnit aStart, bStart, aEnd, bEnd;
    144144
    145145    switch (direction) {
    … …  
    171171    bStart = start(direction, b);
    172172
    173     int aMiddle = middle(direction, a);
    174     int bMiddle = middle(direction, b);
     173    LayoutUnit aMiddle = middle(direction, a);
     174    LayoutUnit bMiddle = middle(direction, b);
    175175
    176176    aEnd = end(direction, a);
    … …  
    211211// * a = Current focused node's rect.
    212212// * b = Focus candidate node's rect.
    213 static bool areRectsPartiallyAligned(FocusDirection direction, const IntRect& a, const IntRect& b)
    214 {
    215     int aStart  = start(direction, a);
    216     int bStart  = start(direction, b);
    217     int bMiddle = middle(direction, b);
    218     int aEnd = end(direction, a);
    219     int bEnd = end(direction, b);
     213static bool areRectsPartiallyAligned(FocusDirection direction, const LayoutRect& a, const LayoutRect& b)
     214{
     215    LayoutUnit aStart  = start(direction, a);
     216    LayoutUnit bStart  = start(direction, b);
     217    LayoutUnit bMiddle = middle(direction, b);
     218    LayoutUnit aEnd = end(direction, a);
     219    LayoutUnit bEnd = end(direction, b);
    220220
    221221    // Picture of the partially aligned logic:
    … …  
    240240}
    241241
    242 static bool areRectsMoreThanFullScreenApart(FocusDirection direction, const IntRect& curRect, const IntRect& targetRect, const IntSize& viewSize)
     242static bool areRectsMoreThanFullScreenApart(FocusDirection direction, const LayoutRect& curRect, const LayoutRect& targetRect, const LayoutSize& viewSize)
    243243{
    244244    ASSERT(isRectInDirection(direction, curRect, targetRect));
    … …  
    260260
    261261// Return true if rect |a| is below |b|. False otherwise.
    262 static inline bool below(const IntRect& a, const IntRect& b)
     262static inline bool below(const LayoutRect& a, const LayoutRect& b)
    263263{
    264264    return a.y() > b.maxY();
    … …  
    266266
    267267// Return true if rect |a| is on the right of |b|. False otherwise.
    268 static inline bool rightOf(const IntRect& a, const IntRect& b)
     268static inline bool rightOf(const LayoutRect& a, const LayoutRect& b)
    269269{
    270270    return a.x() > b.maxX();
    271271}
    272272
    273 static bool isRectInDirection(FocusDirection direction, const IntRect& curRect, const IntRect& targetRect)
     273static bool isRectInDirection(FocusDirection direction, const LayoutRect& curRect, const LayoutRect& targetRect)
    274274{
    275275    switch (direction) {
    … …  
    302302    ASSERT(!frameView->needsLayout());
    303303
    304     IntRect containerViewportRect = frameView->visibleContentRect();
     304    LayoutRect containerViewportRect = frameView->visibleContentRect();
    305305    // We want to select a node if it is currently off screen, but will be
    306306    // exposed after we scroll. Adjust the viewport to post-scrolling position.
    … …  
    330330        return true;
    331331
    332     IntRect rect(render->absoluteClippedOverflowRect());
     332    LayoutRect rect(render->absoluteClippedOverflowRect());
    333333    if (rect.isEmpty())
    334334        return true;
    … …  
    342342
    343343    if (frame && canScrollInDirection(frame->document(), direction)) {
    344         int dx = 0;
    345         int dy = 0;
     344        LayoutUnit dx = 0;
     345        LayoutUnit dy = 0;
    346346        switch (direction) {
    347347        case FocusDirectionLeft:
    … …  
    362362        }
    363363
    364         frame->view()->scrollBy(IntSize(dx, dy));
     364        frame->view()->scrollBy(LayoutSize(dx, dy));
    365365        return true;
    366366    }
    … …  
    378378
    379379    if (canScrollInDirection(container, direction)) {
    380         int dx = 0;
    381         int dy = 0;
     380        LayoutUnit dx = 0;
     381        LayoutUnit dy = 0;
    382382        switch (direction) {
    383383        case FocusDirectionLeft:
    384             dx = - min(Scrollbar::pixelsPerLineStep(), container->renderBox()->scrollLeft());
     384            dx = - min<LayoutUnit>(Scrollbar::pixelsPerLineStep(), container->renderBox()->scrollLeft());
    385385            break;
    386386        case FocusDirectionRight:
    387387            ASSERT(container->renderBox()->scrollWidth() > (container->renderBox()->scrollLeft() + container->renderBox()->clientWidth()));
    388             dx = min(Scrollbar::pixelsPerLineStep(), container->renderBox()->scrollWidth() - (container->renderBox()->scrollLeft() + container->renderBox()->clientWidth()));
     388            dx = min<LayoutUnit>(Scrollbar::pixelsPerLineStep(), container->renderBox()->scrollWidth() - (container->renderBox()->scrollLeft() + container->renderBox()->clientWidth()));
    389389            break;
    390390        case FocusDirectionUp:
    391             dy = - min(Scrollbar::pixelsPerLineStep(), container->renderBox()->scrollTop());
     391            dy = - min<LayoutUnit>(Scrollbar::pixelsPerLineStep(), container->renderBox()->scrollTop());
    392392            break;
    393393        case FocusDirectionDown:
    394394            ASSERT(container->renderBox()->scrollHeight() - (container->renderBox()->scrollTop() + container->renderBox()->clientHeight()));
    395             dy = min(Scrollbar::pixelsPerLineStep(), container->renderBox()->scrollHeight() - (container->renderBox()->scrollTop() + container->renderBox()->clientHeight()));
     395            dy = min<LayoutUnit>(Scrollbar::pixelsPerLineStep(), container->renderBox()->scrollHeight() - (container->renderBox()->scrollTop() + container->renderBox()->clientHeight()));
    396396            break;
    397397        default:
    … …  
    407407}
    408408
    409 static void deflateIfOverlapped(IntRect& a, IntRect& b)
     409static void deflateIfOverlapped(LayoutRect& a, LayoutRect& b)
    410410{
    411411    if (!a.intersects(b) || a.contains(b) || b.contains(a))
    412412        return;
    413413
    414     int deflateFactor = -fudgeFactor();
     414    LayoutUnit deflateFactor = -fudgeFactor();
    415415
    416416    // Avoid negative width or height values.
    … …  
    484484    if ((direction == FocusDirectionUp || direction == FocusDirectionDown) &&  ScrollbarAlwaysOff == verticalMode)
    485485        return false;
    486     IntSize size = frame->view()->contentsSize();
    487     IntSize offset = frame->view()->scrollOffset();
    488     IntRect rect = frame->view()->visibleContentRect(true);
     486    LayoutSize size = frame->view()->contentsSize();
     487    LayoutSize offset = frame->view()->scrollOffset();
     488    LayoutRect rect = frame->view()->visibleContentRect(true);
    489489
    490490    switch (direction) {
    … …  
    503503}
    504504
    505 static IntRect rectToAbsoluteCoordinates(Frame* initialFrame, const IntRect& initialRect)
    506 {
    507     IntRect rect = initialRect;
     505static LayoutRect rectToAbsoluteCoordinates(Frame* initialFrame, const LayoutRect& initialRect)
     506{
     507    LayoutRect rect = initialRect;
    508508    for (Frame* frame = initialFrame; frame; frame = frame->tree()->parent()) {
    509509        if (Element* element = static_cast<Element*>(frame->ownerElement())) {
    … …  
    517517}
    518518
    519 IntRect nodeRectInAbsoluteCoordinates(Node* node, bool ignoreBorder)
     519LayoutRect nodeRectInAbsoluteCoordinates(Node* node, bool ignoreBorder)
    520520{
    521521    ASSERT(node && node->renderer() && !node->document()->view()->needsLayout());
    … …  
    523523    if (node->isDocumentNode())
    524524        return frameRectInAbsoluteCoordinates(static_cast<Document*>(node)->frame());
    525     IntRect rect = rectToAbsoluteCoordinates(node->document()->frame(), node->getRect());
     525    LayoutRect rect = rectToAbsoluteCoordinates(node->document()->frame(), node->getRect());
    526526
    527527    // For authors that use border instead of outline in their CSS, we compensate by ignoring the border when calculating
    … …  
    535535}
    536536
    537 IntRect frameRectInAbsoluteCoordinates(Frame* frame)
     537LayoutRect frameRectInAbsoluteCoordinates(Frame* frame)
    538538{
    539539    return rectToAbsoluteCoordinates(frame, frame->view()->visibleContentRect());
    … …  
    542542// This method calculates the exitPoint from the startingRect and the entryPoint into the candidate rect.
    543543// The line between those 2 points is the closest distance between the 2 rects.
    544 void entryAndExitPointsForDirection(FocusDirection direction, const IntRect& startingRect, const IntRect& potentialRect, IntPoint& exitPoint, IntPoint& entryPoint)
     544void entryAndExitPointsForDirection(FocusDirection direction, const LayoutRect& startingRect, const LayoutRect& potentialRect, LayoutPoint& exitPoint, LayoutPoint& entryPoint)
    545545{
    546546    switch (direction) {
    … …  
    630630    }
    631631
    632     IntRect nodeRect = candidate.rect;
    633     IntRect currentRect = current.rect;
     632    LayoutRect nodeRect = candidate.rect;
     633    LayoutRect currentRect = current.rect;
    634634    deflateIfOverlapped(currentRect, nodeRect);
    635635
    … …  
    637637        return;
    638638
    639     IntPoint exitPoint;
    640     IntPoint entryPoint;
    641     int sameAxisDistance = 0;
    642     int otherAxisDistance = 0;
     639    LayoutPoint exitPoint;
     640    LayoutPoint entryPoint;
     641    LayoutUnit sameAxisDistance = 0;
     642    LayoutUnit otherAxisDistance = 0;
    643643    entryAndExitPointsForDirection(direction, currentRect, nodeRect, exitPoint, entryPoint);
    644644
    … …  
    665665    }
    666666
    667     int x = (entryPoint.x() - exitPoint.x()) * (entryPoint.x() - exitPoint.x());
    668     int y = (entryPoint.y() - exitPoint.y()) * (entryPoint.y() - exitPoint.y());
     667    LayoutUnit x = (entryPoint.x() - exitPoint.x()) * (entryPoint.x() - exitPoint.x());
     668    LayoutUnit y = (entryPoint.y() - exitPoint.y()) * (entryPoint.y() - exitPoint.y());
    669669
    670670    float euclidianDistance = sqrt((x + y) * 1.0f);
    … …  
    675675    float distance = euclidianDistance + sameAxisDistance + 2 * otherAxisDistance;
    676676    candidate.distance = roundf(distance);
    677     IntSize viewSize = candidate.visibleNode->document()->page()->mainFrame()->view()->visibleContentRect().size();
     677    LayoutSize viewSize = candidate.visibleNode->document()->page()->mainFrame()->view()->visibleContentRect().size();
    678678    candidate.alignment = alignmentForRects(direction, currentRect, nodeRect, viewSize);
    679679}
    … …  
    682682{
    683683    ASSERT(candidate.visibleNode && candidate.isOffscreen);
    684     IntRect candidateRect = candidate.rect;
     684    LayoutRect candidateRect = candidate.rect;
    685685    for (Node* parentNode = candidate.visibleNode->parentNode(); parentNode; parentNode = parentNode->parentNode()) {
    686         IntRect parentRect = nodeRectInAbsoluteCoordinates(parentNode);
     686        LayoutRect parentRect = nodeRectInAbsoluteCoordinates(parentNode);
    687687        if (!candidateRect.intersects(parentRect)) {
    688688            if (((direction == FocusDirectionLeft || direction == FocusDirectionRight) && parentNode->renderer()->style()->overflowX() == OHIDDEN)
    … …  
    700700// The virtual rect is the edge of the container or frame. We select which
    701701// edge depending on the direction of the navigation.
    702 IntRect virtualRectForDirection(FocusDirection direction, const IntRect& startingRect, int width)
    703 {
    704     IntRect virtualStartingRect = startingRect;
     702LayoutRect virtualRectForDirection(FocusDirection direction, const LayoutRect& startingRect, LayoutUnit width)
     703{
     704    LayoutRect virtualStartingRect = startingRect;
    705705    switch (direction) {
    706706    case FocusDirectionLeft:
    … …  
    725725}
    726726
    727 IntRect virtualRectForAreaElementAndDirection(HTMLAreaElement* area, FocusDirection direction)
     727LayoutRect virtualRectForAreaElementAndDirection(HTMLAreaElement* area, FocusDirection direction)
    728728{
    729729    ASSERT(area);
    … …  
    731731    // Area elements tend to overlap more than other focusable elements. We flatten the rect of the area elements
    732732    // to minimize the effect of overlapping areas.
    733     IntRect rect = virtualRectForDirection(direction, rectToAbsoluteCoordinates(area->document()->frame(), area->computeRect(area->imageElement()->renderer())), 1);
     733    LayoutRect rect = virtualRectForDirection(direction, rectToAbsoluteCoordinates(area->document()->frame(), area->computeRect(area->imageElement()->renderer())), 1);
    734734    return rect;
    735735}

  • trunk/Source/WebCore/page/SpatialNavigation.h

    r79021 r93270  
    2424#include "FocusDirection.h"
    2525#include "HTMLFrameOwnerElement.h"
    26 #include "IntRect.h"
     26#include "LayoutTypes.h"
    2727#include "Node.h"
    2828
    … …  
    131131    RectsAlignment alignment;
    132132    RectsAlignment parentAlignment;
    133     IntRect rect;
     133    LayoutRect rect;
    134134    bool isOffscreen;
    135135    bool isOffscreenAfterScrolling;
    … …  
    145145void distanceDataForNode(FocusDirection, const FocusCandidate& current, FocusCandidate& candidate);
    146146Node* scrollableEnclosingBoxOrParentFrameForNodeInDirection(FocusDirection, Node*);
    147 IntRect nodeRectInAbsoluteCoordinates(Node*, bool ignoreBorder = false);
    148 IntRect frameRectInAbsoluteCoordinates(Frame*);
    149 IntRect virtualRectForDirection(FocusDirection, const IntRect& startingRect, int width = 0);
    150 IntRect virtualRectForAreaElementAndDirection(HTMLAreaElement*, FocusDirection);
     147LayoutRect nodeRectInAbsoluteCoordinates(Node*, bool ignoreBorder = false);
     148LayoutRect frameRectInAbsoluteCoordinates(Frame*);
     149LayoutRect virtualRectForDirection(FocusDirection, const LayoutRect& startingRect, LayoutUnit width = 0);
     150LayoutRect virtualRectForAreaElementAndDirection(HTMLAreaElement*, FocusDirection);
    151151HTMLFrameOwnerElement* frameOwnerElement(FocusCandidate&);
    152152
Note: See TracChangeset for help on using the changeset viewer.