WebEditorClient should properly write to m_rangeForCandidates
[WebKit.git] / Source / WebCore / html / canvas / CanvasRenderingContext2D.h
1 /*
2  * Copyright (C) 2006, 2007, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef CanvasRenderingContext2D_h
27 #define CanvasRenderingContext2D_h
28
29 #include "AffineTransform.h"
30 #include "CanvasPathMethods.h"
31 #include "CanvasRenderingContext.h"
32 #include "CanvasStyle.h"
33 #include "Color.h"
34 #include "FloatSize.h"
35 #include "FontCascade.h"
36 #include "FontSelectorClient.h"
37 #include "GraphicsContext.h"
38 #include "GraphicsTypes.h"
39 #include "ImageBuffer.h"
40 #include "Path.h"
41 #include "PlatformLayer.h"
42 #include "TextFlags.h"
43 #include <wtf/Vector.h>
44 #include <wtf/text/WTFString.h>
45
46 namespace WebCore {
47
48 class CanvasGradient;
49 class CanvasPattern;
50 class DOMPath;
51 class FloatRect;
52 class GraphicsContext;
53 class HTMLCanvasElement;
54 class HTMLImageElement;
55 class HTMLVideoElement;
56 class ImageData;
57 class TextMetrics;
58
59 typedef int ExceptionCode;
60
61 class CanvasRenderingContext2D final : public CanvasRenderingContext, public CanvasPathMethods {
62 public:
63     CanvasRenderingContext2D(HTMLCanvasElement*, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode);
64     virtual ~CanvasRenderingContext2D();
65
66     const CanvasStyle& strokeStyle() const { return state().strokeStyle; }
67     void setStrokeStyle(CanvasStyle);
68
69     const CanvasStyle& fillStyle() const { return state().fillStyle; }
70     void setFillStyle(CanvasStyle);
71
72     float lineWidth() const;
73     void setLineWidth(float);
74
75     String lineCap() const;
76     void setLineCap(const String&);
77
78     String lineJoin() const;
79     void setLineJoin(const String&);
80
81     float miterLimit() const;
82     void setMiterLimit(float);
83
84     const Vector<float>& getLineDash() const;
85     void setLineDash(const Vector<float>&);
86     void setWebkitLineDash(const Vector<float>&);
87
88     float lineDashOffset() const;
89     void setLineDashOffset(float);
90     float webkitLineDashOffset() const;
91     void setWebkitLineDashOffset(float);
92
93     float shadowOffsetX() const;
94     void setShadowOffsetX(float);
95
96     float shadowOffsetY() const;
97     void setShadowOffsetY(float);
98
99     float shadowBlur() const;
100     void setShadowBlur(float);
101
102     String shadowColor() const;
103     void setShadowColor(const String&);
104
105     float globalAlpha() const;
106     void setGlobalAlpha(float);
107
108     String globalCompositeOperation() const;
109     void setGlobalCompositeOperation(const String&);
110
111     void save() { ++m_unrealizedSaveCount; }
112     void restore();
113
114     void scale(float sx, float sy);
115     void rotate(float angleInRadians);
116     void translate(float tx, float ty);
117     void transform(float m11, float m12, float m21, float m22, float dx, float dy);
118     void setTransform(float m11, float m12, float m21, float m22, float dx, float dy);
119
120     void setStrokeColor(const String& color);
121     void setStrokeColor(float grayLevel);
122     void setStrokeColor(const String& color, float alpha);
123     void setStrokeColor(float grayLevel, float alpha);
124     void setStrokeColor(float r, float g, float b, float a);
125     void setStrokeColor(float c, float m, float y, float k, float a);
126
127     void setFillColor(const String& color);
128     void setFillColor(float grayLevel);
129     void setFillColor(const String& color, float alpha);
130     void setFillColor(float grayLevel, float alpha);
131     void setFillColor(float r, float g, float b, float a);
132     void setFillColor(float c, float m, float y, float k, float a);
133
134     void beginPath();
135
136     void fill(const String& winding = ASCIILiteral("nonzero"));
137     void stroke();
138     void clip(const String& winding = ASCIILiteral("nonzero"));
139
140     void fill(DOMPath&, const String& winding = ASCIILiteral("nonzero"));
141     void stroke(DOMPath&);
142     void clip(DOMPath&, const String& winding = ASCIILiteral("nonzero"));
143
144     bool isPointInPath(const float x, const float y, const String& winding = ASCIILiteral("nonzero"));
145     bool isPointInStroke(const float x, const float y);
146
147     bool isPointInPath(DOMPath&, const float x, const float y, const String& winding = ASCIILiteral("nonzero"));
148     bool isPointInStroke(DOMPath&, const float x, const float y);
149
150     void clearRect(float x, float y, float width, float height);
151     void fillRect(float x, float y, float width, float height);
152     void strokeRect(float x, float y, float width, float height);
153
154     void setShadow(float width, float height, float blur);
155     void setShadow(float width, float height, float blur, const String& color);
156     void setShadow(float width, float height, float blur, float grayLevel);
157     void setShadow(float width, float height, float blur, const String& color, float alpha);
158     void setShadow(float width, float height, float blur, float grayLevel, float alpha);
159     void setShadow(float width, float height, float blur, float r, float g, float b, float a);
160     void setShadow(float width, float height, float blur, float c, float m, float y, float k, float a);
161
162     void clearShadow();
163
164     void drawImage(HTMLImageElement&, float x, float y, ExceptionCode&);
165     void drawImage(HTMLImageElement&, float x, float y, float width, float height, ExceptionCode&);
166     void drawImage(HTMLImageElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode&);
167     void drawImage(HTMLImageElement&, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode&);
168     void drawImage(HTMLCanvasElement&, float x, float y, ExceptionCode&);
169     void drawImage(HTMLCanvasElement&, float x, float y, float width, float height, ExceptionCode&);
170     void drawImage(HTMLCanvasElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode&);
171     void drawImage(HTMLCanvasElement&, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode&);
172     void drawImage(HTMLImageElement&, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator&, const BlendMode&, ExceptionCode&);
173 #if ENABLE(VIDEO)
174     void drawImage(HTMLVideoElement&, float x, float y, ExceptionCode&);
175     void drawImage(HTMLVideoElement&, float x, float y, float width, float height, ExceptionCode&);
176     void drawImage(HTMLVideoElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode&);
177     void drawImage(HTMLVideoElement&, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode&);
178 #endif
179
180     void drawImageFromRect(HTMLImageElement&, float sx = 0, float sy = 0, float sw = 0, float sh = 0,
181                            float dx = 0, float dy = 0, float dw = 0, float dh = 0, const String& compositeOperation = emptyString());
182
183     void setAlpha(float);
184
185     void setCompositeOperation(const String&);
186
187     RefPtr<CanvasGradient> createLinearGradient(float x0, float y0, float x1, float y1, ExceptionCode&);
188     RefPtr<CanvasGradient> createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionCode&);
189     RefPtr<CanvasPattern> createPattern(HTMLImageElement*, const String& repetitionType, ExceptionCode&);
190     RefPtr<CanvasPattern> createPattern(HTMLCanvasElement*, const String& repetitionType, ExceptionCode&);
191
192     RefPtr<ImageData> createImageData(RefPtr<ImageData>&&, ExceptionCode&) const;
193     RefPtr<ImageData> createImageData(float width, float height, ExceptionCode&) const;
194     RefPtr<ImageData> getImageData(float sx, float sy, float sw, float sh, ExceptionCode&) const;
195     RefPtr<ImageData> webkitGetImageDataHD(float sx, float sy, float sw, float sh, ExceptionCode&) const;
196     void putImageData(ImageData*, float dx, float dy, ExceptionCode&);
197     void putImageData(ImageData*, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode&);
198     void webkitPutImageDataHD(ImageData*, float dx, float dy, ExceptionCode&);
199     void webkitPutImageDataHD(ImageData*, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode&);
200
201     void drawFocusIfNeeded(Element*);
202     void drawFocusIfNeeded(DOMPath&, Element*);
203
204     float webkitBackingStorePixelRatio() const { return 1; }
205
206     void reset();
207
208     String font() const;
209     void setFont(const String&);
210
211     String textAlign() const;
212     void setTextAlign(const String&);
213
214     String textBaseline() const;
215     void setTextBaseline(const String&);
216
217     String direction() const;
218     void setDirection(const String&);
219
220     void fillText(const String& text, float x, float y);
221     void fillText(const String& text, float x, float y, float maxWidth);
222     void strokeText(const String& text, float x, float y);
223     void strokeText(const String& text, float x, float y, float maxWidth);
224     Ref<TextMetrics> measureText(const String& text);
225
226     LineCap getLineCap() const { return state().lineCap; }
227     LineJoin getLineJoin() const { return state().lineJoin; }
228
229     bool imageSmoothingEnabled() const;
230     void setImageSmoothingEnabled(bool);
231
232     String imageSmoothingQuality() const;
233     void setImageSmoothingQuality(const String&);
234
235     enum class SmoothingQuality {
236         Low,
237         Medium,
238         High
239     };
240
241     bool usesDisplayListDrawing() const { return m_usesDisplayListDrawing; };
242     void setUsesDisplayListDrawing(bool flag) { m_usesDisplayListDrawing = flag; };
243
244     bool tracksDisplayListReplay() const { return m_tracksDisplayListReplay; }
245     void setTracksDisplayListReplay(bool);
246
247     String displayListAsText(DisplayList::AsTextFlags) const;
248     String replayDisplayListAsText(DisplayList::AsTextFlags) const;
249
250 private:
251     enum class Direction {
252         Inherit,
253         RTL,
254         LTR
255     };
256
257     class FontProxy : public FontSelectorClient {
258     public:
259         FontProxy() = default;
260         virtual ~FontProxy();
261         FontProxy(const FontProxy&);
262         FontProxy& operator=(const FontProxy&);
263
264         bool realized() const { return m_font.fontSelector(); }
265         void initialize(FontSelector&, RenderStyle&);
266         FontMetrics fontMetrics() const;
267         const FontCascadeDescription& fontDescription() const;
268         float width(const TextRun&) const;
269         void drawBidiText(GraphicsContext&, const TextRun&, const FloatPoint&, FontCascade::CustomFontNotReadyAction) const;
270
271     private:
272         void update(FontSelector&);
273         void fontsNeedUpdate(FontSelector&) override;
274
275         FontCascade m_font;
276     };
277
278     struct State final {
279         State();
280
281         State(const State&);
282         State& operator=(const State&);
283
284         String unparsedStrokeColor;
285         String unparsedFillColor;
286         CanvasStyle strokeStyle;
287         CanvasStyle fillStyle;
288         float lineWidth;
289         LineCap lineCap;
290         LineJoin lineJoin;
291         float miterLimit;
292         FloatSize shadowOffset;
293         float shadowBlur;
294         RGBA32 shadowColor;
295         float globalAlpha;
296         CompositeOperator globalComposite;
297         BlendMode globalBlend;
298         AffineTransform transform;
299         bool hasInvertibleTransform;
300         Vector<float> lineDash;
301         float lineDashOffset;
302         bool imageSmoothingEnabled;
303         SmoothingQuality imageSmoothingQuality;
304
305         // Text state.
306         TextAlign textAlign;
307         TextBaseline textBaseline;
308         Direction direction;
309
310         String unparsedFont;
311         FontProxy font;
312     };
313
314     enum CanvasDidDrawOption {
315         CanvasDidDrawApplyNone = 0,
316         CanvasDidDrawApplyTransform = 1,
317         CanvasDidDrawApplyShadow = 1 << 1,
318         CanvasDidDrawApplyClip = 1 << 2,
319         CanvasDidDrawApplyAll = 0xffffffff
320     };
321
322     State& modifiableState() { ASSERT(!m_unrealizedSaveCount); return m_stateStack.last(); }
323     const State& state() const { return m_stateStack.last(); }
324
325     void applyLineDash() const;
326     void setShadow(const FloatSize& offset, float blur, RGBA32 color);
327     void applyShadow();
328     bool shouldDrawShadows() const;
329
330     void didDraw(const FloatRect&, unsigned options = CanvasDidDrawApplyAll);
331     void didDrawEntireCanvas();
332
333     void paintRenderingResultsToCanvas() override;
334
335     GraphicsContext* drawingContext() const;
336
337     void unwindStateStack();
338     void realizeSaves()
339     {
340         if (m_unrealizedSaveCount)
341             realizeSavesLoop();
342     }
343     void realizeSavesLoop();
344
345     void applyStrokePattern();
346     void applyFillPattern();
347
348     void drawTextInternal(const String& text, float x, float y, bool fill, float maxWidth = 0, bool useMaxWidth = false);
349
350     // The relationship between FontCascade and CanvasRenderingContext2D::FontProxy must hold certain invariants.
351     // Therefore, all font operations must pass through the State.
352     const FontProxy& fontProxy();
353
354 #if ENABLE(DASHBOARD_SUPPORT)
355     void clearPathForDashboardBackwardCompatibilityMode();
356 #endif
357
358     void beginCompositeLayer();
359     void endCompositeLayer();
360
361     void fillInternal(const Path&, const String& winding);
362     void strokeInternal(const Path&);
363     void clipInternal(const Path&, const String& winding);
364
365     bool isPointInPathInternal(const Path&, float x, float y, const String& winding);
366     bool isPointInStrokeInternal(const Path&, float x, float y);
367
368     void drawFocusIfNeededInternal(const Path&, Element*);
369
370     void clearCanvas();
371     Path transformAreaToDevice(const Path&) const;
372     Path transformAreaToDevice(const FloatRect&) const;
373     bool rectContainsCanvas(const FloatRect&) const;
374
375     template<class T> IntRect calculateCompositingBufferRect(const T&, IntSize*);
376     std::unique_ptr<ImageBuffer> createCompositingBuffer(const IntRect&);
377     void compositeBuffer(ImageBuffer&, const IntRect&, CompositeOperator);
378
379     void inflateStrokeRect(FloatRect&) const;
380
381     template<class T> void fullCanvasCompositedDrawImage(T&, const FloatRect&, const FloatRect&, CompositeOperator);
382
383     void prepareGradientForDashboard(CanvasGradient& gradient) const;
384
385     RefPtr<ImageData> getImageData(ImageBuffer::CoordinateSystem, float sx, float sy, float sw, float sh, ExceptionCode&) const;
386     void putImageData(ImageData*, ImageBuffer::CoordinateSystem, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode&);
387
388     bool is2d() const override { return true; }
389     bool isAccelerated() const override;
390
391     bool hasInvertibleTransform() const override { return state().hasInvertibleTransform; }
392     TextDirection toTextDirection(Direction, RenderStyle** computedStyle = nullptr) const;
393
394 #if ENABLE(ACCELERATED_2D_CANVAS)
395     PlatformLayer* platformLayer() const override;
396 #endif
397
398     Vector<State, 1> m_stateStack;
399     unsigned m_unrealizedSaveCount { 0 };
400     bool m_usesCSSCompatibilityParseMode;
401 #if ENABLE(DASHBOARD_SUPPORT)
402     bool m_usesDashboardCompatibilityMode;
403 #endif
404
405     bool m_usesDisplayListDrawing { false };
406     bool m_tracksDisplayListReplay { false };
407     mutable std::unique_ptr<struct DisplayListDrawingContext> m_recordingContext;
408 };
409
410 } // namespace WebCore
411
412 SPECIALIZE_TYPE_TRAITS_CANVASRENDERINGCONTEXT(WebCore::CanvasRenderingContext2D, is2d())
413
414 #endif