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 "core/interfaces/native/node/node_image_modifier.h"
16
17 #include "effect/color_filter.h"
18
19 #include "core/common/card_scope.h"
20 #include "core/components/image/image_component.h"
21 #include "core/components/image/image_theme.h"
22 #include "core/components_ng/base/view_abstract.h"
23 #include "core/components_ng/pattern/image/image_model_ng.h"
24 #include "core/pipeline_ng/pipeline_context.h"
25
26 namespace OHOS::Ace::NG {
27 namespace {
28 constexpr int NUM_0 = 1;
29 constexpr int NUM_1 = 1;
30 constexpr int NUM_2 = 2;
31 constexpr int NUM_3 = 3;
32 constexpr int NUM_12 = 12;
33 constexpr int DEFAULT_LENGTH = 4;
34 constexpr int RESIZEABLE_VEC_LENGTH = 12;
35 constexpr CopyOptions DEFAULT_IMAGE_COPYOPTION = CopyOptions::None;
36 constexpr bool DEFAULT_SYNC_LOAD_VALUE = false;
37 constexpr ImageFit DEFAULT_OBJECT_FIT_VALUE = ImageFit::COVER;
38 constexpr bool DEFAULT_FIT_ORIGINAL_SIZE = false;
39 constexpr bool DEFAULT_DRAGGABLE = false;
40 constexpr bool DEFAULT_IMAGE_SENSITIVE = false;
41 constexpr ArkUI_Float32 DEFAULT_IMAGE_EDGE_ANTIALIASING = 0;
42 constexpr ImageResizableSlice DEFAULT_IMAGE_SLICE;
43 const std::vector<float> DEFAULT_COLOR_FILTER = { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0 };
44 constexpr int32_t LOAD_ERROR_CODE = 401;
45 constexpr int32_t IMAGE_LOAD_STATUS_INDEX = 0;
46 constexpr int32_t IMAGE_WIDTH_INDEX = 1;
47 constexpr int32_t IMAGE_HEIGHT_INDEX = 2;
48 constexpr int32_t IMAGE_COMPONENT_WIDTH_INDEX = 3;
49 constexpr int32_t IMAGE_COMPONENT_HEIGHT_INDEX = 4;
50 constexpr int32_t IMAGE_CONTENT_OFFSET_X_INDEX = 5;
51 constexpr int32_t IMAGE_CONTENT_OFFSET_Y_INDEX = 6;
52 constexpr int32_t IMAGE_CONTENT_WIDTH_INDEX = 7;
53 constexpr int32_t IMAGE_CONTENT_HEIGHT_INDEX = 8;
54 constexpr uint32_t MAX_COLOR_FILTER_SIZE = 20;
55 constexpr uint32_t ERROR_UINT_CODE = -1;
56 constexpr int32_t DEFAULT_FALSE = 0;
57 const std::vector<ResizableOption> directions = { ResizableOption::TOP, ResizableOption::RIGHT,
58 ResizableOption::BOTTOM, ResizableOption::LEFT };
59 std::string g_strValue;
60
61 enum class ResourceType : uint32_t {
62 COLOR = 10001,
63 FLOAT,
64 STRING,
65 PLURAL,
66 BOOLEAN,
67 INTARRAY,
68 INTEGER,
69 PATTERN,
70 STRARRAY,
71 MEDIA = 20000,
72 RAWFILE = 30000
73 };
74
SetOptionalBorder(std::optional<Dimension> & optionalDimension,const ArkUI_Float32 * values,ArkUI_Int32 valuesSize,ArkUI_Int32 & offset)75 void SetOptionalBorder(std::optional<Dimension>& optionalDimension, const ArkUI_Float32* values, ArkUI_Int32 valuesSize,
76 ArkUI_Int32& offset)
77 {
78 bool hasValue = static_cast<bool>(values[offset]);
79 if (hasValue) {
80 optionalDimension =
81 Dimension(values[offset + NUM_1], static_cast<OHOS::Ace::DimensionUnit>(values[offset + NUM_2]));
82 }
83 offset = offset + NUM_3;
84 }
85
SetCalcDimension(std::optional<CalcDimension> & optDimension,const ArkUIStringAndFloat * options,ArkUI_Int32 optionsLength,ArkUI_Int32 offset)86 bool SetCalcDimension(std::optional<CalcDimension>& optDimension, const ArkUIStringAndFloat* options,
87 ArkUI_Int32 optionsLength, ArkUI_Int32 offset)
88 {
89 if ((options == nullptr) || (offset < 0) || ((offset + NUM_3) > optionsLength)) {
90 return false;
91 }
92 auto hasValue = options[offset];
93 auto value = options[offset + NUM_1];
94 auto unit = options[offset + NUM_2];
95 if (static_cast<bool>(hasValue.value)) {
96 auto unitValue = static_cast<DimensionUnit>(unit.value);
97 if (unitValue == DimensionUnit::CALC) {
98 std::string str;
99 if (value.valueStr != nullptr) {
100 str = value.valueStr;
101 }
102 CalcDimension calcDimension(str, unitValue);
103 optDimension = calcDimension;
104 } else {
105 CalcDimension calcDimension(value.value, unitValue);
106 optDimension = calcDimension;
107 }
108 }
109 return true;
110 }
111
SetResizableFromVec(ImageResizableSlice & resizable,const ArkUIStringAndFloat * options)112 void SetResizableFromVec(ImageResizableSlice& resizable, const ArkUIStringAndFloat* options)
113 {
114 for (unsigned int index = 0; index < RESIZEABLE_VEC_LENGTH; index += NUM_3) {
115 std::optional<CalcDimension> optDimension;
116 SetCalcDimension(optDimension, options, RESIZEABLE_VEC_LENGTH, index);
117 if (optDimension.has_value()) {
118 auto direction = directions[index / NUM_3];
119 resizable.SetEdgeSlice(direction, optDimension.value());
120 }
121 }
122 }
123
SetImageSrc(ArkUINodeHandle node,const char * value)124 void SetImageSrc(ArkUINodeHandle node, const char* value)
125 {
126 auto* frameNode = reinterpret_cast<FrameNode*>(node);
127 CHECK_NULL_VOID(frameNode);
128 std::string src(value);
129 ImageModelNG::InitImage(frameNode, src);
130 }
131
GetImageSrc(ArkUINodeHandle node)132 const char* GetImageSrc(ArkUINodeHandle node)
133 {
134 auto* frameNode = reinterpret_cast<FrameNode*>(node);
135 CHECK_NULL_RETURN(frameNode, nullptr);
136 g_strValue = ImageModelNG::GetSrc(frameNode).GetSrc();
137 return g_strValue.c_str();
138 }
139
GetThemeConstants(const char * bundleName,const char * moduleName)140 RefPtr<ThemeConstants> GetThemeConstants(const char* bundleName, const char* moduleName)
141 {
142 auto cardId = CardScope::CurrentId();
143 if (cardId != INVALID_CARD_ID) {
144 auto container = Container::Current();
145 auto weak = container->GetCardPipeline(cardId);
146 auto cardPipelineContext = weak.Upgrade();
147 CHECK_NULL_RETURN(cardPipelineContext, nullptr);
148 auto cardThemeManager = cardPipelineContext->GetThemeManager();
149 CHECK_NULL_RETURN(cardThemeManager, nullptr);
150 return cardThemeManager->GetThemeConstants(bundleName, moduleName);
151 }
152 auto container = Container::Current();
153 CHECK_NULL_RETURN(container, nullptr);
154 auto pipelineContext = container->GetPipelineContext();
155 CHECK_NULL_RETURN(pipelineContext, nullptr);
156 auto themeManager = pipelineContext->GetThemeManager();
157 CHECK_NULL_RETURN(themeManager, nullptr);
158 return themeManager->GetThemeConstants(bundleName, moduleName);
159 }
160
SetImageResource(ArkUINodeHandle node,int id,int type,const char * name,const char * bundleName,const char * moduleName)161 void SetImageResource(
162 ArkUINodeHandle node, int id, int type, const char* name, const char* bundleName, const char* moduleName)
163 {
164 auto themeConstants = GetThemeConstants(bundleName, moduleName);
165 auto* frameNode = reinterpret_cast<FrameNode*>(node);
166 CHECK_NULL_VOID(frameNode);
167 if (!themeConstants) {
168 return;
169 }
170 std::optional<std::string> src;
171 if (type == static_cast<int32_t>(ResourceType::RAWFILE)) {
172 src = themeConstants->GetRawfile(name);
173 }
174 if (type == static_cast<int32_t>(ResourceType::MEDIA)) {
175 if (id == -1) {
176 src = themeConstants->GetMediaPathByName(name);
177 } else {
178 src = themeConstants->GetMediaPath(id);
179 }
180 }
181 if (!src.has_value()) {
182 return;
183 }
184
185 ImageModelNG::InitImage(frameNode, src.value());
186 }
187
SetCopyOption(ArkUINodeHandle node,ArkUI_Int32 copyOption)188 void SetCopyOption(ArkUINodeHandle node, ArkUI_Int32 copyOption)
189 {
190 auto* frameNode = reinterpret_cast<FrameNode*>(node);
191 CHECK_NULL_VOID(frameNode);
192 auto copyOptions = static_cast<CopyOptions>(copyOption);
193 if (copyOptions < CopyOptions::None || copyOptions > CopyOptions::Distributed) {
194 copyOptions = DEFAULT_IMAGE_COPYOPTION;
195 }
196 ImageModelNG::SetCopyOption(frameNode, copyOptions);
197 }
198
SetImageShowSrc(ArkUINodeHandle node,ArkUI_CharPtr src,ArkUI_CharPtr bundleName,ArkUI_CharPtr moduleName,ArkUI_Bool isUriPureNumber)199 void SetImageShowSrc(ArkUINodeHandle node, ArkUI_CharPtr src, ArkUI_CharPtr bundleName, ArkUI_CharPtr moduleName,
200 ArkUI_Bool isUriPureNumber)
201 {
202 auto* frameNode = reinterpret_cast<FrameNode*>(node);
203 CHECK_NULL_VOID(frameNode);
204 ImageModelNG::SetInitialSrc(frameNode, src, bundleName, moduleName, isUriPureNumber);
205 }
206
ResetCopyOption(ArkUINodeHandle node)207 void ResetCopyOption(ArkUINodeHandle node)
208 {
209 auto* frameNode = reinterpret_cast<FrameNode*>(node);
210 CHECK_NULL_VOID(frameNode);
211 ImageModelNG::SetCopyOption(frameNode, DEFAULT_IMAGE_COPYOPTION);
212 }
213
SetAutoResize(ArkUINodeHandle node,ArkUI_Bool autoResize)214 void SetAutoResize(ArkUINodeHandle node, ArkUI_Bool autoResize)
215 {
216 auto* frameNode = reinterpret_cast<FrameNode*>(node);
217 CHECK_NULL_VOID(frameNode);
218 ImageModelNG::SetAutoResize(frameNode, autoResize);
219 }
220
GetAutoResize(ArkUINodeHandle node)221 int32_t GetAutoResize(ArkUINodeHandle node)
222 {
223 auto* frameNode = reinterpret_cast<FrameNode*>(node);
224 CHECK_NULL_RETURN(frameNode, true);
225 return ImageModelNG::GetAutoResize(frameNode);
226 }
227
ResetAutoResize(ArkUINodeHandle node)228 void ResetAutoResize(ArkUINodeHandle node)
229 {
230 auto* frameNode = reinterpret_cast<FrameNode*>(node);
231 CHECK_NULL_VOID(frameNode);
232 ImageModelNG::ResetAutoResize(frameNode);
233 }
234
SetObjectRepeat(ArkUINodeHandle node,ArkUI_Int32 imageRepeat)235 void SetObjectRepeat(ArkUINodeHandle node, ArkUI_Int32 imageRepeat)
236 {
237 auto* frameNode = reinterpret_cast<FrameNode*>(node);
238 CHECK_NULL_VOID(frameNode);
239 auto repeat = static_cast<ImageRepeat>(imageRepeat);
240 if (repeat < ImageRepeat::NO_REPEAT || repeat > ImageRepeat::REPEAT) {
241 repeat = ImageRepeat::NO_REPEAT;
242 }
243 ImageModelNG::SetImageRepeat(frameNode, repeat);
244 }
245
GetObjectRepeat(ArkUINodeHandle node)246 int32_t GetObjectRepeat(ArkUINodeHandle node)
247 {
248 int32_t defaultObjectRepeat = static_cast<int32_t>(ImageRepeat::NO_REPEAT);
249 auto* frameNode = reinterpret_cast<FrameNode*>(node);
250 CHECK_NULL_RETURN(frameNode, defaultObjectRepeat);
251 return static_cast<int32_t>(ImageModelNG::GetObjectRepeat(frameNode));
252 }
253
ResetObjectRepeat(ArkUINodeHandle node)254 void ResetObjectRepeat(ArkUINodeHandle node)
255 {
256 auto* frameNode = reinterpret_cast<FrameNode*>(node);
257 CHECK_NULL_VOID(frameNode);
258 ImageModelNG::SetImageRepeat(frameNode, ImageRepeat::NO_REPEAT);
259 }
260
SetRenderMode(ArkUINodeHandle node,ArkUI_Int32 imageRenderMode)261 void SetRenderMode(ArkUINodeHandle node, ArkUI_Int32 imageRenderMode)
262 {
263 auto* frameNode = reinterpret_cast<FrameNode*>(node);
264 CHECK_NULL_VOID(frameNode);
265 auto renderMode = static_cast<ImageRenderMode>(imageRenderMode);
266 if (renderMode < ImageRenderMode::ORIGINAL || renderMode > ImageRenderMode::TEMPLATE) {
267 renderMode = ImageRenderMode::ORIGINAL;
268 }
269 ImageModelNG::SetImageRenderMode(frameNode, renderMode);
270 }
271
ResetRenderMode(ArkUINodeHandle node)272 void ResetRenderMode(ArkUINodeHandle node)
273 {
274 auto* frameNode = reinterpret_cast<FrameNode*>(node);
275 CHECK_NULL_VOID(frameNode);
276 ImageModelNG::SetImageRenderMode(frameNode, ImageRenderMode::ORIGINAL);
277 }
278
GetRenderMode(ArkUINodeHandle node)279 int32_t GetRenderMode(ArkUINodeHandle node)
280 {
281 int32_t defaultRenderMode = static_cast<int32_t>(ImageRenderMode::ORIGINAL);
282 auto* frameNode = reinterpret_cast<FrameNode*>(node);
283 CHECK_NULL_RETURN(frameNode, defaultRenderMode);
284 return static_cast<int32_t>(ImageModelNG::GetImageRenderMode(frameNode));
285 }
286
SetSyncLoad(ArkUINodeHandle node,ArkUI_Bool syncLoadValue)287 void SetSyncLoad(ArkUINodeHandle node, ArkUI_Bool syncLoadValue)
288 {
289 auto* frameNode = reinterpret_cast<FrameNode*>(node);
290 CHECK_NULL_VOID(frameNode);
291 ImageModelNG::SetSyncMode(frameNode, syncLoadValue);
292 }
293
ResetSyncLoad(ArkUINodeHandle node)294 void ResetSyncLoad(ArkUINodeHandle node)
295 {
296 auto* frameNode = reinterpret_cast<FrameNode*>(node);
297 CHECK_NULL_VOID(frameNode);
298 ImageModelNG::SetSyncMode(frameNode, DEFAULT_SYNC_LOAD_VALUE);
299 }
300
SetImageMatrix(ArkUINodeHandle node,const ArkUI_Float32 * matrix)301 void SetImageMatrix(ArkUINodeHandle node, const ArkUI_Float32* matrix)
302 {
303 auto* frameNode = reinterpret_cast<FrameNode*>(node);
304 CHECK_NULL_VOID(frameNode);
305 Matrix4 matrix4Value = Matrix4(
306 matrix[0], matrix[4], matrix[8], matrix[12],
307 matrix[1], matrix[5], matrix[9], matrix[13],
308 matrix[2], matrix[6], matrix[10], matrix[14],
309 matrix[3], matrix[7], matrix[11], matrix[15]);
310 ImageModelNG::SetImageMatrix(frameNode, matrix4Value);
311 }
312
ResetImageMatrix(ArkUINodeHandle node)313 void ResetImageMatrix(ArkUINodeHandle node)
314 {
315 auto* frameNode = reinterpret_cast<FrameNode*>(node);
316 CHECK_NULL_VOID(frameNode);
317 const auto matrix4Len = Matrix4::DIMENSION * Matrix4::DIMENSION;
318 std::vector<float> matrix(matrix4Len);
319 const int32_t initPosition = 5;
320 for (int32_t i = 0; i < matrix4Len; i = i + initPosition) {
321 matrix[i] = 1.0f;
322 }
323 Matrix4 defaultValue = Matrix4(
324 matrix[0], matrix[4], matrix[8], matrix[12],
325 matrix[1], matrix[5], matrix[9], matrix[13],
326 matrix[2], matrix[6], matrix[10], matrix[14],
327 matrix[3], matrix[7], matrix[11], matrix[15]);
328 ImageModelNG::SetImageMatrix(frameNode, defaultValue);
329 }
330
SetObjectFit(ArkUINodeHandle node,ArkUI_Int32 objectFitNumber)331 void SetObjectFit(ArkUINodeHandle node, ArkUI_Int32 objectFitNumber)
332 {
333 auto* frameNode = reinterpret_cast<FrameNode*>(node);
334 CHECK_NULL_VOID(frameNode);
335 ImageFit objectFitValue = static_cast<ImageFit>(objectFitNumber);
336 ImageModelNG::SetImageFit(frameNode, objectFitValue);
337 }
338
GetObjectFit(ArkUINodeHandle node)339 int32_t GetObjectFit(ArkUINodeHandle node)
340 {
341 int32_t defaultObjectFit = static_cast<int32_t>(ImageFit::COVER);
342 auto* frameNode = reinterpret_cast<FrameNode*>(node);
343 CHECK_NULL_RETURN(frameNode, defaultObjectFit);
344 return static_cast<int32_t>(ImageModelNG::GetObjectFit(frameNode));
345 }
346
ResetObjectFit(ArkUINodeHandle node)347 void ResetObjectFit(ArkUINodeHandle node)
348 {
349 auto* frameNode = reinterpret_cast<FrameNode*>(node);
350 CHECK_NULL_VOID(frameNode);
351 ImageModelNG::SetImageFit(frameNode, DEFAULT_OBJECT_FIT_VALUE);
352 }
353
SetFitOriginalSize(ArkUINodeHandle node,ArkUI_Bool fitOriginalSizeValue)354 void SetFitOriginalSize(ArkUINodeHandle node, ArkUI_Bool fitOriginalSizeValue)
355 {
356 auto* frameNode = reinterpret_cast<FrameNode*>(node);
357 CHECK_NULL_VOID(frameNode);
358 ImageModelNG::SetFitOriginSize(frameNode, fitOriginalSizeValue);
359 }
360
ResetFitOriginalSize(ArkUINodeHandle node)361 void ResetFitOriginalSize(ArkUINodeHandle node)
362 {
363 auto* frameNode = reinterpret_cast<FrameNode*>(node);
364 CHECK_NULL_VOID(frameNode);
365 ImageModelNG::SetFitOriginSize(frameNode, DEFAULT_FIT_ORIGINAL_SIZE);
366 }
367
SetSourceSize(ArkUINodeHandle node,ArkUI_Float32 width,ArkUI_Float32 height)368 void SetSourceSize(ArkUINodeHandle node, ArkUI_Float32 width, ArkUI_Float32 height)
369 {
370 auto* frameNode = reinterpret_cast<FrameNode*>(node);
371 CHECK_NULL_VOID(frameNode);
372 CalcDimension widthObj(width, DimensionUnit::VP);
373 CalcDimension heightObj(height, DimensionUnit::VP);
374 ImageModelNG::SetImageSourceSize(frameNode, std::pair<CalcDimension, CalcDimension>(widthObj, heightObj));
375 }
376
ResetSourceSize(ArkUINodeHandle node)377 void ResetSourceSize(ArkUINodeHandle node)
378 {
379 auto* frameNode = reinterpret_cast<FrameNode*>(node);
380 CHECK_NULL_VOID(frameNode);
381 ImageModelNG::SetImageSourceSize(frameNode, std::pair<CalcDimension, CalcDimension>());
382 }
383
SetMatchTextDirection(ArkUINodeHandle node,ArkUI_Uint32 value)384 void SetMatchTextDirection(ArkUINodeHandle node, ArkUI_Uint32 value)
385 {
386 auto* frameNode = reinterpret_cast<FrameNode*>(node);
387 CHECK_NULL_VOID(frameNode);
388 ImageModelNG::SetMatchTextDirection(frameNode, static_cast<bool>(value));
389 }
390
ResetMatchTextDirection(ArkUINodeHandle node)391 void ResetMatchTextDirection(ArkUINodeHandle node)
392 {
393 auto* frameNode = reinterpret_cast<FrameNode*>(node);
394 CHECK_NULL_VOID(frameNode);
395 ImageModelNG::SetMatchTextDirection(frameNode, false);
396 }
397
SetFillColor(ArkUINodeHandle node,ArkUI_Uint32 value)398 void SetFillColor(ArkUINodeHandle node, ArkUI_Uint32 value)
399 {
400 auto* frameNode = reinterpret_cast<FrameNode*>(node);
401 CHECK_NULL_VOID(frameNode);
402 ImageModelNG::SetImageFill(frameNode, Color(value));
403 }
404
ResetImageFill(ArkUINodeHandle node)405 void ResetImageFill(ArkUINodeHandle node)
406 {
407 auto* frameNode = reinterpret_cast<FrameNode*>(node);
408 CHECK_NULL_VOID(frameNode);
409 ImageModelNG::ResetImageFill(frameNode);
410 }
411
ResetFillColor(ArkUINodeHandle node)412 void ResetFillColor(ArkUINodeHandle node)
413 {
414 auto* frameNode = reinterpret_cast<FrameNode*>(node);
415 CHECK_NULL_VOID(frameNode);
416 auto pipelineContext = frameNode->GetContext();
417 CHECK_NULL_VOID(pipelineContext);
418 auto theme = pipelineContext->GetTheme<ImageTheme>();
419 CHECK_NULL_VOID(theme);
420 ImageModelNG::SetImageFill(frameNode, theme->GetFillColor());
421 }
422
SetAlt(ArkUINodeHandle node,const char * src,const char * bundleName,const char * moduleName)423 void SetAlt(ArkUINodeHandle node, const char* src, const char* bundleName, const char* moduleName)
424 {
425 if (ImageSourceInfo::ResolveURIType(src) == SrcType::NETWORK) {
426 return;
427 }
428
429 auto* frameNode = reinterpret_cast<FrameNode*>(node);
430 CHECK_NULL_VOID(frameNode);
431 ImageModelNG::SetAlt(frameNode, ImageSourceInfo { src, bundleName, moduleName });
432 }
433
GetAlt(ArkUINodeHandle node)434 const char* GetAlt(ArkUINodeHandle node)
435 {
436 auto* frameNode = reinterpret_cast<FrameNode*>(node);
437 CHECK_NULL_RETURN(frameNode, nullptr);
438 g_strValue = ImageModelNG::GetAlt(frameNode).GetSrc();
439 return g_strValue.c_str();
440 }
441
ResetAlt(ArkUINodeHandle node)442 void ResetAlt(ArkUINodeHandle node)
443 {
444 auto* frameNode = reinterpret_cast<FrameNode*>(node);
445 CHECK_NULL_VOID(frameNode);
446 ImageModelNG::ResetImageAlt(frameNode);
447 }
448
SetImageInterpolation(ArkUINodeHandle node,ArkUI_Int32 value)449 void SetImageInterpolation(ArkUINodeHandle node, ArkUI_Int32 value)
450 {
451 auto* frameNode = reinterpret_cast<FrameNode*>(node);
452 CHECK_NULL_VOID(frameNode);
453 auto interpolation = static_cast<Ace::ImageInterpolation>(value);
454 if (interpolation < Ace::ImageInterpolation::NONE || interpolation > Ace::ImageInterpolation::HIGH) {
455 interpolation = Ace::ImageInterpolation::NONE;
456 }
457 ImageModelNG::SetImageInterpolation(frameNode, interpolation);
458 }
459
GetImageInterpolation(ArkUINodeHandle node)460 int32_t GetImageInterpolation(ArkUINodeHandle node)
461 {
462 int32_t defaultInterpolation = static_cast<int32_t>(ImageInterpolation::NONE);
463 auto* frameNode = reinterpret_cast<FrameNode*>(node);
464 CHECK_NULL_RETURN(frameNode, defaultInterpolation);
465 return static_cast<int32_t>(ImageModelNG::GetInterpolation(frameNode));
466 }
467
ResetImageInterpolation(ArkUINodeHandle node)468 void ResetImageInterpolation(ArkUINodeHandle node)
469 {
470 auto* frameNode = reinterpret_cast<FrameNode*>(node);
471 CHECK_NULL_VOID(frameNode);
472 ImageModelNG::ResetImageInterpolation(frameNode);
473 }
474
SetColorFilter(ArkUINodeHandle node,const ArkUI_Float32 * array,int length)475 void SetColorFilter(ArkUINodeHandle node, const ArkUI_Float32* array, int length)
476 {
477 CHECK_NULL_VOID(array);
478 if (length != COLOR_FILTER_MATRIX_SIZE) {
479 return;
480 }
481 auto* frameNode = reinterpret_cast<FrameNode*>(node);
482 CHECK_NULL_VOID(frameNode);
483 ImageModelNG::SetColorFilterMatrix(frameNode, std::vector<float>(array, array + length));
484 }
485
GetColorFilter(ArkUINodeHandle node,ArkUIFilterColorType * colorFilter)486 void GetColorFilter(ArkUINodeHandle node, ArkUIFilterColorType* colorFilter)
487 {
488 CHECK_NULL_VOID(colorFilter);
489 auto* frameNode = reinterpret_cast<FrameNode*>(node);
490 CHECK_NULL_VOID(frameNode);
491 auto filterFloatArray = ImageModelNG::GetColorFilter(frameNode);
492 colorFilter->filterSize = filterFloatArray.size() < MAX_COLOR_FILTER_SIZE
493 ? static_cast<int32_t>(filterFloatArray.size())
494 : static_cast<int32_t>(MAX_COLOR_FILTER_SIZE);
495 for (size_t i = 0; i < static_cast<size_t>(colorFilter->filterSize) && i < MAX_COLOR_FILTER_SIZE; i++) {
496 *(colorFilter->filterArray+i) = filterFloatArray[i];
497 }
498 }
499
ResetColorFilter(ArkUINodeHandle node)500 void ResetColorFilter(ArkUINodeHandle node)
501 {
502 auto* frameNode = reinterpret_cast<FrameNode*>(node);
503 CHECK_NULL_VOID(frameNode);
504 ImageModelNG::SetColorFilterMatrix(frameNode, DEFAULT_COLOR_FILTER);
505 }
506
SetDrawingColorFilter(ArkUINodeHandle node,void * colorFilter)507 void SetDrawingColorFilter(ArkUINodeHandle node, void* colorFilter)
508 {
509 auto* frameNode = reinterpret_cast<FrameNode*>(node);
510 CHECK_NULL_VOID(frameNode);
511 auto filter = reinterpret_cast<OHOS::Rosen::Drawing::ColorFilter*>(colorFilter);
512 auto filterPtr = std::make_shared<OHOS::Rosen::Drawing::ColorFilter>(*filter);
513 auto drawingColorFilter = DrawingColorFilter::CreateDrawingColorFilterFromNative(static_cast<void*>(&filterPtr));
514 ImageModelNG::SetDrawingColorFilter(frameNode, drawingColorFilter);
515 }
516
GetDrawingColorFilter(ArkUINodeHandle node)517 void* GetDrawingColorFilter(ArkUINodeHandle node)
518 {
519 auto* frameNode = reinterpret_cast<FrameNode*>(node);
520 CHECK_NULL_RETURN(frameNode, nullptr);
521 auto drawingColorFilter = ImageModelNG::GetDrawingColorFilter(frameNode);
522 CHECK_NULL_RETURN(drawingColorFilter, nullptr);
523 auto filterSptr = reinterpret_cast<std::shared_ptr<OHOS::Rosen::Drawing::ColorFilter>*>(
524 drawingColorFilter->GetDrawingColorFilterSptrAddr());
525 CHECK_NULL_RETURN(filterSptr, nullptr);
526 return (*filterSptr).get();
527 }
528
SetImageSyncLoad(ArkUINodeHandle node,ArkUI_Bool syncLoadValue)529 void SetImageSyncLoad(ArkUINodeHandle node, ArkUI_Bool syncLoadValue)
530 {
531 auto* frameNode = reinterpret_cast<FrameNode*>(node);
532 CHECK_NULL_VOID(frameNode);
533 ImageModelNG::SetSyncMode(frameNode, syncLoadValue);
534 }
535
ResetImageSyncLoad(ArkUINodeHandle node)536 void ResetImageSyncLoad(ArkUINodeHandle node)
537 {
538 auto* frameNode = reinterpret_cast<FrameNode*>(node);
539 CHECK_NULL_VOID(frameNode);
540 ImageModelNG::SetSyncMode(frameNode, DEFAULT_SYNC_LOAD_VALUE);
541 }
542
SetImageObjectFit(ArkUINodeHandle node,ArkUI_Int32 objectFitNumber)543 void SetImageObjectFit(ArkUINodeHandle node, ArkUI_Int32 objectFitNumber)
544 {
545 auto* frameNode = reinterpret_cast<FrameNode*>(node);
546 CHECK_NULL_VOID(frameNode);
547 ImageFit objectFitValue = static_cast<ImageFit>(objectFitNumber);
548 ImageModelNG::SetImageFit(frameNode, objectFitValue);
549 }
550
ResetImageObjectFit(ArkUINodeHandle node)551 void ResetImageObjectFit(ArkUINodeHandle node)
552 {
553 auto* frameNode = reinterpret_cast<FrameNode*>(node);
554 CHECK_NULL_VOID(frameNode);
555 ImageModelNG::SetImageFit(frameNode, DEFAULT_OBJECT_FIT_VALUE);
556 }
557
SetImageFitOriginalSize(ArkUINodeHandle node,ArkUI_Bool fitOriginalSizeValue)558 void SetImageFitOriginalSize(ArkUINodeHandle node, ArkUI_Bool fitOriginalSizeValue)
559 {
560 auto* frameNode = reinterpret_cast<FrameNode*>(node);
561 CHECK_NULL_VOID(frameNode);
562 ImageModelNG::SetFitOriginSize(frameNode, fitOriginalSizeValue);
563 }
564
ResetImageFitOriginalSize(ArkUINodeHandle node)565 void ResetImageFitOriginalSize(ArkUINodeHandle node)
566 {
567 auto* frameNode = reinterpret_cast<FrameNode*>(node);
568 CHECK_NULL_VOID(frameNode);
569 ImageModelNG::SetFitOriginSize(frameNode, DEFAULT_FIT_ORIGINAL_SIZE);
570 }
571
SetImageDraggable(ArkUINodeHandle node,ArkUI_Bool value)572 void SetImageDraggable(ArkUINodeHandle node, ArkUI_Bool value)
573 {
574 auto* frameNode = reinterpret_cast<FrameNode*>(node);
575 CHECK_NULL_VOID(frameNode);
576 ImageModelNG::SetDraggable(frameNode, value);
577 }
578
ResetImageDraggable(ArkUINodeHandle node)579 void ResetImageDraggable(ArkUINodeHandle node)
580 {
581 auto* frameNode = reinterpret_cast<FrameNode*>(node);
582 CHECK_NULL_VOID(frameNode);
583 ImageModelNG::SetDraggable(frameNode, DEFAULT_DRAGGABLE);
584 }
585
GetImageDraggable(ArkUINodeHandle node)586 int32_t GetImageDraggable(ArkUINodeHandle node)
587 {
588 auto* frameNode = reinterpret_cast<FrameNode*>(node);
589 CHECK_NULL_RETURN(frameNode, DEFAULT_DRAGGABLE);
590 return ImageModelNG::GetDraggable(frameNode);
591 }
592
593 /**
594 * @param values radius values
595 * value[0] : radius value for TopLeft，value[1] : radius value for TopRight
596 * value[2] : radius value for BottomLeft，value[3] : radius value for BottomRight
597 * @param units radius units
598 * units[0]: radius unit for TopLeft ,units[1] : radius unit for TopRight
599 * units[2]: radius unit for BottomLeft, units[3] : radius unit for TopRight
600 */
SetImageBorderRadius(ArkUINodeHandle node,const ArkUI_Float32 * values,const int * units,ArkUI_Int32 length)601 void SetImageBorderRadius(ArkUINodeHandle node, const ArkUI_Float32* values, const int* units, ArkUI_Int32 length)
602 {
603 auto nodeModifiers = GetArkUINodeModifiers();
604 CHECK_NULL_VOID(nodeModifiers);
605 nodeModifiers->getCommonModifier()->setBorderRadius(node, values, units, length);
606 auto* frameNode = reinterpret_cast<FrameNode*>(node);
607 CHECK_NULL_VOID(frameNode);
608 if (!Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_FOURTEEN)) {
609 ImageModelNG::SetBackBorder(frameNode);
610 return;
611 }
612 if (length != DEFAULT_LENGTH) {
613 return;
614 }
615 NG::BorderRadiusProperty borderRadius;
616 borderRadius.radiusTopLeft = Dimension(values[NUM_0], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_0]));
617 borderRadius.radiusTopRight = Dimension(values[NUM_1], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_1]));
618 borderRadius.radiusBottomLeft = Dimension(values[NUM_2], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_2]));
619 borderRadius.radiusBottomRight = Dimension(values[NUM_3], static_cast<OHOS::Ace::DimensionUnit>(units[NUM_3]));
620 borderRadius.multiValued = true;
621 ImageModelNG::SetBorderRadius(frameNode, borderRadius);
622 }
623
624
ResetImageBorderRadius(ArkUINodeHandle node)625 void ResetImageBorderRadius(ArkUINodeHandle node)
626 {
627 auto nodeModifiers = GetArkUINodeModifiers();
628 CHECK_NULL_VOID(nodeModifiers);
629 nodeModifiers->getCommonModifier()->resetBorderRadius(node);
630 auto* frameNode = reinterpret_cast<FrameNode*>(node);
631 CHECK_NULL_VOID(frameNode);
632 if (!Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_FOURTEEN)) {
633 ImageModelNG::SetBackBorder(frameNode);
634 return;
635 }
636 OHOS::Ace::CalcDimension reset;
637 ImageModelNG::SetBorderRadius(frameNode, reset);
638 }
639
SetImageBorderWithValues(ArkUINodeHandle node,const ArkUI_Float32 * values,ArkUI_Int32 valuesSize)640 void SetImageBorderWithValues(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize)
641 {
642 auto* frameNode = reinterpret_cast<FrameNode*>(node);
643 CHECK_NULL_VOID(frameNode);
644 if ((values == nullptr) || (valuesSize != NUM_12)) {
645 return;
646 }
647
648 int32_t offset = NUM_0;
649 NG::BorderRadiusProperty borderRadius;
650 SetOptionalBorder(borderRadius.radiusTopLeft, values, valuesSize, offset);
651 SetOptionalBorder(borderRadius.radiusTopRight, values, valuesSize, offset);
652 SetOptionalBorder(borderRadius.radiusBottomLeft, values, valuesSize, offset);
653 SetOptionalBorder(borderRadius.radiusBottomRight, values, valuesSize, offset);
654
655 borderRadius.multiValued = true;
656 if (borderRadius.radiusTopLeft.has_value() || borderRadius.radiusTopRight.has_value() ||
657 borderRadius.radiusBottomLeft.has_value() || borderRadius.radiusBottomRight.has_value()) {
658 ImageModelNG::SetBorderRadius(frameNode, borderRadius);
659 }
660 }
661
SetImageBorder(ArkUINodeHandle node)662 void SetImageBorder(ArkUINodeHandle node)
663 {
664 auto* frameNode = reinterpret_cast<FrameNode*>(node);
665 CHECK_NULL_VOID(frameNode);
666 ImageModelNG::SetBackBorder(frameNode);
667 }
668
ResetImageBorder(ArkUINodeHandle node)669 void ResetImageBorder(ArkUINodeHandle node)
670 {
671 auto* frameNode = reinterpret_cast<FrameNode*>(node);
672 CHECK_NULL_VOID(frameNode);
673 if (!Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_FOURTEEN)) {
674 ImageModelNG::SetBackBorder(frameNode);
675 return;
676 }
677 auto nodeModifiers = GetArkUINodeModifiers();
678 CHECK_NULL_VOID(nodeModifiers);
679 nodeModifiers->getCommonModifier()->resetBorder(node);
680 CalcDimension borderRadius;
681 ImageModelNG::SetBorderRadius(frameNode, borderRadius);
682 }
683
SetImageOpacity(ArkUINodeHandle node,ArkUI_Float32 opacity)684 void SetImageOpacity(ArkUINodeHandle node, ArkUI_Float32 opacity)
685 {
686 auto* frameNode = reinterpret_cast<FrameNode*>(node);
687 CHECK_NULL_VOID(frameNode);
688 auto opacityValue = static_cast<float>(opacity);
689 if ((LessNotEqual(opacityValue, 0.0)) || GreatNotEqual(opacityValue, 1.0)) {
690 opacityValue = 1.0f;
691 }
692 ViewAbstract::SetOpacity(frameNode, opacityValue);
693 }
694
ResetImageOpacity(ArkUINodeHandle node)695 void ResetImageOpacity(ArkUINodeHandle node)
696 {
697 auto* frameNode = reinterpret_cast<FrameNode*>(node);
698 CHECK_NULL_VOID(frameNode);
699 ViewAbstract::SetOpacity(frameNode, 1.0f);
700 }
701
SetEdgeAntialiasing(ArkUINodeHandle node,ArkUI_Float32 edgeAntialiasing)702 void SetEdgeAntialiasing(ArkUINodeHandle node, ArkUI_Float32 edgeAntialiasing)
703 {
704 auto* frameNode = reinterpret_cast<FrameNode*>(node);
705 CHECK_NULL_VOID(frameNode);
706 ImageModelNG::SetSmoothEdge(frameNode, edgeAntialiasing);
707 }
708
ResetEdgeAntialiasing(ArkUINodeHandle node)709 void ResetEdgeAntialiasing(ArkUINodeHandle node)
710 {
711 auto* frameNode = reinterpret_cast<FrameNode*>(node);
712 CHECK_NULL_VOID(frameNode);
713 ImageModelNG::SetSmoothEdge(frameNode, DEFAULT_IMAGE_EDGE_ANTIALIASING);
714 }
715
SetResizable(ArkUINodeHandle node,const ArkUIStringAndFloat * options)716 void SetResizable(ArkUINodeHandle node, const ArkUIStringAndFloat* options)
717 {
718 auto* frameNode = reinterpret_cast<FrameNode*>(node);
719 CHECK_NULL_VOID(frameNode);
720 ImageResizableSlice resizable;
721 SetResizableFromVec(resizable, options);
722 ImageModelNG::SetResizableSlice(frameNode, resizable);
723 }
724
ResetResizable(ArkUINodeHandle node)725 void ResetResizable(ArkUINodeHandle node)
726 {
727 auto* frameNode = reinterpret_cast<FrameNode*>(node);
728 CHECK_NULL_VOID(frameNode);
729 ImageModelNG::SetResizableSlice(frameNode, DEFAULT_IMAGE_SLICE);
730 }
731
SetResizableLattice(ArkUINodeHandle node,void * lattice)732 void SetResizableLattice(ArkUINodeHandle node, void* lattice)
733 {
734 auto* frameNode = reinterpret_cast<FrameNode*>(node);
735 CHECK_NULL_VOID(frameNode);
736 auto drawingLattice = DrawingLattice::CreateDrawingLattice(lattice);
737 if (drawingLattice) {
738 ImageModelNG::SetResizableLattice(frameNode, drawingLattice);
739 } else {
740 ImageModelNG::ResetResizableLattice(frameNode);
741 }
742 }
743
ResetResizableLattice(ArkUINodeHandle node)744 void ResetResizableLattice(ArkUINodeHandle node)
745 {
746 auto* frameNode = reinterpret_cast<FrameNode*>(node);
747 CHECK_NULL_VOID(frameNode);
748 ImageModelNG::ResetResizableLattice(frameNode);
749 }
750
SetDynamicRangeMode(ArkUINodeHandle node,ArkUI_Int32 dynamicRangeMode)751 void SetDynamicRangeMode(ArkUINodeHandle node, ArkUI_Int32 dynamicRangeMode)
752 {
753 auto* frameNode = reinterpret_cast<FrameNode*>(node);
754 CHECK_NULL_VOID(frameNode);
755 DynamicRangeMode dynamicRangeModeValue = static_cast<DynamicRangeMode>(dynamicRangeMode);
756 if (dynamicRangeModeValue < DynamicRangeMode::HIGH || dynamicRangeModeValue > DynamicRangeMode::STANDARD) {
757 dynamicRangeModeValue = DynamicRangeMode::STANDARD;
758 }
759 ImageModelNG::SetDynamicRangeMode(frameNode, dynamicRangeModeValue);
760 }
761
GetFitOriginalSize(ArkUINodeHandle node)762 int32_t GetFitOriginalSize(ArkUINodeHandle node)
763 {
764 auto* frameNode = reinterpret_cast<FrameNode*>(node);
765 CHECK_NULL_RETURN(frameNode, DEFAULT_FALSE);
766 return ImageModelNG::GetFitOriginalSize(frameNode);
767 }
768
GetFillColor(ArkUINodeHandle node)769 uint32_t GetFillColor(ArkUINodeHandle node)
770 {
771 auto* frameNode = reinterpret_cast<FrameNode*>(node);
772 CHECK_NULL_RETURN(frameNode, ERROR_UINT_CODE);
773 return ImageModelNG::GetFillColor(frameNode);
774 }
775
SetPixelMap(ArkUINodeHandle node,void * drawableDescriptor)776 void SetPixelMap(ArkUINodeHandle node, void* drawableDescriptor)
777 {
778 auto* frameNode = reinterpret_cast<FrameNode*>(node);
779 CHECK_NULL_VOID(frameNode);
780 ImageModelNG::SetPixelMap(frameNode, drawableDescriptor);
781 }
782
SetPixelMapArray(ArkUINodeHandle node,void * animatedDrawableDescriptor)783 void SetPixelMapArray(ArkUINodeHandle node, void* animatedDrawableDescriptor)
784 {
785 auto* frameNode = reinterpret_cast<FrameNode*>(node);
786 CHECK_NULL_VOID(frameNode);
787 ImageModelNG::SetPixelMapArray(frameNode, animatedDrawableDescriptor);
788 }
789
SetResourceSrc(ArkUINodeHandle node,void * resource)790 void SetResourceSrc(ArkUINodeHandle node, void* resource)
791 {
792 auto* frameNode = reinterpret_cast<FrameNode*>(node);
793 CHECK_NULL_VOID(frameNode);
794 ImageModelNG::SetResource(frameNode, resource);
795 }
796
SetAltSourceInfo(ArkUINodeHandle node,const ArkUIImageSourceInfo * sourceInfo)797 void SetAltSourceInfo(ArkUINodeHandle node, const ArkUIImageSourceInfo* sourceInfo)
798 {
799 auto* frameNode = reinterpret_cast<FrameNode*>(node);
800 CHECK_NULL_VOID(frameNode);
801 CHECK_NULL_VOID(sourceInfo);
802 if (sourceInfo->url) {
803 if (ImageSourceInfo::ResolveURIType(sourceInfo->url) == SrcType::NETWORK) {
804 return;
805 }
806 ImageModelNG::SetAlt(frameNode, ImageSourceInfo { sourceInfo->url, "", "" });
807 return;
808 }
809 if (sourceInfo->resource) {
810 ImageModelNG::SetAltResource(frameNode, sourceInfo->resource);
811 return;
812 }
813 if (sourceInfo->pixelMap) {
814 ImageModelNG::SetAltPixelMap(frameNode, sourceInfo->pixelMap);
815 return;
816 }
817 }
818
ResetDynamicRangeMode(ArkUINodeHandle node)819 void ResetDynamicRangeMode(ArkUINodeHandle node)
820 {
821 auto* frameNode = reinterpret_cast<FrameNode*>(node);
822 CHECK_NULL_VOID(frameNode);
823 ImageModelNG::SetDynamicRangeMode(frameNode, DynamicRangeMode::STANDARD);
824 }
825
SetEnhancedImageQuality(ArkUINodeHandle node,ArkUI_Int32 imageQuality)826 void SetEnhancedImageQuality(ArkUINodeHandle node, ArkUI_Int32 imageQuality)
827 {
828 auto* frameNode = reinterpret_cast<FrameNode*>(node);
829 CHECK_NULL_VOID(frameNode);
830 AIImageQuality imageQualityValue = static_cast<AIImageQuality>(imageQuality);
831 if (imageQualityValue < AIImageQuality::NONE || imageQualityValue > AIImageQuality::HIGH) {
832 imageQualityValue = AIImageQuality::NONE;
833 }
834 ImageModelNG::SetEnhancedImageQuality(frameNode, imageQualityValue);
835 }
836
ResetEnhancedImageQuality(ArkUINodeHandle node)837 void ResetEnhancedImageQuality(ArkUINodeHandle node)
838 {
839 auto* frameNode = reinterpret_cast<FrameNode*>(node);
840 CHECK_NULL_VOID(frameNode);
841 ImageModelNG::SetEnhancedImageQuality(frameNode, AIImageQuality::NONE);
842 }
843
SetImageResizable(ArkUINodeHandle node,ArkUI_Float32 left,ArkUI_Float32 top,ArkUI_Float32 right,ArkUI_Float32 bottom)844 void SetImageResizable(ArkUINodeHandle node, ArkUI_Float32 left, ArkUI_Float32 top,
845 ArkUI_Float32 right, ArkUI_Float32 bottom)
846 {
847 auto* frameNode = reinterpret_cast<FrameNode*>(node);
848 CHECK_NULL_VOID(frameNode);
849 ImageResizableSlice resizable;
850 Dimension leftDimension(left, DimensionUnit::VP);
851 resizable.SetEdgeSlice(ResizableOption::LEFT, leftDimension);
852 Dimension topDimension(top, DimensionUnit::VP);
853 resizable.SetEdgeSlice(ResizableOption::TOP, topDimension);
854 Dimension rightDimension(right, DimensionUnit::VP);
855 resizable.SetEdgeSlice(ResizableOption::RIGHT, rightDimension);
856 Dimension bottomDimension(bottom, DimensionUnit::VP);
857 resizable.SetEdgeSlice(ResizableOption::BOTTOM, bottomDimension);
858 ImageModelNG::SetResizableSlice(frameNode, resizable);
859 }
860
GetImageResizable(ArkUINodeHandle node,ArkUI_Float32 * arrayValue,ArkUI_Int32 size)861 void GetImageResizable(ArkUINodeHandle node, ArkUI_Float32* arrayValue, ArkUI_Int32 size)
862 {
863 auto* frameNode = reinterpret_cast<FrameNode*>(node);
864 CHECK_NULL_VOID(frameNode);
865 auto resizable = ImageModelNG::GetResizableSlice(frameNode);
866 if (0 < size) {
867 arrayValue[0] = resizable.left.Value();
868 }
869 if (NUM_1 < size) {
870 arrayValue[NUM_1] = resizable.top.Value();
871 }
872 if (NUM_2 < size) {
873 arrayValue[NUM_2] = resizable.right.Value();
874 }
875 if (NUM_3 < size) {
876 arrayValue[NUM_3] = resizable.bottom.Value();
877 }
878 }
879
EnableAnalyzer(ArkUINodeHandle node,ArkUI_Bool enable)880 void EnableAnalyzer(ArkUINodeHandle node, ArkUI_Bool enable)
881 {
882 auto* frameNode = reinterpret_cast<FrameNode*>(node);
883 CHECK_NULL_VOID(frameNode);
884 ImageModelNG::EnableAnalyzer(frameNode, enable);
885 }
886
SetImagePrivacySensitve(ArkUINodeHandle node,ArkUI_Int32 sensitive)887 void SetImagePrivacySensitve(ArkUINodeHandle node, ArkUI_Int32 sensitive)
888 {
889 auto* frameNode = reinterpret_cast<FrameNode*>(node);
890 CHECK_NULL_VOID(frameNode);
891 frameNode->SetPrivacySensitive(static_cast<bool>(sensitive));
892 frameNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
893 }
894
ResetImagePrivacySensitve(ArkUINodeHandle node)895 void ResetImagePrivacySensitve(ArkUINodeHandle node)
896 {
897 auto* frameNode = reinterpret_cast<FrameNode*>(node);
898 CHECK_NULL_VOID(frameNode);
899 frameNode->SetPrivacySensitive(DEFAULT_IMAGE_SENSITIVE);
900 frameNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
901 }
902
AnalyzerConfig(ArkUINodeHandle node,void * config)903 void AnalyzerConfig(ArkUINodeHandle node, void* config)
904 {
905 auto* frameNode = reinterpret_cast<FrameNode*>(node);
906 CHECK_NULL_VOID(frameNode);
907 ImageModelNG::SetImageAnalyzerConfig(frameNode, config);
908 }
909
ResetImageContent(ArkUINodeHandle node)910 void ResetImageContent(ArkUINodeHandle node)
911 {
912 auto* frameNode = reinterpret_cast<FrameNode*>(node);
913 CHECK_NULL_VOID(frameNode);
914 ImageModelNG::ResetImage(frameNode);
915 }
916
ResetImageSrc(ArkUINodeHandle node)917 void ResetImageSrc(ArkUINodeHandle node)
918 {
919 auto* frameNode = reinterpret_cast<FrameNode*>(node);
920 CHECK_NULL_VOID(frameNode);
921 ImageModelNG::ResetImageSrc(frameNode);
922 }
923
SetInitialPixelMap(ArkUINodeHandle node,ArkUI_Int64 pixelMap)924 void SetInitialPixelMap(ArkUINodeHandle node, ArkUI_Int64 pixelMap)
925 {
926 auto* frameNode = reinterpret_cast<FrameNode*>(node);
927 CHECK_NULL_VOID(frameNode);
928 void* rawPtr = reinterpret_cast<void*>(pixelMap);
929 CHECK_NULL_VOID(rawPtr);
930 RefPtr<PixelMap> pixelMapRef = PixelMap::CreatePixelMap(rawPtr);
931 ImageModelNG::SetInitialPixelMap(frameNode, pixelMapRef);
932 }
933
SetOnComplete(ArkUINodeHandle node,void * callback)934 void SetOnComplete(ArkUINodeHandle node, void* callback)
935 {
936 auto* frameNode = reinterpret_cast<FrameNode*>(node);
937 CHECK_NULL_VOID(frameNode);
938 if (callback) {
939 auto onComplete = reinterpret_cast<std::function<void(const LoadImageSuccessEvent&)>*>(callback);
940 ImageModelNG::SetOnComplete(frameNode, std::move(*onComplete));
941 } else {
942 ImageModelNG::SetOnComplete(frameNode, nullptr);
943 }
944 }
945
SetOnError(ArkUINodeHandle node,void * callback)946 void SetOnError(ArkUINodeHandle node, void* callback)
947 {
948 auto* frameNode = reinterpret_cast<FrameNode*>(node);
949 CHECK_NULL_VOID(frameNode);
950 if (callback) {
951 auto onError = reinterpret_cast<std::function<void(const LoadImageFailEvent&)>*>(callback);
952 ImageModelNG::SetOnError(frameNode, std::move(*onError));
953 } else {
954 ImageModelNG::SetOnError(frameNode, nullptr);
955 }
956 }
957
ResetOnError(ArkUINodeHandle node)958 void ResetOnError(ArkUINodeHandle node)
959 {
960 auto* frameNode = reinterpret_cast<FrameNode*>(node);
961 CHECK_NULL_VOID(frameNode);
962 ImageModelNG::SetOnError(frameNode, nullptr);
963 }
964
SetImageOnFinish(ArkUINodeHandle node,void * callback)965 void SetImageOnFinish(ArkUINodeHandle node, void* callback)
966 {
967 auto* frameNode = reinterpret_cast<FrameNode*>(node);
968 CHECK_NULL_VOID(frameNode);
969 if (callback) {
970 auto onFinish = reinterpret_cast<std::function<void()>*>(callback);
971 ImageModelNG::SetOnSvgPlayFinish(frameNode, std::move(*onFinish));
972 } else {
973 ImageModelNG::SetOnSvgPlayFinish(frameNode, nullptr);
974 }
975 }
976
ResetImageOnFinish(ArkUINodeHandle node)977 void ResetImageOnFinish(ArkUINodeHandle node)
978 {
979 auto* frameNode = reinterpret_cast<FrameNode*>(node);
980 CHECK_NULL_VOID(frameNode);
981 ImageModelNG::SetOnSvgPlayFinish(frameNode, nullptr);
982 }
983
SetImageRotateOrientation(ArkUINodeHandle node,ArkUI_Int32 orientation)984 void SetImageRotateOrientation(ArkUINodeHandle node, ArkUI_Int32 orientation)
985 {
986 auto* frameNode = reinterpret_cast<FrameNode*>(node);
987 CHECK_NULL_VOID(frameNode);
988 auto orientationValue = static_cast<ImageRotateOrientation>(orientation);
989 if (orientationValue < ImageRotateOrientation::AUTO || orientationValue > ImageRotateOrientation::LEFT) {
990 orientationValue = ImageRotateOrientation::UP;
991 }
992 ImageModelNG::SetOrientation(frameNode, orientationValue);
993 }
994
ResetImageRotateOrientation(ArkUINodeHandle node)995 void ResetImageRotateOrientation(ArkUINodeHandle node)
996 {
997 auto* frameNode = reinterpret_cast<FrameNode*>(node);
998 CHECK_NULL_VOID(frameNode);
999 ImageModelNG::SetOrientation(frameNode, ImageRotateOrientation::UP);
1000 }
1001 } // namespace
1002
1003 namespace NodeModifier {
GetImageModifier()1004 const ArkUIImageModifier* GetImageModifier()
1005 {
1006 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1007 static const ArkUIImageModifier modifier = {
1008 .setSrc = SetImageSrc,
1009 .setImageShowSrc = SetImageShowSrc,
1010 .setImageResource = SetImageResource,
1011 .setCopyOption = SetCopyOption,
1012 .resetCopyOption = ResetCopyOption,
1013 .setAutoResize = SetAutoResize,
1014 .resetAutoResize = ResetAutoResize,
1015 .setObjectRepeat = SetObjectRepeat,
1016 .resetObjectRepeat = ResetObjectRepeat,
1017 .setRenderMode = SetRenderMode,
1018 .resetRenderMode = ResetRenderMode,
1019 .setSyncLoad = SetSyncLoad,
1020 .resetSyncLoad = ResetSyncLoad,
1021 .setImageMatrix = SetImageMatrix,
1022 .resetImageMatrix = ResetImageMatrix,
1023 .setObjectFit = SetObjectFit,
1024 .resetObjectFit = ResetObjectFit,
1025 .setFitOriginalSize = SetFitOriginalSize,
1026 .resetFitOriginalSize = ResetFitOriginalSize,
1027 .setSourceSize = SetSourceSize,
1028 .resetSourceSize = ResetSourceSize,
1029 .setMatchTextDirection = SetMatchTextDirection,
1030 .resetMatchTextDirection = ResetMatchTextDirection,
1031 .setFillColor = SetFillColor,
1032 .resetImageFill = ResetImageFill,
1033 .resetFillColor = ResetFillColor,
1034 .setAlt = SetAlt,
1035 .resetAlt = ResetAlt,
1036 .setImageInterpolation = SetImageInterpolation,
1037 .resetImageInterpolation = ResetImageInterpolation,
1038 .setColorFilter = SetColorFilter,
1039 .resetColorFilter = ResetColorFilter,
1040 .setImageSyncLoad = SetImageSyncLoad,
1041 .resetImageSyncLoad = ResetImageSyncLoad,
1042 .setImageObjectFit = SetImageObjectFit,
1043 .resetImageObjectFit = ResetImageObjectFit,
1044 .setImageFitOriginalSize = SetImageFitOriginalSize,
1045 .resetImageFitOriginalSize = ResetImageFitOriginalSize,
1046 .setImageDraggable = SetImageDraggable,
1047 .resetImageDraggable = ResetImageDraggable,
1048 .setImageBorderRadius = SetImageBorderRadius,
1049 .resetImageBorderRadius = ResetImageBorderRadius,
1050 .setImageBorder = SetImageBorder,
1051 .setImageBorderWithValues = SetImageBorderWithValues,
1052 .resetImageBorder = ResetImageBorder,
1053 .setImageOpacity = SetImageOpacity,
1054 .resetImageOpacity = ResetImageOpacity,
1055 .setEdgeAntialiasing = SetEdgeAntialiasing,
1056 .resetEdgeAntialiasing = ResetEdgeAntialiasing,
1057 .setResizable = SetResizable,
1058 .resetResizable = ResetResizable,
1059 .setDynamicRangeMode = SetDynamicRangeMode,
1060 .resetDynamicRangeMode = ResetDynamicRangeMode,
1061 .setImageRotateOrientation = SetImageRotateOrientation,
1062 .resetImageRotateOrientation = ResetImageRotateOrientation,
1063 .setEnhancedImageQuality = SetEnhancedImageQuality,
1064 .resetEnhancedImageQuality = ResetEnhancedImageQuality,
1065 .getImageSrc = GetImageSrc,
1066 .getAutoResize = GetAutoResize,
1067 .getObjectRepeat = GetObjectRepeat,
1068 .getObjectFit = GetObjectFit,
1069 .getImageInterpolation = GetImageInterpolation,
1070 .getColorFilter = GetColorFilter,
1071 .getAlt = GetAlt,
1072 .getImageDraggable = GetImageDraggable,
1073 .getRenderMode = GetRenderMode,
1074 .setImageResizable = SetImageResizable,
1075 .getImageResizable = GetImageResizable,
1076 .getFitOriginalSize = GetFitOriginalSize,
1077 .getFillColor = GetFillColor,
1078 .setPixelMap = SetPixelMap,
1079 .setPixelMapArray = SetPixelMapArray,
1080 .setResourceSrc = SetResourceSrc,
1081 .enableAnalyzer = EnableAnalyzer,
1082 .setImagePrivacySensitive = SetImagePrivacySensitve,
1083 .resetImagePrivacySensitive = ResetImagePrivacySensitve,
1084 .analyzerConfig = AnalyzerConfig,
1085 .setDrawingColorFilter = SetDrawingColorFilter,
1086 .getDrawingColorFilter = GetDrawingColorFilter,
1087 .resetImageContent = ResetImageContent,
1088 .resetImageSrc = ResetImageSrc,
1089 .setInitialPixelMap = SetInitialPixelMap,
1090 .setAltSourceInfo = SetAltSourceInfo,
1091 .setOnComplete = SetOnComplete,
1092 .setOnError = SetOnError,
1093 .resetOnError = ResetOnError,
1094 .setImageOnFinish = SetImageOnFinish,
1095 .resetImageOnFinish = ResetImageOnFinish,
1096 .setResizableLattice = SetResizableLattice,
1097 .resetResizableLattice = ResetResizableLattice,
1098 };
1099 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1100 return &modifier;
1101 }
1102
GetCJUIImageModifier()1103 const CJUIImageModifier* GetCJUIImageModifier()
1104 {
1105 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
1106 static const CJUIImageModifier modifier = {
1107 .setSrc = SetImageSrc,
1108 .setImageShowSrc = SetImageShowSrc,
1109 .setCopyOption = SetCopyOption,
1110 .resetCopyOption = ResetCopyOption,
1111 .setAutoResize = SetAutoResize,
1112 .resetAutoResize = ResetAutoResize,
1113 .setObjectRepeat = SetObjectRepeat,
1114 .resetObjectRepeat = ResetObjectRepeat,
1115 .setRenderMode = SetRenderMode,
1116 .resetRenderMode = ResetRenderMode,
1117 .setSyncLoad = SetSyncLoad,
1118 .resetSyncLoad = ResetSyncLoad,
1119 .setObjectFit = SetObjectFit,
1120 .resetObjectFit = ResetObjectFit,
1121 .setFitOriginalSize = SetFitOriginalSize,
1122 .resetFitOriginalSize = ResetFitOriginalSize,
1123 .setSourceSize = SetSourceSize,
1124 .resetSourceSize = ResetSourceSize,
1125 .setMatchTextDirection = SetMatchTextDirection,
1126 .resetMatchTextDirection = ResetMatchTextDirection,
1127 .setFillColor = SetFillColor,
1128 .resetFillColor = ResetFillColor,
1129 .setAlt = SetAlt,
1130 .resetAlt = ResetAlt,
1131 .setImageInterpolation = SetImageInterpolation,
1132 .resetImageInterpolation = ResetImageInterpolation,
1133 .setColorFilter = SetColorFilter,
1134 .resetColorFilter = ResetColorFilter,
1135 .setImageSyncLoad = SetImageSyncLoad,
1136 .resetImageSyncLoad = ResetImageSyncLoad,
1137 .setImageObjectFit = SetImageObjectFit,
1138 .resetImageObjectFit = ResetImageObjectFit,
1139 .setImageFitOriginalSize = SetImageFitOriginalSize,
1140 .resetImageFitOriginalSize = ResetImageFitOriginalSize,
1141 .setImageDraggable = SetImageDraggable,
1142 .resetImageDraggable = ResetImageDraggable,
1143 .setImageBorderRadius = SetImageBorderRadius,
1144 .resetImageBorderRadius = ResetImageBorderRadius,
1145 .setImageBorder = SetImageBorder,
1146 .resetImageBorder = ResetImageBorder,
1147 .setImageOpacity = SetImageOpacity,
1148 .resetImageOpacity = ResetImageOpacity,
1149 .setEdgeAntialiasing = SetEdgeAntialiasing,
1150 .resetEdgeAntialiasing = ResetEdgeAntialiasing,
1151 .setResizable = SetResizable,
1152 .resetResizable = ResetResizable,
1153 .setDynamicRangeMode = SetDynamicRangeMode,
1154 .resetDynamicRangeMode = ResetDynamicRangeMode,
1155 .setEnhancedImageQuality = SetEnhancedImageQuality,
1156 .resetEnhancedImageQuality = ResetEnhancedImageQuality,
1157 .getImageSrc = GetImageSrc,
1158 .getAutoResize = GetAutoResize,
1159 .getObjectRepeat = GetObjectRepeat,
1160 .getObjectFit = GetObjectFit,
1161 .getImageInterpolation = GetImageInterpolation,
1162 .getColorFilter = GetColorFilter,
1163 .getAlt = GetAlt,
1164 .getImageDraggable = GetImageDraggable,
1165 .getRenderMode = GetRenderMode,
1166 .setImageResizable = SetImageResizable,
1167 .getImageResizable = GetImageResizable,
1168 .getFitOriginalSize = GetFitOriginalSize,
1169 .getFillColor = GetFillColor,
1170 .setPixelMap = SetPixelMap,
1171 .setPixelMapArray = SetPixelMapArray,
1172 .setResourceSrc = SetResourceSrc,
1173 .enableAnalyzer = EnableAnalyzer,
1174 .setImagePrivacySensitive = SetImagePrivacySensitve,
1175 .resetImagePrivacySensitive = ResetImagePrivacySensitve,
1176 .analyzerConfig = AnalyzerConfig,
1177 .setDrawingColorFilter = SetDrawingColorFilter,
1178 .getDrawingColorFilter = GetDrawingColorFilter,
1179 .resetImageSrc = ResetImageSrc,
1180 .setInitialPixelMap = SetInitialPixelMap,
1181 .setOnComplete = SetOnComplete,
1182 .setOnError = SetOnError,
1183 .resetOnError = ResetOnError,
1184 .setImageOnFinish = SetImageOnFinish,
1185 .resetImageOnFinish = ResetImageOnFinish,
1186 };
1187 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
1188 return &modifier;
1189 }
1190
SetImageOnComplete(ArkUINodeHandle node,void * extraParam)1191 void SetImageOnComplete(ArkUINodeHandle node, void* extraParam)
1192 {
1193 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1194 CHECK_NULL_VOID(frameNode);
1195 auto onEvent = [node, extraParam](const LoadImageSuccessEvent& info) {
1196 ArkUINodeEvent event;
1197 event.kind = COMPONENT_ASYNC_EVENT;
1198 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1199 event.componentAsyncEvent.subKind = ON_IMAGE_COMPLETE;
1200 event.componentAsyncEvent.data[IMAGE_LOAD_STATUS_INDEX].i32 = info.GetLoadingStatus();
1201 event.componentAsyncEvent.data[IMAGE_WIDTH_INDEX].f32 = info.GetWidth();
1202 event.componentAsyncEvent.data[IMAGE_HEIGHT_INDEX].f32 = info.GetHeight();
1203 event.componentAsyncEvent.data[IMAGE_COMPONENT_WIDTH_INDEX].f32 = info.GetComponentWidth();
1204 event.componentAsyncEvent.data[IMAGE_COMPONENT_HEIGHT_INDEX].f32 = info.GetComponentHeight();
1205 event.componentAsyncEvent.data[IMAGE_CONTENT_OFFSET_X_INDEX].f32 = info.GetContentOffsetX();
1206 event.componentAsyncEvent.data[IMAGE_CONTENT_OFFSET_Y_INDEX].f32 = info.GetContentOffsetY();
1207 event.componentAsyncEvent.data[IMAGE_CONTENT_WIDTH_INDEX].f32 = info.GetContentWidth();
1208 event.componentAsyncEvent.data[IMAGE_CONTENT_HEIGHT_INDEX].f32 = info.GetContentHeight();
1209 SendArkUISyncEvent(&event);
1210 };
1211 ImageModelNG::SetOnComplete(frameNode, std::move(onEvent));
1212 }
1213
SetImageOnError(ArkUINodeHandle node,void * extraParam)1214 void SetImageOnError(ArkUINodeHandle node, void* extraParam)
1215 {
1216 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1217 CHECK_NULL_VOID(frameNode);
1218 auto onEvent = [node, extraParam](const LoadImageFailEvent& info) {
1219 ArkUINodeEvent event;
1220 event.kind = COMPONENT_ASYNC_EVENT;
1221 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1222 event.componentAsyncEvent.subKind = ON_IMAGE_ERROR;
1223 event.componentAsyncEvent.data[0].i32 = LOAD_ERROR_CODE;
1224 SendArkUISyncEvent(&event);
1225 };
1226 ImageModelNG::SetOnError(frameNode, std::move(onEvent));
1227 }
1228
SetImageOnSvgPlayFinish(ArkUINodeHandle node,void * extraParam)1229 void SetImageOnSvgPlayFinish(ArkUINodeHandle node, void* extraParam)
1230 {
1231 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1232 CHECK_NULL_VOID(frameNode);
1233 auto onSvgPlayFinishEvent = [node, extraParam]() {
1234 ArkUINodeEvent event;
1235 event.kind = COMPONENT_ASYNC_EVENT;
1236 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1237 event.componentAsyncEvent.subKind = ON_IMAGE_SVG_PLAY_FINISH;
1238 SendArkUISyncEvent(&event);
1239 };
1240 ImageModelNG::SetOnSvgPlayFinish(frameNode, std::move(onSvgPlayFinishEvent));
1241 }
1242
SetImageOnDownloadProgress(ArkUINodeHandle node,void * extraParam)1243 void SetImageOnDownloadProgress(ArkUINodeHandle node, void* extraParam)
1244 {
1245 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1246 CHECK_NULL_VOID(frameNode);
1247 auto onDownloadProgress = [node, extraParam](const uint32_t& dlNow, const uint32_t& dlTotal) {
1248 ArkUINodeEvent event;
1249 event.kind = COMPONENT_ASYNC_EVENT;
1250 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
1251 event.componentAsyncEvent.subKind = ON_IMAGE_DOWNLOAD_PROGRESS;
1252 event.componentAsyncEvent.data[0].u32 = dlNow;
1253 event.componentAsyncEvent.data[1].u32 = dlTotal;
1254 SendArkUISyncEvent(&event);
1255 };
1256 ImageModelNG::SetOnDownloadProgress(frameNode, std::move(onDownloadProgress));
1257 }
1258
ResetImageOnComplete(ArkUINodeHandle node)1259 void ResetImageOnComplete(ArkUINodeHandle node)
1260 {
1261 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1262 CHECK_NULL_VOID(frameNode);
1263 ImageModelNG::SetOnComplete(frameNode, nullptr);
1264 }
ResetImageOnError(ArkUINodeHandle node)1265 void ResetImageOnError(ArkUINodeHandle node)
1266 {
1267 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1268 CHECK_NULL_VOID(frameNode);
1269 ImageModelNG::SetOnError(frameNode, nullptr);
1270 }
ResetImageOnSvgPlayFinish(ArkUINodeHandle node)1271 void ResetImageOnSvgPlayFinish(ArkUINodeHandle node)
1272 {
1273 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1274 CHECK_NULL_VOID(frameNode);
1275 ImageModelNG::SetOnSvgPlayFinish(frameNode, nullptr);
1276 }
ResetImageOnDownloadProgress(ArkUINodeHandle node)1277 void ResetImageOnDownloadProgress(ArkUINodeHandle node)
1278 {
1279 auto* frameNode = reinterpret_cast<FrameNode*>(node);
1280 CHECK_NULL_VOID(frameNode);
1281 ImageModelNG::SetOnDownloadProgress(frameNode, nullptr);
1282 }
1283 } // namespace NodeModifier
1284 } // namespace OHOS::Ace::NG
1285