1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "bridge/declarative_frontend/jsview/models/canvas_renderer_model_impl.h"
17
18 #include "base/image/pixel_map.h"
19 #include "core/components/custom_paint/custom_paint_component.h"
20 #include "core/components/custom_paint/offscreen_canvas.h"
21
22 #ifdef PIXEL_MAP_SUPPORTED
23 #include "pixel_map.h"
24 #endif
25
26 namespace OHOS::Ace::Framework {
SetFillText(const BaseInfo & baseInfo,const FillTextInfo & fillTextInfo)27 void CanvasRendererModelImpl::SetFillText(const BaseInfo& baseInfo, const FillTextInfo& fillTextInfo)
28 {
29 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
30 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
31 CHECK_NULL_VOID(offscreenPattern);
32 offscreenPattern->FillText(fillTextInfo.text, fillTextInfo.x, fillTextInfo.y, baseInfo.paintState);
33 return;
34 }
35
36 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
37 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
38 CHECK_NULL_VOID(canvasPattern);
39 canvasPattern->FillText(fillTextInfo.text, Offset(fillTextInfo.x, fillTextInfo.y));
40 }
41 }
42
SetStrokeText(const BaseInfo & baseInfo,const FillTextInfo & fillTextInfo)43 void CanvasRendererModelImpl::SetStrokeText(const BaseInfo& baseInfo, const FillTextInfo& fillTextInfo)
44 {
45 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
46 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
47 CHECK_NULL_VOID(offscreenPattern);
48 offscreenPattern->StrokeText(fillTextInfo.text, fillTextInfo.x, fillTextInfo.y, baseInfo.paintState);
49 return;
50 }
51
52 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
53 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
54 CHECK_NULL_VOID(canvasPattern);
55 canvasPattern->StrokeText(fillTextInfo.text, Offset(fillTextInfo.x, fillTextInfo.y));
56 }
57 }
58
SetAntiAlias(const BaseInfo & baseInfo)59 void CanvasRendererModelImpl::SetAntiAlias(const BaseInfo& baseInfo)
60 {
61 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
62 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
63 CHECK_NULL_VOID(offscreenPattern);
64 offscreenPattern->SetAntiAlias(baseInfo.anti);
65 return;
66 }
67
68 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
69 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
70 CHECK_NULL_VOID(canvasPattern);
71 canvasPattern->SetAntiAlias(baseInfo.anti);
72 }
73 }
74
SetFontWeight(const BaseInfo & baseInfo,const FontWeight & weight)75 void CanvasRendererModelImpl::SetFontWeight(const BaseInfo& baseInfo, const FontWeight& weight)
76 {
77 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
78 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
79 CHECK_NULL_VOID(offscreenPattern);
80 offscreenPattern->SetFontWeight(weight);
81 return;
82 }
83
84 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
85 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
86 CHECK_NULL_VOID(canvasPattern);
87 canvasPattern->UpdateFontWeight(weight);
88 }
89 }
90
SetFontStyle(const BaseInfo & baseInfo,const FontStyle & fontStyle)91 void CanvasRendererModelImpl::SetFontStyle(const BaseInfo& baseInfo, const FontStyle& fontStyle)
92 {
93 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
94 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
95 CHECK_NULL_VOID(offscreenPattern);
96 offscreenPattern->SetFontStyle(fontStyle);
97 return;
98 }
99
100 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
101 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
102 CHECK_NULL_VOID(canvasPattern);
103 canvasPattern->UpdateFontStyle(fontStyle);
104 }
105 }
106
SetFontFamilies(const BaseInfo & baseInfo,const std::vector<std::string> & families)107 void CanvasRendererModelImpl::SetFontFamilies(const BaseInfo& baseInfo, const std::vector<std::string>& families)
108 {
109 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
110 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
111 CHECK_NULL_VOID(offscreenPattern);
112 offscreenPattern->SetFontFamilies(families);
113 return;
114 }
115
116 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
117 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
118 CHECK_NULL_VOID(canvasPattern);
119 canvasPattern->UpdateFontFamilies(families);
120 }
121 }
122
SetFontSize(const BaseInfo & baseInfo,const Dimension & size)123 void CanvasRendererModelImpl::SetFontSize(const BaseInfo& baseInfo, const Dimension& size)
124 {
125 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
126 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
127 CHECK_NULL_VOID(offscreenPattern);
128 offscreenPattern->SetFontSize(size);
129 return;
130 }
131
132 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
133 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
134 CHECK_NULL_VOID(canvasPattern);
135 canvasPattern->UpdateFontSize(size);
136 }
137 }
138
GetLineDash(const BaseInfo & baseInfo)139 std::vector<double> CanvasRendererModelImpl::GetLineDash(const BaseInfo& baseInfo)
140 {
141 std::vector<double> lineDash {};
142 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
143 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
144 CHECK_NULL_RETURN(offscreenPattern, lineDash);
145 lineDash = offscreenPattern->GetLineDash().lineDash;
146 } else if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
147 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
148 CHECK_NULL_RETURN(canvasPattern, lineDash);
149 lineDash = canvasPattern->GetLineDash().lineDash;
150 }
151
152 return lineDash;
153 }
154
SetFillGradient(const BaseInfo & baseInfo,const Ace::Gradient & gradient)155 void CanvasRendererModelImpl::SetFillGradient(const BaseInfo& baseInfo, const Ace::Gradient& gradient)
156 {
157 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
158 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
159 CHECK_NULL_VOID(offscreenPattern);
160 offscreenPattern->SetFillGradient(gradient);
161 return;
162 }
163
164 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
165 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
166 CHECK_NULL_VOID(canvasPattern);
167 canvasPattern->UpdateFillGradient(gradient);
168 }
169 }
170
SetFillPattern(const BaseInfo & baseInfo,const std::shared_ptr<Ace::Pattern> & pattern)171 void CanvasRendererModelImpl::SetFillPattern(const BaseInfo& baseInfo, const std::shared_ptr<Ace::Pattern>& pattern)
172 {
173 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
174 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
175 CHECK_NULL_VOID(offscreenPattern);
176 offscreenPattern->SetFillPattern(*(pattern.get()));
177 return;
178 }
179
180 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
181 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
182 CHECK_NULL_VOID(canvasPattern);
183 canvasPattern->UpdateFillPattern(*(pattern.get()));
184 }
185 }
186
SetFillColor(const BaseInfo & baseInfo,const Color & color,bool colorFlag)187 void CanvasRendererModelImpl::SetFillColor(const BaseInfo& baseInfo, const Color& color, bool colorFlag)
188 {
189 if (!colorFlag) {
190 return;
191 }
192
193 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
194 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
195 CHECK_NULL_VOID(offscreenPattern);
196 offscreenPattern->SetFillColor(color);
197 return;
198 }
199
200 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
201 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
202 CHECK_NULL_VOID(canvasPattern);
203 canvasPattern->UpdateFillColor(color);
204 }
205 }
206
SetStrokeGradient(const BaseInfo & baseInfo,const Ace::Gradient & gradient)207 void CanvasRendererModelImpl::SetStrokeGradient(const BaseInfo& baseInfo, const Ace::Gradient& gradient)
208 {
209 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
210 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
211 CHECK_NULL_VOID(offscreenPattern);
212 offscreenPattern->SetStrokeGradient(gradient);
213 return;
214 }
215
216 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
217 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
218 CHECK_NULL_VOID(canvasPattern);
219 canvasPattern->UpdateStrokeGradient(gradient);
220 }
221 }
222
SetStrokePattern(const BaseInfo & baseInfo,const std::shared_ptr<Ace::Pattern> & pattern)223 void CanvasRendererModelImpl::SetStrokePattern(const BaseInfo& baseInfo, const std::shared_ptr<Ace::Pattern>& pattern)
224 {
225 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
226 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
227 CHECK_NULL_VOID(offscreenPattern);
228 offscreenPattern->SetStrokePattern(*(pattern.get()));
229 return;
230 }
231
232 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
233 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
234 CHECK_NULL_VOID(canvasPattern);
235 canvasPattern->UpdateStrokePattern(*(pattern.get()));
236 }
237 }
238
SetStrokeColor(const BaseInfo & baseInfo,const Color & color,bool colorFlag)239 void CanvasRendererModelImpl::SetStrokeColor(const BaseInfo& baseInfo, const Color& color, bool colorFlag)
240 {
241 if (!colorFlag) {
242 return;
243 }
244
245 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
246 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
247 CHECK_NULL_VOID(offscreenPattern);
248 offscreenPattern->SetStrokeColor(color);
249 return;
250 }
251
252 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
253 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
254 CHECK_NULL_VOID(canvasPattern);
255 canvasPattern->UpdateStrokeColor(color);
256 }
257 }
258
DrawImage(const BaseInfo & baseInfo,const ImageInfo & imageInfo)259 void CanvasRendererModelImpl::DrawImage(const BaseInfo& baseInfo, const ImageInfo& imageInfo)
260 {
261 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
262 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
263 CHECK_NULL_VOID(offscreenPattern);
264 if (imageInfo.isImage) {
265 offscreenPattern->DrawImage(imageInfo.image, imageInfo.imgWidth, imageInfo.imgHeight);
266 return;
267 }
268 offscreenPattern->DrawPixelMap(imageInfo.pixelMap, imageInfo.image);
269 return;
270 }
271
272 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
273 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
274 CHECK_NULL_VOID(canvasPattern);
275 if (imageInfo.isImage) {
276 canvasPattern->DrawImage(imageInfo.image, imageInfo.imgWidth, imageInfo.imgHeight);
277 return;
278 }
279 canvasPattern->DrawPixelMap(imageInfo.pixelMap, imageInfo.image);
280 }
281 }
282
PutImageData(const BaseInfo & baseInfo,const ImageData & imageData)283 void CanvasRendererModelImpl::PutImageData(const BaseInfo& baseInfo, const ImageData& imageData)
284 {
285 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
286 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
287 CHECK_NULL_VOID(offscreenPattern);
288 offscreenPattern->PutImageData(imageData);
289 return;
290 }
291
292 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
293 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
294 CHECK_NULL_VOID(canvasPattern);
295 canvasPattern->PutImageData(imageData);
296 }
297 }
298
GetImageData(const BaseInfo & baseInfo,const ImageSize & imageSize)299 std::unique_ptr<ImageData> CanvasRendererModelImpl::GetImageData(const BaseInfo& baseInfo, const ImageSize& imageSize)
300 {
301 std::unique_ptr<ImageData> data;
302 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
303 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
304 CHECK_NULL_RETURN(offscreenPattern, data);
305 data = offscreenPattern->GetImageData(imageSize.left, imageSize.top, imageSize.width, imageSize.height);
306 } else if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
307 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
308 CHECK_NULL_RETURN(canvasPattern, data);
309 data = canvasPattern->GetImageData(imageSize.left, imageSize.top, imageSize.width, imageSize.height);
310 }
311 return data;
312 }
313
DrawPixelMap(const BaseInfo & baseInfo,const ImageInfo & imageInfo)314 void CanvasRendererModelImpl::DrawPixelMap(const BaseInfo& baseInfo, const ImageInfo& imageInfo)
315 {
316 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
317 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
318 CHECK_NULL_VOID(offscreenPattern);
319 offscreenPattern->DrawPixelMap(imageInfo.pixelMap, imageInfo.image);
320 return;
321 }
322
323 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
324 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
325 CHECK_NULL_VOID(canvasPattern);
326 canvasPattern->DrawPixelMap(imageInfo.pixelMap, imageInfo.image);
327 }
328 }
329
GetJsonData(const BaseInfo & baseInfo,const std::string & path)330 std::string CanvasRendererModelImpl::GetJsonData(const BaseInfo& baseInfo, const std::string& path)
331 {
332 std::string jsonData = "";
333 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
334 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
335 CHECK_NULL_RETURN(canvasPattern, jsonData);
336 jsonData = canvasPattern->GetJsonData(path);
337 }
338 return jsonData;
339 }
340
ToDataURL(const BaseInfo & baseInfo,const std::string & dataUrl,double quality)341 std::string CanvasRendererModelImpl::ToDataURL(const BaseInfo& baseInfo, const std::string& dataUrl, double quality)
342 {
343 std::string result = "";
344 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
345 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
346 CHECK_NULL_RETURN(offscreenPattern, result);
347 result = offscreenPattern->ToDataURL(dataUrl, quality);
348 } else if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
349 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
350 CHECK_NULL_RETURN(canvasPattern, result);
351 result = canvasPattern->ToDataURL(dataUrl + "," + std::to_string(quality));
352 }
353 return result;
354 }
355
SetLineCap(const BaseInfo & baseInfo,const LineCapStyle & lineCap)356 void CanvasRendererModelImpl::SetLineCap(const BaseInfo& baseInfo, const LineCapStyle& lineCap)
357 {
358 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
359 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
360 CHECK_NULL_VOID(offscreenPattern);
361 offscreenPattern->SetLineCap(lineCap);
362 return;
363 }
364
365 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
366 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
367 CHECK_NULL_VOID(canvasPattern);
368 canvasPattern->UpdateLineCap(lineCap);
369 }
370 }
371
SetLineJoin(const BaseInfo & baseInfo,const LineJoinStyle & lineJoin)372 void CanvasRendererModelImpl::SetLineJoin(const BaseInfo& baseInfo, const LineJoinStyle& lineJoin)
373 {
374 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
375 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
376 CHECK_NULL_VOID(offscreenPattern);
377 offscreenPattern->SetLineJoin(lineJoin);
378 return;
379 }
380
381 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
382 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
383 CHECK_NULL_VOID(canvasPattern);
384 canvasPattern->UpdateLineJoin(lineJoin);
385 }
386 }
387
SetMiterLimit(const BaseInfo & baseInfo,double limit)388 void CanvasRendererModelImpl::SetMiterLimit(const BaseInfo& baseInfo, double limit)
389 {
390 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
391 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
392 CHECK_NULL_VOID(offscreenPattern);
393 offscreenPattern->SetMiterLimit(limit);
394 return;
395 }
396
397 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
398 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
399 CHECK_NULL_VOID(canvasPattern);
400 canvasPattern->UpdateMiterLimit(limit);
401 }
402 }
403
SetLineWidth(const BaseInfo & baseInfo,double lineWidth)404 void CanvasRendererModelImpl::SetLineWidth(const BaseInfo& baseInfo, double lineWidth)
405 {
406 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
407 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
408 CHECK_NULL_VOID(offscreenPattern);
409 offscreenPattern->SetLineWidth(lineWidth);
410 return;
411 }
412
413 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
414 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
415 CHECK_NULL_VOID(canvasPattern);
416 canvasPattern->UpdateLineWidth(lineWidth);
417 }
418 }
419
SetGlobalAlpha(const BaseInfo & baseInfo,double alpha)420 void CanvasRendererModelImpl::SetGlobalAlpha(const BaseInfo& baseInfo, double alpha)
421 {
422 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
423 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
424 CHECK_NULL_VOID(offscreenPattern);
425 offscreenPattern->SetAlpha(alpha);
426 return;
427 }
428
429 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
430 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
431 CHECK_NULL_VOID(canvasPattern);
432 canvasPattern->UpdateGlobalAlpha(alpha);
433 }
434 }
435
SetCompositeType(const BaseInfo & baseInfo,const CompositeOperation & type)436 void CanvasRendererModelImpl::SetCompositeType(const BaseInfo& baseInfo, const CompositeOperation& type)
437 {
438 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
439 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
440 CHECK_NULL_VOID(offscreenPattern);
441 offscreenPattern->SetCompositeType(type);
442 return;
443 }
444
445 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
446 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
447 CHECK_NULL_VOID(canvasPattern);
448 canvasPattern->UpdateCompositeOperation(type);
449 }
450 }
451
SetLineDashOffset(const BaseInfo & baseInfo,double lineDashOffset)452 void CanvasRendererModelImpl::SetLineDashOffset(const BaseInfo& baseInfo, double lineDashOffset)
453 {
454 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
455 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
456 CHECK_NULL_VOID(offscreenPattern);
457 offscreenPattern->SetLineDashOffset(lineDashOffset);
458 return;
459 }
460
461 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
462 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
463 CHECK_NULL_VOID(canvasPattern);
464 canvasPattern->UpdateLineDashOffset(lineDashOffset);
465 }
466 }
467
SetShadowBlur(const BaseInfo & baseInfo,double blur)468 void CanvasRendererModelImpl::SetShadowBlur(const BaseInfo& baseInfo, double blur)
469 {
470 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
471 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
472 CHECK_NULL_VOID(offscreenPattern);
473 offscreenPattern->SetShadowBlur(blur);
474 return;
475 }
476
477 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
478 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
479 CHECK_NULL_VOID(canvasPattern);
480 canvasPattern->UpdateShadowBlur(blur);
481 }
482 }
483
SetShadowColor(const BaseInfo & baseInfo,const Color & color)484 void CanvasRendererModelImpl::SetShadowColor(const BaseInfo& baseInfo, const Color& color)
485 {
486 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
487 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
488 CHECK_NULL_VOID(offscreenPattern);
489 offscreenPattern->SetShadowColor(color);
490 return;
491 }
492
493 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
494 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
495 CHECK_NULL_VOID(canvasPattern);
496 canvasPattern->UpdateShadowColor(color);
497 }
498 }
499
SetShadowOffsetX(const BaseInfo & baseInfo,double offsetX)500 void CanvasRendererModelImpl::SetShadowOffsetX(const BaseInfo& baseInfo, double offsetX)
501 {
502 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
503 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
504 CHECK_NULL_VOID(offscreenPattern);
505 offscreenPattern->SetShadowOffsetX(offsetX);
506 return;
507 }
508
509 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
510 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
511 CHECK_NULL_VOID(canvasPattern);
512 canvasPattern->UpdateShadowOffsetX(offsetX);
513 }
514 }
515
SetShadowOffsetY(const BaseInfo & baseInfo,double offsetY)516 void CanvasRendererModelImpl::SetShadowOffsetY(const BaseInfo& baseInfo, double offsetY)
517 {
518 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
519 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
520 CHECK_NULL_VOID(offscreenPattern);
521 offscreenPattern->SetShadowOffsetY(offsetY);
522 return;
523 }
524
525 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
526 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
527 CHECK_NULL_VOID(canvasPattern);
528 canvasPattern->UpdateShadowOffsetY(offsetY);
529 }
530 }
531
SetSmoothingEnabled(const BaseInfo & baseInfo,bool enabled)532 void CanvasRendererModelImpl::SetSmoothingEnabled(const BaseInfo& baseInfo, bool enabled)
533 {
534 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
535 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
536 CHECK_NULL_VOID(offscreenPattern);
537 offscreenPattern->SetSmoothingEnabled(enabled);
538 return;
539 }
540
541 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
542 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
543 CHECK_NULL_VOID(canvasPattern);
544 canvasPattern->UpdateSmoothingEnabled(enabled);
545 }
546 }
547
SetSmoothingQuality(const BaseInfo & baseInfo,const std::string & quality)548 void CanvasRendererModelImpl::SetSmoothingQuality(const BaseInfo& baseInfo, const std::string& quality)
549 {
550 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
551 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
552 CHECK_NULL_VOID(offscreenPattern);
553 offscreenPattern->SetSmoothingQuality(quality);
554 return;
555 }
556
557 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
558 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
559 CHECK_NULL_VOID(canvasPattern);
560 canvasPattern->UpdateSmoothingQuality(quality);
561 }
562 }
563
MoveTo(const BaseInfo & baseInfo,double x,double y)564 void CanvasRendererModelImpl::MoveTo(const BaseInfo& baseInfo, double x, double y)
565 {
566 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
567 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
568 CHECK_NULL_VOID(offscreenPattern);
569 offscreenPattern->MoveTo(x, y);
570 return;
571 }
572
573 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
574 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
575 CHECK_NULL_VOID(canvasPattern);
576 canvasPattern->MoveTo(x, y);
577 }
578 }
579
LineTo(const BaseInfo & baseInfo,double x,double y)580 void CanvasRendererModelImpl::LineTo(const BaseInfo& baseInfo, double x, double y)
581 {
582 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
583 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
584 CHECK_NULL_VOID(offscreenPattern);
585 offscreenPattern->LineTo(x, y);
586 return;
587 }
588
589 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
590 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
591 CHECK_NULL_VOID(canvasPattern);
592 canvasPattern->LineTo(x, y);
593 }
594 }
595
BezierCurveTo(const BaseInfo & baseInfo,const BezierCurveParam & param)596 void CanvasRendererModelImpl::BezierCurveTo(const BaseInfo& baseInfo, const BezierCurveParam& param)
597 {
598 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
599 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
600 CHECK_NULL_VOID(offscreenPattern);
601 offscreenPattern->BezierCurveTo(param);
602 return;
603 }
604
605 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
606 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
607 CHECK_NULL_VOID(canvasPattern);
608 canvasPattern->BezierCurveTo(param);
609 }
610 }
611
QuadraticCurveTo(const BaseInfo & baseInfo,const QuadraticCurveParam & param)612 void CanvasRendererModelImpl::QuadraticCurveTo(const BaseInfo& baseInfo, const QuadraticCurveParam& param)
613 {
614 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
615 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
616 CHECK_NULL_VOID(offscreenPattern);
617 offscreenPattern->QuadraticCurveTo(param);
618 return;
619 }
620
621 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
622 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
623 CHECK_NULL_VOID(canvasPattern);
624 canvasPattern->QuadraticCurveTo(param);
625 }
626 }
627
ArcTo(const BaseInfo & baseInfo,const ArcToParam & param)628 void CanvasRendererModelImpl::ArcTo(const BaseInfo& baseInfo, const ArcToParam& param)
629 {
630 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
631 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
632 CHECK_NULL_VOID(offscreenPattern);
633 offscreenPattern->ArcTo(param);
634 return;
635 }
636
637 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
638 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
639 CHECK_NULL_VOID(canvasPattern);
640 canvasPattern->ArcTo(param);
641 }
642 }
643
Arc(const BaseInfo & baseInfo,const ArcParam & param)644 void CanvasRendererModelImpl::Arc(const BaseInfo& baseInfo, const ArcParam& param)
645 {
646 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
647 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
648 CHECK_NULL_VOID(offscreenPattern);
649 offscreenPattern->Arc(param);
650 return;
651 }
652
653 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
654 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
655 CHECK_NULL_VOID(canvasPattern);
656 canvasPattern->Arc(param);
657 }
658 }
659
Ellipse(const BaseInfo & baseInfo,const EllipseParam & param)660 void CanvasRendererModelImpl::Ellipse(const BaseInfo& baseInfo, const EllipseParam& param)
661 {
662 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
663 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
664 CHECK_NULL_VOID(offscreenPattern);
665 offscreenPattern->Ellipse(param);
666 return;
667 }
668
669 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
670 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
671 CHECK_NULL_VOID(canvasPattern);
672 canvasPattern->Ellipse(param);
673 }
674 }
675
SetFillRuleForPath(const BaseInfo & baseInfo,const CanvasFillRule & fillRule)676 void CanvasRendererModelImpl::SetFillRuleForPath(const BaseInfo& baseInfo, const CanvasFillRule& fillRule)
677 {
678 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
679 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
680 CHECK_NULL_VOID(offscreenPattern);
681 offscreenPattern->SetFillRuleForPath(fillRule);
682 offscreenPattern->Fill();
683 return;
684 }
685
686 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
687 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
688 CHECK_NULL_VOID(canvasPattern);
689 canvasPattern->UpdateFillRuleForPath(fillRule);
690 canvasPattern->Fill();
691 }
692 }
693
SetFillRuleForPath2D(const BaseInfo & baseInfo,const CanvasFillRule & fillRule,const RefPtr<CanvasPath2D> & path)694 void CanvasRendererModelImpl::SetFillRuleForPath2D(
695 const BaseInfo& baseInfo, const CanvasFillRule& fillRule, const RefPtr<CanvasPath2D>& path)
696 {
697 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
698 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
699 CHECK_NULL_VOID(offscreenPattern);
700 offscreenPattern->SetFillRuleForPath2D(fillRule);
701 offscreenPattern->Fill(path);
702 return;
703 }
704
705 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
706 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
707 CHECK_NULL_VOID(canvasPattern);
708 canvasPattern->UpdateFillRuleForPath2D(fillRule);
709 canvasPattern->Fill(path);
710 }
711 }
712
SetStrokeRuleForPath2D(const BaseInfo & baseInfo,const CanvasFillRule & fillRule,const RefPtr<CanvasPath2D> & path)713 void CanvasRendererModelImpl::SetStrokeRuleForPath2D(
714 const BaseInfo& baseInfo, const CanvasFillRule& fillRule, const RefPtr<CanvasPath2D>& path)
715 {
716 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
717 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
718 CHECK_NULL_VOID(offscreenPattern);
719 offscreenPattern->SetFillRuleForPath(fillRule);
720 offscreenPattern->Stroke(path);
721 return;
722 }
723
724 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
725 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
726 CHECK_NULL_VOID(canvasPattern);
727 canvasPattern->UpdateFillRuleForPath2D(fillRule);
728 canvasPattern->Stroke(path);
729 }
730 }
731
SetStrokeRuleForPath(const BaseInfo & baseInfo,const CanvasFillRule & fillRule)732 void CanvasRendererModelImpl::SetStrokeRuleForPath(const BaseInfo& baseInfo, const CanvasFillRule& fillRule)
733 {
734 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
735 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
736 CHECK_NULL_VOID(offscreenPattern);
737 offscreenPattern->SetFillRuleForPath2D(fillRule);
738 offscreenPattern->Stroke();
739 return;
740 }
741
742 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
743 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
744 CHECK_NULL_VOID(canvasPattern);
745 canvasPattern->UpdateFillRuleForPath(fillRule);
746 canvasPattern->Stroke();
747 }
748 }
749
SetClipRuleForPath(const BaseInfo & baseInfo,const CanvasFillRule & fillRule)750 void CanvasRendererModelImpl::SetClipRuleForPath(const BaseInfo& baseInfo, const CanvasFillRule& fillRule)
751 {
752 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
753 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
754 CHECK_NULL_VOID(offscreenPattern);
755 offscreenPattern->SetFillRuleForPath(fillRule);
756 offscreenPattern->Clip();
757 return;
758 }
759
760 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
761 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
762 CHECK_NULL_VOID(canvasPattern);
763 canvasPattern->UpdateFillRuleForPath(fillRule);
764 canvasPattern->Clip();
765 }
766 }
767
SetClipRuleForPath2D(const BaseInfo & baseInfo,const CanvasFillRule & fillRule,const RefPtr<CanvasPath2D> & path)768 void CanvasRendererModelImpl::SetClipRuleForPath2D(
769 const BaseInfo& baseInfo, const CanvasFillRule& fillRule, const RefPtr<CanvasPath2D>& path)
770 {
771 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
772 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
773 CHECK_NULL_VOID(offscreenPattern);
774 offscreenPattern->SetFillRuleForPath2D(fillRule);
775 offscreenPattern->Clip(path);
776 return;
777 }
778
779 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
780 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
781 CHECK_NULL_VOID(canvasPattern);
782 canvasPattern->UpdateFillRuleForPath2D(fillRule);
783 canvasPattern->Clip(path);
784 }
785 }
786
AddRect(const BaseInfo & baseInfo,const Rect & rect)787 void CanvasRendererModelImpl::AddRect(const BaseInfo& baseInfo, const Rect& rect)
788 {
789 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
790 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
791 CHECK_NULL_VOID(offscreenPattern);
792 offscreenPattern->AddRect(rect);
793 return;
794 }
795
796 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
797 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
798 CHECK_NULL_VOID(canvasPattern);
799 canvasPattern->AddRect(rect);
800 }
801 }
802
BeginPath(const BaseInfo & baseInfo)803 void CanvasRendererModelImpl::BeginPath(const BaseInfo& baseInfo)
804 {
805 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
806 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
807 CHECK_NULL_VOID(offscreenPattern);
808 offscreenPattern->BeginPath();
809 return;
810 }
811
812 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
813 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
814 CHECK_NULL_VOID(canvasPattern);
815 canvasPattern->BeginPath();
816 }
817 }
818
ClosePath(const BaseInfo & baseInfo)819 void CanvasRendererModelImpl::ClosePath(const BaseInfo& baseInfo)
820 {
821 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
822 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
823 CHECK_NULL_VOID(offscreenPattern);
824 offscreenPattern->ClosePath();
825 return;
826 }
827
828 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
829 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
830 CHECK_NULL_VOID(canvasPattern);
831 canvasPattern->ClosePath();
832 }
833 }
834
Restore(const BaseInfo & baseInfo)835 void CanvasRendererModelImpl::Restore(const BaseInfo& baseInfo)
836 {
837 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
838 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
839 CHECK_NULL_VOID(offscreenPattern);
840 offscreenPattern->Restore();
841 return;
842 }
843
844 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
845 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
846 CHECK_NULL_VOID(canvasPattern);
847 canvasPattern->Restore();
848 }
849 }
850
CanvasRendererSave(const BaseInfo & baseInfo)851 void CanvasRendererModelImpl::CanvasRendererSave(const BaseInfo& baseInfo)
852 {
853 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
854 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
855 CHECK_NULL_VOID(offscreenPattern);
856 offscreenPattern->Save();
857 return;
858 }
859
860 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
861 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
862 CHECK_NULL_VOID(canvasPattern);
863 canvasPattern->Save();
864 }
865 }
866
CanvasRendererRotate(const BaseInfo & baseInfo,double angle)867 void CanvasRendererModelImpl::CanvasRendererRotate(const BaseInfo& baseInfo, double angle)
868 {
869 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
870 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
871 CHECK_NULL_VOID(offscreenPattern);
872 offscreenPattern->Rotate(angle);
873 return;
874 }
875
876 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
877 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
878 CHECK_NULL_VOID(canvasPattern);
879 canvasPattern->Rotate(angle);
880 }
881 }
882
CanvasRendererScale(const BaseInfo & baseInfo,double x,double y)883 void CanvasRendererModelImpl::CanvasRendererScale(const BaseInfo& baseInfo, double x, double y)
884 {
885 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
886 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
887 CHECK_NULL_VOID(offscreenPattern);
888 offscreenPattern->Scale(x, y);
889 return;
890 }
891
892 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
893 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
894 CHECK_NULL_VOID(canvasPattern);
895 canvasPattern->Scale(x, y);
896 }
897 }
898
SetTransform(const BaseInfo & baseInfo,TransformParam & param,bool lengthFlag)899 void CanvasRendererModelImpl::SetTransform(const BaseInfo& baseInfo, TransformParam& param, bool lengthFlag)
900 {
901 if (!lengthFlag) {
902 return;
903 }
904
905 auto temp = param.skewX;
906 param.skewX = param.skewY;
907 param.skewY = temp;
908
909 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
910 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
911 CHECK_NULL_VOID(offscreenPattern);
912 offscreenPattern->SetTransform(param);
913 return;
914 }
915
916 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
917 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
918 CHECK_NULL_VOID(canvasPattern);
919 canvasPattern->SetTransform(param);
920 }
921 }
922
ResetTransform(const BaseInfo & baseInfo)923 void CanvasRendererModelImpl::ResetTransform(const BaseInfo& baseInfo)
924 {
925 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
926 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
927 CHECK_NULL_VOID(offscreenPattern);
928 offscreenPattern->ResetTransform();
929 return;
930 }
931
932 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
933 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
934 CHECK_NULL_VOID(canvasPattern);
935 canvasPattern->ResetTransform();
936 }
937 }
938
Transform(const BaseInfo & baseInfo,const TransformParam & param)939 void CanvasRendererModelImpl::Transform(const BaseInfo& baseInfo, const TransformParam& param)
940 {
941 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
942 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
943 CHECK_NULL_VOID(offscreenPattern);
944 offscreenPattern->Transform(param);
945 return;
946 }
947
948 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
949 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
950 CHECK_NULL_VOID(canvasPattern);
951 canvasPattern->Transform(param);
952 }
953 }
954
Translate(const BaseInfo & baseInfo,double x,double y)955 void CanvasRendererModelImpl::Translate(const BaseInfo& baseInfo, double x, double y)
956 {
957 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
958 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
959 CHECK_NULL_VOID(offscreenPattern);
960 offscreenPattern->Translate(x, y);
961 return;
962 }
963
964 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
965 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
966 CHECK_NULL_VOID(canvasPattern);
967 canvasPattern->Translate(x, y);
968 }
969 }
970
SetLineDash(const BaseInfo & baseInfo,const std::vector<double> & lineDash)971 void CanvasRendererModelImpl::SetLineDash(const BaseInfo& baseInfo, const std::vector<double>& lineDash)
972 {
973 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
974 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
975 CHECK_NULL_VOID(offscreenPattern);
976 offscreenPattern->SetLineDash(lineDash);
977 return;
978 }
979
980 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
981 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
982 CHECK_NULL_VOID(canvasPattern);
983 canvasPattern->UpdateLineDash(lineDash);
984 }
985 }
986
SetTextAlign(const BaseInfo & baseInfo,const TextAlign & align)987 void CanvasRendererModelImpl::SetTextAlign(const BaseInfo& baseInfo, const TextAlign& align)
988 {
989 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
990 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
991 CHECK_NULL_VOID(offscreenPattern);
992 offscreenPattern->SetTextAlign(align);
993 return;
994 }
995
996 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
997 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
998 CHECK_NULL_VOID(canvasPattern);
999 canvasPattern->UpdateTextAlign(align);
1000 }
1001 }
1002
SetTextBaseline(const BaseInfo & baseInfo,const TextBaseline & baseline)1003 void CanvasRendererModelImpl::SetTextBaseline(const BaseInfo& baseInfo, const TextBaseline& baseline)
1004 {
1005 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
1006 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
1007 CHECK_NULL_VOID(offscreenPattern);
1008 offscreenPattern->SetTextBaseline(baseline);
1009 return;
1010 }
1011
1012 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
1013 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
1014 CHECK_NULL_VOID(canvasPattern);
1015 canvasPattern->UpdateTextBaseline(baseline);
1016 }
1017 }
1018
GetMeasureTextWidth(const BaseInfo & baseInfo,const std::string & text)1019 double CanvasRendererModelImpl::GetMeasureTextWidth(const BaseInfo& baseInfo, const std::string& text)
1020 {
1021 double width = 0.0;
1022 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
1023 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
1024 CHECK_NULL_RETURN(offscreenPattern, width);
1025 width = offscreenPattern->MeasureText(text, baseInfo.paintState);
1026 return width;
1027 }
1028
1029 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
1030 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
1031 CHECK_NULL_RETURN(canvasPattern, width);
1032 width = canvasPattern->MeasureText(text, baseInfo.paintState);
1033 }
1034 return width;
1035 }
1036
GetMeasureTextHeight(const BaseInfo & baseInfo,const std::string & text)1037 double CanvasRendererModelImpl::GetMeasureTextHeight(const BaseInfo& baseInfo, const std::string& text)
1038 {
1039 double height = 0.0;
1040 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
1041 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
1042 CHECK_NULL_RETURN(offscreenPattern, height);
1043 height = offscreenPattern->MeasureTextHeight(text, baseInfo.paintState);
1044 return height;
1045 }
1046
1047 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
1048 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
1049 CHECK_NULL_RETURN(canvasPattern, height);
1050 height = canvasPattern->MeasureTextHeight(text, baseInfo.paintState);
1051 }
1052 return height;
1053 }
1054
FillRect(const BaseInfo & baseInfo,const Rect & rect)1055 void CanvasRendererModelImpl::FillRect(const BaseInfo& baseInfo, const Rect& rect)
1056 {
1057 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
1058 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
1059 CHECK_NULL_VOID(offscreenPattern);
1060 offscreenPattern->FillRect(rect);
1061 return;
1062 }
1063
1064 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
1065 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
1066 CHECK_NULL_VOID(canvasPattern);
1067 canvasPattern->FillRect(rect);
1068 }
1069 }
1070
StrokeRect(const BaseInfo & baseInfo,const Rect & rect)1071 void CanvasRendererModelImpl::StrokeRect(const BaseInfo& baseInfo, const Rect& rect)
1072 {
1073 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
1074 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
1075 CHECK_NULL_VOID(offscreenPattern);
1076 offscreenPattern->StrokeRect(rect);
1077 return;
1078 }
1079
1080 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
1081 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
1082 CHECK_NULL_VOID(canvasPattern);
1083 canvasPattern->StrokeRect(rect);
1084 }
1085 }
1086
ClearRect(const BaseInfo & baseInfo,const Rect & rect)1087 void CanvasRendererModelImpl::ClearRect(const BaseInfo& baseInfo, const Rect& rect)
1088 {
1089 if (baseInfo.isOffscreen && baseInfo.offscreenPattern) {
1090 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(baseInfo.offscreenPattern);
1091 CHECK_NULL_VOID(offscreenPattern);
1092 offscreenPattern->ClearRect(rect);
1093 return;
1094 }
1095
1096 if (!baseInfo.isOffscreen && baseInfo.canvasPattern) {
1097 auto canvasPattern = AceType::DynamicCast<CanvasTaskPool>(baseInfo.canvasPattern);
1098 CHECK_NULL_VOID(canvasPattern);
1099 canvasPattern->ClearRect(rect);
1100 }
1101 }
1102
DrawBitmapMesh(const BitmapMeshInfo & bitmapMeshInfo)1103 void CanvasRendererModelImpl::DrawBitmapMesh(const BitmapMeshInfo& bitmapMeshInfo)
1104 {
1105 CHECK_NULL_VOID(bitmapMeshInfo.pool);
1106 auto pool = AceType::DynamicCast<CanvasTaskPool>(bitmapMeshInfo.pool);
1107 CHECK_NULL_VOID(pool);
1108 CHECK_NULL_VOID(bitmapMeshInfo.offscreenPattern);
1109 auto offscreenPattern = AceType::DynamicCast<OffscreenCanvas>(bitmapMeshInfo.offscreenPattern);
1110 CHECK_NULL_VOID(offscreenPattern);
1111 pool->DrawBitmapMesh(offscreenPattern, bitmapMeshInfo.mesh, bitmapMeshInfo.column, bitmapMeshInfo.row);
1112 }
1113
GetPixelMap(const BaseInfo & baseInfo,const ImageSize & imageSize)1114 RefPtr<Ace::PixelMap> CanvasRendererModelImpl::GetPixelMap(
1115 const BaseInfo& baseInfo, const ImageSize& imageSize)
1116 {
1117 #ifdef PIXEL_MAP_SUPPORTED
1118 // 1 Get data from canvas
1119 std::unique_ptr<ImageData> canvasData = GetImageData(baseInfo, imageSize);
1120 CHECK_NULL_RETURN(canvasData, nullptr);
1121
1122 uint32_t finalHeight = static_cast<uint32_t>(std::abs(imageSize.height));
1123 uint32_t finalWidth = static_cast<uint32_t>(std::abs(imageSize.width));
1124 if (finalHeight > 0 && finalWidth > (UINT32_MAX / finalHeight)) {
1125 LOGE("Integer Overflow!!!the product of finalHeight and finalWidth is too big.");
1126 return nullptr;
1127 }
1128 uint32_t length = finalHeight * finalWidth;
1129 uint32_t* data = new uint32_t[length];
1130 for (uint32_t i = 0; i < finalHeight; i++) {
1131 for (uint32_t j = 0; j < finalWidth; j++) {
1132 uint32_t idx = i * finalWidth + j;
1133 Color pixel = canvasData->data[idx];
1134 data[idx] = pixel.GetValue();
1135 }
1136 }
1137
1138 // 2 Create pixelmap
1139 OHOS::Media::InitializationOptions options;
1140 options.alphaType = OHOS::Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1141 options.pixelFormat = OHOS::Media::PixelFormat::RGBA_8888;
1142 options.scaleMode = OHOS::Media::ScaleMode::CENTER_CROP;
1143 options.size.width = static_cast<int32_t>(finalWidth);
1144 options.size.height = static_cast<int32_t>(finalHeight);
1145 options.editable = true;
1146 auto pixelmap = Ace::PixelMap::Create(OHOS::Media::PixelMap::Create(data, length, options));
1147 delete[] data;
1148 return pixelmap;
1149 #else
1150 return nullptr;
1151 #endif
1152 }
1153
GetImageDataModel(const BaseInfo & baseInfo,const ImageSize & imageSize,uint8_t * buffer)1154 void CanvasRendererModelImpl::GetImageDataModel(const BaseInfo& baseInfo, const ImageSize& imageSize, uint8_t* buffer)
1155 {
1156 auto finalHeight = static_cast<uint32_t>(std::abs(imageSize.height));
1157 auto finalWidth = static_cast<uint32_t>(std::abs(imageSize.width));
1158 std::unique_ptr<Ace::ImageData> data = GetImageData(baseInfo, imageSize);
1159
1160 if (data != nullptr) {
1161 for (uint32_t idx = 0; idx < finalHeight * finalWidth; ++idx) {
1162 buffer[4 * idx] = data->data[idx].GetRed();
1163 buffer[4 * idx + 1] = data->data[idx].GetGreen();
1164 buffer[4 * idx + 2] = data->data[idx].GetBlue();
1165 buffer[4 * idx + 3] = data->data[idx].GetAlpha();
1166 }
1167 }
1168 }
1169 } // namespace OHOS::Ace::Framework