From 73314e29442e6fff842623ce7f338b3c0a4edb4a Mon Sep 17 00:00:00 2001 From: wangxiuxiu96 Date: Thu, 15 May 2025 21:30:47 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E8=A7=86=E6=95=88=E6=B7=B1=E6=B5=85?= =?UTF-8?q?=E8=89=B2=E5=88=87=E6=8D=A2-modifier?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangxiuxiu96 Change-Id: I3a12909db053f71fd5f6bf55a1635c0e3dce9a42 --- .../arkts_native_common_bridge.cpp | 511 +++++++++++---- .../nativeModule/arkts_native_common_bridge.h | 2 + .../arkts_native_loading_progress_bridge.cpp | 2 +- .../engine/jsi/nativeModule/arkts_utils.cpp | 9 +- .../engine/jsi/nativeModule/arkts_utils.h | 2 + .../jsview/js_shape_abstract.cpp | 1 - .../jsview/js_view_abstract.cpp | 83 ++- .../core/components_ng/base/view_abstract.cpp | 455 +++++++++++-- .../core/components_ng/base/view_abstract.h | 10 +- .../components_ng/base/view_abstract_model.h | 2 +- .../base/view_abstract_model_ng.h | 9 +- .../property/progress_mask_property.h | 34 +- .../render/adapter/rosen_render_context.cpp | 35 + .../render/adapter/rosen_render_context.h | 2 + .../core/interfaces/arkoala/arkoala_api.h | 34 +- frameworks/core/interfaces/cjui/cjui_api.h | 34 +- .../native/node/node_common_modifier.cpp | 605 ++++++++++++++++-- interfaces/native/node/style_modifier.cpp | 29 +- .../core/base/view_abstract_test_ng.cpp | 2 +- 19 files changed, 1538 insertions(+), 323 deletions(-) diff --git a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_common_bridge.cpp b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_common_bridge.cpp index 6f443e15cde..fd341c4102f 100644 --- a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_common_bridge.cpp +++ b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_common_bridge.cpp @@ -32,6 +32,7 @@ #include "bridge/declarative_frontend/jsview/js_view_context.h" #include "bridge/js_frontend/engine/jsi/ark_js_runtime.h" #include "core/components_ng/pattern/text/text_model_ng.h" +#include "core/common/resource/resource_parse_utils.h" #include "frameworks/bridge/declarative_frontend/engine/functions/js_accessibility_function.h" #include "frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h" #include "frameworks/bridge/declarative_frontend/jsview/js_shape_abstract.h" @@ -174,7 +175,8 @@ void ParseGradientAngle(const EcmaVM *vm, const Local &value, std::v values.push_back({.f32 = static_cast(angleValue)}); } -void ParseGradientColorStops(const EcmaVM *vm, const Local &value, std::vector &colors) +void ParseGradientColorStops(const EcmaVM *vm, const Local &value, std::vector &colors, + std::vector>& vectorResObj) { if (!value->IsArray(vm)) { return; @@ -193,9 +195,17 @@ void ParseGradientColorStops(const EcmaVM *vm, const Local &value, s } Color color; auto colorParams = panda::ArrayRef::GetValueAt(vm, itemArray, NUM_0); - if (!ArkTSUtils::ParseJsColorAlpha(vm, colorParams, color)) { + RefPtr resObj; + if (!ArkTSUtils::ParseJsColorAlpha(vm, colorParams, color, resObj)) { continue; } + if (SystemProperties::ConfigChangePerform()) { + if (resObj) { + vectorResObj.push_back(resObj); + } else { + vectorResObj.push_back(nullptr); + } + } bool hasDimension = false; double dimension = 0.0; if (itemLength > NUM_1) { @@ -225,20 +235,24 @@ bool ParseJsShadowColorStrategy(const EcmaVM *vm, const Local &value return false; } -bool ParseJsShadowDimension(const EcmaVM *vm, const Local &value, CalcDimension& dimension) +bool ParseJsShadowDimension(const EcmaVM *vm, const Local &value, CalcDimension& dimension, + std::vector>& vectorResObj) { - if (ArkTSUtils::ParseJsResource(vm, value, dimension)) { - return true; + RefPtr shadowResObj; + bool ret = ArkTSUtils::ParseJsResource(vm, value, dimension, shadowResObj); + if (!ret) { + ret = ArkTSUtils::ParseJsDimensionVp(vm, value, dimension); + } + if (shadowResObj) { + vectorResObj.push_back(shadowResObj); } else { - if (ArkTSUtils::ParseJsDimensionVp(vm, value, dimension)) { - return true; - } + vectorResObj.push_back(nullptr); } - return false; + return ret; } bool ParseJsShadowColor(const EcmaVM *vm, const Local &colorArg, - int32_t& type, uint32_t& colorValue) + int32_t& type, uint32_t& colorValue, RefPtr& colorResObj) { Color color; ShadowColorStrategy shadowColorStrategy; @@ -246,7 +260,7 @@ bool ParseJsShadowColor(const EcmaVM *vm, const Local &colorArg, type = 1; // 1: has shadowColorStrategy colorValue = static_cast(shadowColorStrategy); return true; - } else if (ArkTSUtils::ParseJsColorAlpha(vm, colorArg, color)) { + } else if (ArkTSUtils::ParseJsColorAlpha(vm, colorArg, color, colorResObj)) { type = 2; // 2: has shadowColor colorValue = color.GetValue(); return true; @@ -470,7 +484,8 @@ void ParseBorderImageLinearGradient(ArkUINodeHandle node, options.push_back({.i32 = static_cast(direction)}); std::vector colors; - ParseGradientColorStops(vm, colorsArg, colors); + std::vector> vectorResObj; + ParseGradientColorStops(vm, colorsArg, colors, vectorResObj); auto repeating = repeatingArg->IsBoolean() ? repeatingArg->BooleaValue(runtimeCallInfo->GetVM()) : false; options.push_back({.i32 = static_cast(repeating)}); GetArkUINodeModifiers()->getCommonModifier()->setBorderImageGradient(node, @@ -928,7 +943,8 @@ bool ParseJsDoublePair(const EcmaVM *vm, const Local &value, ArkUI_F return true; } -void ParseGradientCenter(const EcmaVM* vm, const Local& value, std::vector& values) +void ParseGradientCenter(const EcmaVM* vm, const Local& value, std::vector& values, + std::vector>& vectorResObj) { bool hasValueX = false; bool hasValueY = false; @@ -938,10 +954,24 @@ void ParseGradientCenter(const EcmaVM* vm, const Local& value, std:: auto array = panda::Local(value); auto length = array->Length(vm); if (length == NUM_2) { + RefPtr xResObj; + RefPtr yResObj; hasValueX = - ArkTSUtils::ParseJsDimensionVp(vm, panda::ArrayRef::GetValueAt(vm, array, NUM_0), valueX, false); + ArkTSUtils::ParseJsDimensionVp(vm, panda::ArrayRef::GetValueAt(vm, array, NUM_0), valueX, + xResObj, false); hasValueY = - ArkTSUtils::ParseJsDimensionVp(vm, panda::ArrayRef::GetValueAt(vm, array, NUM_1), valueY, false); + ArkTSUtils::ParseJsDimensionVp(vm, panda::ArrayRef::GetValueAt(vm, array, NUM_1), valueY, + yResObj, false); + if (xResObj) { + vectorResObj.push_back(xResObj); + } else { + vectorResObj.push_back(nullptr); + } + if (yResObj) { + vectorResObj.push_back(yResObj); + } else { + vectorResObj.push_back(nullptr); + } } } values.push_back({.i32 = static_cast(hasValueX)}); @@ -973,8 +1003,32 @@ void PushOuterBorderColorVector(const std::optional& valueColor, std::vec options.push_back(0); } } + +bool ParseJsColorAlpha(const EcmaVM* vm, const Local& value, Color& color, + std::vector>& resObjs) +{ + RefPtr resObj; + bool result = ArkTSUtils::ParseJsColorAlpha(vm, value, color, resObj); + if (SystemProperties::ConfigChangePerform()) { + if (resObj) { + resObjs.push_back(resObj); + } else { + resObjs.push_back(nullptr); + } + } + return result; +} + +void SwapOuterBorderColor(std::vector>& resObjs) +{ + std::swap(resObjs[NUM_8], resObjs[NUM_12]); + std::swap(resObjs[NUM_9], resObjs[NUM_13]); + resObjs.erase(resObjs.begin() + NUM_12); + resObjs.erase(resObjs.begin() + NUM_13); +} + void ParseOuterBorderColor(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, std::vector& values, - int32_t argsIndex, bool needLocalized = false) + int32_t argsIndex, std::vector>& resObjs, bool needLocalized = false) { Local leftArg = runtimeCallInfo->GetCallArgRef(argsIndex); Local rightArg = runtimeCallInfo->GetCallArgRef(argsIndex + NUM_1); @@ -989,36 +1043,37 @@ void ParseOuterBorderColor(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, st std::optional endColor; Color left; - if (!leftArg->IsUndefined() && ArkTSUtils::ParseJsColorAlpha(vm, leftArg, left)) { + if (!leftArg->IsUndefined() && ParseJsColorAlpha(vm, leftArg, left, resObjs)) { leftColor = left; } Color right; - if (!rightArg->IsUndefined() && ArkTSUtils::ParseJsColorAlpha(vm, rightArg, right)) { + if (!rightArg->IsUndefined() && ParseJsColorAlpha(vm, rightArg, right, resObjs)) { rightColor = right; } Color top; - if (!topArg->IsUndefined() && ArkTSUtils::ParseJsColorAlpha(vm, topArg, top)) { + if (!topArg->IsUndefined() && ParseJsColorAlpha(vm, topArg, top, resObjs)) { topColor = top; } Color bottom; - if (!bottomArg->IsUndefined() && ArkTSUtils::ParseJsColorAlpha(vm, bottomArg, bottom)) { + if (!bottomArg->IsUndefined() && ParseJsColorAlpha(vm, bottomArg, bottom, resObjs)) { bottomColor = bottom; } if (needLocalized) { Local startArgs = runtimeCallInfo->GetCallArgRef(27); // 27: index of BorderColor.startColor Local endArgs = runtimeCallInfo->GetCallArgRef(28); // 28: index of BorderColor.endColor Color start; - if (!startArgs->IsUndefined() && ArkTSUtils::ParseJsColorAlpha(vm, startArgs, start)) { + if (!startArgs->IsUndefined() && ParseJsColorAlpha(vm, startArgs, start, resObjs)) { startColor = start; } Color end; - if (!endArgs->IsUndefined() && ArkTSUtils::ParseJsColorAlpha(vm, endArgs, end)) { + if (!endArgs->IsUndefined() && ParseJsColorAlpha(vm, endArgs, end, resObjs)) { endColor = end; } } if (startColor.has_value() || endColor.has_value()) { PushOuterBorderColorVector(startColor, values); PushOuterBorderColorVector(endColor, values); + SwapOuterBorderColor(resObjs); } else { PushOuterBorderColorVector(leftColor, values); PushOuterBorderColorVector(rightColor, values); @@ -1027,6 +1082,13 @@ void ParseOuterBorderColor(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, st PushOuterBorderColorVector(bottomColor, values); } +void ParseOuterBorderColor(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, std::vector& values, + int32_t argsIndex, bool needLocalized = false) +{ + std::vector> resObj; + ParseOuterBorderColor(runtimeCallInfo, vm, values, argsIndex, resObj, needLocalized); +} + bool ParseLocalizedBorderRadius(const EcmaVM* vm, const Local& value, CalcDimension& result) { if (ArkTSUtils::ParseJsLengthMetrics(vm, value, result)) { @@ -1038,8 +1100,22 @@ bool ParseLocalizedBorderRadius(const EcmaVM* vm, const Local& value return false; } +void ParseOuterBorder(EcmaVM* vm, const Local& args, std::optional& optionalDimension, + std::vector>& resObjs) +{ + RefPtr resObj; + ArkTSUtils::ParseOuterBorder(vm, args, optionalDimension, resObj); + if (SystemProperties::ConfigChangePerform()) { + if (resObj) { + resObjs.push_back(resObj); + } else { + resObjs.push_back(nullptr); + } + } +} + void ParseOuterBorderRadius(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, std::vector& values, - int32_t argsIndex, bool needLocalized = false) + int32_t argsIndex, std::vector>& resObjs, bool needLocalized = false) { Local topLeftArgs = runtimeCallInfo->GetCallArgRef(argsIndex); Local topRightArgs = runtimeCallInfo->GetCallArgRef(argsIndex + NUM_1); @@ -1076,10 +1152,10 @@ void ParseOuterBorderRadius(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, s std::optional bottomLeftOptional; std::optional bottomRightOptional; - ArkTSUtils::ParseOuterBorder(vm, topLeftArgs, topLeftOptional); - ArkTSUtils::ParseOuterBorder(vm, topRightArgs, topRightOptional); - ArkTSUtils::ParseOuterBorder(vm, bottomLeftArgs, bottomLeftOptional); - ArkTSUtils::ParseOuterBorder(vm, bottomRightArgs, bottomRightOptional); + ParseOuterBorder(vm, topLeftArgs, topLeftOptional, resObjs); + ParseOuterBorder(vm, topRightArgs, topRightOptional, resObjs); + ParseOuterBorder(vm, bottomLeftArgs, bottomLeftOptional, resObjs); + ParseOuterBorder(vm, bottomRightArgs, bottomRightOptional, resObjs); PushOuterBorderDimensionVector(topLeftOptional, values); PushOuterBorderDimensionVector(topRightOptional, values); @@ -1087,6 +1163,14 @@ void ParseOuterBorderRadius(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, s PushOuterBorderDimensionVector(bottomRightOptional, values); } +void ParseOuterBorderRadius(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, std::vector& values, + int32_t argsIndex, bool needLocalized = false) +{ + std::vector> resObj; + ParseOuterBorderRadius(runtimeCallInfo, vm, values, argsIndex, resObj, needLocalized); +} + + void PushOuterBorderStyleVector(const std::optional& value, std::vector &options) { options.push_back(static_cast(value.has_value())); @@ -1646,6 +1730,13 @@ ArkUINativeModuleValue CommonBridge::SetBorderWidth(ArkUIRuntimeCallInfo* runtim void CommonBridge::ParseOuterBorderWidth( ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, std::vector& values, bool needLocalized) +{ + std::vector> resObj; + ParseOuterBorderWidth(runtimeCallInfo, vm, values, resObj, needLocalized); +} + +void CommonBridge::ParseOuterBorderWidth(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, + std::vector& values, std::vector>& resObjs, bool needLocalized) { Local leftArgs = runtimeCallInfo->GetCallArgRef(NUM_1); Local rightArgs = runtimeCallInfo->GetCallArgRef(NUM_2); @@ -1659,8 +1750,8 @@ void CommonBridge::ParseOuterBorderWidth( std::optional startDim; std::optional endDim; - ArkTSUtils::ParseOuterBorder(vm, leftArgs, leftDim); - ArkTSUtils::ParseOuterBorder(vm, rightArgs, rightDim); + ParseOuterBorder(vm, leftArgs, leftDim, resObjs); + ParseOuterBorder(vm, rightArgs, rightDim, resObjs); if (needLocalized) { Local startArgs = runtimeCallInfo->GetCallArgRef(25); // 25: index of BorderWidth.start Local endArgs = runtimeCallInfo->GetCallArgRef(26); // 26: index of BorderWidth.end @@ -1669,8 +1760,8 @@ void CommonBridge::ParseOuterBorderWidth( ArkTSUtils::ParseOuterBorderForDashParams(vm, topArgs, topDim); ArkTSUtils::ParseOuterBorderForDashParams(vm, bottomArgs, bottomDim); } else { - ArkTSUtils::ParseOuterBorder(vm, topArgs, topDim); - ArkTSUtils::ParseOuterBorder(vm, bottomArgs, bottomDim); + ParseOuterBorder(vm, topArgs, topDim, resObjs); + ParseOuterBorder(vm, bottomArgs, bottomDim, resObjs); } if (startDim.has_value() || endDim.has_value()) { @@ -1700,6 +1791,56 @@ void ParseMirrorDimen(ArkUI_Float32 values[], int units[], int idx, CalcDimensio units[idx] = static_cast(calcDimen.Unit()); } +void ParseJsDimensionVpResObj(EcmaVM* vm, const Local& refValue, CalcDimension& dimension, + std::vector>& vectorResObj) +{ + RefPtr resObj; + ArkTSUtils::ParseJsDimensionVp(vm, refValue, dimension, resObj); + if (resObj) { + vectorResObj.push_back(resObj); + } else { + vectorResObj.push_back(nullptr); + } +} + +void ParseJsShadowRadiusResObj(const EcmaVM *vm, const Local& radiusArg, double& radius, + std::vector>& vectorResObj) +{ + RefPtr radiusResObj; + ArkTSUtils::ParseJsDouble(vm, radiusArg, radius, radiusResObj); + if (radiusResObj) { + vectorResObj.push_back(radiusResObj); + } else { + vectorResObj.push_back(nullptr); + } +} + +bool ParseJsShadowColorResObj(const EcmaVM *vm, const Local& colorArg, int32_t& type, uint32_t& color, + std::vector>& vectorResObj) +{ + RefPtr colorResObj; + bool ret = ParseJsShadowColor(vm, colorArg, type, color, colorResObj); + if (colorResObj) { + vectorResObj.push_back(colorResObj); + } else { + vectorResObj.push_back(nullptr); + } + return ret; +} + +bool SetBackShadowForShadowStyle(const ArkUINodeHandle nativeNode, const EcmaVM *vm, + const Local& styleArg) +{ + int32_t shadowStyle = 0; + if (ArkTSUtils::ParseJsInteger(vm, styleArg, shadowStyle)) { + ArkUIInt32orFloat32 shadows[] = { {.i32 = shadowStyle} }; + GetArkUINodeModifiers()->getCommonModifier()->setBackShadow(nativeNode, shadows, + (sizeof(shadows) / sizeof(shadows[NUM_0])), nullptr); + return true; + } + return false; +} + ArkUINativeModuleValue CommonBridge::SetBorderRadius(ArkUIRuntimeCallInfo *runtimeCallInfo) { EcmaVM *vm = runtimeCallInfo->GetVM(); @@ -2056,9 +2197,11 @@ ArkUINativeModuleValue CommonBridge::SetOutlineColor(ArkUIRuntimeCallInfo* runti Local firstArg = runtimeCallInfo->GetCallArgRef(0); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); std::vector colorOptions; - ParseOuterBorderColor(runtimeCallInfo, vm, colorOptions, NUM_1); + std::vector> vectorResObj; + ParseOuterBorderColor(runtimeCallInfo, vm, colorOptions, NUM_1, vectorResObj); + auto rawPtr = static_cast(&vectorResObj); GetArkUINodeModifiers()->getCommonModifier()->setOutlineColor( - nativeNode, colorOptions.data(), colorOptions.size()); + nativeNode, colorOptions.data(), colorOptions.size(), rawPtr); return panda::JSValueRef::Undefined(vm); } @@ -2079,9 +2222,11 @@ ArkUINativeModuleValue CommonBridge::SetOutlineRadius(ArkUIRuntimeCallInfo* runt Local firstArg = runtimeCallInfo->GetCallArgRef(0); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); std::vector radiusOptions; - ParseOuterBorderRadius(runtimeCallInfo, vm, radiusOptions, NUM_1); + std::vector> vectorResObj; + ParseOuterBorderRadius(runtimeCallInfo, vm, radiusOptions, NUM_1, vectorResObj); + auto rawPtr = static_cast(&vectorResObj); GetArkUINodeModifiers()->getCommonModifier()->setOutlineRadius( - nativeNode, radiusOptions.data(), radiusOptions.size()); + nativeNode, radiusOptions.data(), radiusOptions.size(), rawPtr); return panda::JSValueRef::Undefined(vm); } @@ -2102,9 +2247,11 @@ ArkUINativeModuleValue CommonBridge::SetOutlineWidth(ArkUIRuntimeCallInfo* runti Local firstArg = runtimeCallInfo->GetCallArgRef(0); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); std::vector widthOptions; - ParseOuterBorderWidth(runtimeCallInfo, vm, widthOptions); + std::vector> vectorResObj; + ParseOuterBorderWidth(runtimeCallInfo, vm, widthOptions, vectorResObj); + auto rawPtr = static_cast(&vectorResObj); GetArkUINodeModifiers()->getCommonModifier()->setOutlineWidth( - nativeNode, widthOptions.data(), widthOptions.size()); + nativeNode, widthOptions.data(), widthOptions.size(), rawPtr); return panda::JSValueRef::Undefined(vm); } @@ -2148,15 +2295,17 @@ ArkUINativeModuleValue CommonBridge::SetOutline(ArkUIRuntimeCallInfo* runtimeCal Local firstArg = runtimeCallInfo->GetCallArgRef(0); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); std::vector options; - ParseOuterBorderWidth(runtimeCallInfo, vm, options); // Outline Width args start index from 1 - ParseOuterBorderRadius(runtimeCallInfo, vm, options, NUM_9); // Outline Radius args start index + std::vector> vectorResObj; + ParseOuterBorderWidth(runtimeCallInfo, vm, options, vectorResObj); // Outline Width args start index from 1 + ParseOuterBorderRadius(runtimeCallInfo, vm, options, NUM_9, vectorResObj); // Outline Radius args start index std::vector colorAndStyleOptions; - ParseOuterBorderColor(runtimeCallInfo, vm, colorAndStyleOptions, NUM_5); // Outline Color args start index + ParseOuterBorderColor(runtimeCallInfo, vm, colorAndStyleOptions, NUM_5, vectorResObj); // Outline Color args start index ParseOuterBorderStyle(runtimeCallInfo, vm, colorAndStyleOptions, NUM_13); // Outline Style args start index + auto resRawPtr = static_cast(&vectorResObj); GetArkUINodeModifiers()->getCommonModifier()->setOutline( - nativeNode, options.data(), options.size(), colorAndStyleOptions.data(), colorAndStyleOptions.size()); + nativeNode, options.data(), options.size(), colorAndStyleOptions.data(), colorAndStyleOptions.size(), resRawPtr); return panda::JSValueRef::Undefined(vm); } @@ -2235,26 +2384,23 @@ ArkUINativeModuleValue CommonBridge::SetShadow(ArkUIRuntimeCallInfo *runtimeCall auto offsetYArg = runtimeCallInfo->GetCallArgRef(NUM_6); auto fillArg = runtimeCallInfo->GetCallArgRef(NUM_7); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); - int32_t shadowStyle = 0; - if (ArkTSUtils::ParseJsInteger(vm, styleArg, shadowStyle)) { - ArkUIInt32orFloat32 shadows[] = { {.i32 = shadowStyle} }; - GetArkUINodeModifiers()->getCommonModifier()->setBackShadow(nativeNode, shadows, - (sizeof(shadows) / sizeof(shadows[NUM_0]))); + if (SetBackShadowForShadowStyle(nativeNode, vm, styleArg)) { return panda::JSValueRef::Undefined(vm); } ArkUIInt32orFloat32 shadows[] = { { 0.0 }, { .i32 = 0 }, { 0.0 }, { 0.0 }, { .i32 = static_cast(ShadowType::COLOR) }, { .u32 = 0 }, { .i32 = 0 } }; + std::vector> vectorResObj; double radius; - ArkTSUtils::ParseJsDouble(vm, radiusArg, radius); + ParseJsShadowRadiusResObj(vm, radiusArg, radius, vectorResObj); shadows[NUM_0].f32 = radius; shadows[NUM_0].f32 = (LessNotEqual(shadows[NUM_0].f32, 0.0)) ? 0.0 : shadows[NUM_0].f32; CalcDimension offsetX; - if (ParseJsShadowDimension(vm, offsetXArg, offsetX)) { + if (ParseJsShadowDimension(vm, offsetXArg, offsetX, vectorResObj)) { shadows[NUM_2].f32 = offsetX.Value(); } CalcDimension offsetY; - if (ParseJsShadowDimension(vm, offsetYArg, offsetY)) { + if (ParseJsShadowDimension(vm, offsetYArg, offsetY, vectorResObj)) { shadows[NUM_3].f32 = offsetY.Value(); } if (typeArg->IsInt()) { @@ -2264,13 +2410,14 @@ ArkUINativeModuleValue CommonBridge::SetShadow(ArkUIRuntimeCallInfo *runtimeCall } int32_t type = 0; uint32_t color = 0; - if (ParseJsShadowColor(vm, colorArg, type, color)) { + if (ParseJsShadowColorResObj(vm, colorArg, type, color, vectorResObj)) { shadows[NUM_1].i32 = type; shadows[NUM_5].u32 = color; } shadows[NUM_6].i32 = fillArg->IsBoolean() ? fillArg->BooleaValue(vm) : false; + auto resRawPtr = static_cast(&vectorResObj); GetArkUINodeModifiers()->getCommonModifier()->setBackShadow(nativeNode, shadows, - (sizeof(shadows) / sizeof(shadows[NUM_0]))); + (sizeof(shadows) / sizeof(shadows[NUM_0])), resRawPtr); return panda::JSValueRef::Undefined(vm); } @@ -2344,10 +2491,12 @@ ArkUINativeModuleValue CommonBridge::SetOpacity(ArkUIRuntimeCallInfo *runtimeCal Local secondArg = runtimeCallInfo->GetCallArgRef(1); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); double opacity; - if (!ArkTSUtils::ParseJsDouble(vm, secondArg, opacity)) { + RefPtr opacityResObj; + if (!ArkTSUtils::ParseJsDouble(vm, secondArg, opacity, opacityResObj)) { GetArkUINodeModifiers()->getCommonModifier()->resetOpacity(nativeNode); } else { - GetArkUINodeModifiers()->getCommonModifier()->setOpacity(nativeNode, opacity); + auto opacityRawPtr = AceType::RawPtr(opacityResObj); + GetArkUINodeModifiers()->getCommonModifier()->setOpacity(nativeNode, opacity, opacityRawPtr); } return panda::JSValueRef::Undefined(vm); } @@ -2573,10 +2722,12 @@ ArkUINativeModuleValue CommonBridge::SetColorBlend(ArkUIRuntimeCallInfo *runtime Local secondArg = runtimeCallInfo->GetCallArgRef(NUM_1); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); Color color; - if (!ArkTSUtils::ParseJsColorAlpha(vm, secondArg, color)) { + RefPtr colorBlendObj; + if (!ArkTSUtils::ParseJsColorAlpha(vm, secondArg, color, colorBlendObj)) { GetArkUINodeModifiers()->getCommonModifier()->resetColorBlend(nativeNode); } else { - GetArkUINodeModifiers()->getCommonModifier()->setColorBlend(nativeNode, color.GetValue()); + auto cbColorRawPtr = AceType::RawPtr(colorBlendObj); + GetArkUINodeModifiers()->getCommonModifier()->setColorBlend(nativeNode, color.GetValue(), cbColorRawPtr); } return panda::JSValueRef::Undefined(vm); } @@ -2722,11 +2873,13 @@ ArkUINativeModuleValue CommonBridge::SetLinearGradient(ArkUIRuntimeCallInfo *run values.push_back({.i32 = static_cast(direction)}); std::vector colors; - ParseGradientColorStops(vm, colorsArg, colors); + std::vector> vectorResObj; + ParseGradientColorStops(vm, colorsArg, colors, vectorResObj); auto repeating = repeatingArg->IsBoolean() ? repeatingArg->BooleaValue(vm) : false; values.push_back({.i32 = static_cast(repeating)}); + auto colorRawPtr = static_cast(&vectorResObj); GetArkUINodeModifiers()->getCommonModifier()->setLinearGradient(nativeNode, values.data(), values.size(), - colors.data(), colors.size()); + colors.data(), colors.size(), colorRawPtr); return panda::JSValueRef::Undefined(vm); } @@ -2753,16 +2906,18 @@ ArkUINativeModuleValue CommonBridge::SetSweepGradient(ArkUIRuntimeCallInfo *runt auto repeatingArg = runtimeCallInfo->GetCallArgRef(NUM_6); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); std::vector values; - ParseGradientCenter(vm, centerArg, values); + std::vector> vectorResObj; + ParseGradientCenter(vm, centerArg, values, vectorResObj); ParseGradientAngle(vm, startArg, values); ParseGradientAngle(vm, endArg, values); ParseGradientAngle(vm, rotationArg, values); std::vector colors; - ParseGradientColorStops(vm, colorsArg, colors); + ParseGradientColorStops(vm, colorsArg, colors, vectorResObj); auto repeating = repeatingArg->IsBoolean() ? repeatingArg->BooleaValue(vm) : false; values.push_back({.i32 = static_cast(repeating)}); + auto resRawPtr = static_cast(&vectorResObj); GetArkUINodeModifiers()->getCommonModifier()->setSweepGradient(nativeNode, values.data(), values.size(), - colors.data(), colors.size()); + colors.data(), colors.size(), resRawPtr); return panda::JSValueRef::Undefined(vm); } @@ -2787,18 +2942,26 @@ ArkUINativeModuleValue CommonBridge::SetRadialGradient(ArkUIRuntimeCallInfo *run auto repeatingArg = runtimeCallInfo->GetCallArgRef(NUM_4); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); std::vector values; - ParseGradientCenter(vm, centerArg, values); + std::vector> vectorResObj; + ParseGradientCenter(vm, centerArg, values, vectorResObj); CalcDimension radius; - auto hasRadius = ArkTSUtils::ParseJsDimensionVp(vm, radiusArg, radius, false); + RefPtr radiusResObj; + auto hasRadius = ArkTSUtils::ParseJsDimensionVp(vm, radiusArg, radius, radiusResObj, false); + if (radiusResObj) { + vectorResObj.push_back(radiusResObj); + } else { + vectorResObj.push_back(nullptr); + } values.push_back({.i32 = static_cast(hasRadius)}); values.push_back({.f32 = static_cast(radius.Value())}); values.push_back({.i32 = static_cast(radius.Unit())}); std::vector colors; - ParseGradientColorStops(vm, colorsArg, colors); + ParseGradientColorStops(vm, colorsArg, colors, vectorResObj); auto repeating = repeatingArg->IsBoolean() ? repeatingArg->BooleaValue(vm) : false; values.push_back({.i32 = static_cast(repeating)}); + auto resRawPtr = static_cast(&vectorResObj); GetArkUINodeModifiers()->getCommonModifier()->setRadialGradient(nativeNode, values.data(), values.size(), - colors.data(), colors.size()); + colors.data(), colors.size(), resRawPtr); return panda::JSValueRef::Undefined(vm); } @@ -3016,14 +3179,14 @@ ArkUINativeModuleValue CommonBridge::ResetLinearGradientBlur(ArkUIRuntimeCallInf return panda::JSValueRef::Undefined(vm); } -void SetBackgroundBlurStyleParam( - ArkUIRuntimeCallInfo* runtimeCallInfo, bool& isValidColor, Color& inactiveColor, int32_t& policy, int32_t& blurType) +void SetBackgroundBlurStyleParam(ArkUIRuntimeCallInfo* runtimeCallInfo, bool& isValidColor, Color& inactiveColor, + int32_t& policy, int32_t& blurType, RefPtr& resourceObject) { EcmaVM *vm = runtimeCallInfo->GetVM(); auto policyArg = runtimeCallInfo->GetCallArgRef(NUM_6); auto inactiveColorArg = runtimeCallInfo->GetCallArgRef(NUM_7); auto typeArg = runtimeCallInfo->GetCallArgRef(NUM_8); - if (ArkTSUtils::ParseJsColor(vm, inactiveColorArg, inactiveColor)) { + if (ArkTSUtils::ParseJsColor(vm, inactiveColorArg, inactiveColor, resourceObject)) { isValidColor = true; } ParseJsInt32(vm, policyArg, policy); @@ -3038,28 +3201,16 @@ void SetBackgroundBlurStyleParam( } } -ArkUINativeModuleValue CommonBridge::SetBackgroundBlurStyle(ArkUIRuntimeCallInfo *runtimeCallInfo) +void ParseBackgroundBlurStyleParams(ArkUIRuntimeCallInfo *runtimeCallInfo, int32_t& colorMode, int32_t& adaptiveColor, + double& scale, BlurOption& blurOption) { EcmaVM *vm = runtimeCallInfo->GetVM(); - CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr)); - Local firstArg = runtimeCallInfo->GetCallArgRef(NUM_0); - auto blurStyleArg = runtimeCallInfo->GetCallArgRef(NUM_1); auto colorModeArg = runtimeCallInfo->GetCallArgRef(NUM_2); auto adaptiveColorArg = runtimeCallInfo->GetCallArgRef(NUM_3); auto scaleArg = runtimeCallInfo->GetCallArgRef(NUM_4); auto blurOptionsArg = runtimeCallInfo->GetCallArgRef(NUM_5); - auto disableSystemAdaptationArg = runtimeCallInfo->GetCallArgRef(NUM_9); - auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); - int32_t blurStyle = -1; - if (blurStyleArg->IsNumber()) { - blurStyle = blurStyleArg->Int32Value(vm); - } bool isHasOptions = !(colorModeArg->IsUndefined() && adaptiveColorArg->IsUndefined() && scaleArg->IsUndefined() && blurOptionsArg->IsUndefined()); - int32_t colorMode = -1; - int32_t adaptiveColor = -1; - double scale = -1.0; - BlurOption blurOption; if (isHasOptions) { colorMode = static_cast(ThemeColorMode::SYSTEM); ParseJsInt32(vm, colorModeArg, colorMode); @@ -3073,11 +3224,31 @@ ArkUINativeModuleValue CommonBridge::SetBackgroundBlurStyle(ArkUIRuntimeCallInfo ParseBlurOption(vm, blurOptionsArg, blurOption); } } +} + +ArkUINativeModuleValue CommonBridge::SetBackgroundBlurStyle(ArkUIRuntimeCallInfo *runtimeCallInfo) +{ + EcmaVM *vm = runtimeCallInfo->GetVM(); + CHECK_NULL_RETURN(vm, panda::NativePointerRef::New(vm, nullptr)); + Local firstArg = runtimeCallInfo->GetCallArgRef(NUM_0); + auto blurStyleArg = runtimeCallInfo->GetCallArgRef(NUM_1); + auto disableSystemAdaptationArg = runtimeCallInfo->GetCallArgRef(NUM_9); + auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); + int32_t blurStyle = -1; + if (blurStyleArg->IsNumber()) { + blurStyle = blurStyleArg->Int32Value(vm); + } + int32_t colorMode = -1; + int32_t adaptiveColor = -1; + double scale = -1.0; + BlurOption blurOption; + ParseBackgroundBlurStyleParams(runtimeCallInfo, colorMode, adaptiveColor, scale, blurOption); bool isValidColor = false; Color inactiveColor = Color::TRANSPARENT; auto policy = static_cast(BlurStyleActivePolicy::ALWAYS_ACTIVE); auto blurType = static_cast(BlurType::WITHIN_WINDOW); - SetBackgroundBlurStyleParam(runtimeCallInfo, isValidColor, inactiveColor, policy, blurType); + RefPtr inactiveColorResObj; + SetBackgroundBlurStyleParam(runtimeCallInfo, isValidColor, inactiveColor, policy, blurType, inactiveColorResObj); int32_t intArray[NUM_5]; intArray[NUM_0] = blurStyle; intArray[NUM_1] = colorMode; @@ -3088,9 +3259,10 @@ ArkUINativeModuleValue CommonBridge::SetBackgroundBlurStyle(ArkUIRuntimeCallInfo if (disableSystemAdaptationArg->IsBoolean()) { disableSystemAdaptation = disableSystemAdaptationArg->ToBoolean(vm)->Value(); } + auto inactiveColorRawPtr = AceType::RawPtr(inactiveColorResObj); GetArkUINodeModifiers()->getCommonModifier()->setBackgroundBlurStyle( nativeNode, &intArray, scale, blurOption.grayscale.data(), blurOption.grayscale.size(), - isValidColor, inactiveColor.GetValue(), disableSystemAdaptation); + isValidColor, inactiveColor.GetValue(), disableSystemAdaptation, inactiveColorRawPtr); return panda::JSValueRef::Undefined(vm); } @@ -3885,6 +4057,58 @@ ArkUINativeModuleValue CommonBridge::ResetClipShape(ArkUIRuntimeCallInfo *runtim return panda::JSValueRef::Undefined(vm); } +void ParseJsMaskProperty(FrameNode* frameNode, const Framework::JSRef& paramObject) +{ + auto progressMask = AceType::MakeRefPtr(); + Framework::JSRef jValue = paramObject->GetProperty("value"); + auto value = jValue->IsNumber() ? jValue->ToNumber() : 0.0f; + if (value < 0.0f) { + value = 0.0f; + } + progressMask->SetValue(value); + Framework::JSRef jTotal = paramObject->GetProperty("total"); + auto total = jTotal->IsNumber() ? jTotal->ToNumber() : DEFAULT_PROGRESS_TOTAL; + if (total < 0.0f) { + total = DEFAULT_PROGRESS_TOTAL; + } + progressMask->SetMaxValue(total); + Framework::JSRef jEnableBreathe = paramObject->GetProperty("breathe"); + if (jEnableBreathe->IsBoolean()) { + progressMask->SetEnableBreathe(jEnableBreathe->ToBoolean()); + } + Framework::JSRef jColor = paramObject->GetProperty("color"); + Color colorVal; + if (!SystemProperties::ConfigChangePerform()) { + if (Framework::JSViewAbstract::ParseJsColor(jColor, colorVal)) { + progressMask->SetColor(colorVal); + } else { + auto theme = Framework::JSShapeAbstract::GetTheme(); + progressMask->SetColor(theme->GetMaskColor()); + } + ViewAbstract::SetProgressMask(frameNode, progressMask); + } else { + RefPtr colorResObj; + auto parseJsColor = Framework::JSViewAbstract::ParseJsColor(jColor, colorVal, colorResObj); + if (colorResObj) { + progressMask->SetColor(colorVal); + auto&& updateFunc = [](const RefPtr& resObj, NG::ProgressMaskProperty& progressMask) { + Color color; + ResourceParseUtils::ParseResColor(resObj, color); + progressMask.SetColor(color); + }; + progressMask->AddResource("progressMask.color", colorResObj, std::move(updateFunc)); + ViewAbstract::SetProgressMask(frameNode, progressMask); + } else if (parseJsColor) { + progressMask->SetColor(colorVal); + ViewAbstract::SetProgressMask(frameNode, progressMask); + } else { + auto theme = Framework::JSShapeAbstract::GetTheme(); + progressMask->SetColor(theme->GetMaskColor()); + ViewAbstract::SetProgressMask(frameNode, progressMask); + } + } +} + ArkUINativeModuleValue CommonBridge::SetPixelStretchEffect(ArkUIRuntimeCallInfo *runtimeCallInfo) { EcmaVM *vm = runtimeCallInfo->GetVM(); @@ -3895,20 +4119,22 @@ ArkUINativeModuleValue CommonBridge::SetPixelStretchEffect(ArkUIRuntimeCallInfo auto bottomArg = runtimeCallInfo->GetCallArgRef(NUM_3); auto leftArg = runtimeCallInfo->GetCallArgRef(NUM_4); auto nativeNode = nodePtr(firstArg->ToNativePointer(vm)->Value()); + std::vector> vectorResObj; CalcDimension left; - ArkTSUtils::ParseJsDimensionVp(vm, leftArg, left); + ParseJsDimensionVpResObj(vm, leftArg, left, vectorResObj); CalcDimension right; - ArkTSUtils::ParseJsDimensionVp(vm, rightArg, right); + ParseJsDimensionVpResObj(vm, rightArg, right, vectorResObj); CalcDimension top; - ArkTSUtils::ParseJsDimensionVp(vm, topArg, top); + ParseJsDimensionVpResObj(vm, topArg, top, vectorResObj); CalcDimension bottom; - ArkTSUtils::ParseJsDimensionVp(vm, bottomArg, bottom); + ParseJsDimensionVpResObj(vm, bottomArg, bottom, vectorResObj); + auto rawPtr = static_cast(&vectorResObj); ArkUI_Float32 values[] = { static_cast(left.Value()), static_cast(top.Value()), static_cast(right.Value()), static_cast(bottom.Value()) }; int units[] = { static_cast(left.Unit()), static_cast(top.Unit()), static_cast(right.Unit()), static_cast(bottom.Unit()) }; GetArkUINodeModifiers()->getCommonModifier()->setPixelStretchEffect(nativeNode, values, units, - (sizeof(values) / sizeof(values[NUM_0]))); + (sizeof(values) / sizeof(values[NUM_0])), rawPtr); return panda::JSValueRef::Undefined(vm); } @@ -4073,13 +4299,15 @@ ArkUINativeModuleValue CommonBridge::SetForegroundColor(ArkUIRuntimeCallInfo *ru std::transform(colorStr.begin(), colorStr.end(), colorStr.begin(), ::tolower); if (colorStr.compare("invert") == 0) { auto strategy = static_cast(ForegroundColorStrategy::INVERT); - GetArkUINodeModifiers()->getCommonModifier()->setForegroundColor(nativeNode, false, strategy); + GetArkUINodeModifiers()->getCommonModifier()->setForegroundColor(nativeNode, false, strategy, nullptr); return panda::JSValueRef::Undefined(vm); } } Color foregroundColor = Color::TRANSPARENT; - ArkTSUtils::ParseJsColorAlpha(vm, colorArg, foregroundColor); - GetArkUINodeModifiers()->getCommonModifier()->setForegroundColor(nativeNode, true, foregroundColor.GetValue()); + RefPtr colorResObj; + ArkTSUtils::ParseJsColorAlpha(vm, colorArg, foregroundColor, colorResObj); + auto fgColorRawPtr = AceType::RawPtr(colorResObj); + GetArkUINodeModifiers()->getCommonModifier()->setForegroundColor(nativeNode, true, foregroundColor.GetValue(), fgColorRawPtr); return panda::JSValueRef::Undefined(vm); } @@ -5634,7 +5862,7 @@ ArkUINativeModuleValue CommonBridge::ResetForegroundEffect(ArkUIRuntimeCallInfo* } void SetBackgroundEffectParam(ArkUIRuntimeCallInfo* runtimeCallInfo, int32_t& policy, int32_t& blurType, - Color& inactiveColor, bool& isValidColor) + Color& inactiveColor, bool& isValidColor, RefPtr& resourceObject) { EcmaVM* vm = runtimeCallInfo->GetVM(); Local policyArg = runtimeCallInfo->GetCallArgRef(7); // 7:index of parameter policy @@ -5651,7 +5879,7 @@ void SetBackgroundEffectParam(ArkUIRuntimeCallInfo* runtimeCallInfo, int32_t& po blurType > static_cast(BlurType::BEHIND_WINDOW)) { blurType = static_cast(BlurType::WITHIN_WINDOW); } - if (ArkTSUtils::ParseJsColor(vm, inactiveColorArg, inactiveColor)) { + if (ArkTSUtils::ParseJsColor(vm, inactiveColorArg, inactiveColor, resourceObject)) { isValidColor = true; } } @@ -5670,6 +5898,22 @@ void SetAdaptiveColorParam(ArkUIRuntimeCallInfo* runtimeCallInfo, AdaptiveColor& } } +void ParseBackgroundEffectParams(const Local& saturationArg, const Local& brightnessArg, + ArkUI_Float32& saturationVal, ArkUI_Float32& brightnessVal) +{ + ArkUI_Float32 saturation = 1.0f; + if (saturationArg->IsNumber()) { + saturation = saturationArg->ToNumber(vm)->Value(); + saturation = (saturation > 0.0f || NearZero(saturation)) ? saturation : 1.0f; + } + saturationVal = saturation; + ArkUI_Float32 brightness = 1.0f; + if (brightnessArg->IsNumber()) { + brightness = brightnessArg->ToNumber(vm)->Value(); + brightness = (brightness > 0.0f || NearZero(brightness)) ? brightness : 1.0f; + } + brightnessVal = brightness; +} ArkUINativeModuleValue CommonBridge::SetBackgroundEffect(ArkUIRuntimeCallInfo* runtimeCallInfo) { EcmaVM* vm = runtimeCallInfo->GetVM(); @@ -5687,17 +5931,11 @@ ArkUINativeModuleValue CommonBridge::SetBackgroundEffect(ArkUIRuntimeCallInfo* r radius.SetValue(0.0f); } ArkUI_Float32 saturation = 1.0f; - if (saturationArg->IsNumber()) { - saturation = saturationArg->ToNumber(vm)->Value(); - saturation = (saturation > 0.0f || NearZero(saturation)) ? saturation : 1.0f; - } ArkUI_Float32 brightness = 1.0f; - if (brightnessArg->IsNumber()) { - brightness = brightnessArg->ToNumber(vm)->Value(); - brightness = (brightness > 0.0f || NearZero(brightness)) ? brightness : 1.0f; - } + ParseBackgroundEffectParams(saturationArg, brightnessArg, saturation, brightness); Color color = Color::TRANSPARENT; - if (!ArkTSUtils::ParseJsColor(vm, colorArg, color)) { + RefPtr colorResObj; + if (!ArkTSUtils::ParseJsColor(vm, colorArg, color, colorResObj)) { color.SetValue(Color::TRANSPARENT.GetValue()); } auto adaptiveColor = AdaptiveColor::DEFAULT; @@ -5710,15 +5948,18 @@ ArkUINativeModuleValue CommonBridge::SetBackgroundEffect(ArkUIRuntimeCallInfo* r auto blurType = static_cast(BlurType::WITHIN_WINDOW); Color inactiveColor = Color::TRANSPARENT; bool isValidColor = false; - SetBackgroundEffectParam(runtimeCallInfo, policy, blurType, inactiveColor, isValidColor); + RefPtr inactiveColorResObj; + SetBackgroundEffectParam(runtimeCallInfo, policy, blurType, inactiveColor, isValidColor, inactiveColorResObj); bool disableSystemAdaptation = false; if (disableSystemAdaptationArg->IsBoolean()) { disableSystemAdaptation = disableSystemAdaptationArg->ToBoolean(vm)->Value(); } + auto colorRawPtr = AceType::RawPtr(colorResObj); + auto inactiveColorRawPtr = AceType::RawPtr(inactiveColorResObj); GetArkUINodeModifiers()->getCommonModifier()->setBackgroundEffect(nativeNode, static_cast(radius.Value()), saturation, brightness, color.GetValue(), static_cast(adaptiveColor), blurOption.grayscale.data(), blurOption.grayscale.size(), policy, - blurType, isValidColor, inactiveColor.GetValue(), disableSystemAdaptation); + blurType, isValidColor, inactiveColor.GetValue(), disableSystemAdaptation, colorRawPtr, inactiveColorRawPtr); return panda::JSValueRef::Undefined(vm); } @@ -6157,28 +6398,7 @@ ArkUINativeModuleValue CommonBridge::SetMask(ArkUIRuntimeCallInfo* runtimeCallIn Framework::JSRef typeParam = paramObject->GetProperty("type"); if (!typeParam->IsNull() && !typeParam->IsUndefined() && typeParam->IsString() && typeParam->ToString() == "ProgressMask") { - auto progressMask = AceType::MakeRefPtr(); - Framework::JSRef jValue = paramObject->GetProperty("value"); - auto value = jValue->IsNumber() ? jValue->ToNumber() : 0.0f; - if (value < 0.0f) { - value = 0.0f; - } - progressMask->SetValue(value); - Framework::JSRef jTotal = paramObject->GetProperty("total"); - auto total = jTotal->IsNumber() ? jTotal->ToNumber() : DEFAULT_PROGRESS_TOTAL; - if (total < 0.0f) { - total = DEFAULT_PROGRESS_TOTAL; - } - progressMask->SetMaxValue(total); - Framework::JSRef jColor = paramObject->GetProperty("color"); - Color colorVal; - if (Framework::JSViewAbstract::ParseJsColor(jColor, colorVal)) { - progressMask->SetColor(colorVal); - } else { - auto theme = Framework::JSShapeAbstract::GetTheme(); - progressMask->SetColor(theme->GetMaskColor()); - } - ViewAbstract::SetProgressMask(frameNode, progressMask); + ParseJsMaskProperty(frameNode, paramObject); } else { Framework::JSShapeAbstract* maskShape = Framework::JSRef::Cast(info[NUM_1])->Unwrap(); @@ -6768,7 +6988,7 @@ RefPtr CreateResourceWrapper() } bool ParseLightPosition(ArkUIRuntimeCallInfo *runtimeCallInfo, EcmaVM* vm, ArkUISizeType& dimPosX, - ArkUISizeType& dimPosY, ArkUISizeType& dimPosZ) + ArkUISizeType& dimPosY, ArkUISizeType& dimPosZ, std::vector>& vectorResObj) { Local positionXArg = runtimeCallInfo->GetCallArgRef(NUM_1); Local positionYArg = runtimeCallInfo->GetCallArgRef(NUM_2); @@ -6776,12 +6996,30 @@ bool ParseLightPosition(ArkUIRuntimeCallInfo *runtimeCallInfo, EcmaVM* vm, ArkUI CalcDimension dimPositionX; CalcDimension dimPositionY; CalcDimension dimPositionZ; - bool xSuccess = ArkTSUtils::ParseJsDimensionVp(vm, positionXArg, dimPositionX, false); - bool ySuccess = ArkTSUtils::ParseJsDimensionVp(vm, positionYArg, dimPositionY, false); - bool zSuccess = ArkTSUtils::ParseJsDimensionVp(vm, positionZArg, dimPositionZ, false); + RefPtr xResObj; + RefPtr yResObj; + RefPtr zResObj; + bool xSuccess = ArkTSUtils::ParseJsDimensionVp(vm, positionXArg, dimPositionX, xResObj, false); + bool ySuccess = ArkTSUtils::ParseJsDimensionVp(vm, positionYArg, dimPositionY, yResObj, false); + bool zSuccess = ArkTSUtils::ParseJsDimensionVp(vm, positionZArg, dimPositionZ, zResObj, false); if (!(xSuccess && ySuccess && zSuccess)) { return false; } + if (xResObj) { + vectorResObj.push_back(xResObj); + } else { + vectorResObj.push_back(nullptr); + } + if (yResObj) { + vectorResObj.push_back(yResObj); + } else { + vectorResObj.push_back(nullptr); + } + if (zResObj) { + vectorResObj.push_back(zResObj); + } else { + vectorResObj.push_back(nullptr); + } dimPosX.value = dimPositionX.Value(); dimPosX.unit = static_cast(dimPositionX.Unit()); dimPosY.value = dimPositionY.Value(); @@ -6796,9 +7034,12 @@ void ParseLightSource(ArkUIRuntimeCallInfo *runtimeCallInfo, EcmaVM* vm, ArkUINo struct ArkUISizeType dimPosX = { 0.0, 0 }; struct ArkUISizeType dimPosY = { 0.0, 0 }; struct ArkUISizeType dimPosZ = { 0.0, 0 }; - bool success = ParseLightPosition(runtimeCallInfo, vm, dimPosX, dimPosY, dimPosZ); + std::vector> vectorResObj; + bool success = ParseLightPosition(runtimeCallInfo, vm, dimPosX, dimPosY, dimPosZ, vectorResObj); if (success) { - GetArkUINodeModifiers()->getCommonModifier()->setPointLightPosition(nativeNode, &dimPosX, &dimPosY, &dimPosZ); + auto resRawPtr = static_cast(&vectorResObj); + GetArkUINodeModifiers()->getCommonModifier()->setPointLightPosition( + nativeNode, &dimPosX, &dimPosY, &dimPosZ, resRawPtr); } else { GetArkUINodeModifiers()->getCommonModifier()->resetPointLightPosition(nativeNode); } @@ -6813,8 +7054,10 @@ void ParseLightSource(ArkUIRuntimeCallInfo *runtimeCallInfo, EcmaVM* vm, ArkUINo Local colorArg = runtimeCallInfo->GetCallArgRef(NUM_5); Color colorValue; - if (ArkTSUtils::ParseJsColorAlpha(vm, colorArg, colorValue)) { - GetArkUINodeModifiers()->getCommonModifier()->setPointLightColor(nativeNode, colorValue.GetValue()); + RefPtr colorResObj; + if (ArkTSUtils::ParseJsColorAlpha(vm, colorArg, colorValue, colorResObj)) { + auto colorRawPtr = AceType::RawPtr(colorResObj); + GetArkUINodeModifiers()->getCommonModifier()->setPointLightColor(nativeNode, colorValue.GetValue(), colorRawPtr); } else { GetArkUINodeModifiers()->getCommonModifier()->resetPointLightColor(nativeNode); } diff --git a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_common_bridge.h b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_common_bridge.h index 03cf48d814d..6b0cf775f24 100644 --- a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_common_bridge.h +++ b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_common_bridge.h @@ -333,6 +333,8 @@ public: int& isLocalizedBorderColor, int& isLocalizedBorderRadius); static void ParseOuterBorderWidth(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, std::vector& values, bool needLocalized = false); + static void ParseOuterBorderWidth(ArkUIRuntimeCallInfo* runtimeCallInfo, EcmaVM* vm, + std::vector& values, std::vector>& resObjs, bool needLocalized = false); static LayoutCalPolicy ParseLayoutPolicy(const std::string& layoutPolicy); static ArkUIGesture* GetGestureGroup(ArkUIRuntimeCallInfo* runtimeCallInfo, uint32_t argNumber); static Local CreateCommonGestureEventInfo(EcmaVM* vm, GestureEvent& info); diff --git a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_loading_progress_bridge.cpp b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_loading_progress_bridge.cpp index e87d5347701..a9779807911 100644 --- a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_loading_progress_bridge.cpp +++ b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_native_loading_progress_bridge.cpp @@ -89,7 +89,7 @@ ArkUINativeModuleValue LoadingProgressBridge::SetForegroundColor(ArkUIRuntimeCal ForegroundColorStrategy strategy; if (ArkTSUtils::ParseJsColorStrategy(vm, colorArg, strategy)) { auto strategyInt = static_cast(ForegroundColorStrategy::INVERT); - GetArkUINodeModifiers()->getCommonModifier()->setForegroundColor(nativeNode, false, strategyInt); + GetArkUINodeModifiers()->getCommonModifier()->setForegroundColor(nativeNode, false, strategyInt, nullptr); return panda::JSValueRef::Undefined(vm); } Color foregroundColor; diff --git a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.cpp b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.cpp index 3f321dd743f..6c2454aa247 100644 --- a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.cpp +++ b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.cpp @@ -1693,9 +1693,16 @@ double ArkTSUtils::parseShadowOffsetWithResObj(const EcmaVM* vm, const Local& args, std::optional& optionalDimension) +{ + RefPtr resObj; + ParseOuterBorder(vm, args, optionalDimension, resObj); +} + +void ArkTSUtils::ParseOuterBorder(EcmaVM* vm, const Local& args, + std::optional& optionalDimension, RefPtr& resObj) { CalcDimension valueDim; - if (!args->IsUndefined() && ArkTSUtils::ParseJsDimensionVp(vm, args, valueDim, false)) { + if (!args->IsUndefined() && ArkTSUtils::ParseJsDimensionVp(vm, args, valueDim, resObj, false)) { if (valueDim.IsNegative() || valueDim.Unit() == DimensionUnit::PERCENT) { valueDim.Reset(); } diff --git a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h index 8f6733d2ce6..ffdc783f401 100644 --- a/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h +++ b/frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h @@ -161,6 +161,8 @@ public: std::string& customFamilyName); static void ParseOuterBorder(EcmaVM* vm, const Local& args, std::optional& optionalDimension); + static void ParseOuterBorder(EcmaVM* vm, const Local& args, + std::optional& optionalDimension, RefPtr& resourceObject); static void ParseOuterBorderForDashParams(EcmaVM* vm, const Local& args, std::optional& optionalDimension); static void PushOuterBorderDimensionVector(const std::optional& valueDim, diff --git a/frameworks/bridge/declarative_frontend/jsview/js_shape_abstract.cpp b/frameworks/bridge/declarative_frontend/jsview/js_shape_abstract.cpp index c642251b8b7..541a7d95727 100644 --- a/frameworks/bridge/declarative_frontend/jsview/js_shape_abstract.cpp +++ b/frameworks/bridge/declarative_frontend/jsview/js_shape_abstract.cpp @@ -459,7 +459,6 @@ void JSShapeAbstract::ObjectFill(const JSCallbackInfo& info) if (info.Length() < 1) { return; } - Color color; if (!SystemProperties::ConfigChangePerform()) { if (ParseJsColor(info[0], color) && basicShape_) { diff --git a/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.cpp b/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.cpp index 2784b2b4fe5..68b6336e856 100644 --- a/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.cpp +++ b/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.cpp @@ -179,6 +179,8 @@ const char* DEBUG_LINE_INFO_PACKAGE_NAME = "$packageName"; enum class OperationType { COPY, PASTE, CUT, SELECT_ALL, UNKNOWN }; +static std::map gradientColorMap; + void ParseJsScale(const JSRef& jsValue, float& scaleX, float& scaleY, float& scaleZ, CalcDimension& centerX, CalcDimension& centerY) { @@ -1757,6 +1759,7 @@ void JSViewAbstract::JsScaleY(const JSCallbackInfo& info) void JSViewAbstract::JsOpacity(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("viewAbstract.opacity"); double opacity = 0.0; RefPtr opacityResObj; if (!ParseJsDouble(info[0], opacity, opacityResObj)) { @@ -3191,6 +3194,7 @@ void JSViewAbstract::JsBackgroundBlurStyle(const JSCallbackInfo& info) if (info.Length() == 0) { return; } + ViewAbstractModel::GetInstance()->RemoveResObj("backgroundBlurStyle.backgroundBlurStyleOptions"); BlurStyleOption styleOption; if (info[0]->IsNumber()) { auto blurStyle = info[0]->ToNumber(); @@ -3397,6 +3401,7 @@ void JSViewAbstract::JsBackgroundEffect(const JSCallbackInfo& info) if (info.Length() == 0) { return; } + ViewAbstractModel::GetInstance()->RemoveResObj("backgroundEffect"); EffectOption option; if (info[0]->IsObject()) { JSRef jsOption = JSRef::Cast(info[0]); @@ -3526,6 +3531,7 @@ void JSViewAbstract::GetPixelStretchEffectBottomObj(const JSRef& jsObj void JSViewAbstract::JsPixelStretchEffect(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("pixelStretchEffect"); if (!info[0]->IsObject()) { PixStretchEffectOption option; option.ResetValue(); @@ -4166,6 +4172,9 @@ bool JSViewAbstract::ParseCommonMarginOrPaddingCorner( void JSViewAbstract::JsOutline(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("outerBorderWidth"); + ViewAbstractModel::GetInstance()->RemoveResObj("outerBorderColorRes"); + ViewAbstractModel::GetInstance()->RemoveResObj("outerBorderRadiusRes"); static std::vector checkList { JSCallbackInfoType::OBJECT }; auto jsVal = info[0]; if (!CheckJSCallbackInfo("JsOutline", jsVal, checkList)) { @@ -4200,6 +4209,7 @@ void JSViewAbstract::JsOutline(const JSCallbackInfo& info) void JSViewAbstract::JsOutlineWidth(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("outerBorderWidth"); static std::vector checkList { JSCallbackInfoType::STRING, JSCallbackInfoType::NUMBER, JSCallbackInfoType::OBJECT }; auto jsVal = info[0]; @@ -4212,11 +4222,13 @@ void JSViewAbstract::JsOutlineWidth(const JSCallbackInfo& info) void JSViewAbstract::JsOutlineColor(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("outerBorderColorRes"); ParseOuterBorderColor(info[0]); } void JSViewAbstract::JsOutlineRadius(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("outerBorderRadius"); static std::vector checkList { JSCallbackInfoType::STRING, JSCallbackInfoType::NUMBER, JSCallbackInfoType::OBJECT }; auto jsVal = info[0]; @@ -5554,6 +5566,7 @@ void JSViewAbstract::JsMotionBlur(const JSCallbackInfo& info) void JSViewAbstract::JsColorBlend(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("viewAbstract.colorBlend"); Color colorBlend; if (info[0]->IsUndefined()) { colorBlend = Color::TRANSPARENT; @@ -7780,6 +7793,7 @@ void JSViewAbstract::SetGradientDirection(NG::Gradient& newGradient, const Gradi void JSViewAbstract::JsRadialGradient(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("RadialGradient.gradient"); static std::vector checkList { JSCallbackInfoType::OBJECT }; auto jsVal = info[0]; if (!CheckJSCallbackInfo("JsRadialGradient", jsVal, checkList)) { @@ -7884,6 +7898,7 @@ void JSViewAbstract::ParseRadialGradientCenter(NG::Gradient& newGradient, JSRef< void JSViewAbstract::JsSweepGradient(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("SweepGradient.gradient"); static std::vector checkList { JSCallbackInfoType::OBJECT }; auto jsVal = info[0]; if (!CheckJSCallbackInfo("JsSweepGradient", jsVal, checkList)) { @@ -8014,6 +8029,7 @@ void JSViewAbstract::JsMotionPath(const JSCallbackInfo& info) void JSViewAbstract::JsShadow(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("shadow"); static std::vector checkList { JSCallbackInfoType::OBJECT, JSCallbackInfoType::NUMBER }; auto jsVal = info[0]; if (!CheckJSCallbackInfo("JsShadow", jsVal, checkList)) { @@ -8296,6 +8312,7 @@ void JSViewAbstract::JsClip(const JSCallbackInfo& info) void JSViewAbstract::JsClipShape(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("clipShape"); if (info[0]->IsObject()) { JSShapeAbstract* clipShape = JSRef::Cast(info[0])->Unwrap(); if (clipShape == nullptr) { @@ -8338,21 +8355,26 @@ void JSViewAbstract::ParseJsMaskProperty(const JSRef& paramObject) RefPtr colorResObj; auto ret = ParseJsColor(jColor, colorVal, colorResObj); if (colorResObj) { - progressMask->SetResObj(colorResObj); - ViewAbstractModel::GetInstance()->CreateWithMaskResourceObj(progressMask); + progressMask->SetColor(colorVal); + auto&& updateFunc = [](const RefPtr& resObj, NG::ProgressMaskProperty& progressMask) { + Color color; + ResourceParseUtils::ParseResColor(resObj, color); + progressMask.SetColor(color); + }; + progressMask->AddResource("progressMask.color", colorResObj, std::move(updateFunc)); } else if (ret) { progressMask->SetColor(colorVal); - ViewAbstractModel::GetInstance()->SetProgressMask(progressMask); } else { RefPtr theme = GetTheme(); progressMask->SetColor(theme->GetMaskColor()); - ViewAbstractModel::GetInstance()->SetProgressMask(progressMask); } + ViewAbstractModel::GetInstance()->SetProgressMask(progressMask); } } void JSViewAbstract::JsMask(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("maskShape"); JSRef arg = info[0]; if (!arg->IsObject()) { ViewAbstractModel::GetInstance()->SetProgressMask(nullptr); @@ -8873,7 +8895,7 @@ void JSViewAbstract::JsPointLight(const JSCallbackInfo& info) if (!info[0]->IsObject()) { return; } - + ViewAbstractModel::GetInstance()->RemoveResObj("LightColorRes"); JSRef object = JSRef::Cast(info[0]); JSRef lightSource = object->GetProperty("lightSource"); if (!SystemProperties::ConfigChangePerform()) { @@ -9832,7 +9854,7 @@ bool JSViewAbstract::GetShadowFromTheme(ShadowStyle shadowStyle, Shadow& shadow) } shadow = shadowTheme->GetShadow(shadowStyle, colorMode); if (SystemProperties::ConfigChangePerform()) { - RefPtr resObj = AceType::MakeRefPtr("", "", -1);; + RefPtr resObj = AceType::MakeRefPtr("", "", -1); auto&& updateFunc = [shadowStyle](const RefPtr& resObj, Shadow& shadow) { auto colorMode = Container::CurrentColorMode(); auto container = Container::Current(); @@ -10095,6 +10117,34 @@ void JSViewAbstract::NewGetGradientColorStops(NG::Gradient& gradient, const std: } } +void CheckGradientColorMapAddFront(NG::Gradient& gradient, const int32_t index) +{ + if (gradient.GetColors().size() < index) { + for (int32_t indx = gradient.GetColors().size(); indx < index; indx++) { + auto it = gradientColorMap.find(indx); + if (it != gradientColorMap.end()) { + NG::GradientColor gradientColor = it->second; + gradient.AddColor(gradientColor); + } + } + } +} + +void CheckGradientColorMapAddBack(NG::Gradient& gradient, const size_t colorsLth) +{ + if (gradient.GetColors().size() < colorsLth) { + for (int32_t indx = gradient.GetColors().size(); indx < colorsLth; indx++) { + auto it = gradientColorMap.find(indx); + if (it != gradientColorMap.end()) { + NG::GradientColor gradientColor = it->second; + gradient.AddColor(gradientColor); + } else { + break; + } + } + } +} + void JSViewAbstract::NewParseGradientColor(NG::Gradient& gradient, JSRef& subArray, NG::GradientColor& gradientColor, size_t& i, size_t& length) { @@ -10115,27 +10165,22 @@ void JSViewAbstract::NewParseGradientColor(NG::Gradient& gradient, JSRef& resObj, NG::Gradient& gradient) { - if (gradient.GetColors().size() == length) { + auto&& updateFunc = [gradientColor, length, i](const RefPtr& resObj, NG::Gradient& gradient) { + if (gradient.GetColors().size() >= static_cast(length)) { gradient.ClearColors(); } + CheckGradientColorMapAddFront(gradient, i); Color color; ResourceParseUtils::ParseResColor(resObj, color); - NG::GradientColor gradientColorValue; - double& valued = const_cast(value); + NG::GradientColor& gradientColorValue = const_cast(gradientColor); gradientColorValue.SetColor(color); - gradientColorValue.SetHasValue(false); - // [0, 1] -> [0, 100.0]; - JSRef& subArray1 = const_cast&>(subArray); - if (ParseJsDouble(subArray1->GetValueAt(1), valued)) { - valued = std::clamp(valued, 0.0, 1.0); - gradientColorValue.SetHasValue(true); - } - gradientColorValue.SetDimension(CalcDimension(valued * 100.0, DimensionUnit::PERCENT)); gradient.AddColor(gradientColorValue); + CheckGradientColorMapAddBack(gradient, length); }; std::string key = "LinearGradient.gradient.color" + std::to_string(i); gradient.AddResource(key, resObj, std::move(updateFunc)); + } else { + gradientColorMap[i] = gradientColor; } } @@ -10691,6 +10736,7 @@ void JSViewAbstract::JsOnChildTouchTest(const JSCallbackInfo& info) void JSViewAbstract::JsForegroundColor(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("foregroundColor"); Color foregroundColor = Color::TRANSPARENT; ForegroundColorStrategy strategy; if (ParseJsColorStrategy(info[0], strategy)) { @@ -11596,6 +11642,7 @@ void JSViewAbstract::JsCustomProperty(const JSCallbackInfo& info) void JSViewAbstract::JsLinearGradient(const JSCallbackInfo& info) { + ViewAbstractModel::GetInstance()->RemoveResObj("LinearGradient.gradient"); static std::vector checkList { JSCallbackInfoType::OBJECT }; auto jsVal = info[0]; if (!CheckJSCallbackInfo("LinearGradient", jsVal, checkList)) { diff --git a/frameworks/core/components_ng/base/view_abstract.cpp b/frameworks/core/components_ng/base/view_abstract.cpp index ee4ccab3d87..3a56d22369a 100644 --- a/frameworks/core/components_ng/base/view_abstract.cpp +++ b/frameworks/core/components_ng/base/view_abstract.cpp @@ -71,6 +71,17 @@ std::string PropertyVectorToString(const std::vector& vec } } // namespace +void ViewAbstract::RemoveResObj(const std::string& key) +{ + if (!SystemProperties::ConfigChangePerform()) { + return; + } + auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + pattern->RemoveResObj(key); +} void ViewAbstract::SetWidth(const CalcLength& width) { @@ -798,24 +809,6 @@ void ViewAbstract::SetBackgroundEffect(const EffectOption& effectOption, const S if (!ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess()) { return; } - if (SystemProperties::ConfigChangePerform()) { - auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); - CHECK_NULL_VOID(frameNode); - auto pattern = frameNode->GetPattern(); - CHECK_NULL_VOID(pattern); - RefPtr resObj = AceType::MakeRefPtr("", "", -1); - auto&& updateFunc = [effectOption, sysOptions, weak = AceType::WeakClaim(frameNode)]( - const RefPtr& resObj) { - auto frameNode = weak.Upgrade(); - if (!frameNode) { - return; - } - EffectOption& effectOptionValue = const_cast(effectOption); - effectOptionValue.ReloadResources(); - SetBackgroundEffect(ViewStackProcessor::GetInstance()->GetMainFrameNode(), effectOptionValue, sysOptions); - }; - pattern->AddResObj("backgroundEffect", resObj, std::move(updateFunc)); - } SetBackgroundEffect(ViewStackProcessor::GetInstance()->GetMainFrameNode(), effectOption, sysOptions); } @@ -1577,6 +1570,24 @@ void ViewAbstract::SetOuterBorderRadius(const BorderRadiusProperty& value) void ViewAbstract::SetOuterBorderRadius(FrameNode* frameNode, const BorderRadiusProperty& value) { + if (SystemProperties::ConfigChangePerform()) { + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [value, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + if (!frameNode) { + return; + } + BorderRadiusProperty& outerBorderRadius = const_cast(value); + outerBorderRadius.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(OuterBorderRadius, outerBorderRadius, frameNode); + frameNode->MarkModifyDone(); + frameNode->MarkDirtyNode(); + }; + pattern->AddResObj("outerBorderRadius", resObj, std::move(updateFunc)); + } ACE_UPDATE_NODE_RENDER_CONTEXT(OuterBorderRadius, value, frameNode); } @@ -1624,6 +1635,22 @@ void ViewAbstract::SetOuterBorderColor(const BorderColorProperty& value) void ViewAbstract::SetOuterBorderColor(FrameNode* frameNode, const BorderColorProperty& value) { + if (SystemProperties::ConfigChangePerform()) { + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [value, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + if (!frameNode) { + return; + } + BorderColorProperty& outerBorderColor = const_cast(value); + outerBorderColor.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(OuterBorderColor, outerBorderColor, frameNode); + }; + pattern->AddResObj("outerBorderColor", resObj, std::move(updateFunc)); + } ACE_UPDATE_NODE_RENDER_CONTEXT(OuterBorderColor, value, frameNode); } @@ -1681,6 +1708,24 @@ void ViewAbstract::SetOuterBorderWidth(const BorderWidthProperty& value) void ViewAbstract::SetOuterBorderWidth(FrameNode* frameNode, const BorderWidthProperty& value) { + if (SystemProperties::ConfigChangePerform()) { + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [value, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + if (!frameNode) { + return; + } + BorderWidthProperty& outerBorderWidth = const_cast(value); + outerBorderWidth.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(OuterBorderWidth, outerBorderWidth, frameNode); + frameNode->MarkModifyDone(); + frameNode->MarkDirtyNode(); + }; + pattern->AddResObj("outerBorderWidth", resObj, std::move(updateFunc)); + } ACE_UPDATE_NODE_RENDER_CONTEXT(OuterBorderWidth, value, frameNode); } @@ -4098,6 +4143,22 @@ void ViewAbstract::SetBackShadow(const Shadow& shadow) void ViewAbstract::SetBackShadow(FrameNode* frameNode, const Shadow& shadow) { + if (SystemProperties::ConfigChangePerform()) { + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [shadow, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + if (!frameNode) { + return; + } + Shadow& shadowValue = const_cast(shadow); + shadowValue.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(BackShadow, shadowValue, frameNode); + }; + pattern->AddResObj("shadow", resObj, std::move(updateFunc)); + } ACE_UPDATE_NODE_RENDER_CONTEXT(BackShadow, shadow, frameNode); } @@ -4546,6 +4607,28 @@ void ViewAbstract::SetProgressMask(const RefPtr& progress) if (!ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess()) { return; } + if (SystemProperties::ConfigChangePerform()) { + auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [progress, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + RefPtr& progressValue = const_cast&>(progress); + progressValue->ReloadResources(); + auto target = frameNode->GetRenderContext(); + CHECK_NULL_VOID(target); + if (target->HasClipMask()) { + target->ResetClipMask(); + target->OnClipMaskUpdate(nullptr); + } + target->UpdateProgressMask(progressValue); + target->OnProgressMaskUpdate(progressValue); + }; + pattern->AddResObj("ProgressMask", resObj, std::move(updateFunc)); + } auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); CHECK_NULL_VOID(frameNode); auto target = frameNode->GetRenderContext(); @@ -4675,6 +4758,35 @@ void ViewAbstract::SetColorBlend(FrameNode* frameNode, const Color& colorBlend) ACE_UPDATE_NODE_RENDER_CONTEXT(FrontColorBlend, colorBlend, frameNode); } +void ViewAbstract::SetColorBlend(FrameNode* frameNode, const Color& colorBlend, const RefPtr& resObj) +{ + if (SystemProperties::ConfigChangePerform() && resObj) { + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + auto&& updateFunc = [weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + if (!frameNode) { + return; + } + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + std::string viewAbstractColorBlend = pattern->GetResCacheMapByKey("viewAbstract.colorBlend"); + Color result; + ResourceParseUtils::ParseResColor(resObj, result); + if (viewAbstractColorBlend.empty()) { + pattern->AddResCache("viewAbstract.colorBlend", result.ColorToString()); + } else { + result = Color::ColorFromString(viewAbstractColorBlend); + } + ACE_UPDATE_NODE_RENDER_CONTEXT(FrontColorBlend, result, frameNode); + frameNode->MarkModifyDone(); + frameNode->MarkDirtyNode(); + }; + updateFunc(resObj); + pattern->AddResObj("viewAbstract.colorBlend", resObj, std::move(updateFunc)); + } +} + void ViewAbstract::CreateWithColorBlendResourceObj(const RefPtr& resObj) { auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); @@ -4961,6 +5073,26 @@ void ViewAbstract::SetMask(FrameNode* frameNode, const RefPtr& basic void ViewAbstract::SetProgressMask(FrameNode* frameNode, const RefPtr& progress) { CHECK_NULL_VOID(frameNode); + if (SystemProperties::ConfigChangePerform()) { + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [progress, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + RefPtr& progressValue = const_cast&>(progress); + progressValue->ReloadResources(); + auto target = frameNode->GetRenderContext(); + CHECK_NULL_VOID(target); + if (target->HasClipMask()) { + target->ResetClipMask(); + target->OnClipMaskUpdate(nullptr); + } + target->UpdateProgressMask(progressValue); + target->OnProgressMaskUpdate(progressValue); + }; + pattern->AddResObj("ProgressMask", resObj, std::move(updateFunc)); + } auto target = frameNode->GetRenderContext(); if (target) { if (target->HasClipMask()) { @@ -4971,42 +5103,6 @@ void ViewAbstract::SetProgressMask(FrameNode* frameNode, const RefPtr& progress) -{ - auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); - CHECK_NULL_VOID(frameNode); - auto pattern = frameNode->GetPattern(); - CHECK_NULL_VOID(pattern); - RefPtr resObj = AceType::MakeRefPtr("", "", -1); - auto&& updateFunc = [progress, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { - auto frameNode = weak.Upgrade(); - if (!frameNode) { - return; - } - auto pattern = frameNode->GetPattern(); - CHECK_NULL_VOID(pattern); - std::string colorString = pattern->GetResCacheMapByKey("progressMask.color"); - Color maskColor; - if (colorString.empty()) { - ResourceParseUtils::ParseResColor(progress->GetResObj(), maskColor); - pattern->AddResCache("progressMask.color", maskColor.ColorToString()); - } else { - maskColor = Color::ColorFromString(colorString); - } - progress->SetColor(maskColor); - auto target = frameNode->GetRenderContext(); - if (target) { - if (target->HasClipMask()) { - target->ResetClipMask(); - target->OnClipMaskUpdate(nullptr); - } - target->UpdateProgressMask(progress); - } - }; - updateFunc(resObj); - pattern->AddResObj("progressMask.color", resObj, std::move(updateFunc)); -} - void ViewAbstract::SetUseEffect(bool useEffect, EffectType effectType) { if (!ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess()) { @@ -5334,6 +5430,37 @@ void ViewAbstract::SetOpacity(FrameNode* frameNode, double opacity) ACE_UPDATE_NODE_RENDER_CONTEXT(Opacity, opacity, frameNode); } +void ViewAbstract::SetOpacity(FrameNode* frameNode, double opacity, const RefPtr& resObj) +{ + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + auto&& updateFunc = [weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + if (!frameNode) { + return; + } + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + std::string viewAbstractOpacity = pattern->GetResCacheMapByKey("viewAbstract.opacity"); + double result; + ResourceParseUtils::ParseResDouble(resObj, result); + if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_ELEVEN)) { + result = std::clamp(result, 0.0, 1.0); + } else { + if (result > 1.0 || LessNotEqual(result, 0.0)) { + result = 1.0; + } + } + if (viewAbstractOpacity.empty()) { + pattern->AddResCache("viewAbstract.opacity", std::to_string(result)); + } + ACE_UPDATE_NODE_RENDER_CONTEXT(Opacity, result, frameNode); + }; + pattern->AddResObj("viewAbstract.opacity", resObj, std::move(updateFunc)); + ACE_UPDATE_NODE_RENDER_CONTEXT(Opacity, opacity, frameNode); +} + void ViewAbstract::CreateWithOpacityResourceObj(const RefPtr& resObj) { auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); @@ -5352,12 +5479,12 @@ void ViewAbstract::CreateWithOpacityResourceObj(const RefPtr& re double result; ResourceParseUtils::ParseResDouble(resObj, result); if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_ELEVEN)) { - result = std::clamp(result, 0.0, 1.0); - } else { - if (result > 1.0 || LessNotEqual(result, 0.0)) { - result = 1.0; - } + result = std::clamp(result, 0.0, 1.0); + } else { + if (result > 1.0 || LessNotEqual(result, 0.0)) { + result = 1.0; } + } if (viewAbstractOpacity.empty()) { pattern->AddResCache("viewAbstract.opacity", std::to_string(result)); } else { @@ -5375,18 +5502,77 @@ void ViewAbstract::SetZIndex(FrameNode* frameNode, int32_t value) void ViewAbstract::SetLinearGradient(FrameNode* frameNode, const NG::Gradient& gradient) { + if (SystemProperties::ConfigChangePerform()) { + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [gradient, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + Gradient& gradientValue = const_cast(gradient); + gradientValue.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(LastGradientType, NG::GradientType::LINEAR, frameNode); + ACE_UPDATE_NODE_RENDER_CONTEXT(LinearGradient, gradientValue, frameNode); + }; + pattern->AddResObj("LinearGradient.gradient", resObj, std::move(updateFunc)); + } ACE_UPDATE_NODE_RENDER_CONTEXT(LastGradientType, NG::GradientType::LINEAR, frameNode); ACE_UPDATE_NODE_RENDER_CONTEXT(LinearGradient, gradient, frameNode); } void ViewAbstract::SetSweepGradient(FrameNode* frameNode, const NG::Gradient& gradient) { + if (SystemProperties::ConfigChangePerform()) { + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [gradient, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + Gradient& gradientValue = const_cast(gradient); + auto sweepGradientPtr = gradientValue.GetSweepGradient(); + if (sweepGradientPtr) { + gradientValue.SetSweepGradient(*sweepGradientPtr); + } + gradientValue.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(LastGradientType, NG::GradientType::SWEEP, frameNode); + ACE_UPDATE_NODE_RENDER_CONTEXT(SweepGradient, gradientValue, frameNode); + const auto& target = frameNode->GetRenderContext(); + if (target) { + target->OnSweepGradientUpdate(gradientValue); + } + }; + pattern->AddResObj("SweepGradient.gradient", resObj, std::move(updateFunc)); + } ACE_UPDATE_NODE_RENDER_CONTEXT(LastGradientType, NG::GradientType::SWEEP, frameNode); ACE_UPDATE_NODE_RENDER_CONTEXT(SweepGradient, gradient, frameNode); } void ViewAbstract::SetRadialGradient(FrameNode* frameNode, const NG::Gradient& gradient) { + if (SystemProperties::ConfigChangePerform()) { + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [gradient, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + Gradient& gradientValue = const_cast(gradient); + auto radialGradientPtr = gradientValue.GetRadialGradient(); + if (radialGradientPtr) { + gradientValue.SetRadialGradient(*radialGradientPtr); + } + gradientValue.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(LastGradientType, NG::GradientType::RADIAL, frameNode); + ACE_UPDATE_NODE_RENDER_CONTEXT(RadialGradient, gradientValue, frameNode); + frameNode->MarkModifyDone(); + frameNode->MarkDirtyNode(); + }; + pattern->AddResObj("RadialGradient.gradient", resObj, std::move(updateFunc)); + } ACE_UPDATE_NODE_RENDER_CONTEXT(LastGradientType, NG::GradientType::RADIAL, frameNode); ACE_UPDATE_NODE_RENDER_CONTEXT(RadialGradient, gradient, frameNode); } @@ -5461,9 +5647,10 @@ void ViewAbstract::ReSetMagnifier(FrameNode* frameNode) ACE_RESET_NODE_RENDER_CONTEXT(RenderContext, Magnifier, frameNode); } -void ViewAbstract::SetBackgroundBlurStyle( +void ViewAbstract::UpdateBackgroundBlurStyle( FrameNode* frameNode, const BlurStyleOption& bgBlurStyle, const SysOptions& sysOptions) { + CHECK_NULL_VOID(frameNode); auto pipeline = frameNode->GetContext(); CHECK_NULL_VOID(pipeline); if (bgBlurStyle.policy == BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE) { @@ -5483,8 +5670,62 @@ void ViewAbstract::SetBackgroundBlurStyle( } } +void ViewAbstract::SetBackgroundBlurStyle( + FrameNode* frameNode, const BlurStyleOption& bgBlurStyle, const SysOptions& sysOptions) +{ + CHECK_NULL_VOID(frameNode); + if (SystemProperties::ConfigChangePerform()) { + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [bgBlurStyle, sysOptions, weak = AceType::WeakClaim(frameNode)]( + const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + if (!frameNode) { + return; + } + BlurStyleOption& bgBlurStyleValue = const_cast(bgBlurStyle); + bgBlurStyleValue.ReloadResources(); + auto pipeline = frameNode->GetContext(); + CHECK_NULL_VOID(pipeline); + if (bgBlurStyle.policy == BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE) { + pipeline->AddWindowFocusChangedCallback(frameNode->GetId()); + } else { + pipeline->RemoveWindowFocusChangedCallback(frameNode->GetId()); + } + auto target = frameNode->GetRenderContext(); + CHECK_NULL_VOID(target); + if (target->GetBackgroundEffect().has_value()) { + target->UpdateBackgroundEffect(std::nullopt); + } + target->UpdateBackBlurStyle(bgBlurStyleValue, sysOptions); + if (target->GetBackBlurRadius().has_value()) { + target->UpdateBackBlurRadius(Dimension()); + } + }; + pattern->AddResObj("backgroundBlurStyle.backgroundBlurStyleOptions", resObj, std::move(updateFunc)); + } + UpdateBackgroundBlurStyle(frameNode, bgBlurStyle, sysOptions); +} + void ViewAbstract::SetPixelStretchEffect(FrameNode* frameNode, PixStretchEffectOption& option) { + if (SystemProperties::ConfigChangePerform()) { + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [option, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + if (!frameNode) { + return; + } + PixStretchEffectOption& value = const_cast(option); + value.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(PixelStretchEffect, value, frameNode); + }; + pattern->AddResObj("pixelStretchEffect", resObj, std::move(updateFunc)); + } ACE_UPDATE_NODE_RENDER_CONTEXT(PixelStretchEffect, option, frameNode); } @@ -5539,6 +5780,38 @@ void ViewAbstract::SetForegroundColor(FrameNode* frameNode, const Color& color) renderContext->UpdateForegroundColorFlag(true); } +void ViewAbstract::SetForegroundColor(FrameNode* frameNode, const Color& color, const RefPtr& resObj) +{ + if (SystemProperties::ConfigChangePerform() && resObj) { + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + auto &&updateFunc = [weak = AceType::WeakClaim(frameNode)](const RefPtr &resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + std::string foregroundColorStr = pattern->GetResCacheMapByKey("foregroundColor"); + Color foregroundColor; + if (foregroundColorStr.empty()) { + ResourceParseUtils::ParseResColor(resObj, foregroundColor); + pattern->AddResCache("foregroundColor", foregroundColor.ColorToString()); + } else { + Color::ParseColorString(foregroundColorStr, foregroundColor); + } + SetForegroundColor(AceType::RawPtr(frameNode), foregroundColor); + auto target = frameNode->GetRenderContext(); + if (target) { + target->OnForegroundColorUpdate(foregroundColor); + } + frameNode->MarkModifyDone(); + frameNode->MarkDirtyNode(); + }; + updateFunc(resObj); + pattern->AddResObj("foregroundColor", resObj, std::move(updateFunc)); + } + SetForegroundColor(frameNode, color); +} + void ViewAbstract::SetForegroundColorStrategy(FrameNode* frameNode, const ForegroundColorStrategy& strategy) { ACE_UPDATE_NODE_RENDER_CONTEXT(ForegroundColorStrategy, strategy, frameNode); @@ -5559,6 +5832,21 @@ void ViewAbstract::SetLightPosition(FrameNode* frameNode, const NG::TranslateOpt { CHECK_NULL_VOID(frameNode); ACE_UPDATE_NODE_RENDER_CONTEXT(LightPosition, options, frameNode); + if (SystemProperties::ConfigChangePerform()) { + auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [options, weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + NG::TranslateOptions& optionsValue = const_cast(options); + optionsValue.ReloadResources(); + ACE_UPDATE_NODE_RENDER_CONTEXT(LightPosition, optionsValue, frameNode); + }; + pattern->AddResObj("pointLight.LightSource", resObj, std::move(updateFunc)); + } } void ViewAbstract::SetLightPosition(const NG::TranslateOptions& options) @@ -5645,6 +5933,30 @@ void ViewAbstract::SetLightColor(FrameNode* frameNode, const Color& value) ACE_UPDATE_NODE_RENDER_CONTEXT(LightColor, value, frameNode); } +void ViewAbstract::SetLightColor(FrameNode* frameNode, const Color& value, const RefPtr& resObj) +{ + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + auto &&updateFunc = [weak = AceType::WeakClaim(frameNode)](const RefPtr &resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + std::string colorStr = pattern->GetResCacheMapByKey("LightColorRes"); + Color lightColor; + if (colorStr.empty()) { + ResourceParseUtils::ParseResColor(resObj, lightColor); + pattern->AddResCache("LightColorRes", lightColor.ColorToString()); + } else { + Color::ParseColorString(colorStr, lightColor); + } + ACE_UPDATE_NODE_RENDER_CONTEXT(LightColor, lightColor, frameNode); + }; + updateFunc(resObj); + pattern->AddResObj("LightColorRes", resObj, std::move(updateFunc)); +} + void ViewAbstract::SetLightIlluminated(FrameNode* frameNode, const uint32_t value) { CHECK_NULL_VOID(frameNode); @@ -6032,7 +6344,7 @@ void ViewAbstract::SetMotionBlur(FrameNode* frameNode, const MotionBlurOption &m ACE_UPDATE_NODE_RENDER_CONTEXT(MotionBlur, motionBlurOption, frameNode); } -void ViewAbstract::SetBackgroundEffect( +void ViewAbstract::UpdateBackgroundEffect( FrameNode* frameNode, const EffectOption& effectOption, const SysOptions& sysOptions) { CHECK_NULL_VOID(frameNode); @@ -6055,6 +6367,27 @@ void ViewAbstract::SetBackgroundEffect( } } +void ViewAbstract::SetBackgroundEffect( + FrameNode* frameNode, const EffectOption& effectOption, const SysOptions& sysOptions) +{ + CHECK_NULL_VOID(frameNode); + if (SystemProperties::ConfigChangePerform()) { + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [effectOption, sysOptions, weak = AceType::WeakClaim(frameNode)]( + const RefPtr& resObj) { + auto frameNode = weak.Upgrade(); + CHECK_NULL_VOID(frameNode); + EffectOption& effectOptionValue = const_cast(effectOption); + effectOptionValue.ReloadResources(); + UpdateBackgroundEffect(AceType::RawPtr(frameNode), effectOptionValue, sysOptions); + }; + pattern->AddResObj("backgroundEffect", resObj, std::move(updateFunc)); + } + UpdateBackgroundEffect(frameNode, effectOption, sysOptions); +} + void ViewAbstract::SetDynamicLightUp(FrameNode* frameNode, float rate, float lightUpDegree) { ACE_UPDATE_NODE_RENDER_CONTEXT(DynamicLightUpRate, rate, frameNode); diff --git a/frameworks/core/components_ng/base/view_abstract.h b/frameworks/core/components_ng/base/view_abstract.h index 82f1c778485..b5753d82218 100644 --- a/frameworks/core/components_ng/base/view_abstract.h +++ b/frameworks/core/components_ng/base/view_abstract.h @@ -164,6 +164,7 @@ typedef Rosen::VisualEffect* (*OEMVisualEffectFunc)(const Rosen::VisualEffect* e class ACE_FORCE_EXPORT ViewAbstract { public: + static void RemoveResObj(const std::string& key); static void SetWidth(const CalcLength &width); static void SetWidth(const RefPtr& resObj); static void SetHeight(const CalcLength &height); @@ -608,6 +609,7 @@ public: const CalcDimension& positionX, const CalcDimension& positionY, const CalcDimension& positionZ); static void SetLightIntensity(FrameNode* frameNode, float value); static void SetLightColor(FrameNode* frameNode, const Color& value); + static void SetLightColor(FrameNode* frameNode, const Color& value, const RefPtr& resObj); static void SetLightIlluminated(FrameNode* frameNode, uint32_t value); static void SetIlluminatedBorderWidth(FrameNode* frameNode, const Dimension& value); static void SetBloom(FrameNode* frameNode, float value); @@ -645,6 +647,11 @@ public: static void SetTransform3DMatrix(FrameNode* frameNode, const Matrix4& matrix); static void SetHitTestMode(FrameNode* frameNode, HitTestMode hitTestMode); static void SetOpacity(FrameNode* frameNode, double opacity); + static void SetOpacity(FrameNode* frameNode, double opacity, const RefPtr& resObj); + static void UpdateBackgroundBlurStyle( + FrameNode* frameNode, const BlurStyleOption& bgBlurStyle, const SysOptions& sysOptions); + static void UpdateBackgroundEffect( + FrameNode* frameNode, const EffectOption& effectOption, const SysOptions& sysOptions); static void SetZIndex(FrameNode* frameNode, int32_t value); static void SetAlign(FrameNode* frameNode, Alignment alignment); static void SetBackdropBlur(FrameNode* frameNode, const Dimension& radius, const BlurOption& blurOption, @@ -654,6 +661,7 @@ public: static void SetSepia(FrameNode* frameNode, const Dimension& sepia); static void SetSaturate(FrameNode* frameNode, const Dimension& saturate); static void SetColorBlend(FrameNode* frameNode, const Color& colorBlend); + static void SetColorBlend(FrameNode* frameNode, const Color& colorBlend, const RefPtr& resObj); static void SetGrayScale(FrameNode* frameNode, const Dimension& grayScale); static void SetContrast(FrameNode* frameNode, const Dimension& contrast); static void SetBrightness(FrameNode* frameNode, const Dimension& brightness); @@ -702,6 +710,7 @@ public: static void SetRenderFit(FrameNode* frameNode, RenderFit renderFit); static void SetUseEffect(FrameNode* frameNode, bool useEffect, EffectType effectType); static void SetForegroundColor(FrameNode* frameNode, const Color& color); + static void SetForegroundColor(FrameNode* frameNode, const Color& color, const RefPtr& resObj); static void SetForegroundColorStrategy(FrameNode* frameNode, const ForegroundColorStrategy& strategy); static void SetMotionPath(FrameNode* frameNode, const MotionPathOption& motionPath); static void SetFocusOnTouch(FrameNode* frameNode, bool isSet); @@ -769,7 +778,6 @@ public: NG::TransitionFinishCallback&& finishCallback = nullptr); static void SetMask(FrameNode* frameNode, const RefPtr& basicShape); static void SetProgressMask(FrameNode* frameNode, const RefPtr& progress); - static void CreateWithMaskResourceObj(const RefPtr& progress); static void SetEnabled(FrameNode* frameNode, bool enabled); static void SetUseShadowBatching(FrameNode* frameNode, bool useShadowBatching); static void SetBlendMode(FrameNode* frameNode, BlendMode blendMode); diff --git a/frameworks/core/components_ng/base/view_abstract_model.h b/frameworks/core/components_ng/base/view_abstract_model.h index ee6fa2bc999..d47cc20c523 100644 --- a/frameworks/core/components_ng/base/view_abstract_model.h +++ b/frameworks/core/components_ng/base/view_abstract_model.h @@ -481,7 +481,6 @@ public: // progress mask virtual void SetProgressMask(const RefPtr& progress) = 0; - virtual void CreateWithMaskResourceObj(const RefPtr& progress) {}; // foregroundColor virtual void SetForegroundColor(const Color& color) = 0; virtual void SetForegroundColorStrategy(const ForegroundColorStrategy& strategy) = 0; @@ -520,6 +519,7 @@ public: const RefPtr& frameNode, const RefPtr& resourceObj, PopupType type) = 0; virtual void CreateWithResourceObj( const RefPtr& frameNode, const RefPtr& resourceObj) = 0; + virtual void RemoveResObj(const std::string& key) {}; }; } // namespace OHOS::Ace #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_BASE_VIEW_ABSTRACT_MODEL_H diff --git a/frameworks/core/components_ng/base/view_abstract_model_ng.h b/frameworks/core/components_ng/base/view_abstract_model_ng.h index 14be79ac3ac..65b6432a133 100644 --- a/frameworks/core/components_ng/base/view_abstract_model_ng.h +++ b/frameworks/core/components_ng/base/view_abstract_model_ng.h @@ -958,11 +958,6 @@ public: ViewAbstract::SetProgressMask(progress); } - void CreateWithMaskResourceObj(const RefPtr& progress) override - { - ViewAbstract::CreateWithMaskResourceObj(progress); - } - void SetBackdropBlur(const Dimension& radius, const BlurOption& blurOption, const SysOptions& sysOptions) override { ViewAbstract::SetBackdropBlur(radius, blurOption, sysOptions); @@ -1607,6 +1602,10 @@ public: const RefPtr& frameNode, const RefPtr& resourceObj, PopupType type) override; virtual void CreateWithResourceObj( const RefPtr& frameNode, const RefPtr& resourceObj) override; + void RemoveResObj(const std::string& key) override + { + ViewAbstract::RemoveResObj(key); + } void SetForegroundColor(const Color& color) override { ViewAbstract::SetForegroundColor(color); diff --git a/frameworks/core/components_ng/property/progress_mask_property.h b/frameworks/core/components_ng/property/progress_mask_property.h index d1724e3465a..e84bf8e42bd 100644 --- a/frameworks/core/components_ng/property/progress_mask_property.h +++ b/frameworks/core/components_ng/property/progress_mask_property.h @@ -30,6 +30,12 @@ public: ProgressMaskProperty() = default; ~ProgressMaskProperty() override = default; + struct resourceUpdater { + RefPtr resObj; + std::function&, ProgressMaskProperty&)> updateFunc; + }; + std::unordered_map resMap_; + float GetValue() const { return value_; @@ -45,11 +51,6 @@ public: return color_; } - RefPtr GetResObj() - { - return resObj_; - } - bool GetEnableBreathe() const { return enableBreathe_; @@ -75,10 +76,6 @@ public: enableBreathe_ = enableBreathe; } - void SetResObj(const RefPtr resObj) - { - resObj_ = resObj; - } bool operator==(const ProgressMaskProperty& other) const { return (value_ == other.GetValue() && @@ -96,12 +93,29 @@ public: return *this; } + void AddResource( + const std::string& key, + const RefPtr& resObj, + std::function&, ProgressMaskProperty&)>&& updateFunc) + { + if (resObj == nullptr || !updateFunc) { + return; + } + resMap_[key] = {resObj, std::move(updateFunc)}; + } + + void ReloadResources() + { + for (const auto& [key, resourceUpdater] : resMap_) { + resourceUpdater.updateFunc(resourceUpdater.resObj, *this); + } + } + private: float value_ = 0.0f; float maxValue_ = 100.0f; Color color_ = Color(0x99182431); bool enableBreathe_ = false; - RefPtr resObj_; }; } // namespace OHOS::Ace::NG { #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PROPERTIES_PROGRESS_MASK_PROPERTY_H diff --git a/frameworks/core/components_ng/render/adapter/rosen_render_context.cpp b/frameworks/core/components_ng/render/adapter/rosen_render_context.cpp index 8c5ec7a2e6d..1dba7583839 100644 --- a/frameworks/core/components_ng/render/adapter/rosen_render_context.cpp +++ b/frameworks/core/components_ng/render/adapter/rosen_render_context.cpp @@ -1170,6 +1170,40 @@ void RosenRenderContext::UpdateBackgroundEffect( } } +void RosenRenderContext::UpdateForeBlurStyleForColorMode( + const std::optional& fgBlurStyle, const SysOptions& sysOptions) +{ + auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [weak = AceType::WeakClaim(this), fgBlurStyle, sysOptions]( + const RefPtr& resObj) { + auto render = weak.Upgrade(); + CHECK_NULL_VOID(render); + CHECK_NULL_VOID(render->rsNode_); + const auto& groupProperty = render->GetOrCreateForeground(); + if (groupProperty->CheckBlurStyleOption(fgBlurStyle) && groupProperty->CheckSysOptionsForBlurSame(sysOptions)) { + // Same with previous value. + // If colorMode is following system and has valid blurStyle, still needs updating + if (fgBlurStyle->colorMode != ThemeColorMode::SYSTEM) { + return; + } + if (fgBlurStyle->blurOption.grayscale.size() > 1) { + Rosen::Vector2f grayScale(fgBlurStyle->blurOption.grayscale[0], fgBlurStyle->blurOption.grayscale[1]); + render->rsNode_->SetGreyCoef(grayScale); + } + } else { + groupProperty->propBlurStyleOption = fgBlurStyle; + groupProperty->propSysOptionsForBlur = sysOptions; + } + render->SetFrontBlurFilter(); + }; + updateFunc(resObj); + pattern->AddResObj("foregroundBlurStyle.blurStyle", resObj, std::move(updateFunc)); +} + void RosenRenderContext::UpdateFrontBlurStyle( const std::optional& fgBlurStyle, const SysOptions& sysOptions) { @@ -1189,6 +1223,7 @@ void RosenRenderContext::UpdateFrontBlurStyle( groupProperty->propBlurStyleOption = fgBlurStyle; groupProperty->propSysOptionsForBlur = sysOptions; } + UpdateForeBlurStyleForColorMode(fgBlurStyle, sysOptions); SetFrontBlurFilter(); } diff --git a/frameworks/core/components_ng/render/adapter/rosen_render_context.h b/frameworks/core/components_ng/render/adapter/rosen_render_context.h index 82ce595c22b..ddfc27b738c 100755 --- a/frameworks/core/components_ng/render/adapter/rosen_render_context.h +++ b/frameworks/core/components_ng/render/adapter/rosen_render_context.h @@ -652,6 +652,8 @@ protected: void PaintBorderImageGradient(); void PaintMouseSelectRect(const RectF& rect, const Color& fillColor, const Color& strokeColor); void UpdateBlurStyleForColorMode(const std::optional& bgBlurStyle, const SysOptions& sysOptions); + void UpdateForeBlurStyleForColorMode(const std::optional& fgBlurStyle, + const SysOptions& sysOptions); void SetBackBlurFilter(); void SetFrontBlurFilter(); bool UpdateBlurBackgroundColor(const std::optional& bgBlurStyle); diff --git a/frameworks/core/interfaces/arkoala/arkoala_api.h b/frameworks/core/interfaces/arkoala/arkoala_api.h index f55527014db..b016417e415 100644 --- a/frameworks/core/interfaces/arkoala/arkoala_api.h +++ b/frameworks/core/interfaces/arkoala/arkoala_api.h @@ -2000,13 +2000,14 @@ struct ArkUICommonModifier { void (*resetPositionEdges)(ArkUINodeHandle node); void (*setBorderStyle)(ArkUINodeHandle node, const ArkUI_Int32* styles, ArkUI_Int32 length); void (*resetBorderStyle)(ArkUINodeHandle node); - void (*setBackShadow)(ArkUINodeHandle node, const ArkUIInt32orFloat32* shadows, ArkUI_Int32 length); + void (*setBackShadow)(ArkUINodeHandle node, const ArkUIInt32orFloat32* shadows, ArkUI_Int32 length, + void* resRawPtr); void (*resetBackShadow)(ArkUINodeHandle node); void (*setHitTestBehavior)(ArkUINodeHandle node, ArkUI_Uint32 value); void (*resetHitTestBehavior)(ArkUINodeHandle node); void (*setZIndex)(ArkUINodeHandle node, ArkUI_Int32 value); void (*resetZIndex)(ArkUINodeHandle node); - void (*setOpacity)(ArkUINodeHandle node, ArkUI_Float32 opacity); + void (*setOpacity)(ArkUINodeHandle node, ArkUI_Float32 opacity, void* opacityRawPtr); void (*resetOpacity)(ArkUINodeHandle node); void (*setAlign)(ArkUINodeHandle node, ArkUI_Int32 align); void (*resetAlign)(ArkUINodeHandle node); @@ -2021,7 +2022,7 @@ struct ArkUICommonModifier { void (*resetSepia)(ArkUINodeHandle node); void (*setSaturate)(ArkUINodeHandle node, ArkUI_Float32 saturate); void (*resetSaturate)(ArkUINodeHandle node); - void (*setColorBlend)(ArkUINodeHandle node, ArkUI_Uint32 color); + void (*setColorBlend)(ArkUINodeHandle node, ArkUI_Uint32 color, void* colorBlendRawPtr); void (*resetColorBlend)(ArkUINodeHandle node); void (*setGrayscale)(ArkUINodeHandle node, ArkUI_Float64 grayScale); void (*resetGrayscale)(ArkUINodeHandle node); @@ -2033,13 +2034,13 @@ struct ArkUICommonModifier { ArkUI_Int32 blurValuesSize, ArkUI_Bool disableSystemAdaptation); void (*resetBlur)(ArkUINodeHandle node); void (*setLinearGradient)(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength); + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* colorRawPtr); void (*resetLinearGradient)(ArkUINodeHandle node); void (*setSweepGradient)(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength); + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* resRawPtr); void (*resetSweepGradient)(ArkUINodeHandle node); void (*setRadialGradient)(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength); + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* resRawPtr); void (*resetRadialGradient)(ArkUINodeHandle node); void (*setOverlay)( ArkUINodeHandle node, ArkUI_CharPtr text, const ArkUI_Float32* options, ArkUI_Int32 optionsLength); @@ -2057,7 +2058,7 @@ struct ArkUICommonModifier { void (*resetLinearGradientBlur)(ArkUINodeHandle node); void (*setBackgroundBlurStyle)(ArkUINodeHandle node, ArkUI_Int32 (*intArray)[5], ArkUI_Float32 scale, const ArkUI_Float32* blurValues, ArkUI_Int32 blurValuesSize, ArkUI_Bool isValidColor, - ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation); + ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation, void* inactiveColorRawPtr); void (*resetBackgroundBlurStyle)(ArkUINodeHandle node); void (*setBorder)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize, const ArkUI_Uint32* colorAndStyle, ArkUI_Int32 colorAndStyleSize, ArkUI_Bool isLocalizedBorderWidth, @@ -2092,7 +2093,7 @@ struct ArkUICommonModifier { ArkUIBindTipsOptionsArrow arrowOptions); void (*resetBindTips)(ArkUINodeHandle node); void (*setPixelStretchEffect)( - ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length); + ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length, void* rawPtr); void (*resetPixelStretchEffect)(ArkUINodeHandle node); void (*setLightUpEffect)(ArkUINodeHandle node, ArkUI_Float32 radio); void (*resetLightUpEffect)(ArkUINodeHandle node); @@ -2104,7 +2105,7 @@ struct ArkUICommonModifier { void (*resetRenderFit)(ArkUINodeHandle node); void (*setUseEffect)(ArkUINodeHandle node, ArkUI_Bool useEffect, ArkUI_Int32 effectType); void (*resetUseEffect)(ArkUINodeHandle node); - void (*setForegroundColor)(ArkUINodeHandle node, ArkUI_Bool isColor, ArkUI_Uint32 color); + void (*setForegroundColor)(ArkUINodeHandle node, ArkUI_Bool isColor, ArkUI_Uint32 color, void* fgColorRawPtr); void (*resetForegroundColor)(ArkUINodeHandle node); void (*setMotionPath)( ArkUINodeHandle node, ArkUI_CharPtr path, ArkUI_Float32 from, ArkUI_Float32 to, ArkUI_Bool rotatable); @@ -2204,7 +2205,8 @@ struct ArkUICommonModifier { void (*setBackgroundEffect)(ArkUINodeHandle node, ArkUI_Float32 radius, ArkUI_Float32 saturation, ArkUI_Float32 brightness, ArkUI_Uint32 color, ArkUI_Int32 adaptiveColor, const ArkUI_Float32* blurValues, ArkUI_Int32 blurValuesSize, ArkUI_Int32 policy, ArkUI_Int32 blurType, ArkUI_Bool isValidColor, - ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation); + ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation, void* colorRawPtr, + void* inactiveColorRawPtr); void (*resetBackgroundEffect)(ArkUINodeHandle node); void (*setBackgroundBrightness)(ArkUINodeHandle node, ArkUI_Float32 rate, ArkUI_Float32 lightUpDegree); void (*resetBackgroundBrightness)(ArkUINodeHandle node); @@ -2250,11 +2252,11 @@ struct ArkUICommonModifier { ArkUINodeHandle node, ArkUI_CharPtr value, const ArkUI_Int32* keysIntArray, ArkUI_Int32 length); void (*resetKeyBoardShortCut)(ArkUINodeHandle node); void (*setPointLightPosition)(ArkUINodeHandle node, const struct ArkUISizeType* positionX, - const struct ArkUISizeType* positionY, const struct ArkUISizeType* positionZ); + const struct ArkUISizeType* positionY, const struct ArkUISizeType* positionZ, void* resRawPtr); void (*resetPointLightPosition)(ArkUINodeHandle node); void (*setPointLightIntensity)(ArkUINodeHandle node, ArkUI_Float32 intensity); void (*resetPointLightIntensity)(ArkUINodeHandle node); - void (*setPointLightColor)(ArkUINodeHandle node, ArkUI_Uint32 color); + void (*setPointLightColor)(ArkUINodeHandle node, ArkUI_Uint32 color, void* colorRawPtr); void (*resetPointLightColor)(ArkUINodeHandle node); void (*setPointLightIlluminated)( ArkUINodeHandle node, ArkUI_Uint32 illuminated, const struct ArkUISizeType* illuminatedBorderWidth); @@ -2289,16 +2291,16 @@ struct ArkUICommonModifier { void (*resetMonopolizeEvents)(ArkUINodeHandle node); void (*setConstraintSize)(ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units); void (*resetConstraintSize)(ArkUINodeHandle node); - void (*setOutlineColor)(ArkUINodeHandle node, const ArkUI_Uint32* values, ArkUI_Int32 valuesSize); + void (*setOutlineColor)(ArkUINodeHandle node, const ArkUI_Uint32* values, ArkUI_Int32 valuesSize, void* rawPtr); void (*resetOutlineColor)(ArkUINodeHandle node); - void (*setOutlineRadius)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize); + void (*setOutlineRadius)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize, void* rawPtr); void (*resetOutlineRadius)(ArkUINodeHandle node); - void (*setOutlineWidth)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize); + void (*setOutlineWidth)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize, void* rawPtr); void (*resetOutlineWidth)(ArkUINodeHandle node); void (*setOutlineStyle)(ArkUINodeHandle node, const ArkUI_Uint32* values, ArkUI_Int32 valuesSize); void (*resetOutlineStyle)(ArkUINodeHandle node); void (*setOutline)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize, - const ArkUI_Uint32* colorAndStyle, ArkUI_Int32 colorAndStyleSize); + const ArkUI_Uint32* colorAndStyle, ArkUI_Int32 colorAndStyleSize, void* resRawPtr); void (*resetOutline)(ArkUINodeHandle node); void (*setBindPopup)(ArkUINodeHandle node, ArkUIPopupParam* param, ArkUINodeHandle customNode); void (*resetBindPopup)(ArkUINodeHandle node); diff --git a/frameworks/core/interfaces/cjui/cjui_api.h b/frameworks/core/interfaces/cjui/cjui_api.h index dd10f3a6c5b..adec505d6c0 100644 --- a/frameworks/core/interfaces/cjui/cjui_api.h +++ b/frameworks/core/interfaces/cjui/cjui_api.h @@ -49,13 +49,14 @@ struct CJUICommonModifier { void (*resetPositionEdges)(ArkUINodeHandle node); void (*setBorderStyle)(ArkUINodeHandle node, const ArkUI_Int32* styles, ArkUI_Int32 length); void (*resetBorderStyle)(ArkUINodeHandle node); - void (*setBackShadow)(ArkUINodeHandle node, const ArkUIInt32orFloat32* shadows, ArkUI_Int32 length); + void (*setBackShadow)(ArkUINodeHandle node, const ArkUIInt32orFloat32* shadows, ArkUI_Int32 length, + void* resRawPtr); void (*resetBackShadow)(ArkUINodeHandle node); void (*setHitTestBehavior)(ArkUINodeHandle node, ArkUI_Uint32 value); void (*resetHitTestBehavior)(ArkUINodeHandle node); void (*setZIndex)(ArkUINodeHandle node, ArkUI_Int32 value); void (*resetZIndex)(ArkUINodeHandle node); - void (*setOpacity)(ArkUINodeHandle node, ArkUI_Float32 opacity); + void (*setOpacity)(ArkUINodeHandle node, ArkUI_Float32 opacity, void* opacityRawPtr); void (*resetOpacity)(ArkUINodeHandle node); void (*setAlign)(ArkUINodeHandle node, ArkUI_Int32 align); void (*resetAlign)(ArkUINodeHandle node); @@ -70,7 +71,7 @@ struct CJUICommonModifier { void (*resetSepia)(ArkUINodeHandle node); void (*setSaturate)(ArkUINodeHandle node, ArkUI_Float32 saturate); void (*resetSaturate)(ArkUINodeHandle node); - void (*setColorBlend)(ArkUINodeHandle node, ArkUI_Uint32 color); + void (*setColorBlend)(ArkUINodeHandle node, ArkUI_Uint32 color, void* colorBlendRawPtr); void (*resetColorBlend)(ArkUINodeHandle node); void (*setGrayscale)(ArkUINodeHandle node, ArkUI_Float64 grayScale); void (*resetGrayscale)(ArkUINodeHandle node); @@ -82,13 +83,13 @@ struct CJUICommonModifier { ArkUI_Int32 blurValuesSize, ArkUI_Bool disableSystemAdaptation); void (*resetBlur)(ArkUINodeHandle node); void (*setLinearGradient)(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength); + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* colorRawPtr); void (*resetLinearGradient)(ArkUINodeHandle node); void (*setSweepGradient)(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength); + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* resRawPtr); void (*resetSweepGradient)(ArkUINodeHandle node); void (*setRadialGradient)(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength); + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* resRawPtr); void (*resetRadialGradient)(ArkUINodeHandle node); void (*setOverlay)( ArkUINodeHandle node, ArkUI_CharPtr text, const ArkUI_Float32* options, ArkUI_Int32 optionsLength); @@ -106,7 +107,7 @@ struct CJUICommonModifier { void (*resetLinearGradientBlur)(ArkUINodeHandle node); void (*setBackgroundBlurStyle)(ArkUINodeHandle node, ArkUI_Int32 (*intArray)[5], ArkUI_Float32 scale, const ArkUI_Float32* blurValues, ArkUI_Int32 blurValuesSize, ArkUI_Bool isValidColor, - ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation); + ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation, void* inactiveColorRawPtr); void (*resetBackgroundBlurStyle)(ArkUINodeHandle node); void (*setBorder)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize, const ArkUI_Uint32* colorAndStyle, ArkUI_Int32 colorAndStyleSize, ArkUI_Bool isLocalizedBorderWidth, @@ -136,7 +137,7 @@ struct CJUICommonModifier { ArkUINodeHandle node, ArkUI_CharPtr id, const ArkUIGeometryTransitionOptions* options); void (*resetGeometryTransition)(ArkUINodeHandle node); void (*setPixelStretchEffect)( - ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length); + ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length, void* rawPtr); void (*resetPixelStretchEffect)(ArkUINodeHandle node); void (*setLightUpEffect)(ArkUINodeHandle node, ArkUI_Float32 radio); void (*resetLightUpEffect)(ArkUINodeHandle node); @@ -148,7 +149,7 @@ struct CJUICommonModifier { void (*resetRenderFit)(ArkUINodeHandle node); void (*setUseEffect)(ArkUINodeHandle node, ArkUI_Bool useEffect, ArkUI_Int32 effectType); void (*resetUseEffect)(ArkUINodeHandle node); - void (*setForegroundColor)(ArkUINodeHandle node, ArkUI_Bool isColor, ArkUI_Uint32 color); + void (*setForegroundColor)(ArkUINodeHandle node, ArkUI_Bool isColor, ArkUI_Uint32 color, void* fgColorRawPtr); void (*resetForegroundColor)(ArkUINodeHandle node); void (*setMotionPath)( ArkUINodeHandle node, ArkUI_CharPtr path, ArkUI_Float32 from, ArkUI_Float32 to, ArkUI_Bool rotatable); @@ -243,7 +244,8 @@ struct CJUICommonModifier { void (*setBackgroundEffect)(ArkUINodeHandle node, ArkUI_Float32 radius, ArkUI_Float32 saturation, ArkUI_Float32 brightness, ArkUI_Uint32 color, ArkUI_Int32 adaptiveColor, const ArkUI_Float32* blurValues, ArkUI_Int32 blurValuesSize, ArkUI_Int32 policy, ArkUI_Int32 blurType, ArkUI_Bool isValidColor, - ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation); + ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation, void* colorRawPtr, + void* inactiveColorRawPtr); void (*resetBackgroundEffect)(ArkUINodeHandle node); void (*setBackgroundBrightness)(ArkUINodeHandle node, ArkUI_Float32 rate, ArkUI_Float32 lightUpDegree); void (*resetBackgroundBrightness)(ArkUINodeHandle node); @@ -279,11 +281,11 @@ struct CJUICommonModifier { ArkUINodeHandle node, ArkUI_CharPtr value, const ArkUI_Int32* keysIntArray, ArkUI_Int32 length); void (*resetKeyBoardShortCut)(ArkUINodeHandle node); void (*setPointLightPosition)(ArkUINodeHandle node, const struct ArkUISizeType* positionX, - const struct ArkUISizeType* positionY, const struct ArkUISizeType* positionZ); + const struct ArkUISizeType* positionY, const struct ArkUISizeType* positionZ, void* resRawPtr); void (*resetPointLightPosition)(ArkUINodeHandle node); void (*setPointLightIntensity)(ArkUINodeHandle node, ArkUI_Float32 intensity); void (*resetPointLightIntensity)(ArkUINodeHandle node); - void (*setPointLightColor)(ArkUINodeHandle node, ArkUI_Uint32 color); + void (*setPointLightColor)(ArkUINodeHandle node, ArkUI_Uint32 color, void* colorRawPtr); void (*resetPointLightColor)(ArkUINodeHandle node); void (*setPointLightIlluminated)( ArkUINodeHandle node, ArkUI_Uint32 illuminated, const struct ArkUISizeType* illuminatedBorderWidth); @@ -318,16 +320,16 @@ struct CJUICommonModifier { void (*resetMonopolizeEvents)(ArkUINodeHandle node); void (*setConstraintSize)(ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units); void (*resetConstraintSize)(ArkUINodeHandle node); - void (*setOutlineColor)(ArkUINodeHandle node, const ArkUI_Uint32* values, ArkUI_Int32 valuesSize); + void (*setOutlineColor)(ArkUINodeHandle node, const ArkUI_Uint32* values, ArkUI_Int32 valuesSize, void* rawPtr); void (*resetOutlineColor)(ArkUINodeHandle node); - void (*setOutlineRadius)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize); + void (*setOutlineRadius)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize, void* rawPtr); void (*resetOutlineRadius)(ArkUINodeHandle node); - void (*setOutlineWidth)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize); + void (*setOutlineWidth)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize, void* rawPtr); void (*resetOutlineWidth)(ArkUINodeHandle node); void (*setOutlineStyle)(ArkUINodeHandle node, const ArkUI_Uint32* values, ArkUI_Int32 valuesSize); void (*resetOutlineStyle)(ArkUINodeHandle node); void (*setOutline)(ArkUINodeHandle node, const ArkUI_Float32* values, ArkUI_Int32 valuesSize, - const ArkUI_Uint32* colorAndStyle, ArkUI_Int32 colorAndStyleSize); + const ArkUI_Uint32* colorAndStyle, ArkUI_Int32 colorAndStyleSize, void* resRawPtr); void (*resetOutline)(ArkUINodeHandle node); void (*setBindPopup)(ArkUINodeHandle node, ArkUIPopupParam* param, ArkUINodeHandle customNode); void (*resetBindPopup)(ArkUINodeHandle node); diff --git a/frameworks/core/interfaces/native/node/node_common_modifier.cpp b/frameworks/core/interfaces/native/node/node_common_modifier.cpp index 1a7e2791509..9b9697b8442 100644 --- a/frameworks/core/interfaces/native/node/node_common_modifier.cpp +++ b/frameworks/core/interfaces/native/node/node_common_modifier.cpp @@ -150,6 +150,8 @@ const std::vector DIRECTION_LIST = { constexpr int32_t DEFAULT_DURATION = 1000; std::string g_strValue; +static std::map gradientColorMap; + BorderStyle ConvertBorderStyle(int32_t value) { auto style = static_cast(value); @@ -260,6 +262,54 @@ int32_t ParseAlignmentToIndex(Alignment align) return ERROR_INT_CODE; } +void CheckGradientColorMapAddFront(NG::Gradient& gradient, const int32_t index) +{ + if (gradient.GetColors().size() < static_cast(index)) { + for (int32_t indx = gradient.GetColors().size(); indx < index; indx++) { + auto it = gradientColorMap.find(indx); + if (it != gradientColorMap.end()) { + NG::GradientColor gradientColor = it->second; + gradient.AddColor(gradientColor); + } + } + } +} + +void CheckGradientColorMapAddBack(NG::Gradient& gradient, const size_t colorsLth) +{ + if (gradient.GetColors().size() < colorsLth) { + for (int32_t indx = gradient.GetColors().size(); indx < colorsLth; indx++) { + auto it = gradientColorMap.find(indx); + if (it != gradientColorMap.end()) { + NG::GradientColor gradientColor = it->second; + gradient.AddColor(gradientColor); + } else { + break; + } + } + } +} + +void CheckGradientColorsResObj(NG::Gradient& gradient, const NG::GradientColor& gradientColor, + const size_t colorsLth, const RefPtr colorResObj, const int32_t index) +{ + auto&& updateFunc = [gradientColor, colorsLth, index](const RefPtr& resObj, + NG::Gradient& gradient) { + if (gradient.GetColors().size() >= static_cast(colorsLth)) { + gradient.ClearColors(); + } + CheckGradientColorMapAddFront(gradient, index); + Color color; + ResourceParseUtils::ParseResColor(resObj, color); + NG::GradientColor& gradientColorValue = const_cast(gradientColor); + gradientColorValue.SetColor(color); + gradient.AddColor(gradientColorValue); + CheckGradientColorMapAddBack(gradient, colorsLth); + }; + std::string key = "LinearGradient.gradient.color" + std::to_string(index); + gradient.AddResource(key, colorResObj, std::move(updateFunc)); +} + /** * @param colors color value * colors[0], colors[1], colors[2] : color[0](color, hasDimension, dimension) @@ -267,11 +317,14 @@ int32_t ParseAlignmentToIndex(Alignment align) * ... * @param colorsLength colors length */ -void SetGradientColors(NG::Gradient& gradient, const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength) +void SetGradientColors(NG::Gradient& gradient, const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, + void* colorRawPtr, int startPos = NUM_0) { if ((colors == nullptr) || (colorsLength % NUM_3) != 0) { return; } + auto objs = *(reinterpret_cast>*>(colorRawPtr)); + auto colorsLth = colorsLength / NUM_3; for (int32_t index = 0; index < colorsLength; index += NUM_3) { auto colorValue = colors[index].u32; auto colorHasDimension = colors[index + NUM_1].i32; @@ -285,6 +338,12 @@ void SetGradientColors(NG::Gradient& gradient, const ArkUIInt32orFloat32* colors if (hasDimension) { gradientColor.SetDimension(CalcDimension(dimension * PERCENT_100, DimensionUnit::PERCENT)); } + auto idx = index / NUM_3 + startPos; + if (SystemProperties::ConfigChangePerform() && colorRawPtr != nullptr && objs[idx] != nullptr) { + CheckGradientColorsResObj(gradient, gradientColor, colorsLth, objs[idx], index / NUM_3); + } else if (SystemProperties::ConfigChangePerform() && colorRawPtr != nullptr && objs[idx] == nullptr) { + gradientColorMap[index / NUM_3] = gradientColor; + } gradient.AddColor(gradientColor); } } @@ -395,6 +454,81 @@ ArkUI_Float32 CheckAngle(const ArkUI_Float32 angle) return angle; } +void ParseSweepGradientCenterXResObj(NG::Gradient& gradient, RefPtr& centerXResObj) +{ + if (centerXResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::Gradient& gradient) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + auto unit = static_cast(dimension.Unit()); + auto centerXValue = dimension.Value(); + auto value = (unit == DimensionUnit::PERCENT) ? (centerXValue * PERCENT_100) : centerXValue; + gradient.GetSweepGradient()->centerX = CalcDimension(value, unit); + }; + gradient.AddResource("SweepGradient.center.centerX", centerXResObj, std::move(updateFunc)); + } +} + +void ParseSweepGradientCenterYResObj(NG::Gradient& gradient, RefPtr& centerYResObj) +{ + if (centerYResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::Gradient& gradient) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + auto unit = static_cast(dimension.Unit()); + auto centerYValue = dimension.Value(); + auto value = (unit == DimensionUnit::PERCENT) ? (centerYValue * PERCENT_100) : centerYValue; + gradient.GetSweepGradient()->centerY = CalcDimension(value, unit); + }; + gradient.AddResource("SweepGradient.center.centerY", centerYResObj, std::move(updateFunc)); + } +} + +void ParseRadialGradientCenterXResObj(NG::Gradient& gradient, RefPtr& centerXResObj) +{ + if (centerXResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::Gradient& gradient) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + auto unit = static_cast(dimension.Unit()); + auto centerXValue = dimension.Value(); + auto value = (unit == DimensionUnit::PERCENT) ? (centerXValue * PERCENT_100) : centerXValue; + gradient.GetRadialGradient()->radialCenterX = CalcDimension(value, unit); + }; + gradient.AddResource("RadialGradient.center.centerX", centerXResObj, std::move(updateFunc)); + } +} + +void ParseRadialGradientCenterYResObj(NG::Gradient& gradient, RefPtr& centerYResObj) +{ + if (centerYResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::Gradient& gradient) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + auto unit = static_cast(dimension.Unit()); + auto centerYValue = dimension.Value(); + auto value = (unit == DimensionUnit::PERCENT) ? (centerYValue * PERCENT_100) : centerYValue; + gradient.GetRadialGradient()->radialCenterY = CalcDimension(value, unit); + }; + gradient.AddResource("RadialGradient.center.centerY", centerYResObj, std::move(updateFunc)); + } +} + +void ParseRadialGradientRadiusResObj(NG::Gradient& gradient, RefPtr& radiusResObj) +{ + if (radiusResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::Gradient& gradient) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + auto unit = static_cast(dimension.Unit()); + auto value = CheckAngle(dimension.Value()); + gradient.GetRadialGradient()->radialVerticalSize = CalcDimension(value, unit); + gradient.GetRadialGradient()->radialHorizontalSize = CalcDimension(value, unit); + }; + gradient.AddResource("RadialGradient.radius", radiusResObj, std::move(updateFunc)); + } +} + /** * @param values value value * values[0], values[1], values[2] : centerX Dimension: hasValue, value, unit @@ -405,7 +539,8 @@ ArkUI_Float32 CheckAngle(const ArkUI_Float32 angle) * values[12] : repeating * @param valuesLength values length */ -void SetSweepGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength) +void SetSweepGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, + void* resRawPtr) { if ((values == nullptr) || (valuesLength != NUM_13)) { return; @@ -423,15 +558,26 @@ void SetSweepGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* v auto rotationHasValue = values[NUM_10].i32; auto rotationValue = values[NUM_11].f32; auto repeating = values[NUM_12].i32; + + auto objs = *(reinterpret_cast>*>(resRawPtr)); + RefPtr centerXResObj = objs[NUM_0]; + RefPtr centerYResObj = objs[NUM_1]; + if (static_cast(centerXHasValue)) { auto unit = static_cast(centerXUnit); auto value = (unit == DimensionUnit::PERCENT) ? (centerXValue * PERCENT_100) : centerXValue; gradient.GetSweepGradient()->centerX = CalcDimension(value, unit); + if (SystemProperties::ConfigChangePerform() && centerXResObj) { + ParseSweepGradientCenterXResObj(gradient, centerXResObj); + } } if (static_cast(centerYHasValue)) { auto unit = static_cast(centerYUnit); auto value = (unit == DimensionUnit::PERCENT) ? (centerYValue * PERCENT_100) : centerYValue; gradient.GetSweepGradient()->centerY = CalcDimension(value, unit); + if (SystemProperties::ConfigChangePerform() && centerYResObj) { + ParseSweepGradientCenterYResObj(gradient, centerYResObj); + } } if (static_cast(startHasValue)) { gradient.GetSweepGradient()->startAngle = CalcDimension(CheckAngle(startValue), DimensionUnit::PX); @@ -453,7 +599,8 @@ void SetSweepGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* v * values[9] : repeating * @param valuesLength values length */ -void SetRadialGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength) +void SetRadialGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, + void* resRawPtr) { if ((values == nullptr) || (valuesLength != NUM_10)) { return; @@ -469,22 +616,35 @@ void SetRadialGradientValues(NG::Gradient& gradient, const ArkUIInt32orFloat32* auto radiusValue = values[NUM_7].f32; auto radiusUnit = values[NUM_8].i32; auto repeating = values[NUM_9].i32; + auto objs = *(reinterpret_cast>*>(resRawPtr)); + RefPtr centerXResObj = objs[NUM_0]; + RefPtr centerYResObj = objs[NUM_1]; + RefPtr radiusResObj = objs[NUM_2]; if (static_cast(centerXHasValue)) { auto unit = static_cast(centerXUnit); auto value = (unit == DimensionUnit::PERCENT) ? (centerXValue * PERCENT_100) : centerXValue; gradient.GetRadialGradient()->radialCenterX = CalcDimension(value, unit); + if (SystemProperties::ConfigChangePerform() && centerXResObj) { + ParseRadialGradientCenterXResObj(gradient, centerXResObj); + } } if (static_cast(centerYHasValue)) { auto unit = static_cast(centerYUnit); auto value = (unit == DimensionUnit::PERCENT) ? (centerYValue * PERCENT_100) : centerYValue; gradient.GetRadialGradient()->radialCenterY = CalcDimension(value, unit); + if (SystemProperties::ConfigChangePerform() && centerYResObj) { + ParseRadialGradientCenterYResObj(gradient, centerYResObj); + } } if (static_cast(radiusHasValue)) { auto unit = static_cast(radiusUnit); auto value = CheckAngle(radiusValue); gradient.GetRadialGradient()->radialVerticalSize = CalcDimension(value, unit); gradient.GetRadialGradient()->radialHorizontalSize = CalcDimension(value, unit); + if (SystemProperties::ConfigChangePerform() && radiusResObj) { + ParseRadialGradientRadiusResObj(gradient, radiusResObj); + } } gradient.SetRepeat(static_cast(repeating)); } @@ -1043,9 +1203,68 @@ bool GetShadowFromTheme(ShadowStyle shadowStyle, Shadow& shadow) CHECK_NULL_RETURN(shadowTheme, false); auto colorMode = container->GetColorMode(); shadow = shadowTheme->GetShadow(shadowStyle, colorMode); + if (SystemProperties::ConfigChangePerform()) { + RefPtr resObj = AceType::MakeRefPtr("", "", -1); + auto&& updateFunc = [shadowStyle](const RefPtr& resObj, Shadow& shadow) { + auto colorMode = Container::CurrentColorMode(); + auto container = Container::Current(); + CHECK_NULL_VOID(container); + auto pipelineContext = container->GetPipelineContext(); + CHECK_NULL_VOID(pipelineContext); + auto shadowTheme = pipelineContext->GetTheme(); + if (!shadowTheme) { + return; + } + shadow = shadowTheme->GetShadow(shadowStyle, colorMode); + }; + shadow.AddResource("shadow.shadowStyle", resObj, std::move(updateFunc)); + } return true; } +void CheckBackShadowResObj(const std::vector> objs, Shadow& shadow) +{ + RefPtr radiusResObj = objs[NUM_0]; + RefPtr offsetXResObj = objs[NUM_1]; + RefPtr offsetYResObj = objs[NUM_2]; + RefPtr colorResObj = objs[NUM_3]; + if (radiusResObj) { + auto&& updateFunc = [](const RefPtr& radiusResObj, Shadow& shadow) { + double radius = 0.0; + ResourceParseUtils::ParseResDouble(radiusResObj, radius); + if (LessNotEqual(radius, 0.0)) { + radius = 0.0; + } + shadow.SetBlurRadius(radius); + }; + shadow.AddResource("shadow.radius", radiusResObj, std::move(updateFunc)); + } + if (offsetXResObj) { + auto&& updateFunc = [](const RefPtr& xResObj, Shadow& shadow) { + CalcDimension xValue; + ResourceParseUtils::ParseResResource(xResObj, xValue); + shadow.SetOffsetX(xValue.Value()); + }; + shadow.AddResource("shadow.offsetX", offsetXResObj, std::move(updateFunc)); + } + if (offsetYResObj) { + auto&& updateFunc = [](const RefPtr& yResObj, Shadow& shadow) { + CalcDimension yValue; + ResourceParseUtils::ParseResResource(yResObj, yValue); + shadow.SetOffsetY(yValue.Value()); + }; + shadow.AddResource("shadow.offsetY", offsetYResObj, std::move(updateFunc)); + } + if (colorResObj) { + auto&& updateFunc = [](const RefPtr& colorResObj, Shadow& shadow) { + Color colorValue; + ResourceParseUtils::ParseResColor(colorResObj, colorValue); + shadow.SetColor(colorValue); + }; + shadow.AddResource("shadow.colorValue", colorResObj, std::move(updateFunc)); + } +} + /** * @param shadows shadow value * shadows[0] : BlurRadius, shadows[1] : 1: has ColorStrategy; 2: has Color @@ -1053,7 +1272,7 @@ bool GetShadowFromTheme(ShadowStyle shadowStyle, Shadow& shadow) * shadows[4] : ShadowType, shadows[5] : Color, shadows[6] : IsFilled * @param length shadows length */ -void SetBackShadow(ArkUINodeHandle node, const ArkUIInt32orFloat32* shadows, ArkUI_Int32 length) +void SetBackShadow(ArkUINodeHandle node, const ArkUIInt32orFloat32* shadows, ArkUI_Int32 length, void* resRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -1086,6 +1305,10 @@ void SetBackShadow(ArkUINodeHandle node, const ArkUIInt32orFloat32* shadows, Ark } shadow.SetShadowType(static_cast(shadowType)); shadow.SetIsFilled(static_cast(isFilled)); + auto objs = *(reinterpret_cast>*>(resRawPtr)); + if (SystemProperties::ConfigChangePerform()) { + CheckBackShadowResObj(objs, shadow); + } ViewAbstract::SetBackShadow(frameNode, shadow); } @@ -1126,7 +1349,7 @@ void ResetZIndex(ArkUINodeHandle node) ViewAbstract::SetZIndex(frameNode, 0); } -void SetOpacity(ArkUINodeHandle node, ArkUI_Float32 opacity) +void SetOpacity(ArkUINodeHandle node, ArkUI_Float32 opacity, void* opacityRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -1137,7 +1360,13 @@ void SetOpacity(ArkUINodeHandle node, ArkUI_Float32 opacity) } else { opacity = std::clamp(opacity, 0.0f, 1.0f); } - ViewAbstract::SetOpacity(frameNode, opacity); + if (!SystemProperties::ConfigChangePerform() || !opacityRawPtr) { + ViewAbstract::SetOpacity(frameNode, opacity); + } else { + auto* opacityPtr = reinterpret_cast(opacityRawPtr); + auto opacityResObj = AceType::Claim(opacityPtr); + ViewAbstract::SetOpacity(frameNode, opacity, opacityResObj); + } } void ResetOpacity(ArkUINodeHandle node) @@ -1272,11 +1501,17 @@ void ResetSaturate(ArkUINodeHandle node) ViewAbstract::SetSaturate(frameNode, value); } -void SetColorBlend(ArkUINodeHandle node, uint32_t color) +void SetColorBlend(ArkUINodeHandle node, uint32_t color, void* colorBlendRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); - ViewAbstract::SetColorBlend(frameNode, Color(color)); + if (!SystemProperties::ConfigChangePerform() || !colorBlendRawPtr) { + ViewAbstract::SetColorBlend(frameNode, Color(color)); + } else { + auto* colorBlend = reinterpret_cast(colorBlendRawPtr); + auto colorBlendResObj = AceType::Claim(colorBlend); + ViewAbstract::SetColorBlend(frameNode, Color(color), colorBlendResObj); + } } void ResetColorBlend(ArkUINodeHandle node) @@ -1394,7 +1629,7 @@ void ResetBlur(ArkUINodeHandle node) * @param colorsLength colors length */ void SetLinearGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength) + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* colorRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -1404,7 +1639,7 @@ void SetLinearGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::LINEAR); SetLinearGradientValues(gradient, values, valuesLength); - SetGradientColors(gradient, colors, colorsLength); + SetGradientColors(gradient, colors, colorsLength, colorRawPtr); ViewAbstract::SetLinearGradient(frameNode, gradient); } @@ -1433,7 +1668,7 @@ void ResetLinearGradient(ArkUINodeHandle node) * @param colorsLength colors length */ void SetSweepGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength) + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* resRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -1442,8 +1677,9 @@ void SetSweepGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, A } NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::SWEEP); - SetSweepGradientValues(gradient, values, valuesLength); - SetGradientColors(gradient, colors, colorsLength); + SetSweepGradientValues(gradient, values, valuesLength, resRawPtr); + int startPos = NUM_2; + SetGradientColors(gradient, colors, colorsLength, resRawPtr, startPos); ViewAbstract::SetSweepGradient(frameNode, gradient); } @@ -1470,7 +1706,7 @@ void ResetSweepGradient(ArkUINodeHandle node) * @param colorsLength colors length */ void SetRadialGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, ArkUI_Int32 valuesLength, - const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength) + const ArkUIInt32orFloat32* colors, ArkUI_Int32 colorsLength, void* resRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -1479,8 +1715,9 @@ void SetRadialGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, } NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::RADIAL); - SetRadialGradientValues(gradient, values, valuesLength); - SetGradientColors(gradient, colors, colorsLength); + SetRadialGradientValues(gradient, values, valuesLength, resRawPtr); + int startPos = NUM_3; + SetGradientColors(gradient, colors, colorsLength, resRawPtr, startPos); ViewAbstract::SetRadialGradient(frameNode, gradient); } @@ -1623,7 +1860,7 @@ void SetBorderImageGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* val NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::LINEAR); SetBorderImageGradientValues(gradient, values, valuesLength); - SetGradientColors(gradient, colors, colorsLength); + SetGradientColors(gradient, colors, colorsLength, nullptr); ViewAbstract::SetBorderImageGradient(frameNode, gradient); } @@ -1750,9 +1987,27 @@ void ResetLinearGradientBlur(ArkUINodeHandle node) ViewAbstract::SetLinearGradientBlur(frameNode, blurPara); } +void CheckBackgroundBlurStyleResObj(void* inactiveColorRawPtr, BlurStyleOption& bgBlurStyle) +{ + if (SystemProperties::ConfigChangePerform()) { + auto* inactiveColorPtr = reinterpret_cast(inactiveColorRawPtr); + auto inactiveColorResObj = AceType::Claim(inactiveColorPtr); + if (inactiveColorResObj) { + auto&& updateFunc = [](const RefPtr& resObj, BlurStyleOption& styleOption) { + Color inactiveColorValue; + ResourceParseUtils::ParseResColor(resObj, inactiveColorValue); + styleOption.inactiveColor = inactiveColorValue; + styleOption.isValidColor = true; + }; + bgBlurStyle.AddResource("backgroundBlurStyle.backgroundBlurStyleOptions.inactiveColor", inactiveColorResObj, + std::move(updateFunc)); + } + } +} + void SetBackgroundBlurStyle(ArkUINodeHandle node, ArkUI_Int32 (*intArray)[5], ArkUI_Float32 scale, const ArkUI_Float32* blurValues, ArkUI_Int32 blurValuesSize, ArkUI_Bool isValidColor, ArkUI_Uint32 inactiveColorArg, - ArkUI_Bool disableSystemAdaptation) + ArkUI_Bool disableSystemAdaptation, void* inactiveColorRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -1790,6 +2045,7 @@ void SetBackgroundBlurStyle(ArkUINodeHandle node, ArkUI_Int32 (*intArray)[5], Ar bgBlurStyle.inactiveColor = inactiveColor; SysOptions sysOptions; sysOptions.disableSystemAdaptation = disableSystemAdaptation; + CheckBackgroundBlurStyleResObj(inactiveColorRawPtr, bgBlurStyle); ViewAbstract::SetBackgroundBlurStyle(frameNode, bgBlurStyle, sysOptions); } @@ -2753,6 +3009,65 @@ void ResetSafeAreaPadding(ArkUINodeHandle node) ViewAbstract::ResetSafeAreaPadding(frameNode); } +void CheckPixelStretchEffectResObj(PixStretchEffectOption& option, const std::vector>& objs) +{ + RefPtr leftObj = objs[NUM_0]; + RefPtr rightObj = objs[NUM_1]; + RefPtr topObj = objs[NUM_2]; + RefPtr bottomObj = objs[NUM_3]; + if (leftObj) { + auto&& updateFunc = [](const RefPtr& leftObj, PixStretchEffectOption& effectOption) { + CalcDimension left; + ResourceParseUtils::ParseResDimensionVp(leftObj, left); + effectOption.left = left; + }; + option.AddResource("pixelStretchEffect.left", leftObj, std::move(updateFunc)); + } + if (rightObj) { + auto&& updateFunc = [](const RefPtr& rightObj, PixStretchEffectOption& effectOption) { + CalcDimension right; + ResourceParseUtils::ParseResDimensionVp(rightObj, right); + effectOption.right = right; + }; + option.AddResource("pixelStretchEffect.right", rightObj, std::move(updateFunc)); + } + if (topObj) { + auto&& updateFunc = [](const RefPtr& topObj, PixStretchEffectOption& effectOption) { + CalcDimension top; + ResourceParseUtils::ParseResDimensionVp(topObj, top); + effectOption.top = top; + }; + option.AddResource("pixelStretchEffect.top", topObj, std::move(updateFunc)); + } + if (bottomObj) { + auto&& updateFunc = [](const RefPtr& bottomObj, PixStretchEffectOption& effectOption) { + CalcDimension bottom; + ResourceParseUtils::ParseResDimensionVp(bottomObj, bottom); + effectOption.bottom = bottom; + }; + option.AddResource("pixelStretchEffect.bottom", bottomObj, std::move(updateFunc)); + } +} + +void CheckPixelStretchEffectPercent(bool& illegalInput, Dimension& left, Dimension& right, + Dimension& top, Dimension& bottom) +{ + if (left.Unit() == DimensionUnit::PERCENT || right.Unit() == DimensionUnit::PERCENT || + top.Unit() == DimensionUnit::PERCENT || bottom.Unit() == DimensionUnit::PERCENT) { + if ((NearEqual(left.Value(), 0.0) || left.Unit() == DimensionUnit::PERCENT) && + (NearEqual(top.Value(), 0.0) || top.Unit() == DimensionUnit::PERCENT) && + (NearEqual(right.Value(), 0.0) || right.Unit() == DimensionUnit::PERCENT) && + (NearEqual(bottom.Value(), 0.0) || bottom.Unit() == DimensionUnit::PERCENT)) { + left.SetUnit(DimensionUnit::PERCENT); + top.SetUnit(DimensionUnit::PERCENT); + right.SetUnit(DimensionUnit::PERCENT); + bottom.SetUnit(DimensionUnit::PERCENT); + } else { + illegalInput = true; + } + } +} + /** * @param values value value * values[0] : left, values[1] : top, values[2] : right, values[3] : bottom @@ -2761,7 +3076,7 @@ void ResetSafeAreaPadding(ArkUINodeHandle node) * @param length values length */ void SetPixelStretchEffect( - ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length) + ArkUINodeHandle node, const ArkUI_Float32* values, const ArkUI_Int32* units, ArkUI_Int32 length, void* rawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -2781,20 +3096,7 @@ void SetPixelStretchEffect( Dimension right(rightValue, static_cast(rightUnit)); Dimension bottom(bottomValue, static_cast(bottomUnit)); bool illegalInput = false; - if (left.Unit() == DimensionUnit::PERCENT || right.Unit() == DimensionUnit::PERCENT || - top.Unit() == DimensionUnit::PERCENT || bottom.Unit() == DimensionUnit::PERCENT) { - if ((NearEqual(left.Value(), 0.0) || left.Unit() == DimensionUnit::PERCENT) && - (NearEqual(top.Value(), 0.0) || top.Unit() == DimensionUnit::PERCENT) && - (NearEqual(right.Value(), 0.0) || right.Unit() == DimensionUnit::PERCENT) && - (NearEqual(bottom.Value(), 0.0) || bottom.Unit() == DimensionUnit::PERCENT)) { - left.SetUnit(DimensionUnit::PERCENT); - top.SetUnit(DimensionUnit::PERCENT); - right.SetUnit(DimensionUnit::PERCENT); - bottom.SetUnit(DimensionUnit::PERCENT); - } else { - illegalInput = true; - } - } + CheckPixelStretchEffectPercent(illegalInput, left, right, top, bottom); PixStretchEffectOption option; if ((left.IsNonNegative() && top.IsNonNegative() && right.IsNonNegative() && bottom.IsNonNegative()) || (left.IsNonPositive() && top.IsNonPositive() && right.IsNonPositive() && bottom.IsNonPositive())) { @@ -2808,6 +3110,10 @@ void SetPixelStretchEffect( if (illegalInput) { option.ResetValue(); } + auto objs = *(reinterpret_cast>*>(rawPtr)); + if (SystemProperties::ConfigChangePerform()) { + CheckPixelStretchEffectResObj(option, objs); + } ViewAbstract::SetPixelStretchEffect(frameNode, option); } @@ -2904,12 +3210,18 @@ void ResetUseEffect(ArkUINodeHandle node) ViewAbstract::SetUseEffect(frameNode, false, EffectType::DEFAULT); } -void SetForegroundColor(ArkUINodeHandle node, ArkUI_Bool isColor, uint32_t color) +void SetForegroundColor(ArkUINodeHandle node, ArkUI_Bool isColor, uint32_t color, void* fgColorRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); if (isColor) { - ViewAbstract::SetForegroundColor(frameNode, Color(color)); + if (SystemProperties::ConfigChangePerform() && fgColorRawPtr) { + auto* fgColor = reinterpret_cast(fgColorRawPtr); + auto colorResObj = AceType::Claim(fgColor); + ViewAbstract::SetForegroundColor(frameNode, Color(color), colorResObj); + } else { + ViewAbstract::SetForegroundColor(frameNode, Color(color)); + } } else { auto strategy = static_cast(color); ViewAbstract::SetForegroundColorStrategy(frameNode, strategy); @@ -3830,7 +4142,7 @@ void ResetForegroundEffect(ArkUINodeHandle node) void SetBackgroundEffect(ArkUINodeHandle node, ArkUI_Float32 radiusArg, ArkUI_Float32 saturationArg, ArkUI_Float32 brightnessArg, ArkUI_Uint32 colorArg, ArkUI_Int32 adaptiveColorArg, const ArkUI_Float32* blurValues, ArkUI_Int32 blurValuesSize, ArkUI_Int32 policy, ArkUI_Int32 blurType, ArkUI_Bool isValidColor, - ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation) + ArkUI_Uint32 inactiveColorArg, ArkUI_Bool disableSystemAdaptation, void* colorRawPtr, void* inactiveColorRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -3858,6 +4170,28 @@ void SetBackgroundEffect(ArkUINodeHandle node, ArkUI_Float32 radiusArg, ArkUI_Fl option.isValidColor = isValidColor; SysOptions sysOptions; sysOptions.disableSystemAdaptation = disableSystemAdaptation; + if (SystemProperties::ConfigChangePerform()) { + auto* colorPtr = reinterpret_cast(colorRawPtr); + auto colorResObj = AceType::Claim(colorPtr); + if (colorResObj) { + auto&& updateFunc = [](const RefPtr& colorResObj, EffectOption& effectOption) { + Color effectOptionColor; + ResourceParseUtils::ParseResColor(colorResObj, effectOptionColor); + effectOption.color = effectOptionColor; + }; + option.AddResource("backgroundEffect.color", colorResObj, std::move(updateFunc)); + } + auto* inactiveColorPtr = reinterpret_cast(inactiveColorRawPtr); + auto inactiveColorResObj = AceType::Claim(inactiveColorPtr); + if (inactiveColorResObj) { + auto&& updateFunc = [](const RefPtr& inactiveColorObj, EffectOption& effectOption) { + Color effectOptionInactiveColor; + ResourceParseUtils::ParseResColor(inactiveColorObj, effectOptionInactiveColor); + effectOption.inactiveColor = effectOptionInactiveColor; + }; + option.AddResource("backgroundEffect.inactiveColor", inactiveColorResObj, std::move(updateFunc)); + } + } ViewAbstract::SetBackgroundEffect(frameNode, option, sysOptions); } @@ -4254,8 +4588,40 @@ void ResetKeyBoardShortCut(ArkUINodeHandle node) ViewAbstractModelNG::SetKeyboardShortcut(frameNode, "", std::vector(), nullptr); } +void SetPointLightPositionResObj(void* resRawPtr, NG::TranslateOptions& option) +{ + auto objs = *(reinterpret_cast>*>(resRawPtr)); + RefPtr xResObj = objs[NUM_0]; + RefPtr yResObj = objs[NUM_1]; + RefPtr zResObj = objs[NUM_2]; + if (xResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::TranslateOptions& option) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + option.x = dimension; + }; + option.AddResource("pointLight.LightSource.PositionX", xResObj, std::move(updateFunc)); + } + if (yResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::TranslateOptions& option) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + option.y = dimension; + }; + option.AddResource("pointLight.LightSource.PositionY", yResObj, std::move(updateFunc)); + } + if (zResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::TranslateOptions& option) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + option.z = dimension; + }; + option.AddResource("pointLight.LightSource.PositionZ", zResObj, std::move(updateFunc)); + } +} + void SetPointLightPosition(ArkUINodeHandle node, const struct ArkUISizeType* positionX, - const struct ArkUISizeType* positionY, const struct ArkUISizeType* positionZ) + const struct ArkUISizeType* positionY, const struct ArkUISizeType* positionZ, void* resRawPtr) { #ifdef POINT_LIGHT_ENABLE auto* frameNode = reinterpret_cast(node); @@ -4266,7 +4632,17 @@ void SetPointLightPosition(ArkUINodeHandle node, const struct ArkUISizeType* pos CalcDimension lightPositionX(positionX->value, static_cast(positionX->unit)); CalcDimension lightPositionY(positionY->value, static_cast(positionY->unit)); CalcDimension lightPositionZ(positionZ->value, static_cast(positionZ->unit)); - ViewAbstract::SetLightPosition(frameNode, lightPositionX, lightPositionY, lightPositionZ); + if (!SystemProperties::ConfigChangePerform()) { + ViewAbstract::SetLightPosition(frameNode, lightPositionX, lightPositionY, lightPositionZ); + } else { + NG::TranslateOptions option; + option.x = lightPositionX; + option.y = lightPositionY; + option.z = lightPositionZ; + + SetPointLightPositionResObj(resRawPtr, option); + ViewAbstract::SetLightPosition(frameNode, option); + } #endif } @@ -4300,13 +4676,20 @@ void ResetPointLightIntensity(ArkUINodeHandle node) #endif } -void SetPointLightColor(ArkUINodeHandle node, ArkUI_Uint32 color) +void SetPointLightColor(ArkUINodeHandle node, ArkUI_Uint32 color, void* colorRawPtr) { #ifdef POINT_LIGHT_ENABLE auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); Color colorValue(color); - ViewAbstract::SetLightColor(frameNode, colorValue); + if (SystemProperties::ConfigChangePerform() && colorRawPtr) { + auto* lightColor = reinterpret_cast(colorRawPtr); + auto colorResObj = AceType::Claim(lightColor); + ViewAbstract::SetLightColor(frameNode, colorValue, colorResObj); + } else { + ViewAbstract::SetLightColor(frameNode, colorValue); + } + #endif } @@ -5048,7 +5431,119 @@ void ResetMask(ArkUINodeHandle node) ViewAbstract::SetMask(frameNode, nullptr); } -void SetOutlineColor(ArkUINodeHandle node, const uint32_t* values, int32_t valuesSize) +void CheckOuterBorderWidthResObj(NG::BorderWidthProperty& borderWidth, RefPtr& leftResObj, + RefPtr& rightResObj, RefPtr& topResObj, RefPtr& bottomResObj) +{ + if (leftResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderWidthProperty& borderWidth) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + borderWidth.leftDimen = dimension; + }; + borderWidth.AddResource("outLineWidth.EdgeOutlineWidths.left", leftResObj, std::move(updateFunc)); + } + if (rightResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderWidthProperty& borderWidth) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + borderWidth.rightDimen = dimension; + }; + borderWidth.AddResource("outLineWidth.EdgeOutlineWidths.right", rightResObj, std::move(updateFunc)); + } + if (topResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderWidthProperty& borderWidth) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + borderWidth.topDimen = dimension; + }; + borderWidth.AddResource("outLineWidth.EdgeOutlineWidths.top", topResObj, std::move(updateFunc)); + } + if (bottomResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderWidthProperty& borderWidth) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + borderWidth.bottomDimen = dimension; + }; + borderWidth.AddResource("outLineWidth.EdgeOutlineWidths.bottom", bottomResObj, std::move(updateFunc)); + } +} + +void CheckOuterBorderRadiusResObj(NG::BorderRadiusProperty& borderRadius, + RefPtr& topLeftResObj, RefPtr& topRightResObj, + RefPtr& bottomLeftResObj, RefPtr& bottomRightResObj) +{ + if (topLeftResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderRadiusProperty& borderRadius) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + borderRadius.radiusTopLeft = dimension; + }; + borderRadius.AddResource("outLineRadius.radius.radiusTopLft", topLeftResObj, std::move(updateFunc)); + } + if (topRightResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderRadiusProperty& borderRadius) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + borderRadius.radiusTopRight = dimension; + }; + borderRadius.AddResource("outLineRadius.radius.radiusTopRight", topRightResObj, std::move(updateFunc)); + } + if (bottomLeftResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderRadiusProperty& borderRadius) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + borderRadius.radiusBottomLeft = dimension; + }; + borderRadius.AddResource("outLineRadius.radius.radiusBottomLeft", bottomLeftResObj, std::move(updateFunc)); + } + if (bottomRightResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderRadiusProperty& borderRadius) { + CalcDimension dimension; + ResourceParseUtils::ParseResDimensionVp(resObj, dimension); + borderRadius.radiusBottomRight = dimension; + }; + borderRadius.AddResource("outLineRadius.radius.radiusBottomRight", bottomRightResObj, std::move(updateFunc)); + } +} + +void CheckOuterBorderColorResObj(NG::BorderColorProperty& borderColors, RefPtr& leftResObj, + RefPtr& rightResObj, RefPtr& topResObj, RefPtr& bottomResObj) +{ + if (leftResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderColorProperty& borderColors) { + Color color; + ResourceParseUtils::ParseResColor(resObj, color); + borderColors.leftColor = color; + }; + borderColors.AddResource("outLineColor.edgeColor.left", leftResObj, std::move(updateFunc)); + } + if (rightResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderColorProperty& borderColors) { + Color color; + ResourceParseUtils::ParseResColor(resObj, color); + borderColors.rightColor = color; + }; + borderColors.AddResource("outLineColor.edgeColor.right", rightResObj, std::move(updateFunc)); + } + if (topResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderColorProperty& borderColors) { + Color color; + ResourceParseUtils::ParseResColor(resObj, color); + borderColors.topColor = color; + }; + borderColors.AddResource("outLineColor.edgeColor.top", topResObj, std::move(updateFunc)); + } + if (bottomResObj) { + auto&& updateFunc = [](const RefPtr& resObj, NG::BorderColorProperty& borderColors) { + Color color; + ResourceParseUtils::ParseResColor(resObj, color); + borderColors.bottomColor = color; + }; + borderColors.AddResource("outLineColor.edgeColor.bottom", bottomResObj, std::move(updateFunc)); + } +} + +void SetOutlineColor(ArkUINodeHandle node, const uint32_t* values, int32_t valuesSize, void* resRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -5058,6 +5553,10 @@ void SetOutlineColor(ArkUINodeHandle node, const uint32_t* values, int32_t value SetOptionalBorderColor(borderColors.rightColor, values, valuesSize, colorOffset); SetOptionalBorderColor(borderColors.bottomColor, values, valuesSize, colorOffset); SetOptionalBorderColor(borderColors.leftColor, values, valuesSize, colorOffset); + auto objs = *(reinterpret_cast>*>(resRawPtr)); + if (SystemProperties::ConfigChangePerform()) { + CheckOuterBorderColorResObj(borderColors, objs[NUM_0], objs[NUM_1], objs[NUM_2], objs[NUM_3]); + } borderColors.multiValued = true; ViewAbstract::SetOuterBorderColor(frameNode, borderColors); } @@ -5095,7 +5594,7 @@ ArkUI_Bool GetRenderGroup(ArkUINodeHandle node) return static_cast(ViewAbstract::GetRenderGroup(frameNode)); } -void SetOutlineRadius(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t valuesSize) +void SetOutlineRadius(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t valuesSize, void* resRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -5106,6 +5605,10 @@ void SetOutlineRadius(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t SetOptionalBorder(borderRadius.radiusTopRight, values, valuesSize, radiusOffset); SetOptionalBorder(borderRadius.radiusBottomLeft, values, valuesSize, radiusOffset); SetOptionalBorder(borderRadius.radiusBottomRight, values, valuesSize, radiusOffset); + auto objs = *(reinterpret_cast>*>(resRawPtr)); + if (SystemProperties::ConfigChangePerform()) { + CheckOuterBorderRadiusResObj(borderRadius, objs[NUM_0], objs[NUM_1], objs[NUM_2], objs[NUM_3]); + } borderRadius.multiValued = true; ViewAbstract::SetOuterBorderRadius(frameNode, borderRadius); } @@ -5118,7 +5621,7 @@ void ResetOutlineRadius(ArkUINodeHandle node) ViewAbstract::SetOuterBorderRadius(frameNode, value); } -void SetOutlineWidth(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t valuesSize) +void SetOutlineWidth(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t valuesSize, void* resRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -5129,6 +5632,10 @@ void SetOutlineWidth(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t SetOptionalBorder(borderWidth.rightDimen, values, valuesSize, offset); SetOptionalBorder(borderWidth.topDimen, values, valuesSize, offset); SetOptionalBorder(borderWidth.bottomDimen, values, valuesSize, offset); + auto objs = *(reinterpret_cast>*>(resRawPtr)); + if (SystemProperties::ConfigChangePerform()) { + CheckOuterBorderWidthResObj(borderWidth, objs[NUM_0], objs[NUM_1], objs[NUM_2], objs[NUM_3]); + } borderWidth.multiValued = true; ViewAbstract::SetOuterBorderWidth(frameNode, borderWidth); } @@ -5217,7 +5724,7 @@ void ResetOutlineStyle(ArkUINodeHandle node) * @param optionsLength options colorAndStyleSize */ void SetOutline(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t valuesSize, const uint32_t* colorAndStyle, - int32_t colorAndStyleSize) + int32_t colorAndStyleSize, void* resRawPtr) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); @@ -5225,6 +5732,7 @@ void SetOutline(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t value return; } + auto objs = *(reinterpret_cast>*>(resRawPtr)); int32_t offset = NUM_0; // offset for outline width and outline radius NG::BorderWidthProperty borderWidth; SetOptionalBorder(borderWidth.leftDimen, values, valuesSize, offset); @@ -5232,6 +5740,9 @@ void SetOutline(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t value SetOptionalBorder(borderWidth.topDimen, values, valuesSize, offset); SetOptionalBorder(borderWidth.bottomDimen, values, valuesSize, offset); borderWidth.multiValued = true; + if (SystemProperties::ConfigChangePerform()) { + CheckOuterBorderWidthResObj(borderWidth, objs[NUM_0], objs[NUM_1], objs[NUM_2], objs[NUM_3]); + } ViewAbstract::SetOuterBorderWidth(frameNode, borderWidth); NG::BorderRadiusProperty borderRadius; @@ -5240,6 +5751,9 @@ void SetOutline(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t value SetOptionalBorder(borderRadius.radiusBottomLeft, values, valuesSize, offset); SetOptionalBorder(borderRadius.radiusBottomRight, values, valuesSize, offset); borderRadius.multiValued = true; + if (SystemProperties::ConfigChangePerform()) { + CheckOuterBorderRadiusResObj(borderRadius, objs[NUM_4], objs[NUM_5], objs[NUM_6], objs[NUM_7]); + } ViewAbstract::SetOuterBorderRadius(frameNode, borderRadius); int32_t colorAndStyleOffset = NUM_0; // offset for outline color and outline style @@ -5249,6 +5763,9 @@ void SetOutline(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t value SetOptionalBorderColor(borderColors.topColor, colorAndStyle, colorAndStyleSize, colorAndStyleOffset); SetOptionalBorderColor(borderColors.bottomColor, colorAndStyle, colorAndStyleSize, colorAndStyleOffset); borderColors.multiValued = true; + if (SystemProperties::ConfigChangePerform()) { + CheckOuterBorderColorResObj(borderColors, objs[NUM_8], objs[NUM_9], objs[NUM_10], objs[NUM_11]); + } ViewAbstract::SetOuterBorderColor(frameNode, borderColors); NG::BorderStyleProperty borderStyles; diff --git a/interfaces/native/node/style_modifier.cpp b/interfaces/native/node/style_modifier.cpp index bfda6f3b1cc..750e750df3b 100644 --- a/interfaces/native/node/style_modifier.cpp +++ b/interfaces/native/node/style_modifier.cpp @@ -1524,7 +1524,7 @@ int32_t SetLinearGradient(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item }; fullImpl->getNodeModifiers()->getCommonModifier()->setLinearGradient( - node->uiNodeHandle, values, NUM_4, colors, size * NUM_3); + node->uiNodeHandle, values, NUM_4, colors, size * NUM_3, nullptr); return ERROR_CODE_NO_ERROR; } @@ -1609,7 +1609,7 @@ int32_t SetOpacity(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) } // already check in entry point. auto* fullImpl = GetFullImpl(); - fullImpl->getNodeModifiers()->getCommonModifier()->setOpacity(node->uiNodeHandle, item->value[0].f32); + fullImpl->getNodeModifiers()->getCommonModifier()->setOpacity(node->uiNodeHandle, item->value[0].f32, nullptr); return ERROR_CODE_NO_ERROR; } @@ -2241,7 +2241,8 @@ int32_t SetShadow(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) auto* fullImpl = GetFullImpl(); ArkUIInt32orFloat32 shadows[NUM_1] = { {.i32 = ArkUI_ShadowStyle::ARKUI_SHADOW_STYLE_OUTER_DEFAULT_XS} }; shadows[NUM_0].i32 = item->value[0].i32; - fullImpl->getNodeModifiers()->getCommonModifier()->setBackShadow(node->uiNodeHandle, shadows, ALLOW_SIZE_1); + fullImpl->getNodeModifiers()->getCommonModifier()->setBackShadow(node->uiNodeHandle, shadows, ALLOW_SIZE_1, + nullptr); return ERROR_CODE_NO_ERROR; } @@ -2299,7 +2300,8 @@ int32_t SetCustomShadow(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) if (length > NUM_6) { shadows[NUM_6].i32 = item->value[NUM_6].i32; } - fullImpl->getNodeModifiers()->getCommonModifier()->setBackShadow(node->uiNodeHandle, shadows, ALLOW_SIZE_7); + fullImpl->getNodeModifiers()->getCommonModifier()->setBackShadow(node->uiNodeHandle, shadows, ALLOW_SIZE_7, + nullptr); return ERROR_CODE_NO_ERROR; } @@ -2726,7 +2728,7 @@ int32_t SetSweepGradient(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) values[NUM_12].i32 = item->size > NUM_5 ? item->value[NUM_5].i32 : static_cast(true); fullImpl->getNodeModifiers()->getCommonModifier()->setSweepGradient( - node->uiNodeHandle, values, NUM_13, colors, size * NUM_3); + node->uiNodeHandle, values, NUM_13, colors, size * NUM_3, nullptr); return ERROR_CODE_NO_ERROR; } @@ -2828,7 +2830,7 @@ int32_t SetRadialGradient(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item values[NUM_9].i32 = item->size > NUM_3 ? item->value[NUM_3].i32 : static_cast(false); fullImpl->getNodeModifiers()->getCommonModifier()->setRadialGradient( - node->uiNodeHandle, values, NUM_10, colors, size * NUM_3); + node->uiNodeHandle, values, NUM_10, colors, size * NUM_3, nullptr); return ERROR_CODE_NO_ERROR; } @@ -3322,13 +3324,13 @@ int32_t SetForegroundColor(ArkUI_NodeHandle node, const ArkUI_AttributeItem* ite if (std::strcmp(item->string, COLORING_STRATEGY) == 0) { isColor = false; fullImpl->getNodeModifiers()->getCommonModifier()->setForegroundColor( - node->uiNodeHandle, isColor, static_cast(ForegroundColorStrategy::INVERT)); + node->uiNodeHandle, isColor, static_cast(ForegroundColorStrategy::INVERT), nullptr); return ERROR_CODE_NO_ERROR; } if (std::strcmp(item->string, COLOR_MARKERS) == 0 && item->size > 0) { isColor = true; fullImpl->getNodeModifiers()->getCommonModifier()->setForegroundColor( - node->uiNodeHandle, isColor, item->value[0].u32); + node->uiNodeHandle, isColor, item->value[0].u32, nullptr); return ERROR_CODE_NO_ERROR; } } @@ -3340,11 +3342,11 @@ int32_t SetForegroundColor(ArkUI_NodeHandle node, const ArkUI_AttributeItem* ite item->value[0].i32 == ArkUI_ColorStrategy::ARKUI_COLOR_STRATEGY_PRIMARY) { isColor = false; fullImpl->getNodeModifiers()->getCommonModifier()->setForegroundColor( - node->uiNodeHandle, isColor, item->value[0].i32); + node->uiNodeHandle, isColor, item->value[0].i32, nullptr); } else { isColor = true; fullImpl->getNodeModifiers()->getCommonModifier()->setForegroundColor( - node->uiNodeHandle, isColor, item->value[0].u32); + node->uiNodeHandle, isColor, item->value[0].u32, nullptr); } return ERROR_CODE_NO_ERROR; } @@ -3758,7 +3760,7 @@ int32_t SetOutlineColor(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) } fullImpl->getNodeModifiers()->getCommonModifier()->setOutlineColor( - node->uiNodeHandle, colors, ALLOW_SIZE_8); + node->uiNodeHandle, colors, ALLOW_SIZE_8, nullptr); return ERROR_CODE_NO_ERROR; } @@ -3848,7 +3850,7 @@ int32_t SetColorBlend(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) } auto* fullImpl = GetFullImpl(); fullImpl->getNodeModifiers()->getCommonModifier()->setColorBlend( - node->uiNodeHandle, item->value[NUM_0].u32); + node->uiNodeHandle, item->value[NUM_0].u32, nullptr); return ERROR_CODE_NO_ERROR; } @@ -10470,7 +10472,8 @@ int32_t SetBackgroundBlurStyle(ArkUI_NodeHandle node, const ArkUI_AttributeItem* bool isValidColor = false; Color inactiveColor = Color::TRANSPARENT; fullImpl->getNodeModifiers()->getCommonModifier()->setBackgroundBlurStyle( - node->uiNodeHandle, &intArray, scale, &greyVector[0], NUM_2, isValidColor, inactiveColor.GetValue(), true); + node->uiNodeHandle, &intArray, scale, &greyVector[0], NUM_2, isValidColor, inactiveColor.GetValue(), true, + nullptr); return ERROR_CODE_NO_ERROR; } diff --git a/test/unittest/core/base/view_abstract_test_ng.cpp b/test/unittest/core/base/view_abstract_test_ng.cpp index adac80483db..d123dee203b 100644 --- a/test/unittest/core/base/view_abstract_test_ng.cpp +++ b/test/unittest/core/base/view_abstract_test_ng.cpp @@ -2411,7 +2411,7 @@ HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0045, TestSize.Level1) CHECK_NULL_VOID(frameNode); auto pattern = frameNode->GetPattern(); CHECK_NULL_VOID(pattern); - RefPtr resObj = AceType::MakeRefPtr("", "", -1);; + RefPtr resObj = AceType::MakeRefPtr("", "", -1); auto&& updateFunc = [weak = AceType::WeakClaim(frameNode)](const RefPtr& resObj) {}; updateFunc(resObj); pattern->AddResObj("foregroundColor", resObj, std::move(updateFunc)); -- Gitee From a28810ec8d366f13b9f26d531df52494cdcc903c Mon Sep 17 00:00:00 2001 From: dongbin Date: Sun, 25 May 2025 02:52:38 +0800 Subject: [PATCH 2/2] dark update Signed-off-by: dongbin --- .../base/view_abstract_model_ng.cpp | 11 +++++++ .../base/view_abstract_model_ng.h | 1 + .../native/node/node_common_modifier.cpp | 33 +++++++++++++++++++ 3 files changed, 45 insertions(+) diff --git a/frameworks/core/components_ng/base/view_abstract_model_ng.cpp b/frameworks/core/components_ng/base/view_abstract_model_ng.cpp index 52511c720af..57c7e1f1523 100644 --- a/frameworks/core/components_ng/base/view_abstract_model_ng.cpp +++ b/frameworks/core/components_ng/base/view_abstract_model_ng.cpp @@ -1268,4 +1268,15 @@ void ViewAbstractModelNG::CreateWithResourceObj( CHECK_NULL_VOID(frameNode); CreateWithBoolResourceObj(frameNode, resourceObj); } + +void ViewAbstractModelNG::RemoveResObj(FrameNode* frameNode, const std::string& key) +{ + if (!SystemProperties::ConfigChangePerform()) { + return; + } + CHECK_NULL_VOID(frameNode); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_VOID(pattern); + pattern->RemoveResObj(key); +} } // namespace OHOS::Ace::NG diff --git a/frameworks/core/components_ng/base/view_abstract_model_ng.h b/frameworks/core/components_ng/base/view_abstract_model_ng.h index 65b6432a133..17e43d92365 100644 --- a/frameworks/core/components_ng/base/view_abstract_model_ng.h +++ b/frameworks/core/components_ng/base/view_abstract_model_ng.h @@ -1877,6 +1877,7 @@ public: { ViewAbstract::SetCompositingFilter(frameNode, compositingFilter); } + static void RemoveResObj(FrameNode* frameNode, const std::string& key); private: bool CheckMenuIsShow(const MenuParam& menuParam, int32_t targetId, const RefPtr& targetNode); diff --git a/frameworks/core/interfaces/native/node/node_common_modifier.cpp b/frameworks/core/interfaces/native/node/node_common_modifier.cpp index 9b9697b8442..75e34d2799c 100644 --- a/frameworks/core/interfaces/native/node/node_common_modifier.cpp +++ b/frameworks/core/interfaces/native/node/node_common_modifier.cpp @@ -1276,6 +1276,7 @@ void SetBackShadow(ArkUINodeHandle node, const ArkUIInt32orFloat32* shadows, Ark { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "shadow"); if (length == NUM_1) { Shadow shadow; auto shadowStyle = static_cast(shadows[NUM_0].i32); @@ -1316,6 +1317,7 @@ void ResetBackShadow(ArkUINodeHandle node) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "shadow"); Shadow shadow; ViewAbstract::SetBackShadow(frameNode, shadow); } @@ -1363,6 +1365,7 @@ void SetOpacity(ArkUINodeHandle node, ArkUI_Float32 opacity, void* opacityRawPtr if (!SystemProperties::ConfigChangePerform() || !opacityRawPtr) { ViewAbstract::SetOpacity(frameNode, opacity); } else { + ViewAbstractModelNG::RemoveResObj(frameNode, "viewAbstract.opacity"); auto* opacityPtr = reinterpret_cast(opacityRawPtr); auto opacityResObj = AceType::Claim(opacityPtr); ViewAbstract::SetOpacity(frameNode, opacity, opacityResObj); @@ -1508,6 +1511,7 @@ void SetColorBlend(ArkUINodeHandle node, uint32_t color, void* colorBlendRawPtr) if (!SystemProperties::ConfigChangePerform() || !colorBlendRawPtr) { ViewAbstract::SetColorBlend(frameNode, Color(color)); } else { + ViewAbstractModelNG::RemoveResObj(frameNode, "viewAbstract.colorBlend"); auto* colorBlend = reinterpret_cast(colorBlendRawPtr); auto colorBlendResObj = AceType::Claim(colorBlend); ViewAbstract::SetColorBlend(frameNode, Color(color), colorBlendResObj); @@ -1636,6 +1640,7 @@ void SetLinearGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, if ((values == nullptr) || (valuesLength != NUM_4) || ((colorsLength % NUM_3) != 0)) { return; } + ViewAbstractModelNG::RemoveResObj(frameNode, "LinearGradient.gradient"); NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::LINEAR); SetLinearGradientValues(gradient, values, valuesLength); @@ -1647,6 +1652,7 @@ void ResetLinearGradient(ArkUINodeHandle node) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "LinearGradient.gradient"); NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::LINEAR); ViewAbstract::SetLinearGradient(frameNode, gradient); @@ -1675,6 +1681,7 @@ void SetSweepGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, A if ((values == nullptr) || (valuesLength != NUM_13) || ((colorsLength % NUM_3) != 0)) { return; } + ViewAbstractModelNG::RemoveResObj(frameNode, "SweepGradient.gradient"); NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::SWEEP); SetSweepGradientValues(gradient, values, valuesLength, resRawPtr); @@ -1687,6 +1694,7 @@ void ResetSweepGradient(ArkUINodeHandle node) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "SweepGradient.gradient"); NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::SWEEP); ViewAbstract::SetSweepGradient(frameNode, gradient); @@ -1713,6 +1721,7 @@ void SetRadialGradient(ArkUINodeHandle node, const ArkUIInt32orFloat32* values, if ((values == nullptr) || (valuesLength != NUM_10) || ((colorsLength % NUM_3) != 0)) { return; } + ViewAbstractModelNG::RemoveResObj(frameNode, "RadialGradient.gradient"); NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::RADIAL); SetRadialGradientValues(gradient, values, valuesLength, resRawPtr); @@ -1725,6 +1734,7 @@ void ResetRadialGradient(ArkUINodeHandle node) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "RadialGradient.gradient"); NG::Gradient gradient; gradient.CreateGradientWithType(NG::GradientType::RADIAL); ViewAbstract::SetRadialGradient(frameNode, gradient); @@ -2011,6 +2021,7 @@ void SetBackgroundBlurStyle(ArkUINodeHandle node, ArkUI_Int32 (*intArray)[5], Ar { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "backgroundBlurStyle.backgroundBlurStyleOptions"); ArkUI_Int32 blurStyle = (*intArray)[NUM_0]; ArkUI_Int32 colorMode = (*intArray)[NUM_1]; ArkUI_Int32 adaptiveColor = (*intArray)[NUM_2]; @@ -2074,6 +2085,7 @@ void ResetBackgroundBlurStyle(ArkUINodeHandle node) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "backgroundBlurStyle.backgroundBlurStyleOptions"); BlurStyleOption bgBlurStyle; ViewAbstract::SetBackgroundBlurStyle(frameNode, bgBlurStyle); } @@ -3083,6 +3095,7 @@ void SetPixelStretchEffect( if (length != NUM_4) { return; } + ViewAbstractModelNG::RemoveResObj(frameNode, "pixelStretchEffect"); auto leftValue = values[NUM_0]; auto leftUnit = units[NUM_0]; auto topValue = values[NUM_1]; @@ -3121,6 +3134,7 @@ void ResetPixelStretchEffect(ArkUINodeHandle node) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "pixelStretchEffect"); PixStretchEffectOption option; option.ResetValue(); ViewAbstract::SetPixelStretchEffect(frameNode, option); @@ -3216,6 +3230,7 @@ void SetForegroundColor(ArkUINodeHandle node, ArkUI_Bool isColor, uint32_t color CHECK_NULL_VOID(frameNode); if (isColor) { if (SystemProperties::ConfigChangePerform() && fgColorRawPtr) { + ViewAbstractModelNG::RemoveResObj(frameNode, "foregroundColor"); auto* fgColor = reinterpret_cast(fgColorRawPtr); auto colorResObj = AceType::Claim(fgColor); ViewAbstract::SetForegroundColor(frameNode, Color(color), colorResObj); @@ -4146,6 +4161,7 @@ void SetBackgroundEffect(ArkUINodeHandle node, ArkUI_Float32 radiusArg, ArkUI_Fl { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "backgroundEffect"); CalcDimension radius; if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_EIGHTEEN)) { radius = CalcDimension(radiusArg, DimensionUnit::VP); @@ -4199,6 +4215,7 @@ void ResetBackgroundEffect(ArkUINodeHandle node) { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "backgroundEffect"); CalcDimension radius; radius.SetValue(0.0f); double saturation = 1.0f; @@ -4635,6 +4652,7 @@ void SetPointLightPosition(ArkUINodeHandle node, const struct ArkUISizeType* pos if (!SystemProperties::ConfigChangePerform()) { ViewAbstract::SetLightPosition(frameNode, lightPositionX, lightPositionY, lightPositionZ); } else { + ViewAbstractModelNG::RemoveResObj(frameNode, "pointLight.LightSource"); NG::TranslateOptions option; option.x = lightPositionX; option.y = lightPositionY; @@ -4683,6 +4701,7 @@ void SetPointLightColor(ArkUINodeHandle node, ArkUI_Uint32 color, void* colorRaw CHECK_NULL_VOID(frameNode); Color colorValue(color); if (SystemProperties::ConfigChangePerform() && colorRawPtr) { + ViewAbstractModelNG::RemoveResObj(frameNode, "LightColorRes"); auto* lightColor = reinterpret_cast(colorRawPtr); auto colorResObj = AceType::Claim(lightColor); ViewAbstract::SetLightColor(frameNode, colorValue, colorResObj); @@ -4730,6 +4749,7 @@ void SetPointLightBloom(ArkUINodeHandle node, ArkUI_Float32 bloom, ArkUI_Float32 #ifdef POINT_LIGHT_ENABLE auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "shadow"); ViewAbstract::SetBloom(frameNode, static_cast(bloom)); Shadow shadow; shadow.SetBlurRadius(bloom * static_cast(bloomRadius)); @@ -4744,6 +4764,7 @@ void ResetPointLightBloom(ArkUINodeHandle node) #ifdef POINT_LIGHT_ENABLE auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "shadow"); ViewAbstract::SetBloom(frameNode, 0.0f); Shadow shadow; shadow.SetBlurRadius(0); @@ -4763,6 +4784,7 @@ void SetClipShape( { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "clipShape"); if (std::strcmp(type, "rect") == 0) { auto shape = AceType::MakeRefPtr(); auto width = Dimension(attribute[NUM_0], static_cast(unit)); @@ -4816,6 +4838,7 @@ void SetClipPath(ArkUINodeHandle node, ArkUI_CharPtr type, const ArkUI_Float32 ( { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "clipShape"); auto path = AceType::MakeRefPtr(); auto width = Dimension((*attribute)[NUM_0], static_cast(unit)); auto height = Dimension((*attribute)[NUM_1], static_cast(unit)); @@ -5332,6 +5355,7 @@ void SetMaskShape(ArkUINodeHandle node, ArkUI_CharPtr type, ArkUI_Uint32 fill, A { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "maskShape"); std::string shapeType(type); auto strokeWidth_ = Dimension(strokeWidth, static_cast(unit)); if (shapeType == "rect") { @@ -5398,6 +5422,7 @@ void SetMaskPath(ArkUINodeHandle node, ArkUI_CharPtr type, ArkUI_Uint32 fill, Ar auto* frameNode = reinterpret_cast(node); auto strokeWidth_ = Dimension(strokeWidth, static_cast(unit)); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "maskShape"); auto path = AceType::MakeRefPtr(); auto width = Dimension((*attribute)[NUM_0], static_cast(unit)); auto height = Dimension((*attribute)[NUM_1], static_cast(unit)); @@ -5415,6 +5440,7 @@ void SetProgressMask(ArkUINodeHandle node, const ArkUI_Float32* attribute, ArkUI { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "ProgressMask"); auto progressMask = AceType::MakeRefPtr(); int value = attribute[NUM_0]; int total = attribute[NUM_1]; @@ -5547,6 +5573,7 @@ void SetOutlineColor(ArkUINodeHandle node, const uint32_t* values, int32_t value { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "outerBorderColor"); int32_t colorOffset = NUM_0; NG::BorderColorProperty borderColors; SetOptionalBorderColor(borderColors.topColor, values, valuesSize, colorOffset); @@ -5600,6 +5627,7 @@ void SetOutlineRadius(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t CHECK_NULL_VOID(frameNode); int32_t radiusOffset = NUM_0; + ViewAbstractModelNG::RemoveResObj(frameNode, "outerBorderRadius"); NG::BorderRadiusProperty borderRadius; SetOptionalBorder(borderRadius.radiusTopLeft, values, valuesSize, radiusOffset); SetOptionalBorder(borderRadius.radiusTopRight, values, valuesSize, radiusOffset); @@ -5625,6 +5653,7 @@ void SetOutlineWidth(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "outerBorderWidth"); int32_t offset = NUM_0; NG::BorderWidthProperty borderWidth; @@ -5645,6 +5674,7 @@ void SetOutlineWidthFloat(ArkUINodeHandle node, ArkUI_Float32 left, ArkUI_Float3 { auto* frameNode = reinterpret_cast(node); CHECK_NULL_VOID(frameNode); + ViewAbstractModelNG::RemoveResObj(frameNode, "outerBorderWidth"); NG::BorderWidthProperty borderWidth; borderWidth.leftDimen = Dimension(left, DimensionUnit::VP); borderWidth.topDimen = Dimension(top, DimensionUnit::VP); @@ -5731,6 +5761,9 @@ void SetOutline(ArkUINodeHandle node, const ArkUI_Float32* values, int32_t value if ((values == nullptr) || (valuesSize != NUM_24) || (colorAndStyle == nullptr) || colorAndStyleSize != NUM_16) { return; } + ViewAbstractModelNG::RemoveResObj(frameNode, "outerBorderWidth"); + ViewAbstractModelNG::RemoveResObj(frameNode, "outerBorderColor"); + ViewAbstractModelNG::RemoveResObj(frameNode, "outerBorderRadius"); auto objs = *(reinterpret_cast>*>(resRawPtr)); int32_t offset = NUM_0; // offset for outline width and outline radius -- Gitee