HTMLCanvasElement.cpp [plain text]
#include "config.h"
#include "HTMLCanvasElement.h"
#include "CanvasContextAttributes.h"
#include "CanvasRenderingContext2D.h"
#if ENABLE(3D_CANVAS)
#include "WebGLContextAttributes.h"
#include "WebGLRenderingContext.h"
#endif
#include "CanvasGradient.h"
#include "CanvasPattern.h"
#include "CanvasStyle.h"
#include "Chrome.h"
#include "Document.h"
#include "Frame.h"
#include "GraphicsContext.h"
#include "HTMLNames.h"
#include "ImageBuffer.h"
#include "MappedAttribute.h"
#include "Page.h"
#include "RenderHTMLCanvas.h"
#include "Settings.h"
#include <math.h>
#include <stdio.h>
namespace WebCore {
using namespace HTMLNames;
HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document* doc)
: HTMLElement(tagName, doc)
, CanvasSurface(doc->frame() ? doc->frame()->page()->chrome()->scaleFactor() : 1)
, m_observer(0)
, m_ignoreReset(false)
{
ASSERT(hasTagName(canvasTag));
}
HTMLCanvasElement::~HTMLCanvasElement()
{
if (m_observer)
m_observer->canvasDestroyed(this);
}
#if ENABLE(DASHBOARD_SUPPORT)
HTMLTagStatus HTMLCanvasElement::endTagRequirement() const
{
Settings* settings = document()->settings();
if (settings && settings->usesDashboardBackwardCompatibilityMode())
return TagStatusForbidden;
return HTMLElement::endTagRequirement();
}
int HTMLCanvasElement::tagPriority() const
{
Settings* settings = document()->settings();
if (settings && settings->usesDashboardBackwardCompatibilityMode())
return 0;
return HTMLElement::tagPriority();
}
#endif
void HTMLCanvasElement::parseMappedAttribute(MappedAttribute* attr)
{
const QualifiedName& attrName = attr->name();
if (attrName == widthAttr || attrName == heightAttr)
reset();
HTMLElement::parseMappedAttribute(attr);
}
RenderObject* HTMLCanvasElement::createRenderer(RenderArena* arena, RenderStyle* style)
{
Frame* frame = document()->frame();
if (frame && frame->script()->canExecuteScripts(NotAboutToExecuteScript)) {
m_rendererIsCanvas = true;
return new (arena) RenderHTMLCanvas(this);
}
m_rendererIsCanvas = false;
return HTMLElement::createRenderer(arena, style);
}
void HTMLCanvasElement::setHeight(int value)
{
setAttribute(heightAttr, String::number(value));
}
void HTMLCanvasElement::setWidth(int value)
{
setAttribute(widthAttr, String::number(value));
}
CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
{
if (type == "2d") {
if (m_context && !m_context->is2d())
return 0;
if (!m_context) {
bool usesDashbardCompatibilityMode = false;
#if ENABLE(DASHBOARD_SUPPORT)
if (Settings* settings = document()->settings())
usesDashbardCompatibilityMode = settings->usesDashboardBackwardCompatibilityMode();
#endif
m_context = new CanvasRenderingContext2D(this, document()->inCompatMode(), usesDashbardCompatibilityMode);
}
return m_context.get();
}
#if ENABLE(3D_CANVAS)
Settings* settings = document()->settings();
if (settings && settings->webGLEnabled() && settings->acceleratedCompositingEnabled()) {
if ((type == "webkit-3d") ||
(type == "experimental-webgl")) {
if (m_context && !m_context->is3d())
return 0;
if (!m_context) {
m_context = WebGLRenderingContext::create(this, static_cast<WebGLContextAttributes*>(attrs));
if (m_context) {
setNeedsStyleRecalc(SyntheticStyleChange);
}
}
return m_context.get();
}
}
#else
UNUSED_PARAM(attrs);
#endif
return 0;
}
void HTMLCanvasElement::willDraw(const FloatRect& rect)
{
CanvasSurface::willDraw(rect);
if (RenderBox* ro = renderBox()) {
FloatRect destRect = ro->contentBoxRect();
FloatRect r = mapRect(rect, FloatRect(0, 0, size().width(), size().height()), destRect);
r.intersect(destRect);
if (m_dirtyRect.contains(r))
return;
m_dirtyRect.unite(r);
ro->repaintRectangle(enclosingIntRect(m_dirtyRect));
}
if (m_observer)
m_observer->canvasChanged(this, rect);
}
void HTMLCanvasElement::reset()
{
if (m_ignoreReset)
return;
bool ok;
int w = getAttribute(widthAttr).toInt(&ok);
if (!ok)
w = DefaultWidth;
int h = getAttribute(heightAttr).toInt(&ok);
if (!ok)
h = DefaultHeight;
IntSize oldSize = size();
setSurfaceSize(IntSize(w, h));
#if ENABLE(3D_CANVAS)
if (m_context && m_context->is3d())
static_cast<WebGLRenderingContext*>(m_context.get())->reshape(width(), height());
#endif
bool hadImageBuffer = hasCreatedImageBuffer();
if (m_context && m_context->is2d())
static_cast<CanvasRenderingContext2D*>(m_context.get())->reset();
if (RenderObject* renderer = this->renderer()) {
if (m_rendererIsCanvas) {
if (oldSize != size())
toRenderHTMLCanvas(renderer)->canvasSizeChanged();
if (hadImageBuffer)
renderer->repaint();
}
}
if (m_observer)
m_observer->canvasResized(this);
}
void HTMLCanvasElement::paint(GraphicsContext* context, const IntRect& r)
{
m_dirtyRect = FloatRect();
if (context->paintingDisabled())
return;
#if ENABLE(3D_CANVAS)
WebGLRenderingContext* context3D = 0;
if (m_context && m_context->is3d()) {
context3D = static_cast<WebGLRenderingContext*>(m_context.get());
context3D->beginPaint();
}
#endif
if (hasCreatedImageBuffer()) {
ImageBuffer* imageBuffer = buffer();
if (imageBuffer) {
Image* image = imageBuffer->image();
if (image)
context->drawImage(image, DeviceColorSpace, r);
}
}
#if ENABLE(3D_CANVAS)
if (context3D)
context3D->endPaint();
#endif
}
#if ENABLE(3D_CANVAS)
bool HTMLCanvasElement::is3D() const
{
return m_context && m_context->is3d();
}
#endif
}