Home | History | Annotate | Download | only in paint 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "config.h"
      6 #include "core/paint/ObjectPainter.h"
      7 
      8 #include "core/rendering/PaintInfo.h"
      9 #include "core/rendering/RenderObject.h"
     10 #include "core/rendering/RenderTheme.h"
     11 #include "core/rendering/style/RenderStyle.h"
     12 #include "platform/geometry/LayoutPoint.h"
     13 #include "platform/graphics/GraphicsContextStateSaver.h"
     14 
     15 namespace blink {
     16 
     17 void ObjectPainter::paintFocusRing(PaintInfo& paintInfo, const LayoutPoint& paintOffset, RenderStyle* style)
     18 {
     19     Vector<LayoutRect> focusRingRects;
     20     m_renderObject.addFocusRingRects(focusRingRects, paintOffset, paintInfo.paintContainer());
     21     ASSERT(style->outlineStyleIsAuto());
     22     Vector<IntRect> focusRingIntRects;
     23     for (size_t i = 0; i < focusRingRects.size(); ++i)
     24         focusRingIntRects.append(pixelSnappedIntRect(focusRingRects[i]));
     25     paintInfo.context->drawFocusRing(focusRingIntRects, style->outlineWidth(), style->outlineOffset(), m_renderObject.resolveColor(style, CSSPropertyOutlineColor));
     26 }
     27 
     28 void ObjectPainter::paintOutline(PaintInfo& paintInfo, const LayoutRect& paintRect)
     29 {
     30     RenderStyle* styleToUse = m_renderObject.style();
     31     if (!styleToUse->hasOutline())
     32         return;
     33 
     34     LayoutUnit outlineWidth = styleToUse->outlineWidth();
     35 
     36     int outlineOffset = styleToUse->outlineOffset();
     37 
     38     if (styleToUse->outlineStyleIsAuto()) {
     39         if (RenderTheme::theme().shouldDrawDefaultFocusRing(&m_renderObject)) {
     40             // Only paint the focus ring by hand if the theme isn't able to draw the focus ring.
     41             paintFocusRing(paintInfo, paintRect.location(), styleToUse);
     42         }
     43         return;
     44     }
     45 
     46     if (styleToUse->outlineStyle() == BNONE)
     47         return;
     48 
     49     IntRect inner = pixelSnappedIntRect(paintRect);
     50     inner.inflate(outlineOffset);
     51 
     52     IntRect outer = pixelSnappedIntRect(inner);
     53     outer.inflate(outlineWidth);
     54 
     55     // FIXME: This prevents outlines from painting inside the object. See bug 12042
     56     if (outer.isEmpty())
     57         return;
     58 
     59     EBorderStyle outlineStyle = styleToUse->outlineStyle();
     60     Color outlineColor = m_renderObject.resolveColor(styleToUse, CSSPropertyOutlineColor);
     61 
     62     GraphicsContext* graphicsContext = paintInfo.context;
     63     bool useTransparencyLayer = outlineColor.hasAlpha();
     64     if (useTransparencyLayer) {
     65         if (outlineStyle == SOLID) {
     66             Path path;
     67             path.addRect(outer);
     68             path.addRect(inner);
     69             graphicsContext->setFillRule(RULE_EVENODD);
     70             graphicsContext->setFillColor(outlineColor);
     71             graphicsContext->fillPath(path);
     72             return;
     73         }
     74         graphicsContext->beginTransparencyLayer(static_cast<float>(outlineColor.alpha()) / 255);
     75         outlineColor = Color(outlineColor.red(), outlineColor.green(), outlineColor.blue());
     76     }
     77 
     78     int leftOuter = outer.x();
     79     int leftInner = inner.x();
     80     int rightOuter = outer.maxX();
     81     int rightInner = inner.maxX();
     82     int topOuter = outer.y();
     83     int topInner = inner.y();
     84     int bottomOuter = outer.maxY();
     85     int bottomInner = inner.maxY();
     86 
     87     drawLineForBoxSide(graphicsContext, leftOuter, topOuter, leftInner, bottomOuter, BSLeft, outlineColor, outlineStyle, outlineWidth, outlineWidth);
     88     drawLineForBoxSide(graphicsContext, leftOuter, topOuter, rightOuter, topInner, BSTop, outlineColor, outlineStyle, outlineWidth, outlineWidth);
     89     drawLineForBoxSide(graphicsContext, rightInner, topOuter, rightOuter, bottomOuter, BSRight, outlineColor, outlineStyle, outlineWidth, outlineWidth);
     90     drawLineForBoxSide(graphicsContext, leftOuter, bottomInner, rightOuter, bottomOuter, BSBottom, outlineColor, outlineStyle, outlineWidth, outlineWidth);
     91 
     92     if (useTransparencyLayer)
     93         graphicsContext->endLayer();
     94 }
     95 
     96 void ObjectPainter::drawLineForBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
     97     BoxSide side, Color color, EBorderStyle style,
     98     int adjacentWidth1, int adjacentWidth2, bool antialias)
     99 {
    100     int thickness;
    101     int length;
    102     if (side == BSTop || side == BSBottom) {
    103         thickness = y2 - y1;
    104         length = x2 - x1;
    105     } else {
    106         thickness = x2 - x1;
    107         length = y2 - y1;
    108     }
    109 
    110     // FIXME: We really would like this check to be an ASSERT as we don't want to draw empty borders. However
    111     // nothing guarantees that the following recursive calls to drawLineForBoxSide will have non-null dimensions.
    112     if (!thickness || !length)
    113         return;
    114 
    115     if (style == DOUBLE && thickness < 3)
    116         style = SOLID;
    117 
    118     switch (style) {
    119     case BNONE:
    120     case BHIDDEN:
    121         return;
    122     case DOTTED:
    123     case DASHED:
    124         drawDashedOrDottedBoxSide(graphicsContext, x1, y1, x2, y2, side,
    125             color, thickness, style, antialias);
    126         break;
    127     case DOUBLE:
    128         drawDoubleBoxSide(graphicsContext, x1, y1, x2, y2, length, side, color,
    129             thickness, adjacentWidth1, adjacentWidth2, antialias);
    130         break;
    131     case RIDGE:
    132     case GROOVE:
    133         drawRidgeOrGrooveBoxSide(graphicsContext, x1, y1, x2, y2, side, color,
    134             style, adjacentWidth1, adjacentWidth2, antialias);
    135         break;
    136     case INSET:
    137         // FIXME: Maybe we should lighten the colors on one side like Firefox.
    138         // https://bugs.webkit.org/show_bug.cgi?id=58608
    139         if (side == BSTop || side == BSLeft)
    140             color = color.dark();
    141         // fall through
    142     case OUTSET:
    143         if (style == OUTSET && (side == BSBottom || side == BSRight))
    144             color = color.dark();
    145         // fall through
    146     case SOLID:
    147         drawSolidBoxSide(graphicsContext, x1, y1, x2, y2, side, color, adjacentWidth1, adjacentWidth2, antialias);
    148         break;
    149     }
    150 }
    151 
    152 void ObjectPainter::drawDashedOrDottedBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
    153     BoxSide side, Color color, int thickness, EBorderStyle style, bool antialias)
    154 {
    155     if (thickness <= 0)
    156         return;
    157 
    158     bool wasAntialiased = graphicsContext->shouldAntialias();
    159     StrokeStyle oldStrokeStyle = graphicsContext->strokeStyle();
    160     graphicsContext->setShouldAntialias(antialias);
    161     graphicsContext->setStrokeColor(color);
    162     graphicsContext->setStrokeThickness(thickness);
    163     graphicsContext->setStrokeStyle(style == DASHED ? DashedStroke : DottedStroke);
    164 
    165     switch (side) {
    166     case BSBottom:
    167     case BSTop:
    168         graphicsContext->drawLine(IntPoint(x1, (y1 + y2) / 2), IntPoint(x2, (y1 + y2) / 2));
    169         break;
    170     case BSRight:
    171     case BSLeft:
    172         graphicsContext->drawLine(IntPoint((x1 + x2) / 2, y1), IntPoint((x1 + x2) / 2, y2));
    173         break;
    174     }
    175     graphicsContext->setShouldAntialias(wasAntialiased);
    176     graphicsContext->setStrokeStyle(oldStrokeStyle);
    177 }
    178 
    179 void ObjectPainter::drawDoubleBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
    180     int length, BoxSide side, Color color, int thickness, int adjacentWidth1, int adjacentWidth2, bool antialias)
    181 {
    182     int thirdOfThickness = (thickness + 1) / 3;
    183     ASSERT(thirdOfThickness);
    184 
    185     if (!adjacentWidth1 && !adjacentWidth2) {
    186         StrokeStyle oldStrokeStyle = graphicsContext->strokeStyle();
    187         graphicsContext->setStrokeStyle(NoStroke);
    188         graphicsContext->setFillColor(color);
    189 
    190         bool wasAntialiased = graphicsContext->shouldAntialias();
    191         graphicsContext->setShouldAntialias(antialias);
    192 
    193         switch (side) {
    194         case BSTop:
    195         case BSBottom:
    196             graphicsContext->drawRect(IntRect(x1, y1, length, thirdOfThickness));
    197             graphicsContext->drawRect(IntRect(x1, y2 - thirdOfThickness, length, thirdOfThickness));
    198             break;
    199         case BSLeft:
    200         case BSRight:
    201             // FIXME: Why do we offset the border by 1 in this case but not the other one?
    202             if (length > 1) {
    203                 graphicsContext->drawRect(IntRect(x1, y1 + 1, thirdOfThickness, length - 1));
    204                 graphicsContext->drawRect(IntRect(x2 - thirdOfThickness, y1 + 1, thirdOfThickness, length - 1));
    205             }
    206             break;
    207         }
    208 
    209         graphicsContext->setShouldAntialias(wasAntialiased);
    210         graphicsContext->setStrokeStyle(oldStrokeStyle);
    211         return;
    212     }
    213 
    214     int adjacent1BigThird = ((adjacentWidth1 > 0) ? adjacentWidth1 + 1 : adjacentWidth1 - 1) / 3;
    215     int adjacent2BigThird = ((adjacentWidth2 > 0) ? adjacentWidth2 + 1 : adjacentWidth2 - 1) / 3;
    216 
    217     switch (side) {
    218     case BSTop:
    219         drawLineForBoxSide(graphicsContext, x1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
    220             y1, x2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0), y1 + thirdOfThickness,
    221             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
    222         drawLineForBoxSide(graphicsContext, x1 + std::max((adjacentWidth1 * 2 + 1) / 3, 0),
    223             y2 - thirdOfThickness, x2 - std::max((adjacentWidth2 * 2 + 1) / 3, 0), y2,
    224             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
    225         break;
    226     case BSLeft:
    227         drawLineForBoxSide(graphicsContext, x1, y1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
    228             x1 + thirdOfThickness, y2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0),
    229             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
    230         drawLineForBoxSide(graphicsContext, x2 - thirdOfThickness, y1 + std::max((adjacentWidth1 * 2 + 1) / 3, 0),
    231             x2, y2 - std::max((adjacentWidth2 * 2 + 1) / 3, 0),
    232             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
    233         break;
    234     case BSBottom:
    235         drawLineForBoxSide(graphicsContext, x1 + std::max((adjacentWidth1 * 2 + 1) / 3, 0),
    236             y1, x2 - std::max((adjacentWidth2 * 2 + 1) / 3, 0), y1 + thirdOfThickness,
    237             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
    238         drawLineForBoxSide(graphicsContext, x1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
    239             y2 - thirdOfThickness, x2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0), y2,
    240             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
    241         break;
    242     case BSRight:
    243         drawLineForBoxSide(graphicsContext, x1, y1 + std::max((adjacentWidth1 * 2 + 1) / 3, 0),
    244             x1 + thirdOfThickness, y2 - std::max((adjacentWidth2 * 2 + 1) / 3, 0),
    245             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
    246         drawLineForBoxSide(graphicsContext, x2 - thirdOfThickness, y1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
    247             x2, y2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0),
    248             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
    249         break;
    250     default:
    251         break;
    252     }
    253 }
    254 
    255 void ObjectPainter::drawRidgeOrGrooveBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
    256     BoxSide side, Color color, EBorderStyle style, int adjacentWidth1, int adjacentWidth2, bool antialias)
    257 {
    258     EBorderStyle s1;
    259     EBorderStyle s2;
    260     if (style == GROOVE) {
    261         s1 = INSET;
    262         s2 = OUTSET;
    263     } else {
    264         s1 = OUTSET;
    265         s2 = INSET;
    266     }
    267 
    268     int adjacent1BigHalf = ((adjacentWidth1 > 0) ? adjacentWidth1 + 1 : adjacentWidth1 - 1) / 2;
    269     int adjacent2BigHalf = ((adjacentWidth2 > 0) ? adjacentWidth2 + 1 : adjacentWidth2 - 1) / 2;
    270 
    271     switch (side) {
    272     case BSTop:
    273         drawLineForBoxSide(graphicsContext, x1 + std::max(-adjacentWidth1, 0) / 2, y1, x2 - std::max(-adjacentWidth2, 0) / 2, (y1 + y2 + 1) / 2,
    274             side, color, s1, adjacent1BigHalf, adjacent2BigHalf, antialias);
    275         drawLineForBoxSide(graphicsContext, x1 + std::max(adjacentWidth1 + 1, 0) / 2, (y1 + y2 + 1) / 2, x2 - std::max(adjacentWidth2 + 1, 0) / 2, y2,
    276             side, color, s2, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
    277         break;
    278     case BSLeft:
    279         drawLineForBoxSide(graphicsContext, x1, y1 + std::max(-adjacentWidth1, 0) / 2, (x1 + x2 + 1) / 2, y2 - std::max(-adjacentWidth2, 0) / 2,
    280             side, color, s1, adjacent1BigHalf, adjacent2BigHalf, antialias);
    281         drawLineForBoxSide(graphicsContext, (x1 + x2 + 1) / 2, y1 + std::max(adjacentWidth1 + 1, 0) / 2, x2, y2 - std::max(adjacentWidth2 + 1, 0) / 2,
    282             side, color, s2, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
    283         break;
    284     case BSBottom:
    285         drawLineForBoxSide(graphicsContext, x1 + std::max(adjacentWidth1, 0) / 2, y1, x2 - std::max(adjacentWidth2, 0) / 2, (y1 + y2 + 1) / 2,
    286             side, color, s2, adjacent1BigHalf, adjacent2BigHalf, antialias);
    287         drawLineForBoxSide(graphicsContext, x1 + std::max(-adjacentWidth1 + 1, 0) / 2, (y1 + y2 + 1) / 2, x2 - std::max(-adjacentWidth2 + 1, 0) / 2, y2,
    288             side, color, s1, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
    289         break;
    290     case BSRight:
    291         drawLineForBoxSide(graphicsContext, x1, y1 + std::max(adjacentWidth1, 0) / 2, (x1 + x2 + 1) / 2, y2 - std::max(adjacentWidth2, 0) / 2,
    292             side, color, s2, adjacent1BigHalf, adjacent2BigHalf, antialias);
    293         drawLineForBoxSide(graphicsContext, (x1 + x2 + 1) / 2, y1 + std::max(-adjacentWidth1 + 1, 0) / 2, x2, y2 - std::max(-adjacentWidth2 + 1, 0) / 2,
    294             side, color, s1, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
    295         break;
    296     }
    297 }
    298 
    299 void ObjectPainter::drawSolidBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
    300     BoxSide side, Color color, int adjacentWidth1, int adjacentWidth2, bool antialias)
    301 {
    302     StrokeStyle oldStrokeStyle = graphicsContext->strokeStyle();
    303     graphicsContext->setStrokeStyle(NoStroke);
    304     graphicsContext->setFillColor(color);
    305     ASSERT(x2 >= x1);
    306     ASSERT(y2 >= y1);
    307     if (!adjacentWidth1 && !adjacentWidth2) {
    308         // Turn off antialiasing to match the behavior of drawConvexPolygon();
    309         // this matters for rects in transformed contexts.
    310         bool wasAntialiased = graphicsContext->shouldAntialias();
    311         graphicsContext->setShouldAntialias(antialias);
    312         graphicsContext->drawRect(IntRect(x1, y1, x2 - x1, y2 - y1));
    313         graphicsContext->setShouldAntialias(wasAntialiased);
    314         graphicsContext->setStrokeStyle(oldStrokeStyle);
    315         return;
    316     }
    317     FloatPoint quad[4];
    318     switch (side) {
    319     case BSTop:
    320         quad[0] = FloatPoint(x1 + std::max(-adjacentWidth1, 0), y1);
    321         quad[1] = FloatPoint(x1 + std::max(adjacentWidth1, 0), y2);
    322         quad[2] = FloatPoint(x2 - std::max(adjacentWidth2, 0), y2);
    323         quad[3] = FloatPoint(x2 - std::max(-adjacentWidth2, 0), y1);
    324         break;
    325     case BSBottom:
    326         quad[0] = FloatPoint(x1 + std::max(adjacentWidth1, 0), y1);
    327         quad[1] = FloatPoint(x1 + std::max(-adjacentWidth1, 0), y2);
    328         quad[2] = FloatPoint(x2 - std::max(-adjacentWidth2, 0), y2);
    329         quad[3] = FloatPoint(x2 - std::max(adjacentWidth2, 0), y1);
    330         break;
    331     case BSLeft:
    332         quad[0] = FloatPoint(x1, y1 + std::max(-adjacentWidth1, 0));
    333         quad[1] = FloatPoint(x1, y2 - std::max(-adjacentWidth2, 0));
    334         quad[2] = FloatPoint(x2, y2 - std::max(adjacentWidth2, 0));
    335         quad[3] = FloatPoint(x2, y1 + std::max(adjacentWidth1, 0));
    336         break;
    337     case BSRight:
    338         quad[0] = FloatPoint(x1, y1 + std::max(adjacentWidth1, 0));
    339         quad[1] = FloatPoint(x1, y2 - std::max(adjacentWidth2, 0));
    340         quad[2] = FloatPoint(x2, y2 - std::max(-adjacentWidth2, 0));
    341         quad[3] = FloatPoint(x2, y1 + std::max(-adjacentWidth1, 0));
    342         break;
    343     }
    344 
    345     graphicsContext->drawConvexPolygon(4, quad, antialias);
    346     graphicsContext->setStrokeStyle(oldStrokeStyle);
    347 }
    348 
    349 } // namespace blink
    350