#include "config.h"
#include "CanvasSurface.h"
#include "AffineTransform.h"
#include "ExceptionCode.h"
#include "FloatRect.h"
#include "GraphicsContext.h"
#include "HTMLCanvasElement.h"
#include "ImageBuffer.h"
#include "MIMETypeRegistry.h"
namespace WebCore {
const int CanvasSurface::DefaultWidth = 300;
const int CanvasSurface::DefaultHeight = 150;
CanvasSurface::CanvasSurface(float pageScaleFactor, float maximumDecodedImageSize)
: m_size(DefaultWidth, DefaultHeight)
, m_pageScaleFactor(pageScaleFactor)
, m_originClean(true)
, m_maximumDecodedImageSize(maximumDecodedImageSize)
, m_hasCreatedImageBuffer(false)
{
}
CanvasSurface::~CanvasSurface()
{
}
void CanvasSurface::setSurfaceSize(const IntSize& size)
{
m_size = size;
m_hasCreatedImageBuffer = false;
m_imageBuffer.clear();
}
String CanvasSurface::toDataURL(const String& mimeType, ExceptionCode& ec)
{
if (!m_originClean) {
ec = SECURITY_ERR;
return String();
}
if (m_size.isEmpty() || !buffer())
return String("data:,");
if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
return buffer()->toDataURL("image/png");
return buffer()->toDataURL(mimeType);
}
void CanvasSurface::willDraw(const FloatRect&)
{
if (m_imageBuffer)
m_imageBuffer->clearImage();
}
IntRect CanvasSurface::convertLogicalToDevice(const FloatRect& logicalRect) const
{
return IntRect(convertLogicalToDevice(logicalRect.location()), convertLogicalToDevice(logicalRect.size()));
}
IntSize CanvasSurface::convertLogicalToDevice(const FloatSize& logicalSize) const
{
float wf = ceilf(logicalSize.width() * m_pageScaleFactor);
float hf = ceilf(logicalSize.height() * m_pageScaleFactor);
if (!(wf >= 1 && hf >= 1 && wf * hf * 4 <= m_maximumDecodedImageSize))
return IntSize();
return IntSize(static_cast<unsigned>(wf), static_cast<unsigned>(hf));
}
IntPoint CanvasSurface::convertLogicalToDevice(const FloatPoint& logicalPos) const
{
float xf = logicalPos.x() * m_pageScaleFactor;
float yf = logicalPos.y() * m_pageScaleFactor;
return IntPoint(static_cast<unsigned>(xf), static_cast<unsigned>(yf));
}
void CanvasSurface::createImageBuffer() const
{
ASSERT(!m_imageBuffer);
m_hasCreatedImageBuffer = true;
FloatSize unscaledSize(width(), height());
IntSize size = convertLogicalToDevice(unscaledSize);
if (!size.width() || !size.height())
return;
m_imageBuffer = ImageBuffer::create(size);
if (!m_imageBuffer)
return;
m_imageBuffer->context()->scale(FloatSize(size.width() / unscaledSize.width(), size.height() / unscaledSize.height()));
m_imageBuffer->context()->setShadowsIgnoreTransforms(true);
}
GraphicsContext* CanvasSurface::drawingContext() const
{
return buffer() ? m_imageBuffer->context() : 0;
}
ImageBuffer* CanvasSurface::buffer() const
{
if (!m_hasCreatedImageBuffer)
createImageBuffer();
return m_imageBuffer.get();
}
AffineTransform CanvasSurface::baseTransform() const
{
ASSERT(m_hasCreatedImageBuffer);
FloatSize unscaledSize(width(), height());
IntSize size = convertLogicalToDevice(unscaledSize);
AffineTransform transform;
if (size.width() && size.height())
transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
transform.multiply(m_imageBuffer->baseTransform());
return transform;
}
const SecurityOrigin& CanvasSurface::securityOrigin() const
{
return *(static_cast<const HTMLCanvasElement*>(this)->document()->securityOrigin());
}
RenderBox* CanvasSurface::renderBox() const
{
return static_cast<const HTMLCanvasElement*>(this)->renderBox();
}
RenderStyle* CanvasSurface::computedStyle()
{
return static_cast<HTMLCanvasElement*>(this)->computedStyle();
}
CSSStyleSelector* CanvasSurface::styleSelector()
{
return static_cast<HTMLCanvasElement*>(this)->document()->styleSelector();
}
}