1 /*
2 * Copyright (c) 2024 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 "js_pen.h"
17
18 #include <cstdint>
19
20 #include "color_filter_napi/js_color_filter.h"
21 #include "image_filter_napi/js_image_filter.h"
22 #include "js_drawing_utils.h"
23 #include "mask_filter_napi/js_mask_filter.h"
24 #include "matrix_napi/js_matrix.h"
25 #include "path_effect_napi/js_path_effect.h"
26 #include "path_napi/js_path.h"
27 #include "shader_effect_napi/js_shader_effect.h"
28 #include "shadow_layer_napi/js_shadow_layer.h"
29
30 namespace OHOS::Rosen {
31 namespace Drawing {
32 thread_local napi_ref JsPen::constructor_ = nullptr;
33 const std::string CLASS_NAME = "Pen";
Init(napi_env env,napi_value exportObj)34 napi_value JsPen::Init(napi_env env, napi_value exportObj)
35 {
36 napi_property_descriptor properties[] = {
37 DECLARE_NAPI_FUNCTION("setAntiAlias", SetAntiAlias),
38 DECLARE_NAPI_FUNCTION("setAlpha", SetAlpha),
39 DECLARE_NAPI_FUNCTION("getAlpha", GetAlpha),
40 DECLARE_NAPI_FUNCTION("setBlendMode", SetBlendMode),
41 DECLARE_NAPI_FUNCTION("setCapStyle", SetCapStyle),
42 DECLARE_NAPI_FUNCTION("getCapStyle", GetCapStyle),
43 DECLARE_NAPI_FUNCTION("setColor", SetColor),
44 DECLARE_NAPI_FUNCTION("getColor", GetColor),
45 DECLARE_NAPI_FUNCTION("setColorFilter", SetColorFilter),
46 DECLARE_NAPI_FUNCTION("getColorFilter", GetColorFilter),
47 DECLARE_NAPI_FUNCTION("setImageFilter", SetImageFilter),
48 DECLARE_NAPI_FUNCTION("setDither", SetDither),
49 DECLARE_NAPI_FUNCTION("setJoinStyle", SetJoinStyle),
50 DECLARE_NAPI_FUNCTION("getJoinStyle", GetJoinStyle),
51 DECLARE_NAPI_FUNCTION("setMaskFilter", SetMaskFilter),
52 DECLARE_NAPI_FUNCTION("setPathEffect", SetPathEffect),
53 DECLARE_NAPI_FUNCTION("setStrokeWidth", SetStrokeWidth),
54 DECLARE_NAPI_FUNCTION("setShadowLayer", SetShadowLayer),
55 DECLARE_NAPI_FUNCTION("setShaderEffect", SetShaderEffect),
56 DECLARE_NAPI_FUNCTION("getFillPath", GetFillPath),
57 DECLARE_NAPI_FUNCTION("isAntiAlias", IsAntiAlias),
58 DECLARE_NAPI_FUNCTION("getWidth", GetWidth),
59 DECLARE_NAPI_FUNCTION("setMiterLimit", SetMiterLimit),
60 DECLARE_NAPI_FUNCTION("getMiterLimit", GetMiterLimit),
61 DECLARE_NAPI_FUNCTION("reset", Reset),
62 };
63
64 napi_value constructor = nullptr;
65 napi_status status = napi_define_class(env, CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Constructor, nullptr,
66 sizeof(properties) / sizeof(properties[0]), properties, &constructor);
67 if (status != napi_ok) {
68 ROSEN_LOGE("JsPen::Init Failed to define Pen class");
69 return nullptr;
70 }
71
72 status = napi_create_reference(env, constructor, 1, &constructor_);
73 if (status != napi_ok) {
74 ROSEN_LOGE("JsPen::Init Failed to create reference of constructor");
75 return nullptr;
76 }
77
78 status = napi_set_named_property(env, exportObj, CLASS_NAME.c_str(), constructor);
79 if (status != napi_ok) {
80 ROSEN_LOGE("JsPen::Init Failed to set constructor");
81 return nullptr;
82 }
83
84 return exportObj;
85 }
86
Constructor(napi_env env,napi_callback_info info)87 napi_value JsPen::Constructor(napi_env env, napi_callback_info info)
88 {
89 size_t argCount = ARGC_ONE;
90 napi_value argv[ARGC_ONE] = {nullptr};
91 napi_value jsThis = nullptr;
92 napi_status status = napi_get_cb_info(env, info, &argCount, argv, &jsThis, nullptr);
93 if (status != napi_ok) {
94 ROSEN_LOGE("JsPen::Constructor failed to napi_get_cb_info");
95 return nullptr;
96 }
97
98 JsPen* jsPen = nullptr;
99 if (argCount == 0) {
100 jsPen = new JsPen();
101 } else {
102 JsPen* otherPen = nullptr;
103 GET_UNWRAP_PARAM(ARGC_ZERO, otherPen);
104 Pen* pen = otherPen->GetPen();
105 if (pen != nullptr) {
106 jsPen = new JsPen(*pen);
107 }
108 }
109 if (jsPen == nullptr) {
110 ROSEN_LOGE("JsPen::Constructor jsPen is nullptr");
111 return nullptr;
112 }
113
114 status = napi_wrap(env, jsThis, jsPen, JsPen::Destructor, nullptr, nullptr);
115 if (status != napi_ok) {
116 delete jsPen;
117 ROSEN_LOGE("JsPen::Constructor Failed to wrap native instance");
118 return nullptr;
119 }
120
121 return jsThis;
122 }
123
Destructor(napi_env env,void * nativeObject,void * finalize)124 void JsPen::Destructor(napi_env env, void* nativeObject, void* finalize)
125 {
126 (void)finalize;
127 if (nativeObject != nullptr) {
128 JsPen* napi = reinterpret_cast<JsPen*>(nativeObject);
129 delete napi;
130 }
131 }
132
JsPen()133 JsPen::JsPen()
134 {
135 pen_ = new Pen();
136 }
137
JsPen(const Pen & pen)138 JsPen::JsPen(const Pen& pen)
139 {
140 pen_ = new Pen(pen);
141 }
142
~JsPen()143 JsPen::~JsPen()
144 {
145 delete pen_;
146 pen_ = nullptr;
147 }
148
SetColor(napi_env env,napi_callback_info info)149 napi_value JsPen::SetColor(napi_env env, napi_callback_info info)
150 {
151 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
152 if (!jsPen) {
153 return nullptr;
154 }
155 Pen* pen = jsPen->GetPen();
156 if (pen == nullptr) {
157 ROSEN_LOGE("JsPen::SetColor pen is nullptr");
158 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
159 }
160
161 size_t argc = ARGC_FOUR;
162 napi_value argv[ARGC_FOUR] = {nullptr};
163 CHECK_PARAM_NUMBER_WITH_OPTIONAL_PARAMS(argv, argc, ARGC_ONE, ARGC_FOUR);
164
165 Drawing::Color drawingColor;
166 if (argc == ARGC_ONE) {
167 int32_t argb[ARGC_FOUR] = {0};
168 if (!ConvertFromJsColor(env, argv[ARGC_ZERO], argb, ARGC_FOUR)) {
169 ROSEN_LOGE("JsPen::SetColor Argv[0] is invalid");
170 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
171 "Parameter verification failed. The range of color channels must be [0, 255].");
172 }
173 drawingColor = Color::ColorQuadSetARGB(argb[ARGC_ZERO], argb[ARGC_ONE], argb[ARGC_TWO], argb[ARGC_THREE]);
174 } else if (argc == ARGC_FOUR) {
175 int32_t alpha = 0;
176 GET_COLOR_PARAM(ARGC_ZERO, alpha);
177 int32_t red = 0;
178 GET_COLOR_PARAM(ARGC_ONE, red);
179 int32_t green = 0;
180 GET_COLOR_PARAM(ARGC_TWO, green);
181 int32_t blue = 0;
182 GET_COLOR_PARAM(ARGC_THREE, blue);
183 drawingColor = Color::ColorQuadSetARGB(alpha, red, green, blue);
184 } else {
185 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Incorrect number of parameters.");
186 }
187 pen->SetColor(drawingColor);
188 return nullptr;
189 }
190
SetStrokeWidth(napi_env env,napi_callback_info info)191 napi_value JsPen::SetStrokeWidth(napi_env env, napi_callback_info info)
192 {
193 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
194 if (!jsPen) {
195 return nullptr;
196 }
197 Pen* pen = jsPen->GetPen();
198 if (pen == nullptr) {
199 ROSEN_LOGE("JsPen::SetStrokeWidth pen is nullptr");
200 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
201 }
202
203 napi_value argv[ARGC_ONE] = {nullptr};
204 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
205
206 double width = 0.0;
207 GET_DOUBLE_PARAM(ARGC_ZERO, width);
208
209 pen->SetWidth(static_cast<float>(width));
210 return nullptr;
211 }
212
213
SetAntiAlias(napi_env env,napi_callback_info info)214 napi_value JsPen::SetAntiAlias(napi_env env, napi_callback_info info)
215 {
216 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
217 if (!jsPen) {
218 return nullptr;
219 }
220 Pen* pen = jsPen->GetPen();
221 if (pen == nullptr) {
222 ROSEN_LOGE("JsPen::SetAntiAlias pen is nullptr");
223 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
224 }
225
226 napi_value argv[ARGC_ONE] = {nullptr};
227 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
228
229 bool aa = false;
230 GET_BOOLEAN_PARAM(ARGC_ZERO, aa);
231
232 pen->SetAntiAlias(aa);
233 return nullptr;
234 }
235
SetAlpha(napi_env env,napi_callback_info info)236 napi_value JsPen::SetAlpha(napi_env env, napi_callback_info info)
237 {
238 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
239 if (!jsPen) {
240 return nullptr;
241 }
242 Pen* pen = jsPen->GetPen();
243 if (pen == nullptr) {
244 ROSEN_LOGE("JsPen::SetAlpha pen is nullptr");
245 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
246 }
247
248 napi_value argv[ARGC_ONE] = {nullptr};
249 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
250
251 int32_t alpha = 0;
252 if (!ConvertFromJsNumber(env, argv[ARGC_ZERO], alpha, 0, Color::RGB_MAX)) {
253 ROSEN_LOGE("JsPen::SetAlpha Argv[0] is invalid");
254 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
255 "Parameter verification failed. The alpha range must be [0, 255].");
256 }
257
258 pen->SetAlpha(alpha);
259 return nullptr;
260 }
261
SetBlendMode(napi_env env,napi_callback_info info)262 napi_value JsPen::SetBlendMode(napi_env env, napi_callback_info info)
263 {
264 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
265 if (!jsPen) {
266 return nullptr;
267 }
268 Pen* pen = jsPen->GetPen();
269 if (pen == nullptr) {
270 ROSEN_LOGE("JsPen::SetBlendMode pen is nullptr");
271 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
272 }
273
274 napi_value argv[ARGC_ONE] = {nullptr};
275 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
276
277 int32_t mode = 0;
278 GET_ENUM_PARAM(ARGC_ZERO, mode, 0, static_cast<int32_t>(BlendMode::LUMINOSITY));
279
280 pen->SetBlendMode(static_cast<BlendMode>(mode));
281 return nullptr;
282 }
283
SetColorFilter(napi_env env,napi_callback_info info)284 napi_value JsPen::SetColorFilter(napi_env env, napi_callback_info info)
285 {
286 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
287 if (!jsPen) {
288 return nullptr;
289 }
290 Pen* pen = jsPen->GetPen();
291 if (pen == nullptr) {
292 ROSEN_LOGE("JsPen::SetColorFilter pen is nullptr");
293 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
294 }
295
296 napi_value argv[ARGC_ONE] = {nullptr};
297 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
298
299 JsColorFilter* jsColorFilter = nullptr;
300 GET_UNWRAP_PARAM_OR_NULL(ARGC_ZERO, jsColorFilter);
301
302 Filter filter = pen->GetFilter();
303 filter.SetColorFilter(jsColorFilter ? jsColorFilter->GetColorFilter() : nullptr);
304 pen->SetFilter(filter);
305 return nullptr;
306 }
307
GetColorFilter(napi_env env,napi_callback_info info)308 napi_value JsPen::GetColorFilter(napi_env env, napi_callback_info info)
309 {
310 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
311 if (jsPen == nullptr) {
312 ROSEN_LOGE("JsPen::GetColorFilter jsPen is nullptr");
313 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
314 }
315 Pen* pen = jsPen->GetPen();
316 if (pen == nullptr) {
317 ROSEN_LOGE("JsPen::GetColorFilter pen is nullptr");
318 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
319 }
320 if (pen->HasFilter()) {
321 return JsColorFilter::Create(env, pen->GetFilter().GetColorFilter());
322 }
323 return nullptr;
324 }
325
SetImageFilter(napi_env env,napi_callback_info info)326 napi_value JsPen::SetImageFilter(napi_env env, napi_callback_info info)
327 {
328 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
329 if (jsPen == nullptr) {
330 ROSEN_LOGE("JsPen::SetImageFilter jsPen is nullptr");
331 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
332 }
333 Pen* pen = jsPen->GetPen();
334 if (pen == nullptr) {
335 ROSEN_LOGE("JsPen::SetImageFilter pen is nullptr");
336 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
337 }
338
339 napi_value argv[ARGC_ONE] = {nullptr};
340 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
341
342 JsImageFilter* jsImageFilter = nullptr;
343 GET_UNWRAP_PARAM_OR_NULL(ARGC_ZERO, jsImageFilter);
344
345 Filter filter = pen->GetFilter();
346 filter.SetImageFilter(jsImageFilter != nullptr ? jsImageFilter->GetImageFilter() : nullptr);
347 pen->SetFilter(filter);
348 return nullptr;
349 }
350
SetMaskFilter(napi_env env,napi_callback_info info)351 napi_value JsPen::SetMaskFilter(napi_env env, napi_callback_info info)
352 {
353 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
354 if (jsPen == nullptr) {
355 ROSEN_LOGE("JsPen::SetMaskFilter jsPen is nullptr");
356 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
357 }
358 Pen* pen = jsPen->GetPen();
359 if (pen == nullptr) {
360 ROSEN_LOGE("JsPen::SetMaskFilter pen is nullptr");
361 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
362 }
363
364 napi_value argv[ARGC_ONE] = {nullptr};
365 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
366
367 JsMaskFilter* jsMaskFilter = nullptr;
368 GET_UNWRAP_PARAM_OR_NULL(ARGC_ZERO, jsMaskFilter);
369
370 Filter filter = pen->GetFilter();
371 filter.SetMaskFilter(jsMaskFilter ? jsMaskFilter->GetMaskFilter() : nullptr);
372 pen->SetFilter(filter);
373 return nullptr;
374 }
375
SetDither(napi_env env,napi_callback_info info)376 napi_value JsPen::SetDither(napi_env env, napi_callback_info info)
377 {
378 napi_value argv[ARGC_ONE] = {nullptr};
379 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
380
381 bool dither = false;
382 GET_BOOLEAN_PARAM(ARGC_ZERO, dither);
383 return nullptr;
384 }
385
SetJoinStyle(napi_env env,napi_callback_info info)386 napi_value JsPen::SetJoinStyle(napi_env env, napi_callback_info info)
387 {
388 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
389 if (jsPen == nullptr) {
390 ROSEN_LOGE("JsPen::SetJoinStyle jsPen is nullptr");
391 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
392 }
393 Pen* pen = jsPen->GetPen();
394 if (pen == nullptr) {
395 ROSEN_LOGE("JsPen::SetJoinStyle pen is nullptr");
396 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
397 }
398
399 napi_value argv[ARGC_ONE] = {nullptr};
400 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
401
402 int32_t joinStyle = 0;
403 GET_ENUM_PARAM(ARGC_ZERO, joinStyle, 0, static_cast<int32_t>(Pen::JoinStyle::BEVEL_JOIN));
404
405 pen->SetJoinStyle(static_cast<Pen::JoinStyle>(joinStyle));
406 return nullptr;
407 }
408
GetJoinStyle(napi_env env,napi_callback_info info)409 napi_value JsPen::GetJoinStyle(napi_env env, napi_callback_info info)
410 {
411 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
412 if (jsPen == nullptr) {
413 ROSEN_LOGE("JsPen::GetJoinStyle jsPen is nullptr");
414 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
415 }
416 Pen* pen = jsPen->GetPen();
417 if (pen == nullptr) {
418 ROSEN_LOGE("JsPen::GetJoinStyle pen is nullptr");
419 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
420 }
421 return CreateJsNumber(env, static_cast<int32_t>(pen->GetJoinStyle()));
422 }
423
CapCastToTsCap(Pen::CapStyle cap)424 static int32_t CapCastToTsCap(Pen::CapStyle cap)
425 {
426 int32_t tsCap = 0; // 0: CapStyle::FLAT_CAP
427 switch (cap) {
428 case Pen::CapStyle::FLAT_CAP:
429 tsCap = 0; // 0: CapStyle::FLAT_CAP
430 break;
431 case Pen::CapStyle::SQUARE_CAP:
432 tsCap = 1; // 1: CapStyle::SQUARE_CAP
433 break;
434 case Pen::CapStyle::ROUND_CAP:
435 tsCap = 2; // 2: CapStyle::ROUND_CAP
436 break;
437 default:
438 break;
439 }
440 return tsCap;
441 }
442
TsCapCastToCap(int32_t tsCap)443 static Pen::CapStyle TsCapCastToCap(int32_t tsCap)
444 {
445 Pen::CapStyle cap = Pen::CapStyle::FLAT_CAP;
446 switch (tsCap) {
447 case 0: // 0: CapStyle::FLAT_CAP
448 cap = Pen::CapStyle::FLAT_CAP;
449 break;
450 case 1: // 1: CapStyle::SQUARE_CAP
451 cap = Pen::CapStyle::SQUARE_CAP;
452 break;
453 case 2: // 2: CapStyle::ROUND_CAP
454 cap = Pen::CapStyle::ROUND_CAP;
455 break;
456 default:
457 break;
458 }
459 return cap;
460 }
461
SetCapStyle(napi_env env,napi_callback_info info)462 napi_value JsPen::SetCapStyle(napi_env env, napi_callback_info info)
463 {
464 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
465 if (jsPen == nullptr) {
466 ROSEN_LOGE("JsPen::SetCapStyle jsPen is nullptr");
467 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
468 }
469 Pen* pen = jsPen->GetPen();
470 if (pen == nullptr) {
471 ROSEN_LOGE("JsPen::SetCapStyle pen is nullptr");
472 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
473 }
474
475 napi_value argv[ARGC_ONE] = {nullptr};
476 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
477
478 int32_t capStyle = 0;
479 GET_ENUM_PARAM(ARGC_ZERO, capStyle, 0, static_cast<int32_t>(Pen::CapStyle::SQUARE_CAP));
480
481 pen->SetCapStyle(TsCapCastToCap(capStyle));
482 return nullptr;
483 }
484
GetCapStyle(napi_env env,napi_callback_info info)485 napi_value JsPen::GetCapStyle(napi_env env, napi_callback_info info)
486 {
487 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
488 if (jsPen == nullptr) {
489 ROSEN_LOGE("JsPen::GetCapStyle jsPen is nullptr");
490 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
491 }
492 Pen* pen = jsPen->GetPen();
493 if (pen == nullptr) {
494 ROSEN_LOGE("JsPen::GetCapStyle pen is nullptr");
495 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
496 }
497
498 Pen::CapStyle capStyle = pen->GetCapStyle();
499 return CreateJsNumber(env, CapCastToTsCap(capStyle));
500 }
501
SetPathEffect(napi_env env,napi_callback_info info)502 napi_value JsPen::SetPathEffect(napi_env env, napi_callback_info info)
503 {
504 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
505 if (jsPen == nullptr) {
506 ROSEN_LOGE("JsPen::SetPathEffect jsPen is nullptr");
507 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
508 }
509 Pen* pen = jsPen->GetPen();
510 if (pen == nullptr) {
511 ROSEN_LOGE("JsPen::SetPathEffect pen is nullptr");
512 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
513 }
514
515 napi_value argv[ARGC_ONE] = {nullptr};
516 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
517
518 JsPathEffect* jsPathEffect = nullptr;
519 GET_UNWRAP_PARAM_OR_NULL(ARGC_ZERO, jsPathEffect);
520
521 pen->SetPathEffect(jsPathEffect ? jsPathEffect->GetPathEffect() : nullptr);
522 return nullptr;
523 }
524
SetShadowLayer(napi_env env,napi_callback_info info)525 napi_value JsPen::SetShadowLayer(napi_env env, napi_callback_info info)
526 {
527 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
528 if (jsPen == nullptr) {
529 ROSEN_LOGE("JsPen::SetShadowLayer jsPen is nullptr");
530 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
531 }
532 Pen* pen = jsPen->GetPen();
533 if (pen == nullptr) {
534 ROSEN_LOGE("JsPen::SetShadowLayer pen is nullptr");
535 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
536 }
537
538 napi_value argv[ARGC_ONE] = {nullptr};
539 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
540
541 JsShadowLayer* jsShadowLayer = nullptr;
542 GET_UNWRAP_PARAM_OR_NULL(ARGC_ZERO, jsShadowLayer);
543
544 pen->SetLooper(jsShadowLayer ? jsShadowLayer->GetBlurDrawLooper() : nullptr);
545 return nullptr;
546 }
547
SetShaderEffect(napi_env env,napi_callback_info info)548 napi_value JsPen::SetShaderEffect(napi_env env, napi_callback_info info)
549 {
550 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
551 if (jsPen == nullptr) {
552 ROSEN_LOGE("JsPen::SetShaderEffect jsPen is nullptr");
553 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
554 }
555 Pen* pen = jsPen->GetPen();
556 if (pen == nullptr) {
557 ROSEN_LOGE("JsPen::SetShaderEffect pen is nullptr");
558 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
559 }
560
561 napi_value argv[ARGC_ONE] = { nullptr };
562 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
563
564 JsShaderEffect* jsShaderEffect = nullptr;
565 GET_UNWRAP_PARAM_OR_NULL(ARGC_ZERO, jsShaderEffect);
566
567 pen->SetShaderEffect(jsShaderEffect ? jsShaderEffect->GetShaderEffect() : nullptr);
568 return nullptr;
569 }
570
GetFillPath(napi_env env,napi_callback_info info)571 napi_value JsPen::GetFillPath(napi_env env, napi_callback_info info)
572 {
573 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
574 if (jsPen == nullptr) {
575 ROSEN_LOGE("JsPen::GetFillPath jsPen is nullptr");
576 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
577 }
578 Pen* pen = jsPen->GetPen();
579 if (pen == nullptr) {
580 ROSEN_LOGE("JsPen::GetFillPath pen is nullptr");
581 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
582 }
583 napi_value argv[ARGC_TWO] = {nullptr};
584 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_TWO);
585
586 JsPath* src = nullptr;
587 GET_UNWRAP_PARAM(ARGC_ZERO, src);
588 if (src->GetPath() == nullptr) {
589 ROSEN_LOGE("JsPen::GetFillPath src jsPath is nullptr");
590 return nullptr;
591 }
592
593 JsPath* dst = nullptr;
594 GET_UNWRAP_PARAM(ARGC_ONE, dst);
595 if (dst->GetPath() == nullptr) {
596 ROSEN_LOGE("JsPen::GetFillPath dst jsPath is nullptr");
597 return nullptr;
598 }
599
600 return CreateJsValue(env, pen->GetFillPath(*src->GetPath(), *dst->GetPath(), nullptr, Matrix()));
601 }
602
IsAntiAlias(napi_env env,napi_callback_info info)603 napi_value JsPen::IsAntiAlias(napi_env env, napi_callback_info info)
604 {
605 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
606 if (jsPen == nullptr) {
607 ROSEN_LOGE("JsPen::IsAntiAlias jsPen is nullptr");
608 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
609 }
610 Pen* pen = jsPen->GetPen();
611 if (pen == nullptr) {
612 ROSEN_LOGE("JsPen::IsAntiAlias pen is nullptr");
613 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
614 }
615
616 return CreateJsValue(env, pen->IsAntiAlias());
617 }
618
GetAlpha(napi_env env,napi_callback_info info)619 napi_value JsPen::GetAlpha(napi_env env, napi_callback_info info)
620 {
621 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
622 if (jsPen == nullptr) {
623 ROSEN_LOGE("JsPen::GetAlpha jsPen is nullptr");
624 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
625 }
626 Pen* pen = jsPen->GetPen();
627 if (pen == nullptr) {
628 ROSEN_LOGE("JsPen::GetAlpha pen is nullptr");
629 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
630 }
631
632 uint32_t alpha = pen->GetAlpha();
633 return CreateJsNumber(env, alpha);
634 }
635
GetWidth(napi_env env,napi_callback_info info)636 napi_value JsPen::GetWidth(napi_env env, napi_callback_info info)
637 {
638 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
639 if (jsPen == nullptr) {
640 ROSEN_LOGE("JsPen::GetWidth jsPen is nullptr");
641 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
642 }
643 Pen* pen = jsPen->GetPen();
644 if (pen == nullptr) {
645 ROSEN_LOGE("JsPen::GetWidth pen is nullptr");
646 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
647 }
648
649 scalar width = pen->GetWidth();
650 return CreateJsNumber(env, width);
651 }
652
SetMiterLimit(napi_env env,napi_callback_info info)653 napi_value JsPen::SetMiterLimit(napi_env env, napi_callback_info info)
654 {
655 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
656 if (jsPen == nullptr) {
657 ROSEN_LOGE("JsPen::SetMiterLimit jsPen is nullptr");
658 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
659 }
660 Pen* pen = jsPen->GetPen();
661 if (pen == nullptr) {
662 ROSEN_LOGE("JsPen::SetMiterLimit pen is nullptr");
663 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
664 }
665
666 napi_value argv[ARGC_ONE] = {nullptr};
667 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
668
669 double miterLimit = 0;
670 GET_DOUBLE_PARAM(ARGC_ZERO, miterLimit);
671
672 pen->SetMiterLimit(miterLimit);
673 return nullptr;
674 }
675
GetMiterLimit(napi_env env,napi_callback_info info)676 napi_value JsPen::GetMiterLimit(napi_env env, napi_callback_info info)
677 {
678 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
679 if (jsPen == nullptr) {
680 ROSEN_LOGE("JsPen::GetMiterLimit jsPen is nullptr");
681 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
682 }
683 Pen* pen = jsPen->GetPen();
684 if (pen == nullptr) {
685 ROSEN_LOGE("JsPen::GetMiterLimit pen is nullptr");
686 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
687 }
688
689 scalar miterLimit = pen->GetMiterLimit();
690 return CreateJsNumber(env, miterLimit);
691 }
692
Reset(napi_env env,napi_callback_info info)693 napi_value JsPen::Reset(napi_env env, napi_callback_info info)
694 {
695 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
696 if (jsPen == nullptr) {
697 ROSEN_LOGE("JsPen::Reset jsPen is nullptr");
698 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
699 }
700 Pen* pen = jsPen->GetPen();
701 if (pen == nullptr) {
702 ROSEN_LOGE("JsPen::Reset pen is nullptr");
703 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
704 }
705
706 pen->Reset();
707 return nullptr;
708 }
709
GetColor(napi_env env,napi_callback_info info)710 napi_value JsPen::GetColor(napi_env env, napi_callback_info info)
711 {
712 JsPen* jsPen = CheckParamsAndGetThis<JsPen>(env, info);
713 if (jsPen == nullptr) {
714 ROSEN_LOGE("JsPen::GetColor jsPen is nullptr");
715 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
716 }
717 Pen* pen = jsPen->GetPen();
718 if (pen == nullptr) {
719 ROSEN_LOGE("JsPen::GetColor pen is nullptr");
720 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
721 }
722
723 Color color = pen->GetColor();
724 return GetColorAndConvertToJsValue(env, color);
725 }
726
GetPen()727 Pen* JsPen::GetPen()
728 {
729 return pen_;
730 }
731 } // namespace Drawing
732 } // namespace OHOS::Rosen
733