WebCore/html/HTMLCanvasElement.cpp

   1 /*
   2  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
   3  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "HTMLCanvasElement.h"
  29
  30 #include "CanvasGradient.h"
  31 #include "CanvasPattern.h"
  32 #include "CanvasRenderingContext2D.h"
  33 #include "CanvasStyle.h"
  34 #include "Chrome.h"
  35 #include "Document.h"
  36 #include "ExceptionCode.h"
  37 #include "Frame.h"
  38 #include "GraphicsContext.h"
  39 #include "HTMLNames.h"
  40 #include "ImageBuffer.h"
  41 #include "MIMETypeRegistry.h"
  42 #include "Page.h"
  43 #include "RenderHTMLCanvas.h"
  44 #include "Settings.h"
  45 #include <kjs/interpreter.h>
  46 #include <math.h>
  47 #include <stdio.h>
  48
  49 #if PLATFORM(QT)
  50 #include <QPainter>
  51 #include <QPixmap>
  52 #elif PLATFORM(CAIRO)
  53 #include <cairo.h>
  54 #endif
  55
  56 namespace WebCore {
  57
  58 using namespace HTMLNames;
  59
  60 // These values come from the WhatWG spec.
  61 static const int defaultWidth = 300;
  62 static const int defaultHeight = 150;
  63
  64 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
  65 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
  66 // in exchange for a smaller maximum canvas size.
  67 const float HTMLCanvasElement::MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
  68
  69 HTMLCanvasElement::HTMLCanvasElement(Document* doc)
  70     : HTMLElement(canvasTag, doc)
  71     , m_size(defaultWidth, defaultHeight)
  72     , m_observer(0)
  73     , m_originClean(true)
  74     , m_ignoreReset(false)
  75     , m_createdImageBuffer(false)
  76 {
  77 }
  78
  79 HTMLCanvasElement::~HTMLCanvasElement()
  80 {
  81     if (m_2DContext)
  82         m_2DContext->detachCanvas();
  83 }
  84
  85 #if ENABLE(DASHBOARD_SUPPORT)
  86
  87 HTMLTagStatus HTMLCanvasElement::endTagRequirement() const
  88 {
  89     Settings* settings = document()->settings();
  90     if (settings && settings->usesDashboardBackwardCompatibilityMode())
  91         return TagStatusForbidden;
  92
  93     return HTMLElement::endTagRequirement();
  94 }
  95
  96 int HTMLCanvasElement::tagPriority() const
  97 {
  98     Settings* settings = document()->settings();
  99     if (settings && settings->usesDashboardBackwardCompatibilityMode())
 100         return 0;
 101
 102     return HTMLElement::tagPriority();
 103 }
 104
 105 #endif
 106
 107 void HTMLCanvasElement::parseMappedAttribute(MappedAttribute* attr)
 108 {
 109     const QualifiedName& attrName = attr->name();
 110     if (attrName == widthAttr || attrName == heightAttr)
 111         reset();
 112     HTMLElement::parseMappedAttribute(attr);
 113 }
 114
 115 RenderObject* HTMLCanvasElement::createRenderer(RenderArena* arena, RenderStyle* style)
 116 {
 117     Settings* settings = document()->settings();
 118     if (settings && settings->isJavaScriptEnabled()) {
 119         m_rendererIsCanvas = true;
 120         return new (arena) RenderHTMLCanvas(this);
 121     }
 122
 123     m_rendererIsCanvas = false;
 124     return HTMLElement::createRenderer(arena, style);
 125 }
 126
 127 void HTMLCanvasElement::setHeight(int value)
 128 {
 129     setAttribute(heightAttr, String::number(value));
 130 }
 131
 132 void HTMLCanvasElement::setWidth(int value)
 133 {
 134     setAttribute(widthAttr, String::number(value));
 135 }
 136
 137 String HTMLCanvasElement::toDataURL(const String& mimeType, ExceptionCode& ec)
 138 {
 139     if (!m_originClean) {
 140         ec = SECURITY_ERR;
 141         return String();
 142     }
 143
 144     if (m_size.isEmpty())
 145         return String("data:,");
 146
 147     if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
 148         return buffer()->toDataURL("image/png");
 149
 150     return buffer()->toDataURL(mimeType);
 151 }
 152
 153 CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type)
 154 {
 155     if (type == "2d") {
 156         if (!m_2DContext)
 157             m_2DContext = CanvasRenderingContext2D::create(this);
 158         return m_2DContext.get();
 159     }
 160     return 0;
 161 }
 162
 163 void HTMLCanvasElement::willDraw(const FloatRect& rect)
 164 {
 165     m_imageBuffer->clearImage();
 166
 167     if (RenderObject* ro = renderer()) {
 168 #ifdef CANVAS_INCREMENTAL_REPAINT
 169         // Handle CSS triggered scaling
 170         float widthScale = static_cast<float>(ro->width()) / static_cast<float>(m_size.width());
 171         float heightScale = static_cast<float>(ro->height()) / static_cast<float>(m_size.height());
 172         FloatRect r(rect.x() * widthScale, rect.y() * heightScale, rect.width() * widthScale, rect.height() * heightScale);
 173         ro->repaintRectangle(enclosingIntRect(r));
 174 #else
 175         ro->repaint();
 176 #endif
 177     }
 178
 179     if (m_observer)
 180         m_observer->canvasChanged(this, rect);
 181 }
 182
 183 void HTMLCanvasElement::reset()
 184 {
 185     if (m_ignoreReset)
 186         return;
 187
 188     bool ok;
 189     int w = getAttribute(widthAttr).toInt(&ok);
 190     if (!ok)
 191         w = defaultWidth;
 192     int h = getAttribute(heightAttr).toInt(&ok);
 193     if (!ok)
 194         h = defaultHeight;
 195
 196     IntSize oldSize = m_size;
 197     m_size = IntSize(w, h);
 198
 199     bool hadImageBuffer = m_createdImageBuffer;
 200     m_createdImageBuffer = false;
 201     m_imageBuffer.clear();
 202     if (m_2DContext)
 203         m_2DContext->reset();
 204
 205     if (RenderObject* ro = renderer())
 206         if (m_rendererIsCanvas) {
 207             if (oldSize != m_size)
 208                 static_cast<RenderHTMLCanvas*>(ro)->canvasSizeChanged();
 209             if (hadImageBuffer)
 210                 ro->repaint();
 211         }
 212
 213     if (m_observer)
 214         m_observer->canvasResized(this);
 215 }
 216
 217 void HTMLCanvasElement::paint(GraphicsContext* context, const IntRect& r)
 218 {
 219     if (context->paintingDisabled())
 220         return;
 221
 222     if (m_imageBuffer) {
 223         Image* image = m_imageBuffer->image();
 224         if (image)
 225             context->drawImage(image, r);
 226     }
 227 }
 228
 229 IntRect HTMLCanvasElement::convertLogicalToDevice(const FloatRect& logicalRect) const
 230 {
 231     return IntRect(convertLogicalToDevice(logicalRect.location()), convertLogicalToDevice(logicalRect.size()));
 232 }
 233
 234 IntSize HTMLCanvasElement::convertLogicalToDevice(const FloatSize& logicalSize) const
 235 {
 236     float pageScaleFactor = document()->frame() ? document()->frame()->page()->chrome()->scaleFactor() : 1.0f;
 237     float wf = ceilf(logicalSize.width() * pageScaleFactor);
 238     float hf = ceilf(logicalSize.height() * pageScaleFactor);
 239
 240     if (!(wf >= 1 && hf >= 1 && wf * hf <= MaxCanvasArea))
 241         return IntSize();
 242
 243     return IntSize(static_cast<unsigned>(wf), static_cast<unsigned>(hf));
 244 }
 245
 246 IntPoint HTMLCanvasElement::convertLogicalToDevice(const FloatPoint& logicalPos) const
 247 {
 248     float pageScaleFactor = document()->frame() ? document()->frame()->page()->chrome()->scaleFactor() : 1.0f;
 249     float xf = logicalPos.x() * pageScaleFactor;
 250     float yf = logicalPos.y() * pageScaleFactor;
 251
 252     return IntPoint(static_cast<unsigned>(xf), static_cast<unsigned>(yf));
 253 }
 254
 255 void HTMLCanvasElement::createImageBuffer() const
 256 {
 257     ASSERT(!m_imageBuffer);
 258
 259     m_createdImageBuffer = true;
 260
 261     FloatSize unscaledSize(width(), height());
 262     IntSize size = convertLogicalToDevice(unscaledSize);
 263     if (!size.width() || !size.height())
 264         return;
 265     m_imageBuffer.set(ImageBuffer::create(size, false).release());
 266 }
 267
 268 GraphicsContext* HTMLCanvasElement::drawingContext() const
 269 {
 270     return buffer() ? m_imageBuffer->context() : 0;
 271 }
 272
 273 ImageBuffer* HTMLCanvasElement::buffer() const
 274 {
 275     if (!m_createdImageBuffer)
 276         createImageBuffer();
 277     return m_imageBuffer.get();
 278 }
 279
 280 #if PLATFORM(CG)
 281
 282 CGImageRef HTMLCanvasElement::createPlatformImage() const
 283 {
 284     GraphicsContext* context = drawingContext();
 285     if (!context)
 286         return 0;
 287
 288     CGContextRef contextRef = context->platformContext();
 289     if (!contextRef)
 290         return 0;
 291
 292     CGContextFlush(contextRef);
 293
 294     return CGBitmapContextCreateImage(contextRef);
 295 }
 296
 297 #elif PLATFORM(QT)
 298
 299 QPixmap HTMLCanvasElement::createPlatformImage() const
 300 {
 301     if (!m_imageBuffer)
 302         return QPixmap();
 303     return *m_imageBuffer->pixmap();
 304 }
 305
 306 #elif PLATFORM(CAIRO)
 307
 308 cairo_surface_t* HTMLCanvasElement::createPlatformImage() const
 309 {
 310     if (!m_imageBuffer)
 311         return 0;
 312
 313     // Note that unlike CG, our returned image is not a copy or
 314     // copy-on-write, but the original. This is fine, since it is only
 315     // ever used as a source.
 316
 317     cairo_surface_flush(m_imageBuffer->surface());
 318     cairo_surface_reference(m_imageBuffer->surface());
 319     return m_imageBuffer->surface();
 320 }
 321
 322 #endif
 323
 324 }