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_matrix.h"
17 #include "js_drawing_utils.h"
18 #include "native_value.h"
19
20 static constexpr uint32_t POLY_POINT_COUNT_MAX = 4;
21
22 namespace OHOS::Rosen {
23 namespace Drawing {
24 thread_local napi_ref JsMatrix::constructor_ = nullptr;
25 const std::string CLASS_NAME = "Matrix";
26
27 static const napi_property_descriptor g_properties[] = {
28 DECLARE_NAPI_FUNCTION("getValue", JsMatrix::GetValue),
29 DECLARE_NAPI_FUNCTION("postConcat", JsMatrix::PostConcat),
30 DECLARE_NAPI_FUNCTION("postRotate", JsMatrix::PostRotate),
31 DECLARE_NAPI_FUNCTION("postSkew", JsMatrix::PostSkew),
32 DECLARE_NAPI_FUNCTION("postTranslate", JsMatrix::PostTranslate),
33 DECLARE_NAPI_FUNCTION("preRotate", JsMatrix::PreRotate),
34 DECLARE_NAPI_FUNCTION("preScale", JsMatrix::PreScale),
35 DECLARE_NAPI_FUNCTION("preSkew", JsMatrix::PreSkew),
36 DECLARE_NAPI_FUNCTION("preTranslate", JsMatrix::PreTranslate),
37 DECLARE_NAPI_FUNCTION("setConcat", JsMatrix::SetConcat),
38 DECLARE_NAPI_FUNCTION("setRotation", JsMatrix::SetRotation),
39 DECLARE_NAPI_FUNCTION("setScale", JsMatrix::SetScale),
40 DECLARE_NAPI_FUNCTION("setSinCos", JsMatrix::SetSinCos),
41 DECLARE_NAPI_FUNCTION("setSkew", JsMatrix::SetSkew),
42 DECLARE_NAPI_FUNCTION("setTranslation", JsMatrix::SetTranslation),
43 DECLARE_NAPI_FUNCTION("setMatrix", JsMatrix::SetMatrix),
44 DECLARE_NAPI_FUNCTION("preConcat", JsMatrix::PreConcat),
45 DECLARE_NAPI_FUNCTION("isAffine", JsMatrix::IsAffine),
46 DECLARE_NAPI_FUNCTION("isEqual", JsMatrix::IsEqual),
47 DECLARE_NAPI_FUNCTION("invert", JsMatrix::Invert),
48 DECLARE_NAPI_FUNCTION("isIdentity", JsMatrix::IsIdentity),
49 DECLARE_NAPI_FUNCTION("mapPoints", JsMatrix::MapPoints),
50 DECLARE_NAPI_FUNCTION("mapRadius", JsMatrix::MapRadius),
51 DECLARE_NAPI_FUNCTION("postScale", JsMatrix::PostScale),
52 DECLARE_NAPI_FUNCTION("rectStaysRect", JsMatrix::RectStaysRect),
53 DECLARE_NAPI_FUNCTION("reset", JsMatrix::Reset),
54 DECLARE_NAPI_FUNCTION("getAll", JsMatrix::GetAll),
55 DECLARE_NAPI_FUNCTION("setPolyToPoly", JsMatrix::SetPolyToPoly),
56 DECLARE_NAPI_FUNCTION("setRectToRect", JsMatrix::SetRectToRect),
57 DECLARE_NAPI_FUNCTION("mapRect", JsMatrix::MapRect),
58 };
59
Init(napi_env env,napi_value exportObj)60 napi_value JsMatrix::Init(napi_env env, napi_value exportObj)
61 {
62 napi_value constructor = nullptr;
63 napi_status status = napi_define_class(env, CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Constructor, nullptr,
64 sizeof(g_properties) / sizeof(g_properties[0]), g_properties, &constructor);
65 if (status != napi_ok) {
66 ROSEN_LOGE("JsMatrix::Init Failed to define Matrix class");
67 return nullptr;
68 }
69
70 status = napi_create_reference(env, constructor, 1, &constructor_);
71 if (status != napi_ok) {
72 ROSEN_LOGE("JsMatrix::Init Failed to create reference of constructor");
73 return nullptr;
74 }
75
76 status = napi_set_named_property(env, exportObj, CLASS_NAME.c_str(), constructor);
77 if (status != napi_ok) {
78 ROSEN_LOGE("JsMatrix::Init Failed to set constructor");
79 return nullptr;
80 }
81
82 return exportObj;
83 }
84
Constructor(napi_env env,napi_callback_info info)85 napi_value JsMatrix::Constructor(napi_env env, napi_callback_info info)
86 {
87 size_t argCount = ARGC_ONE;
88 napi_value argv[ARGC_ONE] = {nullptr};
89 napi_value jsThis = nullptr;
90 napi_status status = napi_get_cb_info(env, info, &argCount, argv, &jsThis, nullptr);
91 if (status != napi_ok) {
92 ROSEN_LOGE("JsMatrix::Constructor failed to napi_get_cb_info");
93 return nullptr;
94 }
95
96 std::shared_ptr<Matrix> matrix = nullptr;
97 if (argCount == ARGC_ONE) {
98 JsMatrix* jsOther = nullptr;
99 GET_UNWRAP_PARAM(ARGC_ZERO, jsOther);
100 std::shared_ptr<Matrix> other = jsOther->GetMatrix();
101 matrix = other == nullptr ? std::make_shared<Matrix>() : std::make_shared<Matrix>(*other);
102 } else {
103 matrix = std::make_shared<Matrix>();
104 }
105 JsMatrix* jsMatrix = new JsMatrix(matrix);
106 status = napi_wrap(env, jsThis, jsMatrix, JsMatrix::Destructor, nullptr, nullptr);
107 if (status != napi_ok) {
108 delete jsMatrix;
109 ROSEN_LOGE("JsMatrix::Constructor Failed to wrap native instance");
110 return nullptr;
111 }
112 return jsThis;
113 }
114
Destructor(napi_env env,void * nativeObject,void * finalize)115 void JsMatrix::Destructor(napi_env env, void* nativeObject, void* finalize)
116 {
117 (void)finalize;
118 if (nativeObject != nullptr) {
119 JsMatrix* napi = reinterpret_cast<JsMatrix*>(nativeObject);
120 delete napi;
121 }
122 }
123
CreateJsMatrix(napi_env env,const std::shared_ptr<Matrix> matrix)124 napi_value JsMatrix::CreateJsMatrix(napi_env env, const std::shared_ptr<Matrix> matrix)
125 {
126 napi_value constructor = nullptr;
127 napi_value result = nullptr;
128 napi_status status = napi_get_reference_value(env, constructor_, &constructor);
129 if (status == napi_ok) {
130 auto jsMatrix = new JsMatrix(matrix);
131 napi_create_object(env, &result);
132 if (result == nullptr) {
133 delete jsMatrix;
134 ROSEN_LOGE("JsMatrix::CreateJsMatrix Create matrix object failed!");
135 return nullptr;
136 }
137 status = napi_wrap(env, result, jsMatrix, JsMatrix::Destructor, nullptr, nullptr);
138 if (status != napi_ok) {
139 delete jsMatrix;
140 ROSEN_LOGE("JsMatrix::CreateJsMatrix failed to wrap native instance");
141 return nullptr;
142 }
143 napi_define_properties(env, result, sizeof(g_properties) / sizeof(g_properties[0]), g_properties);
144 return result;
145 }
146 return result;
147 }
148
GetValue(napi_env env,napi_callback_info info)149 napi_value JsMatrix::GetValue(napi_env env, napi_callback_info info)
150 {
151 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
152 return (me != nullptr) ? me->OnGetValue(env, info) : nullptr;
153 }
154
OnGetValue(napi_env env,napi_callback_info info)155 napi_value JsMatrix::OnGetValue(napi_env env, napi_callback_info info)
156 {
157 if (m_matrix == nullptr) {
158 ROSEN_LOGE("JsMatrix::OnGetValue matrix is nullptr");
159 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
160 }
161
162 napi_value argv[ARGC_ONE] = {nullptr};
163 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
164
165 int32_t index = -1;
166 GET_INT32_PARAM(ARGC_ZERO, index);
167
168 if (index < 0 || index >= Matrix::MATRIX_SIZE) {
169 ROSEN_LOGE("JsMatrix::OnGetValue index is out of range");
170 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
171 }
172
173 double value = m_matrix->Get(index);
174 return GetDoubleAndConvertToJsValue(env, value);
175 }
176
PostConcat(napi_env env,napi_callback_info info)177 napi_value JsMatrix::PostConcat(napi_env env, napi_callback_info info)
178 {
179 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
180 return (me != nullptr) ? me->OnPostConcat(env, info) : nullptr;
181 }
182
OnPostConcat(napi_env env,napi_callback_info info)183 napi_value JsMatrix::OnPostConcat(napi_env env, napi_callback_info info)
184 {
185 if (m_matrix == nullptr) {
186 ROSEN_LOGE("JsMatrix::OnPostConcat matrix is nullptr");
187 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
188 }
189
190 napi_value argv[ARGC_ONE] = {nullptr};
191 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
192
193 JsMatrix* jsMatrix = nullptr;
194 GET_UNWRAP_PARAM(ARGC_ZERO, jsMatrix);
195
196 std::shared_ptr<Matrix> matrix = jsMatrix->GetMatrix();
197 if (matrix == nullptr) {
198 ROSEN_LOGE("JsMatrix::OnPostConcat matrix is nullptr");
199 return nullptr;
200 }
201 m_matrix->PostConcat(*matrix);
202 return nullptr;
203 }
204
PostRotate(napi_env env,napi_callback_info info)205 napi_value JsMatrix::PostRotate(napi_env env, napi_callback_info info)
206 {
207 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
208 return (me != nullptr) ? me->OnPostRotate(env, info) : nullptr;
209 }
210
OnPostRotate(napi_env env,napi_callback_info info)211 napi_value JsMatrix::OnPostRotate(napi_env env, napi_callback_info info)
212 {
213 if (m_matrix == nullptr) {
214 ROSEN_LOGE("JsMatrix::OnPostRotate matrix is nullptr");
215 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
216 }
217
218 napi_value argv[ARGC_THREE] = {nullptr};
219 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_THREE);
220
221 double degree = 0.0;
222 GET_DOUBLE_PARAM(ARGC_ZERO, degree);
223 double px = 0.0;
224 GET_DOUBLE_PARAM(ARGC_ONE, px);
225 double py = 0.0;
226 GET_DOUBLE_PARAM(ARGC_TWO, py);
227
228 JS_CALL_DRAWING_FUNC(m_matrix->PostRotate(degree, px, py));
229
230 return nullptr;
231 }
232
PostSkew(napi_env env,napi_callback_info info)233 napi_value JsMatrix::PostSkew(napi_env env, napi_callback_info info)
234 {
235 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
236 return (me != nullptr) ? me->OnPostSkew(env, info) : nullptr;
237 }
238
OnPostSkew(napi_env env,napi_callback_info info)239 napi_value JsMatrix::OnPostSkew(napi_env env, napi_callback_info info)
240 {
241 if (m_matrix == nullptr) {
242 ROSEN_LOGE("JsMatrix::OnPostSkew matrix is nullptr");
243 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
244 }
245
246 napi_value argv[ARGC_FOUR] = {nullptr};
247 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_FOUR);
248
249 double kx = 0.0;
250 GET_DOUBLE_PARAM(ARGC_ZERO, kx);
251 double ky = 0.0;
252 GET_DOUBLE_PARAM(ARGC_ONE, ky);
253 double px = 0.0;
254 GET_DOUBLE_PARAM(ARGC_TWO, px);
255 double py = 0.0;
256 GET_DOUBLE_PARAM(ARGC_THREE, py);
257
258 m_matrix->PostSkew(kx, ky, px, py);
259 return nullptr;
260 }
261
PostTranslate(napi_env env,napi_callback_info info)262 napi_value JsMatrix::PostTranslate(napi_env env, napi_callback_info info)
263 {
264 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
265 return (me != nullptr) ? me->OnPostTranslate(env, info) : nullptr;
266 }
267
OnPostTranslate(napi_env env,napi_callback_info info)268 napi_value JsMatrix::OnPostTranslate(napi_env env, napi_callback_info info)
269 {
270 if (m_matrix == nullptr) {
271 ROSEN_LOGE("JsMatrix::OnPostTranslate matrix is nullptr");
272 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
273 }
274
275 napi_value argv[ARGC_TWO] = {nullptr};
276 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_TWO);
277
278 double dx = 0.0;
279 GET_DOUBLE_PARAM(ARGC_ZERO, dx);
280 double dy = 0.0;
281 GET_DOUBLE_PARAM(ARGC_ONE, dy);
282
283 JS_CALL_DRAWING_FUNC(m_matrix->PostTranslate(dx, dy));
284 return nullptr;
285 }
286
PreRotate(napi_env env,napi_callback_info info)287 napi_value JsMatrix::PreRotate(napi_env env, napi_callback_info info)
288 {
289 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
290 return (me != nullptr) ? me->OnPreRotate(env, info) : nullptr;
291 }
292
OnPreRotate(napi_env env,napi_callback_info info)293 napi_value JsMatrix::OnPreRotate(napi_env env, napi_callback_info info)
294 {
295 if (m_matrix == nullptr) {
296 ROSEN_LOGE("JsMatrix::OnPreRotate matrix is nullptr");
297 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
298 }
299
300 napi_value argv[ARGC_THREE] = {nullptr};
301 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_THREE);
302
303 double degree = 0.0;
304 GET_DOUBLE_PARAM(ARGC_ZERO, degree);
305 double px = 0.0;
306 GET_DOUBLE_PARAM(ARGC_ONE, px);
307 double py = 0.0;
308 GET_DOUBLE_PARAM(ARGC_TWO, py);
309
310 JS_CALL_DRAWING_FUNC(m_matrix->PreRotate(degree, px, py));
311
312 return nullptr;
313 }
314
PreScale(napi_env env,napi_callback_info info)315 napi_value JsMatrix::PreScale(napi_env env, napi_callback_info info)
316 {
317 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
318 return (me != nullptr) ? me->OnPreScale(env, info) : nullptr;
319 }
320
OnPreScale(napi_env env,napi_callback_info info)321 napi_value JsMatrix::OnPreScale(napi_env env, napi_callback_info info)
322 {
323 if (m_matrix == nullptr) {
324 ROSEN_LOGE("JsMatrix::OnPreScale matrix is nullptr");
325 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
326 }
327
328 napi_value argv[ARGC_FOUR] = {nullptr};
329 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_FOUR);
330
331 double sx = 0.0;
332 GET_DOUBLE_PARAM(ARGC_ZERO, sx);
333 double sy = 0.0;
334 GET_DOUBLE_PARAM(ARGC_ONE, sy);
335 double px = 0.0;
336 GET_DOUBLE_PARAM(ARGC_TWO, px);
337 double py = 0.0;
338 GET_DOUBLE_PARAM(ARGC_THREE, py);
339
340 JS_CALL_DRAWING_FUNC(m_matrix->PreScale(sx, sy, px, py));
341
342 return nullptr;
343 }
344
PreSkew(napi_env env,napi_callback_info info)345 napi_value JsMatrix::PreSkew(napi_env env, napi_callback_info info)
346 {
347 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
348 return (me != nullptr) ? me->OnPreSkew(env, info) : nullptr;
349 }
350
OnPreSkew(napi_env env,napi_callback_info info)351 napi_value JsMatrix::OnPreSkew(napi_env env, napi_callback_info info)
352 {
353 if (m_matrix == nullptr) {
354 ROSEN_LOGE("JsMatrix::OnPreSkew matrix is nullptr");
355 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
356 }
357
358 napi_value argv[ARGC_FOUR] = {nullptr};
359 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_FOUR);
360
361 double kx = 0.0;
362 GET_DOUBLE_PARAM(ARGC_ZERO, kx);
363 double ky = 0.0;
364 GET_DOUBLE_PARAM(ARGC_ONE, ky);
365 double px = 0.0;
366 GET_DOUBLE_PARAM(ARGC_TWO, px);
367 double py = 0.0;
368 GET_DOUBLE_PARAM(ARGC_THREE, py);
369
370 m_matrix->PreSkew(kx, ky, px, py);
371 return nullptr;
372 }
373
PreTranslate(napi_env env,napi_callback_info info)374 napi_value JsMatrix::PreTranslate(napi_env env, napi_callback_info info)
375 {
376 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
377 return (me != nullptr) ? me->OnPreTranslate(env, info) : nullptr;
378 }
379
OnPreTranslate(napi_env env,napi_callback_info info)380 napi_value JsMatrix::OnPreTranslate(napi_env env, napi_callback_info info)
381 {
382 if (m_matrix == nullptr) {
383 ROSEN_LOGE("JsMatrix::OnPreTranslate matrix is nullptr");
384 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
385 }
386
387 napi_value argv[ARGC_TWO] = {nullptr};
388 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_TWO);
389
390 double dx = 0.0;
391 GET_DOUBLE_PARAM(ARGC_ZERO, dx);
392 double dy = 0.0;
393 GET_DOUBLE_PARAM(ARGC_ONE, dy);
394
395 JS_CALL_DRAWING_FUNC(m_matrix->PreTranslate(dx, dy));
396
397 return nullptr;
398 }
399
SetConcat(napi_env env,napi_callback_info info)400 napi_value JsMatrix::SetConcat(napi_env env, napi_callback_info info)
401 {
402 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
403 return (me != nullptr) ? me->OnSetConcat(env, info) : nullptr;
404 }
405
OnSetConcat(napi_env env,napi_callback_info info)406 napi_value JsMatrix::OnSetConcat(napi_env env, napi_callback_info info)
407 {
408 if (m_matrix == nullptr) {
409 ROSEN_LOGE("JsMatrix::OnSetConcat matrix is nullptr");
410 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
411 }
412
413 napi_value argv[ARGC_TWO] = {nullptr};
414 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_TWO);
415
416 JsMatrix* jsMatrix1 = nullptr;
417 GET_UNWRAP_PARAM(ARGC_ZERO, jsMatrix1);
418 JsMatrix* jsMatrix2 = nullptr;
419 GET_UNWRAP_PARAM(ARGC_ONE, jsMatrix2);
420
421 std::shared_ptr<Matrix> matrix1 = jsMatrix1->GetMatrix();
422 std::shared_ptr<Matrix> matrix2 = jsMatrix2->GetMatrix();
423 if (matrix1 == nullptr || matrix2 == nullptr) {
424 ROSEN_LOGE("JsMatrix::OnSetConcat matrix is nullptr");
425 return nullptr;
426 }
427
428 m_matrix->SetConcat(*matrix1, *matrix2);
429 return nullptr;
430 }
431
SetRotation(napi_env env,napi_callback_info info)432 napi_value JsMatrix::SetRotation(napi_env env, napi_callback_info info)
433 {
434 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
435 return (me != nullptr) ? me->OnSetRotation(env, info) : nullptr;
436 }
437
OnSetRotation(napi_env env,napi_callback_info info)438 napi_value JsMatrix::OnSetRotation(napi_env env, napi_callback_info info)
439 {
440 if (m_matrix == nullptr) {
441 ROSEN_LOGE("JsMatrix::OnSetRotation matrix is nullptr");
442 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
443 }
444
445 napi_value argv[ARGC_THREE] = {nullptr};
446 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_THREE);
447
448 double degree = 0.0;
449 GET_DOUBLE_PARAM(ARGC_ZERO, degree);
450 double px = 0.0;
451 GET_DOUBLE_PARAM(ARGC_ONE, px);
452 double py = 0.0;
453 GET_DOUBLE_PARAM(ARGC_TWO, py);
454
455 JS_CALL_DRAWING_FUNC(m_matrix->Rotate(degree, px, py));
456 return nullptr;
457 }
458
SetScale(napi_env env,napi_callback_info info)459 napi_value JsMatrix::SetScale(napi_env env, napi_callback_info info)
460 {
461 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
462 return (me != nullptr) ? me->OnSetScale(env, info) : nullptr;
463 }
464
OnSetScale(napi_env env,napi_callback_info info)465 napi_value JsMatrix::OnSetScale(napi_env env, napi_callback_info info)
466 {
467 if (m_matrix == nullptr) {
468 ROSEN_LOGE("JsMatrix::OnSetScale matrix is nullptr");
469 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
470 }
471
472 napi_value argv[ARGC_FOUR] = {nullptr};
473 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_FOUR);
474
475 double sx = 0.0;
476 GET_DOUBLE_PARAM(ARGC_ZERO, sx);
477 double sy = 0.0;
478 GET_DOUBLE_PARAM(ARGC_ONE, sy);
479 double px = 0.0;
480 GET_DOUBLE_PARAM(ARGC_TWO, px);
481 double py = 0.0;
482 GET_DOUBLE_PARAM(ARGC_THREE, py);
483
484 JS_CALL_DRAWING_FUNC(m_matrix->Scale(sx, sy, px, py));
485 return nullptr;
486 }
487
SetSinCos(napi_env env,napi_callback_info info)488 napi_value JsMatrix::SetSinCos(napi_env env, napi_callback_info info)
489 {
490 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
491 return (me != nullptr) ? me->OnSetSinCos(env, info) : nullptr;
492 }
493
OnSetSinCos(napi_env env,napi_callback_info info)494 napi_value JsMatrix::OnSetSinCos(napi_env env, napi_callback_info info)
495 {
496 if (m_matrix == nullptr) {
497 ROSEN_LOGE("JsMatrix::OnSetSinCos matrix is nullptr");
498 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
499 }
500
501 napi_value argv[ARGC_FOUR] = {nullptr};
502 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_FOUR);
503
504 double sin = 0.0;
505 GET_DOUBLE_PARAM(ARGC_ZERO, sin);
506 double cos = 0.0;
507 GET_DOUBLE_PARAM(ARGC_ONE, cos);
508 double px = 0.0;
509 GET_DOUBLE_PARAM(ARGC_TWO, px);
510 double py = 0.0;
511 GET_DOUBLE_PARAM(ARGC_THREE, py);
512
513 m_matrix->SetSinCos(sin, cos, px, py);
514 return nullptr;
515 }
516
SetSkew(napi_env env,napi_callback_info info)517 napi_value JsMatrix::SetSkew(napi_env env, napi_callback_info info)
518 {
519 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
520 return (me != nullptr) ? me->OnSetSkew(env, info) : nullptr;
521 }
522
OnSetSkew(napi_env env,napi_callback_info info)523 napi_value JsMatrix::OnSetSkew(napi_env env, napi_callback_info info)
524 {
525 if (m_matrix == nullptr) {
526 ROSEN_LOGE("JsMatrix::OnSetSkew matrix is nullptr");
527 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
528 }
529
530 napi_value argv[ARGC_FOUR] = {nullptr};
531 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_FOUR);
532
533 double kx = 0.0;
534 GET_DOUBLE_PARAM(ARGC_ZERO, kx);
535 double ky = 0.0;
536 GET_DOUBLE_PARAM(ARGC_ONE, ky);
537 double px = 0.0;
538 GET_DOUBLE_PARAM(ARGC_TWO, px);
539 double py = 0.0;
540 GET_DOUBLE_PARAM(ARGC_THREE, py);
541
542 m_matrix->SetSkew(kx, ky, px, py);
543 return nullptr;
544 }
545
SetTranslation(napi_env env,napi_callback_info info)546 napi_value JsMatrix::SetTranslation(napi_env env, napi_callback_info info)
547 {
548 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
549 return (me != nullptr) ? me->OnSetTranslation(env, info) : nullptr;
550 }
551
OnSetTranslation(napi_env env,napi_callback_info info)552 napi_value JsMatrix::OnSetTranslation(napi_env env, napi_callback_info info)
553 {
554 if (m_matrix == nullptr) {
555 ROSEN_LOGE("JsMatrix::OnSetTranslation matrix is nullptr");
556 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
557 }
558
559 napi_value argv[ARGC_TWO] = {nullptr};
560 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_TWO);
561
562 double dx = 0.0;
563 GET_DOUBLE_PARAM(ARGC_ZERO, dx);
564 double dy = 0.0;
565 GET_DOUBLE_PARAM(ARGC_ONE, dy);
566
567 JS_CALL_DRAWING_FUNC(m_matrix->Translate(dx, dy));
568 return nullptr;
569 }
570
SetMatrix(napi_env env,napi_callback_info info)571 napi_value JsMatrix::SetMatrix(napi_env env, napi_callback_info info)
572 {
573 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
574 return (me != nullptr) ? me->OnSetMatrix(env, info) : nullptr;
575 }
576
OnSetMatrix(napi_env env,napi_callback_info info)577 napi_value JsMatrix::OnSetMatrix(napi_env env, napi_callback_info info)
578 {
579 if (m_matrix == nullptr) {
580 ROSEN_LOGE("JsMatrix::OnSetMatrix matrix is nullptr");
581 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
582 }
583
584 napi_value argv[ARGC_ONE] = {nullptr};
585 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
586
587 uint32_t arrayLength = 0;
588 if ((napi_get_array_length(env, argv[ARGC_ZERO], &arrayLength) != napi_ok)) {
589 JsMatrix* jsMatrix = nullptr;
590 GET_UNWRAP_PARAM(ARGC_ZERO, jsMatrix);
591
592 std::shared_ptr<Matrix> matrix = jsMatrix->GetMatrix();
593 if (matrix == nullptr) {
594 ROSEN_LOGE("JsMatrix::OnSetMatrix matrix is nullptr");
595 return nullptr;
596 }
597
598 *m_matrix = *matrix;
599 return nullptr;
600 }
601
602 if (arrayLength != ARGC_NINE) { // arrayLength must be an nine number
603 ROSEN_LOGE("JsMatrix::OnSetMatrix count of array is not nine : %{public}u", arrayLength);
604 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
605 "parameter array length verification failed.");
606 }
607
608 scalar matrixPara[arrayLength];
609 for (size_t i = 0; i < arrayLength; i++) {
610 bool hasElement = false;
611 napi_has_element(env, argv[ARGC_ZERO], i, &hasElement);
612 if (!hasElement) {
613 ROSEN_LOGE("JsMatrix::OnSetMatrix parameter check error");
614 return nullptr;
615 }
616
617 napi_value element = nullptr;
618 napi_get_element(env, argv[ARGC_ZERO], i, &element);
619
620 double value = 0.0;
621 ConvertFromJsNumber(env, element, value);
622 matrixPara[i] = value;
623 }
624
625 m_matrix->SetMatrix(matrixPara[ARGC_ZERO], matrixPara[ARGC_ONE], matrixPara[ARGC_TWO],
626 matrixPara[ARGC_THREE], matrixPara[ARGC_FOUR], matrixPara[ARGC_FIVE], matrixPara[ARGC_SIX],
627 matrixPara[ARGC_SEVEN], matrixPara[ARGC_EIGHT]);
628 return nullptr;
629 }
630
PreConcat(napi_env env,napi_callback_info info)631 napi_value JsMatrix::PreConcat(napi_env env, napi_callback_info info)
632 {
633 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
634 return (me != nullptr) ? me->OnPreConcat(env, info) : nullptr;
635 }
636
OnPreConcat(napi_env env,napi_callback_info info)637 napi_value JsMatrix::OnPreConcat(napi_env env, napi_callback_info info)
638 {
639 if (m_matrix == nullptr) {
640 ROSEN_LOGE("JsMatrix::OnPreConcat matrix is nullptr");
641 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
642 }
643
644 napi_value argv[ARGC_ONE] = {nullptr};
645 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
646
647 JsMatrix* jsMatrix = nullptr;
648 GET_UNWRAP_PARAM(ARGC_ZERO, jsMatrix);
649
650 if (jsMatrix->GetMatrix() == nullptr) {
651 ROSEN_LOGE("JsMatrix::OnPreConcat matrix is nullptr");
652 return nullptr;
653 }
654
655 m_matrix->PreConcat(*jsMatrix->GetMatrix());
656 return nullptr;
657 }
658
IsAffine(napi_env env,napi_callback_info info)659 napi_value JsMatrix::IsAffine(napi_env env, napi_callback_info info)
660 {
661 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
662 return (me != nullptr) ? me->OnIsAffine(env, info) : nullptr;
663 }
664
OnIsAffine(napi_env env,napi_callback_info info)665 napi_value JsMatrix::OnIsAffine(napi_env env, napi_callback_info info)
666 {
667 if (m_matrix == nullptr) {
668 ROSEN_LOGE("JsMatrix::OnIsAffine matrix is nullptr");
669 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
670 }
671
672 return CreateJsValue(env, m_matrix->IsAffine());
673 }
674
IsEqual(napi_env env,napi_callback_info info)675 napi_value JsMatrix::IsEqual(napi_env env, napi_callback_info info)
676 {
677 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
678 return (me != nullptr) ? me->OnIsEqual(env, info) : nullptr;
679 }
680
OnIsEqual(napi_env env,napi_callback_info info)681 napi_value JsMatrix::OnIsEqual(napi_env env, napi_callback_info info)
682 {
683 if (m_matrix == nullptr) {
684 ROSEN_LOGE("JsMatrix::OnIsEqual matrix is nullptr");
685 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
686 }
687
688 napi_value argv[ARGC_ONE] = {nullptr};
689 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
690
691 JsMatrix* jsMatrix = nullptr;
692 GET_UNWRAP_PARAM(ARGC_ZERO, jsMatrix);
693
694 if (jsMatrix->GetMatrix() == nullptr) {
695 ROSEN_LOGE("JsMatrix::OnIsEqual matrix is nullptr");
696 return CreateJsValue(env, false);
697 }
698
699 return CreateJsValue(env, m_matrix->operator == (*jsMatrix->GetMatrix()));
700 }
701
Invert(napi_env env,napi_callback_info info)702 napi_value JsMatrix::Invert(napi_env env, napi_callback_info info)
703 {
704 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
705 return (me != nullptr) ? me->OnInvert(env, info) : nullptr;
706 }
707
OnInvert(napi_env env,napi_callback_info info)708 napi_value JsMatrix::OnInvert(napi_env env, napi_callback_info info)
709 {
710 if (m_matrix == nullptr) {
711 ROSEN_LOGE("JsMatrix::OnInvert matrix is nullptr");
712 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
713 }
714
715 napi_value argv[ARGC_ONE] = {nullptr};
716 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
717
718 JsMatrix* jsMatrix = nullptr;
719 GET_UNWRAP_PARAM(ARGC_ZERO, jsMatrix);
720
721 if (jsMatrix->GetMatrix() == nullptr) {
722 ROSEN_LOGE("JsMatrix::OnInvert matrix is nullptr");
723 return nullptr;
724 }
725
726 return CreateJsValue(env, m_matrix->Invert(*jsMatrix->GetMatrix()));
727 }
728
IsIdentity(napi_env env,napi_callback_info info)729 napi_value JsMatrix::IsIdentity(napi_env env, napi_callback_info info)
730 {
731 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
732 return (me != nullptr) ? me->OnIsIdentity(env, info) : nullptr;
733 }
734
OnIsIdentity(napi_env env,napi_callback_info info)735 napi_value JsMatrix::OnIsIdentity(napi_env env, napi_callback_info info)
736 {
737 if (m_matrix == nullptr) {
738 ROSEN_LOGE("JsMatrix::OnIsIdentity matrix is nullptr");
739 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
740 }
741
742 return CreateJsValue(env, m_matrix->IsIdentity());
743 }
744
MapPoints(napi_env env,napi_callback_info info)745 napi_value JsMatrix::MapPoints(napi_env env, napi_callback_info info)
746 {
747 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
748 return (me != nullptr) ? me->OnMapPoints(env, info) : nullptr;
749 }
750
OnMapPoints(napi_env env,napi_callback_info info)751 napi_value JsMatrix::OnMapPoints(napi_env env, napi_callback_info info)
752 {
753 if (m_matrix == nullptr) {
754 ROSEN_LOGE("JsMatrix::OnMapPoints matrix is nullptr");
755 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
756 }
757
758 napi_value argv[ARGC_ONE] = {nullptr};
759 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
760
761 napi_value srcArray = argv[ARGC_ZERO];
762
763 /* Check size */
764 uint32_t srcPointsSize = 0;
765 if (napi_get_array_length(env, srcArray, &srcPointsSize) != napi_ok || (srcPointsSize == 0)) {
766 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Incorrect src array size.");
767 }
768
769 std::vector<Point> dstPoints(srcPointsSize);
770 std::vector<Point> srcPoints(srcPointsSize);
771 /* Fill vector with data from input array */
772 if (!ConvertFromJsPointsArray(env, srcArray, srcPoints.data(), srcPointsSize)) {
773 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Incorrect src array data.");
774 }
775
776 JS_CALL_DRAWING_FUNC(m_matrix->MapPoints(dstPoints, srcPoints, srcPointsSize));
777
778 napi_value resultArray = nullptr;
779 if (napi_create_array_with_length(env, dstPoints.size(), &resultArray) != napi_ok) {
780 ROSEN_LOGE("JsMatrix::OnMapPoints failed to create array");
781 return nullptr;
782 }
783 for (uint32_t idx = 0; idx < dstPoints.size(); idx++) {
784 NAPI_CALL(env, napi_set_element(env, resultArray, idx, ConvertPointToJsValue(env, dstPoints.at(idx))));
785 }
786
787 return resultArray;
788 }
789
MapRadius(napi_env env,napi_callback_info info)790 napi_value JsMatrix::MapRadius(napi_env env, napi_callback_info info)
791 {
792 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
793 return (me != nullptr) ? me->OnMapRadius(env, info) : nullptr;
794 }
795
OnMapRadius(napi_env env,napi_callback_info info)796 napi_value JsMatrix::OnMapRadius(napi_env env, napi_callback_info info)
797 {
798 if (m_matrix == nullptr) {
799 ROSEN_LOGE("JsMatrix::OnMapRadius matrix is nullptr");
800 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
801 }
802
803 napi_value argv[ARGC_ONE] = {nullptr};
804 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
805
806 double radius = 0.0;
807 GET_DOUBLE_PARAM(ARGC_ZERO, radius);
808
809 return CreateJsNumber(env, m_matrix->MapRadius(radius));
810 }
811
PostScale(napi_env env,napi_callback_info info)812 napi_value JsMatrix::PostScale(napi_env env, napi_callback_info info)
813 {
814 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
815 return (me != nullptr) ? me->OnPostScale(env, info) : nullptr;
816 }
817
OnPostScale(napi_env env,napi_callback_info info)818 napi_value JsMatrix::OnPostScale(napi_env env, napi_callback_info info)
819 {
820 if (m_matrix == nullptr) {
821 ROSEN_LOGE("JsMatrix::OnPostScale matrix is nullptr");
822 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
823 }
824
825 napi_value argv[ARGC_FOUR] = {nullptr};
826 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_FOUR);
827
828 double sx = 0.0;
829 GET_DOUBLE_PARAM(ARGC_ZERO, sx);
830 double sy = 0.0;
831 GET_DOUBLE_PARAM(ARGC_ONE, sy);
832 double px = 0.0;
833 GET_DOUBLE_PARAM(ARGC_TWO, px);
834 double py = 0.0;
835 GET_DOUBLE_PARAM(ARGC_THREE, py);
836
837 JS_CALL_DRAWING_FUNC(m_matrix->PostScale(sx, sy, px, py));
838
839 return nullptr;
840 }
841
RectStaysRect(napi_env env,napi_callback_info info)842 napi_value JsMatrix::RectStaysRect(napi_env env, napi_callback_info info)
843 {
844 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
845 return (me != nullptr) ? me->OnRectStaysRect(env, info) : nullptr;
846 }
847
OnRectStaysRect(napi_env env,napi_callback_info info)848 napi_value JsMatrix::OnRectStaysRect(napi_env env, napi_callback_info info)
849 {
850 if (m_matrix == nullptr) {
851 ROSEN_LOGE("JsMatrix::OnRectStaysRect matrix is nullptr");
852 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
853 }
854
855 return CreateJsValue(env, m_matrix->RectStaysRect());
856 }
857
Reset(napi_env env,napi_callback_info info)858 napi_value JsMatrix::Reset(napi_env env, napi_callback_info info)
859 {
860 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
861 return (me != nullptr) ? me->OnReset(env, info) : nullptr;
862 }
863
OnReset(napi_env env,napi_callback_info info)864 napi_value JsMatrix::OnReset(napi_env env, napi_callback_info info)
865 {
866 if (m_matrix == nullptr) {
867 ROSEN_LOGE("JsMatrix::OnReset matrix is nullptr");
868 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
869 }
870
871 m_matrix->Reset();
872 return nullptr;
873 }
874
GetAll(napi_env env,napi_callback_info info)875 napi_value JsMatrix::GetAll(napi_env env, napi_callback_info info)
876 {
877 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
878 return (me != nullptr) ? me->OnGetAll(env, info) : nullptr;
879 }
880
OnGetAll(napi_env env,napi_callback_info info)881 napi_value JsMatrix::OnGetAll(napi_env env, napi_callback_info info)
882 {
883 if (m_matrix == nullptr) {
884 ROSEN_LOGE("JsMatrix::OnGetAll matrix is nullptr");
885 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
886 }
887
888 Matrix::Buffer matrData;
889 m_matrix->GetAll(matrData);
890
891 napi_value array = nullptr;
892 NAPI_CALL(env, napi_create_array_with_length(env, Matrix::MATRIX_SIZE, &array));
893 for (int i = 0; i < Matrix::MATRIX_SIZE; ++i) {
894 NAPI_CALL(env, napi_set_element(env, array, i, CreateJsValue(env, matrData[i])));
895 }
896 return array;
897 }
898
SetPolyToPoly(napi_env env,napi_callback_info info)899 napi_value JsMatrix::SetPolyToPoly(napi_env env, napi_callback_info info)
900 {
901 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
902 return (me != nullptr) ? me->OnSetPolyToPoly(env, info) : nullptr;
903 }
904
OnSetPolyToPoly(napi_env env,napi_callback_info info)905 napi_value JsMatrix::OnSetPolyToPoly(napi_env env, napi_callback_info info)
906 {
907 if (m_matrix == nullptr) {
908 ROSEN_LOGE("JsMatrix::OnSetPolyToPoly matrix is nullptr");
909 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
910 }
911
912 napi_value argv[ARGC_THREE] = {nullptr};
913 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_THREE);
914
915 uint32_t count = 0;
916 GET_UINT32_PARAM(ARGC_TWO, count);
917
918 if (count > POLY_POINT_COUNT_MAX) {
919 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
920 "Invalid param 'count' > 4");
921 }
922
923 Drawing::Point srcPoints[POLY_POINT_COUNT_MAX];
924 if (!ConvertFromJsPointsArray(env, argv[ARGC_ZERO], srcPoints, count)) {
925 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
926 "Invalid 'src' Array<Point> type.");
927 }
928 Drawing::Point dstPoints[POLY_POINT_COUNT_MAX];
929 if (!ConvertFromJsPointsArray(env, argv[ARGC_ONE], dstPoints, count)) {
930 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
931 "Invalid 'dst' Array<Point> type.");
932 }
933
934 bool result = m_matrix->SetPolyToPoly(srcPoints, dstPoints, count);
935 return CreateJsValue(env, result);
936 }
937
SetRectToRect(napi_env env,napi_callback_info info)938 napi_value JsMatrix::SetRectToRect(napi_env env, napi_callback_info info)
939 {
940 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
941 return (me != nullptr) ? me->OnSetRectToRect(env, info) : nullptr;
942 }
943
OnSetRectToRect(napi_env env,napi_callback_info info)944 napi_value JsMatrix::OnSetRectToRect(napi_env env, napi_callback_info info)
945 {
946 if (m_matrix == nullptr) {
947 ROSEN_LOGE("JsMatrix::OnSetRectToRect matrix is nullptr");
948 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
949 }
950
951 napi_value argv[ARGC_THREE] = {nullptr};
952 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_THREE);
953
954 double ltrb[ARGC_FOUR];
955 if (!ConvertFromJsRect(env, argv[ARGC_ZERO], ltrb, ARGC_FOUR)) {
956 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
957 "Incorrect 'src' Rect type. The type of left, top, right and bottom must be number.");
958 }
959 Drawing::Rect srcRect = Drawing::Rect(ltrb[ARGC_ZERO], ltrb[ARGC_ONE], ltrb[ARGC_TWO], ltrb[ARGC_THREE]);
960 if (!ConvertFromJsRect(env, argv[ARGC_ONE], ltrb, ARGC_FOUR)) {
961 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
962 "Incorrect 'dst' Rect type. The type of left, top, right and bottom must be number.");
963 }
964 Drawing::Rect dstRect = Drawing::Rect(ltrb[ARGC_ZERO], ltrb[ARGC_ONE], ltrb[ARGC_TWO], ltrb[ARGC_THREE]);
965
966 int32_t stf;
967 GET_ENUM_PARAM(ARGC_TWO, stf, 0, static_cast<int32_t>(ScaleToFit::END_SCALETOFIT));
968
969 bool result = m_matrix->SetRectToRect(srcRect, dstRect, static_cast<ScaleToFit>(stf));
970 return CreateJsValue(env, result);
971 }
972
MapRect(napi_env env,napi_callback_info info)973 napi_value JsMatrix::MapRect(napi_env env, napi_callback_info info)
974 {
975 JsMatrix* me = CheckParamsAndGetThis<JsMatrix>(env, info);
976 return (me != nullptr) ? me->OnMapRect(env, info) : nullptr;
977 }
978
OnMapRect(napi_env env,napi_callback_info info)979 napi_value JsMatrix::OnMapRect(napi_env env, napi_callback_info info)
980 {
981 if (m_matrix == nullptr) {
982 ROSEN_LOGE("JsMatrix::OnMapRect matrix is nullptr");
983 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
984 }
985
986 napi_value argv[ARGC_TWO] = {nullptr};
987 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_TWO);
988
989 double src[ARGC_FOUR];
990 if (!ConvertFromJsRect(env, argv[ARGC_ONE], src, ARGC_FOUR)) {
991 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
992 "JsMatrix::OnMapRect Incorrect parameter type for src rect. The types must be numbers.");
993 }
994 Rect dstRect;
995 Rect srcRect{ src[ARGC_ZERO], src[ARGC_ONE], src[ARGC_TWO], src[ARGC_THREE]};
996 auto res = CreateJsValue(env, m_matrix->MapRect(dstRect, srcRect));
997 auto objValue = argv[ARGC_ZERO];
998 if (napi_set_named_property(env, objValue, "left", CreateJsNumber(env, dstRect.GetLeft())) != napi_ok ||
999 napi_set_named_property(env, objValue, "top", CreateJsNumber(env, dstRect.GetTop())) != napi_ok ||
1000 napi_set_named_property(env, objValue, "right", CreateJsNumber(env, dstRect.GetRight())) != napi_ok ||
1001 napi_set_named_property(env, objValue, "bottom", CreateJsNumber(env, dstRect.GetBottom())) != napi_ok) {
1002 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM,
1003 "JsMatrix::OnMapRect Cannot fill 'dst' Rect type.");
1004 }
1005 return res;
1006 }
1007
~JsMatrix()1008 JsMatrix::~JsMatrix()
1009 {
1010 m_matrix = nullptr;
1011 }
1012
GetMatrix()1013 std::shared_ptr<Matrix> JsMatrix::GetMatrix()
1014 {
1015 return m_matrix;
1016 }
1017 }
1018 }
1019