1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "bridge/cj_frontend/interfaces/cj_ffi/cj_view_abstract_ffi.h"
17
18 #include <cinttypes>
19
20 #include "cj_lambda.h"
21 #include "bridge/cj_frontend/interfaces/cj_ffi/matrix4/cj_matrix4_ffi.h"
22 #include "bridge/cj_frontend/interfaces/cj_ffi/cj_pixel_unit_convert_ffi.h"
23 #include "bridge/common/utils/utils.h"
24 #include "core/common/container.h"
25 #include "core/components/theme/theme_manager.h"
26 #include "core/components_ng/base/view_abstract.h"
27 #include "core/components_ng/base/view_abstract_model_ng.h"
28 #include "core/components_ng/base/view_stack_model.h"
29 #include "core/pipeline_ng/pipeline_context.h"
30 #include "core/components_ng/pattern/overlay/modal_style.h"
31 #include "bridge/cj_frontend/cppview/view_abstract.h"
32 #include "bridge/cj_frontend/cppview/shape_abstract.h"
33
34 using namespace OHOS::Ace;
35 using namespace OHOS::FFI;
36 using namespace OHOS::Matrix4;
37 using namespace OHOS::Ace::Framework;
38
39 namespace {
40 using DoubleBindCallback = std::function<void(const std::string&)>;
41 constexpr double FULL_DIMENSION = 100.0;
42 constexpr double HALF_DIMENSION = 50.0;
43 constexpr float ROUND_UNIT = 360.0;
44 constexpr float DEFAULT_BIAS = 0.5f;
45 constexpr double HUNDRED = 100.0;
46 constexpr int SHEET_HEIGHT_MEDIUM = 0;
47 constexpr int SHEET_HEIGHT_LARGE = 1;
48 constexpr int SHEET_HEIGHT_FITCONTENT = 2;
49 constexpr uint32_t COLOR_ALPHA_OFFSET = 24;
50 constexpr uint32_t COLOR_ALPHA_VALUE = 0xFF000000;
51
ColorAlphaAdapt(uint32_t origin)52 uint32_t ColorAlphaAdapt(uint32_t origin)
53 {
54 uint32_t result = origin;
55 if ((origin >> COLOR_ALPHA_OFFSET) == 0) {
56 result = origin | COLOR_ALPHA_VALUE;
57 }
58 return result;
59 }
60 const std::vector<BorderStyle> BORDER_STYLES = { BorderStyle::SOLID, BorderStyle::DASHED, BorderStyle::DOTTED };
61 const std::vector<ImageRepeat> IMAGES_REPEATS = { ImageRepeat::NO_REPEAT, ImageRepeat::REPEAT_X, ImageRepeat::REPEAT_Y,
62 ImageRepeat::REPEAT };
63 const std::vector<BackgroundImageSizeType> IMAGE_SIZES = { BackgroundImageSizeType::CONTAIN,
64 BackgroundImageSizeType::COVER, BackgroundImageSizeType::AUTO };
65 const std::vector<TextDirection> TEXT_DIRECTIONS = { TextDirection::LTR, TextDirection::RTL, TextDirection::AUTO };
66 const std::vector<WindowBlurStyle> WINDOW_BLUR_STYLES = { WindowBlurStyle::STYLE_BACKGROUND_SMALL_LIGHT,
67 WindowBlurStyle::STYLE_BACKGROUND_MEDIUM_LIGHT, WindowBlurStyle::STYLE_BACKGROUND_LARGE_LIGHT,
68 WindowBlurStyle::STYLE_BACKGROUND_XLARGE_LIGHT, WindowBlurStyle::STYLE_BACKGROUND_SMALL_DARK,
69 WindowBlurStyle::STYLE_BACKGROUND_MEDIUM_DARK, WindowBlurStyle::STYLE_BACKGROUND_LARGE_DARK,
70 WindowBlurStyle::STYLE_BACKGROUND_XLARGE_DARK };
71 const std::vector<FlexAlign> ITEM_ALIGNS = { FlexAlign::AUTO, FlexAlign::FLEX_START, FlexAlign::CENTER,
72 FlexAlign::FLEX_END, FlexAlign::STRETCH, FlexAlign::BASELINE };
73 const std::vector<VisibleType> VISIBILITIES = {
74 VisibleType::VISIBLE,
75 VisibleType::INVISIBLE,
76 VisibleType::GONE,
77 };
78 const std::vector<OHOS::Ace::Framework::CJResponseType> RESPONSE_TYPES = {
79 OHOS::Ace::Framework::CJResponseType::RIGHT_CLICK, OHOS::Ace::Framework::CJResponseType::LONGPRESS
80 };
81
82 const std::vector<Align> ALIGNS = { Align::TOP_LEFT, Align::TOP_CENTER, Align::TOP_RIGHT, Align::CENTER_LEFT,
83 Align::CENTER, Align::CENTER_RIGHT, Align::BOTTOM_LEFT, Align::BOTTOM_CENTER, Align::BOTTOM_RIGHT };
84
85 const std::vector<Alignment> ALIGNMENT_LIST = { Alignment::TOP_LEFT, Alignment::TOP_CENTER, Alignment::TOP_RIGHT,
86 Alignment::CENTER_LEFT, Alignment::CENTER, Alignment::CENTER_RIGHT, Alignment::BOTTOM_LEFT,
87 Alignment::BOTTOM_CENTER, Alignment::BOTTOM_RIGHT };
88
89 const std::vector<RenderFit> RENDERFITS = {
90 RenderFit::CENTER,
91 RenderFit::TOP,
92 RenderFit::BOTTOM,
93 RenderFit::LEFT,
94 RenderFit::RIGHT,
95 RenderFit::TOP_LEFT,
96 RenderFit::TOP_RIGHT,
97 RenderFit::BOTTOM_LEFT,
98 RenderFit::BOTTOM_RIGHT,
99 RenderFit::RESIZE_FILL,
100 RenderFit::RESIZE_CONTAIN,
101 RenderFit::RESIZE_CONTAIN_TOP_LEFT,
102 RenderFit::RESIZE_CONTAIN_BOTTOM_RIGHT,
103 RenderFit::RESIZE_COVER,
104 RenderFit::RESIZE_COVER_TOP_LEFT,
105 RenderFit::RESIZE_COVER_BOTTOM_RIGHT
106 };
107
108 // Regex for match the placeholder.
109 const std::regex RESOURCE_APP_STRING_PLACEHOLDER(R"(\%((\d+)(\$)){0,1}([dsf]))", std::regex::icase);
110
UpdateBackgroundImagePosition(const DimensionUnit & typeX,const DimensionUnit & typeY,const double valueX,const double valueY,BackgroundImagePosition & bgImgPosition)111 void UpdateBackgroundImagePosition(const DimensionUnit& typeX, const DimensionUnit& typeY, const double valueX,
112 const double valueY, BackgroundImagePosition& bgImgPosition)
113 {
114 bgImgPosition.SetSizeX(AnimatableDimension(valueX, typeX));
115 bgImgPosition.SetSizeY(AnimatableDimension(valueY, typeY));
116 }
117
UpdateBackgroundImagePosition(const Align & align,BackgroundImagePosition & bgImgPosition)118 void UpdateBackgroundImagePosition(const Align& align, BackgroundImagePosition& bgImgPosition)
119 {
120 switch (static_cast<Align>(align)) {
121 case Align::TOP_LEFT:
122 UpdateBackgroundImagePosition(DimensionUnit::PERCENT, DimensionUnit::PERCENT, 0.0, 0.0, bgImgPosition);
123 break;
124 case Align::TOP_CENTER:
125 UpdateBackgroundImagePosition(
126 DimensionUnit::PERCENT, DimensionUnit::PERCENT, HALF_DIMENSION, 0.0, bgImgPosition);
127 break;
128 case Align::TOP_RIGHT:
129 UpdateBackgroundImagePosition(
130 DimensionUnit::PERCENT, DimensionUnit::PERCENT, FULL_DIMENSION, 0.0, bgImgPosition);
131 break;
132 case Align::CENTER_LEFT:
133 UpdateBackgroundImagePosition(
134 DimensionUnit::PERCENT, DimensionUnit::PERCENT, 0.0, HALF_DIMENSION, bgImgPosition);
135 break;
136 case Align::CENTER:
137 UpdateBackgroundImagePosition(
138 DimensionUnit::PERCENT, DimensionUnit::PERCENT, HALF_DIMENSION, HALF_DIMENSION, bgImgPosition);
139 break;
140 case Align::CENTER_RIGHT:
141 UpdateBackgroundImagePosition(
142 DimensionUnit::PERCENT, DimensionUnit::PERCENT, FULL_DIMENSION, HALF_DIMENSION, bgImgPosition);
143 break;
144 case Align::BOTTOM_LEFT:
145 UpdateBackgroundImagePosition(
146 DimensionUnit::PERCENT, DimensionUnit::PERCENT, 0.0, FULL_DIMENSION, bgImgPosition);
147 break;
148 case Align::BOTTOM_CENTER:
149 UpdateBackgroundImagePosition(
150 DimensionUnit::PERCENT, DimensionUnit::PERCENT, HALF_DIMENSION, FULL_DIMENSION, bgImgPosition);
151 break;
152 case Align::BOTTOM_RIGHT:
153 UpdateBackgroundImagePosition(
154 DimensionUnit::PERCENT, DimensionUnit::PERCENT, FULL_DIMENSION, FULL_DIMENSION, bgImgPosition);
155 break;
156 default:
157 break;
158 }
159 }
160
DealBindPopupParams(bool isShow,const CJBindPopupParams & bindPopupParams,const std::function<void (bool)> & onStateChangeFunc,const std::function<void ()> & primaryActionFunc,const std::function<void ()> & secondaryActionFunc)161 void DealBindPopupParams(bool isShow, const CJBindPopupParams& bindPopupParams,
162 const std::function<void(bool)>& onStateChangeFunc, const std::function<void()>& primaryActionFunc,
163 const std::function<void()>& secondaryActionFunc)
164 {
165 auto popupParam = AceType::MakeRefPtr<PopupParam>();
166 popupParam->SetIsShow(isShow);
167 popupParam->SetMessage(bindPopupParams.message);
168 popupParam->SetPlacement(bindPopupParams.placementOnTop ? Placement::TOP : Placement::BOTTOM);
169 auto onStateChangeCallback = [onStateChangeFunc](const std::string& param) {
170 auto paramData = JsonUtil::ParseJsonString(param);
171 onStateChangeFunc(paramData->GetBool("isVisible"));
172 };
173 popupParam->SetOnStateChange(onStateChangeCallback);
174 std::string primaryString = bindPopupParams.primaryValue;
175 if (!primaryString.empty()) {
176 ButtonProperties propertiesPrimary;
177 propertiesPrimary.value = primaryString;
178 auto touchPrimaryCallback = [primaryActionFunc](TouchEventInfo&) {
179 primaryActionFunc();
180 };
181 auto onNewClick = [primaryActionFunc](const GestureEvent& info) -> void { primaryActionFunc(); };
182 propertiesPrimary.touchFunc = touchPrimaryCallback;
183 propertiesPrimary.action = AceType::MakeRefPtr<NG::ClickEvent>(onNewClick);
184 propertiesPrimary.showButton = true;
185 popupParam->SetPrimaryButtonProperties(propertiesPrimary);
186 }
187
188 std::string secondaryString = bindPopupParams.secondaryValue;
189 if (!secondaryString.empty()) {
190 ButtonProperties propertiesSecondary;
191 propertiesSecondary.value = secondaryString;
192 auto touchSecondaryCallback = [secondaryActionFunc](TouchEventInfo&) {
193 secondaryActionFunc();
194 };
195 auto onNewClick = [secondaryActionFunc](const GestureEvent& info) -> void { secondaryActionFunc(); };
196 propertiesSecondary.touchFunc = touchSecondaryCallback;
197 propertiesSecondary.action = AceType::MakeRefPtr<NG::ClickEvent>(onNewClick);
198 propertiesSecondary.showButton = true;
199 popupParam->SetSecondaryButtonProperties(propertiesSecondary);
200 }
201 ViewAbstractModel::GetInstance()->BindPopup(popupParam, nullptr);
202 }
203
204 /**
205 * Method for replacing placeholders reserved in advance by actual content.
206 * @example "hello %s" -> "hello world"
207 * @param originStr
208 * @param param
209 * @todo Replacing multiple placeholders at the same time
210 */
ReplaceHolder(std::string & originStr,const std::string & param)211 void ReplaceHolder(std::string& originStr, const std::string& param)
212 {
213 std::string::const_iterator start = originStr.begin();
214 std::string::const_iterator end = originStr.end();
215 std::smatch matchs;
216 bool shortHolderType = false;
217 bool firstMatch = true;
218 while (std::regex_search(start, end, matchs, RESOURCE_APP_STRING_PLACEHOLDER)) {
219 std::string pos = matchs[2];
220 std::string type = matchs[4];
221 if (firstMatch) {
222 firstMatch = false;
223 shortHolderType = pos.length() == 0;
224 } else {
225 if (shortHolderType ^ (pos.length() == 0)) {
226 LOGE("wrong place holder,stop parse string");
227 return;
228 }
229 }
230 originStr.replace(matchs[0].first - originStr.begin(), matchs[0].length(), param);
231 start = originStr.begin() + matchs.prefix().length() + param.length();
232 end = originStr.end();
233 }
234 }
235 } // namespace
236
237 extern "C" {
FfiOHOSAceFrameworkViewAbstractSetWidth(double width,int32_t unit)238 void FfiOHOSAceFrameworkViewAbstractSetWidth(double width, int32_t unit)
239 {
240 Dimension value(width, static_cast<DimensionUnit>(unit));
241
242 if (LessNotEqual(value.Value(), 0.0)) {
243 value.SetValue(0.0);
244 }
245 ViewAbstractModel::GetInstance()->SetWidth(value);
246 }
247
FfiOHOSAceFrameworkViewAbstractSetHeight(double height,int32_t unit)248 void FfiOHOSAceFrameworkViewAbstractSetHeight(double height, int32_t unit)
249 {
250 Dimension value(height, static_cast<DimensionUnit>(unit));
251
252 if (LessNotEqual(value.Value(), 0.0)) {
253 value.SetValue(0.0);
254 }
255 ViewAbstractModel::GetInstance()->SetHeight(value);
256 }
257
FFISetWidthWithEmpty()258 void FFISetWidthWithEmpty()
259 {
260 ViewAbstractModel::GetInstance()->ClearWidthOrHeight(true);
261 }
262
FFISetHeightWithEmpty()263 void FFISetHeightWithEmpty()
264 {
265 ViewAbstractModel::GetInstance()->ClearWidthOrHeight(false);
266 }
267
FfiOHOSAceFrameworkViewAbstractSetSize(double width,int32_t widthUnit,double height,int32_t heightUnit)268 void FfiOHOSAceFrameworkViewAbstractSetSize(double width, int32_t widthUnit, double height, int32_t heightUnit)
269 {
270 Dimension widthDime(width, static_cast<DimensionUnit>(widthUnit));
271 Dimension heightDime(height, static_cast<DimensionUnit>(heightUnit));
272
273 if (LessNotEqual(widthDime.Value(), 0.0)) {
274 widthDime.SetValue(0.0);
275 }
276 if (LessNotEqual(heightDime.Value(), 0.0)) {
277 heightDime.SetValue(0.0);
278 }
279 ViewAbstractModel::GetInstance()->SetWidth(widthDime);
280 ViewAbstractModel::GetInstance()->SetHeight(heightDime);
281 }
282
FfiOHOSAceFrameworkViewAbstractSetResponseRegion(CJResponseRegion value)283 void FfiOHOSAceFrameworkViewAbstractSetResponseRegion(CJResponseRegion value)
284 {
285 std::vector<DimensionRect> result;
286 ParseCJResponseRegion(value, result);
287 ViewAbstractModel::GetInstance()->SetResponseRegion(result);
288 }
289
FfiOHOSAceFrameworkViewAbstractSetResponseRegionArray(VectorStringPtr vecContent)290 void FfiOHOSAceFrameworkViewAbstractSetResponseRegionArray(VectorStringPtr vecContent)
291 {
292 std::vector<DimensionRect> result;
293 ParseVectorStringPtr(vecContent, result);
294 ViewAbstractModel::GetInstance()->SetResponseRegion(result);
295 }
296
FfiOHOSAceFrameworkViewAbstractSetConstraintSize(CJConstraintSize value)297 void FfiOHOSAceFrameworkViewAbstractSetConstraintSize(CJConstraintSize value)
298 {
299 Dimension minWidthDime(value.minWidth, static_cast<DimensionUnit>(value.minWidthUnit));
300 Dimension maxWidthDime(value.maxWidth, static_cast<DimensionUnit>(value.maxWidthUnit));
301 Dimension minHeightDime(value.minHeight, static_cast<DimensionUnit>(value.minHeightUnit));
302 Dimension maxHeightDime(value.maxHeight, static_cast<DimensionUnit>(value.maxHeightUnit));
303
304 ViewAbstractModel::GetInstance()->SetMinWidth(minWidthDime);
305 ViewAbstractModel::GetInstance()->SetMaxWidth(maxWidthDime);
306 ViewAbstractModel::GetInstance()->SetMinHeight(minHeightDime);
307 ViewAbstractModel::GetInstance()->SetMaxHeight(maxHeightDime);
308 }
309
FfiOHOSAceFrameworkViewAbstractSetLayoutPriority(int32_t value)310 void FfiOHOSAceFrameworkViewAbstractSetLayoutPriority(int32_t value)
311 {
312 ViewAbstractModel::GetInstance()->SetLayoutPriority(value);
313 }
314
FfiOHOSAceFrameworkViewAbstractSetLayoutWeight(int32_t value)315 void FfiOHOSAceFrameworkViewAbstractSetLayoutWeight(int32_t value)
316 {
317 ViewAbstractModel::GetInstance()->SetLayoutWeight(value);
318 }
319
FfiOHOSAceFrameworkViewAbstractSetBorder(CJBorder params)320 void FfiOHOSAceFrameworkViewAbstractSetBorder(CJBorder params)
321 {
322 Dimension widthDime(params.width, static_cast<DimensionUnit>(params.widthUnit));
323 Dimension radiusDime(params.radius, static_cast<DimensionUnit>(params.radiusUnit));
324 if (!Utils::CheckParamsValid(params.style, BORDER_STYLES.size())) {
325 LOGE("invalid value for border style");
326 return;
327 }
328
329 ViewAbstractModel::GetInstance()->SetBorderWidth(widthDime);
330 ViewAbstractModel::GetInstance()->SetBorderColor(Color(params.color));
331 ViewAbstractModel::GetInstance()->SetBorderRadius(radiusDime);
332 ViewAbstractModel::GetInstance()->SetBorderStyle(BORDER_STYLES[params.style]);
333 }
334
FfiOHOSAceFrameworkViewAbstractSetBorderWidth(double width,int32_t unit)335 void FfiOHOSAceFrameworkViewAbstractSetBorderWidth(double width, int32_t unit)
336 {
337 Dimension value(width, static_cast<DimensionUnit>(unit));
338
339 ViewAbstractModel::GetInstance()->SetBorderWidth(value);
340 }
341
FfiOHOSAceFrameworkViewAbstractSetBorderWidthWithCJEdge(CJEdge params)342 void FfiOHOSAceFrameworkViewAbstractSetBorderWidthWithCJEdge(CJEdge params)
343 {
344 std::optional<CalcDimension> leftDimen;
345 std::optional<CalcDimension> rightDimen;
346 std::optional<CalcDimension> topDimen;
347 std::optional<CalcDimension> bottomDimen;
348 CalcDimension left(params.left, static_cast<DimensionUnit>(params.leftUnit));
349 CalcDimension right(params.right, static_cast<DimensionUnit>(params.rightUnit));
350 CalcDimension top(params.top, static_cast<DimensionUnit>(params.topUnit));
351 CalcDimension bottom(params.bottom, static_cast<DimensionUnit>(params.bottomUnit));
352
353 if (left.Unit() == DimensionUnit::PERCENT || left.IsNegative()) {
354 left.Reset();
355 }
356 leftDimen = left;
357
358 if (right.Unit() == DimensionUnit::PERCENT || right.IsNegative()) {
359 right.Reset();
360 }
361 rightDimen = right;
362
363 if (top.Unit() == DimensionUnit::PERCENT || top.IsNegative()) {
364 top.Reset();
365 }
366 topDimen = top;
367
368 if (bottom.Unit() == DimensionUnit::PERCENT || bottom.IsNegative()) {
369 bottom.Reset();
370 }
371 bottomDimen = bottom;
372
373 ViewAbstractModel::GetInstance()->SetBorderWidth(leftDimen, rightDimen, topDimen, bottomDimen);
374 }
375
FfiOHOSAceFrameworkViewAbstractSetBorderColor(uint32_t color)376 void FfiOHOSAceFrameworkViewAbstractSetBorderColor(uint32_t color)
377 {
378 ViewAbstractModel::GetInstance()->SetBorderColor(Color(color));
379 }
380
FfiOHOSAceFrameworkViewAbstractSetBorderRadius(double radius,int32_t unit)381 void FfiOHOSAceFrameworkViewAbstractSetBorderRadius(double radius, int32_t unit)
382 {
383 Dimension value(radius, static_cast<DimensionUnit>(unit));
384
385 ViewAbstractModel::GetInstance()->SetBorderRadius(value);
386 }
387
FfiOHOSAceFrameworkViewAbstractSetAllBorderRadius(CJBorderRadius value)388 void FfiOHOSAceFrameworkViewAbstractSetAllBorderRadius(CJBorderRadius value)
389 {
390 CalcDimension topLeft(value.topLeft, static_cast<DimensionUnit>(value.topLeftUnit));
391 CalcDimension topRight(value.topRight, static_cast<DimensionUnit>(value.topRightUnit));
392 CalcDimension bottomLeft(value.bottomLeft, static_cast<DimensionUnit>(value.bottomLeftUnit));
393 CalcDimension bottomRight(value.bottomRight, static_cast<DimensionUnit>(value.bottomRightUnit));
394 ViewAbstractModel::GetInstance()->SetBorderRadius(topLeft, topRight, bottomLeft, bottomRight);
395 }
396
FfiOHOSAceFrameworkViewAbstractSetBorderStyle(int32_t style)397 void FfiOHOSAceFrameworkViewAbstractSetBorderStyle(int32_t style)
398 {
399 if (!Utils::CheckParamsValid(style, BORDER_STYLES.size())) {
400 LOGE("invalid value for border style");
401 return;
402 }
403
404 ViewAbstractModel::GetInstance()->SetBorderStyle(BORDER_STYLES[style]);
405 }
406
FfiOHOSAceFrameworkViewAbstractSetMargin(double margin,int32_t unit)407 void FfiOHOSAceFrameworkViewAbstractSetMargin(double margin, int32_t unit)
408 {
409 Dimension value(margin, static_cast<DimensionUnit>(unit));
410
411 ViewAbstractModel::GetInstance()->SetMargin(value);
412 }
413
FfiOHOSAceFrameworkViewAbstractSetMargins(CJEdge params)414 void FfiOHOSAceFrameworkViewAbstractSetMargins(CJEdge params)
415 {
416 Dimension topDime(params.top, static_cast<DimensionUnit>(params.topUnit));
417 Dimension rightDime(params.right, static_cast<DimensionUnit>(params.rightUnit));
418 Dimension bottomDime(params.bottom, static_cast<DimensionUnit>(params.bottomUnit));
419 Dimension leftDime(params.left, static_cast<DimensionUnit>(params.leftUnit));
420
421 ViewAbstractModel::GetInstance()->SetMargins(topDime, bottomDime, leftDime, rightDime);
422 }
423
FfiOHOSAceFrameworkViewAbstractSetPadding(double padding,int32_t unit)424 void FfiOHOSAceFrameworkViewAbstractSetPadding(double padding, int32_t unit)
425 {
426 Dimension value(padding, static_cast<DimensionUnit>(unit));
427
428 ViewAbstractModel::GetInstance()->SetPadding(value);
429 }
430
FfiOHOSAceFrameworkViewAbstractSetPaddings(CJEdge params)431 void FfiOHOSAceFrameworkViewAbstractSetPaddings(CJEdge params)
432 {
433 Dimension topDime(params.top, static_cast<DimensionUnit>(params.topUnit));
434 Dimension rightDime(params.right, static_cast<DimensionUnit>(params.rightUnit));
435 Dimension bottomDime(params.bottom, static_cast<DimensionUnit>(params.bottomUnit));
436 Dimension leftDime(params.left, static_cast<DimensionUnit>(params.leftUnit));
437
438 ViewAbstractModel::GetInstance()->SetPaddings(topDime, bottomDime, leftDime, rightDime);
439 }
440
FfiOHOSAceFrameworkViewAbstractSetForegroundBlurStyleOption(int32_t blurStyle,CJForegroundBlurStyle options)441 void FfiOHOSAceFrameworkViewAbstractSetForegroundBlurStyleOption(int32_t blurStyle, CJForegroundBlurStyle options)
442 {
443 BlurStyleOption styleOption;
444 if (blurStyle >= static_cast<int>(BlurStyle::NO_MATERIAL) &&
445 blurStyle <= static_cast<int>(BlurStyle::COMPONENT_ULTRA_THICK)) {
446 styleOption.blurStyle = static_cast<BlurStyle>(blurStyle);
447 }
448
449 auto colorMode = options.colorMode;
450 if (colorMode >= static_cast<int32_t>(ThemeColorMode::SYSTEM) &&
451 colorMode <= static_cast<int32_t>(ThemeColorMode::DARK)) {
452 styleOption.colorMode = static_cast<ThemeColorMode>(colorMode);
453 }
454
455 auto adaptiveColor = options.adaptiveColor;
456 if (adaptiveColor >= static_cast<int32_t>(AdaptiveColor::DEFAULT) &&
457 adaptiveColor <= static_cast<int32_t>(AdaptiveColor::AVERAGE)) {
458 styleOption.adaptiveColor = static_cast<AdaptiveColor>(adaptiveColor);
459 }
460
461 BlurOption blurOption;
462 std::vector<float> greyVec(2); // 2 number
463 greyVec[0] = options.blurOptions.grayscale[0];
464 greyVec[1] = options.blurOptions.grayscale[1];
465 blurOption.grayscale = greyVec;
466 styleOption.blurOption = blurOption;
467 ViewAbstractModel::GetInstance()->SetForegroundBlurStyle(styleOption);
468 }
469
FfiOHOSAceFrameworkViewAbstractSetForegroundBlurStyle(int32_t blurStyle)470 void FfiOHOSAceFrameworkViewAbstractSetForegroundBlurStyle(int32_t blurStyle)
471 {
472 BlurStyleOption styleOption;
473 if (blurStyle >= static_cast<int>(BlurStyle::NO_MATERIAL) &&
474 blurStyle <= static_cast<int>(BlurStyle::COMPONENT_ULTRA_THICK)) {
475 styleOption.blurStyle = static_cast<BlurStyle>(blurStyle);
476 }
477 ViewAbstractModel::GetInstance()->SetForegroundBlurStyle(styleOption);
478 }
479
FfiOHOSAceFrameworkViewAbstractSetForegroundColor(char * strategy)480 void FfiOHOSAceFrameworkViewAbstractSetForegroundColor(char* strategy)
481 {
482 if (strcmp(strategy, "invert") == 0) {
483 ForegroundColorStrategy cStrategy = ForegroundColorStrategy::INVERT;
484 ViewAbstractModel::GetInstance()->SetForegroundColorStrategy(cStrategy);
485 }
486 }
487
FfiOHOSAceFrameworkViewAbstractSetForegroundResourceColor(uint32_t color)488 void FfiOHOSAceFrameworkViewAbstractSetForegroundResourceColor(uint32_t color)
489 {
490 ViewAbstractModel::GetInstance()->SetForegroundColor(Color(color));
491 }
492
FfiOHOSAceFrameworkViewAbstractSetBackgroundColor(uint32_t color)493 void FfiOHOSAceFrameworkViewAbstractSetBackgroundColor(uint32_t color)
494 {
495 ViewAbstractModel::GetInstance()->SetBackgroundColor(Color(color));
496 }
497
FfiOHOSAceFrameworkViewAbstractSetBackgroundImage(const char * src,int32_t repeat)498 void FfiOHOSAceFrameworkViewAbstractSetBackgroundImage(const char* src, int32_t repeat)
499 {
500 if (!Utils::CheckParamsValid(repeat, IMAGES_REPEATS.size())) {
501 LOGE("invalid value for image repeat");
502 return;
503 }
504
505 ImageSourceInfo info(src);
506 ViewAbstractModel::GetInstance()->SetBackgroundImage(info, nullptr);
507 ViewAbstractModel::GetInstance()->SetBackgroundImageRepeat(IMAGES_REPEATS[repeat]);
508 }
509
FfiOHOSAceFrameworkViewAbstractSetBackgroundImageSizeType(int32_t imageSize)510 void FfiOHOSAceFrameworkViewAbstractSetBackgroundImageSizeType(int32_t imageSize)
511 {
512 if (!Utils::CheckParamsValid(imageSize, IMAGE_SIZES.size())) {
513 LOGE("invalid value for image repeat");
514 return;
515 }
516 BackgroundImageSize bgImgSize;
517
518 bgImgSize.SetSizeTypeX(IMAGE_SIZES[imageSize]);
519 bgImgSize.SetSizeTypeY(IMAGE_SIZES[imageSize]);
520
521 ViewAbstractModel::GetInstance()->SetBackgroundImageSize(bgImgSize);
522 }
523
FfiOHOSAceFrameworkViewAbstractSetBackgroundImageSize(double width,int32_t widthUnit,double height,int32_t heightUnit)524 void FfiOHOSAceFrameworkViewAbstractSetBackgroundImageSize(
525 double width, int32_t widthUnit, double height, int32_t heightUnit)
526 {
527 Dimension widthDime(width, static_cast<DimensionUnit>(widthUnit));
528 Dimension heightDime(height, static_cast<DimensionUnit>(heightUnit));
529
530 BackgroundImageSize bgImgSize;
531
532 double valueWidth = widthDime.ConvertToPx();
533 double valueHeight = heightDime.ConvertToPx();
534 BackgroundImageSizeType typeWidth = BackgroundImageSizeType::LENGTH;
535 BackgroundImageSizeType typeHeight = BackgroundImageSizeType::LENGTH;
536 if (widthDime.Unit() == DimensionUnit::PERCENT) {
537 typeWidth = BackgroundImageSizeType::PERCENT;
538 valueWidth = widthDime.Value() * FULL_DIMENSION;
539 }
540 if (heightDime.Unit() == DimensionUnit::PERCENT) {
541 typeHeight = BackgroundImageSizeType::PERCENT;
542 valueHeight = heightDime.Value() * FULL_DIMENSION;
543 }
544 bgImgSize.SetSizeTypeX(typeWidth);
545 bgImgSize.SetSizeValueX(valueWidth);
546 bgImgSize.SetSizeTypeY(typeHeight);
547 bgImgSize.SetSizeValueY(valueHeight);
548
549 ViewAbstractModel::GetInstance()->SetBackgroundImageSize(bgImgSize);
550 }
551
FfiOHOSAceFrameworkViewAbstractSetBackgroundImagePositionAlign(int32_t align)552 void FfiOHOSAceFrameworkViewAbstractSetBackgroundImagePositionAlign(int32_t align)
553 {
554 if (!Utils::CheckParamsValid(align, ALIGNS.size())) {
555 LOGE("invalid value for align");
556 return;
557 }
558 BackgroundImagePosition bgImgPosition;
559 bgImgPosition.SetIsAlign(true);
560 UpdateBackgroundImagePosition(static_cast<Align>(align), bgImgPosition);
561 ViewAbstractModel::GetInstance()->SetBackgroundImagePosition(bgImgPosition);
562 }
563
FfiOHOSAceFrameworkViewAbstractSetBackgroundImagePositionXY(double x,int32_t xUnit,double y,int32_t yUnit)564 void FfiOHOSAceFrameworkViewAbstractSetBackgroundImagePositionXY(double x, int32_t xUnit, double y, int32_t yUnit)
565 {
566 Dimension xDime(x, static_cast<DimensionUnit>(xUnit));
567 Dimension yDime(y, static_cast<DimensionUnit>(yUnit));
568
569 BackgroundImagePosition bgImgPosition;
570
571 DimensionUnit typeX = xDime.Unit();
572 DimensionUnit typeY = yDime.Unit();
573 double valueX = xDime.ConvertToPx();
574 double valueY = yDime.ConvertToPx();
575 if (xDime.Unit() == DimensionUnit::LPX) {
576 valueX = FfiOHOSAceFrameworkLpx2Px(xDime.Value());
577 }
578 if (yDime.Unit() == DimensionUnit::LPX) {
579 valueY = FfiOHOSAceFrameworkLpx2Px(yDime.Value());
580 }
581 if (xDime.Unit() == DimensionUnit::PERCENT) {
582 valueX = xDime.Value();
583 }
584 if (yDime.Unit() == DimensionUnit::PERCENT) {
585 valueY = yDime.Value();
586 }
587 UpdateBackgroundImagePosition(typeX, typeY, valueX, valueY, bgImgPosition);
588
589 ViewAbstractModel::GetInstance()->SetBackgroundImagePosition(bgImgPosition);
590 }
591
FfiOHOSAceFrameworkViewAbstractSetScale(CJSetScale value)592 void FfiOHOSAceFrameworkViewAbstractSetScale(CJSetScale value)
593 {
594 Dimension centerXValue(value.centerX, static_cast<DimensionUnit>(value.centerXUnit));
595 Dimension centerYValue(value.centerY, static_cast<DimensionUnit>(value.centerYUnit));
596 ViewAbstractModel::GetInstance()->SetScale(value.scaleX, value.scaleY, value.scaleZ);
597 ViewAbstractModel::GetInstance()->SetPivot(centerXValue, centerYValue, Dimension(0));
598 }
599
FfiOHOSAceFrameworkViewAbstractSetScaleSingle(float scale)600 void FfiOHOSAceFrameworkViewAbstractSetScaleSingle(float scale)
601 {
602 ViewAbstractModel::GetInstance()->SetScale(scale, scale, 1.0f);
603 }
604
FfiOHOSAceFrameworkViewAbstractSetScaleX(float scaleVal)605 void FfiOHOSAceFrameworkViewAbstractSetScaleX(float scaleVal)
606 {
607 ViewAbstractModel::GetInstance()->SetScale(scaleVal, 1.0f, 1.0f);
608 }
609
FfiOHOSAceFrameworkViewAbstractSetScaleY(float scaleVal)610 void FfiOHOSAceFrameworkViewAbstractSetScaleY(float scaleVal)
611 {
612 ViewAbstractModel::GetInstance()->SetScale(1.0f, scaleVal, 1.0f);
613 }
614
FfiOHOSAceFrameworkViewAbstractSetOpacity(double opacity)615 void FfiOHOSAceFrameworkViewAbstractSetOpacity(double opacity)
616 {
617 ViewAbstractModel::GetInstance()->SetOpacity(opacity);
618 }
619
FfiOHOSAceFrameworkViewAbstractSetRotate(CJSetRotate value)620 void FfiOHOSAceFrameworkViewAbstractSetRotate(CJSetRotate value)
621 {
622 Dimension centerXValue(value.centerX, static_cast<DimensionUnit>(value.centerXUnit));
623 Dimension centerYValue(value.centerY, static_cast<DimensionUnit>(value.centerYUnit));
624 ViewAbstractModel::GetInstance()->SetRotate(value.dx, value.dy, value.dz, value.angle);
625 ViewAbstractModel::GetInstance()->SetPivot(centerXValue, centerYValue, Dimension(0));
626 }
627
FfiOHOSAceFrameworkViewAbstractSetRotateSingle(float rotateZ)628 void FfiOHOSAceFrameworkViewAbstractSetRotateSingle(float rotateZ)
629 {
630 ViewAbstractModel::GetInstance()->SetRotate(0.0f, 0.0f, 1.0f, rotateZ);
631 }
632
FfiOHOSAceFrameworkViewAbstractSetRotateX(float rotateVal)633 void FfiOHOSAceFrameworkViewAbstractSetRotateX(float rotateVal)
634 {
635 ViewAbstractModel::GetInstance()->SetRotate(1.0f, 0.0f, 0.0f, rotateVal);
636 }
637
FfiOHOSAceFrameworkViewAbstractSetRotateY(float rotateVal)638 void FfiOHOSAceFrameworkViewAbstractSetRotateY(float rotateVal)
639 {
640 ViewAbstractModel::GetInstance()->SetRotate(0.0f, 1.0f, 0.0f, rotateVal);
641 }
642
FfiOHOSAceFrameworkViewAbstractSetTranslate(CJTranslate value)643 void FfiOHOSAceFrameworkViewAbstractSetTranslate(CJTranslate value)
644 {
645 Dimension translateX(value.x, static_cast<DimensionUnit>(value.xUnit));
646 Dimension translateY(value.y, static_cast<DimensionUnit>(value.yUnit));
647 Dimension translateZ(value.z, static_cast<DimensionUnit>(value.zUnit));
648 ViewAbstractModel::GetInstance()->SetTranslate(translateX, translateY, translateZ);
649 }
650
FfiOHOSAceFrameworkViewAbstractSetTranslateSingle(double translateValue,int32_t translateUnit)651 void FfiOHOSAceFrameworkViewAbstractSetTranslateSingle(double translateValue, int32_t translateUnit)
652 {
653 Dimension translate(translateValue, static_cast<DimensionUnit>(translateUnit));
654 ViewAbstractModel::GetInstance()->SetTranslate(translate, translate, translate);
655 }
656
FfiOHOSAceFrameworkViewAbstractSetTranslateX(double translateValue,int32_t translateUnit)657 void FfiOHOSAceFrameworkViewAbstractSetTranslateX(double translateValue, int32_t translateUnit)
658 {
659 Dimension translate(translateValue, static_cast<DimensionUnit>(translateUnit));
660 ViewAbstractModel::GetInstance()->SetTranslate(translate, 0.0_px, 0.0_px);
661 }
662
FfiOHOSAceFrameworkViewAbstractSetTranslateY(double translateValue,int32_t translateUnit)663 void FfiOHOSAceFrameworkViewAbstractSetTranslateY(double translateValue, int32_t translateUnit)
664 {
665 Dimension translate(translateValue, static_cast<DimensionUnit>(translateUnit));
666 ViewAbstractModel::GetInstance()->SetTranslate(0.0_px, translate, 0.0_px);
667 }
668
FfiOHOSAceFrameworkViewAbstractSetTransition()669 void FfiOHOSAceFrameworkViewAbstractSetTransition()
670 {
671 ViewAbstractModel::GetInstance()->SetTransition(
672 NG::TransitionOptions::GetDefaultTransition(TransitionType::ALL)
673 );
674 }
675
FfiOHOSAceFrameworkViewAbstractTransition(int64_t id)676 void FfiOHOSAceFrameworkViewAbstractTransition(int64_t id)
677 {
678 auto nativeTransitionEffect = FFIData::GetData<NativeTransitionEffect>(id);
679 if (nativeTransitionEffect == nullptr) {
680 return;
681 }
682 auto chainedEffect = nativeTransitionEffect->effect;
683 ViewAbstractModel::GetInstance()->SetChainedTransition(chainedEffect);
684 }
685
FfiOHOSAceFrameworkViewAbstractSetTransform(int64_t id)686 void FfiOHOSAceFrameworkViewAbstractSetTransform(int64_t id)
687 {
688 auto nativeMatrix = FFIData::GetData<NativeMatrix>(id);
689 if (nativeMatrix != nullptr) {
690 auto matrix4 = nativeMatrix->GetMatrix4();
691 const auto matrix4Len = Matrix4::DIMENSION * Matrix4::DIMENSION;
692 std::vector<float> matrixVector(matrix4Len);
693 for (int32_t i = 0; i < matrix4Len; i++) {
694 matrixVector[i] = matrix4[i];
695 }
696 ViewAbstractModel::GetInstance()->SetTransformMatrix(matrixVector);
697 } else {
698 LOGE("FfiOHOSMatrix4Translate: invalid id of Matrix");
699 }
700 }
701
FfiOHOSAceFrameworkViewAbstractSetAlign(int32_t value)702 void FfiOHOSAceFrameworkViewAbstractSetAlign(int32_t value)
703 {
704 if (!Utils::CheckParamsValid(value, ALIGNMENT_LIST.size())) {
705 LOGE("set align error, invalid value for alignment");
706 return;
707 }
708 ViewAbstractModel::GetInstance()->SetAlign(ALIGNMENT_LIST[value]);
709 }
710
FfiOHOSAceFrameworkViewAbstractSetDirection(int32_t dirValue)711 void FfiOHOSAceFrameworkViewAbstractSetDirection(int32_t dirValue)
712 {
713 if (!Utils::CheckParamsValid(dirValue, TEXT_DIRECTIONS.size())) {
714 LOGE("invalid value for text direction");
715 return;
716 }
717 ViewAbstractModel::GetInstance()->SetLayoutDirection(TEXT_DIRECTIONS[dirValue]);
718 }
719
FfiOHOSAceFrameworkViewAbstractSetPosition(double x,int32_t xUnit,double y,int32_t yUnit)720 void FfiOHOSAceFrameworkViewAbstractSetPosition(double x, int32_t xUnit, double y, int32_t yUnit)
721 {
722 Dimension dx(x, static_cast<DimensionUnit>(xUnit));
723 Dimension dy(y, static_cast<DimensionUnit>(yUnit));
724 ViewAbstractModel::GetInstance()->SetPosition(dx, dy);
725 }
726
FfiOHOSAceFrameworkViewAbstractSetMarkAnchor(double x,int32_t xUnit,double y,int32_t yUnit)727 void FfiOHOSAceFrameworkViewAbstractSetMarkAnchor(double x, int32_t xUnit, double y, int32_t yUnit)
728 {
729 Dimension dx(x, static_cast<DimensionUnit>(xUnit));
730 Dimension dy(y, static_cast<DimensionUnit>(yUnit));
731 ViewAbstractModel::GetInstance()->MarkAnchor(dx, dy);
732 }
733
FfiOHOSAceFrameworkViewAbstractSetOffset(double x,int32_t xUnit,double y,int32_t yUnit)734 void FfiOHOSAceFrameworkViewAbstractSetOffset(double x, int32_t xUnit, double y, int32_t yUnit)
735 {
736 Dimension dx(x, static_cast<DimensionUnit>(xUnit));
737 Dimension dy(y, static_cast<DimensionUnit>(yUnit));
738 ViewAbstractModel::GetInstance()->SetOffset(dx, dy);
739 }
740
FfiOHOSAceFrameworkViewAbstractSetAlignRules(CJAlignRuleOption option)741 void FfiOHOSAceFrameworkViewAbstractSetAlignRules(CJAlignRuleOption option)
742 {
743 std::map<AlignDirection, AlignRule> alignRules;
744 BiasPair biasPair(DEFAULT_BIAS, DEFAULT_BIAS);
745 if (option.leftAnchor != nullptr) {
746 AlignRule alignRule;
747 alignRule.anchor = std::string(option.leftAnchor);
748 alignRule.horizontal = static_cast<HorizontalAlign>(option.leftHorizontalAlign);
749 alignRules[AlignDirection::LEFT] = alignRule;
750 }
751 if (option.middleAnchor != nullptr) {
752 AlignRule alignRule;
753 alignRule.anchor = std::string(option.middleAnchor);
754 alignRule.horizontal = static_cast<HorizontalAlign>(option.middleHorizontalAlign);
755 alignRules[AlignDirection::MIDDLE] = alignRule;
756 }
757 if (option.rightAnchor != nullptr) {
758 AlignRule alignRule;
759 alignRule.anchor = std::string(option.rightAnchor);
760 alignRule.horizontal = static_cast<HorizontalAlign>(option.rightHorizontalAlign);
761 alignRules[AlignDirection::RIGHT] = alignRule;
762 }
763 if (option.topAnchor != nullptr) {
764 AlignRule alignRule;
765 alignRule.anchor = std::string(option.topAnchor);
766 alignRule.vertical = static_cast<VerticalAlign>(option.topVerticalAlign);
767 alignRules[AlignDirection::TOP] = alignRule;
768 }
769 if (option.centerAnchor != nullptr) {
770 AlignRule alignRule;
771 alignRule.anchor = std::string(option.centerAnchor);
772 alignRule.vertical = static_cast<VerticalAlign>(option.centerVerticalAlign);
773 alignRules[AlignDirection::CENTER] = alignRule;
774 }
775 if (option.bottomAnchor != nullptr) {
776 AlignRule alignRule;
777 alignRule.anchor = std::string(option.bottomAnchor);
778 alignRule.vertical = static_cast<VerticalAlign>(option.bottomVerticalAlign);
779 alignRules[AlignDirection::BOTTOM] = alignRule;
780 }
781 if (option.horizontalBias != nullptr) {
782 biasPair.first = *option.horizontalBias;
783 }
784 if (option.verticalBias != nullptr) {
785 biasPair.second = *option.verticalBias;
786 }
787
788 ViewAbstractModel::GetInstance()->SetAlignRules(alignRules);
789 ViewAbstractModel::GetInstance()->SetBias(biasPair);
790 }
791
FfiOHOSAceFrameworkViewAbstractSetEnabled(bool value)792 void FfiOHOSAceFrameworkViewAbstractSetEnabled(bool value)
793 {
794 ViewAbstractModel::GetInstance()->SetEnabled(value);
795 }
796
FfiOHOSAceFrameworkViewAbstractSetAspectRatio(double value)797 void FfiOHOSAceFrameworkViewAbstractSetAspectRatio(double value)
798 {
799 ViewAbstractModel::GetInstance()->SetAspectRatio(static_cast<float>(value));
800 }
801
FfiOHOSAceFrameworkViewAbstractSetDisplayPriority(int32_t value)802 void FfiOHOSAceFrameworkViewAbstractSetDisplayPriority(int32_t value)
803 {
804 ViewAbstractModel::GetInstance()->SetDisplayIndex(value);
805 }
806
FfiOHOSAceFrameworkViewAbstractSetSharedTransition(char * shareId,CJSharedTransitionOptions option)807 void FfiOHOSAceFrameworkViewAbstractSetSharedTransition(char* shareId, CJSharedTransitionOptions option)
808 {
809 std::shared_ptr<SharedTransitionOption> sharedOption;
810 sharedOption = std::make_shared<SharedTransitionOption>();
811
812 sharedOption->duration = option.duration;
813 sharedOption->curve = CreateCurve(std::string(option.curve), false);
814
815 MotionPathOption motionPathOption;
816 if (!std::string(option.motionPathOption.path).empty()) {
817 motionPathOption.SetPath(std::string(option.motionPathOption.path));
818 double from = option.motionPathOption.from;
819 double to = option.motionPathOption.to;
820 if (from > 1.0 || from < 0.0) {
821 from = 0.0;
822 }
823 if (to > 1.0 || to < 0.0) {
824 from = 1.0;
825 } else if (to < from) {
826 to = from;
827 }
828 motionPathOption.SetBegin(static_cast<float>(from));
829 motionPathOption.SetEnd(static_cast<float>(to));
830 motionPathOption.SetRotate(option.motionPathOption.rotatable);
831 sharedOption->motionPathOption = motionPathOption;
832 }
833
834 sharedOption->delay = option.delay;
835 sharedOption->zIndex = option.zIndex;
836 sharedOption->type = static_cast<SharedTransitionEffectType>(option.type);
837
838 ViewAbstractModel::GetInstance()->SetSharedTransition(std::string(shareId), sharedOption);
839 }
840
FfiOHOSAceFrameworkViewAbstractSetGeometryTransition(char * id,CJGeometryTransitionOptions option)841 void FfiOHOSAceFrameworkViewAbstractSetGeometryTransition(char* id, CJGeometryTransitionOptions option)
842 {
843 bool followWithoutTransition = option.follow;
844 bool doRegisterSharedTransition = true;
845 switch (option.hierarchyStrategy) {
846 case 0:
847 doRegisterSharedTransition = false;
848 break;
849 case 1:
850 doRegisterSharedTransition = true;
851 break;
852 default:
853 break;
854 }
855 ViewAbstractModel::GetInstance()->SetGeometryTransition(
856 std::string(id), followWithoutTransition, doRegisterSharedTransition);
857 }
858
FfiOHOSAceFrameworkViewAbstractSetBlur(double value)859 void FfiOHOSAceFrameworkViewAbstractSetBlur(double value)
860 {
861 Dimension radius(value, DimensionUnit::PX);
862 BlurOption options;
863 ViewAbstractModel::GetInstance()->SetFrontBlur(radius, options);
864 }
865
FfiOHOSAceFrameworkViewAbstractSetColorBlend(uint32_t color)866 void FfiOHOSAceFrameworkViewAbstractSetColorBlend(uint32_t color)
867 {
868 ViewAbstractModel::GetInstance()->SetColorBlend(Color(color));
869 }
870
FfiOHOSAceFrameworkViewAbstractSetBackdropBlur(double value)871 void FfiOHOSAceFrameworkViewAbstractSetBackdropBlur(double value)
872 {
873 Dimension radius(value, DimensionUnit::PX);
874 BlurOption options;
875 ViewAbstractModel::GetInstance()->SetBackdropBlur(radius, options);
876 }
877
FfiOHOSAceFrameworkViewAbstractSetWindowBlur(float progress,int32_t styleValue)878 void FfiOHOSAceFrameworkViewAbstractSetWindowBlur(float progress, int32_t styleValue)
879 {
880 if (!Utils::CheckParamsValid(styleValue, WINDOW_BLUR_STYLES.size())) {
881 LOGE("invalid value for window blur style");
882 return;
883 }
884 ViewAbstractModel::GetInstance()->SetWindowBlur(progress, WINDOW_BLUR_STYLES[styleValue]);
885 }
886
FfiOHOSAceFrameworkViewAbstractSetShadow(double radius,uint32_t color,double offsetX,double offsetY)887 void FfiOHOSAceFrameworkViewAbstractSetShadow(double radius, uint32_t color, double offsetX, double offsetY)
888 {
889 Dimension dOffsetX(offsetX, DimensionUnit::VP);
890 Dimension dOffsetY(offsetY, DimensionUnit::VP);
891 if (LessOrEqual(radius, 0.0)) {
892 LOGE("Shadow Parse radius failed, radius = %{public}lf", radius);
893 return;
894 }
895 std::vector<Shadow> shadows(1);
896 shadows.begin()->SetBlurRadius(radius);
897 shadows.begin()->SetOffsetX(dOffsetX.Value());
898 shadows.begin()->SetOffsetY(dOffsetY.Value());
899 shadows.begin()->SetColor(Color(color));
900 ViewAbstractModel::GetInstance()->SetBackShadow(shadows);
901 }
902
FfiOHOSAceFrameworkViewAbstractSetGrayScale(double value)903 void FfiOHOSAceFrameworkViewAbstractSetGrayScale(double value)
904 {
905 Dimension dValue(value, DimensionUnit::VP);
906 if (LessNotEqual(dValue.Value(), 0.0)) {
907 dValue.SetValue(0.0);
908 }
909 if (GreatNotEqual(dValue.Value(), 1.0)) {
910 dValue.SetValue(1.0);
911 }
912 ViewAbstractModel::GetInstance()->SetGrayScale(dValue);
913 }
914
FfiOHOSAceFrameworkViewAbstractSetBrightness(double value)915 void FfiOHOSAceFrameworkViewAbstractSetBrightness(double value)
916 {
917 Dimension dValue(value, DimensionUnit::VP);
918 ViewAbstractModel::GetInstance()->SetBrightness(dValue);
919 }
920
FfiOHOSAceFrameworkViewAbstractSetSaturate(double value)921 void FfiOHOSAceFrameworkViewAbstractSetSaturate(double value)
922 {
923 Dimension dValue(value, DimensionUnit::VP);
924 if (LessNotEqual(dValue.Value(), 0.0)) {
925 dValue.SetValue(0.0);
926 }
927 ViewAbstractModel::GetInstance()->SetSaturate(dValue);
928 }
929
FfiOHOSAceFrameworkViewAbstractSetContrast(double value)930 void FfiOHOSAceFrameworkViewAbstractSetContrast(double value)
931 {
932 Dimension dValue(value, DimensionUnit::VP);
933 if (LessNotEqual(dValue.Value(), 0.0)) {
934 dValue.SetValue(0.0);
935 }
936 ViewAbstractModel::GetInstance()->SetContrast(dValue);
937 }
938
FfiOHOSAceFrameworkViewAbstractSetInvert(double value)939 void FfiOHOSAceFrameworkViewAbstractSetInvert(double value)
940 {
941 InvertVariant invert = static_cast<float>(value);
942 if (LessNotEqual(value, 0.0)) {
943 invert = static_cast<float>(0.0);
944 }
945 ViewAbstractModel::GetInstance()->SetInvert(invert);
946 }
947
FfiOHOSAceFrameworkViewAbstractSetSepia(double value)948 void FfiOHOSAceFrameworkViewAbstractSetSepia(double value)
949 {
950 Dimension dValue(value, DimensionUnit::VP);
951 if (LessNotEqual(dValue.Value(), 0.0)) {
952 dValue.SetValue(0.0);
953 }
954 ViewAbstractModel::GetInstance()->SetSepia(dValue);
955 }
956
FfiOHOSAceFrameworkViewAbstractSetHueRotate(float deg)957 void FfiOHOSAceFrameworkViewAbstractSetHueRotate(float deg)
958 {
959 deg = std::fmod(deg, ROUND_UNIT);
960 if (deg < 0.0) {
961 deg += ROUND_UNIT;
962 }
963 ViewAbstractModel::GetInstance()->SetHueRotate(deg);
964 }
965
FfiOHOSAceFrameworkViewAbstractSetFlexBasis(double value,int32_t unit)966 void FfiOHOSAceFrameworkViewAbstractSetFlexBasis(double value, int32_t unit)
967 {
968 Dimension radius(value, static_cast<DimensionUnit>(unit));
969 ViewAbstractModel::GetInstance()->SetFlexBasis(radius);
970 }
971
FfiOHOSAceFrameworkViewAbstractSetFlexGrow(double value)972 void FfiOHOSAceFrameworkViewAbstractSetFlexGrow(double value)
973 {
974 ViewAbstractModel::GetInstance()->SetFlexGrow(static_cast<float>(value));
975 }
976
FfiOHOSAceFrameworkViewAbstractSetFlexShrink(double value)977 void FfiOHOSAceFrameworkViewAbstractSetFlexShrink(double value)
978 {
979 ViewAbstractModel::GetInstance()->SetFlexShrink(static_cast<float>(value));
980 }
981
FfiOHOSAceFrameworkViewAbstractSetAlignSelf(int32_t alignValue)982 void FfiOHOSAceFrameworkViewAbstractSetAlignSelf(int32_t alignValue)
983 {
984 if (!Utils::CheckParamsValid(alignValue, ITEM_ALIGNS.size())) {
985 LOGE("invalid value for image repeat");
986 return;
987 }
988 ViewAbstractModel::GetInstance()->SetAlignSelf(ITEM_ALIGNS[alignValue]);
989 }
990
FfiOHOSAceFrameworkViewAbstractSetZIndex(int32_t zIndex)991 void FfiOHOSAceFrameworkViewAbstractSetZIndex(int32_t zIndex)
992 {
993 ViewAbstractModel::GetInstance()->SetZIndex(zIndex);
994 }
995
FfiOHOSAceFrameworkViewAbstractSetVisibility(int32_t visibility)996 void FfiOHOSAceFrameworkViewAbstractSetVisibility(int32_t visibility)
997 {
998 if (!Utils::CheckParamsValid(visibility, VISIBILITIES.size())) {
999 LOGE("invalid value for visibility");
1000 return;
1001 }
1002 ViewAbstractModel::GetInstance()->SetVisibility(VISIBILITIES[visibility], [](int32_t visible) {});
1003 }
1004
FfiOHOSAceFrameworkViewAbstractSetClip(bool isClip)1005 void FfiOHOSAceFrameworkViewAbstractSetClip(bool isClip)
1006 {
1007 ViewAbstractModel::GetInstance()->SetClipEdge(isClip);
1008 }
1009
FfiOHOSAceFrameworkViewAbstractSetClipByShape(int64_t shapeId)1010 void FfiOHOSAceFrameworkViewAbstractSetClipByShape(int64_t shapeId)
1011 {
1012 auto context = FFIData::GetData<NativeShapeAbstract>(shapeId);
1013 if (context != nullptr) {
1014 ViewAbstractModel::GetInstance()->SetClipShape(context->GetBasicShape());
1015 } else {
1016 LOGI("set clip error, Cannot get NativeShape by id: %{public}" PRId64, shapeId);
1017 }
1018 }
1019
FfiOHOSAceFrameworkViewAbstractSetMaskByShape(int64_t shapeId)1020 void FfiOHOSAceFrameworkViewAbstractSetMaskByShape(int64_t shapeId)
1021 {
1022 auto context = FFIData::GetData<NativeShapeAbstract>(shapeId);
1023 if (context != nullptr) {
1024 ViewAbstractModel::GetInstance()->SetMask(context->GetBasicShape());
1025 } else {
1026 LOGI("set mask error, Cannot get NativeShape by id: %{public}" PRId64, shapeId);
1027 }
1028 }
1029
FfiOHOSAceFrameworkViewAbstractPop()1030 void FfiOHOSAceFrameworkViewAbstractPop()
1031 {
1032 ViewStackModel::GetInstance()->Pop();
1033 }
1034
FfiOHOSAceFrameworkViewAbstractSetOverlay(const char * title,int32_t align,double x,double y)1035 void FfiOHOSAceFrameworkViewAbstractSetOverlay(const char* title, int32_t align, double x, double y)
1036 {
1037 if (!Utils::CheckParamsValid(align, ALIGNMENT_LIST.size())) {
1038 LOGE("set align error, invalid value for alignment");
1039 return;
1040 }
1041 Dimension offsetX(x, DimensionUnit::VP);
1042 Dimension offsetY(y, DimensionUnit::VP);
1043 ViewAbstractModel::GetInstance()->SetOverlay(
1044 title, nullptr, nullptr, ALIGNMENT_LIST[align], offsetX, offsetY, NG::OverlayType::TEXT);
1045 }
1046
FfiOHOSAceFrameworkViewAbstractBindPopup(bool isShow,CJBindPopupParams bindPopupParams)1047 void FfiOHOSAceFrameworkViewAbstractBindPopup(bool isShow, CJBindPopupParams bindPopupParams)
1048 {
1049 std::function<void(bool)> onStateChangeFunc = (reinterpret_cast<int64_t>(bindPopupParams.onStateChange) == 0)
1050 ? ([](bool) -> void {})
1051 : CJLambda::Create(bindPopupParams.onStateChange);
1052 std::function<void()> primaryActionFunc = (reinterpret_cast<int64_t>(bindPopupParams.primaryAction) == 0)
1053 ? ([]() -> void {})
1054 : CJLambda::Create(bindPopupParams.primaryAction);
1055 std::function<void()> secondaryActionFunc = (reinterpret_cast<int64_t>(bindPopupParams.secondaryAction) == 0)
1056 ? ([]() -> void {})
1057 : CJLambda::Create(bindPopupParams.secondaryAction);
1058
1059 DealBindPopupParams(isShow, bindPopupParams, onStateChangeFunc, primaryActionFunc, secondaryActionFunc);
1060 }
1061
FfiOHOSAceFrameworkViewAbstractKeyShortcut(std::string & value,int32_t * keysArray,int64_t size,void (* callback)(void))1062 void FfiOHOSAceFrameworkViewAbstractKeyShortcut(
1063 std::string& value, int32_t *keysArray, int64_t size, void (*callback)(void))
1064 {
1065 std::vector<ModifierKey> keys(size);
1066 keys.clear();
1067 for (size_t i = 0; i < static_cast<size_t>(size); i++) {
1068 keys.emplace_back(static_cast<ModifierKey>(keysArray[i]));
1069 }
1070 int64_t funcId = reinterpret_cast<int64_t>(callback);
1071 if (funcId == 0) {
1072 ViewAbstractModel::GetInstance()->SetKeyboardShortcut(value, keys, nullptr);
1073 return;
1074 }
1075 auto onKeyboardShortcutAction = [func = CJLambda::Create(callback)]() { func(); };
1076 ViewAbstractModel::GetInstance()->SetKeyboardShortcut(value, keys, std::move(onKeyboardShortcutAction));
1077 return;
1078 }
1079
FfiOHOSAceFrameworkViewAbstractKeyShortcutByFuncKey(int32_t value,int32_t * keysArray,int64_t size,void (* callback)(void))1080 void FfiOHOSAceFrameworkViewAbstractKeyShortcutByFuncKey(
1081 int32_t value, int32_t *keysArray, int64_t size, void (*callback)(void))
1082 {
1083 if (size == 0) {
1084 ViewAbstractModel::GetInstance()->SetKeyboardShortcut("", std::vector<ModifierKey>(), nullptr);
1085 return;
1086 }
1087 std::string keyValue = Utils::GetFunctionKey(value);
1088 FfiOHOSAceFrameworkViewAbstractKeyShortcut(keyValue, keysArray, size, callback);
1089 }
1090
FfiOHOSAceFrameworkViewAbstractKeyShortcutByChar(const char * value,int32_t * keysArray,int64_t size,void (* callback)(void))1091 void FfiOHOSAceFrameworkViewAbstractKeyShortcutByChar(
1092 const char* value, int32_t *keysArray, int64_t size, void (*callback)(void))
1093 {
1094 std::string keyValue(value);
1095 if (size == 0 || keyValue.empty()) {
1096 ViewAbstractModel::GetInstance()->SetKeyboardShortcut("", std::vector<ModifierKey>(), nullptr);
1097 return;
1098 }
1099 if (keyValue.size() > 1) {
1100 return;
1101 }
1102 FfiOHOSAceFrameworkViewAbstractKeyShortcut(keyValue, keysArray, size, callback);
1103 }
1104
FfiOHOSAceFrameworkViewAbstractBindCustomPopup(CJBindCustomPopup value)1105 void FfiOHOSAceFrameworkViewAbstractBindCustomPopup(CJBindCustomPopup value)
1106 {
1107 std::function<void(bool)> onStateChangeFunc =
1108 (reinterpret_cast<int64_t>(value.onStateChange) == 0) ?
1109 ([](bool) -> void {}) : CJLambda::Create(value.onStateChange);
1110 auto popupParam = AceType::MakeRefPtr<PopupParam>();
1111 popupParam->SetIsShow(value.isShow);
1112 popupParam->SetUseCustomComponent(true);
1113 popupParam->SetPlacement(static_cast<Placement>(value.placement));
1114 popupParam->SetMaskColor(Color(value.maskColor));
1115 popupParam->SetBackgroundColor(Color(value.backgroundColor));
1116 popupParam->SetEnableArrow(value.enableArrow);
1117 popupParam->SetHasAction(!value.autoCancel);
1118 auto onStateChangeCallback = [onStateChangeFunc](const std::string& param) {
1119 auto paramData = JsonUtil::ParseJsonString(param);
1120 onStateChangeFunc(paramData->GetBool("isVisible"));
1121 };
1122 popupParam->SetOnStateChange(onStateChangeCallback);
1123 if (popupParam->IsShow()) {
1124 auto builderFunc = CJLambda::Create(value.builder);
1125 RefPtr<AceType> customNode;
1126 {
1127 ViewStackModel::GetInstance()->NewScope();
1128 builderFunc();
1129 customNode = ViewStackModel::GetInstance()->Finish();
1130 }
1131 ViewAbstractModel::GetInstance()->BindPopup(popupParam, customNode);
1132 } else {
1133 ViewAbstractModel::GetInstance()->BindPopup(popupParam, nullptr);
1134 }
1135 }
1136
FfiOHOSAceFrameworkViewAbstractBindMenu(VectorMenuValuePtr vectorMenuValue,void (* menuActionCallback)(const char *))1137 void FfiOHOSAceFrameworkViewAbstractBindMenu(
1138 VectorMenuValuePtr vectorMenuValue, void (*menuActionCallback)(const char*))
1139 {
1140 auto vectorValue = *reinterpret_cast<std::vector<std::string>*>(vectorMenuValue);
1141 std::function<void(const std::string&)> menuActionHandle =
1142 [ffiMenuActionCallback = CJLambda::Create(menuActionCallback)](
1143 const std::string& value) -> void { ffiMenuActionCallback(value.c_str()); };
1144 std::vector<NG::OptionParam> params(vectorValue.size());
1145 for (size_t i = 0; i < vectorValue.size(); ++i) {
1146 auto label = vectorValue[i];
1147 params[i].value = label;
1148 LOGD("option #%{public}d is %{public}s", static_cast<int>(i), params[i].value.c_str());
1149 params[i].action = [menuActionHandle, label]() {
1150 menuActionHandle(label);
1151 };
1152 }
1153 NG::MenuParam options;
1154 ViewAbstractModel::GetInstance()->BindMenu(std::move(params), nullptr, options);
1155 }
1156
FfiOHOSAceFrameworkViewAbstractBindCustomMenu(void (* builder)())1157 void FfiOHOSAceFrameworkViewAbstractBindCustomMenu(void (*builder)())
1158 {
1159 NG::MenuParam params;
1160 ViewAbstractModel::GetInstance()->BindMenu({}, CJLambda::Create(builder), params);
1161 }
1162
FfiOHOSAceFrameworkViewAbstractBindContextMenu(void (* builder)(),int32_t responseType)1163 void FfiOHOSAceFrameworkViewAbstractBindContextMenu(void (*builder)(), int32_t responseType)
1164 {
1165 if (!Utils::CheckParamsValid(responseType, RESPONSE_TYPES.size())) {
1166 LOGE("bindContextMenu error, invalid value for responseType");
1167 return;
1168 }
1169 NG::MenuParam options {.type = NG::MenuType::CONTEXT_MENU};
1170 auto buildFunc = CJLambda::Create(builder);
1171 auto emptyFunc = std::function([] {});
1172 ViewAbstractModel::GetInstance()->BindContextMenu(
1173 static_cast<OHOS::Ace::ResponseType>(responseType), buildFunc, options, emptyFunc
1174 );
1175 }
1176
NewGetCjGradientColorStops(NG::Gradient & gradient,CArrCColors cjColors)1177 static void NewGetCjGradientColorStops(NG::Gradient& gradient, CArrCColors cjColors)
1178 {
1179 int64_t length = cjColors.size;
1180 for (int64_t i = 0; i < length; i++) {
1181 NG::GradientColor gradientColor;
1182 // color
1183 uint32_t realColor = cjColors.header[i].color;
1184 Color color = Color(realColor);
1185 gradientColor.SetColor(color);
1186 gradientColor.SetHasValue(false);
1187 // stop value
1188 double value = 0.0;
1189 value = cjColors.header[i].location;
1190 value = std::clamp(value, 0.0, 1.0);
1191 gradientColor.SetHasValue(true);
1192 gradientColor.SetDimension(CalcDimension(value * HUNDRED, DimensionUnit::PERCENT));
1193 gradient.AddColor(gradientColor);
1194 }
1195 }
1196
NewCjLinearGradient(LinearGradientParam linearGradientParam,NG::Gradient & newGradient)1197 static void NewCjLinearGradient(LinearGradientParam linearGradientParam, NG::Gradient& newGradient)
1198 {
1199 newGradient.CreateGradientWithType(NG::GradientType::LINEAR);
1200 // angle
1201 double* angle = linearGradientParam.angle;
1202 if (angle != nullptr) {
1203 newGradient.GetLinearGradient()->angle = CalcDimension(*angle, DimensionUnit::PX);
1204 }
1205 // direction
1206 auto direction = static_cast<GradientDirection>(linearGradientParam.direction);
1207 switch (direction) {
1208 case GradientDirection::LEFT:
1209 newGradient.GetLinearGradient()->linearX = NG::GradientDirection::LEFT;
1210 break;
1211 case GradientDirection::RIGHT:
1212 newGradient.GetLinearGradient()->linearX = NG::GradientDirection::RIGHT;
1213 break;
1214 case GradientDirection::TOP:
1215 newGradient.GetLinearGradient()->linearY = NG::GradientDirection::TOP;
1216 break;
1217 case GradientDirection::BOTTOM:
1218 newGradient.GetLinearGradient()->linearY = NG::GradientDirection::BOTTOM;
1219 break;
1220 case GradientDirection::LEFT_TOP:
1221 newGradient.GetLinearGradient()->linearX = NG::GradientDirection::LEFT;
1222 newGradient.GetLinearGradient()->linearY = NG::GradientDirection::TOP;
1223 break;
1224 case GradientDirection::LEFT_BOTTOM:
1225 newGradient.GetLinearGradient()->linearX = NG::GradientDirection::LEFT;
1226 newGradient.GetLinearGradient()->linearY = NG::GradientDirection::BOTTOM;
1227 break;
1228 case GradientDirection::RIGHT_TOP:
1229 newGradient.GetLinearGradient()->linearX = NG::GradientDirection::RIGHT;
1230 newGradient.GetLinearGradient()->linearY = NG::GradientDirection::TOP;
1231 break;
1232 case GradientDirection::RIGHT_BOTTOM:
1233 newGradient.GetLinearGradient()->linearX = NG::GradientDirection::RIGHT;
1234 newGradient.GetLinearGradient()->linearY = NG::GradientDirection::BOTTOM;
1235 break;
1236 case GradientDirection::NONE:
1237 case GradientDirection::START_TO_END:
1238 case GradientDirection::END_TO_START:
1239 default:
1240 break;
1241 }
1242 newGradient.SetRepeat(linearGradientParam.repeating);
1243 NewGetCjGradientColorStops(newGradient, linearGradientParam.colors);
1244 }
1245
FfiOHOSAceFrameworkViewAbstractLinearGradient(LinearGradientParam linearGradientParam)1246 void FfiOHOSAceFrameworkViewAbstractLinearGradient(LinearGradientParam linearGradientParam)
1247 {
1248 NG::Gradient newGradient;
1249 NewCjLinearGradient(linearGradientParam, newGradient);
1250 ViewAbstractModel::GetInstance()->SetLinearGradient(newGradient);
1251 }
1252
NewCjSweepGradient(SweepGradientParam sweepGradientParam,NG::Gradient & newGradient)1253 static void NewCjSweepGradient(SweepGradientParam sweepGradientParam, NG::Gradient& newGradient)
1254 {
1255 newGradient.CreateGradientWithType(NG::GradientType::SWEEP);
1256 // center
1257 CTupleLength center = sweepGradientParam.center;
1258 DimensionUnit rowUnitType = static_cast<DimensionUnit>(center.rowUnitType);
1259 newGradient.GetSweepGradient()->centerX = CalcDimension(center.rowValue, rowUnitType);
1260 double hundredPercent = 100.0;
1261 if (static_cast<DimensionUnit>(center.rowUnitType) == DimensionUnit::PERCENT) {
1262 // [0,1] -> [0, 100]
1263 double rowValue = center.rowValue * hundredPercent;
1264 newGradient.GetSweepGradient()->centerX = CalcDimension(rowValue, DimensionUnit::PERCENT);
1265 }
1266 DimensionUnit columnUnitType = static_cast<DimensionUnit>(center.columnUnitType);
1267 newGradient.GetSweepGradient()->centerY = CalcDimension(center.columnValue, columnUnitType);
1268 if (static_cast<DimensionUnit>(center.columnUnitType) == DimensionUnit::PERCENT) {
1269 // [0,1] -> [0, 100]
1270 double columnValue = center.columnValue * hundredPercent;
1271 newGradient.GetSweepGradient()->centerY = CalcDimension(columnValue, DimensionUnit::PERCENT);
1272 }
1273 // start
1274 double start = sweepGradientParam.start;
1275 newGradient.GetSweepGradient()->startAngle = CalcDimension(start, DimensionUnit::PX);
1276 // end
1277 double end = sweepGradientParam.end;
1278 newGradient.GetSweepGradient()->endAngle = CalcDimension(end, DimensionUnit::PX);
1279 // rotation
1280 double rotation = sweepGradientParam.rotation;
1281 newGradient.GetSweepGradient()->rotation = CalcDimension(rotation, DimensionUnit::PX);
1282 // repeating
1283 newGradient.SetRepeat(sweepGradientParam.repeating);
1284 // color stops
1285 NewGetCjGradientColorStops(newGradient, sweepGradientParam.colors);
1286 }
1287
FfiOHOSAceFrameworkViewAbstractSweepGradient(SweepGradientParam sweepGradientParam)1288 void FfiOHOSAceFrameworkViewAbstractSweepGradient(SweepGradientParam sweepGradientParam)
1289 {
1290 NG::Gradient newGradient;
1291 NewCjSweepGradient(sweepGradientParam, newGradient);
1292 ViewAbstractModel::GetInstance()->SetSweepGradient(newGradient);
1293 }
1294
NewCjRadialGradient(RadialGradientParam radialGradientParam,NG::Gradient & newGradient)1295 static void NewCjRadialGradient(RadialGradientParam radialGradientParam, NG::Gradient& newGradient)
1296 {
1297 newGradient.CreateGradientWithType(NG::GradientType::RADIAL);
1298 // center
1299 CTupleLength center = radialGradientParam.center;
1300 DimensionUnit rowUnitType = static_cast<DimensionUnit>(center.rowUnitType);
1301 newGradient.GetRadialGradient()->radialCenterX = CalcDimension(center.rowValue, rowUnitType);
1302 double hundredPercent = 100.0;
1303 if (static_cast<DimensionUnit>(center.rowUnitType) == DimensionUnit::PERCENT) {
1304 // [0,1] -> [0, 100]
1305 double rowValue = center.rowValue * hundredPercent;
1306 newGradient.GetRadialGradient()->radialCenterX = CalcDimension(rowValue, DimensionUnit::PERCENT);
1307 }
1308
1309 DimensionUnit columnUnitType = static_cast<DimensionUnit>(center.columnUnitType);
1310 newGradient.GetRadialGradient()->radialCenterY = CalcDimension(center.columnValue, columnUnitType);
1311 if (static_cast<DimensionUnit>(center.columnUnitType) == DimensionUnit::PERCENT) {
1312 // [0,1] -> [0, 100]
1313 double columnValue = center.columnValue * hundredPercent;
1314 newGradient.GetRadialGradient()->radialCenterY = CalcDimension(columnValue, DimensionUnit::PERCENT);
1315 }
1316 // radius
1317 newGradient.GetRadialGradient()->radialVerticalSize =
1318 Dimension(radialGradientParam.radius, static_cast<DimensionUnit>(radialGradientParam.radiusUnit));
1319 newGradient.GetRadialGradient()->radialHorizontalSize =
1320 Dimension(radialGradientParam.radius, static_cast<DimensionUnit>(radialGradientParam.radiusUnit));
1321 // repeating
1322 newGradient.SetRepeat(radialGradientParam.repeating);
1323 // color stops
1324 NewGetCjGradientColorStops(newGradient, radialGradientParam.colors);
1325 }
1326
FfiOHOSAceFrameworkViewAbstractRadialGradient(RadialGradientParam radialGradientParam)1327 void FfiOHOSAceFrameworkViewAbstractRadialGradient(RadialGradientParam radialGradientParam)
1328 {
1329 NG::Gradient newGradient;
1330 NewCjRadialGradient(radialGradientParam, newGradient);
1331 ViewAbstractModel::GetInstance()->SetRadialGradient(newGradient);
1332 }
1333
FfiOHOSAceFrameworkViewAbstractRenderFit(int32_t fitMode)1334 void FfiOHOSAceFrameworkViewAbstractRenderFit(int32_t fitMode)
1335 {
1336 if (!OHOS::Ace::Framework::Utils::CheckParamsValid(fitMode, RENDERFITS.size())) {
1337 LOGE("invalid value for fitMode");
1338 return;
1339 }
1340 ViewAbstractModel::GetInstance()->SetRenderFit(RENDERFITS[fitMode]);
1341 }
1342
FfiOHOSAceFrameworkViewAbstractSetInspectorKey(const char * key)1343 void FfiOHOSAceFrameworkViewAbstractSetInspectorKey(const char* key)
1344 {
1345 ViewAbstractModel::GetInstance()->SetInspectorId(key);
1346 }
1347
FfiOHOSAceFrameworkViewAbstractSetId(const char * id)1348 void FfiOHOSAceFrameworkViewAbstractSetId(const char* id)
1349 {
1350 ViewAbstractModel::GetInstance()->SetInspectorId(id);
1351 }
1352
FFICJCreateVectorNativeRectangle(int64_t size)1353 VectorNativeRectangleHandle FFICJCreateVectorNativeRectangle(int64_t size)
1354 {
1355 LOGE("Create NativeRectangle Vector");
1356 return new std::vector<NativeRectangle>(size);
1357 }
1358
FFICJVectorNativeRectangleDelete(VectorNativeRectangleHandle vec)1359 void FFICJVectorNativeRectangleDelete(VectorNativeRectangleHandle vec)
1360 {
1361 auto actualVec = reinterpret_cast<std::vector<NativeRectangle>*>(vec);
1362 delete actualVec;
1363 }
1364
FFICJVectorNativeRectangleSetElement(VectorNativeRectangleHandle vec,int64_t index,NativeRectangle rect)1365 void FFICJVectorNativeRectangleSetElement(VectorNativeRectangleHandle vec, int64_t index, NativeRectangle rect)
1366 {
1367 LOGE("NativeRectangle Vector Set Element");
1368 auto actualVec = reinterpret_cast<std::vector<NativeRectangle>*>(vec);
1369 (*actualVec)[index] = rect;
1370 LOGE("NativeRectangle Vector Set Element Success");
1371 }
1372
FFIOHOSAceFrameworkGetResourceStr(int64_t id,uint32_t type,const char * param)1373 ExternalString FFIOHOSAceFrameworkGetResourceStr(int64_t id, uint32_t type, const char* param)
1374 {
1375 std::string result;
1376 if (!ParseCjString(id, static_cast<ResourceType>(type), param, result)) {
1377 LOGE("Parse String Failed.");
1378 }
1379 return ::Utils::MallocCString(result);
1380 }
1381
FFIOHOSAceFrameworkGetResourcePluralStr(int64_t id,uint32_t type,int64_t count,const char * plural)1382 ExternalString FFIOHOSAceFrameworkGetResourcePluralStr(int64_t id, uint32_t type, int64_t count, const char* plural)
1383 {
1384 std::string result;
1385 if (!ParseCjString(id, static_cast<ResourceType>(type), count, plural, result)) {
1386 LOGE("Parse String Failed.");
1387 }
1388 return ::Utils::MallocCString(result);
1389 }
1390
FFIOHOSAceFrameworkGetResourceDimension(int64_t id)1391 RetDimension FFIOHOSAceFrameworkGetResourceDimension(int64_t id)
1392 {
1393 Dimension result;
1394 RetDimension ret = { .value = 0.0, .unit = 0 };
1395 if (!ParseCjDimension(id, result)) {
1396 LOGE("Parse Dimension Failed.");
1397 }
1398 ret.value = result.Value();
1399 ret.unit = static_cast<int32_t>(result.Unit());
1400 return ret;
1401 }
1402
FFIOHOSAceFrameworkGetResourceColor(int64_t id)1403 uint32_t FFIOHOSAceFrameworkGetResourceColor(int64_t id)
1404 {
1405 Color color;
1406 uint32_t result;
1407 if (!ParseColorById(id, color)) {
1408 LOGE("Parse Color Failed.");
1409 }
1410 result = color.GetValue();
1411 return result;
1412 }
1413
FFIOHOSAceFrameworkGetResourceMedia(int64_t id,uint32_t type,const char * param)1414 ExternalString FFIOHOSAceFrameworkGetResourceMedia(int64_t id, uint32_t type, const char* param)
1415 {
1416 std::string result;
1417 if (!ParseCjMedia(id, static_cast<ResourceType>(type), param, result)) {
1418 LOGE("Parse Media Failed.");
1419 }
1420 return ::Utils::MallocCString(result);
1421 }
1422
FfiOHOSAceFrameworkViewAbstractExpandSafeArea(uint32_t types,uint32_t edges)1423 void FfiOHOSAceFrameworkViewAbstractExpandSafeArea(uint32_t types, uint32_t edges)
1424 {
1425 NG::SafeAreaExpandOpts opts { .type = types, .edges = edges };
1426 ViewAbstractModel::GetInstance()->UpdateSafeAreaExpandOpts(opts);
1427 }
1428
ParseSheetCallback(CJSheetOptions options,std::function<void ()> & onAppear,std::function<void ()> & onDisappear,std::function<void ()> & shouldDismiss,std::function<void ()> & onWillAppear,std::function<void ()> & onWillDisappear)1429 void ParseSheetCallback(CJSheetOptions options, std::function<void()>& onAppear,
1430 std::function<void()>& onDisappear, std::function<void()>& shouldDismiss, std::function<void()>& onWillAppear,
1431 std::function<void()>& onWillDisappear)
1432 {
1433 if (options.onAppear.hasValue) {
1434 onAppear = CJLambda::Create(options.onAppear.value);
1435 }
1436 if (options.onDisappear.hasValue) {
1437 onDisappear = CJLambda::Create(options.onDisappear.value);
1438 }
1439 if (options.shouldDismiss.hasValue) {
1440 shouldDismiss = CJLambda::Create(options.shouldDismiss.value);
1441 }
1442 if (options.onWillAppear.hasValue) {
1443 onWillAppear = CJLambda::Create(options.onWillAppear.value);
1444 }
1445 if (options.onWillDisappear.hasValue) {
1446 onWillDisappear = CJLambda::Create(options.onWillDisappear.value);
1447 }
1448 }
1449
ParseSheetDetentHeight(const int args,NG::SheetHeight & detent)1450 void ParseSheetDetentHeight(const int args, NG::SheetHeight& detent)
1451 {
1452 if (args == SHEET_HEIGHT_MEDIUM) {
1453 detent.sheetMode = NG::SheetMode::MEDIUM;
1454 detent.height.reset();
1455 return;
1456 }
1457 if (args == SHEET_HEIGHT_LARGE) {
1458 detent.sheetMode = NG::SheetMode::LARGE;
1459 detent.height.reset();
1460 return;
1461 }
1462 if (args == SHEET_HEIGHT_FITCONTENT) {
1463 detent.sheetMode = NG::SheetMode::AUTO;
1464 detent.height.reset();
1465 return;
1466 }
1467 }
1468
ParseSheetDetents(const CArrInt32 array,std::vector<NG::SheetHeight> & sheetDetents)1469 bool ParseSheetDetents(const CArrInt32 array, std::vector<NG::SheetHeight>& sheetDetents)
1470 {
1471 int* intArr = static_cast<int*>(array.head);
1472 std::vector<int> intVec(intArr, intArr + array.size);
1473 NG::SheetHeight sheetDetent;
1474 for (size_t i = 0; i < intVec.size(); i++) {
1475 ParseSheetDetentHeight(intVec[i], sheetDetent);
1476 if ((!sheetDetent.height.has_value()) && (!sheetDetent.sheetMode.has_value())) {
1477 continue;
1478 }
1479 sheetDetents.emplace_back(sheetDetent);
1480 sheetDetent.height.reset();
1481 sheetDetent.sheetMode.reset();
1482 }
1483 return true;
1484 }
1485
ParseSheetStyle(CJSheetOptions option,NG::SheetStyle & sheetStyle)1486 void ParseSheetStyle(CJSheetOptions option, NG::SheetStyle& sheetStyle)
1487 {
1488 std::vector<NG::SheetHeight> detents;
1489 if (option.detents.hasValue && ParseSheetDetents(option.detents.value, detents)) {
1490 sheetStyle.detents = detents;
1491 }
1492 if (option.blurStyle.hasValue) {
1493 BlurStyleOption styleOption;
1494 int32_t blurStyle = option.blurStyle.value;
1495 if (blurStyle >= static_cast<int>(BlurStyle::NO_MATERIAL) &&
1496 blurStyle <= static_cast<int>(BlurStyle::COMPONENT_ULTRA_THICK)) {
1497 styleOption.blurStyle = static_cast<BlurStyle>(blurStyle);
1498 sheetStyle.backgroundBlurStyle = styleOption;
1499 }
1500 }
1501 if (option.showClose.hasValue) {
1502 sheetStyle.showCloseIcon = option.showClose.value;
1503 }
1504 if (option.dragBarl.hasValue) {
1505 sheetStyle.showDragBar = option.dragBarl.value;
1506 } else {
1507 sheetStyle.showDragBar = true;
1508 }
1509 if (option.enableOutsideInteractive.hasValue) {
1510 sheetStyle.interactive = option.enableOutsideInteractive.value;
1511 }
1512 if (option.enableOutsideInteractive.hasValue) {
1513 sheetStyle.interactive = option.enableOutsideInteractive.value;
1514 }
1515 if (option.preferType.hasValue) {
1516 auto sheetType = option.preferType.value;
1517 if (sheetType >= static_cast<int>(NG::SheetType::SHEET_BOTTOM) &&
1518 sheetType <= static_cast<int>(NG::SheetType::SHEET_POPUP)) {
1519 sheetStyle.sheetType = static_cast<NG::SheetType>(sheetType);
1520 }
1521 }
1522 if (option.backgroundColor.hasValue) {
1523 sheetStyle.backgroundColor = Color(ColorAlphaAdapt(option.backgroundColor.value));
1524 }
1525 if (option.maskColor.hasValue) {
1526 sheetStyle.maskColor = Color(ColorAlphaAdapt(option.maskColor.value));
1527 }
1528 NG::SheetHeight sheetDetent;
1529 if (option.height.hasValue) {
1530 ParseSheetDetentHeight(option.height.value, sheetDetent);
1531 sheetStyle.sheetMode = sheetDetent.sheetMode;
1532 sheetStyle.height = sheetDetent.height;
1533 }
1534 }
1535
ParseSheetTitle(CJSheetOptions option,NG::SheetStyle & sheetStyle,std::function<void ()> & titleBuilderFunction)1536 void ParseSheetTitle(CJSheetOptions option, NG::SheetStyle& sheetStyle, std::function<void()>& titleBuilderFunction)
1537 {
1538 sheetStyle.isTitleBuilder = true;
1539 titleBuilderFunction = option.title.hasValue ? CJLambda::Create(option.title.value)
1540 : ([]() -> void {});
1541 }
FfiOHOSAceFrameworkViewAbstractbindSheetParam(bool isShow,void (* builder)(),CJSheetOptions option)1542 void FfiOHOSAceFrameworkViewAbstractbindSheetParam(bool isShow, void (*builder)(), CJSheetOptions option)
1543 {
1544 auto buildFunc = CJLambda::Create(builder);
1545 NG::SheetStyle sheetStyle;
1546 DoubleBindCallback callback = nullptr;
1547 sheetStyle.sheetMode = NG::SheetMode::LARGE;
1548 sheetStyle.showDragBar = true;
1549 sheetStyle.showInPage = false;
1550 std::function<void()> onAppearCallback;
1551 std::function<void()> onDisappearCallback;
1552 std::function<void()> onWillAppearCallback;
1553 std::function<void()> onWillDisappearCallback;
1554 std::function<void()> shouldDismissFunc;
1555 std::function<void(const int32_t)> onWillDismissCallback;
1556 std::function<void(const float)> onHeightDidChangeCallback;
1557 std::function<void(const float)> onDetentsDidChangeCallback;
1558 std::function<void(const float)> onWidthDidChangeCallback;
1559 std::function<void(const float)> onTypeDidChangeCallback;
1560 std::function<void()> titleBuilderFunction;
1561 std::function<void()> sheetSpringBackFunc;
1562 ParseSheetCallback(option, onAppearCallback, onDisappearCallback, shouldDismissFunc,
1563 onWillAppearCallback, onWillDisappearCallback);
1564 ParseSheetStyle(option, sheetStyle);
1565 ParseSheetTitle(option, sheetStyle, titleBuilderFunction);
1566 ViewAbstractModel::GetInstance()->BindSheet(isShow, std::move(callback), std::move(buildFunc),
1567 std::move(titleBuilderFunction), sheetStyle, std::move(onAppearCallback), std::move(onDisappearCallback),
1568 std::move(shouldDismissFunc), std::move(onWillDismissCallback), std::move(onWillAppearCallback),
1569 std::move(onWillDisappearCallback), std::move(onHeightDidChangeCallback),
1570 std::move(onDetentsDidChangeCallback), std::move(onWidthDidChangeCallback),
1571 std::move(onTypeDidChangeCallback), std::move(sheetSpringBackFunc));
1572 return;
1573 }
1574
FFIOHOSAceFrameworkFocusable(bool isFocusable)1575 void FFIOHOSAceFrameworkFocusable(bool isFocusable)
1576 {
1577 ViewAbstractModel::GetInstance()->SetFocusable(isFocusable);
1578 }
1579
FFIOHOSAceFrameworkTabIndex(int32_t index)1580 void FFIOHOSAceFrameworkTabIndex(int32_t index)
1581 {
1582 ViewAbstractModel::GetInstance()->SetTabIndex(index);
1583 }
1584
FFIOHOSAceFrameworkDefaultFocus(bool isDefaultFocus)1585 void FFIOHOSAceFrameworkDefaultFocus(bool isDefaultFocus)
1586 {
1587 ViewAbstractModel::GetInstance()->SetDefaultFocus(isDefaultFocus);
1588 }
1589
FFIOHOSAceFrameworkGroupDefaultFocus(bool isGroupDefaultFocus)1590 void FFIOHOSAceFrameworkGroupDefaultFocus(bool isGroupDefaultFocus)
1591 {
1592 ViewAbstractModel::GetInstance()->SetGroupDefaultFocus(isGroupDefaultFocus);
1593 }
1594
FFIOHOSAceFrameworkFocusOnTouch(bool isFocusOnTouch)1595 void FFIOHOSAceFrameworkFocusOnTouch(bool isFocusOnTouch)
1596 {
1597 ViewAbstractModel::GetInstance()->SetFocusOnTouch(isFocusOnTouch);
1598 }
FFIOHOSAceFrameworkRequestFocus(const char * inspectorKey)1599 bool FFIOHOSAceFrameworkRequestFocus(const char* inspectorKey)
1600 {
1601 bool result = false;
1602 auto pipelineContext = PipelineContext::GetCurrentContext();
1603 if (!pipelineContext) {
1604 LOGE("pipeline context is non-valid");
1605 return result;
1606 }
1607 if (!pipelineContext->GetTaskExecutor()) {
1608 LOGE("TaskExecutor is non-valid");
1609 return result;
1610 }
1611 pipelineContext->GetTaskExecutor()->PostSyncTask(
1612 [pipelineContext, inspectorKey, &result]() { result = pipelineContext->RequestFocus(inspectorKey); },
1613 TaskExecutor::TaskType::UI, "ArkUICjRequestFocus");
1614 return result;
1615 }
1616
ParseModalTransition(CJContentCoverOptions options,NG::ModalStyle & modalStyle)1617 void ParseModalTransition(CJContentCoverOptions options, NG::ModalStyle& modalStyle)
1618 {
1619 modalStyle.modalTransition = NG::ModalTransition::DEFAULT;
1620 auto modalTransition = options.modalTransition;
1621 auto transitionNumber = static_cast<int32_t>(modalTransition);
1622 modalStyle.modalTransition = static_cast<NG::ModalTransition>(transitionNumber);
1623 if (options.backgroundColor.hasValue) {
1624 auto backgroundColor = static_cast<uint32_t>(options.backgroundColor.value);
1625 modalStyle.backgroundColor = Color(backgroundColor);
1626 }
1627 }
1628
FFIOHOSAceFrameworkBindContentCover(bool isShow,void (* builder)(),CJContentCoverOptions options)1629 void FFIOHOSAceFrameworkBindContentCover(bool isShow, void (*builder)(), CJContentCoverOptions options)
1630 {
1631 // parse builder
1632 auto buildFunc = CJLambda::Create(builder);
1633
1634 // parse ModalTransition
1635 NG::ModalStyle modalStyle;
1636 ParseModalTransition(options, modalStyle);
1637 std::function<void()> onWillShowCallback;
1638 std::function<void()> onWillDismissCallback;
1639 NG::ContentCoverParam contentCoverParam;
1640 std::function<void(const int32_t&)> onWillDismissFunc;
1641 // parse callback
1642 std::function<void()> onShowCallback = options.onAppear.hasValue ? CJLambda::Create(options.onAppear.value)
1643 : ([]() -> void {});
1644 std::function<void()> onDismissCallback = options.onDisappear.hasValue ? CJLambda::Create(options.onDisappear.value)
1645 : ([]() -> void {});
1646
1647 ViewAbstractModel::GetInstance()->BindContentCover(isShow, nullptr, std::move(buildFunc), modalStyle,
1648 std::move(onShowCallback), std::move(onDismissCallback), std::move(onWillShowCallback),
1649 std::move(onWillDismissCallback), contentCoverParam);
1650 }
1651 }
1652
1653 namespace OHOS::Ace {
ParseCjDimension(int64_t id,Dimension & result)1654 bool ParseCjDimension(int64_t id, Dimension& result)
1655 {
1656 auto themeConstants = ViewAbstract::GetThemeConstants();
1657 if (!themeConstants) {
1658 LOGW("themeConstants is nullptr");
1659 return false;
1660 }
1661 result = themeConstants->GetDimension(static_cast<uint32_t>(id));
1662 return true;
1663 }
1664
ParseCjMedia(int64_t id,ResourceType type,const std::string & params,std::string & result)1665 bool ParseCjMedia(int64_t id, ResourceType type, const std::string& params, std::string& result)
1666 {
1667 auto themeConstants = ViewAbstract::GetThemeConstants();
1668 if (!themeConstants) {
1669 LOGW("themeConstants is nullptr");
1670 return false;
1671 }
1672 if (type == ResourceType::MEDIA) {
1673 result = themeConstants->GetMediaPath(static_cast<uint32_t>(id));
1674 return true;
1675 }
1676 if (type == ResourceType::RAWFILE) {
1677 if (params.empty()) {
1678 LOGW("param is empty");
1679 return false;
1680 }
1681 result = themeConstants->GetRawfile(params);
1682 return true;
1683 }
1684 LOGE("CJImage::Create ParseCjMedia type is wrong");
1685 return false;
1686 }
1687
ParseCjString(int64_t id,ResourceType type,const std::string & params,std::string & result)1688 bool ParseCjString(int64_t id, ResourceType type, const std::string& params, std::string& result)
1689 {
1690 auto themeConstants = ViewAbstract::GetThemeConstants();
1691 if (!themeConstants) {
1692 LOGW("themeConstants is nullptr");
1693 return false;
1694 }
1695
1696 if (type == ResourceType::STRING) {
1697 auto originStr = themeConstants->GetString(static_cast<uint32_t>(id));
1698 ReplaceHolder(originStr, params);
1699 result = originStr;
1700 } else {
1701 LOGE("Resource type invalid");
1702 return false;
1703 }
1704 return true;
1705 }
1706
ParseCjString(int64_t id,ResourceType type,int64_t count,const std::string & plural,std::string & result)1707 bool ParseCjString(int64_t id, ResourceType type, int64_t count, const std::string& plural, std::string& result)
1708 {
1709 auto themeConstants = ViewAbstract::GetThemeConstants();
1710 if (!themeConstants) {
1711 LOGW("themeConstants is nullptr");
1712 return false;
1713 }
1714
1715 if (type == ResourceType::PLURAL) {
1716 auto pluralStr = themeConstants->GetPluralString(static_cast<uint32_t>(id), count);
1717 ReplaceHolder(pluralStr, plural);
1718 result = pluralStr;
1719 } else {
1720 LOGE("Resource type invalid");
1721 return false;
1722 }
1723 return true;
1724 }
1725
ParseColorById(int64_t id,Color & color)1726 bool ParseColorById(int64_t id, Color& color)
1727 {
1728 auto themeConstants = ViewAbstract::GetThemeConstants();
1729 if (!themeConstants) {
1730 LOGW("themeConstants is nullptr");
1731 return false;
1732 }
1733 color = themeConstants->GetColor(static_cast<uint32_t>(id));
1734 return true;
1735 }
1736
ParseCJResponseRegion(CJResponseRegion value,std::vector<DimensionRect> & result)1737 void ParseCJResponseRegion(CJResponseRegion value, std::vector<DimensionRect>& result)
1738 {
1739 Dimension xDime(value.x, static_cast<DimensionUnit>(value.xUnit));
1740 Dimension yDime(value.y, static_cast<DimensionUnit>(value.yUnit));
1741 Dimension widthDime(value.width, static_cast<DimensionUnit>(value.widthUnit));
1742 Dimension heightDime(value.height, static_cast<DimensionUnit>(value.heightUnit));
1743 DimensionOffset offsetDimen(xDime, yDime);
1744 DimensionRect dimenRect(widthDime, heightDime, offsetDimen);
1745 result.emplace_back(dimenRect);
1746 }
1747
ParseVectorStringPtr(VectorStringPtr vecContent,std::vector<DimensionRect> & result)1748 void ParseVectorStringPtr(VectorStringPtr vecContent, std::vector<DimensionRect>& result)
1749 {
1750 auto nativeRectangleVec = *reinterpret_cast<std::vector<NativeRectangle>*>(vecContent);
1751 for (size_t i = 0; i < nativeRectangleVec.size(); i++) {
1752 Dimension xDimen = Dimension(nativeRectangleVec[i].x, static_cast<DimensionUnit>(nativeRectangleVec[i].xUnit));
1753 Dimension yDimen = Dimension(nativeRectangleVec[i].y, static_cast<DimensionUnit>(nativeRectangleVec[i].yUnit));
1754 Dimension widthDimen =
1755 Dimension(nativeRectangleVec[i].width, static_cast<DimensionUnit>(nativeRectangleVec[i].widthUnit));
1756 Dimension heightDimen =
1757 Dimension(nativeRectangleVec[i].height, static_cast<DimensionUnit>(nativeRectangleVec[i].heightUnit));
1758 DimensionOffset offsetDimen(xDimen, yDimen);
1759 DimensionRect dimenRect(widthDimen, heightDimen, offsetDimen);
1760 result.emplace_back(dimenRect);
1761 }
1762 }
1763
1764 } // namespace OHOS::Ace
1765