⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 107296 in webkit


Ignore:
Timestamp:
Feb 9, 2012, 3:09:38 PM (15 years ago)
Author:
leviw@chromium.org
Message:

Add roundedIntPoint method for LayoutPoints
​https://bugs.webkit.org/show_bug.cgi?id=78262

Reviewed by Eric Seidel.

Adding a roundedIntPoint method that operates on a LayoutPoint. Currently, this does
nothing as LayoutPoint is a typedef to IntPoint. When we enable sub-pixel LayoutUnits,
this is a critical part in our pixel snapping strategy, where we round the logical top-
left point, then snap the right and bottom edges.

Also using this new method where we wish to convert LayoutPoints to IntPoints, which
we're currently doing implicitly (since they're the same thing).

No new tests. No change in functionality.

  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::visiblePositionForPoint):
(WebCore::AccessibilityRenderObject::accessibilityHitTest):

  • page/EventHandler.cpp:

(WebCore::EventHandler::eventMayStartDrag):
(WebCore::EventHandler::hitTestResultAtPoint):
(WebCore::EventHandler::selectCursor):

  • rendering/LayoutTypes.h:

(WebCore::roundedIntPoint):
(WebCore):

  • rendering/RenderEmbeddedObject.cpp:

(WebCore::RenderEmbeddedObject::getReplacementTextGeometry):

  • rendering/RenderFlowThread.cpp:

(WebCore::RenderFlowThread::paintIntoRegion):

  • rendering/RenderFrameSet.cpp:

(WebCore::RenderFrameSet::getCursor):

  • rendering/RenderImage.cpp:

(WebCore::RenderImage::paintReplaced):

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::scrollRectToVisible):
(WebCore::RenderLayer::offsetFromResizeCorner):
(WebCore::RenderLayer::isPointInResizeControl):
(WebCore::RenderLayer::paintLayerContents):

  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::paintContents):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::paintContents):

  • rendering/mathml/RenderMathMLBlock.cpp:

(WebCore::RenderMathMLBlock::paint):

  • rendering/mathml/RenderMathMLFraction.cpp:

(WebCore::RenderMathMLFraction::paint):

  • rendering/mathml/RenderMathMLRoot.cpp:

(WebCore::RenderMathMLRoot::paint):

  • rendering/mathml/RenderMathMLSquareRoot.cpp:

(WebCore::RenderMathMLSquareRoot::paint):

