CanvasRenderingContext2D.cpp [plain text]
#include "config.h"
#include "CanvasRenderingContext2D.h"
#include "CSSFontSelector.h"
#include "CSSParser.h"
#include "CSSPropertyNames.h"
#include "ImageBuffer.h"
#include "ImageData.h"
#include "InspectorInstrumentation.h"
#include "Path2D.h"
#include "RenderTheme.h"
#include "StyleProperties.h"
#include "StyleResolver.h"
#include "TextMetrics.h"
#include "TextRun.h"
#include <wtf/CheckedArithmetic.h>
#include <wtf/MathExtras.h>
#include <wtf/text/StringBuilder.h>
namespace WebCore {
using namespace HTMLNames;
std::unique_ptr<CanvasRenderingContext2D> CanvasRenderingContext2D::create(CanvasBase& canvas, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode)
{
auto renderingContext = std::unique_ptr<CanvasRenderingContext2D>(new CanvasRenderingContext2D(canvas, usesCSSCompatibilityParseMode, usesDashboardCompatibilityMode));
InspectorInstrumentation::didCreateCanvasRenderingContext(*renderingContext);
return renderingContext;
}
CanvasRenderingContext2D::CanvasRenderingContext2D(CanvasBase& canvas, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode)
: CanvasRenderingContext2DBase(canvas, usesCSSCompatibilityParseMode, usesDashboardCompatibilityMode)
{
}
CanvasRenderingContext2D::~CanvasRenderingContext2D() = default;
void CanvasRenderingContext2D::drawFocusIfNeeded(Element& element)
{
drawFocusIfNeededInternal(m_path, element);
}
void CanvasRenderingContext2D::drawFocusIfNeeded(Path2D& path, Element& element)
{
drawFocusIfNeededInternal(path.path(), element);
}
void CanvasRenderingContext2D::drawFocusIfNeededInternal(const Path& path, Element& element)
{
auto* context = drawingContext();
if (!element.focused() || !state().hasInvertibleTransform || path.isEmpty() || !element.isDescendantOf(canvas()) || !context)
return;
context->drawFocusRing(path, 1, 1, RenderTheme::focusRingColor(element.document().styleColorOptions()));
}
String CanvasRenderingContext2D::font() const
{
if (!state().font.realized())
return DefaultFont;
StringBuilder serializedFont;
const auto& fontDescription = state().font.fontDescription();
if (fontDescription.italic())
serializedFont.appendLiteral("italic ");
if (fontDescription.variantCaps() == FontVariantCaps::Small)
serializedFont.appendLiteral("small-caps ");
serializedFont.appendNumber(fontDescription.computedPixelSize());
serializedFont.appendLiteral("px");
for (unsigned i = 0; i < fontDescription.familyCount(); ++i) {
if (i)
serializedFont.append(',');
String family = fontDescription.familyAt(i);
if (family.startsWith("-webkit-"))
family = family.substring(8);
if (family.contains(' '))
family = makeString('"', family, '"');
serializedFont.append(' ');
serializedFont.append(family);
}
return serializedFont.toString();
}
void CanvasRenderingContext2D::setFont(const String& newFont)
{
if (newFont == state().unparsedFont && state().font.realized())
return;
auto parsedStyle = MutableStyleProperties::create();
CSSParser::parseValue(parsedStyle, CSSPropertyFont, newFont, true, strictToCSSParserMode(!m_usesCSSCompatibilityParseMode));
if (parsedStyle->isEmpty())
return;
String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont);
if (fontValue == "inherit" || fontValue == "initial")
return;
String newFontSafeCopy(newFont); realizeSaves();
modifiableState().unparsedFont = newFontSafeCopy;
auto newStyle = RenderStyle::createPtr();
Document& document = canvas().document();
document.updateStyleIfNeeded();
if (auto* computedStyle = canvas().computedStyle())
newStyle->setFontDescription(FontCascadeDescription { computedStyle->fontDescription() });
else {
FontCascadeDescription defaultFontDescription;
defaultFontDescription.setOneFamily(DefaultFontFamily);
defaultFontDescription.setSpecifiedSize(DefaultFontSize);
defaultFontDescription.setComputedSize(DefaultFontSize);
newStyle->setFontDescription(WTFMove(defaultFontDescription));
}
newStyle->fontCascade().update(&document.fontSelector());
StyleResolver& styleResolver = canvas().styleResolver();
styleResolver.applyPropertyToStyle(CSSPropertyFontFamily, parsedStyle->getPropertyCSSValue(CSSPropertyFontFamily).get(), WTFMove(newStyle));
styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontStyle, parsedStyle->getPropertyCSSValue(CSSPropertyFontStyle).get());
styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontVariantCaps, parsedStyle->getPropertyCSSValue(CSSPropertyFontVariantCaps).get());
styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontWeight, parsedStyle->getPropertyCSSValue(CSSPropertyFontWeight).get());
styleResolver.updateFont();
styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontSize, parsedStyle->getPropertyCSSValue(CSSPropertyFontSize).get());
styleResolver.updateFont();
styleResolver.applyPropertyToCurrentStyle(CSSPropertyLineHeight, parsedStyle->getPropertyCSSValue(CSSPropertyLineHeight).get());
modifiableState().font.initialize(document.fontSelector(), *styleResolver.style());
}
static CanvasTextAlign toCanvasTextAlign(TextAlign textAlign)
{
switch (textAlign) {
case StartTextAlign:
return CanvasTextAlign::Start;
case EndTextAlign:
return CanvasTextAlign::End;
case LeftTextAlign:
return CanvasTextAlign::Left;
case RightTextAlign:
return CanvasTextAlign::Right;
case CenterTextAlign:
return CanvasTextAlign::Center;
}
ASSERT_NOT_REACHED();
return CanvasTextAlign::Start;
}
static TextAlign fromCanvasTextAlign(CanvasTextAlign canvasTextAlign)
{
switch (canvasTextAlign) {
case CanvasTextAlign::Start:
return StartTextAlign;
case CanvasTextAlign::End:
return EndTextAlign;
case CanvasTextAlign::Left:
return LeftTextAlign;
case CanvasTextAlign::Right:
return RightTextAlign;
case CanvasTextAlign::Center:
return CenterTextAlign;
}
ASSERT_NOT_REACHED();
return StartTextAlign;
}
CanvasTextAlign CanvasRenderingContext2D::textAlign() const
{
return toCanvasTextAlign(state().textAlign);
}
void CanvasRenderingContext2D::setTextAlign(CanvasTextAlign canvasTextAlign)
{
auto textAlign = fromCanvasTextAlign(canvasTextAlign);
if (state().textAlign == textAlign)
return;
realizeSaves();
modifiableState().textAlign = textAlign;
}
static CanvasTextBaseline toCanvasTextBaseline(TextBaseline textBaseline)
{
switch (textBaseline) {
case TopTextBaseline:
return CanvasTextBaseline::Top;
case HangingTextBaseline:
return CanvasTextBaseline::Hanging;
case MiddleTextBaseline:
return CanvasTextBaseline::Middle;
case AlphabeticTextBaseline:
return CanvasTextBaseline::Alphabetic;
case IdeographicTextBaseline:
return CanvasTextBaseline::Ideographic;
case BottomTextBaseline:
return CanvasTextBaseline::Bottom;
}
ASSERT_NOT_REACHED();
return CanvasTextBaseline::Top;
}
static TextBaseline fromCanvasTextBaseline(CanvasTextBaseline canvasTextBaseline)
{
switch (canvasTextBaseline) {
case CanvasTextBaseline::Top:
return TopTextBaseline;
case CanvasTextBaseline::Hanging:
return HangingTextBaseline;
case CanvasTextBaseline::Middle:
return MiddleTextBaseline;
case CanvasTextBaseline::Alphabetic:
return AlphabeticTextBaseline;
case CanvasTextBaseline::Ideographic:
return IdeographicTextBaseline;
case CanvasTextBaseline::Bottom:
return BottomTextBaseline;
}
ASSERT_NOT_REACHED();
return TopTextBaseline;
}
CanvasTextBaseline CanvasRenderingContext2D::textBaseline() const
{
return toCanvasTextBaseline(state().textBaseline);
}
void CanvasRenderingContext2D::setTextBaseline(CanvasTextBaseline canvasTextBaseline)
{
auto textBaseline = fromCanvasTextBaseline(canvasTextBaseline);
if (state().textBaseline == textBaseline)
return;
realizeSaves();
modifiableState().textBaseline = textBaseline;
}
inline TextDirection CanvasRenderingContext2D::toTextDirection(Direction direction, const RenderStyle** computedStyle) const
{
auto* style = (computedStyle || direction == Direction::Inherit) ? canvas().computedStyle() : nullptr;
if (computedStyle)
*computedStyle = style;
switch (direction) {
case Direction::Inherit:
return style ? style->direction() : LTR;
case Direction::Rtl:
return RTL;
case Direction::Ltr:
return LTR;
}
ASSERT_NOT_REACHED();
return LTR;
}
CanvasDirection CanvasRenderingContext2D::direction() const
{
if (state().direction == Direction::Inherit)
canvas().document().updateStyleIfNeeded();
return toTextDirection(state().direction) == RTL ? CanvasDirection::Rtl : CanvasDirection::Ltr;
}
void CanvasRenderingContext2D::setDirection(CanvasDirection direction)
{
if (state().direction == direction)
return;
realizeSaves();
modifiableState().direction = direction;
}
void CanvasRenderingContext2D::fillText(const String& text, float x, float y, std::optional<float> maxWidth)
{
drawTextInternal(text, x, y, true, maxWidth);
}
void CanvasRenderingContext2D::strokeText(const String& text, float x, float y, std::optional<float> maxWidth)
{
drawTextInternal(text, x, y, false, maxWidth);
}
static inline bool isSpaceThatNeedsReplacing(UChar c)
{
return c == 0x0009 || c == 0x000A || c == 0x000B || c == 0x000C || c == 0x000D;
}
static void normalizeSpaces(String& text)
{
size_t i = text.find(isSpaceThatNeedsReplacing);
if (i == notFound)
return;
unsigned textLength = text.length();
Vector<UChar> charVector(textLength);
StringView(text).getCharactersWithUpconvert(charVector.data());
charVector[i++] = ' ';
for (; i < textLength; ++i) {
if (isSpaceThatNeedsReplacing(charVector[i]))
charVector[i] = ' ';
}
text = String::adopt(WTFMove(charVector));
}
Ref<TextMetrics> CanvasRenderingContext2D::measureText(const String& text)
{
Ref<TextMetrics> metrics = TextMetrics::create();
String normalizedText = text;
normalizeSpaces(normalizedText);
const RenderStyle* computedStyle;
auto direction = toTextDirection(state().direction, &computedStyle);
bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
TextRun textRun(normalizedText, 0, 0, AllowTrailingExpansion, direction, override, true);
auto& font = fontProxy();
auto& fontMetrics = font.fontMetrics();
GlyphOverflow glyphOverflow;
glyphOverflow.computeBounds = true;
float fontWidth = font.width(textRun, &glyphOverflow);
metrics->setWidth(fontWidth);
FloatPoint offset = textOffset(fontWidth, direction);
metrics->setActualBoundingBoxAscent(glyphOverflow.top - offset.y());
metrics->setActualBoundingBoxDescent(glyphOverflow.bottom + offset.y());
metrics->setFontBoundingBoxAscent(fontMetrics.ascent() - offset.y());
metrics->setFontBoundingBoxDescent(fontMetrics.descent() + offset.y());
metrics->setEmHeightAscent(fontMetrics.ascent() - offset.y());
metrics->setEmHeightDescent(fontMetrics.descent() + offset.y());
metrics->setHangingBaseline(fontMetrics.ascent() - offset.y());
metrics->setAlphabeticBaseline(-offset.y());
metrics->setIdeographicBaseline(-fontMetrics.descent() - offset.y());
metrics->setActualBoundingBoxLeft(glyphOverflow.left - offset.x());
metrics->setActualBoundingBoxRight(fontWidth + glyphOverflow.right + offset.x());
return metrics;
}
auto CanvasRenderingContext2D::fontProxy() -> const FontProxy& {
auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
canvas.document().updateStyleIfNeeded();
if (!state().font.realized())
setFont(state().unparsedFont);
return state().font;
}
FloatPoint CanvasRenderingContext2D::textOffset(float width, TextDirection direction)
{
auto& fontMetrics = fontProxy().fontMetrics();
FloatPoint offset;
switch (state().textBaseline) {
case TopTextBaseline:
case HangingTextBaseline:
offset.setY(fontMetrics.ascent());
break;
case BottomTextBaseline:
case IdeographicTextBaseline:
offset.setY(-fontMetrics.descent());
break;
case MiddleTextBaseline:
offset.setY(fontMetrics.height() / 2 - fontMetrics.descent());
break;
case AlphabeticTextBaseline:
default:
break;
}
bool isRTL = direction == RTL;
auto align = state().textAlign;
if (align == StartTextAlign)
align = isRTL ? RightTextAlign : LeftTextAlign;
else if (align == EndTextAlign)
align = isRTL ? LeftTextAlign : RightTextAlign;
switch (align) {
case CenterTextAlign:
offset.setX(-width / 2);
break;
case RightTextAlign:
offset.setX(-width);
break;
default:
break;
}
return offset;
}
void CanvasRenderingContext2D::drawTextInternal(const String& text, float x, float y, bool fill, std::optional<float> maxWidth)
{
auto& fontProxy = this->fontProxy();
const auto& fontMetrics = fontProxy.fontMetrics();
auto* c = drawingContext();
if (!c)
return;
if (!state().hasInvertibleTransform)
return;
if (!std::isfinite(x) | !std::isfinite(y))
return;
if (maxWidth && (!std::isfinite(maxWidth.value()) || maxWidth.value() <= 0))
return;
auto gradient = c->strokeGradient();
if (!fill && gradient && gradient->isZeroSize())
return;
gradient = c->fillGradient();
if (fill && gradient && gradient->isZeroSize())
return;
String normalizedText = text;
normalizeSpaces(normalizedText);
const RenderStyle* computedStyle;
auto direction = toTextDirection(state().direction, &computedStyle);
bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
TextRun textRun(normalizedText, 0, 0, AllowTrailingExpansion, direction, override, true);
float fontWidth = fontProxy.width(textRun);
bool useMaxWidth = maxWidth && maxWidth.value() < fontWidth;
float width = useMaxWidth ? maxWidth.value() : fontWidth;
FloatPoint location(x, y);
location += textOffset(width, direction);
FloatRect textRect = FloatRect(location.x() - fontMetrics.height() / 2, location.y() - fontMetrics.ascent() - fontMetrics.lineGap(),
width + fontMetrics.height(), fontMetrics.lineSpacing());
if (!fill)
inflateStrokeRect(textRect);
#if USE(CG)
const CanvasStyle& drawStyle = fill ? state().fillStyle : state().strokeStyle;
if (drawStyle.canvasGradient() || drawStyle.canvasPattern()) {
IntRect maskRect = enclosingIntRect(textRect);
if (shouldDrawShadows()) {
GraphicsContextStateSaver stateSaver(*c);
FloatSize offset(0, 2 * maskRect.height());
FloatSize shadowOffset;
float shadowRadius;
Color shadowColor;
c->getShadow(shadowOffset, shadowRadius, shadowColor);
FloatRect shadowRect(maskRect);
shadowRect.inflate(shadowRadius * 1.4);
shadowRect.move(shadowOffset * -1);
c->clip(shadowRect);
shadowOffset += offset;
c->setLegacyShadow(shadowOffset, shadowRadius, shadowColor);
if (fill)
c->setFillColor(Color::black);
else
c->setStrokeColor(Color::black);
fontProxy.drawBidiText(*c, textRun, location + offset, FontCascade::UseFallbackIfFontNotReady);
}
auto maskImage = ImageBuffer::createCompatibleBuffer(maskRect.size(), ColorSpaceSRGB, *c);
if (!maskImage)
return;
auto& maskImageContext = maskImage->context();
if (fill)
maskImageContext.setFillColor(Color::black);
else {
maskImageContext.setStrokeColor(Color::black);
maskImageContext.setStrokeThickness(c->strokeThickness());
}
maskImageContext.setTextDrawingMode(fill ? TextModeFill : TextModeStroke);
if (useMaxWidth) {
maskImageContext.translate(location - maskRect.location());
maskImageContext.scale(FloatSize((fontWidth > 0 ? (width / fontWidth) : 0), 1));
fontProxy.drawBidiText(maskImageContext, textRun, FloatPoint(0, 0), FontCascade::UseFallbackIfFontNotReady);
} else {
maskImageContext.translate(-maskRect.location());
fontProxy.drawBidiText(maskImageContext, textRun, location, FontCascade::UseFallbackIfFontNotReady);
}
GraphicsContextStateSaver stateSaver(*c);
c->clipToImageBuffer(*maskImage, maskRect);
drawStyle.applyFillColor(*c);
c->fillRect(maskRect);
return;
}
#endif
c->setTextDrawingMode(fill ? TextModeFill : TextModeStroke);
GraphicsContextStateSaver stateSaver(*c);
if (useMaxWidth) {
c->translate(location);
c->scale(FloatSize((fontWidth > 0 ? (width / fontWidth) : 0), 1));
location = FloatPoint();
}
if (isFullCanvasCompositeMode(state().globalComposite)) {
beginCompositeLayer();
fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
endCompositeLayer();
didDrawEntireCanvas();
} else if (state().globalComposite == CompositeCopy) {
clearCanvas();
fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
didDrawEntireCanvas();
} else {
fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
didDraw(textRect);
}
}
}