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#include "napi/native_api.h" 16#include <js_native_api.h> 17#include <native_drawing/drawing_bitmap.h> 18#include <native_drawing/drawing_brush.h> 19#include <native_drawing/drawing_canvas.h> 20#include <native_drawing/drawing_color.h> 21#include <native_drawing/drawing_font_collection.h> 22#include <native_drawing/drawing_path.h> 23#include <native_drawing/drawing_pen.h> 24#include <native_drawing/drawing_text_typography.h> 25#include <cstring> 26 27#define SUCCESS 0 28#define FAIL (-1) 29#define ONEVAL 1 30#define ZEROOVAL 0.0 31#define FIVTENVAL 50 32#define THRTENVAL 30 33#define WIDTH 500 34#define HEIGHT 500 35#define ZEROVAL 0 36#define TENVAL 10.0 37#define MINUSTENVAL (-10.5) 38#define MINUSFIVEVAL (-5.5) 39#define FIVEVAL 5.0 40#define EIGHUNVAL 800.0 41#define MINUSEIGHUNVAL (-800.0) 42#define SENHUNVAL 700.0 43#define SENFIVEVAL 750.0 44#define MINUSSENFIVEVAL (-750.0) 45#define SIXFIVEVAL 650.0 46#define POSX_1 1.0f 47#define POSY_1 1.0f 48#define POSX_2 10.0f 49#define POSY_2 10.0f 50#define POSX_3 20.0f 51#define POSY_3 20.0f 52 53#define ONEHUNVAL 100 54#define EIGTENVAL 80 55#define MINIMUMVALUE (-340282346638528859811704183484516925440.000000) 56 57static napi_value OHDrawingBitmapCreate(napi_env env, napi_callback_info info) 58{ 59 napi_value result = nullptr; 60 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 61 if (bitmap == nullptr) { 62 napi_create_int32(env, FAIL, &result); 63 } else { 64 napi_create_int32(env, SUCCESS, &result); 65 } 66 OH_Drawing_BitmapDestroy(bitmap); 67 return result; 68} 69 70static napi_value OHDrawingBitmapBuild(napi_env env, napi_callback_info info) 71{ 72 napi_value result = nullptr; 73 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 74 const unsigned int width = WIDTH; 75 const unsigned int height = HEIGHT; 76 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_ARGB_4444, ALPHA_FORMAT_UNPREMUL}; 77 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 78 if (width == OH_Drawing_BitmapGetWidth(bitmap)) { 79 napi_create_int32(env, SUCCESS, &result); 80 } else { 81 napi_create_int32(env, FAIL, &result); 82 } 83 OH_Drawing_BitmapDestroy(bitmap); 84 return result; 85} 86 87static napi_value OHDrawingBitmapGetWidth(napi_env env, napi_callback_info info) 88{ 89 napi_value result = nullptr; 90 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 91 const unsigned int width = WIDTH; 92 const unsigned int height = HEIGHT; 93 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_ARGB_4444, ALPHA_FORMAT_UNPREMUL}; 94 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 95 if (OH_Drawing_BitmapGetWidth(bitmap) == width) { 96 napi_create_int32(env, SUCCESS, &result); 97 } else { 98 napi_create_int32(env, FAIL, &result); 99 } 100 OH_Drawing_BitmapDestroy(bitmap); 101 return result; 102} 103 104static napi_value OHDrawingBitmapGetHeight(napi_env env, napi_callback_info info) 105{ 106 napi_value result = nullptr; 107 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 108 const unsigned int width = WIDTH; 109 const unsigned int height = HEIGHT; 110 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_ARGB_4444, ALPHA_FORMAT_UNPREMUL}; 111 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 112 if (OH_Drawing_BitmapGetHeight(bitmap) == height) { 113 napi_create_int32(env, SUCCESS, &result); 114 } else { 115 napi_create_int32(env, FAIL, &result); 116 } 117 OH_Drawing_BitmapCreate(); 118 return result; 119} 120 121static napi_value OHDrawingBitmapGetPixels(napi_env env, napi_callback_info info) 122{ 123 napi_value result = nullptr; 124 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 125 const unsigned int width = WIDTH; 126 const unsigned int height = HEIGHT; 127 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_ARGB_4444, ALPHA_FORMAT_UNPREMUL}; 128 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 129 if (OH_Drawing_BitmapGetPixels(bitmap) == nullptr) { 130 napi_create_int32(env, FAIL, &result); 131 } else { 132 napi_create_int32(env, SUCCESS, &result); 133 } 134 OH_Drawing_BitmapCreate(); 135 return result; 136} 137 138static napi_value OHDrawingBrushCreate(napi_env env, napi_callback_info info) 139{ 140 napi_value result = nullptr; 141 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 142 if (brush == nullptr) { 143 napi_create_int32(env, FAIL, &result); 144 } else { 145 napi_create_int32(env, SUCCESS, &result); 146 } 147 OH_Drawing_BrushDestroy(brush); 148 return result; 149} 150 151static napi_value OHDrawingBrushIsAntiAlias(napi_env env, napi_callback_info info) 152{ 153 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 154 OH_Drawing_BrushSetAntiAlias(brush, false); 155 napi_value result = nullptr; 156 if (OH_Drawing_BrushIsAntiAlias(brush) == false) { 157 napi_create_int32(env, SUCCESS, &result); 158 } else { 159 napi_create_int32(env, FAIL, &result); 160 } 161 OH_Drawing_BrushDestroy(brush); 162 return result; 163} 164 165static napi_value OHDrawingBrushSetAntiAlias(napi_env env, napi_callback_info info) 166{ 167 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 168 OH_Drawing_BrushSetAntiAlias(brush, true); 169 napi_value result = nullptr; 170 if (OH_Drawing_BrushIsAntiAlias(brush) == true) { 171 napi_create_int32(env, SUCCESS, &result); 172 } else { 173 napi_create_int32(env, FAIL, &result); 174 } 175 OH_Drawing_BrushDestroy(brush); 176 return result; 177} 178 179static napi_value OHDrawingBrushGetColor(napi_env env, napi_callback_info info) 180{ 181 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 182 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 183 napi_value result = nullptr; 184 if (OH_Drawing_BrushGetColor(brush) != 0xFFFF0000) { 185 napi_create_int32(env, FAIL, &result); 186 } else { 187 napi_create_int32(env, SUCCESS, &result); 188 } 189 OH_Drawing_BrushDestroy(brush); 190 return result; 191} 192 193static napi_value OHDrawingBrushSetColor(napi_env env, napi_callback_info info) 194{ 195 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 196 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 197 napi_value result = nullptr; 198 if (OH_Drawing_BrushGetColor(brush) == 0xFFFF0000) { 199 napi_create_int32(env, SUCCESS, &result); 200 } else { 201 napi_create_int32(env, FAIL, &result); 202 } 203 OH_Drawing_BrushDestroy(brush); 204 return result; 205} 206 207static napi_value OHDrawingCanvasCreate(napi_env env, napi_callback_info info) 208{ 209 napi_value result = nullptr; 210 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 211 if (canvas == nullptr) { 212 napi_create_int32(env, FAIL, &result); 213 } else { 214 napi_create_int32(env, SUCCESS, &result); 215 } 216 OH_Drawing_CanvasDestroy(canvas); 217 return result; 218} 219 220static napi_value OHDrawingPathCreate(napi_env env, napi_callback_info info) 221{ 222 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 223 napi_value result = nullptr; 224 if (path == nullptr) { 225 napi_create_int32(env, FAIL, &result); 226 } else { 227 napi_create_int32(env, SUCCESS, &result); 228 } 229 OH_Drawing_PathDestroy(path); 230 return result; 231} 232 233static napi_value OHDrawingPenCreate(napi_env env, napi_callback_info info) 234{ 235 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 236 napi_value result = nullptr; 237 if (pen == nullptr) { 238 napi_create_int32(env, FAIL, &result); 239 } else { 240 napi_create_int32(env, SUCCESS, &result); 241 } 242 OH_Drawing_PenDestroy(pen); 243 return result; 244} 245 246static napi_value OHDrawingPenIsAntiAlias(napi_env env, napi_callback_info info) 247{ 248 napi_value result = nullptr; 249 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 250 OH_Drawing_PenSetAntiAlias(pen, false); 251 if (OH_Drawing_PenIsAntiAlias(pen)) { 252 napi_create_int32(env, FAIL, &result); 253 } else { 254 napi_create_int32(env, SUCCESS, &result); 255 } 256 OH_Drawing_PenDestroy(pen); 257 return result; 258} 259 260static napi_value OHDrawingPenSetAntiAlias(napi_env env, napi_callback_info info) 261{ 262 napi_value result = nullptr; 263 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 264 OH_Drawing_PenSetAntiAlias(pen, true); 265 if (OH_Drawing_PenIsAntiAlias(pen)) { 266 napi_create_int32(env, SUCCESS, &result); 267 } else { 268 napi_create_int32(env, FAIL, &result); 269 } 270 OH_Drawing_PenDestroy(pen); 271 return result; 272} 273 274static napi_value OHDrawingPenGetColor(napi_env env, napi_callback_info info) 275{ 276 napi_value result = nullptr; 277 OH_Drawing_Pen *penn = OH_Drawing_PenCreate(); 278 OH_Drawing_PenSetColor(penn, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 279 if (OH_Drawing_PenGetColor(penn) == 0xFFFF0000) { 280 napi_create_int32(env, SUCCESS, &result); 281 } else { 282 napi_create_int32(env, FAIL, &result); 283 } 284 OH_Drawing_PenDestroy(penn); 285 return result; 286} 287 288static napi_value OHDrawingPenSetColor(napi_env env, napi_callback_info info) 289{ 290 napi_value result = nullptr; 291 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 292 OH_Drawing_PenSetColor(pen, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 293 if (OH_Drawing_PenGetColor(pen) == 0xFFFF0000) { 294 napi_create_int32(env, SUCCESS, &result); 295 } else { 296 napi_create_int32(env, FAIL, &result); 297 } 298 OH_Drawing_PenDestroy(pen); 299 return result; 300} 301 302static napi_value OHDrawingPenGetWidth(napi_env env, napi_callback_info info) 303{ 304 napi_value result = nullptr; 305 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 306 OH_Drawing_PenSetWidth(pen, TENVAL); 307 if (OH_Drawing_PenGetWidth(pen) == TENVAL) { 308 napi_create_int32(env, SUCCESS, &result); 309 } else { 310 napi_create_int32(env, FAIL, &result); 311 } 312 OH_Drawing_PenDestroy(pen); 313 return result; 314} 315 316static napi_value OHDrawingPenSetWidth(napi_env env, napi_callback_info info) 317{ 318 napi_value result = nullptr; 319 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 320 OH_Drawing_PenSetWidth(pen, FIVEVAL); 321 if (OH_Drawing_PenGetWidth(pen) == FIVEVAL) { 322 napi_create_int32(env, SUCCESS, &result); 323 } else { 324 napi_create_int32(env, FAIL, &result); 325 } 326 OH_Drawing_PenDestroy(pen); 327 return result; 328} 329 330static napi_value OHDrawingPenGetMiterLimit(napi_env env, napi_callback_info info) 331{ 332 napi_value result = nullptr; 333 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 334 OH_Drawing_PenSetMiterLimit(pen, TENVAL); 335 if (OH_Drawing_PenGetMiterLimit(pen) == TENVAL) { 336 napi_create_int32(env, SUCCESS, &result); 337 } else { 338 napi_create_int32(env, FAIL, &result); 339 } 340 OH_Drawing_PenDestroy(pen); 341 return result; 342} 343 344static napi_value OHDrawingPenSetMiterLimit(napi_env env, napi_callback_info info) 345{ 346 napi_value result = nullptr; 347 OH_Drawing_Pen *penn = OH_Drawing_PenCreate(); 348 OH_Drawing_PenSetMiterLimit(penn, FIVEVAL); 349 if (OH_Drawing_PenGetMiterLimit(penn) == FIVEVAL) { 350 napi_create_int32(env, SUCCESS, &result); 351 } else { 352 napi_create_int32(env, FAIL, &result); 353 } 354 OH_Drawing_PenDestroy(penn); 355 return result; 356} 357 358static napi_value OHDrawingPenGetCap(napi_env env, napi_callback_info info) 359{ 360 OH_Drawing_Pen *penen = OH_Drawing_PenCreate(); 361 OH_Drawing_PenSetCap(penen, OH_Drawing_PenLineCapStyle::LINE_SQUARE_CAP); 362 napi_value result = nullptr; 363 if (OH_Drawing_PenGetCap(penen) == OH_Drawing_PenLineCapStyle::LINE_SQUARE_CAP) { 364 napi_create_int32(env, SUCCESS, &result); 365 } else { 366 napi_create_int32(env, FAIL, &result); 367 } 368 OH_Drawing_PenDestroy(penen); 369 return result; 370} 371 372static napi_value OHDrawingPenSetCap(napi_env env, napi_callback_info info) 373{ 374 OH_Drawing_Pen *penen = OH_Drawing_PenCreate(); 375 OH_Drawing_PenSetCap(penen, OH_Drawing_PenLineCapStyle::LINE_SQUARE_CAP); 376 napi_value result = nullptr; 377 if (OH_Drawing_PenGetCap(penen) == OH_Drawing_PenLineCapStyle::LINE_SQUARE_CAP) { 378 napi_create_int32(env, SUCCESS, &result); 379 } else { 380 napi_create_int32(env, FAIL, &result); 381 } 382 OH_Drawing_PenDestroy(penen); 383 return result; 384} 385 386static napi_value OHDrawingPenGetJoin(napi_env env, napi_callback_info info) 387{ 388 OH_Drawing_Pen *penval = OH_Drawing_PenCreate(); 389 OH_Drawing_PenSetJoin(penval, OH_Drawing_PenLineJoinStyle::LINE_ROUND_JOIN); 390 napi_value result = nullptr; 391 if (OH_Drawing_PenGetJoin(penval) == OH_Drawing_PenLineJoinStyle::LINE_ROUND_JOIN) { 392 napi_create_int32(env, SUCCESS, &result); 393 } else { 394 napi_create_int32(env, FAIL, &result); 395 } 396 OH_Drawing_PenDestroy(penval); 397 return result; 398} 399 400static napi_value OHDrawingPenSetJoin(napi_env env, napi_callback_info info) 401{ 402 OH_Drawing_Pen *penval = OH_Drawing_PenCreate(); 403 OH_Drawing_PenSetJoin(penval, OH_Drawing_PenLineJoinStyle::LINE_MITER_JOIN); 404 napi_value result = nullptr; 405 if (OH_Drawing_PenGetJoin(penval) == OH_Drawing_PenLineJoinStyle::LINE_MITER_JOIN) { 406 napi_create_int32(env, SUCCESS, &result); 407 } else { 408 napi_create_int32(env, FAIL, &result); 409 } 410 OH_Drawing_PenDestroy(penval); 411 return result; 412} 413 414static napi_value OHDrawingColorSetArgb(napi_env env, napi_callback_info info) 415{ 416 OH_Drawing_Brush *brushsh = OH_Drawing_BrushCreate(); 417 napi_value result = nullptr; 418 OH_Drawing_BrushSetColor(brushsh, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00)); 419 if (OH_Drawing_BrushGetColor(brushsh) == 0xFFFF0000) { 420 napi_create_int32(env, SUCCESS, &result); 421 } else { 422 napi_create_int32(env, FAIL, &result); 423 } 424 OH_Drawing_BrushDestroy(brushsh); 425 return result; 426} 427 428static napi_value OHDrawingCreateFontCollection(napi_env env, napi_callback_info info) 429{ 430 napi_value result = nullptr; 431 OH_Drawing_FontCollection *fontCollection = OH_Drawing_CreateFontCollection(); 432 if (fontCollection == nullptr) { 433 napi_create_int32(env, FAIL, &result); 434 } else { 435 napi_create_int32(env, SUCCESS, &result); 436 } 437 OH_Drawing_DestroyFontCollection(fontCollection); 438 return result; 439} 440 441static napi_value OHDrawingCreateTypographyStyle(napi_env env, napi_callback_info info) 442{ 443 OH_Drawing_TypographyStyle *TypographyStyle = OH_Drawing_CreateTypographyStyle(); 444 napi_value result = nullptr; 445 if (TypographyStyle == nullptr) { 446 napi_create_int32(env, FAIL, &result); 447 } else { 448 napi_create_int32(env, SUCCESS, &result); 449 } 450 OH_Drawing_DestroyTypographyStyle(TypographyStyle); 451 return result; 452} 453 454static napi_value OHDrawingCreateTextStyle(napi_env env, napi_callback_info info) 455{ 456 napi_value result = nullptr; 457 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 458 if (txtStyle == nullptr) { 459 napi_create_int32(env, FAIL, &result); 460 } else { 461 napi_create_int32(env, SUCCESS, &result); 462 } 463 OH_Drawing_DestroyTextStyle(txtStyle); 464 return result; 465} 466 467static napi_value OHDrawingCreateTypographyHandler(napi_env env, napi_callback_info info) 468{ 469 napi_value result = nullptr; 470 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 471 OH_Drawing_TypographyCreate *handler = 472 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 473 if (handler != nullptr) { 474 napi_create_int32(env, SUCCESS, &result); 475 } else { 476 napi_create_int32(env, FAIL, &result); 477 } 478 OH_Drawing_DestroyTypographyHandler(handler); 479 return result; 480} 481 482static napi_value OHDrawingCreateTypography(napi_env env, napi_callback_info info) 483{ 484 napi_value result = nullptr; 485 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 486 OH_Drawing_TypographyCreate *handler = 487 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 488 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 489 if (typography != nullptr) { 490 napi_create_int32(env, SUCCESS, &result); 491 } else { 492 napi_create_int32(env, FAIL, &result); 493 } 494 OH_Drawing_DestroyTypography(typography); 495 OH_Drawing_DestroyTypographyHandler(handler); 496 return result; 497} 498 499static napi_value OHDrawingTypographyLayout(napi_env env, napi_callback_info info) 500{ 501 napi_value result = nullptr; 502 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 503 OH_Drawing_TypographyCreate *handler = 504 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 505 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 506 double maxWidth = EIGHUNVAL; 507 OH_Drawing_TypographyLayout(typography, maxWidth); 508 if (maxWidth == OH_Drawing_TypographyGetMaxWidth(typography)) { 509 napi_create_int32(env, SUCCESS, &result); 510 } else { 511 napi_create_int32(env, FAIL, &result); 512 } 513 OH_Drawing_DestroyTypography(typography); 514 OH_Drawing_DestroyTypographyHandler(handler); 515 return result; 516} 517 518static napi_value OHDrawingTypographyGetMaxWidth(napi_env env, napi_callback_info info) 519{ 520 napi_value result = nullptr; 521 OH_Drawing_TypographyStyle *typoStylee = OH_Drawing_CreateTypographyStyle(); 522 OH_Drawing_TypographyCreate *handlerr = 523 OH_Drawing_CreateTypographyHandler(typoStylee, OH_Drawing_CreateFontCollection()); 524 OH_Drawing_Typography *typographyy = OH_Drawing_CreateTypography(handlerr); 525 double maxWidth = SENHUNVAL; 526 OH_Drawing_TypographyLayout(typographyy, maxWidth); 527 if (maxWidth == OH_Drawing_TypographyGetMaxWidth(typographyy)) { 528 napi_create_int32(env, SUCCESS, &result); 529 } else { 530 napi_create_int32(env, FAIL, &result); 531 } 532 OH_Drawing_DestroyTypography(typographyy); 533 OH_Drawing_DestroyTypographyHandler(handlerr); 534 return result; 535} 536 537static napi_value OHDrawingTypographyGetMinIntrinsicWidth(napi_env env, napi_callback_info info) 538{ 539 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 540 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 541 OH_Drawing_TypographyCreate *handler = 542 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 543 544 double fontSize = THRTENVAL; 545 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 546 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_400); 547 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 548 549 const char *fontFamilies[] = {"Roboooto"}; 550 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 551 OH_Drawing_TypographyHandlerPushTextStyle(handler, txtStyle); 552 553 const char *text = "OpennnnHarmony\n"; 554 OH_Drawing_TypographyHandlerAddText(handler, text); 555 OH_Drawing_TypographyHandlerPopTextStyle(handler); 556 557 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 558 double maxWidth = EIGHUNVAL; 559 OH_Drawing_TypographyLayout(typography, maxWidth); 560 561 napi_value result = nullptr; 562 double minIntrinsicWidth = OH_Drawing_TypographyGetMinIntrinsicWidth(typography); 563 double maxIntrinsicWidth = OH_Drawing_TypographyGetMaxIntrinsicWidth(typography); 564 if (minIntrinsicWidth <= maxIntrinsicWidth) { 565 napi_create_int32(env, SUCCESS, &result); 566 } else { 567 napi_create_int32(env, FAIL, &result); 568 } 569 OH_Drawing_DestroyTypography(typography); 570 OH_Drawing_DestroyTypographyHandler(handler); 571 return result; 572} 573 574static napi_value OHDrawingTypographyGetMaxIntrinsicWidth(napi_env env, napi_callback_info info) 575{ 576 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 577 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 578 OH_Drawing_TypographyCreate *handler = 579 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 580 581 double fontSize = THRTENVAL; 582 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 583 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_400); 584 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 585 586 const char *fontFamilies[] = {"Roboooto"}; 587 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 588 OH_Drawing_TypographyHandlerPushTextStyle(handler, txtStyle); 589 590 const char *text = "OpennnnHarmony\n"; 591 OH_Drawing_TypographyHandlerAddText(handler, text); 592 OH_Drawing_TypographyHandlerPopTextStyle(handler); 593 594 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 595 double maxWidth = SENFIVEVAL; 596 OH_Drawing_TypographyLayout(typography, maxWidth); 597 598 napi_value result = nullptr; 599 double minIntrinsicWidth = OH_Drawing_TypographyGetMinIntrinsicWidth(typography); 600 double maxIntrinsicWidth = OH_Drawing_TypographyGetMaxIntrinsicWidth(typography); 601 if (minIntrinsicWidth <= maxIntrinsicWidth) { 602 napi_create_int32(env, SUCCESS, &result); 603 } else { 604 napi_create_int32(env, FAIL, &result); 605 } 606 OH_Drawing_DestroyTypography(typography); 607 OH_Drawing_DestroyTypographyHandler(handler); 608 return result; 609} 610 611static napi_value OHDrawingTypographyGetLongestLine(napi_env env, napi_callback_info info) 612{ 613 OH_Drawing_TypographyStyle *typoStylee = OH_Drawing_CreateTypographyStyle(); 614 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 615 OH_Drawing_TypographyCreate *handlerr = 616 OH_Drawing_CreateTypographyHandler(typoStylee, OH_Drawing_CreateFontCollection()); 617 618 const char *fontFamilies[] = {"Robotoo"}; 619 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 620 const char *text = "OpenHarmonyy\n"; 621 OH_Drawing_TypographyHandlerAddText(handlerr, text); 622 623 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handlerr); 624 double maxWidth = EIGHUNVAL; 625 OH_Drawing_TypographyLayout(typography, maxWidth); 626 napi_value result = nullptr; 627 628 if (OH_Drawing_TypographyGetLongestLine(typography) != ZEROOVAL) { 629 napi_create_int32(env, SUCCESS, &result); 630 } else { 631 napi_create_int32(env, FAIL, &result); 632 } 633 OH_Drawing_DestroyTypography(typography); 634 OH_Drawing_DestroyTypographyHandler(handlerr); 635 return result; 636} 637 638static napi_value OHDrawingTypographyGetLongestLineAbnormal(napi_env env, napi_callback_info info) 639{ 640 OH_Drawing_TypographyStyle *typoStylee = OH_Drawing_CreateTypographyStyle(); 641 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 642 OH_Drawing_TypographyCreate *handlerr = 643 OH_Drawing_CreateTypographyHandler(typoStylee, OH_Drawing_CreateFontCollection()); 644 645 const char *fontFamilies[] = {"Robotoo"}; 646 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 647 const char *text = "OpenHarmonnnyy\n"; 648 OH_Drawing_TypographyHandlerAddText(handlerr, text); 649 650 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handlerr); 651 652 napi_value result = nullptr; 653 if (OH_Drawing_TypographyGetLongestLine(typography) != ZEROOVAL) { 654 napi_create_int32(env, SUCCESS, &result); 655 } else { 656 napi_create_int32(env, FAIL, &result); 657 } 658 OH_Drawing_DestroyTypography(typography); 659 OH_Drawing_DestroyTypographyHandler(handlerr); 660 return result; 661} 662 663static napi_value OHDrawingTypographyGetLongestLineWithIndent(napi_env env, napi_callback_info info) 664{ 665 OH_Drawing_TypographyStyle *typoStylee = OH_Drawing_CreateTypographyStyle(); 666 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 667 OH_Drawing_TypographyCreate *handlerr = 668 OH_Drawing_CreateTypographyHandler(typoStylee, OH_Drawing_CreateFontCollection()); 669 670 const char *fontFamilies[] = {"Robotoo"}; 671 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 672 const char *text = "OpenHarmonyy\n"; 673 OH_Drawing_TypographyHandlerAddText(handlerr, text); 674 675 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handlerr); 676 double maxWidth = EIGHUNVAL; 677 OH_Drawing_TypographyLayout(typography, maxWidth); 678 napi_value result = nullptr; 679 680 if (OH_Drawing_TypographyGetLongestLineWithIndent(typography) != ZEROOVAL) { 681 napi_create_int32(env, SUCCESS, &result); 682 } else { 683 napi_create_int32(env, FAIL, &result); 684 } 685 OH_Drawing_DestroyTypography(typography); 686 OH_Drawing_DestroyTypographyHandler(handlerr); 687 return result; 688} 689 690static napi_value OHDrawingTypographyGetAlphabeticBaseline(napi_env env, napi_callback_info info) 691{ 692 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 693 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 694 OH_Drawing_TypographyCreate *handler = 695 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 696 697 double fontSize = THRTENVAL; 698 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 699 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_400); 700 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 701 702 const char *fontFamilies[] = {"Roboto"}; 703 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 704 const char *text = "OpenHarmony\n"; 705 OH_Drawing_TypographyHandlerAddText(handler, text); 706 707 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 708 double maxWidth = EIGHUNVAL; 709 OH_Drawing_TypographyLayout(typography, maxWidth); 710 711 napi_value result = nullptr; 712 if (OH_Drawing_TypographyGetAlphabeticBaseline(typography) != ZEROOVAL) { 713 napi_create_int32(env, SUCCESS, &result); 714 } else { 715 napi_create_int32(env, FAIL, &result); 716 } 717 OH_Drawing_DestroyTypography(typography); 718 OH_Drawing_DestroyTypographyHandler(handler); 719 return result; 720} 721 722static napi_value OHDrawingTypographyGetAlphabeticBaselineNormal(napi_env env, napi_callback_info info) 723{ 724 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 725 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 726 OH_Drawing_TypographyCreate *handler = 727 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 728 729 double fontSize = THRTENVAL; 730 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 731 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_500); 732 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 733 734 const char *fontFamilies[] = {"Roobooto"}; 735 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 736 const char *text = "OopenHarmoony\n"; 737 OH_Drawing_TypographyHandlerAddText(handler, text); 738 739 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 740 double maxWidth = EIGHUNVAL; 741 OH_Drawing_TypographyLayout(typography, maxWidth); 742 743 napi_value result = nullptr; 744 if (OH_Drawing_TypographyGetAlphabeticBaseline(typography) != ZEROOVAL) { 745 napi_create_int32(env, SUCCESS, &result); 746 } else { 747 napi_create_int32(env, FAIL, &result); 748 } 749 OH_Drawing_DestroyTypography(typography); 750 OH_Drawing_DestroyTypographyHandler(handler); 751 return result; 752} 753 754static napi_value OHDrawingTypographyGetIdeographicBaseline(napi_env env, napi_callback_info info) 755{ 756 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 757 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 758 OH_Drawing_TypographyCreate *handler = 759 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 760 761 double fontSize = FIVTENVAL; 762 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 763 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_500); 764 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_IDEOGRAPHIC); 765 766 const char *fontFamilies[] = {"Rooboto"}; 767 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 768 const char *text = "OopenHarmony"; 769 OH_Drawing_TypographyHandlerAddText(handler, text); 770 771 OH_Drawing_Typography *typographyy = OH_Drawing_CreateTypography(handler); 772 double maxWidth = EIGHUNVAL; 773 OH_Drawing_TypographyLayout(typographyy, maxWidth); 774 775 napi_value result = nullptr; 776 if (OH_Drawing_TypographyGetIdeographicBaseline(typographyy) != ZEROOVAL) { 777 napi_create_int32(env, SUCCESS, &result); 778 } else { 779 napi_create_int32(env, FAIL, &result); 780 } 781 OH_Drawing_DestroyTypography(typographyy); 782 OH_Drawing_DestroyTypographyHandler(handler); 783 return result; 784} 785 786static napi_value OHDrawingTypographyGetIdeographicBaselineNormal(napi_env env, napi_callback_info info) 787{ 788 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 789 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 790 OH_Drawing_TypographyCreate *handler = 791 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 792 793 double fontSize = FIVTENVAL; 794 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 795 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_400); 796 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_IDEOGRAPHIC); 797 798 const char *fontFamilies[] = {"Rooooboto"}; 799 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 800 const char *text = "OooopenHarmony"; 801 OH_Drawing_TypographyHandlerAddText(handler, text); 802 803 OH_Drawing_Typography *typographyy = OH_Drawing_CreateTypography(handler); 804 double maxWidth = EIGHUNVAL; 805 OH_Drawing_TypographyLayout(typographyy, maxWidth); 806 807 napi_value result = nullptr; 808 if (OH_Drawing_TypographyGetIdeographicBaseline(typographyy) != ZEROOVAL) { 809 napi_create_int32(env, SUCCESS, &result); 810 } else { 811 napi_create_int32(env, FAIL, &result); 812 } 813 OH_Drawing_DestroyTypography(typographyy); 814 OH_Drawing_DestroyTypographyHandler(handler); 815 return result; 816} 817 818static napi_value OHDrawingTypographyGetHeight(napi_env env, napi_callback_info info) 819{ 820 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 821 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 822 OH_Drawing_TypographyCreate *handler = 823 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 824 825 const char *fontFamilies[] = {"Robooto"}; 826 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 827 const char *text = "OpenHarmoony"; 828 OH_Drawing_TypographyHandlerAddText(handler, text); 829 830 OH_Drawing_Typography *ttypography = OH_Drawing_CreateTypography(handler); 831 double maxWidth = SIXFIVEVAL; 832 OH_Drawing_TypographyLayout(ttypography, maxWidth); 833 834 napi_value result = nullptr; 835 if (OH_Drawing_TypographyGetHeight(ttypography) != ZEROOVAL) { 836 napi_create_int32(env, SUCCESS, &result); 837 } else { 838 napi_create_int32(env, FAIL, &result); 839 } 840 OH_Drawing_DestroyTypography(ttypography); 841 OH_Drawing_DestroyTypographyHandler(handler); 842 return result; 843} 844 845static napi_value OHDrawingTypographyGetHeightAbnormal(napi_env env, napi_callback_info info) 846{ 847 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 848 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 849 OH_Drawing_TypographyCreate *handler = 850 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 851 852 const char *fontFamilies[] = {"Robootooo"}; 853 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 854 const char *text = "OpenHarmoooony"; 855 OH_Drawing_TypographyHandlerAddText(handler, text); 856 857 OH_Drawing_Typography *ttypography = OH_Drawing_CreateTypography(handler); 858 859 napi_value result = nullptr; 860 if (OH_Drawing_TypographyGetHeight(ttypography) != ZEROOVAL) { 861 napi_create_int32(env, SUCCESS, &result); 862 } else { 863 napi_create_int32(env, FAIL, &result); 864 } 865 OH_Drawing_DestroyTypography(ttypography); 866 OH_Drawing_DestroyTypographyHandler(handler); 867 return result; 868} 869 870static napi_value OHDrawingPenGetCapNormal(napi_env env, napi_callback_info info) 871{ 872 OH_Drawing_Pen *penval = OH_Drawing_PenCreate(); 873 OH_Drawing_PenSetCap(penval, OH_Drawing_PenLineCapStyle::LINE_FLAT_CAP); 874 napi_value result = nullptr; 875 if (OH_Drawing_PenGetCap(penval) == OH_Drawing_PenLineCapStyle::LINE_FLAT_CAP) { 876 napi_create_int32(env, SUCCESS, &result); 877 } else { 878 napi_create_int32(env, FAIL, &result); 879 } 880 OH_Drawing_PenDestroy(penval); 881 return result; 882} 883 884static napi_value OHDrawingPenSetCapNormal(napi_env env, napi_callback_info info) 885{ 886 OH_Drawing_Pen *penen = OH_Drawing_PenCreate(); 887 OH_Drawing_PenSetCap(penen, OH_Drawing_PenLineCapStyle::LINE_FLAT_CAP); 888 napi_value result = nullptr; 889 if (OH_Drawing_PenGetCap(penen) == OH_Drawing_PenLineCapStyle::LINE_FLAT_CAP) { 890 napi_create_int32(env, SUCCESS, &result); 891 } else { 892 napi_create_int32(env, FAIL, &result); 893 } 894 OH_Drawing_PenDestroy(penen); 895 return result; 896} 897 898static napi_value OHDrawingPenSetJoinNormal(napi_env env, napi_callback_info info) 899{ 900 OH_Drawing_Pen *penval = OH_Drawing_PenCreate(); 901 OH_Drawing_PenSetJoin(penval, OH_Drawing_PenLineJoinStyle::LINE_ROUND_JOIN); 902 napi_value result = nullptr; 903 if (OH_Drawing_PenGetJoin(penval) == OH_Drawing_PenLineJoinStyle::LINE_ROUND_JOIN) { 904 napi_create_int32(env, SUCCESS, &result); 905 } else { 906 napi_create_int32(env, FAIL, &result); 907 } 908 OH_Drawing_PenDestroy(penval); 909 return result; 910} 911 912static napi_value OHDrawingPenGetJoinNormal(napi_env env, napi_callback_info info) 913{ 914 OH_Drawing_Pen *penval = OH_Drawing_PenCreate(); 915 OH_Drawing_PenSetJoin(penval, OH_Drawing_PenLineJoinStyle::LINE_MITER_JOIN); 916 napi_value result = nullptr; 917 if (OH_Drawing_PenGetJoin(penval) == OH_Drawing_PenLineJoinStyle::LINE_MITER_JOIN) { 918 napi_create_int32(env, SUCCESS, &result); 919 } else { 920 napi_create_int32(env, FAIL, &result); 921 } 922 OH_Drawing_PenDestroy(penval); 923 return result; 924} 925 926static napi_value OHDrawingPenIsAntiAliasNormal(napi_env env, napi_callback_info info) 927{ 928 napi_value result = nullptr; 929 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 930 OH_Drawing_PenSetAntiAlias(pen, true); 931 if (OH_Drawing_PenIsAntiAlias(pen)) { 932 napi_create_int32(env, SUCCESS, &result); 933 } else { 934 napi_create_int32(env, FAIL, &result); 935 } 936 OH_Drawing_PenDestroy(pen); 937 return result; 938} 939 940static napi_value OHDrawingPenSetAntiAliasNormal(napi_env env, napi_callback_info info) 941{ 942 napi_value result = nullptr; 943 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 944 OH_Drawing_PenSetAntiAlias(pen, false); 945 if (OH_Drawing_PenIsAntiAlias(pen)) { 946 napi_create_int32(env, FAIL, &result); 947 } else { 948 napi_create_int32(env, SUCCESS, &result); 949 } 950 OH_Drawing_PenDestroy(pen); 951 return result; 952} 953 954static napi_value OHDrawingBitmapBuildNormal(napi_env env, napi_callback_info info) 955{ 956 napi_value result = nullptr; 957 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 958 const unsigned int width = WIDTH; 959 const unsigned int height = HEIGHT; 960 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 961 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 962 if (width == OH_Drawing_BitmapGetWidth(bitmap)) { 963 napi_create_int32(env, SUCCESS, &result); 964 } else { 965 napi_create_int32(env, FAIL, &result); 966 } 967 OH_Drawing_BitmapDestroy(bitmap); 968 return result; 969} 970 971static napi_value OHDrawingBitmapGetWidthNormal(napi_env env, napi_callback_info info) 972{ 973 napi_value result = nullptr; 974 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 975 const unsigned int width = WIDTH; 976 const unsigned int height = HEIGHT; 977 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_BGRA_8888, ALPHA_FORMAT_UNPREMUL}; 978 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 979 if (OH_Drawing_BitmapGetWidth(bitmap) == width) { 980 napi_create_int32(env, SUCCESS, &result); 981 } else { 982 napi_create_int32(env, FAIL, &result); 983 } 984 OH_Drawing_BitmapDestroy(bitmap); 985 return result; 986} 987 988static napi_value OHDrawingBitmapGetHeightNormal(napi_env env, napi_callback_info info) 989{ 990 napi_value result = nullptr; 991 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 992 const unsigned int width = WIDTH; 993 const unsigned int height = HEIGHT; 994 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_BGRA_8888, ALPHA_FORMAT_UNPREMUL}; 995 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 996 if (OH_Drawing_BitmapGetHeight(bitmap) == height) { 997 napi_create_int32(env, SUCCESS, &result); 998 } else { 999 napi_create_int32(env, FAIL, &result); 1000 } 1001 OH_Drawing_BitmapDestroy(bitmap); 1002 return result; 1003} 1004 1005static napi_value OHDrawingBitmapGetPixelsNormal(napi_env env, napi_callback_info info) 1006{ 1007 napi_value result = nullptr; 1008 OH_Drawing_Bitmap *bitmapp = OH_Drawing_BitmapCreate(); 1009 const unsigned int width = WIDTH; 1010 const unsigned int height = HEIGHT; 1011 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_BGRA_8888, ALPHA_FORMAT_UNPREMUL}; 1012 OH_Drawing_BitmapBuild(bitmapp, width, height, &bitmapFormat); 1013 if (OH_Drawing_BitmapGetPixels(bitmapp) == nullptr) { 1014 napi_create_int32(env, FAIL, &result); 1015 } else { 1016 napi_create_int32(env, SUCCESS, &result); 1017 } 1018 OH_Drawing_BitmapDestroy(bitmapp); 1019 return result; 1020} 1021 1022static napi_value OHDrawingBrushIsAntiAliasNormal(napi_env env, napi_callback_info info) 1023{ 1024 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1025 OH_Drawing_BrushSetAntiAlias(brush, true); 1026 napi_value result = nullptr; 1027 if (OH_Drawing_BrushIsAntiAlias(brush) == true) { 1028 napi_create_int32(env, SUCCESS, &result); 1029 } else { 1030 napi_create_int32(env, FAIL, &result); 1031 } 1032 OH_Drawing_BrushDestroy(brush); 1033 return result; 1034} 1035 1036static napi_value OHDrawingBrushSetAntiAliasNormal(napi_env env, napi_callback_info info) 1037{ 1038 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1039 OH_Drawing_BrushSetAntiAlias(brush, false); 1040 napi_value result = nullptr; 1041 if (OH_Drawing_BrushIsAntiAlias(brush) == false) { 1042 napi_create_int32(env, SUCCESS, &result); 1043 } else { 1044 napi_create_int32(env, FAIL, &result); 1045 } 1046 OH_Drawing_BrushDestroy(brush); 1047 return result; 1048} 1049 1050static napi_value OHDrawingBrushGetColorNormal(napi_env env, napi_callback_info info) 1051{ 1052 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1053 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF)); 1054 napi_value result = nullptr; 1055 if (OH_Drawing_BrushGetColor(brush) != 0xFFFFFFFF) { 1056 napi_create_int32(env, FAIL, &result); 1057 } else { 1058 napi_create_int32(env, SUCCESS, &result); 1059 } 1060 OH_Drawing_BrushDestroy(brush); 1061 return result; 1062} 1063 1064static napi_value OHDrawingBrushSetColorNormal(napi_env env, napi_callback_info info) 1065{ 1066 OH_Drawing_Brush *brushh = OH_Drawing_BrushCreate(); 1067 OH_Drawing_BrushSetColor(brushh, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF)); 1068 napi_value result = nullptr; 1069 if (OH_Drawing_BrushGetColor(brushh) != 0xFFFFFFFF) { 1070 napi_create_int32(env, FAIL, &result); 1071 } else { 1072 napi_create_int32(env, SUCCESS, &result); 1073 } 1074 OH_Drawing_BrushDestroy(brushh); 1075 return result; 1076} 1077 1078static napi_value OHDrawingPenGetColorNormal(napi_env env, napi_callback_info info) 1079{ 1080 napi_value result = nullptr; 1081 OH_Drawing_Pen *peen = OH_Drawing_PenCreate(); 1082 OH_Drawing_PenSetColor(peen, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF)); 1083 if (OH_Drawing_PenGetColor(peen) == 0xFFFFFFFF) { 1084 napi_create_int32(env, SUCCESS, &result); 1085 } else { 1086 napi_create_int32(env, FAIL, &result); 1087 } 1088 OH_Drawing_PenDestroy(peen); 1089 return result; 1090} 1091 1092static napi_value OHDrawingPenSetColorNormal(napi_env env, napi_callback_info info) 1093{ 1094 napi_value result = nullptr; 1095 OH_Drawing_Pen *ppen = OH_Drawing_PenCreate(); 1096 OH_Drawing_PenSetColor(ppen, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF)); 1097 if (OH_Drawing_PenGetColor(ppen) == 0xFFFFFFFF) { 1098 napi_create_int32(env, SUCCESS, &result); 1099 } else { 1100 napi_create_int32(env, FAIL, &result); 1101 } 1102 OH_Drawing_PenDestroy(ppen); 1103 return result; 1104} 1105 1106static napi_value OHDrawingPenGetWidthNormal(napi_env env, napi_callback_info info) 1107{ 1108 napi_value result = nullptr; 1109 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1110 OH_Drawing_PenSetWidth(pen, MINUSTENVAL); 1111 if (OH_Drawing_PenGetWidth(pen) == MINUSTENVAL) { 1112 napi_create_int32(env, SUCCESS, &result); 1113 } else { 1114 napi_create_int32(env, FAIL, &result); 1115 } 1116 OH_Drawing_PenDestroy(pen); 1117 return result; 1118} 1119 1120static napi_value OHDrawingPenSetWidthNormal(napi_env env, napi_callback_info info) 1121{ 1122 napi_value result = nullptr; 1123 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1124 OH_Drawing_PenSetWidth(pen, MINUSFIVEVAL); 1125 if (OH_Drawing_PenGetWidth(pen) == MINUSFIVEVAL) { 1126 napi_create_int32(env, SUCCESS, &result); 1127 } else { 1128 napi_create_int32(env, FAIL, &result); 1129 } 1130 OH_Drawing_PenDestroy(pen); 1131 return result; 1132} 1133 1134static napi_value OHDrawingPenGetMiterLimitNormal(napi_env env, napi_callback_info info) 1135{ 1136 napi_value result = nullptr; 1137 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1138 OH_Drawing_PenSetMiterLimit(pen, MINUSTENVAL); 1139 if (OH_Drawing_PenGetMiterLimit(pen) == MINUSTENVAL) { 1140 napi_create_int32(env, SUCCESS, &result); 1141 } else { 1142 napi_create_int32(env, FAIL, &result); 1143 } 1144 OH_Drawing_PenDestroy(pen); 1145 return result; 1146} 1147 1148static napi_value OHDrawingPenSetMiterLimitNormal(napi_env env, napi_callback_info info) 1149{ 1150 napi_value result = nullptr; 1151 OH_Drawing_Pen *penn = OH_Drawing_PenCreate(); 1152 OH_Drawing_PenSetMiterLimit(penn, MINUSFIVEVAL); 1153 if (OH_Drawing_PenGetMiterLimit(penn) == MINUSFIVEVAL) { 1154 napi_create_int32(env, SUCCESS, &result); 1155 } else { 1156 napi_create_int32(env, FAIL, &result); 1157 } 1158 OH_Drawing_PenDestroy(penn); 1159 return result; 1160} 1161 1162static napi_value OHDrawingColorSetArgbNormal(napi_env env, napi_callback_info info) 1163{ 1164 OH_Drawing_Brush *brushs = OH_Drawing_BrushCreate(); 1165 napi_value result = nullptr; 1166 OH_Drawing_BrushSetColor(brushs, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF)); 1167 if (OH_Drawing_BrushGetColor(brushs) == 0xFFFFFFFF) { 1168 napi_create_int32(env, SUCCESS, &result); 1169 } else { 1170 napi_create_int32(env, FAIL, &result); 1171 } 1172 OH_Drawing_BrushDestroy(brushs); 1173 return result; 1174} 1175 1176static napi_value OHDrawingTypographyLayoutNormal(napi_env env, napi_callback_info info) 1177{ 1178 napi_value result = nullptr; 1179 OH_Drawing_TypographyStyle *typoStylee = OH_Drawing_CreateTypographyStyle(); 1180 OH_Drawing_TypographyCreate *handler = 1181 OH_Drawing_CreateTypographyHandler(typoStylee, OH_Drawing_CreateFontCollection()); 1182 OH_Drawing_Typography *typographyy = OH_Drawing_CreateTypography(handler); 1183 double maxWidth = MINUSEIGHUNVAL; 1184 OH_Drawing_TypographyLayout(typographyy, maxWidth); 1185 if (maxWidth == OH_Drawing_TypographyGetMaxWidth(typographyy)) { 1186 napi_create_int32(env, SUCCESS, &result); 1187 } else { 1188 napi_create_int32(env, FAIL, &result); 1189 } 1190 OH_Drawing_DestroyTypography(typographyy); 1191 OH_Drawing_DestroyTypographyHandler(handler); 1192 return result; 1193} 1194 1195static napi_value OHDrawingTypographyGetMaxWidthNormal(napi_env env, napi_callback_info info) 1196{ 1197 napi_value result = nullptr; 1198 OH_Drawing_TypographyStyle *typoStylee = OH_Drawing_CreateTypographyStyle(); 1199 OH_Drawing_TypographyCreate *handler = 1200 OH_Drawing_CreateTypographyHandler(typoStylee, OH_Drawing_CreateFontCollection()); 1201 OH_Drawing_Typography *typographyy = OH_Drawing_CreateTypography(handler); 1202 double maxWidth = -700.0; 1203 OH_Drawing_TypographyLayout(typographyy, maxWidth); 1204 if (maxWidth == OH_Drawing_TypographyGetMaxWidth(typographyy)) { 1205 napi_create_int32(env, SUCCESS, &result); 1206 } else { 1207 napi_create_int32(env, FAIL, &result); 1208 } 1209 OH_Drawing_DestroyTypography(typographyy); 1210 OH_Drawing_DestroyTypographyHandler(handler); 1211 return result; 1212} 1213 1214static napi_value OHDrawingTypographyGetMinIntrinsicWidthNormal(napi_env env, napi_callback_info info) 1215{ 1216 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1217 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1218 OH_Drawing_TypographyCreate *handler = 1219 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 1220 1221 double fontSize = THRTENVAL; 1222 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1223 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_400); 1224 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 1225 1226 const char *fontFamilies[] = {"Roboooto"}; 1227 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 1228 OH_Drawing_TypographyHandlerPushTextStyle(handler, txtStyle); 1229 1230 const char *text = "OpennnnHarmony\n"; 1231 OH_Drawing_TypographyHandlerAddText(handler, text); 1232 OH_Drawing_TypographyHandlerPopTextStyle(handler); 1233 1234 OH_Drawing_Typography *typographyyy = OH_Drawing_CreateTypography(handler); 1235 double maxWidth = MINUSEIGHUNVAL; 1236 OH_Drawing_TypographyLayout(typographyyy, maxWidth); 1237 1238 napi_value result = nullptr; 1239 double minIntrinsicWidth = OH_Drawing_TypographyGetMinIntrinsicWidth(typographyyy); 1240 double maxIntrinsicWidth = OH_Drawing_TypographyGetMaxIntrinsicWidth(typographyyy); 1241 if (minIntrinsicWidth <= maxIntrinsicWidth) { 1242 napi_create_int32(env, SUCCESS, &result); 1243 } else { 1244 napi_create_int32(env, FAIL, &result); 1245 } 1246 OH_Drawing_DestroyTypography(typographyyy); 1247 OH_Drawing_DestroyTypographyHandler(handler); 1248 return result; 1249} 1250 1251static napi_value OHDrawingTypographyGetMaxIntrinsicWidthNormal(napi_env env, napi_callback_info info) 1252{ 1253 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1254 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1255 OH_Drawing_TypographyCreate *handlerrr = 1256 OH_Drawing_CreateTypographyHandler(typoStyle, OH_Drawing_CreateFontCollection()); 1257 1258 double fontSize = THRTENVAL; 1259 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1260 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_400); 1261 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 1262 1263 const char *fontFamilies[] = {"Roboooooto"}; 1264 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 1265 OH_Drawing_TypographyHandlerPushTextStyle(handlerrr, txtStyle); 1266 1267 const char *text = "OpennnnHarmoooony\n"; 1268 OH_Drawing_TypographyHandlerAddText(handlerrr, text); 1269 OH_Drawing_TypographyHandlerPopTextStyle(handlerrr); 1270 1271 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handlerrr); 1272 double maxWidth = MINUSSENFIVEVAL; 1273 OH_Drawing_TypographyLayout(typography, maxWidth); 1274 1275 napi_value result = nullptr; 1276 double minIntrinsicWidth = OH_Drawing_TypographyGetMinIntrinsicWidth(typography); 1277 double maxIntrinsicWidth = OH_Drawing_TypographyGetMaxIntrinsicWidth(typography); 1278 if (minIntrinsicWidth <= maxIntrinsicWidth) { 1279 napi_create_int32(env, SUCCESS, &result); 1280 } else { 1281 napi_create_int32(env, FAIL, &result); 1282 } 1283 OH_Drawing_DestroyTypography(typography); 1284 OH_Drawing_DestroyTypographyHandler(handlerrr); 1285 return result; 1286} 1287 1288static napi_value OHDrawingCreateTypographyStyleAnormal(napi_env env, napi_callback_info info) 1289{ 1290 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1291 OH_Drawing_SetTypographyTextDirection(typoStyle, TEXT_DIRECTION_LTR); 1292 OH_Drawing_SetTypographyTextAlign(typoStyle, TEXT_ALIGN_LEFT); 1293 napi_value result = nullptr; 1294 if (typoStyle != nullptr) { 1295 napi_create_int32(env, SUCCESS, &result); 1296 } else { 1297 napi_create_int32(env, FAIL, &result); 1298 } 1299 OH_Drawing_DestroyTypographyStyle(typoStyle); 1300 return result; 1301} 1302 1303static napi_value OHDrawingCreateTypographyStyleBnormal(napi_env env, napi_callback_info info) 1304{ 1305 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1306 OH_Drawing_SetTypographyTextDirection(typoStyle, TEXT_DIRECTION_RTL); 1307 OH_Drawing_SetTypographyTextAlign(typoStyle, TEXT_ALIGN_LEFT); 1308 napi_value result = nullptr; 1309 if (typoStyle != nullptr) { 1310 napi_create_int32(env, SUCCESS, &result); 1311 } else { 1312 napi_create_int32(env, FAIL, &result); 1313 } 1314 OH_Drawing_DestroyTypographyStyle(typoStyle); 1315 return result; 1316} 1317 1318static napi_value OHDrawingCreateTypographyStyleCnormal(napi_env env, napi_callback_info info) 1319{ 1320 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1321 OH_Drawing_SetTypographyTextDirection(typoStyle, TEXT_DIRECTION_RTL); 1322 OH_Drawing_SetTypographyTextAlign(typoStyle, TEXT_ALIGN_RIGHT); 1323 napi_value result = nullptr; 1324 if (typoStyle != nullptr) { 1325 napi_create_int32(env, SUCCESS, &result); 1326 } else { 1327 napi_create_int32(env, FAIL, &result); 1328 } 1329 OH_Drawing_DestroyTypographyStyle(typoStyle); 1330 return result; 1331} 1332 1333static napi_value OHDrawingCreateTypographyStyleDnormal(napi_env env, napi_callback_info info) 1334{ 1335 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1336 OH_Drawing_SetTypographyTextDirection(typoStyle, TEXT_DIRECTION_RTL); 1337 OH_Drawing_SetTypographyTextAlign(typoStyle, TEXT_ALIGN_CENTER); 1338 napi_value result = nullptr; 1339 if (typoStyle != nullptr) { 1340 napi_create_int32(env, SUCCESS, &result); 1341 } else { 1342 napi_create_int32(env, FAIL, &result); 1343 } 1344 OH_Drawing_DestroyTypographyStyle(typoStyle); 1345 return result; 1346} 1347 1348static napi_value OHDrawingCreateTypographyStyleEnormal(napi_env env, napi_callback_info info) 1349{ 1350 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1351 OH_Drawing_SetTypographyTextDirection(typoStyle, TEXT_DIRECTION_LTR); 1352 OH_Drawing_SetTypographyTextAlign(typoStyle, TEXT_ALIGN_CENTER); 1353 napi_value result = nullptr; 1354 if (typoStyle != nullptr) { 1355 napi_create_int32(env, SUCCESS, &result); 1356 } else { 1357 napi_create_int32(env, FAIL, &result); 1358 } 1359 OH_Drawing_DestroyTypographyStyle(typoStyle); 1360 return result; 1361} 1362 1363static napi_value OHDrawingCreateTypographyStyleFnormal(napi_env env, napi_callback_info info) 1364{ 1365 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1366 OH_Drawing_SetTypographyTextMaxLines(typoStyle, ONEHUNVAL); 1367 napi_value result = nullptr; 1368 if (typoStyle != nullptr) { 1369 napi_create_int32(env, SUCCESS, &result); 1370 } else { 1371 napi_create_int32(env, FAIL, &result); 1372 } 1373 OH_Drawing_DestroyTypographyStyle(typoStyle); 1374 return result; 1375} 1376 1377static napi_value OHDrawingCreateTextStyleAnormal(napi_env env, napi_callback_info info) 1378{ 1379 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1380 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF); 1381 OH_Drawing_SetTextStyleColor(txtStyle, color); 1382 napi_value result = nullptr; 1383 if (txtStyle != nullptr) { 1384 napi_create_int32(env, SUCCESS, &result); 1385 } else { 1386 napi_create_int32(env, FAIL, &result); 1387 } 1388 OH_Drawing_DestroyTextStyle(txtStyle); 1389 return result; 1390} 1391 1392static napi_value OHDrawingCreateTextStyleBnormal(napi_env env, napi_callback_info info) 1393{ 1394 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1395 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0x00, 0x00, 0x00); 1396 OH_Drawing_SetTextStyleColor(txtStyle, color); 1397 napi_value result = nullptr; 1398 if (txtStyle != nullptr) { 1399 napi_create_int32(env, SUCCESS, &result); 1400 } else { 1401 napi_create_int32(env, FAIL, &result); 1402 } 1403 OH_Drawing_DestroyTextStyle(txtStyle); 1404 return result; 1405} 1406 1407static napi_value OHDrawingCreateTextStyleCnormal(napi_env env, napi_callback_info info) 1408{ 1409 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1410 double fontSize = EIGTENVAL; 1411 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1412 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_100); 1413 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 1414 OH_Drawing_SetTextStyleFontHeight(txtStyle, ONEVAL); 1415 napi_value result = nullptr; 1416 if (txtStyle != nullptr) { 1417 napi_create_int32(env, SUCCESS, &result); 1418 } else { 1419 napi_create_int32(env, FAIL, &result); 1420 } 1421 OH_Drawing_DestroyTextStyle(txtStyle); 1422 return result; 1423} 1424 1425static napi_value OHDrawingCreateTextStyleDnormal(napi_env env, napi_callback_info info) 1426{ 1427 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1428 double fontSize = EIGTENVAL; 1429 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1430 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_200); 1431 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 1432 OH_Drawing_SetTextStyleFontHeight(txtStyle, ONEVAL); 1433 napi_value result = nullptr; 1434 if (txtStyle != nullptr) { 1435 napi_create_int32(env, SUCCESS, &result); 1436 } else { 1437 napi_create_int32(env, FAIL, &result); 1438 } 1439 OH_Drawing_DestroyTextStyle(txtStyle); 1440 return result; 1441} 1442 1443static napi_value OHDrawingCreateTextStyleEnormal(napi_env env, napi_callback_info info) 1444{ 1445 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1446 double fontSize = EIGTENVAL; 1447 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1448 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_300); 1449 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 1450 OH_Drawing_SetTextStyleFontHeight(txtStyle, ONEVAL); 1451 napi_value result = nullptr; 1452 if (txtStyle != nullptr) { 1453 napi_create_int32(env, SUCCESS, &result); 1454 } else { 1455 napi_create_int32(env, FAIL, &result); 1456 } 1457 OH_Drawing_DestroyTextStyle(txtStyle); 1458 return result; 1459} 1460 1461static napi_value OHDrawingCreateTextStyleFnormal(napi_env env, napi_callback_info info) 1462{ 1463 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1464 double fontSize = EIGTENVAL; 1465 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1466 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_400); 1467 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_ALPHABETIC); 1468 OH_Drawing_SetTextStyleFontHeight(txtStyle, ONEVAL); 1469 napi_value result = nullptr; 1470 if (txtStyle != nullptr) { 1471 napi_create_int32(env, SUCCESS, &result); 1472 } else { 1473 napi_create_int32(env, FAIL, &result); 1474 } 1475 OH_Drawing_DestroyTextStyle(txtStyle); 1476 return result; 1477} 1478 1479static napi_value OHDrawingCreateTextStyleGnormal(napi_env env, napi_callback_info info) 1480{ 1481 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1482 double fontSize = EIGTENVAL; 1483 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1484 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_100); 1485 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_IDEOGRAPHIC); 1486 OH_Drawing_SetTextStyleFontHeight(txtStyle, ONEVAL); 1487 napi_value result = nullptr; 1488 if (txtStyle != nullptr) { 1489 napi_create_int32(env, SUCCESS, &result); 1490 } else { 1491 napi_create_int32(env, FAIL, &result); 1492 } 1493 OH_Drawing_DestroyTextStyle(txtStyle); 1494 return result; 1495} 1496 1497static napi_value OHDrawingCreateTextStyleHnormal(napi_env env, napi_callback_info info) 1498{ 1499 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1500 double fontSize = EIGTENVAL; 1501 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1502 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_200); 1503 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_IDEOGRAPHIC); 1504 OH_Drawing_SetTextStyleFontHeight(txtStyle, ONEVAL); 1505 napi_value result = nullptr; 1506 if (txtStyle != nullptr) { 1507 napi_create_int32(env, SUCCESS, &result); 1508 } else { 1509 napi_create_int32(env, FAIL, &result); 1510 } 1511 OH_Drawing_DestroyTextStyle(txtStyle); 1512 return result; 1513} 1514 1515static napi_value OHDrawingCreateTextStyleInormal(napi_env env, napi_callback_info info) 1516{ 1517 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1518 double fontSize = EIGTENVAL; 1519 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1520 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_300); 1521 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_IDEOGRAPHIC); 1522 OH_Drawing_SetTextStyleFontHeight(txtStyle, ONEVAL); 1523 napi_value result = nullptr; 1524 if (txtStyle != nullptr) { 1525 napi_create_int32(env, SUCCESS, &result); 1526 } else { 1527 napi_create_int32(env, FAIL, &result); 1528 } 1529 OH_Drawing_DestroyTextStyle(txtStyle); 1530 return result; 1531} 1532 1533static napi_value OHDrawingCreateTextStyleJnormal(napi_env env, napi_callback_info info) 1534{ 1535 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1536 double fontSize = EIGTENVAL; 1537 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1538 OH_Drawing_SetTextStyleFontWeight(txtStyle, FONT_WEIGHT_400); 1539 OH_Drawing_SetTextStyleBaseLine(txtStyle, TEXT_BASELINE_IDEOGRAPHIC); 1540 OH_Drawing_SetTextStyleFontHeight(txtStyle, ONEVAL); 1541 napi_value result = nullptr; 1542 if (txtStyle != nullptr) { 1543 napi_create_int32(env, SUCCESS, &result); 1544 } else { 1545 napi_create_int32(env, FAIL, &result); 1546 } 1547 OH_Drawing_DestroyTextStyle(txtStyle); 1548 return result; 1549} 1550 1551static napi_value OHDrawingCreateTextStyleKnormal(napi_env env, napi_callback_info info) 1552{ 1553 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1554 OH_Drawing_SetTextStyleDecoration(txtStyle, TEXT_DECORATION_NONE); 1555 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0x00, 0x00, 0x00); 1556 OH_Drawing_SetTextStyleDecorationColor(txtStyle, color); 1557 napi_value result = nullptr; 1558 if (txtStyle != nullptr) { 1559 napi_create_int32(env, SUCCESS, &result); 1560 } else { 1561 napi_create_int32(env, FAIL, &result); 1562 } 1563 OH_Drawing_DestroyTextStyle(txtStyle); 1564 return result; 1565} 1566 1567static napi_value OHDrawingCreateTextStyleLnormal(napi_env env, napi_callback_info info) 1568{ 1569 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1570 OH_Drawing_SetTextStyleDecoration(txtStyle, TEXT_DECORATION_UNDERLINE); 1571 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0x00, 0x00, 0x00); 1572 OH_Drawing_SetTextStyleDecorationColor(txtStyle, color); 1573 napi_value result = nullptr; 1574 if (txtStyle != nullptr) { 1575 napi_create_int32(env, SUCCESS, &result); 1576 } else { 1577 napi_create_int32(env, FAIL, &result); 1578 } 1579 OH_Drawing_DestroyTextStyle(txtStyle); 1580 return result; 1581} 1582 1583static napi_value OHDrawingCreateTextStyleMnormal(napi_env env, napi_callback_info info) 1584{ 1585 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1586 OH_Drawing_SetTextStyleDecoration(txtStyle, TEXT_DECORATION_NONE); 1587 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF); 1588 OH_Drawing_SetTextStyleDecorationColor(txtStyle, color); 1589 napi_value result = nullptr; 1590 if (txtStyle != nullptr) { 1591 napi_create_int32(env, SUCCESS, &result); 1592 } else { 1593 napi_create_int32(env, FAIL, &result); 1594 } 1595 OH_Drawing_DestroyTextStyle(txtStyle); 1596 return result; 1597} 1598 1599static napi_value OHDrawingCreateTextStyleNnormal(napi_env env, napi_callback_info info) 1600{ 1601 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1602 OH_Drawing_SetTextStyleDecoration(txtStyle, TEXT_DECORATION_UNDERLINE); 1603 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF); 1604 OH_Drawing_SetTextStyleDecorationColor(txtStyle, color); 1605 napi_value result = nullptr; 1606 if (txtStyle != nullptr) { 1607 napi_create_int32(env, SUCCESS, &result); 1608 } else { 1609 napi_create_int32(env, FAIL, &result); 1610 } 1611 OH_Drawing_DestroyTextStyle(txtStyle); 1612 return result; 1613} 1614 1615static napi_value OHDrawingCreateTextStyleOnormal(napi_env env, napi_callback_info info) 1616{ 1617 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1618 const char *fontFamilies[] = {"Roboto"}; 1619 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 1620 OH_Drawing_SetTextStyleFontStyle(txtStyle, FONT_STYLE_NORMAL); 1621 OH_Drawing_SetTextStyleLocale(txtStyle, "en"); 1622 napi_value result = nullptr; 1623 if (txtStyle != nullptr) { 1624 napi_create_int32(env, SUCCESS, &result); 1625 } else { 1626 napi_create_int32(env, FAIL, &result); 1627 } 1628 OH_Drawing_DestroyTextStyle(txtStyle); 1629 return result; 1630} 1631 1632static napi_value OHDrawingCreateTextStylePnormal(napi_env env, napi_callback_info info) 1633{ 1634 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1635 const char *fontFamilies[] = {"Roboto"}; 1636 OH_Drawing_SetTextStyleFontFamilies(txtStyle, ONEVAL, fontFamilies); 1637 OH_Drawing_SetTextStyleFontStyle(txtStyle, FONT_STYLE_ITALIC); 1638 OH_Drawing_SetTextStyleLocale(txtStyle, "en"); 1639 napi_value result = nullptr; 1640 if (txtStyle != nullptr) { 1641 napi_create_int32(env, SUCCESS, &result); 1642 } else { 1643 napi_create_int32(env, FAIL, &result); 1644 } 1645 OH_Drawing_DestroyTextStyle(txtStyle); 1646 return result; 1647} 1648 1649static napi_value OHDrawingCreateTextStyleQnormal(napi_env env, napi_callback_info info) 1650{ 1651 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1652 OH_Drawing_SetTextStyleDecoration(txtStyle, TEXT_DECORATION_OVERLINE); 1653 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00); 1654 OH_Drawing_SetTextStyleDecorationColor(txtStyle, color); 1655 napi_value result = nullptr; 1656 if (txtStyle != nullptr) { 1657 napi_create_int32(env, SUCCESS, &result); 1658 } else { 1659 napi_create_int32(env, FAIL, &result); 1660 } 1661 OH_Drawing_DestroyTextStyle(txtStyle); 1662 return result; 1663} 1664 1665static napi_value OHDrawingCreateTextStyleRnormal(napi_env env, napi_callback_info info) 1666{ 1667 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1668 OH_Drawing_SetTextStyleDecoration(txtStyle, TEXT_DECORATION_OVERLINE); 1669 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF); 1670 OH_Drawing_SetTextStyleDecorationColor(txtStyle, color); 1671 napi_value result = nullptr; 1672 if (txtStyle != nullptr) { 1673 napi_create_int32(env, SUCCESS, &result); 1674 } else { 1675 napi_create_int32(env, FAIL, &result); 1676 } 1677 OH_Drawing_DestroyTextStyle(txtStyle); 1678 return result; 1679} 1680 1681static napi_value OHDrawingCreateTextStyleSnormal(napi_env env, napi_callback_info info) 1682{ 1683 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1684 OH_Drawing_SetTextStyleDecoration(txtStyle, TEXT_DECORATION_LINE_THROUGH); 1685 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00); 1686 OH_Drawing_SetTextStyleDecorationColor(txtStyle, color); 1687 napi_value result = nullptr; 1688 if (txtStyle != nullptr) { 1689 napi_create_int32(env, SUCCESS, &result); 1690 } else { 1691 napi_create_int32(env, FAIL, &result); 1692 } 1693 OH_Drawing_DestroyTextStyle(txtStyle); 1694 return result; 1695} 1696 1697static napi_value OHDrawingCreateTextStyleTnormal(napi_env env, napi_callback_info info) 1698{ 1699 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1700 OH_Drawing_SetTextStyleDecoration(txtStyle, TEXT_DECORATION_LINE_THROUGH); 1701 uint32_t color = OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF); 1702 OH_Drawing_SetTextStyleDecorationColor(txtStyle, color); 1703 napi_value result = nullptr; 1704 if (txtStyle != nullptr) { 1705 napi_create_int32(env, SUCCESS, &result); 1706 } else { 1707 napi_create_int32(env, FAIL, &result); 1708 } 1709 OH_Drawing_DestroyTextStyle(txtStyle); 1710 return result; 1711} 1712 1713static OH_Drawing_TypographyCreate *TypographyCreate() 1714{ 1715 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1716 OH_Drawing_FontCollection *fontCollection = OH_Drawing_CreateFontCollection(); 1717 OH_Drawing_TypographyCreate *handler = OH_Drawing_CreateTypographyHandler(typoStyle, fontCollection); 1718 return handler; 1719} 1720 1721static double TypographyGetLongestLine(OH_Drawing_TypographyCreate *handler, int fontSize) 1722{ 1723 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1724 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1725 OH_Drawing_TypographyHandlerPushTextStyle(handler, txtStyle); 1726 const char *text = "test/n"; 1727 OH_Drawing_TypographyHandlerAddText(handler, text); 1728 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 1729 double maxWidth = 800; 1730 OH_Drawing_TypographyLayout(typography, maxWidth); 1731 double len = OH_Drawing_TypographyGetLongestLine(typography); 1732 OH_Drawing_DestroyTypography(typography); 1733 return len; 1734} 1735 1736static double TypographyGetLongestLineWithIndent(OH_Drawing_TypographyCreate *handler, int fontSize) 1737{ 1738 OH_Drawing_TextStyle *txtStyle = OH_Drawing_CreateTextStyle(); 1739 OH_Drawing_SetTextStyleFontSize(txtStyle, fontSize); 1740 OH_Drawing_TypographyHandlerPushTextStyle(handler, txtStyle); 1741 const char *text = "test/n"; 1742 OH_Drawing_TypographyHandlerAddText(handler, text); 1743 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 1744 double maxWidth = 800; 1745 OH_Drawing_TypographyLayout(typography, maxWidth); 1746 double len = OH_Drawing_TypographyGetLongestLineWithIndent(typography); 1747 OH_Drawing_DestroyTypography(typography); 1748 return len; 1749} 1750 1751static napi_value OHDrawingTypographyHandlerAddText(napi_env env, napi_callback_info info) 1752{ 1753 napi_value result = nullptr; 1754 OH_Drawing_TypographyCreate *handlerOne = TypographyCreate(); 1755 OH_Drawing_TypographyCreate *handlerTwo = TypographyCreate(); 1756 int fontSizeOne = 15; 1757 int fontSizeTwo = 30; 1758 double lenOne = TypographyGetLongestLine(handlerOne, fontSizeOne); 1759 double lenTwo = TypographyGetLongestLine(handlerTwo, fontSizeTwo); 1760 if (lenOne < lenTwo && lenOne != ZEROVAL && lenTwo != ZEROVAL) { 1761 OH_Drawing_TypographyHandlerPopTextStyle(handlerOne); 1762 OH_Drawing_TypographyHandlerPopTextStyle(handlerTwo); 1763 napi_create_int32(env, SUCCESS, &result); 1764 } else { 1765 napi_create_int32(env, FAIL, &result); 1766 } 1767 OH_Drawing_DestroyTypographyHandler(handlerOne); 1768 OH_Drawing_DestroyTypographyHandler(handlerTwo); 1769 return result; 1770} 1771 1772static napi_value OHDrawingTypographyHandlerAddTextAanormal(napi_env env, napi_callback_info info) 1773{ 1774 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1775 OH_Drawing_FontCollection *fontCollection = OH_Drawing_CreateFontCollection(); 1776 OH_Drawing_TypographyCreate *handler = OH_Drawing_CreateTypographyHandler(typoStyle, fontCollection); 1777 const char *text = ""; 1778 OH_Drawing_TypographyHandlerAddText(handler, text); 1779 OH_Drawing_Typography *typography = OH_Drawing_CreateTypography(handler); 1780 double maxWidth = 50; 1781 OH_Drawing_TypographyLayout(typography, maxWidth); 1782 napi_value result = nullptr; 1783 1784 double len = OH_Drawing_TypographyGetLongestLine(typography); 1785 if (len == MINIMUMVALUE) { 1786 napi_create_int32(env, SUCCESS, &result); 1787 } else { 1788 napi_create_int32(env, FAIL, &result); 1789 } 1790 OH_Drawing_DestroyTypography(typography); 1791 OH_Drawing_DestroyTypographyHandler(handler); 1792 return result; 1793} 1794 1795static napi_value GetCanvasResult(napi_env env, OH_Drawing_Canvas *canvas) 1796{ 1797 napi_value result = nullptr; 1798 if (canvas == nullptr) { 1799 napi_create_int32(env, FAIL, &result); 1800 } else { 1801 napi_create_int32(env, SUCCESS, &result); 1802 } 1803 OH_Drawing_CanvasDestroy(canvas); 1804 return result; 1805} 1806 1807static napi_value OHDrawingCanvasCreateBitmap(napi_env env, napi_callback_info info) 1808{ 1809 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1810 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1811 OH_Drawing_CanvasBind(canvas, bitmap); 1812 OH_Drawing_BitmapDestroy(bitmap); 1813 return GetCanvasResult(env, canvas); 1814} 1815 1816static napi_value OHDrawingCanvasCreatePen(napi_env env, napi_callback_info info) 1817{ 1818 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1819 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1820 OH_Drawing_CanvasAttachPen(canvas, pen); 1821 OH_Drawing_PenDestroy(pen); 1822 return GetCanvasResult(env, canvas); 1823} 1824 1825static napi_value OHDrawingCanvasCreateBrush(napi_env env, napi_callback_info info) 1826{ 1827 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1828 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1829 OH_Drawing_CanvasAttachBrush(canvas, brush); 1830 OH_Drawing_BrushDestroy(brush); 1831 return GetCanvasResult(env, canvas); 1832} 1833 1834static napi_value OHDrawingCanvasCreateSave(napi_env env, napi_callback_info info) 1835{ 1836 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1837 OH_Drawing_CanvasSave(canvas); 1838 OH_Drawing_CanvasRestore(canvas); 1839 return GetCanvasResult(env, canvas); 1840} 1841 1842static napi_value OHDrawingCanvasCreateDrawLine(napi_env env, napi_callback_info info) 1843{ 1844 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1845 OH_Drawing_CanvasDrawLine(canvas, POSX_1, POSY_1, POSX_2, POSY_2); 1846 return GetCanvasResult(env, canvas); 1847} 1848 1849static napi_value OHDrawingCanvasCreateDrawPath(napi_env env, napi_callback_info info) 1850{ 1851 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1852 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1853 OH_Drawing_CanvasDrawPath(canvas, path); 1854 OH_Drawing_PathDestroy(path); 1855 return GetCanvasResult(env, canvas); 1856} 1857 1858static napi_value OHDrawingCanvasCreateClear(napi_env env, napi_callback_info info) 1859{ 1860 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1861 OH_Drawing_CanvasClear(canvas, 0xffffffff); 1862 return GetCanvasResult(env, canvas); 1863} 1864 1865static napi_value OHDrawingCanvasCreateDetachPen(napi_env env, napi_callback_info info) 1866{ 1867 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1868 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1869 OH_Drawing_CanvasAttachPen(canvas, pen); 1870 OH_Drawing_CanvasDetachPen(canvas); 1871 OH_Drawing_PenDestroy(pen); 1872 return GetCanvasResult(env, canvas); 1873} 1874 1875static napi_value OHDrawingCanvasCreateDetachBrush(napi_env env, napi_callback_info info) 1876{ 1877 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1878 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1879 OH_Drawing_CanvasAttachBrush(canvas, brush); 1880 OH_Drawing_CanvasDetachBrush(canvas); 1881 OH_Drawing_BrushDestroy(brush); 1882 return GetCanvasResult(env, canvas); 1883} 1884 1885static napi_value GetPathResult(napi_env env, OH_Drawing_Path *path) 1886{ 1887 napi_value result = nullptr; 1888 if (path == nullptr) { 1889 napi_create_int32(env, FAIL, &result); 1890 } else { 1891 napi_create_int32(env, SUCCESS, &result); 1892 } 1893 OH_Drawing_PathDestroy(path); 1894 return result; 1895} 1896 1897static napi_value OHDrawingPathCreateMoveTo(napi_env env, napi_callback_info info) 1898{ 1899 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1900 OH_Drawing_PathMoveTo(path, POSX_1, POSY_1); 1901 return GetPathResult(env, path); 1902} 1903 1904static napi_value OHDrawingPathCreateLineTo(napi_env env, napi_callback_info info) 1905{ 1906 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1907 OH_Drawing_PathLineTo(path, POSX_1, POSY_1); 1908 return GetPathResult(env, path); 1909} 1910 1911static napi_value OHDrawingPathCreateArcTo(napi_env env, napi_callback_info info) 1912{ 1913 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1914 OH_Drawing_PathArcTo(path, POSX_1, POSY_1, POSX_2, POSY_2, POSX_3, POSY_3); 1915 return GetPathResult(env, path); 1916} 1917static napi_value OHDrawingPathCreateQuadTo(napi_env env, napi_callback_info info) 1918{ 1919 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1920 OH_Drawing_PathQuadTo(path, POSX_1, POSY_1, POSX_2, POSY_2); 1921 return GetPathResult(env, path); 1922} 1923static napi_value OHDrawingPathCreateCubicTo(napi_env env, napi_callback_info info) 1924{ 1925 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1926 OH_Drawing_PathCubicTo(path, POSX_1, POSY_1, POSX_2, POSY_2, POSX_3, POSY_3); 1927 return GetPathResult(env, path); 1928} 1929static napi_value OHDrawingPathCreateClose(napi_env env, napi_callback_info info) 1930{ 1931 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1932 OH_Drawing_PathClose(path); 1933 return GetPathResult(env, path); 1934} 1935static napi_value OHDrawingPathCreateReset(napi_env env, napi_callback_info info) 1936{ 1937 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1938 OH_Drawing_PathReset(path); 1939 return GetPathResult(env, path); 1940} 1941 1942static napi_value OHDrawingCreateTypographyPaint(napi_env env, napi_callback_info info) 1943{ 1944 napi_value result = nullptr; 1945 OH_Drawing_TypographyStyle *typoStyle = OH_Drawing_CreateTypographyStyle(); 1946 OH_Drawing_FontCollection *fontCollection = OH_Drawing_CreateFontCollection(); 1947 OH_Drawing_TypographyCreate *handler = OH_Drawing_CreateTypographyHandler(typoStyle, fontCollection); 1948 OH_Drawing_Typography *typographyStyle = OH_Drawing_CreateTypography(handler); 1949 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1950 OH_Drawing_TypographyPaint(typographyStyle, canvas, POSX_1, POSY_1); 1951 if (typoStyle == nullptr) { 1952 napi_create_int32(env, FAIL, &result); 1953 } else { 1954 napi_create_int32(env, SUCCESS, &result); 1955 } 1956 OH_Drawing_DestroyTypographyHandler(handler); 1957 OH_Drawing_DestroyTypographyStyle(typoStyle); 1958 OH_Drawing_DestroyFontCollection(fontCollection); 1959 OH_Drawing_CanvasDestroy(canvas); 1960 return result; 1961} 1962 1963EXTERN_C_START 1964static napi_value Init(napi_env env, napi_value exports) 1965{ 1966 napi_property_descriptor desc[] = { 1967 {"oHDrawingBitmapCreate", nullptr, OHDrawingBitmapCreate, nullptr, nullptr, nullptr, napi_default, nullptr}, 1968 {"oHDrawingBitmapBuild", nullptr, OHDrawingBitmapBuild, nullptr, nullptr, nullptr, napi_default, nullptr}, 1969 {"oHDrawingBitmapGetWidth", nullptr, OHDrawingBitmapGetWidth, nullptr, nullptr, nullptr, napi_default, nullptr}, 1970 {"oHDrawingBitmapGetHeight", nullptr, OHDrawingBitmapGetHeight, nullptr, nullptr, nullptr, napi_default, 1971 nullptr}, 1972 {"oHDrawingBitmapGetPixels", nullptr, OHDrawingBitmapGetPixels, nullptr, nullptr, nullptr, napi_default, 1973 nullptr}, 1974 1975 {"oHDrawingBrushCreate", nullptr, OHDrawingBrushCreate, nullptr, nullptr, nullptr, napi_default, nullptr}, 1976 {"oHDrawingBrushIsAntiAlias", nullptr, OHDrawingBrushIsAntiAlias, nullptr, nullptr, nullptr, napi_default, 1977 nullptr}, 1978 {"oHDrawingBrushSetAntiAlias", nullptr, OHDrawingBrushSetAntiAlias, nullptr, nullptr, nullptr, napi_default, 1979 nullptr}, 1980 {"oHDrawingBrushGetColor", nullptr, OHDrawingBrushGetColor, nullptr, nullptr, nullptr, napi_default, nullptr}, 1981 {"oHDrawingBrushSetColor", nullptr, OHDrawingBrushSetColor, nullptr, nullptr, nullptr, napi_default, nullptr}, 1982 1983 {"oHDrawingCanvasCreate", nullptr, OHDrawingCanvasCreate, nullptr, nullptr, nullptr, napi_default, nullptr}, 1984 {"oHDrawingPathCreate", nullptr, OHDrawingPathCreate, nullptr, nullptr, nullptr, napi_default, nullptr}, 1985 1986 {"oHDrawingPenCreate", nullptr, OHDrawingPenCreate, nullptr, nullptr, nullptr, napi_default, nullptr}, 1987 {"oHDrawingPenIsAntiAlias", nullptr, OHDrawingPenIsAntiAlias, nullptr, nullptr, nullptr, napi_default, nullptr}, 1988 {"oHDrawingPenSetAntiAlias", nullptr, OHDrawingPenSetAntiAlias, nullptr, nullptr, nullptr, napi_default, 1989 nullptr}, 1990 {"oHDrawingPenGetColor", nullptr, OHDrawingPenGetColor, nullptr, nullptr, nullptr, napi_default, nullptr}, 1991 {"oHDrawingPenSetColor", nullptr, OHDrawingPenSetColor, nullptr, nullptr, nullptr, napi_default, nullptr}, 1992 {"oHDrawingPenGetWidth", nullptr, OHDrawingPenGetWidth, nullptr, nullptr, nullptr, napi_default, nullptr}, 1993 {"oHDrawingPenSetWidth", nullptr, OHDrawingPenSetWidth, nullptr, nullptr, nullptr, napi_default, nullptr}, 1994 {"oHDrawingPenGetMiterLimit", nullptr, OHDrawingPenGetMiterLimit, nullptr, nullptr, nullptr, napi_default, 1995 nullptr}, 1996 {"oHDrawingPenSetMiterLimit", nullptr, OHDrawingPenSetMiterLimit, nullptr, nullptr, nullptr, napi_default, 1997 nullptr}, 1998 {"oHDrawingPenGetCap", nullptr, OHDrawingPenGetCap, nullptr, nullptr, nullptr, napi_default, nullptr}, 1999 {"oHDrawingPenSetCap", nullptr, OHDrawingPenSetCap, nullptr, nullptr, nullptr, napi_default, nullptr}, 2000 {"oHDrawingPenGetJoin", nullptr, OHDrawingPenGetJoin, nullptr, nullptr, nullptr, napi_default, nullptr}, 2001 {"oHDrawingPenSetJoin", nullptr, OHDrawingPenSetJoin, nullptr, nullptr, nullptr, napi_default, nullptr}, 2002 2003 {"oHDrawingColorSetArgb", nullptr, OHDrawingColorSetArgb, nullptr, nullptr, nullptr, napi_default, nullptr}, 2004 2005 {"oHDrawingCreateFontCollection", nullptr, OHDrawingCreateFontCollection, nullptr, nullptr, nullptr, 2006 napi_default, nullptr}, 2007 {"oHDrawingCreateTypographyStyle", nullptr, OHDrawingCreateTypographyStyle, nullptr, nullptr, nullptr, 2008 napi_default, nullptr}, 2009 2010 {"oHDrawingCreateTextStyle", nullptr, OHDrawingCreateTextStyle, nullptr, nullptr, nullptr, napi_default, 2011 nullptr}, 2012 {"oHDrawingCreateTypographyHandler", nullptr, OHDrawingCreateTypographyHandler, nullptr, nullptr, nullptr, 2013 napi_default, nullptr}, 2014 {"oHDrawingCreateTypography", nullptr, OHDrawingCreateTypography, nullptr, nullptr, nullptr, napi_default, 2015 nullptr}, 2016 {"oHDrawingTypographyLayout", nullptr, OHDrawingTypographyLayout, nullptr, nullptr, nullptr, napi_default, 2017 nullptr}, 2018 {"oHDrawingTypographyGetMaxWidth", nullptr, OHDrawingTypographyGetMaxWidth, nullptr, nullptr, nullptr, 2019 napi_default, nullptr}, 2020 2021 {"oHDrawingTypographyGetMinIntrinsicWidth", nullptr, OHDrawingTypographyGetMinIntrinsicWidth, nullptr, nullptr, 2022 nullptr, napi_default, nullptr}, 2023 {"oHDrawingTypographyGetMaxIntrinsicWidth", nullptr, OHDrawingTypographyGetMaxIntrinsicWidth, nullptr, nullptr, 2024 nullptr, napi_default, nullptr}, 2025 2026 {"oHDrawingTypographyGetLongestLine", nullptr, OHDrawingTypographyGetLongestLine, nullptr, nullptr, nullptr, 2027 napi_default, nullptr}, 2028 {"oHDrawingTypographyGetLongestLineAbnormal", nullptr, OHDrawingTypographyGetLongestLineAbnormal, nullptr, 2029 nullptr, nullptr, napi_default, nullptr}, 2030 {"oHDrawingTypographyGetLongestLineWithIndent", nullptr, OHDrawingTypographyGetLongestLineWithIndent, nullptr, 2031 nullptr, nullptr, napi_default, nullptr}, 2032 2033 {"oHDrawingTypographyGetAlphabeticBaseline", nullptr, OHDrawingTypographyGetAlphabeticBaseline, nullptr, 2034 nullptr, nullptr, napi_default, nullptr}, 2035 {"oHDrawingTypographyGetAlphabeticBaselineNormal", nullptr, OHDrawingTypographyGetAlphabeticBaselineNormal, 2036 nullptr, nullptr, nullptr, napi_default, nullptr}, 2037 2038 {"oHDrawingTypographyGetIdeographicBaseline", nullptr, OHDrawingTypographyGetIdeographicBaseline, nullptr, 2039 nullptr, nullptr, napi_default, nullptr}, 2040 {"oHDrawingTypographyGetIdeographicBaselineNormal", nullptr, OHDrawingTypographyGetIdeographicBaselineNormal, 2041 nullptr, nullptr, nullptr, napi_default, nullptr}, 2042 2043 {"oHDrawingTypographyGetHeight", nullptr, OHDrawingTypographyGetHeight, nullptr, nullptr, nullptr, napi_default, 2044 nullptr}, 2045 {"oHDrawingTypographyGetHeightAbnormal", nullptr, OHDrawingTypographyGetHeightAbnormal, nullptr, nullptr, 2046 nullptr, napi_default, nullptr}, 2047 2048 {"oHDrawingPenGetCapNormal", nullptr, OHDrawingPenGetCapNormal, nullptr, nullptr, nullptr, napi_default, 2049 nullptr}, 2050 {"oHDrawingPenSetCapNormal", nullptr, OHDrawingPenSetCapNormal, nullptr, nullptr, nullptr, napi_default, 2051 nullptr}, 2052 {"oHDrawingPenGetJoinNormal", nullptr, OHDrawingPenGetJoinNormal, nullptr, nullptr, nullptr, napi_default, 2053 nullptr}, 2054 {"oHDrawingPenSetJoinNormal", nullptr, OHDrawingPenSetJoinNormal, nullptr, nullptr, nullptr, napi_default, 2055 nullptr}, 2056 2057 {"oHDrawingPenIsAntiAliasNormal", nullptr, OHDrawingPenIsAntiAliasNormal, nullptr, nullptr, nullptr, 2058 napi_default, nullptr}, 2059 {"oHDrawingPenSetAntiAliasNormal", nullptr, OHDrawingPenSetAntiAliasNormal, nullptr, nullptr, nullptr, 2060 napi_default, nullptr}, 2061 2062 {"oHDrawingBitmapBuildNormal", nullptr, OHDrawingBitmapBuildNormal, nullptr, nullptr, nullptr, napi_default, 2063 nullptr}, 2064 {"oHDrawingBitmapGetWidthNormal", nullptr, OHDrawingBitmapGetWidthNormal, nullptr, nullptr, nullptr, 2065 napi_default, nullptr}, 2066 {"oHDrawingBitmapGetHeightNormal", nullptr, OHDrawingBitmapGetHeightNormal, nullptr, nullptr, nullptr, 2067 napi_default, nullptr}, 2068 {"oHDrawingBitmapGetPixelsNormal", nullptr, OHDrawingBitmapGetPixelsNormal, nullptr, nullptr, nullptr, 2069 napi_default, nullptr}, 2070 2071 {"oHDrawingBrushIsAntiAliasNormal", nullptr, OHDrawingBrushIsAntiAliasNormal, nullptr, nullptr, nullptr, 2072 napi_default, nullptr}, 2073 {"oHDrawingBrushSetAntiAliasNormal", nullptr, OHDrawingBrushSetAntiAliasNormal, nullptr, nullptr, nullptr, 2074 napi_default, nullptr}, 2075 2076 {"oHDrawingBrushGetColorNormal", nullptr, OHDrawingBrushGetColorNormal, nullptr, nullptr, nullptr, napi_default, 2077 nullptr}, 2078 {"oHDrawingBrushSetColorNormal", nullptr, OHDrawingBrushSetColorNormal, nullptr, nullptr, nullptr, napi_default, 2079 nullptr}, 2080 {"oHDrawingPenGetColorNormal", nullptr, OHDrawingPenGetColorNormal, nullptr, nullptr, nullptr, napi_default, 2081 nullptr}, 2082 {"oHDrawingPenSetColorNormal", nullptr, OHDrawingPenSetColorNormal, nullptr, nullptr, nullptr, napi_default, 2083 nullptr}, 2084 {"oHDrawingPenGetWidthNormal", nullptr, OHDrawingPenGetWidthNormal, nullptr, nullptr, nullptr, napi_default, 2085 nullptr}, 2086 {"oHDrawingPenSetWidthNormal", nullptr, OHDrawingPenSetWidthNormal, nullptr, nullptr, nullptr, napi_default, 2087 nullptr}, 2088 {"oHDrawingPenGetMiterLimitNormal", nullptr, OHDrawingPenGetMiterLimitNormal, nullptr, nullptr, nullptr, 2089 napi_default, nullptr}, 2090 {"oHDrawingPenSetMiterLimitNormal", nullptr, OHDrawingPenSetMiterLimitNormal, nullptr, nullptr, nullptr, 2091 napi_default, nullptr}, 2092 {"oHDrawingColorSetArgbNormal", nullptr, OHDrawingColorSetArgbNormal, nullptr, nullptr, nullptr, napi_default, 2093 nullptr}, 2094 {"oHDrawingTypographyLayoutNormal", nullptr, OHDrawingTypographyLayoutNormal, nullptr, nullptr, nullptr, 2095 napi_default, nullptr}, 2096 {"oHDrawingTypographyGetMaxWidthNormal", nullptr, OHDrawingTypographyGetMaxWidthNormal, nullptr, nullptr, 2097 nullptr, napi_default, nullptr}, 2098 {"oHDrawingTypographyGetMinIntrinsicWidthNormal", nullptr, OHDrawingTypographyGetMinIntrinsicWidthNormal, 2099 nullptr, nullptr, nullptr, napi_default, nullptr}, 2100 {"oHDrawingTypographyGetMaxIntrinsicWidthNormal", nullptr, OHDrawingTypographyGetMaxIntrinsicWidthNormal, 2101 nullptr, nullptr, nullptr, napi_default, nullptr}, 2102 2103 {"oHDrawingCreateTypographyStyleAnormal", nullptr, OHDrawingCreateTypographyStyleAnormal, nullptr, nullptr, 2104 nullptr, napi_default, nullptr}, 2105 {"oHDrawingCreateTypographyStyleBnormal", nullptr, OHDrawingCreateTypographyStyleBnormal, nullptr, nullptr, 2106 nullptr, napi_default, nullptr}, 2107 {"oHDrawingCreateTypographyStyleCnormal", nullptr, OHDrawingCreateTypographyStyleCnormal, nullptr, nullptr, 2108 nullptr, napi_default, nullptr}, 2109 {"oHDrawingCreateTypographyStyleDnormal", nullptr, OHDrawingCreateTypographyStyleDnormal, nullptr, nullptr, 2110 nullptr, napi_default, nullptr}, 2111 {"oHDrawingCreateTypographyStyleEnormal", nullptr, OHDrawingCreateTypographyStyleEnormal, nullptr, nullptr, 2112 nullptr, napi_default, nullptr}, 2113 {"oHDrawingCreateTypographyStyleFnormal", nullptr, OHDrawingCreateTypographyStyleFnormal, nullptr, nullptr, 2114 nullptr, napi_default, nullptr}, 2115 2116 {"oHDrawingCreateTextStyleAnormal", nullptr, OHDrawingCreateTextStyleAnormal, nullptr, nullptr, nullptr, 2117 napi_default, nullptr}, 2118 {"oHDrawingCreateTextStyleBnormal", nullptr, OHDrawingCreateTextStyleBnormal, nullptr, nullptr, nullptr, 2119 napi_default, nullptr}, 2120 {"oHDrawingCreateTextStyleCnormal", nullptr, OHDrawingCreateTextStyleCnormal, nullptr, nullptr, nullptr, 2121 napi_default, nullptr}, 2122 {"oHDrawingCreateTextStyleDnormal", nullptr, OHDrawingCreateTextStyleDnormal, nullptr, nullptr, nullptr, 2123 napi_default, nullptr}, 2124 {"oHDrawingCreateTextStyleEnormal", nullptr, OHDrawingCreateTextStyleEnormal, nullptr, nullptr, nullptr, 2125 napi_default, nullptr}, 2126 {"oHDrawingCreateTextStyleFnormal", nullptr, OHDrawingCreateTextStyleFnormal, nullptr, nullptr, nullptr, 2127 napi_default, nullptr}, 2128 {"oHDrawingCreateTextStyleGnormal", nullptr, OHDrawingCreateTextStyleGnormal, nullptr, nullptr, nullptr, 2129 napi_default, nullptr}, 2130 {"oHDrawingCreateTextStyleHnormal", nullptr, OHDrawingCreateTextStyleHnormal, nullptr, nullptr, nullptr, 2131 napi_default, nullptr}, 2132 {"oHDrawingCreateTextStyleInormal", nullptr, OHDrawingCreateTextStyleInormal, nullptr, nullptr, nullptr, 2133 napi_default, nullptr}, 2134 {"oHDrawingCreateTextStyleJnormal", nullptr, OHDrawingCreateTextStyleJnormal, nullptr, nullptr, nullptr, 2135 napi_default, nullptr}, 2136 {"oHDrawingCreateTextStyleKnormal", nullptr, OHDrawingCreateTextStyleKnormal, nullptr, nullptr, nullptr, 2137 napi_default, nullptr}, 2138 {"oHDrawingCreateTextStyleLnormal", nullptr, OHDrawingCreateTextStyleLnormal, nullptr, nullptr, nullptr, 2139 napi_default, nullptr}, 2140 {"oHDrawingCreateTextStyleMnormal", nullptr, OHDrawingCreateTextStyleMnormal, nullptr, nullptr, nullptr, 2141 napi_default, nullptr}, 2142 {"oHDrawingCreateTextStyleNnormal", nullptr, OHDrawingCreateTextStyleNnormal, nullptr, nullptr, nullptr, 2143 napi_default, nullptr}, 2144 {"oHDrawingCreateTextStyleOnormal", nullptr, OHDrawingCreateTextStyleOnormal, nullptr, nullptr, nullptr, 2145 napi_default, nullptr}, 2146 {"oHDrawingCreateTextStylePnormal", nullptr, OHDrawingCreateTextStylePnormal, nullptr, nullptr, nullptr, 2147 napi_default, nullptr}, 2148 {"oHDrawingCreateTextStyleQnormal", nullptr, OHDrawingCreateTextStyleQnormal, nullptr, nullptr, nullptr, 2149 napi_default, nullptr}, 2150 {"oHDrawingCreateTextStyleRnormal", nullptr, OHDrawingCreateTextStyleRnormal, nullptr, nullptr, nullptr, 2151 napi_default, nullptr}, 2152 {"oHDrawingCreateTextStyleSnormal", nullptr, OHDrawingCreateTextStyleSnormal, nullptr, nullptr, nullptr, 2153 napi_default, nullptr}, 2154 {"oHDrawingCreateTextStyleTnormal", nullptr, OHDrawingCreateTextStyleTnormal, nullptr, nullptr, nullptr, 2155 napi_default, nullptr}, 2156 2157 {"oHDrawingTypographyHandlerAddText", nullptr, OHDrawingTypographyHandlerAddText, nullptr, nullptr, nullptr, 2158 napi_default, nullptr}, 2159 {"oHDrawingTypographyHandlerAddTextAanormal", nullptr, OHDrawingTypographyHandlerAddTextAanormal, nullptr, 2160 nullptr, nullptr, napi_default, nullptr}, 2161 {"oHDrawingCanvasCreateBitmap", nullptr, OHDrawingCanvasCreateBitmap, nullptr, nullptr, nullptr, napi_default, 2162 nullptr}, 2163 {"oHDrawingCanvasCreatePen", nullptr, OHDrawingCanvasCreatePen, nullptr, nullptr, nullptr, napi_default, 2164 nullptr}, 2165 {"oHDrawingCanvasCreateBrush", nullptr, OHDrawingCanvasCreateBrush, nullptr, nullptr, nullptr, napi_default, 2166 nullptr}, 2167 {"oHDrawingCanvasCreateSave", nullptr, OHDrawingCanvasCreateSave, nullptr, nullptr, nullptr, napi_default, 2168 nullptr}, 2169 {"oHDrawingCanvasCreateDrawLine", nullptr, OHDrawingCanvasCreateDrawLine, nullptr, nullptr, nullptr, 2170 napi_default, nullptr}, 2171 {"oHDrawingCanvasCreateDrawPath", nullptr, OHDrawingCanvasCreateDrawPath, nullptr, nullptr, nullptr, 2172 napi_default, nullptr}, 2173 {"oHDrawingCanvasCreateClear", nullptr, OHDrawingCanvasCreateClear, nullptr, nullptr, nullptr, napi_default, 2174 nullptr}, 2175 {"oHDrawingCanvasCreateDetachPen", nullptr, OHDrawingCanvasCreateDetachPen, nullptr, nullptr, nullptr, 2176 napi_default, nullptr}, 2177 {"oHDrawingCanvasCreateDetachBrush", nullptr, OHDrawingCanvasCreateDetachBrush, nullptr, nullptr, nullptr, 2178 napi_default, nullptr}, 2179 {"ohDrawingPathCreateMoveTo", nullptr, OHDrawingPathCreateMoveTo, nullptr, nullptr, nullptr, napi_default, 2180 nullptr}, 2181 {"ohDrawingPathCreateLineTo", nullptr, OHDrawingPathCreateLineTo, nullptr, nullptr, nullptr, napi_default, 2182 nullptr}, 2183 {"ohDrawingPathCreateArcTo", nullptr, OHDrawingPathCreateArcTo, nullptr, nullptr, nullptr, napi_default, 2184 nullptr}, 2185 {"ohDrawingPathCreateQuadTo", nullptr, OHDrawingPathCreateQuadTo, nullptr, nullptr, nullptr, napi_default, 2186 nullptr}, 2187 {"ohDrawingPathCreateCubicTo", nullptr, OHDrawingPathCreateCubicTo, nullptr, nullptr, nullptr, napi_default, 2188 nullptr}, 2189 {"ohDrawingPathCreateClose", nullptr, OHDrawingPathCreateClose, nullptr, nullptr, nullptr, napi_default, 2190 nullptr}, 2191 {"ohDrawingPathCreateReset", nullptr, OHDrawingPathCreateReset, nullptr, nullptr, nullptr, napi_default, 2192 nullptr}, 2193 {"oHDrawingCreateTypographyPaint", nullptr, OHDrawingCreateTypographyPaint, nullptr, nullptr, nullptr, 2194 napi_default, nullptr}, 2195 }; 2196 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); 2197 return exports; 2198} 2199 2200EXTERN_C_END 2201 2202static napi_module demoModule = { 2203 .nm_version = 1, 2204 .nm_flags = 0, 2205 .nm_filename = nullptr, 2206 .nm_register_func = Init, 2207 .nm_modname = "nativeDrawing", 2208 .nm_priv = ((void *)0), 2209 .reserved = {0}, 2210}; 2211 2212extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); } 2213