Location:
trunk/Source/WebCore
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r107291 r107296  
     12012-02-09  Levi Weintraub  <leviw@chromium.org>
     2
     3        Add roundedIntPoint method for LayoutPoints
     4        https://bugs.webkit.org/show_bug.cgi?id=78262
     5
     6        Reviewed by Eric Seidel.
     7
     8        Adding a roundedIntPoint method that operates on a LayoutPoint. Currently, this does
     9        nothing as LayoutPoint is a typedef to IntPoint. When we enable sub-pixel LayoutUnits,
     10        this is a critical part in our pixel snapping strategy, where we round the logical top-
     11        left point, then snap the right and bottom edges.
     12
     13        Also using this new method where we wish to convert LayoutPoints to IntPoints, which
     14        we're currently doing implicitly (since they're the same thing).
     15
     16        No new tests. No change in functionality.
     17
     18        * accessibility/AccessibilityRenderObject.cpp:
     19        (WebCore::AccessibilityRenderObject::visiblePositionForPoint):
     20        (WebCore::AccessibilityRenderObject::accessibilityHitTest):
     21        * page/EventHandler.cpp:
     22        (WebCore::EventHandler::eventMayStartDrag):
     23        (WebCore::EventHandler::hitTestResultAtPoint):
     24        (WebCore::EventHandler::selectCursor):
     25        * rendering/LayoutTypes.h:
     26        (WebCore::roundedIntPoint):
     27        (WebCore):
     28        * rendering/RenderEmbeddedObject.cpp:
     29        (WebCore::RenderEmbeddedObject::getReplacementTextGeometry):
     30        * rendering/RenderFlowThread.cpp:
     31        (WebCore::RenderFlowThread::paintIntoRegion):
     32        * rendering/RenderFrameSet.cpp:
     33        (WebCore::RenderFrameSet::getCursor):
     34        * rendering/RenderImage.cpp:
     35        (WebCore::RenderImage::paintReplaced):
     36        * rendering/RenderLayer.cpp:
     37        (WebCore::RenderLayer::scrollRectToVisible):
     38        (WebCore::RenderLayer::offsetFromResizeCorner):
     39        (WebCore::RenderLayer::isPointInResizeControl):
     40        (WebCore::RenderLayer::paintLayerContents):
     41        * rendering/RenderLayerBacking.cpp:
     42        (WebCore::RenderLayerBacking::paintContents):
     43        * rendering/RenderLayerCompositor.cpp:
     44        (WebCore::RenderLayerCompositor::paintContents):
     45        * rendering/mathml/RenderMathMLBlock.cpp:
     46        (WebCore::RenderMathMLBlock::paint):
     47        * rendering/mathml/RenderMathMLFraction.cpp:
     48        (WebCore::RenderMathMLFraction::paint):
     49        * rendering/mathml/RenderMathMLRoot.cpp:
     50        (WebCore::RenderMathMLRoot::paint):
     51        * rendering/mathml/RenderMathMLSquareRoot.cpp:
     52        (WebCore::RenderMathMLSquareRoot::paint):
     53
    1542012-02-09  John Bates  <jbates@google.com>
    255

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r106884 r107296  
    26762676        LayoutPoint ourpoint;
    26772677#if PLATFORM(MAC)
    2678         ourpoint = frameView->screenToContents(point);
     2678        ourpoint = frameView->screenToContents(roundedIntPoint(point));
    26792679#else
    26802680        ourpoint = point;
    … …  
    28552855
    28562856    if (node->hasTagName(areaTag))
    2857         return accessibilityImageMapHitTest(static_cast<HTMLAreaElement*>(node), point);
     2857        return accessibilityImageMapHitTest(static_cast<HTMLAreaElement*>(node), roundedIntPoint(point));
    28582858   
    28592859    if (node->hasTagName(optionTag))

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

    r107062 r107296  
    698698    m_frame->contentRenderer()->layer()->hitTest(request, result);
    699699    DragState state;
    700     return result.innerNode() && page->dragController()->draggableNode(m_frame, result.innerNode(), result.point(), state);
     700    return result.innerNode() && page->dragController()->draggableNode(m_frame, result.innerNode(), roundedIntPoint(result.point()), state);
    701701}
    702702
    … …  
    10321032
    10331033        if (testScrollbars == ShouldHitTestScrollbars) {
    1034             Scrollbar* eventScrollbar = view->scrollbarAtPoint(point);
     1034            Scrollbar* eventScrollbar = view->scrollbarAtPoint(roundedIntPoint(point));
    10351035            if (eventScrollbar)
    10361036                result.setScrollbar(eventScrollbar);
    … …  
    10471047            FrameView* mainView = mainFrame->view();
    10481048            if (resultView && mainView) {
    1049                 LayoutPoint mainFramePoint = mainView->rootViewToContents(resultView->contentsToRootView(result.point()));
     1049                IntPoint mainFramePoint = mainView->rootViewToContents(resultView->contentsToRootView(roundedIntPoint(result.point())));
    10501050                result = mainFrame->eventHandler()->hitTestResultAtPoint(mainFramePoint, allowShadowContent, ignoreClipping, testScrollbars, hitType, padding);
    10511051            }
    … …  
    12661266    if (renderer) {
    12671267        Cursor overrideCursor;
    1268         switch (renderer->getCursor(event.localPoint(), overrideCursor)) {
     1268        switch (renderer->getCursor(roundedIntPoint(event.localPoint()), overrideCursor)) {
    12691269        case SetCursorBasedOnStyle:
    12701270            break;

  • trunk/Source/WebCore/rendering/LayoutTypes.h

    r95901 r107296  
    5757}
    5858
     59inline IntPoint roundedIntPoint(const LayoutPoint& p)
     60{
     61    return p;
     62}
     63
    5964inline LayoutPoint roundedLayoutPoint(const FloatPoint& p)
    6065{

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r107160 r107296  
    24412441    // sit above the background/border.
    24422442    if (hasOverflowClip() && style()->visibility() == VISIBLE && (phase == PaintPhaseBlockBackground || phase == PaintPhaseChildBlockBackground) && paintInfo.shouldPaintWithinRoot(this))
    2443         layer()->paintOverflowControls(paintInfo.context, adjustedPaintOffset, paintInfo.rect);
     2443        layer()->paintOverflowControls(paintInfo.context, roundedIntPoint(adjustedPaintOffset), paintInfo.rect);
    24442444}
    24452445

  • trunk/Source/WebCore/rendering/RenderEmbeddedObject.cpp

    r106492 r107296  
    191191{
    192192    contentRect = contentBoxRect();
    193     contentRect.moveBy(accumulatedOffset);
     193    contentRect.moveBy(roundedIntPoint(accumulatedOffset));
    194194   
    195195    FontDescription fontDescription;

  • trunk/Source/WebCore/rendering/RenderFlowThread.cpp

    r106694 r107296  
    465465
    466466        context->translate(renderFlowThreadOffset.x(), renderFlowThreadOffset.y());
    467         info.rect.moveBy(-renderFlowThreadOffset);
     467        info.rect.moveBy(-roundedIntPoint(renderFlowThreadOffset));
    468468       
    469469        layer()->paint(context, info.rect, 0, 0, region, RenderLayer::PaintLayerTemporaryClipRects);

  • trunk/Source/WebCore/rendering/RenderFrameSet.cpp

    r107009 r107296  
    803803CursorDirective RenderFrameSet::getCursor(const LayoutPoint& point, Cursor& cursor) const
    804804{
    805     if (canResizeRow(point)) {
     805    if (canResizeRow(roundedIntPoint(point))) {
    806806        cursor = rowResizeCursor();
    807807        return SetCursor;

  • trunk/Source/WebCore/rendering/RenderImage.cpp

    r106492 r107296  
    300300                    centerY = 0;
    301301                imageOffset = LayoutSize(leftBorder + leftPad + centerX + 1, topBorder + topPad + centerY + 1);
    302                 context->drawImage(image.get(), style()->colorSpace(), IntRect(paintOffset + imageOffset, imageSize));
     302                context->drawImage(image.get(), style()->colorSpace(), IntRect(roundedIntPoint(paintOffset + imageOffset), imageSize));
    303303                errorPictureDrawn = true;
    304304            }

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r107168 r107296  
    15791579                LayoutRect r = getRectToExpose(viewRect, rect, alignX, alignY);
    15801580               
    1581                 frameView->setScrollPosition(r.location());
     1581                frameView->setScrollPosition(roundedIntPoint(r.location()));
    15821582
    15831583                // This is the outermost view of a web page, so after scrolling this view we
    … …  
    21362136    // Currently the resize corner is always the bottom right corner
    21372137    // FIXME: This assumes the location is 0, 0. Is this guaranteed to always be the case?
    2138     LayoutPoint bottomRight = toPoint(size());
    2139     LayoutPoint localPoint = absoluteToContents(absolutePoint);
     2138    IntPoint bottomRight = toPoint(size());
     2139    IntPoint localPoint = roundedIntPoint(absoluteToContents(absolutePoint));
    21402140    return localPoint - bottomRight;
    21412141}
    … …  
    25442544}
    25452545
    2546 bool RenderLayer::isPointInResizeControl(const LayoutPoint& absolutePoint) const
     2546bool RenderLayer::isPointInResizeControl(const IntPoint& absolutePoint) const
    25472547{
    25482548    if (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE)
    … …  
    25522552    ASSERT(box);
    25532553
    2554     LayoutPoint localPoint = absoluteToContents(absolutePoint);
    2555 
    2556     LayoutRect localBounds(0, 0, box->width(), box->height());
     2554    IntPoint localPoint = roundedIntPoint(absoluteToContents(absolutePoint));
     2555
     2556    IntRect localBounds(0, 0, box->pixelSnappedWidth(), box->pixelSnappedHeight());
    25572557    return resizerCornerRect(this, localBounds).contains(localPoint);
    25582558}
    … …  
    29472947    if (isPaintingOverlayScrollbars) {
    29482948        clipToRect(rootLayer, context, paintDirtyRect, damageRect);
    2949         paintOverflowControls(context, paintOffset, damageRect.rect(), true);
     2949        paintOverflowControls(context, roundedIntPoint(paintOffset), damageRect.rect(), true);
    29502950        restoreClip(context, paintDirtyRect, damageRect);
    29512951    }

  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r106459 r107296  
    11621162        context.translate(-scrollCornerAndResizer.x(), -scrollCornerAndResizer.y());
    11631163        LayoutRect transformedClip = clip;
    1164         transformedClip.moveBy(scrollCornerAndResizer.location());
     1164        transformedClip.moveBy(roundedIntPoint(scrollCornerAndResizer.location()));
    11651165        m_owningLayer->paintScrollCorner(&context, LayoutPoint(), transformedClip);
    11661166        m_owningLayer->paintResizer(&context, LayoutPoint(), transformedClip);

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r107119 r107296  
    16181618        context.translate(-scrollCorner.x(), -scrollCorner.y());
    16191619        LayoutRect transformedClip = clip;
    1620         transformedClip.moveBy(scrollCorner.location());
     1620        transformedClip.moveBy(roundedIntPoint(scrollCorner.location()));
    16211621        m_renderView->frameView()->paintScrollCorner(&context, transformedClip);
    16221622        context.restore();

  • trunk/Source/WebCore/rendering/RenderListMarker.cpp

    r106900 r107296  
    11111111        return;
    11121112
    1113     LayoutPoint boxOrigin(paintOffset + location());
     1113    IntPoint boxOrigin(paintOffset + location());
    11141114    LayoutRect overflowRect(visualOverflowRect());
    11151115    overflowRect.moveBy(boxOrigin);

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.cpp

    r107019 r107296  
    8383        return;
    8484
    85     LayoutPoint adjustedPaintOffset = paintOffset + location();
     85    IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location());
    8686
    8787    GraphicsContextStateSaver stateSaver(*info.context);

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.cpp

    r107263 r107296  
    154154    }
    155155   
    156     LayoutPoint adjustedPaintOffset = paintOffset + location();
     156    IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location());
    157157    adjustedPaintOffset.setY(adjustedPaintOffset.y() + verticalOffset);
    158158   

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp

    r107263 r107296  
    105105        return;
    106106
    107     LayoutPoint adjustedPaintOffset = paintOffset + location();
     107    IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location());
    108108   
    109109    RenderBoxModelObject* indexBox = toRenderBoxModelObject(lastChild());

  • trunk/Source/WebCore/rendering/mathml/RenderMathMLSquareRoot.cpp

    r107263 r107296  
    7474        return;
    7575   
    76     LayoutPoint adjustedPaintOffset = paintOffset + location();
     76    IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location());
    7777
    7878    LayoutUnit maxHeight = 0;
Note: See TracChangeset for help on using the changeset viewer.