6c20067991106787e23c4a5c6d505535dbd3f08a
[WebKit-https.git] / Source / WebCore / platform / graphics / cairo / GraphicsContextImplCairo.cpp
1 /*
2  * Copyright (C) 2017 Metrological Group B.V.
3  * Copyright (C) 2017 Igalia S.L.
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 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 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 "GraphicsContextImplCairo.h"
29
30 #if USE(CAIRO)
31
32 #include "CairoOperations.h"
33 #include "Font.h"
34 #include "GlyphBuffer.h"
35 #include "GraphicsContextPlatformPrivateCairo.h"
36
37 namespace WebCore {
38
39 GraphicsContext::GraphicsContextImplFactory GraphicsContextImplCairo::createFactory(PlatformContextCairo& platformContext)
40 {
41     return GraphicsContext::GraphicsContextImplFactory(
42         [&platformContext](GraphicsContext& context)
43         {
44             return std::make_unique<GraphicsContextImplCairo>(context, platformContext);
45         });
46 }
47
48 GraphicsContext::GraphicsContextImplFactory GraphicsContextImplCairo::createFactory(cairo_t* cairoContext)
49 {
50     return GraphicsContext::GraphicsContextImplFactory(
51         [cairoContext](GraphicsContext& context)
52         {
53             return std::make_unique<GraphicsContextImplCairo>(context, cairoContext);
54         });
55 }
56
57 GraphicsContextImplCairo::GraphicsContextImplCairo(GraphicsContext& context, PlatformContextCairo& platformContext)
58     : GraphicsContextImpl(context, FloatRect { }, AffineTransform { })
59     , m_platformContext(platformContext)
60     , m_private(std::make_unique<GraphicsContextPlatformPrivate>(m_platformContext))
61 {
62     m_platformContext.setGraphicsContextPrivate(m_private.get());
63     m_private->syncContext(m_platformContext.cr());
64 }
65
66 GraphicsContextImplCairo::GraphicsContextImplCairo(GraphicsContext& context, cairo_t* cairoContext)
67     : GraphicsContextImpl(context, FloatRect { }, AffineTransform { })
68     , m_ownedPlatformContext(std::make_unique<PlatformContextCairo>(cairoContext))
69     , m_platformContext(*m_ownedPlatformContext)
70     , m_private(std::make_unique<GraphicsContextPlatformPrivate>(m_platformContext))
71 {
72     m_platformContext.setGraphicsContextPrivate(m_private.get());
73     m_private->syncContext(m_platformContext.cr());
74 }
75
76 GraphicsContextImplCairo::~GraphicsContextImplCairo()
77 {
78     m_platformContext.setGraphicsContextPrivate(nullptr);
79 }
80
81 bool GraphicsContextImplCairo::hasPlatformContext() const
82 {
83     return true;
84 }
85
86 PlatformContextCairo* GraphicsContextImplCairo::platformContext() const
87 {
88     return &m_platformContext;
89 }
90
91 void GraphicsContextImplCairo::updateState(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
92 {
93     if (flags & GraphicsContextState::StrokeThicknessChange)
94         Cairo::State::setStrokeThickness(m_platformContext, state.strokeThickness);
95
96     if (flags & GraphicsContextState::StrokeStyleChange)
97         Cairo::State::setStrokeStyle(m_platformContext, state.strokeStyle);
98
99     if (flags & GraphicsContextState::ShadowChange) {
100         if (state.shadowsIgnoreTransforms) {
101             // Meaning that this graphics context is associated with a CanvasRenderingContext
102             // We flip the height since CG and HTML5 Canvas have opposite Y axis
103             auto& mutableState = const_cast<GraphicsContextState&>(graphicsContext().state());
104             auto& shadowOffset = state.shadowOffset;
105             mutableState.shadowOffset = { shadowOffset.width(), -shadowOffset.height() };
106         }
107     }
108
109     if (flags & GraphicsContextState::CompositeOperationChange)
110         Cairo::State::setCompositeOperation(m_platformContext, state.compositeOperator, state.blendMode);
111
112     if (flags & GraphicsContextState::ShouldAntialiasChange)
113         Cairo::State::setShouldAntialias(m_platformContext, state.shouldAntialias);
114 }
115
116 void GraphicsContextImplCairo::clearShadow()
117 {
118 }
119
120 void GraphicsContextImplCairo::setLineCap(LineCap lineCap)
121 {
122     Cairo::setLineCap(m_platformContext, lineCap);
123 }
124
125 void GraphicsContextImplCairo::setLineDash(const DashArray& dashes, float dashOffset)
126 {
127     Cairo::setLineDash(m_platformContext, dashes, dashOffset);
128 }
129
130 void GraphicsContextImplCairo::setLineJoin(LineJoin lineJoin)
131 {
132     Cairo::setLineJoin(m_platformContext, lineJoin);
133 }
134
135 void GraphicsContextImplCairo::setMiterLimit(float miterLimit)
136 {
137     Cairo::setMiterLimit(m_platformContext, miterLimit);
138 }
139
140 void GraphicsContextImplCairo::fillRect(const FloatRect& rect)
141 {
142     auto& state = graphicsContext().state();
143     Cairo::fillRect(m_platformContext, rect, Cairo::FillSource(state), Cairo::ShadowState(state));
144 }
145
146 void GraphicsContextImplCairo::fillRect(const FloatRect& rect, const Color& color)
147 {
148     Cairo::fillRect(m_platformContext, rect, color, Cairo::ShadowState(graphicsContext().state()));
149 }
150
151 void GraphicsContextImplCairo::fillRect(const FloatRect& rect, Gradient& gradient)
152 {
153     RefPtr<cairo_pattern_t> platformGradient = adoptRef(gradient.createPlatformGradient(1.0));
154     if (!platformGradient)
155         return;
156
157     Cairo::save(m_platformContext);
158     Cairo::fillRect(m_platformContext, rect, platformGradient.get());
159     Cairo::restore(m_platformContext);
160 }
161
162 void GraphicsContextImplCairo::fillRect(const FloatRect& rect, const Color& color, CompositeOperator compositeOperator, BlendMode blendMode)
163 {
164     auto& state = graphicsContext().state();
165     CompositeOperator previousOperator = state.compositeOperator;
166
167     Cairo::State::setCompositeOperation(m_platformContext, compositeOperator, blendMode);
168     Cairo::fillRect(m_platformContext, rect, color, Cairo::ShadowState(state));
169     Cairo::State::setCompositeOperation(m_platformContext, previousOperator, BlendMode::Normal);
170 }
171
172 void GraphicsContextImplCairo::fillRoundedRect(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
173 {
174     auto& state = graphicsContext().state();
175
176     CompositeOperator previousOperator = state.compositeOperator;
177     Cairo::State::setCompositeOperation(m_platformContext, previousOperator, blendMode);
178
179     Cairo::ShadowState shadowState(state);
180     if (rect.isRounded())
181         Cairo::fillRoundedRect(m_platformContext, rect, color, shadowState);
182     else
183         Cairo::fillRect(m_platformContext, rect.rect(), color, shadowState);
184
185     Cairo::State::setCompositeOperation(m_platformContext, previousOperator, BlendMode::Normal);
186 }
187
188 void GraphicsContextImplCairo::fillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color&)
189 {
190     Cairo::fillRectWithRoundedHole(m_platformContext, rect, roundedHoleRect, { }, Cairo::ShadowState(graphicsContext().state()));
191 }
192
193 void GraphicsContextImplCairo::fillPath(const Path& path)
194 {
195     auto& state = graphicsContext().state();
196     Cairo::fillPath(m_platformContext, path, Cairo::FillSource(state), Cairo::ShadowState(state));
197 }
198
199 void GraphicsContextImplCairo::fillEllipse(const FloatRect& rect)
200 {
201     Path path;
202     path.addEllipse(rect);
203     fillPath(path);
204 }
205
206 void GraphicsContextImplCairo::strokeRect(const FloatRect& rect, float lineWidth)
207 {
208     auto& state = graphicsContext().state();
209     Cairo::strokeRect(m_platformContext, rect, lineWidth, Cairo::StrokeSource(state), Cairo::ShadowState(state));
210 }
211
212 void GraphicsContextImplCairo::strokePath(const Path& path)
213 {
214     auto& state = graphicsContext().state();
215     Cairo::strokePath(m_platformContext, path, Cairo::StrokeSource(state), Cairo::ShadowState(state));
216 }
217
218 void GraphicsContextImplCairo::strokeEllipse(const FloatRect& rect)
219 {
220     Path path;
221     path.addEllipse(rect);
222     strokePath(path);
223 }
224
225 void GraphicsContextImplCairo::clearRect(const FloatRect& rect)
226 {
227     Cairo::clearRect(m_platformContext, rect);
228 }
229
230 void GraphicsContextImplCairo::drawGlyphs(const Font& font, const GlyphBuffer& glyphBuffer, unsigned from, unsigned numGlyphs, const FloatPoint& point, FontSmoothingMode fontSmoothing)
231 {
232     UNUSED_PARAM(fontSmoothing);
233     if (!font.platformData().size())
234         return;
235
236     auto xOffset = point.x();
237     Vector<cairo_glyph_t> glyphs(numGlyphs);
238     {
239         ASSERT(from + numGlyphs <= glyphBuffer.size());
240         auto* glyphsData = glyphBuffer.glyphs(from);
241         auto* advances = glyphBuffer.advances(from);
242
243         auto yOffset = point.y();
244         for (size_t i = 0; i < numGlyphs; ++i) {
245             glyphs[i] = { glyphsData[i], xOffset, yOffset };
246             xOffset += advances[i].width();
247         }
248     }
249
250     cairo_scaled_font_t* scaledFont = font.platformData().scaledFont();
251     double syntheticBoldOffset = font.syntheticBoldOffset();
252
253     auto& state = graphicsContext().state();
254     Cairo::drawGlyphs(m_platformContext, Cairo::FillSource(state), Cairo::StrokeSource(state),
255         Cairo::ShadowState(state), point, scaledFont, syntheticBoldOffset, glyphs, xOffset,
256         state.textDrawingMode, state.strokeThickness, state.shadowOffset, state.shadowColor);
257 }
258
259 ImageDrawResult GraphicsContextImplCairo::drawImage(Image& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& imagePaintingOptions)
260 {
261     return GraphicsContextImpl::drawImageImpl(graphicsContext(), image, destination, source, imagePaintingOptions);
262 }
263
264 ImageDrawResult GraphicsContextImplCairo::drawTiledImage(Image& image, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& imagePaintingOptions)
265 {
266     return GraphicsContextImpl::drawTiledImageImpl(graphicsContext(), image, destination, source, tileSize, spacing, imagePaintingOptions);
267 }
268
269 ImageDrawResult GraphicsContextImplCairo::drawTiledImage(Image& image, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions& imagePaintingOptions)
270 {
271     return GraphicsContextImpl::drawTiledImageImpl(graphicsContext(), image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions);
272 }
273
274 void GraphicsContextImplCairo::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator compositeOperator, BlendMode blendMode, ImageOrientation orientation)
275 {
276     UNUSED_PARAM(imageSize);
277     auto& state = graphicsContext().state();
278     Cairo::drawNativeImage(m_platformContext, image.get(), destRect, srcRect, compositeOperator, blendMode, orientation, state.imageInterpolationQuality, state.alpha, Cairo::ShadowState(state));
279 }
280
281 void GraphicsContextImplCairo::drawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize&, CompositeOperator compositeOperator, BlendMode blendMode)
282 {
283     if (auto surface = image.nativeImageForCurrentFrame())
284         Cairo::drawPattern(m_platformContext, surface.get(), IntSize(image.size()), destRect, tileRect, patternTransform, phase, compositeOperator, blendMode);
285 }
286
287 void GraphicsContextImplCairo::drawRect(const FloatRect& rect, float borderThickness)
288 {
289     auto& state = graphicsContext().state();
290     Cairo::drawRect(m_platformContext, rect, borderThickness, state.fillColor, state.strokeStyle, state.strokeColor);
291 }
292
293 void GraphicsContextImplCairo::drawLine(const FloatPoint& point1, const FloatPoint& point2)
294 {
295     auto& state = graphicsContext().state();
296     Cairo::drawLine(m_platformContext, point1, point2, state.strokeStyle, state.strokeColor, state.strokeThickness, state.shouldAntialias);
297 }
298
299 void GraphicsContextImplCairo::drawLinesForText(const FloatPoint& point, float thickness, const DashArray& widths, bool printing, bool doubleUnderlines)
300 {
301     auto& state = graphicsContext().state();
302     Cairo::drawLinesForText(m_platformContext, point, thickness, widths, printing, doubleUnderlines, state.strokeColor);
303 }
304
305 void GraphicsContextImplCairo::drawDotsForDocumentMarker(const FloatRect& rect, DocumentMarkerLineStyle style)
306 {
307     Cairo::drawDotsForDocumentMarker(m_platformContext, rect, style);
308 }
309
310 void GraphicsContextImplCairo::drawEllipse(const FloatRect& rect)
311 {
312     auto& state = graphicsContext().state();
313     Cairo::drawEllipse(*platformContext(), rect, state.fillColor, state.strokeStyle, state.strokeColor, state.strokeThickness);
314 }
315
316 void GraphicsContextImplCairo::drawPath(const Path&)
317 {
318 }
319
320 void GraphicsContextImplCairo::drawFocusRing(const Path& path, float width, float offset, const Color& color)
321 {
322     UNUSED_PARAM(offset);
323     Cairo::drawFocusRing(m_platformContext, path, width, color);
324 }
325
326 void GraphicsContextImplCairo::drawFocusRing(const Vector<FloatRect>& rects, float width, float offset, const Color& color)
327 {
328     UNUSED_PARAM(offset);
329     Cairo::drawFocusRing(m_platformContext, rects, width, color);
330 }
331
332 void GraphicsContextImplCairo::save()
333 {
334     Cairo::save(m_platformContext);
335 }
336
337 void GraphicsContextImplCairo::restore()
338 {
339     Cairo::restore(m_platformContext);
340 }
341
342 void GraphicsContextImplCairo::translate(float x, float y)
343 {
344     Cairo::translate(m_platformContext, x, y);
345 }
346
347 void GraphicsContextImplCairo::rotate(float angleInRadians)
348 {
349     Cairo::rotate(m_platformContext, angleInRadians);
350 }
351
352 void GraphicsContextImplCairo::scale(const FloatSize& size)
353 {
354     Cairo::scale(m_platformContext, size);
355 }
356
357 void GraphicsContextImplCairo::concatCTM(const AffineTransform& transform)
358 {
359     Cairo::concatCTM(m_platformContext, transform);
360 }
361
362 void GraphicsContextImplCairo::setCTM(const AffineTransform& transform)
363 {
364     Cairo::State::setCTM(m_platformContext, transform);
365 }
366
367 AffineTransform GraphicsContextImplCairo::getCTM(GraphicsContext::IncludeDeviceScale)
368 {
369     return Cairo::State::getCTM(m_platformContext);
370 }
371
372 void GraphicsContextImplCairo::beginTransparencyLayer(float opacity)
373 {
374     Cairo::beginTransparencyLayer(m_platformContext, opacity);
375 }
376
377 void GraphicsContextImplCairo::endTransparencyLayer()
378 {
379     Cairo::endTransparencyLayer(m_platformContext);
380 }
381
382 void GraphicsContextImplCairo::clip(const FloatRect& rect)
383 {
384     Cairo::clip(m_platformContext, rect);
385 }
386
387 void GraphicsContextImplCairo::clipOut(const FloatRect& rect)
388 {
389     Cairo::clipOut(m_platformContext, rect);
390 }
391
392 void GraphicsContextImplCairo::clipOut(const Path& path)
393 {
394     Cairo::clipOut(m_platformContext, path);
395 }
396
397 void GraphicsContextImplCairo::clipPath(const Path& path, WindRule clipRule)
398 {
399     Cairo::clipPath(m_platformContext, path, clipRule);
400 }
401
402 IntRect GraphicsContextImplCairo::clipBounds()
403 {
404     return Cairo::State::getClipBounds(m_platformContext);
405 }
406
407 void GraphicsContextImplCairo::clipToImageBuffer(ImageBuffer& buffer, const FloatRect& destRect)
408 {
409     RefPtr<Image> image = buffer.copyImage(DontCopyBackingStore);
410     if (!image)
411         return;
412
413     if (auto surface = image->nativeImageForCurrentFrame())
414         Cairo::clipToImageBuffer(m_platformContext, surface.get(), destRect);
415 }
416
417 void GraphicsContextImplCairo::applyDeviceScaleFactor(float)
418 {
419 }
420
421 FloatRect GraphicsContextImplCairo::roundToDevicePixels(const FloatRect& rect, GraphicsContext::RoundingMode)
422 {
423     return Cairo::State::roundToDevicePixels(m_platformContext, rect);
424 }
425
426 } // namespace WebCore
427
428 #endif // USE(CAIRO)