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