/* * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved. * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies) * Copyright (C) 2007 Alp Toker * Copyright (C) 2008 Eric Seidel * Copyright (C) 2008 Dirk Schulze * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved. * Copyright (C) 2012 Intel Corporation. All rights reserved. * Copyright (C) 2013 Adobe Systems Incorporated. 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 * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" #include "CanvasRenderingContext2D.h" #include "AffineTransform.h" #include "CSSFontSelector.h" #include "CSSParser.h" #include "CSSPropertyNames.h" #include "CachedImage.h" #include "CanvasGradient.h" #include "CanvasPattern.h" #include "Console.h" #include "DOMPath.h" #include "ExceptionCode.h" #include "ExceptionCodePlaceholder.h" #include "FloatConversion.h" #include "FloatQuad.h" #include "FontCache.h" #include "GraphicsContext.h" #include "HTMLCanvasElement.h" #include "HTMLImageElement.h" #include "HTMLMediaElement.h" #include "HTMLNames.h" #include "HTMLVideoElement.h" #include "ImageData.h" #include "KURL.h" #include "Page.h" #include "RenderHTMLCanvas.h" #include "SecurityOrigin.h" #include "Settings.h" #include "StrokeStyleApplier.h" #include "StylePropertySet.h" #include "StyleResolver.h" #include "TextMetrics.h" #include "TextRun.h" #if USE(ACCELERATED_COMPOSITING) #include "RenderLayer.h" #endif #include #include #include #include #include #if USE(CG) #include #endif using namespace std; namespace WebCore { using namespace HTMLNames; static const int defaultFontSize = 10; static const char* const defaultFontFamily = "sans-serif"; static const char* const defaultFont = "10px sans-serif"; static bool isOriginClean(CachedImage* cachedImage, SecurityOrigin* securityOrigin) { if (!cachedImage->image()->hasSingleSecurityOrigin()) return false; if (cachedImage->passesAccessControlCheck(securityOrigin)) return true; return !securityOrigin->taintsCanvas(cachedImage->response().url()); } class CanvasStrokeStyleApplier : public StrokeStyleApplier { public: CanvasStrokeStyleApplier(CanvasRenderingContext2D* canvasContext) : m_canvasContext(canvasContext) { } virtual void strokeStyle(GraphicsContext* c) { c->setStrokeThickness(m_canvasContext->lineWidth()); c->setLineCap(m_canvasContext->getLineCap()); c->setLineJoin(m_canvasContext->getLineJoin()); c->setMiterLimit(m_canvasContext->miterLimit()); const Vector& lineDash = m_canvasContext->getLineDash(); DashArray convertedLineDash(lineDash.size()); for (size_t i = 0; i < lineDash.size(); ++i) convertedLineDash[i] = static_cast(lineDash[i]); c->setLineDash(convertedLineDash, m_canvasContext->lineDashOffset()); } private: CanvasRenderingContext2D* m_canvasContext; }; CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement* canvas, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode) : CanvasRenderingContext(canvas) , m_stateStack(1) , m_unrealizedSaveCount(0) , m_usesCSSCompatibilityParseMode(usesCSSCompatibilityParseMode) #if ENABLE(DASHBOARD_SUPPORT) , m_usesDashboardCompatibilityMode(usesDashboardCompatibilityMode) #endif { #if !ENABLE(DASHBOARD_SUPPORT) ASSERT_UNUSED(usesDashboardCompatibilityMode, !usesDashboardCompatibilityMode); #endif } void CanvasRenderingContext2D::unwindStateStack() { // Ensure that the state stack in the ImageBuffer's context // is cleared before destruction, to avoid assertions in the // GraphicsContext dtor. if (size_t stackSize = m_stateStack.size()) { if (GraphicsContext* context = canvas()->existingDrawingContext()) { while (--stackSize) context->restore(); } } } CanvasRenderingContext2D::~CanvasRenderingContext2D() { #if !ASSERT_DISABLED unwindStateStack(); #endif } bool CanvasRenderingContext2D::isAccelerated() const { #if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS) if (!canvas()->hasCreatedImageBuffer()) return false; GraphicsContext* context = drawingContext(); return context && context->isAcceleratedContext(); #else return false; #endif } void CanvasRenderingContext2D::reset() { unwindStateStack(); m_stateStack.resize(1); m_stateStack.first() = State(); m_path.clear(); m_unrealizedSaveCount = 0; } CanvasRenderingContext2D::State::State() : m_strokeStyle(Color::black) , m_fillStyle(Color::black) , m_lineWidth(1) , m_lineCap(ButtCap) , m_lineJoin(MiterJoin) , m_miterLimit(10) , m_shadowBlur(0) , m_shadowColor(Color::transparent) , m_globalAlpha(1) , m_globalComposite(CompositeSourceOver) , m_globalBlend(BlendModeNormal) , m_invertibleCTM(true) , m_lineDashOffset(0) , m_imageSmoothingEnabled(true) , m_textAlign(StartTextAlign) , m_textBaseline(AlphabeticTextBaseline) , m_unparsedFont(defaultFont) , m_realizedFont(false) { } CanvasRenderingContext2D::State::State(const State& other) : FontSelectorClient() , m_unparsedStrokeColor(other.m_unparsedStrokeColor) , m_unparsedFillColor(other.m_unparsedFillColor) , m_strokeStyle(other.m_strokeStyle) , m_fillStyle(other.m_fillStyle) , m_lineWidth(other.m_lineWidth) , m_lineCap(other.m_lineCap) , m_lineJoin(other.m_lineJoin) , m_miterLimit(other.m_miterLimit) , m_shadowOffset(other.m_shadowOffset) , m_shadowBlur(other.m_shadowBlur) , m_shadowColor(other.m_shadowColor) , m_globalAlpha(other.m_globalAlpha) , m_globalComposite(other.m_globalComposite) , m_globalBlend(other.m_globalBlend) , m_transform(other.m_transform) , m_invertibleCTM(other.m_invertibleCTM) , m_lineDashOffset(other.m_lineDashOffset) , m_imageSmoothingEnabled(other.m_imageSmoothingEnabled) , m_textAlign(other.m_textAlign) , m_textBaseline(other.m_textBaseline) , m_unparsedFont(other.m_unparsedFont) , m_font(other.m_font) , m_realizedFont(other.m_realizedFont) { if (m_realizedFont) m_font.fontSelector()->registerForInvalidationCallbacks(this); } CanvasRenderingContext2D::State& CanvasRenderingContext2D::State::operator=(const State& other) { if (this == &other) return *this; if (m_realizedFont) m_font.fontSelector()->unregisterForInvalidationCallbacks(this); m_unparsedStrokeColor = other.m_unparsedStrokeColor; m_unparsedFillColor = other.m_unparsedFillColor; m_strokeStyle = other.m_strokeStyle; m_fillStyle = other.m_fillStyle; m_lineWidth = other.m_lineWidth; m_lineCap = other.m_lineCap; m_lineJoin = other.m_lineJoin; m_miterLimit = other.m_miterLimit; m_shadowOffset = other.m_shadowOffset; m_shadowBlur = other.m_shadowBlur; m_shadowColor = other.m_shadowColor; m_globalAlpha = other.m_globalAlpha; m_globalComposite = other.m_globalComposite; m_globalBlend = other.m_globalBlend; m_transform = other.m_transform; m_invertibleCTM = other.m_invertibleCTM; m_imageSmoothingEnabled = other.m_imageSmoothingEnabled; m_textAlign = other.m_textAlign; m_textBaseline = other.m_textBaseline; m_unparsedFont = other.m_unparsedFont; m_font = other.m_font; m_realizedFont = other.m_realizedFont; if (m_realizedFont) m_font.fontSelector()->registerForInvalidationCallbacks(this); return *this; } CanvasRenderingContext2D::State::~State() { if (m_realizedFont) m_font.fontSelector()->unregisterForInvalidationCallbacks(this); } void CanvasRenderingContext2D::State::fontsNeedUpdate(FontSelector* fontSelector) { ASSERT_ARG(fontSelector, fontSelector == m_font.fontSelector()); ASSERT(m_realizedFont); m_font.update(fontSelector); } void CanvasRenderingContext2D::realizeSavesLoop() { ASSERT(m_unrealizedSaveCount); ASSERT(m_stateStack.size() >= 1); GraphicsContext* context = drawingContext(); do { m_stateStack.append(state()); if (context) context->save(); } while (--m_unrealizedSaveCount); } void CanvasRenderingContext2D::restore() { if (m_unrealizedSaveCount) { --m_unrealizedSaveCount; return; } ASSERT(m_stateStack.size() >= 1); if (m_stateStack.size() <= 1) return; m_path.transform(state().m_transform); m_stateStack.removeLast(); m_path.transform(state().m_transform.inverse()); GraphicsContext* c = drawingContext(); if (!c) return; c->restore(); } void CanvasRenderingContext2D::setStrokeStyle(CanvasStyle style) { if (!style.isValid()) return; if (state().m_strokeStyle.isValid() && state().m_strokeStyle.isEquivalentColor(style)) return; if (style.isCurrentColor()) { if (style.hasOverrideAlpha()) style = CanvasStyle(colorWithOverrideAlpha(currentColor(canvas()), style.overrideAlpha())); else style = CanvasStyle(currentColor(canvas())); } else checkOrigin(style.canvasPattern()); realizeSaves(); State& state = modifiableState(); state.m_strokeStyle = style; GraphicsContext* c = drawingContext(); if (!c) return; state.m_strokeStyle.applyStrokeColor(c); state.m_unparsedStrokeColor = String(); } void CanvasRenderingContext2D::setFillStyle(CanvasStyle style) { if (!style.isValid()) return; if (state().m_fillStyle.isValid() && state().m_fillStyle.isEquivalentColor(style)) return; if (style.isCurrentColor()) { if (style.hasOverrideAlpha()) style = CanvasStyle(colorWithOverrideAlpha(currentColor(canvas()), style.overrideAlpha())); else style = CanvasStyle(currentColor(canvas())); } else checkOrigin(style.canvasPattern()); realizeSaves(); State& state = modifiableState(); state.m_fillStyle = style; GraphicsContext* c = drawingContext(); if (!c) return; state.m_fillStyle.applyFillColor(c); state.m_unparsedFillColor = String(); } float CanvasRenderingContext2D::lineWidth() const { return state().m_lineWidth; } void CanvasRenderingContext2D::setLineWidth(float width) { if (!(std::isfinite(width) && width > 0)) return; if (state().m_lineWidth == width) return; realizeSaves(); modifiableState().m_lineWidth = width; GraphicsContext* c = drawingContext(); if (!c) return; c->setStrokeThickness(width); } String CanvasRenderingContext2D::lineCap() const { return lineCapName(state().m_lineCap); } void CanvasRenderingContext2D::setLineCap(const String& s) { LineCap cap; if (!parseLineCap(s, cap)) return; if (state().m_lineCap == cap) return; realizeSaves(); modifiableState().m_lineCap = cap; GraphicsContext* c = drawingContext(); if (!c) return; c->setLineCap(cap); } String CanvasRenderingContext2D::lineJoin() const { return lineJoinName(state().m_lineJoin); } void CanvasRenderingContext2D::setLineJoin(const String& s) { LineJoin join; if (!parseLineJoin(s, join)) return; if (state().m_lineJoin == join) return; realizeSaves(); modifiableState().m_lineJoin = join; GraphicsContext* c = drawingContext(); if (!c) return; c->setLineJoin(join); } float CanvasRenderingContext2D::miterLimit() const { return state().m_miterLimit; } void CanvasRenderingContext2D::setMiterLimit(float limit) { if (!(std::isfinite(limit) && limit > 0)) return; if (state().m_miterLimit == limit) return; realizeSaves(); modifiableState().m_miterLimit = limit; GraphicsContext* c = drawingContext(); if (!c) return; c->setMiterLimit(limit); } float CanvasRenderingContext2D::shadowOffsetX() const { return state().m_shadowOffset.width(); } void CanvasRenderingContext2D::setShadowOffsetX(float x) { if (!std::isfinite(x)) return; if (state().m_shadowOffset.width() == x) return; realizeSaves(); modifiableState().m_shadowOffset.setWidth(x); applyShadow(); } float CanvasRenderingContext2D::shadowOffsetY() const { return state().m_shadowOffset.height(); } void CanvasRenderingContext2D::setShadowOffsetY(float y) { if (!std::isfinite(y)) return; if (state().m_shadowOffset.height() == y) return; realizeSaves(); modifiableState().m_shadowOffset.setHeight(y); applyShadow(); } float CanvasRenderingContext2D::shadowBlur() const { return state().m_shadowBlur; } void CanvasRenderingContext2D::setShadowBlur(float blur) { if (!(std::isfinite(blur) && blur >= 0)) return; if (state().m_shadowBlur == blur) return; realizeSaves(); modifiableState().m_shadowBlur = blur; applyShadow(); } String CanvasRenderingContext2D::shadowColor() const { return Color(state().m_shadowColor).serialized(); } void CanvasRenderingContext2D::setShadowColor(const String& color) { RGBA32 rgba; if (!parseColorOrCurrentColor(rgba, color, canvas())) return; if (state().m_shadowColor == rgba) return; realizeSaves(); modifiableState().m_shadowColor = rgba; applyShadow(); } const Vector& CanvasRenderingContext2D::getLineDash() const { return state().m_lineDash; } static bool lineDashSequenceIsValid(const Vector& dash) { for (size_t i = 0; i < dash.size(); i++) { if (!std::isfinite(dash[i]) || dash[i] < 0) return false; } return true; } void CanvasRenderingContext2D::setLineDash(const Vector& dash) { if (!lineDashSequenceIsValid(dash)) return; realizeSaves(); modifiableState().m_lineDash = dash; // Spec requires the concatenation of two copies the dash list when the // number of elements is odd if (dash.size() % 2) modifiableState().m_lineDash.appendVector(dash); applyLineDash(); } void CanvasRenderingContext2D::setWebkitLineDash(const Vector& dash) { if (!lineDashSequenceIsValid(dash)) return; realizeSaves(); modifiableState().m_lineDash = dash; applyLineDash(); } float CanvasRenderingContext2D::lineDashOffset() const { return state().m_lineDashOffset; } void CanvasRenderingContext2D::setLineDashOffset(float offset) { if (!std::isfinite(offset) || state().m_lineDashOffset == offset) return; realizeSaves(); modifiableState().m_lineDashOffset = offset; applyLineDash(); } float CanvasRenderingContext2D::webkitLineDashOffset() const { return lineDashOffset(); } void CanvasRenderingContext2D::setWebkitLineDashOffset(float offset) { setLineDashOffset(offset); } void CanvasRenderingContext2D::applyLineDash() const { GraphicsContext* c = drawingContext(); if (!c) return; DashArray convertedLineDash(state().m_lineDash.size()); for (size_t i = 0; i < state().m_lineDash.size(); ++i) convertedLineDash[i] = static_cast(state().m_lineDash[i]); c->setLineDash(convertedLineDash, state().m_lineDashOffset); } float CanvasRenderingContext2D::globalAlpha() const { return state().m_globalAlpha; } void CanvasRenderingContext2D::setGlobalAlpha(float alpha) { if (!(alpha >= 0 && alpha <= 1)) return; if (state().m_globalAlpha == alpha) return; realizeSaves(); modifiableState().m_globalAlpha = alpha; GraphicsContext* c = drawingContext(); if (!c) return; c->setAlpha(alpha); } String CanvasRenderingContext2D::globalCompositeOperation() const { return compositeOperatorName(state().m_globalComposite, state().m_globalBlend); } void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operation) { CompositeOperator op = CompositeSourceOver; BlendMode blendMode = BlendModeNormal; if (!parseCompositeAndBlendOperator(operation, op, blendMode)) return; if ((state().m_globalComposite == op) && (state().m_globalBlend == blendMode)) return; realizeSaves(); modifiableState().m_globalComposite = op; modifiableState().m_globalBlend = blendMode; GraphicsContext* c = drawingContext(); if (!c) return; c->setCompositeOperation(op, blendMode); } void CanvasRenderingContext2D::scale(float sx, float sy) { GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; if (!std::isfinite(sx) | !std::isfinite(sy)) return; AffineTransform newTransform = state().m_transform; newTransform.scaleNonUniform(sx, sy); if (state().m_transform == newTransform) return; realizeSaves(); if (!newTransform.isInvertible()) { modifiableState().m_invertibleCTM = false; return; } modifiableState().m_transform = newTransform; c->scale(FloatSize(sx, sy)); m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy)); } void CanvasRenderingContext2D::rotate(float angleInRadians) { GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; if (!std::isfinite(angleInRadians)) return; AffineTransform newTransform = state().m_transform; newTransform.rotate(angleInRadians / piDouble * 180.0); if (state().m_transform == newTransform) return; realizeSaves(); if (!newTransform.isInvertible()) { modifiableState().m_invertibleCTM = false; return; } modifiableState().m_transform = newTransform; c->rotate(angleInRadians); m_path.transform(AffineTransform().rotate(-angleInRadians / piDouble * 180.0)); } void CanvasRenderingContext2D::translate(float tx, float ty) { GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; if (!std::isfinite(tx) | !std::isfinite(ty)) return; AffineTransform newTransform = state().m_transform; newTransform.translate(tx, ty); if (state().m_transform == newTransform) return; realizeSaves(); if (!newTransform.isInvertible()) { modifiableState().m_invertibleCTM = false; return; } modifiableState().m_transform = newTransform; c->translate(tx, ty); m_path.transform(AffineTransform().translate(-tx, -ty)); } void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float m22, float dx, float dy) { GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; if (!std::isfinite(m11) | !std::isfinite(m21) | !std::isfinite(dx) | !std::isfinite(m12) | !std::isfinite(m22) | !std::isfinite(dy)) return; AffineTransform transform(m11, m12, m21, m22, dx, dy); AffineTransform newTransform = state().m_transform * transform; if (state().m_transform == newTransform) return; realizeSaves(); if (!newTransform.isInvertible()) { modifiableState().m_invertibleCTM = false; return; } modifiableState().m_transform = newTransform; c->concatCTM(transform); m_path.transform(transform.inverse()); } void CanvasRenderingContext2D::setTransform(float m11, float m12, float m21, float m22, float dx, float dy) { GraphicsContext* c = drawingContext(); if (!c) return; if (!std::isfinite(m11) | !std::isfinite(m21) | !std::isfinite(dx) | !std::isfinite(m12) | !std::isfinite(m22) | !std::isfinite(dy)) return; AffineTransform ctm = state().m_transform; if (!ctm.isInvertible()) return; realizeSaves(); c->setCTM(canvas()->baseTransform()); modifiableState().m_transform = AffineTransform(); m_path.transform(ctm); modifiableState().m_invertibleCTM = true; transform(m11, m12, m21, m22, dx, dy); } void CanvasRenderingContext2D::setStrokeColor(const String& color) { if (color == state().m_unparsedStrokeColor) return; realizeSaves(); setStrokeStyle(CanvasStyle::createFromString(color, canvas()->document())); modifiableState().m_unparsedStrokeColor = color; } void CanvasRenderingContext2D::setStrokeColor(float grayLevel) { if (state().m_strokeStyle.isValid() && state().m_strokeStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, 1.0f)) return; setStrokeStyle(CanvasStyle(grayLevel, 1.0f)); } void CanvasRenderingContext2D::setStrokeColor(const String& color, float alpha) { setStrokeStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha)); } void CanvasRenderingContext2D::setStrokeColor(float grayLevel, float alpha) { if (state().m_strokeStyle.isValid() && state().m_strokeStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha)) return; setStrokeStyle(CanvasStyle(grayLevel, alpha)); } void CanvasRenderingContext2D::setStrokeColor(float r, float g, float b, float a) { if (state().m_strokeStyle.isValid() && state().m_strokeStyle.isEquivalentRGBA(r, g, b, a)) return; setStrokeStyle(CanvasStyle(r, g, b, a)); } void CanvasRenderingContext2D::setStrokeColor(float c, float m, float y, float k, float a) { if (state().m_strokeStyle.isValid() && state().m_strokeStyle.isEquivalentCMYKA(c, m, y, k, a)) return; setStrokeStyle(CanvasStyle(c, m, y, k, a)); } void CanvasRenderingContext2D::setFillColor(const String& color) { if (color == state().m_unparsedFillColor) return; realizeSaves(); setFillStyle(CanvasStyle::createFromString(color, canvas()->document())); modifiableState().m_unparsedFillColor = color; } void CanvasRenderingContext2D::setFillColor(float grayLevel) { if (state().m_fillStyle.isValid() && state().m_fillStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, 1.0f)) return; setFillStyle(CanvasStyle(grayLevel, 1.0f)); } void CanvasRenderingContext2D::setFillColor(const String& color, float alpha) { setFillStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha)); } void CanvasRenderingContext2D::setFillColor(float grayLevel, float alpha) { if (state().m_fillStyle.isValid() && state().m_fillStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha)) return; setFillStyle(CanvasStyle(grayLevel, alpha)); } void CanvasRenderingContext2D::setFillColor(float r, float g, float b, float a) { if (state().m_fillStyle.isValid() && state().m_fillStyle.isEquivalentRGBA(r, g, b, a)) return; setFillStyle(CanvasStyle(r, g, b, a)); } void CanvasRenderingContext2D::setFillColor(float c, float m, float y, float k, float a) { if (state().m_fillStyle.isValid() && state().m_fillStyle.isEquivalentCMYKA(c, m, y, k, a)) return; setFillStyle(CanvasStyle(c, m, y, k, a)); } void CanvasRenderingContext2D::beginPath() { m_path.clear(); } #if ENABLE(CANVAS_PATH) PassRefPtr CanvasRenderingContext2D::currentPath() { return DOMPath::create(m_path); } void CanvasRenderingContext2D::setCurrentPath(DOMPath* path) { if (!path) return; m_path = path->path(); } #endif static bool validateRectForCanvas(float& x, float& y, float& width, float& height) { if (!std::isfinite(x) | !std::isfinite(y) | !std::isfinite(width) | !std::isfinite(height)) return false; if (!width && !height) return false; if (width < 0) { width = -width; x -= width; } if (height < 0) { height = -height; y -= height; } return true; } #if ENABLE(DASHBOARD_SUPPORT) void CanvasRenderingContext2D::clearPathForDashboardBackwardCompatibilityMode() { if (m_usesDashboardCompatibilityMode) m_path.clear(); } #endif static bool isFullCanvasCompositeMode(CompositeOperator op) { // See 4.8.11.1.3 Compositing // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already // implement the specification's behavior. return op == CompositeSourceIn || op == CompositeSourceOut || op == CompositeDestinationIn || op == CompositeDestinationAtop; } static bool parseWinding(const String& windingRuleString, WindRule& windRule) { if (windingRuleString == "nonzero") windRule = RULE_NONZERO; else if (windingRuleString == "evenodd") windRule = RULE_EVENODD; else return false; return true; } void CanvasRenderingContext2D::fill(const String& windingRuleString) { GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; // If gradient size is zero, then paint nothing. Gradient* gradient = c->fillGradient(); if (gradient && gradient->isZeroSize()) return; if (!m_path.isEmpty()) { WindRule windRule = c->fillRule(); WindRule newWindRule = RULE_NONZERO; if (!parseWinding(windingRuleString, newWindRule)) return; c->setFillRule(newWindRule); if (isFullCanvasCompositeMode(state().m_globalComposite)) { fullCanvasCompositedFill(m_path); didDrawEntireCanvas(); } else if (state().m_globalComposite == CompositeCopy) { clearCanvas(); c->fillPath(m_path); didDrawEntireCanvas(); } else { c->fillPath(m_path); didDraw(m_path.fastBoundingRect()); } c->setFillRule(windRule); } #if ENABLE(DASHBOARD_SUPPORT) clearPathForDashboardBackwardCompatibilityMode(); #endif } void CanvasRenderingContext2D::stroke() { GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; // If gradient size is zero, then paint nothing. Gradient* gradient = c->strokeGradient(); if (gradient && gradient->isZeroSize()) return; if (!m_path.isEmpty()) { FloatRect dirtyRect = m_path.fastBoundingRect(); inflateStrokeRect(dirtyRect); c->strokePath(m_path); didDraw(dirtyRect); } #if ENABLE(DASHBOARD_SUPPORT) clearPathForDashboardBackwardCompatibilityMode(); #endif } void CanvasRenderingContext2D::clip(const String& windingRuleString) { GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; WindRule newWindRule = RULE_NONZERO; if (!parseWinding(windingRuleString, newWindRule)) return; realizeSaves(); c->canvasClip(m_path, newWindRule); #if ENABLE(DASHBOARD_SUPPORT) clearPathForDashboardBackwardCompatibilityMode(); #endif } bool CanvasRenderingContext2D::isPointInPath(const float x, const float y, const String& windingRuleString) { GraphicsContext* c = drawingContext(); if (!c) return false; if (!state().m_invertibleCTM) return false; FloatPoint point(x, y); AffineTransform ctm = state().m_transform; FloatPoint transformedPoint = ctm.inverse().mapPoint(point); if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y())) return false; WindRule windRule = RULE_NONZERO; if (!parseWinding(windingRuleString, windRule)) return false; return m_path.contains(transformedPoint, windRule); } bool CanvasRenderingContext2D::isPointInStroke(const float x, const float y) { GraphicsContext* c = drawingContext(); if (!c) return false; if (!state().m_invertibleCTM) return false; FloatPoint point(x, y); AffineTransform ctm = state().m_transform; FloatPoint transformedPoint = ctm.inverse().mapPoint(point); if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y())) return false; CanvasStrokeStyleApplier applier(this); return m_path.strokeContains(&applier, transformedPoint); } void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height) { if (!validateRectForCanvas(x, y, width, height)) return; GraphicsContext* context = drawingContext(); if (!context) return; if (!state().m_invertibleCTM) return; FloatRect rect(x, y, width, height); bool saved = false; if (shouldDrawShadows()) { context->save(); saved = true; context->setLegacyShadow(FloatSize(), 0, Color::transparent, ColorSpaceDeviceRGB); } if (state().m_globalAlpha != 1) { if (!saved) { context->save(); saved = true; } context->setAlpha(1); } if (state().m_globalComposite != CompositeSourceOver) { if (!saved) { context->save(); saved = true; } context->setCompositeOperation(CompositeSourceOver); } context->clearRect(rect); if (saved) context->restore(); didDraw(rect); } void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height) { if (!validateRectForCanvas(x, y, width, height)) return; GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; // from the HTML5 Canvas spec: // If x0 = x1 and y0 = y1, then the linear gradient must paint nothing // If x0 = x1 and y0 = y1 and r0 = r1, then the radial gradient must paint nothing Gradient* gradient = c->fillGradient(); if (gradient && gradient->isZeroSize()) return; FloatRect rect(x, y, width, height); if (rectContainsCanvas(rect)) { c->fillRect(rect); didDrawEntireCanvas(); } else if (isFullCanvasCompositeMode(state().m_globalComposite)) { fullCanvasCompositedFill(rect); didDrawEntireCanvas(); } else if (state().m_globalComposite == CompositeCopy) { clearCanvas(); c->fillRect(rect); didDrawEntireCanvas(); } else { c->fillRect(rect); didDraw(rect); } } void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height) { if (!validateRectForCanvas(x, y, width, height)) return; GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; if (!(state().m_lineWidth >= 0)) return; // If gradient size is zero, then paint nothing. Gradient* gradient = c->strokeGradient(); if (gradient && gradient->isZeroSize()) return; FloatRect rect(x, y, width, height); FloatRect boundingRect = rect; boundingRect.inflate(state().m_lineWidth / 2); c->strokeRect(rect, state().m_lineWidth); didDraw(boundingRect); } void CanvasRenderingContext2D::setShadow(float width, float height, float blur) { setShadow(FloatSize(width, height), blur, Color::transparent); } void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color) { RGBA32 rgba; if (!parseColorOrCurrentColor(rgba, color, canvas())) return; setShadow(FloatSize(width, height), blur, rgba); } void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel) { setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(grayLevel, grayLevel, grayLevel, 1)); } void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color, float alpha) { RGBA32 rgba; if (!parseColorOrCurrentColor(rgba, color, canvas())) return; setShadow(FloatSize(width, height), blur, colorWithOverrideAlpha(rgba, alpha)); } void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel, float alpha) { setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(grayLevel, grayLevel, grayLevel, alpha)); } void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float r, float g, float b, float a) { setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(r, g, b, a)); } void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a) { setShadow(FloatSize(width, height), blur, makeRGBAFromCMYKA(c, m, y, k, a)); } void CanvasRenderingContext2D::clearShadow() { setShadow(FloatSize(), 0, Color::transparent); } void CanvasRenderingContext2D::setShadow(const FloatSize& offset, float blur, RGBA32 color) { if (state().m_shadowOffset == offset && state().m_shadowBlur == blur && state().m_shadowColor == color) return; bool wasDrawingShadows = shouldDrawShadows(); realizeSaves(); modifiableState().m_shadowOffset = offset; modifiableState().m_shadowBlur = blur; modifiableState().m_shadowColor = color; if (!wasDrawingShadows && !shouldDrawShadows()) return; applyShadow(); } void CanvasRenderingContext2D::applyShadow() { GraphicsContext* c = drawingContext(); if (!c) return; if (shouldDrawShadows()) { float width = state().m_shadowOffset.width(); float height = state().m_shadowOffset.height(); c->setLegacyShadow(FloatSize(width, -height), state().m_shadowBlur, state().m_shadowColor, ColorSpaceDeviceRGB); } else c->setLegacyShadow(FloatSize(), 0, Color::transparent, ColorSpaceDeviceRGB); } bool CanvasRenderingContext2D::shouldDrawShadows() const { return alphaChannel(state().m_shadowColor) && (state().m_shadowBlur || !state().m_shadowOffset.isZero()); } static LayoutSize size(HTMLImageElement* image) { if (CachedImage* cachedImage = image->cachedImage()) return cachedImage->imageSizeForRenderer(image->renderer(), 1.0f); // FIXME: Not sure about this. return IntSize(); } #if ENABLE(VIDEO) static IntSize size(HTMLVideoElement* video) { if (MediaPlayer* player = video->player()) return player->naturalSize(); return IntSize(); } #endif static inline FloatRect normalizeRect(const FloatRect& rect) { return FloatRect(min(rect.x(), rect.maxX()), min(rect.y(), rect.maxY()), max(rect.width(), -rect.width()), max(rect.height(), -rect.height())); } void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, float x, float y, ExceptionCode& ec) { if (!image) { ec = TYPE_MISMATCH_ERR; return; } LayoutSize s = size(image); drawImage(image, x, y, s.width(), s.height(), ec); } void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, float x, float y, float width, float height, ExceptionCode& ec) { if (!image) { ec = TYPE_MISMATCH_ERR; return; } LayoutSize s = size(image); drawImage(image, FloatRect(0, 0, s.width(), s.height()), FloatRect(x, y, width, height), ec); } void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode& ec) { drawImage(image, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), ec); } void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode& ec) { drawImage(image, srcRect, dstRect, state().m_globalComposite, state().m_globalBlend, ec); } void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator& op, const BlendMode& blendMode, ExceptionCode& ec) { if (!image) { ec = TYPE_MISMATCH_ERR; return; } ec = 0; if (!std::isfinite(dstRect.x()) || !std::isfinite(dstRect.y()) || !std::isfinite(dstRect.width()) || !std::isfinite(dstRect.height()) || !std::isfinite(srcRect.x()) || !std::isfinite(srcRect.y()) || !std::isfinite(srcRect.width()) || !std::isfinite(srcRect.height())) return; if (!dstRect.width() || !dstRect.height()) return; if (!image->complete()) return; FloatRect normalizedSrcRect = normalizeRect(srcRect); FloatRect normalizedDstRect = normalizeRect(dstRect); FloatRect imageRect = FloatRect(FloatPoint(), size(image)); if (!srcRect.width() || !srcRect.height()) { ec = INDEX_SIZE_ERR; return; } if (!imageRect.contains(normalizedSrcRect)) return; GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; CachedImage* cachedImage = image->cachedImage(); if (!cachedImage) return; checkOrigin(image); if (rectContainsCanvas(normalizedDstRect)) { c->drawImage(cachedImage->imageForRenderer(image->renderer()), ColorSpaceDeviceRGB, normalizedDstRect, normalizedSrcRect, op, blendMode); didDrawEntireCanvas(); } else if (isFullCanvasCompositeMode(op)) { fullCanvasCompositedDrawImage(cachedImage->imageForRenderer(image->renderer()), ColorSpaceDeviceRGB, normalizedDstRect, normalizedSrcRect, op); didDrawEntireCanvas(); } else if (op == CompositeCopy) { clearCanvas(); c->drawImage(cachedImage->imageForRenderer(image->renderer()), ColorSpaceDeviceRGB, normalizedDstRect, normalizedSrcRect, op, blendMode); didDrawEntireCanvas(); } else { c->drawImage(cachedImage->imageForRenderer(image->renderer()), ColorSpaceDeviceRGB, normalizedDstRect, normalizedSrcRect, op, blendMode); didDraw(normalizedDstRect); } } void CanvasRenderingContext2D::drawImage(HTMLCanvasElement* sourceCanvas, float x, float y, ExceptionCode& ec) { drawImage(sourceCanvas, 0, 0, sourceCanvas->width(), sourceCanvas->height(), x, y, sourceCanvas->width(), sourceCanvas->height(), ec); } void CanvasRenderingContext2D::drawImage(HTMLCanvasElement* sourceCanvas, float x, float y, float width, float height, ExceptionCode& ec) { drawImage(sourceCanvas, FloatRect(0, 0, sourceCanvas->width(), sourceCanvas->height()), FloatRect(x, y, width, height), ec); } void CanvasRenderingContext2D::drawImage(HTMLCanvasElement* sourceCanvas, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode& ec) { drawImage(sourceCanvas, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), ec); } void CanvasRenderingContext2D::drawImage(HTMLCanvasElement* sourceCanvas, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode& ec) { if (!sourceCanvas) { ec = TYPE_MISMATCH_ERR; return; } FloatRect srcCanvasRect = FloatRect(FloatPoint(), sourceCanvas->size()); if (!srcCanvasRect.width() || !srcCanvasRect.height()) { ec = INVALID_STATE_ERR; return; } if (!srcRect.width() || !srcRect.height()) { ec = INDEX_SIZE_ERR; return; } ec = 0; if (!srcCanvasRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height()) return; GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; // FIXME: Do this through platform-independent GraphicsContext API. ImageBuffer* buffer = sourceCanvas->buffer(); if (!buffer) return; checkOrigin(sourceCanvas); #if ENABLE(ACCELERATED_2D_CANVAS) // If we're drawing from one accelerated canvas 2d to another, avoid calling sourceCanvas->makeRenderingResultsAvailable() // as that will do a readback to software. CanvasRenderingContext* sourceContext = sourceCanvas->renderingContext(); // FIXME: Implement an accelerated path for drawing from a WebGL canvas to a 2d canvas when possible. if (!isAccelerated() || !sourceContext || !sourceContext->isAccelerated() || !sourceContext->is2d()) sourceCanvas->makeRenderingResultsAvailable(); #else sourceCanvas->makeRenderingResultsAvailable(); #endif if (rectContainsCanvas(dstRect)) { c->drawImageBuffer(buffer, ColorSpaceDeviceRGB, dstRect, srcRect, state().m_globalComposite, state().m_globalBlend); didDrawEntireCanvas(); } else if (isFullCanvasCompositeMode(state().m_globalComposite)) { fullCanvasCompositedDrawImage(buffer, ColorSpaceDeviceRGB, dstRect, srcRect, state().m_globalComposite); didDrawEntireCanvas(); } else if (state().m_globalComposite == CompositeCopy) { clearCanvas(); c->drawImageBuffer(buffer, ColorSpaceDeviceRGB, dstRect, srcRect, state().m_globalComposite, state().m_globalBlend); didDrawEntireCanvas(); } else { c->drawImageBuffer(buffer, ColorSpaceDeviceRGB, dstRect, srcRect, state().m_globalComposite, state().m_globalBlend); didDraw(dstRect); } } #if ENABLE(VIDEO) void CanvasRenderingContext2D::drawImage(HTMLVideoElement* video, float x, float y, ExceptionCode& ec) { if (!video) { ec = TYPE_MISMATCH_ERR; return; } IntSize s = size(video); drawImage(video, x, y, s.width(), s.height(), ec); } void CanvasRenderingContext2D::drawImage(HTMLVideoElement* video, float x, float y, float width, float height, ExceptionCode& ec) { if (!video) { ec = TYPE_MISMATCH_ERR; return; } IntSize s = size(video); drawImage(video, FloatRect(0, 0, s.width(), s.height()), FloatRect(x, y, width, height), ec); } void CanvasRenderingContext2D::drawImage(HTMLVideoElement* video, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode& ec) { drawImage(video, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), ec); } void CanvasRenderingContext2D::drawImage(HTMLVideoElement* video, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode& ec) { if (!video) { ec = TYPE_MISMATCH_ERR; return; } ec = 0; if (video->readyState() == HTMLMediaElement::HAVE_NOTHING || video->readyState() == HTMLMediaElement::HAVE_METADATA) return; FloatRect videoRect = FloatRect(FloatPoint(), size(video)); if (!srcRect.width() || !srcRect.height()) { ec = INDEX_SIZE_ERR; return; } if (!videoRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height()) return; GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; checkOrigin(video); GraphicsContextStateSaver stateSaver(*c); c->clip(dstRect); c->translate(dstRect.x(), dstRect.y()); c->scale(FloatSize(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height())); c->translate(-srcRect.x(), -srcRect.y()); video->paintCurrentFrameInContext(c, IntRect(IntPoint(), size(video))); stateSaver.restore(); didDraw(dstRect); } #endif void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation) { CompositeOperator op; BlendMode blendOp = BlendModeNormal; if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != BlendModeNormal) op = CompositeSourceOver; drawImage(image, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), op, BlendModeNormal, IGNORE_EXCEPTION); } void CanvasRenderingContext2D::setAlpha(float alpha) { setGlobalAlpha(alpha); } void CanvasRenderingContext2D::setCompositeOperation(const String& operation) { setGlobalCompositeOperation(operation); } void CanvasRenderingContext2D::clearCanvas() { FloatRect canvasRect(0, 0, canvas()->width(), canvas()->height()); GraphicsContext* c = drawingContext(); if (!c) return; c->save(); c->setCTM(canvas()->baseTransform()); c->clearRect(canvasRect); c->restore(); } Path CanvasRenderingContext2D::transformAreaToDevice(const Path& path) const { Path transformed(path); transformed.transform(state().m_transform); transformed.transform(canvas()->baseTransform()); return transformed; } Path CanvasRenderingContext2D::transformAreaToDevice(const FloatRect& rect) const { Path path; path.addRect(rect); return transformAreaToDevice(path); } bool CanvasRenderingContext2D::rectContainsCanvas(const FloatRect& rect) const { FloatQuad quad(rect); FloatQuad canvasQuad(FloatRect(0, 0, canvas()->width(), canvas()->height())); return state().m_transform.mapQuad(quad).containsQuad(canvasQuad); } template IntRect CanvasRenderingContext2D::calculateCompositingBufferRect(const T& area, IntSize* croppedOffset) { IntRect canvasRect(0, 0, canvas()->width(), canvas()->height()); canvasRect = canvas()->baseTransform().mapRect(canvasRect); Path path = transformAreaToDevice(area); IntRect bufferRect = enclosingIntRect(path.fastBoundingRect()); IntPoint originalLocation = bufferRect.location(); bufferRect.intersect(canvasRect); if (croppedOffset) *croppedOffset = originalLocation - bufferRect.location(); return bufferRect; } PassOwnPtr CanvasRenderingContext2D::createCompositingBuffer(const IntRect& bufferRect) { RenderingMode renderMode = isAccelerated() ? Accelerated : Unaccelerated; return ImageBuffer::create(bufferRect.size(), 1, ColorSpaceDeviceRGB, renderMode); } void CanvasRenderingContext2D::compositeBuffer(ImageBuffer* buffer, const IntRect& bufferRect, CompositeOperator op) { IntRect canvasRect(0, 0, canvas()->width(), canvas()->height()); canvasRect = canvas()->baseTransform().mapRect(canvasRect); GraphicsContext* c = drawingContext(); if (!c) return; c->save(); c->setCTM(AffineTransform()); c->setCompositeOperation(op); c->save(); c->clipOut(bufferRect); c->clearRect(canvasRect); c->restore(); c->drawImageBuffer(buffer, ColorSpaceDeviceRGB, bufferRect.location(), state().m_globalComposite); c->restore(); } static void drawImageToContext(Image* image, GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& dest, const FloatRect& src, CompositeOperator op) { context->drawImage(image, styleColorSpace, dest, src, op); } static void drawImageToContext(ImageBuffer* imageBuffer, GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& dest, const FloatRect& src, CompositeOperator op) { context->drawImageBuffer(imageBuffer, styleColorSpace, dest, src, op); } template void CanvasRenderingContext2D::fullCanvasCompositedDrawImage(T* image, ColorSpace styleColorSpace, const FloatRect& dest, const FloatRect& src, CompositeOperator op) { ASSERT(isFullCanvasCompositeMode(op)); IntSize croppedOffset; IntRect bufferRect = calculateCompositingBufferRect(dest, &croppedOffset); if (bufferRect.isEmpty()) { clearCanvas(); return; } OwnPtr buffer = createCompositingBuffer(bufferRect); if (!buffer) return; GraphicsContext* c = drawingContext(); if (!c) return; FloatRect adjustedDest = dest; adjustedDest.setLocation(FloatPoint(0, 0)); AffineTransform effectiveTransform = c->getCTM(); IntRect transformedAdjustedRect = enclosingIntRect(effectiveTransform.mapRect(adjustedDest)); buffer->context()->translate(-transformedAdjustedRect.location().x(), -transformedAdjustedRect.location().y()); buffer->context()->translate(croppedOffset.width(), croppedOffset.height()); buffer->context()->concatCTM(effectiveTransform); drawImageToContext(image, buffer->context(), styleColorSpace, adjustedDest, src, CompositeSourceOver); compositeBuffer(buffer.get(), bufferRect, op); } template void CanvasRenderingContext2D::fullCanvasCompositedFill(const T& area) { ASSERT(isFullCanvasCompositeMode(state().m_globalComposite)); IntRect bufferRect = calculateCompositingBufferRect(area, 0); if (bufferRect.isEmpty()) { clearCanvas(); return; } OwnPtr buffer = createCompositingBuffer(bufferRect); if (!buffer) return; Path path = transformAreaToDevice(area); path.translate(FloatSize(-bufferRect.x(), -bufferRect.y())); buffer->context()->setCompositeOperation(CompositeSourceOver); modifiableState().m_fillStyle.applyFillColor(buffer->context()); buffer->context()->fillPath(path); compositeBuffer(buffer.get(), bufferRect, state().m_globalComposite); } void CanvasRenderingContext2D::prepareGradientForDashboard(CanvasGradient* gradient) const { #if ENABLE(DASHBOARD_SUPPORT) if (m_usesDashboardCompatibilityMode) gradient->setDashboardCompatibilityMode(); #else UNUSED_PARAM(gradient); #endif } PassRefPtr CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1, ExceptionCode& ec) { if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(x1) || !std::isfinite(y1)) { ec = NOT_SUPPORTED_ERR; return 0; } RefPtr gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1)); prepareGradientForDashboard(gradient.get()); return gradient.release(); } PassRefPtr CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionCode& ec) { if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(r0) || !std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(r1)) { ec = NOT_SUPPORTED_ERR; return 0; } if (r0 < 0 || r1 < 0) { ec = INDEX_SIZE_ERR; return 0; } RefPtr gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1); prepareGradientForDashboard(gradient.get()); return gradient.release(); } PassRefPtr CanvasRenderingContext2D::createPattern(HTMLImageElement* image, const String& repetitionType, ExceptionCode& ec) { if (!image) { ec = TYPE_MISMATCH_ERR; return 0; } bool repeatX, repeatY; ec = 0; CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY, ec); if (ec) return 0; if (!image->complete()) return 0; CachedImage* cachedImage = image->cachedImage(); if (!cachedImage || !image->cachedImage()->imageForRenderer(image->renderer())) return CanvasPattern::create(Image::nullImage(), repeatX, repeatY, true); bool originClean = isOriginClean(cachedImage, canvas()->securityOrigin()); return CanvasPattern::create(cachedImage->imageForRenderer(image->renderer()), repeatX, repeatY, originClean); } PassRefPtr CanvasRenderingContext2D::createPattern(HTMLCanvasElement* canvas, const String& repetitionType, ExceptionCode& ec) { if (!canvas) { ec = TYPE_MISMATCH_ERR; return 0; } if (!canvas->width() || !canvas->height()) { ec = INVALID_STATE_ERR; return 0; } bool repeatX, repeatY; ec = 0; CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY, ec); if (ec) return 0; return CanvasPattern::create(canvas->copiedImage(), repeatX, repeatY, canvas->originClean()); } void CanvasRenderingContext2D::didDrawEntireCanvas() { didDraw(FloatRect(FloatPoint::zero(), canvas()->size()), CanvasDidDrawApplyClip); } void CanvasRenderingContext2D::didDraw(const FloatRect& r, unsigned options) { GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; #if ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING) // If we are drawing to hardware and we have a composited layer, just call contentChanged(). if (isAccelerated()) { RenderBox* renderBox = canvas()->renderBox(); if (renderBox && renderBox->hasAcceleratedCompositing()) { renderBox->contentChanged(CanvasPixelsChanged); canvas()->clearCopiedImage(); canvas()->notifyObserversCanvasChanged(r); return; } } #endif FloatRect dirtyRect = r; if (options & CanvasDidDrawApplyTransform) { AffineTransform ctm = state().m_transform; dirtyRect = ctm.mapRect(r); } if (options & CanvasDidDrawApplyShadow && alphaChannel(state().m_shadowColor)) { // The shadow gets applied after transformation FloatRect shadowRect(dirtyRect); shadowRect.move(state().m_shadowOffset); shadowRect.inflate(state().m_shadowBlur); dirtyRect.unite(shadowRect); } if (options & CanvasDidDrawApplyClip) { // FIXME: apply the current clip to the rectangle. Unfortunately we can't get the clip // back out of the GraphicsContext, so to take clip into account for incremental painting, // we'd have to keep the clip path around. } canvas()->didDraw(dirtyRect); } GraphicsContext* CanvasRenderingContext2D::drawingContext() const { return canvas()->drawingContext(); } static PassRefPtr createEmptyImageData(const IntSize& size) { Checked dataSize = 4; dataSize *= size.width(); dataSize *= size.height(); if (dataSize.hasOverflowed()) return 0; RefPtr data = ImageData::create(size); data->data()->zeroFill(); return data.release(); } PassRefPtr CanvasRenderingContext2D::createImageData(PassRefPtr imageData, ExceptionCode& ec) const { if (!imageData) { ec = NOT_SUPPORTED_ERR; return 0; } return createEmptyImageData(imageData->size()); } PassRefPtr CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionCode& ec) const { ec = 0; if (!sw || !sh) { ec = INDEX_SIZE_ERR; return 0; } if (!std::isfinite(sw) || !std::isfinite(sh)) { ec = NOT_SUPPORTED_ERR; return 0; } FloatSize logicalSize(fabs(sw), fabs(sh)); if (!logicalSize.isExpressibleAsIntSize()) return 0; IntSize size = expandedIntSize(logicalSize); if (size.width() < 1) size.setWidth(1); if (size.height() < 1) size.setHeight(1); return createEmptyImageData(size); } PassRefPtr CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh, ExceptionCode& ec) const { return getImageData(ImageBuffer::LogicalCoordinateSystem, sx, sy, sw, sh, ec); } PassRefPtr CanvasRenderingContext2D::webkitGetImageDataHD(float sx, float sy, float sw, float sh, ExceptionCode& ec) const { return getImageData(ImageBuffer::BackingStoreCoordinateSystem, sx, sy, sw, sh, ec); } PassRefPtr CanvasRenderingContext2D::getImageData(ImageBuffer::CoordinateSystem coordinateSystem, float sx, float sy, float sw, float sh, ExceptionCode& ec) const { if (!canvas()->originClean()) { DEFINE_STATIC_LOCAL(String, consoleMessage, (ASCIILiteral("Unable to get image data from canvas because the canvas has been tainted by cross-origin data."))); canvas()->document()->addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, consoleMessage); ec = SECURITY_ERR; return 0; } if (!sw || !sh) { ec = INDEX_SIZE_ERR; return 0; } if (!std::isfinite(sx) || !std::isfinite(sy) || !std::isfinite(sw) || !std::isfinite(sh)) { ec = NOT_SUPPORTED_ERR; return 0; } if (sw < 0) { sx += sw; sw = -sw; } if (sh < 0) { sy += sh; sh = -sh; } FloatRect logicalRect(sx, sy, sw, sh); if (logicalRect.width() < 1) logicalRect.setWidth(1); if (logicalRect.height() < 1) logicalRect.setHeight(1); if (!logicalRect.isExpressibleAsIntRect()) return 0; IntRect imageDataRect = enclosingIntRect(logicalRect); ImageBuffer* buffer = canvas()->buffer(); if (!buffer) return createEmptyImageData(imageDataRect.size()); RefPtr byteArray = buffer->getUnmultipliedImageData(imageDataRect, coordinateSystem); if (!byteArray) return 0; return ImageData::create(imageDataRect.size(), byteArray.release()); } void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy, ExceptionCode& ec) { if (!data) { ec = TYPE_MISMATCH_ERR; return; } putImageData(data, dx, dy, 0, 0, data->width(), data->height(), ec); } void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData* data, float dx, float dy, ExceptionCode& ec) { if (!data) { ec = TYPE_MISMATCH_ERR; return; } webkitPutImageDataHD(data, dx, dy, 0, 0, data->width(), data->height(), ec); } void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode& ec) { putImageData(data, ImageBuffer::LogicalCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight, ec); } void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData* data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode& ec) { putImageData(data, ImageBuffer::BackingStoreCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight, ec); } void CanvasRenderingContext2D::putImageData(ImageData* data, ImageBuffer::CoordinateSystem coordinateSystem, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode& ec) { if (!data) { ec = TYPE_MISMATCH_ERR; return; } if (!std::isfinite(dx) || !std::isfinite(dy) || !std::isfinite(dirtyX) || !std::isfinite(dirtyY) || !std::isfinite(dirtyWidth) || !std::isfinite(dirtyHeight)) { ec = NOT_SUPPORTED_ERR; return; } ImageBuffer* buffer = canvas()->buffer(); if (!buffer) return; if (dirtyWidth < 0) { dirtyX += dirtyWidth; dirtyWidth = -dirtyWidth; } if (dirtyHeight < 0) { dirtyY += dirtyHeight; dirtyHeight = -dirtyHeight; } FloatRect clipRect(dirtyX, dirtyY, dirtyWidth, dirtyHeight); clipRect.intersect(IntRect(0, 0, data->width(), data->height())); IntSize destOffset(static_cast(dx), static_cast(dy)); IntRect destRect = enclosingIntRect(clipRect); destRect.move(destOffset); destRect.intersect(IntRect(IntPoint(), coordinateSystem == ImageBuffer::LogicalCoordinateSystem ? buffer->logicalSize() : buffer->internalSize())); if (destRect.isEmpty()) return; IntRect sourceRect(destRect); sourceRect.move(-destOffset); buffer->putByteArray(Unmultiplied, data->data(), IntSize(data->width(), data->height()), sourceRect, IntPoint(destOffset), coordinateSystem); if (coordinateSystem == ImageBuffer::BackingStoreCoordinateSystem) { FloatRect dirtyRect = destRect; dirtyRect.scale(1 / canvas()->deviceScaleFactor()); destRect = enclosingIntRect(dirtyRect); } didDraw(destRect, CanvasDidDrawApplyNone); // ignore transform, shadow and clip } String CanvasRenderingContext2D::font() const { if (!state().m_realizedFont) return defaultFont; StringBuilder serializedFont; const FontDescription& fontDescription = state().m_font.fontDescription(); if (fontDescription.italic()) serializedFont.appendLiteral("italic "); if (fontDescription.smallCaps() == FontSmallCapsOn) serializedFont.appendLiteral("small-caps "); serializedFont.appendNumber(fontDescription.computedPixelSize()); serializedFont.appendLiteral("px"); for (unsigned i = 0; i < state().m_font.familyCount(); ++i) { if (i) serializedFont.append(','); // FIXME: We should append family directly to serializedFont rather than building a temporary string. String family = state().m_font.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().m_unparsedFont && state().m_realizedFont) return; RefPtr parsedStyle = MutableStylePropertySet::create(); CSSParser::parseValue(parsedStyle.get(), CSSPropertyFont, newFont, true, strictToCSSParserMode(!m_usesCSSCompatibilityParseMode), 0); if (parsedStyle->isEmpty()) return; String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont); // According to http://lists.w3.org/Archives/Public/public-html/2009Jul/0947.html, // the "inherit" and "initial" values must be ignored. if (fontValue == "inherit" || fontValue == "initial") return; // The parse succeeded. String newFontSafeCopy(newFont); // Create a string copy since newFont can be deleted inside realizeSaves. realizeSaves(); modifiableState().m_unparsedFont = newFontSafeCopy; // Map the