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