Reviewed by Oliver.
[WebKit-https.git] / 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 "Frame.h"
37 #include "GraphicsContext.h"
38 #include "ImageBuffer.h"
39 #include "HTMLNames.h"
40 #include "Page.h"
41 #include "RenderHTMLCanvas.h"
42 #include "Settings.h"
43 #include <math.h>
44
45 #if PLATFORM(QT)
46 #include <QPainter>
47 #include <QPixmap>
48 #elif PLATFORM(CAIRO)
49 #include <cairo.h>
50 #endif
51
52 namespace WebCore {
53
54 using namespace HTMLNames;
55
56 // These values come from the WhatWG spec.
57 static const int defaultWidth = 300;
58 static const int defaultHeight = 150;
59
60 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it 
61 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
62 // in exchange for a smaller maximum canvas size.
63 static const float maxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
64
65 HTMLCanvasElement::HTMLCanvasElement(Document* doc)
66     : HTMLElement(canvasTag, doc)
67     , m_size(defaultWidth, defaultHeight)
68     , m_createdImageBuffer(false)
69 {
70 }
71
72 HTMLCanvasElement::~HTMLCanvasElement()
73 {
74     if (m_2DContext)
75         m_2DContext->detachCanvas();
76 }
77
78 HTMLTagStatus HTMLCanvasElement::endTagRequirement() const 
79 {
80     Settings* settings = document()->settings();
81     if (settings && settings->usesDashboardBackwardCompatibilityMode())
82         return TagStatusForbidden; 
83
84     return HTMLElement::endTagRequirement();
85 }
86
87 int HTMLCanvasElement::tagPriority() const 
88
89     Settings* settings = document()->settings();
90     if (settings && settings->usesDashboardBackwardCompatibilityMode())
91         return 0; 
92
93     return HTMLElement::tagPriority();
94 }
95
96 void HTMLCanvasElement::parseMappedAttribute(MappedAttribute* attr)
97 {
98     const QualifiedName& attrName = attr->name();
99     if (attrName == widthAttr || attrName == heightAttr)
100         reset();
101     HTMLElement::parseMappedAttribute(attr);
102 }
103
104 RenderObject* HTMLCanvasElement::createRenderer(RenderArena* arena, RenderStyle* style)
105 {
106     Settings* settings = document()->settings();
107     if (settings && settings->isJavaScriptEnabled()) {
108         m_rendererIsCanvas = true;
109         return new (arena) RenderHTMLCanvas(this);
110     }
111
112     m_rendererIsCanvas = false;
113     return HTMLElement::createRenderer(arena, style);
114 }
115
116 void HTMLCanvasElement::setHeight(int value)
117 {
118     setAttribute(heightAttr, String::number(value));
119 }
120
121 void HTMLCanvasElement::setWidth(int value)
122 {
123     setAttribute(widthAttr, String::number(value));
124 }
125
126 CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type)
127 {
128     if (type == "2d") {
129         if (!m_2DContext)
130             m_2DContext = new CanvasRenderingContext2D(this);
131         return m_2DContext.get();
132     }
133     return 0;
134 }
135
136 void HTMLCanvasElement::willDraw(const FloatRect& rect)
137 {
138     if (RenderObject* ro = renderer()) {
139 #ifdef CANVAS_INCREMENTAL_REPAINT
140         // Handle CSS triggered scaling
141         float widthScale = static_cast<float>(ro->width()) / static_cast<float>(m_size.width());
142         float heightScale = static_cast<float>(ro->height()) / static_cast<float>(m_size.height());
143         FloatRect r(rect.x() * widthScale, rect.y() * heightScale, rect.width() * widthScale, rect.height() * heightScale);
144         ro->repaintRectangle(enclosingIntRect(r));
145 #else
146         ro->repaint();
147 #endif
148     }
149 }
150
151 void HTMLCanvasElement::reset()
152 {
153     bool ok;
154     int w = getAttribute(widthAttr).toInt(&ok);
155     if (!ok)
156         w = defaultWidth;
157     int h = getAttribute(heightAttr).toInt(&ok);
158     if (!ok)
159         h = defaultHeight;
160
161     IntSize oldSize = m_size;
162     m_size = IntSize(w, h);
163
164     bool hadImageBuffer = m_createdImageBuffer;
165     m_createdImageBuffer = false;
166     m_imageBuffer.clear();
167     if (m_2DContext)
168         m_2DContext->reset();
169
170     if (RenderObject* ro = renderer())
171         if (m_rendererIsCanvas) {
172             if (oldSize != m_size)
173                 static_cast<RenderHTMLCanvas*>(ro)->canvasSizeChanged();
174             if (hadImageBuffer)
175                 ro->repaint();
176         }
177 }
178
179 void HTMLCanvasElement::paint(GraphicsContext* p, const IntRect& r)
180 {
181     if (p->paintingDisabled())
182         return;
183     
184     if (m_imageBuffer)
185         p->paintBuffer(m_imageBuffer.get(), r);
186 }
187
188 void HTMLCanvasElement::createImageBuffer() const
189 {
190     ASSERT(!m_createdImageBuffer);
191     ASSERT(!m_imageBuffer);
192
193     m_createdImageBuffer = true;
194
195     float unscaledWidth = width();
196     float unscaledHeight = height();
197     float pageScaleFactor = document()->frame() ? document()->frame()->page()->chrome()->scaleFactor() : 1.0f;
198     float wf = ceilf(unscaledWidth * pageScaleFactor);
199     float hf = ceilf(unscaledHeight * pageScaleFactor);
200
201     if (!(wf >= 1 && hf >= 1 && wf * hf <= maxCanvasArea))
202         return;
203
204     IntSize size(static_cast<unsigned>(wf), static_cast<unsigned>(hf));
205
206     m_imageBuffer.set(ImageBuffer::create(size, false).release());
207 }
208
209 GraphicsContext* HTMLCanvasElement::drawingContext() const
210 {
211     return buffer()->context();
212 }
213
214 ImageBuffer* HTMLCanvasElement::buffer() const
215 {
216     if (!m_createdImageBuffer)
217         createImageBuffer();
218     return m_imageBuffer.get();
219 }
220
221 #if PLATFORM(CG)
222
223 CGImageRef HTMLCanvasElement::createPlatformImage() const
224 {
225     GraphicsContext* context = drawingContext();
226     if (!context)
227         return 0;
228
229     CGContextRef contextRef = context->platformContext();
230     if (!contextRef)
231         return 0;
232
233     CGContextFlush(contextRef);
234
235     return CGBitmapContextCreateImage(contextRef);
236 }
237
238 #elif PLATFORM(QT)
239
240 QPixmap HTMLCanvasElement::createPlatformImage() const
241 {
242     if (!m_imageBuffer)
243         return QPixmap();
244     return *m_imageBuffer->pixmap();
245 }
246
247 #elif PLATFORM(CAIRO)
248
249 cairo_surface_t* HTMLCanvasElement::createPlatformImage() const
250 {
251     if (!m_imageBuffer)
252         return 0;
253
254     // Note that unlike CG, our returned image is not a copy or
255     // copy-on-write, but the original. This is fine, since it is only
256     // ever used as a source.
257
258     cairo_surface_flush(m_imageBuffer->surface());
259     cairo_surface_reference(m_imageBuffer->surface());
260     return m_imageBuffer->surface();
261 }
262
263 #endif
264
265 }