diff --git a/frameworks/core/interfaces/native/implementation/frame_node_peer_impl.h b/frameworks/core/interfaces/native/implementation/frame_node_peer_impl.h index 516f31c096c7fefc1b24d143b4c9fce892d6975f..f99c2072e367a187064b29c6da443cd0cf7fc8ec 100644 --- a/frameworks/core/interfaces/native/implementation/frame_node_peer_impl.h +++ b/frameworks/core/interfaces/native/implementation/frame_node_peer_impl.h @@ -95,7 +95,7 @@ struct FrameNodePeer { RenderNodePeer* GetRenderNodePeer() { - return RenderNodePeer::Create(node); + return OHOS::Ace::NG::PeerUtils::CreatePeer(node); } }; #endif // FOUNDATION_ARKUI_ACE_ENGINE_FRAMEWORKS_CORE_INTERFACES_NATIVE_IMPL_FRAME_NODE_PEER_IMPL_H diff --git a/frameworks/core/interfaces/native/implementation/render_node_accessor.cpp b/frameworks/core/interfaces/native/implementation/render_node_accessor.cpp index b1880a1f4dae969f492498c8db3d91bc07741ede..f71ee0cb00faa14b5e7f3d656fa62691e441acc4 100644 --- a/frameworks/core/interfaces/native/implementation/render_node_accessor.cpp +++ b/frameworks/core/interfaces/native/implementation/render_node_accessor.cpp @@ -23,11 +23,408 @@ #include "core/components_ng/base/frame_node.h" #include "core/components_ng/pattern/render_node/render_node_pattern.h" #include "core/interfaces/native/implementation/render_node_peer_impl.h" +#include "core/interfaces/native/implementation/shape_clip_peer.h" +#include "core/interfaces/native/implementation/shape_mask_peer.h" #include "core/interfaces/native/utility/callback_helper.h" #include "core/interfaces/native/utility/converter.h" +#include "core/interfaces/native/utility/reverse_converter.h" #include "core/components_ng/base/view_abstract_model_static.h" +#include "core/interfaces/native/utility/validators.h" namespace OHOS::Ace::NG { +namespace Converter { +struct Circle { + float centerX; + float centerY; + float radius; +}; + +template<> +OHOS::Ace::NG::RectF Convert(const Ark_Rect& value) +{ + auto left = Converter::Convert(value.left); + auto top = Converter::Convert(value.top); + auto right = Converter::Convert(value.right); + auto bottom = Converter::Convert(value.bottom); + return { left, top, right - left, bottom - top }; +} + +template<> +Converter::Circle Convert(const Ark_Circle& src) +{ + return { + Converter::Convert(src.centerX), + Converter::Convert(src.centerY), + Converter::Convert(src.radius) + }; +} + +template<> +OHOS::Ace::NG::RoundRect Convert(const Ark_RoundRect& value) +{ + auto rect = Converter::Convert(value.rect); + auto corners = Converter::Convert(value.corners); + + RoundRect roundRectInstance; + roundRectInstance.SetCornerRadius(RoundRect::CornerPos::TOP_LEFT_POS, + corners.topLeftRadius.GetX().Value(), + corners.topLeftRadius.GetY().Value()); + roundRectInstance.SetCornerRadius(RoundRect::CornerPos::TOP_RIGHT_POS, + corners.topRightRadius.GetX().Value(), + corners.topRightRadius.GetY().Value()); + roundRectInstance.SetCornerRadius(RoundRect::CornerPos::BOTTOM_LEFT_POS, + corners.bottomLeftRadius.GetX().Value(), + corners.bottomLeftRadius.GetY().Value()); + roundRectInstance.SetCornerRadius(RoundRect::CornerPos::BOTTOM_RIGHT_POS, + corners.bottomRightRadius.GetX().Value(), + corners.bottomRightRadius.GetY().Value()); + + auto left = Converter::Convert(rect.Left()); + auto top = Converter::Convert(rect.Top()); + auto right = Converter::Convert(rect.Right()); + auto bottom = Converter::Convert(rect.Bottom()); + RectF rectValue(left, top, right - left, bottom - top); + roundRectInstance.SetRect(rectValue); + + return roundRectInstance; +} + +template<> +Size Convert(const Ark_Size& value) +{ + auto width = Converter::OptConvert(value.width); + auto height = Converter::OptConvert(value.height); + Validator::ValidateNonNegative(width); + Validator::ValidateNonNegative(height); + return Size { width.value_or(0), height.value_or(0) }; +} + +template<> +Rect Convert(const Ark_Frame& value) +{ + auto x = Converter::Convert(value.x); + auto y = Converter::Convert(value.y); + auto width = Converter::OptConvert(value.width); + auto height = Converter::OptConvert(value.height); + Validator::ValidateNonNegative(width); + Validator::ValidateNonNegative(height); + return Rect { x, y, width.value_or(0), height.value_or(0) }; +} + +template<> +VectorF Convert(const Ark_Vector2& value) +{ + return { + Converter::Convert(value.x), + Converter::Convert(value.y) + }; +} + +template<> +Vector3F Convert(const Ark_Vector3& value) +{ + return { + Converter::Convert(value.x), + Converter::Convert(value.y), + Converter::Convert(value.z) + }; +} + +template<> +Matrix4 Convert(const Ark_Matrix4& value) +{ + return { + Converter::Convert(value.value0), + Converter::Convert(value.value1), + Converter::Convert(value.value2), + Converter::Convert(value.value3), + Converter::Convert(value.value4), + Converter::Convert(value.value5), + Converter::Convert(value.value6), + Converter::Convert(value.value7), + Converter::Convert(value.value8), + Converter::Convert(value.value9), + Converter::Convert(value.value10), + Converter::Convert(value.value11), + Converter::Convert(value.value12), + Converter::Convert(value.value13), + Converter::Convert(value.value14), + Converter::Convert(value.value15) + }; +} + +template<> +TranslateOptions Convert(const Ark_Vector2& value) +{ + return { + Converter::Convert(value.x), + Converter::Convert(value.y), + CalcDimension(0.f) + }; +} + +template<> +Offset Convert(const Ark_Vector2& value) +{ + return Offset{ + Converter::Convert(value.x), + Converter::Convert(value.y) + }; +} + +template<> +BorderWidthProperty Convert(const Ark_EdgesNumber& src) +{ + BorderWidthProperty property; + property.leftDimen = OptConvert(src.left); + property.topDimen = OptConvert(src.top); + property.rightDimen = OptConvert(src.right); + property.bottomDimen = OptConvert(src.bottom); + property.multiValued = true; + return property; +} + +template<> +BorderRadiusProperty Convert(const Ark_BorderRadiuses_graphics& src) +{ + BorderRadiusProperty property; + property.radiusTopLeft = OptConvert(src.topLeft); + property.radiusTopRight = OptConvert(src.topRight); + property.radiusBottomLeft = OptConvert(src.bottomLeft); + property.radiusBottomRight = OptConvert(src.bottomRight); + return property; +} + +template<> +Color Convert(const Ark_Length& src) +{ + if (src.type == Ark_Tag::INTEROP_TAG_RESOURCE) { + auto resource = ArkValue(src); + ResourceConverter converter(resource); + return converter.ToColor().value_or(Color()); + } else { + return Color(static_cast(src.value)); + } +} + +template<> +RefPtr Convert(const Ark_Rect& src) +{ + const auto two = 2; + auto dst = AceType::MakeRefPtr(); + float left = Converter::Convert(src.left); + float top = Converter::Convert(src.top); + float right = Converter::Convert(src.right); + float bottom = Converter::Convert(src.bottom); + auto width = Dimension(right - left); + auto height = Dimension(bottom - top); + auto deltaX = Dimension(left); + auto deltaY = Dimension(top); + auto position = DimensionOffset(deltaX, deltaY); + dst->SetWidth(width); + dst->SetHeight(height); + dst->SetPosition(position); + dst->SetRadiusX(Dimension((right - left) / two)); + dst->SetRadiusY(Dimension((bottom - top) / two)); + dst->SetAxisX(Dimension(left + (right - left) / two)); + dst->SetAxisY(Dimension(top + (bottom - top) / two)); + return dst; +} + +void AssignArkValue(Ark_Vector2& dst, const Offset& src) +{ + dst.x = Converter::ArkValue(src.GetX()); + dst.y = Converter::ArkValue(src.GetY()); +} + +void AssignArkValue(Ark_Vector2& dst, const DimensionOffset& src) +{ + dst.x = Converter::ArkValue(src.GetX()); + dst.y = Converter::ArkValue(src.GetY()); +} + +void AssignArkValue(Ark_Vector2& dst, const VectorF& src) +{ + dst.x = Converter::ArkValue(src.x); + dst.y = Converter::ArkValue(src.y); +} + +void AssignArkValue(Ark_Vector2& dst, const TranslateOptions& src) +{ + dst.x = Converter::ArkValue(src.x); + dst.y = Converter::ArkValue(src.y); +} + +void AssignArkValue(Ark_Vector3& dst, const Vector3F& src) +{ + dst.x = Converter::ArkValue(src.x); + dst.y = Converter::ArkValue(src.y); + dst.z = Converter::ArkValue(src.z); +} + +void AssignArkValue(Ark_Matrix4& dst, const Matrix4& src) +{ + constexpr int32_t index0 = 0; + constexpr int32_t index1 = 1; + constexpr int32_t index2 = 2; + constexpr int32_t index3 = 3; + dst.value0 = Converter::ArkValue(src.Get(index0, index0)); + dst.value1 = Converter::ArkValue(src.Get(index0, index1)); + dst.value2 = Converter::ArkValue(src.Get(index0, index2)); + dst.value3 = Converter::ArkValue(src.Get(index0, index3)); + dst.value4 = Converter::ArkValue(src.Get(index1, index0)); + dst.value5 = Converter::ArkValue(src.Get(index1, index1)); + dst.value6 = Converter::ArkValue(src.Get(index1, index2)); + dst.value7 = Converter::ArkValue(src.Get(index1, index3)); + dst.value8 = Converter::ArkValue(src.Get(index2, index0)); + dst.value9 = Converter::ArkValue(src.Get(index2, index1)); + dst.value10 = Converter::ArkValue(src.Get(index2, index2)); + dst.value11 = Converter::ArkValue(src.Get(index2, index3)); + dst.value12 = Converter::ArkValue(src.Get(index3, index0)); + dst.value13 = Converter::ArkValue(src.Get(index3, index1)); + dst.value14 = Converter::ArkValue(src.Get(index3, index2)); + dst.value15 = Converter::ArkValue(src.Get(index3, index3)); +} + +void AssignArkValue(Ark_BorderStyle& dst, const BorderStyle& src) +{ + switch (src) { + case OHOS::Ace::BorderStyle::SOLID: dst = ARK_BORDER_STYLE_SOLID; break; + case OHOS::Ace::BorderStyle::DASHED: dst = ARK_BORDER_STYLE_DASHED; break; + case OHOS::Ace::BorderStyle::DOTTED: dst = ARK_BORDER_STYLE_DOTTED; break; + default: dst = static_cast(-1); + } +} + +void AssignArkValue(Ark_EdgeStyles& dst, const BorderStyleProperty& src) +{ + if (src.styleTop.has_value()) { + dst.top = Converter::ArkValue(src.styleTop.value()); + } else { + dst.top = Converter::ArkValue(Ark_Empty()); + } + + if (src.styleRight.has_value()) { + dst.right = Converter::ArkValue(src.styleRight.value()); + } else { + dst.right = Converter::ArkValue(Ark_Empty()); + } + + if (src.styleBottom.has_value()) { + dst.bottom = Converter::ArkValue(src.styleBottom.value()); + } else { + dst.bottom = Converter::ArkValue(Ark_Empty()); + } + + if (src.styleLeft.has_value()) { + dst.left = Converter::ArkValue(src.styleLeft.value()); + } else { + dst.left = Converter::ArkValue(Ark_Empty()); + } +} + +void AssignArkValue(Ark_EdgesNumber& dst, const BorderWidthProperty& src) +{ + if (src.topDimen.has_value()) { + dst.top = Converter::ArkValue(src.topDimen.value()); + } else { + dst.top = Converter::ArkValue(Ark_Empty()); + } + + if (src.rightDimen.has_value()) { + dst.right = Converter::ArkValue(src.rightDimen.value()); + } else { + dst.right = Converter::ArkValue(Ark_Empty()); + } + + if (src.bottomDimen.has_value()) { + dst.bottom = Converter::ArkValue(src.bottomDimen.value()); + } else { + dst.bottom = Converter::ArkValue(Ark_Empty()); + } + + if (src.leftDimen.has_value()) { + dst.left = Converter::ArkValue(src.leftDimen.value()); + } else { + dst.left = Converter::ArkValue(Ark_Empty()); + } +} + +void AssignArkValue(Ark_BorderRadiuses_graphics& dst, const BorderRadiusProperty& src) +{ + if (src.radiusTopLeft.has_value()) { + dst.topLeft = Converter::ArkValue(src.radiusTopLeft.value()); + } else { + dst.topLeft = Converter::ArkValue(0); + } + + if (src.radiusTopRight.has_value()) { + dst.topRight = Converter::ArkValue(src.radiusTopRight.value()); + } else { + dst.topRight = Converter::ArkValue(0); + } + + if (src.radiusBottomRight.has_value()) { + dst.bottomRight = Converter::ArkValue(src.radiusBottomRight.value()); + } else { + dst.bottomRight = Converter::ArkValue(0); + } + + if (src.radiusBottomLeft.has_value()) { + dst.bottomLeft = Converter::ArkValue(src.radiusBottomLeft.value()); + } else { + dst.bottomLeft = Converter::ArkValue(0); + } +} + +void AssignArkValue(Ark_EdgesNumber& dst, const BorderColorProperty& src) +{ + if (src.topColor.has_value()) { + dst.top = Converter::ArkValue(static_cast(src.topColor.value().GetValue())); + } else { + dst.top = Converter::ArkValue(Ark_Empty()); + } + + if (src.rightColor.has_value()) { + dst.right = Converter::ArkValue(static_cast(src.rightColor.value().GetValue())); + } else { + dst.right = Converter::ArkValue(Ark_Empty()); + } + + if (src.bottomColor.has_value()) { + dst.bottom = Converter::ArkValue(static_cast(src.bottomColor.value().GetValue())); + } else { + dst.bottom = Converter::ArkValue(Ark_Empty()); + } + + if (src.leftColor.has_value()) { + dst.left = Converter::ArkValue(static_cast(src.leftColor.value().GetValue())); + } else { + dst.left = Converter::ArkValue(Ark_Empty()); + } +} + +template<> +void AssignCast(std::optional& dst, const Ark_LengthMetricsUnit& src) +{ + switch (src) { + case ARK_LENGTH_METRICS_UNIT_DEFAULT: dst = RenderNodePeer::LengthMetricsUnit::DEFAULT; break; + case ARK_LENGTH_METRICS_UNIT_PX: dst = RenderNodePeer::LengthMetricsUnit::PX; break; + default: LOGE("Unexpected enum value in Ark_LengthMetricsUnit: %{public}d", src); + } +} + +void AssignArkValue(Ark_LengthMetricsUnit& dst, const RenderNodePeer::LengthMetricsUnit& src) +{ + switch (src) { + case RenderNodePeer::LengthMetricsUnit::DEFAULT: dst = ARK_LENGTH_METRICS_UNIT_DEFAULT; break; + case RenderNodePeer::LengthMetricsUnit::PX: dst = ARK_LENGTH_METRICS_UNIT_PX; break; + default: dst = static_cast(-1); + LOGE("Unexpected enum value in RenderNodePeer::LengthMetricsUnit: %{public}d", src); + } +} +} + namespace GeneratedModifier { namespace { constexpr int32_t ARK_UNION_UNDEFINED = 1; @@ -47,13 +444,41 @@ DimensionUnit ConvertLengthMetricsUnitToDimensionUnit(Ark_Int32 unitValue, Dimen } } // namespace namespace RenderNodeAccessor { -void DestroyPeerImpl(Ark_RenderNode peer) {} +RefPtr GetParentNode(const RefPtr& nodeRef) +{ + CHECK_NULL_RETURN(nodeRef, nullptr); + auto parent = nodeRef->GetParent(); + while (parent != nullptr && !AceType::InstanceOf(parent)) { + parent = parent->GetParent(); + } + return (parent == nullptr || parent->GetTag() == V2::PAGE_ETS_TAG || parent->GetTag() == V2::STAGE_ETS_TAG) + ? nullptr : AceType::DynamicCast(parent); +} + +RefPtr GetRenderContext(const RefPtr& node, bool checkProxy = true) +{ + CHECK_NULL_RETURN(node, nullptr); + if (checkProxy) { + CHECK_NULL_RETURN(node->GetTag() != "BuilderProxyNode", nullptr); + } + return node->GetRenderContext(); +} + +RefPtr GetBasicShape(Ark_BaseShape peer) +{ + return peer ? peer->shape : nullptr; +} + +void DestroyPeerImpl(Ark_RenderNode peer) +{ + PeerUtils::DestroyPeer(peer); +} Ark_RenderNode CtorImpl(Ark_Int32 nodeId, const DrawCallbackFunc* value) { auto frameNode = NG::FrameNode::GetOrCreateFrameNode( V2::RENDER_NODE_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr(); }); frameNode->SetIsArkTsRenderNode(true); - auto renderNodePeer = RenderNodePeer::Create(frameNode); + auto renderNodePeer = PeerUtils::CreatePeer(frameNode); return renderNodePeer; } Ark_NativePointer GetFinalizerImpl() @@ -68,10 +493,12 @@ void AppendChildImpl(Ark_RenderNode peer, Ark_RenderNode node) } auto parent = peer->GetFrameNode(); auto child = node->GetFrameNode(); - if (parent && child) { - parent->AddChild(child); - parent->MarkNeedFrameFlushDirty(NG::PROPERTY_UPDATE_MEASURE); + CHECK_NULL_VOID(parent && child); + if (child->GetParent() != nullptr) { + return; } + parent->AddChild(child); + parent->MarkNeedFrameFlushDirty(NG::PROPERTY_UPDATE_MEASURE); } void InsertChildAfterImpl(Ark_RenderNode peer, Ark_RenderNode child, const Ark_Union_RenderNode_Undefined* sibling) { @@ -79,14 +506,24 @@ void InsertChildAfterImpl(Ark_RenderNode peer, Ark_RenderNode child, const Ark_U LOGW("This renderNode or child is nullptr when InsertChildAfter !"); return; } - if (!sibling || sibling->selector == ARK_UNION_UNDEFINED || !sibling->value0) { + if (!sibling) { LOGW("Sibling node is nullptr or undefined when InsertChildAfter !"); return; } auto currentNode = peer->GetFrameNode(); auto childNode = child->GetFrameNode(); - auto siblingNode = sibling->value0->GetFrameNode(); - auto index = currentNode->GetChildIndex(siblingNode); + CHECK_NULL_VOID(currentNode && childNode); + if (childNode->GetParent() != nullptr) { + return; + } + + auto siblingOpt = Converter::OptConvert(*sibling); + auto index = -1; + if (siblingOpt.has_value()) { + auto siblingNode = siblingOpt.value()->GetFrameNode(); + index = currentNode->GetChildIndex(siblingNode); + } + currentNode->AddChild(childNode, index + 1); currentNode->MarkNeedFrameFlushDirty(NG::PROPERTY_UPDATE_MEASURE); } @@ -98,10 +535,9 @@ void RemoveChildImpl(Ark_RenderNode peer, Ark_RenderNode node) } auto currentNode = peer->GetFrameNode(); auto childNode = node->GetFrameNode(); - if (currentNode && childNode) { - currentNode->RemoveChild(childNode); - currentNode->MarkNeedFrameFlushDirty(NG::PROPERTY_UPDATE_MEASURE); - } + CHECK_NULL_VOID(currentNode && childNode); + currentNode->RemoveChild(childNode); + currentNode->MarkNeedFrameFlushDirty(NG::PROPERTY_UPDATE_MEASURE); } void ClearChildrenImpl(Ark_RenderNode peer) { @@ -110,28 +546,68 @@ void ClearChildrenImpl(Ark_RenderNode peer) return; } auto currentNode = peer->GetFrameNode(); - if (currentNode) { - currentNode->Clean(); - currentNode->MarkNeedFrameFlushDirty(NG::PROPERTY_UPDATE_MEASURE); - } + CHECK_NULL_VOID(currentNode); + currentNode->Clean(); + currentNode->MarkNeedFrameFlushDirty(NG::PROPERTY_UPDATE_MEASURE); } Ark_Union_RenderNode_Undefined GetChildImpl(Ark_RenderNode peer, const Ark_Number* index) { - return {}; + auto errorValue = Converter::ArkUnion(Ark_Undefined{}); + CHECK_NULL_RETURN(peer && index, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto indexInt = Converter::Convert(*index); + CHECK_NULL_RETURN(indexInt >= 0, errorValue); + LOGW("FrameNodeAccessor::GetChildImpl work only for case: IsExpanded is false"); + auto retValue = PeerUtils::CreatePeer( + frameNode->GetFrameNodeChildByIndex(indexInt, false, false)); + return Converter::ArkUnion(retValue); } Ark_Union_RenderNode_Undefined GetFirstChildImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkUnion(Ark_Undefined{}); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto child = frameNode->GetFirstChild(); + CHECK_NULL_RETURN(child, errorValue); + auto retValue = PeerUtils::CreatePeer(AceType::DynamicCast(child)); + return Converter::ArkUnion(retValue); } Ark_Union_RenderNode_Undefined GetNextSiblingImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkUnion(Ark_Undefined{}); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto parent = GetParentNode(frameNode); + CHECK_NULL_RETURN(parent, errorValue); + LOGW("RenderNodeAccessor::GetNextSiblingImpl work only for case: IsExpanded is false"); + auto index = parent->GetFrameNodeIndex(frameNode, false); + CHECK_NULL_RETURN(index >= 0, errorValue); + auto sibling = parent->GetFrameNodeChildByIndex(index + 1, false, false); + auto retValue = PeerUtils::CreatePeer(sibling); + return Converter::ArkUnion(retValue); } Ark_Union_RenderNode_Undefined GetPreviousSiblingImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkUnion(Ark_Undefined{}); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto parent = GetParentNode(frameNode); + CHECK_NULL_RETURN(parent, errorValue); + LOGW("RenderNodeAccessor::GetPreviousSiblingImpl work only for case: IsExpanded is false"); + auto index = parent->GetFrameNodeIndex(frameNode, false); + CHECK_NULL_RETURN(index > 0, errorValue); + auto sibling = parent->GetFrameNodeChildByIndex(index - 1, false, false); + auto retValue = PeerUtils::CreatePeer(sibling); + return Converter::ArkUnion(retValue); +} +void DrawImpl(Ark_RenderNode peer, const Ark_DrawContext* context) +{ + LOGW("RenderNodeAccessor::DrawImpl is not implemented."); } -void DrawImpl(Ark_RenderNode peer, const Ark_DrawContext* context) {} void InvalidateImpl(Ark_RenderNode peer) { if (!peer) { @@ -142,15 +618,20 @@ void InvalidateImpl(Ark_RenderNode peer) CHECK_NULL_VOID(frameNode); auto pattern = frameNode->GetPattern(); CHECK_NULL_VOID(pattern); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); pattern->Invalidate(); renderContext->RequestNextFrame(); } -void DisposeImpl(Ark_RenderNode peer) {} -Ark_Number GetBackgroundColorImpl(Ark_RenderNode peer) +void DisposeImpl(Ark_RenderNode peer) { - return {}; + CHECK_NULL_VOID(peer); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_VOID(frameNode); + auto parent = GetParentNode(frameNode); + CHECK_NULL_VOID(parent); + parent->RemoveChild(frameNode); + parent->MarkNeedFrameFlushDirty(NG::PROPERTY_UPDATE_MEASURE); } void SetRectMaskImpl(Ark_RenderNode peer, const Ark_Rect* rect, const Ark_Number* fillColor, const Ark_Number* strokeColor, const Ark_Number* strokeWidth) @@ -159,16 +640,13 @@ void SetRectMaskImpl(Ark_RenderNode peer, const Ark_Rect* rect, const Ark_Number LOGW("This renderNode is nullptr when SetRectMask !"); return; } + CHECK_NULL_VOID(rect || fillColor || strokeColor || strokeWidth); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); - auto left = Converter::Convert(rect->left); - auto top = Converter::Convert(rect->top); - auto right = Converter::Convert(rect->right); - auto bottom = Converter::Convert(rect->bottom); - RectF rectF(left, top, right - left, bottom - top); + const auto rectF = Converter::Convert(*rect); ShapeMaskProperty property { Converter::Convert(*fillColor), Converter::Convert(*strokeColor), Converter::Convert(*strokeWidth) }; renderContext->SetRectMask(rectF, property); @@ -181,23 +659,20 @@ void SetCircleMaskImpl(Ark_RenderNode peer, const Ark_Circle* circle, const Ark_ LOGW("This renderNode is nullptr when SetCircleMask !"); return; } + CHECK_NULL_VOID(circle || fillColor || strokeColor || strokeWidth); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); - auto centerXValue = Converter::Convert(circle->centerX); - auto centerYValue = Converter::Convert(circle->centerY); - auto radiusValue = Converter::Convert(circle->radius); - + auto circleConv = Converter::Convert(*circle); Circle circleValue; - Dimension centerX(centerXValue, DimensionUnit::PX); + Dimension centerX(circleConv.centerX, DimensionUnit::PX); circleValue.SetAxisX(centerX); - Dimension centerY(centerYValue, DimensionUnit::PX); + Dimension centerY(circleConv.centerY, DimensionUnit::PX); circleValue.SetAxisY(centerY); - Dimension radius(radiusValue, DimensionUnit::PX); + Dimension radius(circleConv.radius, DimensionUnit::PX); circleValue.SetRadius(radius); - ShapeMaskProperty property { Converter::Convert(*fillColor), Converter::Convert(*strokeColor), Converter::Convert(*strokeWidth) }; @@ -211,31 +686,13 @@ void SetRoundRectMaskImpl(Ark_RenderNode peer, const Ark_RoundRect* roundRect, c LOGW("This renderNode is nullptr when SetRoundRectMask !"); return; } + CHECK_NULL_VOID(roundRect || fillColor || strokeColor || strokeWidth); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); - auto rect = roundRect->rect; - auto corners = roundRect->corners; - - RoundRect roundRectInstance; - roundRectInstance.SetCornerRadius(RoundRect::CornerPos::TOP_LEFT_POS, Converter::Convert(corners.topLeft.x), - Converter::Convert(corners.topLeft.y)); - roundRectInstance.SetCornerRadius(RoundRect::CornerPos::TOP_RIGHT_POS, - Converter::Convert(corners.topRight.x), Converter::Convert(corners.topRight.y)); - roundRectInstance.SetCornerRadius(RoundRect::CornerPos::BOTTOM_LEFT_POS, - Converter::Convert(corners.bottomLeft.x), Converter::Convert(corners.bottomLeft.y)); - roundRectInstance.SetCornerRadius(RoundRect::CornerPos::BOTTOM_RIGHT_POS, - Converter::Convert(corners.bottomRight.x), Converter::Convert(corners.bottomRight.y)); - - auto left = Converter::Convert(rect.left); - auto top = Converter::Convert(rect.top); - auto right = Converter::Convert(rect.right); - auto bottom = Converter::Convert(rect.bottom); - RectF rectValue(left, top, right - left, bottom - top); - roundRectInstance.SetRect(rectValue); - + auto roundRectInstance = Converter::Convert(*roundRect); ShapeMaskProperty property { Converter::Convert(*fillColor), Converter::Convert(*strokeColor), Converter::Convert(*strokeWidth) }; @@ -249,16 +706,13 @@ void SetOvalMaskImpl(Ark_RenderNode peer, const Ark_Rect* rect, const Ark_Number LOGW("This renderNode is nullptr when SetOvalMask !"); return; } + CHECK_NULL_VOID(rect || fillColor || strokeColor || strokeWidth); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); - auto left = Converter::Convert(rect->left); - auto top = Converter::Convert(rect->top); - auto right = Converter::Convert(rect->right); - auto bottom = Converter::Convert(rect->bottom); - RectF rectValue(left, top, right - left, bottom - top); + const auto rectValue = Converter::Convert(*rect); ShapeMaskProperty property { Converter::Convert(*fillColor), Converter::Convert(*strokeColor), Converter::Convert(*strokeWidth) }; @@ -273,9 +727,10 @@ void SetPathImpl(Ark_RenderNode peer, const Ark_CommandPath* path, const Ark_Num LOGW("This renderNode is nullptr when SetPath !"); return; } + CHECK_NULL_VOID(path || fillColor || strokeColor || strokeWidth); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); auto pathValue = Converter::Convert(*path); @@ -292,17 +747,13 @@ void SetRectClipImpl(Ark_RenderNode peer, const Ark_Rect* rect) LOGW("This renderNode is nullptr when SetRectClip !"); return; } + CHECK_NULL_VOID(rect); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); - auto left = Converter::Convert(rect->left); - auto top = Converter::Convert(rect->top); - auto right = Converter::Convert(rect->right); - auto bottom = Converter::Convert(rect->bottom); - RectF rectValue(left, top, right - left, bottom - top); - + const auto rectValue = Converter::Convert(*rect); renderContext->ClipWithRect(rectValue); renderContext->RequestNextFrame(); } @@ -312,21 +763,19 @@ void SetCircleClipImpl(Ark_RenderNode peer, const Ark_Circle* circle) LOGW("This renderNode is nullptr when SetCircleClip !"); return; } + CHECK_NULL_VOID(circle); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); - auto centerXValue = Converter::Convert(circle->centerX); - auto centerYValue = Converter::Convert(circle->centerY); - auto radiusValue = Converter::Convert(circle->radius); - + auto circleConv = Converter::Convert(*circle); Circle circleValue; - Dimension centerX(centerXValue, DimensionUnit::PX); + Dimension centerX(circleConv.centerX, DimensionUnit::PX); circleValue.SetAxisX(centerX); - Dimension centerY(centerYValue, DimensionUnit::PX); + Dimension centerY(circleConv.centerY, DimensionUnit::PX); circleValue.SetAxisY(centerY); - Dimension radius(radiusValue, DimensionUnit::PX); + Dimension radius(circleConv.radius, DimensionUnit::PX); circleValue.SetRadius(radius); renderContext->ClipWithCircle(circleValue); @@ -338,31 +787,13 @@ void SetRoundRectClipImpl(Ark_RenderNode peer, const Ark_RoundRect* roundRect) LOGW("This renderNode is nullptr when SetRoundRectClip !"); return; } + CHECK_NULL_VOID(roundRect); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); - auto rect = roundRect->rect; - auto corners = roundRect->corners; - - RoundRect roundRectInstance; - roundRectInstance.SetCornerRadius(RoundRect::CornerPos::TOP_LEFT_POS, Converter::Convert(corners.topLeft.x), - Converter::Convert(corners.topLeft.y)); - roundRectInstance.SetCornerRadius(RoundRect::CornerPos::TOP_RIGHT_POS, - Converter::Convert(corners.topRight.x), Converter::Convert(corners.topRight.y)); - roundRectInstance.SetCornerRadius(RoundRect::CornerPos::BOTTOM_LEFT_POS, - Converter::Convert(corners.bottomLeft.x), Converter::Convert(corners.bottomLeft.y)); - roundRectInstance.SetCornerRadius(RoundRect::CornerPos::BOTTOM_RIGHT_POS, - Converter::Convert(corners.bottomRight.x), Converter::Convert(corners.bottomRight.y)); - - auto left = Converter::Convert(rect.left); - auto top = Converter::Convert(rect.top); - auto right = Converter::Convert(rect.right); - auto bottom = Converter::Convert(rect.bottom); - RectF rectValue(left, top, right - left, bottom - top); - roundRectInstance.SetRect(rectValue); - + auto roundRectInstance = Converter::Convert(*roundRect); renderContext->ClipWithRoundRect(roundRectInstance); renderContext->RequestNextFrame(); } @@ -372,17 +803,13 @@ void SetOvalClipImpl(Ark_RenderNode peer, const Ark_Rect* rect) LOGW("This renderNode is nullptr when SetOvalClip !"); return; } + CHECK_NULL_VOID(rect); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); - auto left = Converter::Convert(rect->left); - auto top = Converter::Convert(rect->top); - auto right = Converter::Convert(rect->right); - auto bottom = Converter::Convert(rect->bottom); - RectF rectValue(left, top, right - left, bottom - top); - + const auto rectValue = Converter::Convert(*rect); renderContext->ClipWithOval(rectValue); renderContext->RequestNextFrame(); } @@ -392,9 +819,10 @@ void SetPathClipImpl(Ark_RenderNode peer, const Ark_CommandPath* path) LOGW("This renderNode is nullptr when SetPathClip !"); return; } + CHECK_NULL_VOID(path); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); + auto renderContext = GetRenderContext(frameNode); CHECK_NULL_VOID(renderContext); auto pathValue = Converter::Convert(*path); @@ -402,24 +830,36 @@ void SetPathClipImpl(Ark_RenderNode peer, const Ark_CommandPath* path) renderContext->SetClipBoundsWithCommands(pathValue); renderContext->RequestNextFrame(); } +Ark_Number GetBackgroundColorImpl(Ark_RenderNode peer) +{ + auto errorValue = Converter::ArkValue(static_cast(Color::TRANSPARENT.GetValue())); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto retValue = ViewAbstract::GetBackgroundColor(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(static_cast(retValue.GetValue())); +} void SetBackgroundColorImpl(Ark_RenderNode peer, const Ark_Number* backgroundColor) { if (!peer) { LOGW("This renderNode is nullptr when SetBackgroundColor !"); return; } + CHECK_NULL_VOID(backgroundColor); auto colorValue = Converter::Convert(*backgroundColor); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetBackgroundColor(colorValue); - renderContext->RequestNextFrame(); + ViewAbstractModelStatic::SetBackgroundColor(Referenced::RawPtr(frameNode), Color(colorValue)); } Ark_Boolean GetClipToFrameImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(true); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto clipValue = ViewAbstract::GetClip(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(clipValue); } void SetClipToFrameImpl(Ark_RenderNode peer, Ark_Boolean clipToFrame) { @@ -431,14 +871,16 @@ void SetClipToFrameImpl(Ark_RenderNode peer, Ark_Boolean clipToFrame) auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetClipToFrame(useClip); - renderContext->RequestNextFrame(); + ViewAbstractModelStatic::SetClipEdge(Referenced::RawPtr(frameNode), useClip); } Ark_Number GetOpacityImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(1.f); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto opacityValue = ViewAbstract::GetOpacity(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(static_cast(opacityValue)); } void SetOpacityImpl(Ark_RenderNode peer, const Ark_Number* opacity) { @@ -446,18 +888,47 @@ void SetOpacityImpl(Ark_RenderNode peer, const Ark_Number* opacity) LOGW("This renderNode is nullptr when SetOpacity !"); return; } + CHECK_NULL_VOID(opacity); auto opacityValue = Converter::Convert(*opacity); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetOpacity(opacityValue); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + + if (Container::LessThanAPIVersion(PlatformVersion::VERSION_ELEVEN)) { + if (GreatNotEqual(opacityValue, 1.0f) || LessNotEqual(opacityValue, 0.0f)) { + opacityValue = 1.0f; + } + } else { + opacityValue = std::clamp(opacityValue, 0.0f, 1.0f); + } + ViewAbstract::SetOpacity(Referenced::RawPtr(frameNode), opacityValue); } Ark_Size GetSizeImpl(Ark_RenderNode peer) { - return {}; + Ark_Size retValue = { + .width = Converter::ArkValue(0.f), + .height = Converter::ArkValue(0.f), + }; + + CHECK_NULL_RETURN(peer, retValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, retValue); + auto layoutProperty = frameNode->GetLayoutProperty(); + CHECK_NULL_RETURN(layoutProperty, retValue); + + const auto& constraint = layoutProperty->GetCalcLayoutConstraint(); + CHECK_NULL_RETURN(constraint, retValue); + auto calcSizeConv = constraint->selfIdealSize; + if (calcSizeConv.has_value()) { + auto width = calcSizeConv.value().Width().value_or(CalcLength()).GetDimension(); + auto height = calcSizeConv.value().Height().value_or(CalcLength()).GetDimension(); + retValue = { + .width = Converter::ArkValue(width), + .height = Converter::ArkValue(height) + }; + } + return retValue; } void SetSizeImpl(Ark_RenderNode peer, const Ark_Size* size, const Ark_Int32 unitValue) { @@ -465,8 +936,7 @@ void SetSizeImpl(Ark_RenderNode peer, const Ark_Size* size, const Ark_Int32 unit LOGW("This renderNode is nullptr when SetSize !"); return; } - auto widthValue = Converter::Convert(size->width); - auto heightValue = Converter::Convert(size->height); + auto sizeValue = Converter::Convert(*size); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); @@ -474,12 +944,20 @@ void SetSizeImpl(Ark_RenderNode peer, const Ark_Size* size, const Ark_Int32 unit auto layoutProperty = frameNode->GetLayoutProperty(); CHECK_NULL_VOID(layoutProperty); DimensionUnit unit = ConvertLengthMetricsUnitToDimensionUnit(unitValue, DimensionUnit::VP); - layoutProperty->UpdateUserDefinedIdealSize(CalcSize(CalcLength(widthValue, unit), CalcLength(heightValue, unit))); + layoutProperty->UpdateUserDefinedIdealSize( + CalcSize(CalcLength(sizeValue.Width(), unit), CalcLength(sizeValue.Height(), unit))); frameNode->MarkDirtyNode(NG::PROPERTY_UPDATE_MEASURE); } Ark_Position GetPositionImpl(Ark_RenderNode peer) { - return {}; + auto defaultPosition = OffsetT(Dimension(0, DimensionUnit::VP), Dimension(0, DimensionUnit::VP)); + auto errorValue = Converter::ArkValue(defaultPosition); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + + auto positionValue = ViewAbstract::GetPosition(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(positionValue); } void SetPositionImpl(Ark_RenderNode peer, const Ark_Position* position, const Ark_Int32 unitValue) { @@ -487,26 +965,49 @@ void SetPositionImpl(Ark_RenderNode peer, const Ark_Position* position, const Ar LOGW("This renderNode is nullptr when SetPosition !"); return; } - auto xValue = Converter::Convert(position->x.value); - auto yValue = Converter::Convert(position->y.value); - + CHECK_NULL_VOID(position); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); - const auto& renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->ResetPosition(); DimensionUnit unit = ConvertLengthMetricsUnitToDimensionUnit(unitValue, DimensionUnit::VP); - Dimension x = Dimension(xValue.Value(), unit); - Dimension y = Dimension(yValue.Value(), unit); + auto positionConv = Converter::Convert>(*position); + auto x = std::get<0>(positionConv); + x.SetUnit(unit); + auto y = std::get<1>(positionConv); + y.SetUnit(unit); OffsetT value(x, y); - renderContext->UpdatePosition(value); - renderContext->RequestNextFrame(); + ViewAbstractModelStatic::SetPosition(Referenced::RawPtr(frameNode), value); } Ark_Frame GetFrameImpl(Ark_RenderNode peer) { - return {}; + // The default value is { x: 0, y: 0, width: 0, height: 0 }. + // used as Position + Size + Ark_Frame retValue = { + .x = Converter::ArkValue(0), + .y = Converter::ArkValue(0), + .width = Converter::ArkValue(0), + .height = Converter::ArkValue(0) + }; + + CHECK_NULL_RETURN(peer, retValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, retValue); + auto layoutProperty = frameNode->GetLayoutProperty(); + CHECK_NULL_RETURN(layoutProperty, retValue); + + auto calcSizeConv = layoutProperty->GetCalcLayoutConstraint()->selfIdealSize; + if (calcSizeConv.has_value()) { + auto width = calcSizeConv.value().Width().value_or(CalcLength()).GetDimension(); + auto height = calcSizeConv.value().Height().value_or(CalcLength()).GetDimension(); + retValue.width = Converter::ArkValue(width); + retValue.height = Converter::ArkValue(height); + }; + + auto positionValue = ViewAbstract::GetPosition(Referenced::RawPtr(frameNode)); + retValue.x = Converter::ArkValue(positionValue.GetX()); + retValue.y = Converter::ArkValue(positionValue.GetY()); + return retValue; } void SetFrameImpl(Ark_RenderNode peer, const Ark_Frame* frame) { @@ -514,23 +1015,39 @@ void SetFrameImpl(Ark_RenderNode peer, const Ark_Frame* frame) LOGW("This renderNode is nullptr when SetFrame !"); return; } - auto positionX = Converter::Convert(frame->x); - auto positionY = Converter::Convert(frame->y); - auto width = Converter::Convert(frame->width); - auto height = Converter::Convert(frame->height); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - const auto& renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetFrame(Dimension(positionX, DimensionUnit::VP).ConvertToPx(), - Dimension(positionY, DimensionUnit::VP).ConvertToPx(), Dimension(width, DimensionUnit::VP).ConvertToPx(), - Dimension(height, DimensionUnit::VP).ConvertToPx()); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(frame); + + auto frameConv = Converter::Convert(*frame); + OffsetT offset( + Dimension(frameConv.Left(), DimensionUnit::VP), + Dimension(frameConv.Top(), DimensionUnit::VP) + ); + ViewAbstractModelStatic::SetPosition(Referenced::RawPtr(frameNode), offset); + + auto layoutProperty = frameNode->GetLayoutProperty(); + CHECK_NULL_VOID(layoutProperty); + layoutProperty->UpdateUserDefinedIdealSize(CalcSize( + CalcLength(Dimension(frameConv.Width(), DimensionUnit::VP).ConvertToPx()), + CalcLength(Dimension(frameConv.Height(), DimensionUnit::VP).ConvertToPx()) + )); + frameNode->MarkDirtyNode(NG::PROPERTY_UPDATE_MEASURE); } Ark_Vector2 GetPivotImpl(Ark_RenderNode peer) { - return {}; + // The value is a floating point number in the range [0.0, 1.0], and the default value is 0.5. + auto defaultPivot = DimensionOffset(Dimension(0.5f), Dimension(0.5f)); + auto errorValue = Converter::ArkValue(defaultPivot); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto renderContext = GetRenderContext(frameNode, false); + CHECK_NULL_RETURN(renderContext, errorValue); + auto pivot = renderContext->GetTransformCenterValue(defaultPivot); + return Converter::ArkValue(pivot); } void SetPivotImpl(Ark_RenderNode peer, const Ark_Vector2* pivot) { @@ -538,19 +1055,26 @@ void SetPivotImpl(Ark_RenderNode peer, const Ark_Vector2* pivot) LOGW("This renderNode is nullptr when SetPivot !"); return; } - auto pivotX = Converter::Convert(pivot->x); - auto pivotY = Converter::Convert(pivot->y); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - const auto& renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetRenderPivot(pivotX, pivotY); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(pivot); + + auto pivotConv = Converter::Convert(*pivot); + auto x = GreatOrEqual(pivotConv.x, 0.f) && LessOrEqual(pivotConv.x, 1.f) ? pivotConv.x : 0.5f; + auto y = GreatOrEqual(pivotConv.y, 0.f) && LessOrEqual(pivotConv.y, 1.f) ? pivotConv.y : 0.5f; + ViewAbstractModelStatic::SetPivot(Referenced::RawPtr(frameNode), DimensionOffset(Dimension(x), Dimension(y))); } Ark_Vector2 GetScaleImpl(Ark_RenderNode peer) { - return {}; + // The default value is { x: 1, y: 1 }. + auto errorValue = Converter::ArkValue(VectorF(1.f, 1.f)); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto scaleValue = ViewAbstract::GetScale(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(scaleValue); } void SetScaleImpl(Ark_RenderNode peer, const Ark_Vector2* scale) { @@ -558,18 +1082,26 @@ void SetScaleImpl(Ark_RenderNode peer, const Ark_Vector2* scale) LOGW("This renderNode is nullptr when SetScale !"); return; } - auto scaleX = Converter::Convert(scale->x); - auto scaleY = Converter::Convert(scale->y); + auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - const auto& renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetScale(scaleX, scaleY); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(scale); + + auto scaleConv = Converter::Convert(*scale); + auto x = GreatOrEqual(scaleConv.x, 0.f) ? scaleConv.x : 1.f; + auto y = GreatOrEqual(scaleConv.y, 0.f) ? scaleConv.y : 1.f; + ViewAbstract::SetScale(Referenced::RawPtr(frameNode), VectorF(x, y)); } Ark_Vector2 GetTranslationImpl(Ark_RenderNode peer) { - return {}; + // The default value is { x: 0, y: 0 }. + auto errorValue = Converter::ArkValue(VectorF(0.f, 0.f)); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto translateValue = ViewAbstract::GetTranslate(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(translateValue); } void SetTranslationImpl(Ark_RenderNode peer, const Ark_Vector2* translation) { @@ -577,20 +1109,27 @@ void SetTranslationImpl(Ark_RenderNode peer, const Ark_Vector2* translation) LOGW("This renderNode is nullptr when SetTranslation !"); return; } - auto translationX = Converter::Convert(translation->x); - auto translationY = Converter::Convert(translation->y); - float translateZ = 0.0f; auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - const auto& renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetTranslate(translationX, translationY, translateZ); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(translation); + + auto translateConv = Converter::Convert(*translation); + auto x = GreatOrEqual(translateConv.x, 0.f) ? translateConv.x : 0.f; + auto y = GreatOrEqual(translateConv.y, 0.f) ? translateConv.y : 0.f; + ViewAbstract::SetTranslate(Referenced::RawPtr(frameNode), + TranslateOptions(CalcDimension(x), CalcDimension(y), CalcDimension(0.f))); } Ark_Vector3 GetRotationImpl(Ark_RenderNode peer) { - return {}; + // The default value is { x: 0, y: 0, z: 0}. + auto errorValue = Converter::ArkValue(Vector3F(0.f, 0.f, 0.f)); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto rotateValue = ViewAbstract::GetRotate(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(Vector3F(rotateValue.x, rotateValue.y, rotateValue.z)); } void SetRotationImpl(Ark_RenderNode peer, const Ark_Vector3* rotation, const Ark_Int32 unitValue) { @@ -598,24 +1137,31 @@ void SetRotationImpl(Ark_RenderNode peer, const Ark_Vector3* rotation, const Ark LOGW("This renderNode is nullptr when SetRotation !"); return; } - auto rotationX = Converter::Convert(rotation->x); - auto rotationY = Converter::Convert(rotation->y); - auto rotationZ = Converter::Convert(rotation->z); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - const auto& renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(rotation); + DimensionUnit unit = ConvertLengthMetricsUnitToDimensionUnit(unitValue, DimensionUnit::VP); - Dimension first = Dimension(rotationX, unit); - Dimension second = Dimension(rotationY, unit); - Dimension third = Dimension(rotationZ, unit); - renderContext->SetRotation(first.ConvertToPx(), second.ConvertToPx(), third.ConvertToPx()); - renderContext->RequestNextFrame(); + auto rotationConv = Converter::Convert(*rotation); + auto x = Dimension(GreatOrEqual(rotationConv.x, 0.f) ? rotationConv.x : 0.f, unit); + auto y = Dimension(GreatOrEqual(rotationConv.y, 0.f) ? rotationConv.y : 0.f, unit); + auto z = Dimension(GreatOrEqual(rotationConv.z, 0.f) ? rotationConv.z : 0.f, unit); + ViewAbstract::SetRotate(Referenced::RawPtr(frameNode), + Vector5F(x.ConvertToPx(), y.ConvertToPx(), z.ConvertToPx(), 0.f, 0.f) + ); } Ark_Matrix4 GetTransformImpl(Ark_RenderNode peer) { - return {}; + // The default value is [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] + auto errorValue = Converter::ArkValue( + Matrix4(1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f)); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto transformValue = ViewAbstract::GetTransform(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(transformValue); } void SetTransformImpl(Ark_RenderNode peer, const Ark_Matrix4* transform) { @@ -623,32 +1169,27 @@ void SetTransformImpl(Ark_RenderNode peer, const Ark_Matrix4* transform) LOGW("This renderNode is nullptr when SetTransform !"); return; } - auto value0 = Converter::Convert(transform->value0); - auto value1 = Converter::Convert(transform->value1); - auto value2 = Converter::Convert(transform->value2); - auto value3 = Converter::Convert(transform->value3); - auto value4 = Converter::Convert(transform->value4); - auto value5 = Converter::Convert(transform->value5); - auto value6 = Converter::Convert(transform->value6); - auto value7 = Converter::Convert(transform->value7); - auto value8 = Converter::Convert(transform->value8); - auto value9 = Converter::Convert(transform->value9); - auto value10 = Converter::Convert(transform->value10); - auto value11 = Converter::Convert(transform->value11); - auto value12 = Converter::Convert(transform->value12); - auto value13 = Converter::Convert(transform->value13); - auto value14 = Converter::Convert(transform->value14); - auto value15 = Converter::Convert(transform->value15); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto matrix4 = std::make_optional(value0, value4, value8, value12, value1, value5, value9, value13, value2, - value6, value10, value14, value3, value7, value11, value15); - NG::ViewAbstractModelStatic::SetTransformMatrix(AceType::RawPtr(frameNode), matrix4); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(transform); + + auto transformConv = Converter::Convert(*transform); + ViewAbstractModelStatic::SetTransformMatrix(Referenced::RawPtr(frameNode), transformConv); } Ark_Number GetShadowColorImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(static_cast(Color::TRANSPARENT.GetValue())); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + auto color = shadow.value().GetColor(); + return Converter::ArkValue(static_cast(color.GetValue())); + } + return errorValue; } void SetShadowColorImpl(Ark_RenderNode peer, const Ark_Number* shadowColor) { @@ -656,18 +1197,36 @@ void SetShadowColorImpl(Ark_RenderNode peer, const Ark_Number* shadowColor) LOGW("This renderNode is nullptr when SetShadowColor !"); return; } - auto colorValue = Converter::Convert(*shadowColor); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetShadowColor(colorValue); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(shadowColor); + + auto colorConv = Converter::Convert(*shadowColor); + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + auto color = Color(colorConv); + if (peer->shadowAlpha.has_value()) { + color = color.ChangeAlpha(peer->shadowAlpha.value()); + } + shadow->SetColor(color); + std::vector shadows { shadow.value() }; + ViewAbstractModelStatic::SetBackShadow(Referenced::RawPtr(frameNode), shadows); + } } Ark_Vector2 GetShadowOffsetImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(Offset(0, 0)); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + auto offset = shadow.value().GetOffset(); + return Converter::ArkValue(offset); + } + return errorValue; } void SetShadowOffsetImpl(Ark_RenderNode peer, const Ark_Vector2* shadowOffset, const Ark_Int32 unitValue) { @@ -675,22 +1234,28 @@ void SetShadowOffsetImpl(Ark_RenderNode peer, const Ark_Vector2* shadowOffset, c LOGW("This renderNode is nullptr when SetShadowOffset !"); return; } - auto offsetX = Converter::Convert(shadowOffset->x); - auto offsetY = Converter::Convert(shadowOffset->y); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - const auto& renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(shadowOffset); + DimensionUnit unit = ConvertLengthMetricsUnitToDimensionUnit(unitValue, DimensionUnit::VP); - Dimension first = Dimension(offsetX, unit); - Dimension second = Dimension(offsetY, unit); - renderContext->SetShadowOffset(first.ConvertToPx(), second.ConvertToPx()); - renderContext->RequestNextFrame(); + auto offsetConv = Converter::Convert(*shadowOffset); + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + Dimension first = Dimension(offsetConv.GetX(), unit); + Dimension second = Dimension(offsetConv.GetY(), unit); + shadow->SetOffset(Offset(first.ConvertToPx(), second.ConvertToPx())); + std::vector shadows { shadow.value() }; + ViewAbstractModelStatic::SetBackShadow(Referenced::RawPtr(frameNode), shadows); + } } Ark_String GetLabelImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue("", Converter::FC); + CHECK_NULL_RETURN(peer, errorValue); + return Converter::ArkValue(peer->label, Converter::FC); } void SetLabelImpl(Ark_RenderNode peer, const Ark_String* label) { @@ -698,17 +1263,25 @@ void SetLabelImpl(Ark_RenderNode peer, const Ark_String* label) LOGW("This renderNode is nullptr when SetLabel !"); return; } - auto labelValue = Converter::Convert(*label); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(label); + auto labelConv = Converter::Convert(*label); auto pattern = frameNode->GetPattern(); CHECK_NULL_VOID(pattern); - pattern->SetLabel(std::string(labelValue)); + pattern->SetLabel(labelConv); + peer->label = labelConv; } Ark_Number GetShadowAlphaImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(0); + CHECK_NULL_RETURN(peer, errorValue); + if (peer->shadowAlpha.has_value()) { + return Converter::ArkValue(peer->shadowAlpha.value()); + } + return errorValue; } void SetShadowAlphaImpl(Ark_RenderNode peer, const Ark_Number* shadowAlpha) { @@ -716,18 +1289,37 @@ void SetShadowAlphaImpl(Ark_RenderNode peer, const Ark_Number* shadowAlpha) LOGW("This renderNode is nullptr when SetShadowAlpha !"); return; } - auto alphaValue = Converter::Convert(*shadowAlpha); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetShadowAlpha(alphaValue); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(shadowAlpha); + + auto alphaConv = Converter::Convert(*shadowAlpha); + peer->shadowAlpha = alphaConv; + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + auto color = shadow.value().GetColor(); + if (peer->shadowAlpha.has_value()) { + color = color.ChangeAlpha(peer->shadowAlpha.value()); + } + shadow->SetColor(color); + std::vector shadows { shadow.value() }; + ViewAbstractModelStatic::SetBackShadow(Referenced::RawPtr(frameNode), shadows); + } } Ark_Number GetShadowElevationImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(0.f); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + auto elevation = shadow.value().GetElevation(); + return Converter::ArkValue(elevation); + } + return errorValue; } void SetShadowElevationImpl(Ark_RenderNode peer, const Ark_Number* shadowElevation) { @@ -735,18 +1327,32 @@ void SetShadowElevationImpl(Ark_RenderNode peer, const Ark_Number* shadowElevati LOGW("This renderNode is nullptr when SetShadowElevation !"); return; } - auto elevationValue = Converter::Convert(*shadowElevation); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetShadowElevation(elevationValue); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(shadowElevation); + + auto elevationConv = Converter::Convert(*shadowElevation); + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + shadow->SetElevation(elevationConv); + std::vector shadows { shadow.value() }; + ViewAbstractModelStatic::SetBackShadow(Referenced::RawPtr(frameNode), shadows); + } } Ark_Number GetShadowRadiusImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(0.f); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + auto radius = shadow.value().GetBlurRadius(); + return Converter::ArkValue(radius); + } + return errorValue; } void SetShadowRadiusImpl(Ark_RenderNode peer, const Ark_Number* shadowRadius) { @@ -754,18 +1360,28 @@ void SetShadowRadiusImpl(Ark_RenderNode peer, const Ark_Number* shadowRadius) LOGW("This renderNode is nullptr when SetShadowRadius !"); return; } - auto radiusValue = Converter::Convert(*shadowRadius); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetShadowRadius(radiusValue); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(shadowRadius); + + auto radiusConv = Converter::Convert(*shadowRadius); + auto shadow = ViewAbstract::GetShadow(Referenced::RawPtr(frameNode)); + if (shadow.has_value()) { + shadow->SetBlurRadius(radiusConv); + std::vector shadows { shadow.value() }; + ViewAbstractModelStatic::SetBackShadow(Referenced::RawPtr(frameNode), shadows); + } } Ark_EdgeStyles GetBorderStyleImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(BorderStyleProperty()); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto value = ViewAbstract::GetBorderStyle(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(value); } void SetBorderStyleImpl(Ark_RenderNode peer, const Ark_EdgeStyles* borderStyle) { @@ -773,20 +1389,23 @@ void SetBorderStyleImpl(Ark_RenderNode peer, const Ark_EdgeStyles* borderStyle) LOGW("This renderNode is nullptr when SetBorderStyle !"); return; } - auto left = borderStyle->left.value; - auto right = borderStyle->right.value; - auto top = borderStyle->top.value; - auto bottom = borderStyle->bottom.value; auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(borderStyle); - auto borderStyleProperty = Converter::Convert(*borderStyle); - ACE_UPDATE_NODE_RENDER_CONTEXT(BorderStyle, borderStyleProperty, frameNode); + auto value = Converter::Convert(*borderStyle); + ViewAbstractModelStatic::SetBorderStyle(Referenced::RawPtr(frameNode), value); } Ark_EdgesNumber GetBorderWidthImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(BorderWidthProperty()); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto value = ViewAbstract::GetBorderWidth(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(value); } void SetBorderWidthImpl(Ark_RenderNode peer, const Ark_EdgesNumber* borderWidth, const Ark_Int32 unitValue) { @@ -794,29 +1413,42 @@ void SetBorderWidthImpl(Ark_RenderNode peer, const Ark_EdgesNumber* borderWidth, LOGW("This renderNode is nullptr when SetBorderWidth !"); return; } - auto left = Converter::Convert(borderWidth->left.value); - auto right = Converter::Convert(borderWidth->right.value); - auto top = Converter::Convert(borderWidth->top.value); - auto bottom = Converter::Convert(borderWidth->bottom.value); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(borderWidth); + auto layoutProperty = frameNode->GetLayoutProperty(); + CHECK_NULL_VOID(layoutProperty); DimensionUnit unit = ConvertLengthMetricsUnitToDimensionUnit(unitValue, DimensionUnit::VP); - BorderWidthProperty borderWidthProperty { .leftDimen = Dimension(left.Value(), unit), - .topDimen = Dimension(top.Value(), unit), - .rightDimen = Dimension(right.Value(), unit), - .bottomDimen = Dimension(bottom.Value(), unit), - .multiValued = true }; - layoutProperty->UpdateBorderWidth(borderWidthProperty); - frameNode->MarkDirtyNode(); - renderContext->SetBorderWidth(borderWidthProperty); + auto value = Converter::Convert(*borderWidth); + if (value.leftDimen) { + value.leftDimen->SetUnit(unit); + } + if (value.topDimen) { + value.topDimen->SetUnit(unit); + } + if (value.rightDimen) { + value.rightDimen->SetUnit(unit); + } + if (value.bottomDimen) { + value.bottomDimen->SetUnit(unit); + } + ViewAbstractModelStatic::SetBorderWidth(Referenced::RawPtr(frameNode), value); } Ark_EdgesNumber GetBorderColorImpl(Ark_RenderNode peer) { - return {}; + Color defaultColor(0xff000000); + BorderColorProperty borderColors = { + defaultColor, defaultColor, defaultColor, defaultColor, std::nullopt, std::nullopt + }; + auto errorValue = Converter::ArkValue(borderColors); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto value = ViewAbstract::GetBorderColor(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(value); } void SetBorderColorImpl(Ark_RenderNode peer, const Ark_EdgesNumber* borderColor) { @@ -824,25 +1456,23 @@ void SetBorderColorImpl(Ark_RenderNode peer, const Ark_EdgesNumber* borderColor) LOGW("This renderNode is nullptr when SetBorderColor !"); return; } - auto left = Converter::Convert(borderColor->left.value); - auto right = Converter::Convert(borderColor->right.value); - auto top = Converter::Convert(borderColor->top.value); - auto bottom = Converter::Convert(borderColor->bottom.value); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - BorderColorProperty borderColorProperty { .leftColor = Color(left), - .rightColor = Color(right), - .topColor = Color(top), - .bottomColor = Color(bottom), - .multiValued = true }; - ACE_UPDATE_NODE_RENDER_CONTEXT(BorderColor, borderColorProperty, frameNode); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(borderColor); + + auto value = Converter::Convert(*borderColor); + ViewAbstractModelStatic::SetBorderColor(Referenced::RawPtr(frameNode), value); } Ark_BorderRadiuses_graphics GetBorderRadiusImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(BorderRadiusProperty()); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto value = ViewAbstract::GetBorderRadius(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(value); } void SetBorderRadiusImpl(Ark_RenderNode peer, const Ark_BorderRadiuses_graphics* borderRadius, Ark_Int32 unitValue) { @@ -850,33 +1480,70 @@ void SetBorderRadiusImpl(Ark_RenderNode peer, const Ark_BorderRadiuses_graphics* LOGW("This renderNode is nullptr when SetBorderRadius !"); return; } - auto topLeft = Converter::Convert(borderRadius->topLeft); - auto topRight = Converter::Convert(borderRadius->topRight); - auto bottomLeft = Converter::Convert(borderRadius->bottomLeft); - auto bottomRight = Converter::Convert(borderRadius->bottomRight); auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - const auto& renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + CHECK_NULL_VOID(borderRadius); + DimensionUnit unit = ConvertLengthMetricsUnitToDimensionUnit(unitValue, DimensionUnit::VP); - BorderRadiusProperty borderRadiusProperty( - Dimension(topLeft, unit), Dimension(topRight, unit), Dimension(bottomRight, unit), Dimension(bottomLeft, unit)); - renderContext->UpdateBorderRadius(borderRadiusProperty); + auto value = Converter::Convert(*borderRadius); + if (value.radiusTopLeft) { + value.radiusTopLeft->SetUnit(unit); + } + if (value.radiusTopRight) { + value.radiusTopRight->SetUnit(unit); + } + if (value.radiusBottomRight) { + value.radiusBottomRight->SetUnit(unit); + } + if (value.radiusBottomLeft) { + value.radiusBottomLeft->SetUnit(unit); + } + ViewAbstractModelStatic::SetBorderRadius(Referenced::RawPtr(frameNode), value); } Ark_ShapeMask GetShapeMaskImpl(Ark_RenderNode peer) { - return {}; + CHECK_NULL_RETURN(peer, nullptr); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, nullptr); + auto value = ViewAbstract::GetMask(Referenced::RawPtr(frameNode)); + return PeerUtils::CreatePeer(value); +} +void SetShapeMaskImpl(Ark_RenderNode peer, Ark_ShapeMask shapeMask) +{ + CHECK_NULL_VOID(peer && shapeMask); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_VOID(frameNode); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + auto value = GetBasicShape(shapeMask); + ViewAbstract::SetMask(Referenced::RawPtr(frameNode), value); } -void SetShapeMaskImpl(Ark_RenderNode peer, Ark_ShapeMask shapeMask) {} Ark_ShapeClip GetShapeClipImpl(Ark_RenderNode peer) { - return {}; + CHECK_NULL_RETURN(peer, nullptr); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, nullptr); + auto value = ViewAbstract::GetClipShape(Referenced::RawPtr(frameNode)); + return PeerUtils::CreatePeer(value); +} +void SetShapeClipImpl(Ark_RenderNode peer, Ark_ShapeClip shapeClip) +{ + CHECK_NULL_VOID(peer && shapeClip); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_VOID(frameNode); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + auto value = GetBasicShape(shapeClip); + ViewAbstract::SetClipShape(Referenced::RawPtr(frameNode), value); } -void SetShapeClipImpl(Ark_RenderNode peer, Ark_ShapeClip shapeClip) {} Ark_Boolean GetMarkNodeGroupImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(false); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + auto isRenderGroup = ViewAbstract::GetRenderGroup(Referenced::RawPtr(frameNode)); + return Converter::ArkValue(isRenderGroup); } void SetMarkNodeGroupImpl(Ark_RenderNode peer, Ark_Boolean markNodeGroup) { @@ -888,17 +1555,25 @@ void SetMarkNodeGroupImpl(Ark_RenderNode peer, Ark_Boolean markNodeGroup) auto frameNode = peer->GetFrameNode(); CHECK_NULL_VOID(frameNode); - auto renderContext = frameNode->GetRenderContext(); - CHECK_NULL_VOID(renderContext); - renderContext->SetMarkNodeGroup(isNodeGroup); - frameNode->SetApplicationRenderGroupMarked(true); - renderContext->RequestNextFrame(); + CHECK_NULL_VOID(frameNode->GetTag() != "BuilderProxyNode"); + + frameNode->SetApplicationRenderGroupMarked(isNodeGroup); + ViewAbstract::SetRenderGroup(Referenced::RawPtr(frameNode), isNodeGroup); } Ark_LengthMetricsUnit GetLengthMetricsUnitImpl(Ark_RenderNode peer) { - return {}; + auto errorValue = Converter::ArkValue(RenderNodePeer::LengthMetricsUnit::DEFAULT); + CHECK_NULL_RETURN(peer, errorValue); + auto frameNode = peer->GetFrameNode(); + CHECK_NULL_RETURN(frameNode, errorValue); + return Converter::ArkValue(peer->lengthMetricsUnit); +} +void SetLengthMetricsUnitImpl(Ark_RenderNode peer, Ark_LengthMetricsUnit lengthMetricsUnit) +{ + CHECK_NULL_VOID(peer); + auto value = Converter::OptConvert(lengthMetricsUnit); + peer->lengthMetricsUnit = value.has_value() ? value.value() : RenderNodePeer::LengthMetricsUnit::DEFAULT; } -void SetLengthMetricsUnitImpl(Ark_RenderNode peer, Ark_LengthMetricsUnit lengthMetricsUnit) {} } // namespace RenderNodeAccessor const GENERATED_ArkUIRenderNodeAccessor* GetRenderNodeAccessor() { diff --git a/frameworks/core/interfaces/native/implementation/render_node_peer_impl.h b/frameworks/core/interfaces/native/implementation/render_node_peer_impl.h index 9d08618df995b2dda7f0ab3a08b77f4785dd8735..a979e268a45d61c1c8d4184b6536e17c1eb1dabb 100644 --- a/frameworks/core/interfaces/native/implementation/render_node_peer_impl.h +++ b/frameworks/core/interfaces/native/implementation/render_node_peer_impl.h @@ -15,42 +15,54 @@ #ifndef FOUNDATION_ARKUI_ACE_ENGINE_FRAMEWORKS_CORE_INTERFACES_NATIVE_IMPL_RENDER_NODE_PEER_IMPL_H #define FOUNDATION_ARKUI_ACE_ENGINE_FRAMEWORKS_CORE_INTERFACES_NATIVE_IMPL_RENDER_NODE_PEER_IMPL_H -#include "base/memory/referenced.h" -#include "core/components_ng/base/frame_node.h" #include "core/interfaces/native/generated/interface/arkoala_api_generated.h" +#include "core/components_ng/pattern/render_node/render_node_pattern.h" +#include "core/interfaces/native/utility/peer_utils.h" +#include "core/components_ng/base/frame_node.h" +#include "base/memory/referenced.h" -struct RenderNodePeer { +struct RenderNodePeer final { public: - RenderNodePeer() = default; - RenderNodePeer(const OHOS::Ace::RefPtr& src) : node(src) {} - ~RenderNodePeer() = default; - - static RenderNodePeer* Create(Ark_UIContext uiContext) + enum class LengthMetricsUnit : int32_t { DEFAULT = 0, PX }; + LengthMetricsUnit lengthMetricsUnit{ LengthMetricsUnit::DEFAULT }; + std::optional shadowAlpha{ std::nullopt }; + std::string label = ""; + friend OHOS::Ace::NG::PeerUtils; + const OHOS::Ace::RefPtr& GetFrameNode() const { - return new RenderNodePeer; + return node; } - static RenderNodePeer* Create(const OHOS::Ace::RefPtr& src) - { - return new RenderNodePeer(src); - } +protected: + OHOS::Ace::RefPtr node; - static RenderNodePeer* Create(OHOS::Ace::NG::FrameNode* src) + RenderNodePeer() { - return new RenderNodePeer(OHOS::Ace::Referenced::Claim(src)); + auto nodeId = OHOS::Ace::ElementRegister::GetInstance()->MakeUniqueId(); + node = OHOS::Ace::NG::FrameNode::GetOrCreateFrameNode( + OHOS::Ace::V2::RENDER_NODE_ETS_TAG, + nodeId, + []() { return OHOS::Ace::AceType::MakeRefPtr(); }); + node->SetIsArkTsRenderNode(true); } - static void Destroy(RenderNodePeer* peer) + RenderNodePeer(const OHOS::Ace::RefPtr& src) + : node(src) { - delete peer; + if (node) { + node->SetIsArkTsRenderNode(true); + } } - const OHOS::Ace::RefPtr& GetFrameNode() const + RenderNodePeer(OHOS::Ace::NG::FrameNode* src) + : node(OHOS::Ace::Referenced::Claim(src)) { - return node; + if (node) { + node->SetIsArkTsRenderNode(true); + } } private: - OHOS::Ace::RefPtr node; + ~RenderNodePeer() = default; }; #endif // FOUNDATION_ARKUI_ACE_ENGINE_FRAMEWORKS_CORE_INTERFACES_NATIVE_IMPL_RENDER_NODE_PEER_IMPL_H diff --git a/frameworks/core/interfaces/native/implementation/shape_clip_accessor.cpp b/frameworks/core/interfaces/native/implementation/shape_clip_accessor.cpp index 5f85c1799a3c5827814be36abce2959594545228..d0f8696116ceb4d9aba2881ad303eab42aa6d1a3 100644 --- a/frameworks/core/interfaces/native/implementation/shape_clip_accessor.cpp +++ b/frameworks/core/interfaces/native/implementation/shape_clip_accessor.cpp @@ -37,35 +37,37 @@ void SetRectShapeImpl(Ark_ShapeClip peer, const Ark_Rect* rect) { if (peer && rect) { - peer->SetRectShape(Converter::Convert>(*rect)); + peer->shape = Converter::Convert>(*rect); } } void SetRoundRectShapeImpl(Ark_ShapeClip peer, const Ark_RoundRect* roundRect) { if (peer && roundRect) { - peer->SetRoundRectShape(Converter::Convert>(*roundRect)); + peer->shape = Converter::Convert>(*roundRect); } } void SetCircleShapeImpl(Ark_ShapeClip peer, const Ark_Circle* circle) { if (peer && circle) { - peer->SetCircleShape(Converter::Convert>(*circle)); + peer->shape = Converter::Convert>(*circle); } } void SetOvalShapeImpl(Ark_ShapeClip peer, const Ark_Rect* oval) { if (peer && oval) { - peer->SetOvalShape(Converter::Convert>(*oval)); + peer->shape = Converter::Convert>(*oval); } } void SetCommandPathImpl(Ark_ShapeClip peer, const Ark_CommandPath* path) { if (peer && path) { - peer->SetCommandPath(Converter::Convert(*path)); + auto pathShape = OHOS::Ace::AceType::MakeRefPtr(); + pathShape->SetValue(Converter::Convert(*path)); + peer->shape = pathShape; } } } // ShapeClipAccessor diff --git a/frameworks/core/interfaces/native/implementation/shape_clip_peer.h b/frameworks/core/interfaces/native/implementation/shape_clip_peer.h index 072bd72ee2294d2b97bbf6432878003f912d570d..d09e6b78953dd9d02dc54ddcc63da9ce638de857 100644 --- a/frameworks/core/interfaces/native/implementation/shape_clip_peer.h +++ b/frameworks/core/interfaces/native/implementation/shape_clip_peer.h @@ -20,6 +20,7 @@ struct ShapeClipPeer final : public BaseShapePeer { protected: ShapeClipPeer() = default; + explicit ShapeClipPeer(const RefPtr& src) : BaseShapePeer(src) {} ~ShapeClipPeer() override = default; friend OHOS::Ace::NG::PeerUtils; }; diff --git a/frameworks/core/interfaces/native/implementation/shape_mask_accessor.cpp b/frameworks/core/interfaces/native/implementation/shape_mask_accessor.cpp index ec6a787c67fe8eb5cb6eabcc0307911632720d0f..ffe361954de58c5df4e26e04fa5b52dc7cd68dbb 100644 --- a/frameworks/core/interfaces/native/implementation/shape_mask_accessor.cpp +++ b/frameworks/core/interfaces/native/implementation/shape_mask_accessor.cpp @@ -41,35 +41,42 @@ void SetRectShapeImpl(Ark_ShapeMask peer, const Ark_Rect* rect) { if (peer && rect) { - peer->SetRectShape(Converter::Convert>(*rect)); + peer->shape = Converter::Convert>(*rect); + peer->SetBasicProperties(); } } void SetRoundRectShapeImpl(Ark_ShapeMask peer, const Ark_RoundRect* roundRect) { if (peer && roundRect) { - peer->SetRoundRectShape(Converter::Convert>(*roundRect)); + peer->shape = Converter::Convert>(*roundRect); + peer->SetBasicProperties(); } } void SetCircleShapeImpl(Ark_ShapeMask peer, const Ark_Circle* circle) { if (peer && circle) { - peer->SetCircleShape(Converter::Convert>(*circle)); + peer->shape = Converter::Convert>(*circle); + peer->SetBasicProperties(); } } void SetOvalShapeImpl(Ark_ShapeMask peer, const Ark_Rect* oval) { if (peer && oval) { - peer->SetOvalShape(Converter::Convert>(*oval)); + peer->shape = Converter::Convert>(*oval); + peer->SetBasicProperties(); } } void SetCommandPathImpl(Ark_ShapeMask peer, const Ark_CommandPath* path) { if (peer && path) { - peer->SetCommandPath(Converter::Convert(*path)); + auto pathShape = OHOS::Ace::AceType::MakeRefPtr(); + pathShape->SetValue(Converter::Convert(*path)); + peer->shape = pathShape; + peer->SetBasicProperties(); } } Ark_Number GetFillColorImpl(Ark_ShapeMask peer) @@ -82,6 +89,9 @@ void SetFillColorImpl(Ark_ShapeMask peer, { CHECK_NULL_VOID(peer && fillColor); peer->fillColor = Converter::Convert(*fillColor); + if (peer->shape) { + peer->shape->SetColor(OHOS::Ace::Color(peer->fillColor)); + } } Ark_Number GetStrokeColorImpl(Ark_ShapeMask peer) { @@ -93,6 +103,9 @@ void SetStrokeColorImpl(Ark_ShapeMask peer, { CHECK_NULL_VOID(peer && strokeColor); peer->strokeColor = Converter::Convert(*strokeColor); + if (peer->shape) { + peer->shape->SetStrokeColor(peer->strokeColor); + } } Ark_Number GetStrokeWidthImpl(Ark_ShapeMask peer) { @@ -104,6 +117,9 @@ void SetStrokeWidthImpl(Ark_ShapeMask peer, { CHECK_NULL_VOID(peer && strokeWidth); peer->strokeWidth = Converter::Convert(*strokeWidth); + if (peer->shape) { + peer->shape->SetStrokeWidth(peer->strokeWidth); + } } } // ShapeMaskAccessor const GENERATED_ArkUIShapeMaskAccessor* GetShapeMaskAccessor() diff --git a/frameworks/core/interfaces/native/implementation/shape_mask_peer.h b/frameworks/core/interfaces/native/implementation/shape_mask_peer.h index 843e0e59f999558d4fcd7b5044f5d15cfa5c818d..b0e12d8f56d30d6548cc8ef1807e5dfc2415b9ea 100644 --- a/frameworks/core/interfaces/native/implementation/shape_mask_peer.h +++ b/frameworks/core/interfaces/native/implementation/shape_mask_peer.h @@ -27,59 +27,27 @@ const float DEFAULT_WIDTH = 0.0f; struct BaseShapePeer { BaseShapePeer() = default; + explicit BaseShapePeer(const RefPtr& src) : shape(src) {} virtual ~BaseShapePeer() = default; - void SetRectShape(const RefPtr& value) - { - ResetAll(); - rect = value; - } - void SetRoundRectShape(const RefPtr& value) - { - ResetAll(); - roundRect = value; - } - void SetCircleShape(const RefPtr& value) - { - ResetAll(); - circle = value; - } - void SetOvalShape(const RefPtr& value) - { - ResetAll(); - oval = value; - } - void SetCommandPath(const std::string& value) - { - ResetAll(); - path = value; - } - -private: - void ResetAll() - { - rect = nullptr; - roundRect = nullptr; - circle = nullptr; - oval = nullptr; - path = std::nullopt; - } - -public: - RefPtr rect = nullptr; - RefPtr roundRect = nullptr; - RefPtr circle = nullptr; - RefPtr oval = nullptr; - std::optional path = std::nullopt; + RefPtr shape = nullptr; }; struct ShapeMaskPeer final : public BaseShapePeer { protected: ShapeMaskPeer() = default; + explicit ShapeMaskPeer(const RefPtr& src) : BaseShapePeer(src) {} ~ShapeMaskPeer() override = default; friend OHOS::Ace::NG::PeerUtils; public: +void SetBasicProperties() + { + shape->SetColor(OHOS::Ace::Color(fillColor)); + shape->SetStrokeColor(strokeColor); + shape->SetStrokeWidth(strokeWidth); + } + uint32_t fillColor = DEFAULT_COLOR; uint32_t strokeColor = DEFAULT_COLOR; float strokeWidth = DEFAULT_WIDTH; diff --git a/frameworks/core/interfaces/native/utility/converter.h b/frameworks/core/interfaces/native/utility/converter.h index 68d8186d239d065aaa97eeda35ebe475eb90727c..65727d84db4fb274eda1f3eba5f70f952834c96e 100644 --- a/frameworks/core/interfaces/native/utility/converter.h +++ b/frameworks/core/interfaces/native/utility/converter.h @@ -488,6 +488,9 @@ namespace Converter { template<> BorderColorProperty Convert(const Ark_EdgeColors& src); template<> BorderColorProperty Convert(const Ark_LocalizedEdgeColors& src); template<> BorderColorProperty Convert(const Ark_ResourceColor& src); + template<> BorderColorProperty Convert(const Ark_EdgesNumber& src); + template<> BorderRadiusProperty Convert(const Ark_BorderRadiuses_graphics& src); + template<> BorderWidthProperty Convert(const Ark_EdgesNumber& src); template<> BorderRadiusProperty Convert(const Ark_BorderRadiuses& src); template<> BorderRadiusProperty Convert(const Ark_Length& src); template<> BorderRadiusProperty Convert(const Ark_LengthMetrics& src); @@ -547,6 +550,7 @@ namespace Converter { template<> LightSource Convert(const Ark_LightSource& src); template<> ListItemGroupIndex Convert(const Ark_VisibleListContentInfo& src); template<> ListItemIndex Convert(const Ark_VisibleListContentInfo& src); + template<> Matrix4 Convert(const Ark_Matrix4& value); template<> MenuOptionsParam Convert(const Ark_TextMenuItem& src); template<> NG::NavToolbarItemStatus Convert(const Opt_ToolbarItemStatus& src); template<> NG::NavigationBackgroundOptions Convert(const Ark_MoreButtonOptions& src); @@ -582,6 +586,7 @@ namespace Converter { template<> RadioStyle Convert(const Ark_RadioStyle& src); template<> Radius Convert(const Ark_Vector2& src); template<> RangeContent Convert(const Ark_TextPickerRangeContent& src); + template<> RectF Convert(const Ark_Rect& value); template<> Rect Convert(const Ark_RectResult& src); template<> RefPtr Convert(const Ark_CircleShape& src); template<> RefPtr Convert(const Ark_EllipseShape& src); @@ -592,6 +597,7 @@ namespace Converter { template<> RefPtr Convert(const Ark_Curve& src); template<> RefPtr Convert(const Ark_ICurve& src); template<> RefPtr Convert(const Ark_String& src); + template<> RefPtr Convert(const Ark_Rect& src); template<> RefPtr Convert(const Ark_ExpectedFrameRateRange& src); template<> RefPtr Convert(const Ark_GestureGroupInterface& src); template<> RefPtr Convert(const Ark_LongPressGestureInterface& src); @@ -603,6 +609,7 @@ namespace Converter { template<> RefPtr Convert(const Ark_PixelMap& src); template<> RefPtr Convert(const Ark_Rect& src); template<> RefPtr Convert(const Ark_RoundRect& src); + template<> RoundRect Convert(const Ark_RoundRect& value); template<> ScaleOpt Convert(const Ark_ScaleOptions& src); template<> ScrollFrameResult Convert(const Ark_ScrollResult& src); template<> SelectionOptions Convert(const Ark_SelectionOptions& options); diff --git a/frameworks/core/interfaces/native/utility/reverse_converter.cpp b/frameworks/core/interfaces/native/utility/reverse_converter.cpp index 2865e7ca88f680f1afe01b37d988b493cd7f25db..e45f68b296bd14f0625953eaaed971744f0af511 100644 --- a/frameworks/core/interfaces/native/utility/reverse_converter.cpp +++ b/frameworks/core/interfaces/native/utility/reverse_converter.cpp @@ -487,6 +487,12 @@ void AssignArkValue(Ark_Position& dst, const OffsetF& src) dst.y = Converter::ArkValue(src.GetY()); } +void AssignArkValue(Ark_Position& dst, const OffsetT& src) +{ + dst.x = Converter::ArkValue(src.GetX()); + dst.y = Converter::ArkValue(src.GetY()); +} + void AssignArkValue(Ark_LengthMetricsCustom& dst, const CalcDimension& src) { dst.value = Converter::ArkValue(static_cast(src.Value())); diff --git a/frameworks/core/interfaces/native/utility/reverse_converter.h b/frameworks/core/interfaces/native/utility/reverse_converter.h index 453be6925cff9743289c33c9a9cc149d69719d37..4f745717986b0de61f069a199f5a9e4c8a885152 100644 --- a/frameworks/core/interfaces/native/utility/reverse_converter.h +++ b/frameworks/core/interfaces/native/utility/reverse_converter.h @@ -71,6 +71,7 @@ #include "core/interfaces/native/implementation/mouse_event_peer.h" #include "core/interfaces/native/implementation/navigation_transition_proxy_peer.h" #include "core/interfaces/native/implementation/nav_destination_context_peer.h" +#include "core/interfaces/native/implementation/render_node_peer_impl.h" #include "core/interfaces/native/implementation/submit_event_peer.h" #include "core/interfaces/native/implementation/swipe_recognizer_peer.h" #include "core/interfaces/native/implementation/touch_event_peer.h" @@ -188,6 +189,8 @@ namespace OHOS::Ace::NG::Converter { void AssignArkValue(Ark_BaseGestureEvent& dst, const std::shared_ptr& src); void AssignArkValue(Ark_BlurStyle& dst, const BlurStyle& src); void AssignArkValue(Ark_BorderRadiuses& dst, const BorderRadiusProperty& src); + void AssignArkValue(Ark_BorderRadiuses_graphics& dst, const BorderRadiusProperty& src); + void AssignArkValue(Ark_BorderStyle& dst, const BorderStyle& src); void AssignArkValue(Ark_Buffer& dst, const std::string& src); void AssignArkValue(Ark_CaretOffset& dst, const NG::OffsetF& src); void AssignArkValue(Ark_CheckboxGroupResult& dst, const CheckboxGroupResult& src); @@ -206,6 +209,9 @@ namespace OHOS::Ace::NG::Converter { void AssignArkValue(Ark_Edge& dst, const ScrollEdge& src); void AssignArkValue(Ark_EdgeEffect& dst, const EdgeEffect& src); void AssignArkValue(Ark_EdgeEffectOptions& dst, const bool& src); + void AssignArkValue(Ark_EdgesNumber& dst, const BorderColorProperty& src); + void AssignArkValue(Ark_EdgesNumber& dst, const BorderWidthProperty& src); + void AssignArkValue(Ark_EdgeStyles& dst, const BorderStyleProperty& src); void AssignArkValue(Ark_EffectDirection& dst, const OHOS::Ace::CommonSubType& src); void AssignArkValue(Ark_EffectScope& dst, const OHOS::Ace::ScopeType& src); void AssignArkValue(Ark_EnterKeyType& dst, const TextInputAction& src); @@ -249,6 +255,7 @@ namespace OHOS::Ace::NG::Converter { void AssignArkValue(Ark_Length& dst, const std::string& src); void AssignArkValue(Ark_LengthMetrics& dst, const Dimension& src); void AssignArkValue(Ark_LengthMetricsUnit& dst, const OHOS::Ace::CanvasUnit& src); + void AssignArkValue(Ark_LengthMetricsUnit& dst, const RenderNodePeer::LengthMetricsUnit& src); void AssignArkValue(Ark_LengthUnit& dst, const DimensionUnit& src); void AssignArkValue(Ark_LineBreakStrategy& dst, const LineBreakStrategy& src); void AssignArkValue(Ark_LineMetrics& dst, const TextLineMetrics& src); @@ -288,6 +295,7 @@ namespace OHOS::Ace::NG::Converter { void AssignArkValue(Ark_PanelMode& dst, const PanelMode& src); void AssignArkValue(Ark_PasteButtonOnClickResult& dst, const SecurityComponentHandleResult& src); void AssignArkValue(Ark_Position& dst, const OffsetF& src); + void AssignArkValue(Ark_Position& dst, const OffsetT& src); void AssignArkValue(Ark_LengthMetricsCustom& dst, const CalcDimension& src); void AssignArkValue(Ark_PositionWithAffinity& dst, const PositionWithAffinity& src); void AssignArkValue(Ark_PreviewText& dst, const PreviewText& src, ConvContext *ctx); @@ -386,6 +394,12 @@ namespace OHOS::Ace::NG::Converter { void AssignArkValue(Ark_WordBreak& dst, const WordBreak& src); void AssignArkValue(Array_ImageAnalyzerType& dst, const std::vector& src); void AssignArkValue(Array_Number& dst, const std::vector& src); + void AssignArkValue(Ark_Vector2& dst, const DimensionOffset& src); + void AssignArkValue(Ark_Vector2& dst, const Offset& src); + void AssignArkValue(Ark_Vector2& dst, const VectorF& src); + void AssignArkValue(Ark_Vector2& dst, const TranslateOptions& src); + void AssignArkValue(Ark_Vector3& dst, const Vector3F& src); + void AssignArkValue(Ark_Matrix4& dst, const Matrix4& src); // SORTED_SECTION template<> Ark_LengthMetrics ArkCreate(Ark_LengthUnit unit, float value); diff --git a/test/unittest/capi/accessors/BUILD.gn b/test/unittest/capi/accessors/BUILD.gn index e8b92fa357ba73ff9a2339e458849f0f90ba947d..d82e34a24922171c47ccaddc0712d618c6f31584 100644 --- a/test/unittest/capi/accessors/BUILD.gn +++ b/test/unittest/capi/accessors/BUILD.gn @@ -113,6 +113,7 @@ ace_unittest("capi_all_accessors_test") { "progress_mask_accessor_test.cpp", "pulse_symbol_effect_accessor_test.cpp", "rect_shape_accessor_test.cpp", + "render_node_accessor_test.cpp", "rendering_context_settings_accessor_test.cpp", "replace_symbol_effect_accessor_test.cpp", "richeditor_base_controller_accessor_test.cpp", diff --git a/test/unittest/capi/accessors/layout_manager_accessor_test.cpp b/test/unittest/capi/accessors/layout_manager_accessor_test.cpp index f886328cce830b8b0684c6b755ce85daf6bf7010..8bd6244c04976ca670441cfc76ebcdfc09ab2869 100755 --- a/test/unittest/capi/accessors/layout_manager_accessor_test.cpp +++ b/test/unittest/capi/accessors/layout_manager_accessor_test.cpp @@ -40,15 +40,6 @@ void AssignCast(std::optional& dst, const Ark_TextDirection& } } template<> -NG::RectF Convert(const Ark_Rect& src) -{ - auto left = Converter::Convert(src.left); - auto top = Converter::Convert(src.top); - auto right = Converter::Convert(src.right); - auto bottom = Converter::Convert(src.bottom); - return NG::RectF(left, top, right - left, bottom - top); -} -template<> ParagraphManager::TextBox Convert(const Ark_TextBox& src) { ParagraphManager::TextBox dst; diff --git a/test/unittest/capi/accessors/render_node_accessor_test.cpp b/test/unittest/capi/accessors/render_node_accessor_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..36035d67bc1be2dd0e005f3928a9ecb782c8ec1b --- /dev/null +++ b/test/unittest/capi/accessors/render_node_accessor_test.cpp @@ -0,0 +1,1979 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "core/components_ng/base/frame_node.h" +#include "core/components_ng/base/ui_node.h" +#include "core/interfaces/native/implementation/render_node_peer_impl.h" +#include "core/interfaces/native/implementation/shape_clip_peer.h" +#include "core/interfaces/native/implementation/shape_mask_peer.h" +#include "accessor_test_base.h" +#include "test/unittest/capi/modifiers/generated/type_helpers.h" +#include "node_api.h" +#include "core/interfaces/native/utility/reverse_converter.h" +#include "core/interfaces/native/utility/converter.h" +#include "gmock/gmock.h" +#include "core/components_ng/pattern/text/text_pattern.h" +#include "core/components_ng/pattern/render_node/render_node_pattern.h" + +namespace OHOS::Ace::NG { + +using namespace testing; +using namespace testing::ext; + +namespace { +const auto POS_INVALID = -1; +const auto POS_0 = 0; +const auto POS_1 = 1; +const auto POS_2 = 2; +const auto CHILD_COUNT_0 = 0; +const auto CHILD_COUNT_1 = 1; +const auto CHILD_COUNT_2 = 2; +const auto CHILD_COUNT_3 = 3; +const Ark_Boolean ARK_FALSE = Converter::ArkValue(false); +const Ark_Boolean ARK_TRUE = Converter::ArkValue(true); + +Ark_RenderNode GetRenderNode(Ark_Union_RenderNode_Undefined value) +{ + return value.selector != INTEROP_TAG_UNDEFINED ? value.value0 : nullptr; +} +} // namespace + +class RenderNodeAccessorTest + : public AccessorTestCtorBase { +public: + void* CreatePeerInstance() override + { + return PeerUtils::CreatePeer(); + } + void DestroyPeer(RenderNodePeer* peer) + { + PeerUtils::DestroyPeer(peer); + } +}; + +/** + * @tc.name: AppendChildTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, AppendChildTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->appendChild, nullptr); + auto childPeer = CreatePeer(); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_0); + EXPECT_EQ(childPeer->GetFrameNode()->GetParentFrameNode(), nullptr); + accessor_->appendChild(peer_, childPeer); + childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_1); + auto childUINodeRef = AceType::DynamicCast(childPeer->GetFrameNode()); + EXPECT_EQ(childPeer->GetFrameNode()->GetParentFrameNode(), peer_->GetFrameNode()); + EXPECT_EQ(childList.back(), childUINodeRef); + DestroyPeer(childPeer); +} + +/** + * @tc.name: InsertChildAfterTest1 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, InsertChildAfterTest1, TestSize.Level1) +{ + ASSERT_NE(accessor_->insertChildAfter, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto childPeer1 = CreatePeer(); + auto childUINodeRef1 = AceType::DynamicCast(childPeer1->GetFrameNode()); + + auto childPeer2 = CreatePeer(); + auto childUINodeRef2 = AceType::DynamicCast(childPeer2->GetFrameNode()); + + auto childPeer3 = CreatePeer(); + auto childUINodeRef3 = AceType::DynamicCast(childPeer3->GetFrameNode()); + + accessor_->appendChild(peer_, childPeer1); + accessor_->appendChild(peer_, childPeer2); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_2); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_1); + + Ark_Union_RenderNode_Undefined siblingUnion; + TypeHelper::WriteToUnion(siblingUnion) = childPeer1; + accessor_->insertChildAfter(peer_, childPeer3, &siblingUnion); + childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_3); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef3), POS_1); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_2); + DestroyPeer(childPeer1); + DestroyPeer(childPeer2); + DestroyPeer(childPeer3); +} + +/** + * @tc.name: InsertChildAfterTest2 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, InsertChildAfterTest2, TestSize.Level1) +{ + ASSERT_NE(accessor_->insertChildAfter, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto childPeer1 = CreatePeer(); + auto childUINodeRef1 = AceType::DynamicCast(childPeer1->GetFrameNode()); + + auto childPeer2 = CreatePeer(); + auto childUINodeRef2 = AceType::DynamicCast(childPeer2->GetFrameNode()); + + auto childPeer3 = CreatePeer(); + auto childUINodeRef3 = AceType::DynamicCast(childPeer3->GetFrameNode()); + + accessor_->appendChild(peer_, childPeer1); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_1); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_INVALID); + + Ark_Union_RenderNode_Undefined siblingUnion; + TypeHelper::WriteToUnion(siblingUnion) = childPeer2; + accessor_->insertChildAfter(peer_, childPeer3, &siblingUnion); + childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_2); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_1); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef3), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_INVALID); + DestroyPeer(childPeer1); + DestroyPeer(childPeer2); + DestroyPeer(childPeer3); +} + +/** + * @tc.name: InsertChildAfterTest3 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, InsertChildAfterTest3, TestSize.Level1) +{ + ASSERT_NE(accessor_->insertChildAfter, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto childPeer1 = CreatePeer(); + auto childUINodeRef1 = AceType::DynamicCast(childPeer1->GetFrameNode()); + + auto childPeer2 = CreatePeer(); + + auto childPeer3 = CreatePeer(); + auto childUINodeRef3 = AceType::DynamicCast(childPeer3->GetFrameNode()); + + accessor_->appendChild(peer_, childPeer1); + accessor_->appendChild(childPeer2, childPeer3); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_1); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + + Ark_Union_RenderNode_Undefined siblingUnion; + TypeHelper::WriteToUnion(siblingUnion) = childPeer1; + accessor_->insertChildAfter(peer_, childPeer3, &siblingUnion); + childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_1); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef3), POS_INVALID); + DestroyPeer(childPeer1); + DestroyPeer(childPeer2); + DestroyPeer(childPeer3); +} + +/** + * @tc.name: RemoveChildTest1 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, RemoveChildTest1, TestSize.Level1) +{ + ASSERT_NE(accessor_->removeChild, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto childPeer1 = CreatePeer(); + auto childUINodeRef1 = AceType::DynamicCast(childPeer1->GetFrameNode()); + + auto childPeer2 = CreatePeer(); + auto childUINodeRef2 = AceType::DynamicCast(childPeer2->GetFrameNode()); + + auto childPeer3 = CreatePeer(); + auto childUINodeRef3 = AceType::DynamicCast(childPeer3->GetFrameNode()); + + accessor_->appendChild(peer_, childPeer1); + accessor_->appendChild(peer_, childPeer2); + accessor_->appendChild(peer_, childPeer3); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_3); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_1); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef3), POS_2); + accessor_->removeChild(peer_, childPeer2); + childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_2); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef3), POS_1); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_INVALID); + DestroyPeer(childPeer1); + DestroyPeer(childPeer2); + DestroyPeer(childPeer3); +} + +/** + * @tc.name: RemoveChildTest2 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, RemoveChildTest2, TestSize.Level1) +{ + ASSERT_NE(accessor_->removeChild, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto childPeer1 = CreatePeer(); + auto childUINodeRef1 = AceType::DynamicCast(childPeer1->GetFrameNode()); + + auto childPeer2 = CreatePeer(); + auto childUINodeRef2 = AceType::DynamicCast(childPeer2->GetFrameNode()); + + auto childPeer3 = CreatePeer(); + auto childUINodeRef3 = AceType::DynamicCast(childPeer3->GetFrameNode()); + + accessor_->appendChild(peer_, childPeer1); + accessor_->appendChild(peer_, childPeer3); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_2); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_INVALID); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef3), POS_1); + accessor_->removeChild(peer_, childPeer2); + childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_2); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_INVALID); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef3), POS_1); + DestroyPeer(childPeer1); + DestroyPeer(childPeer2); + DestroyPeer(childPeer3); +} + +/** + * @tc.name: ClearChildrenTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, ClearChildrenTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->clearChildren, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + accessor_->clearChildren(peer_); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto childPeer1 = CreatePeer(); + auto childUINodeRef1 = AceType::DynamicCast(childPeer1->GetFrameNode()); + + auto childPeer2 = CreatePeer(); + auto childUINodeRef2 = AceType::DynamicCast(childPeer2->GetFrameNode()); + + auto childPeer3 = CreatePeer(); + auto childUINodeRef3 = AceType::DynamicCast(childPeer3->GetFrameNode()); + + accessor_->appendChild(peer_, childPeer1); + accessor_->appendChild(peer_, childPeer2); + accessor_->appendChild(peer_, childPeer3); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_3); + accessor_->clearChildren(peer_); + childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_0); + DestroyPeer(childPeer1); + DestroyPeer(childPeer2); + DestroyPeer(childPeer3); +} + +/** + * @tc.name: GetChildTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetChildTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->getChild, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto childPeer1 = CreatePeer(); + auto childUINodeRef1 = AceType::DynamicCast(childPeer1->GetFrameNode()); + + auto childPeer2 = CreatePeer(); + auto childUINodeRef2 = AceType::DynamicCast(childPeer2->GetFrameNode()); + + accessor_->appendChild(peer_, childPeer1); + accessor_->appendChild(peer_, childPeer2); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_2); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_1); + Ark_Number pos0 = Converter::ArkValue(POS_0); + Ark_Number pos1 = Converter::ArkValue(POS_1); + Ark_Number pos2 = Converter::ArkValue(POS_2); + + auto checkChild = GetRenderNode(accessor_->getChild(peer_, &pos0)); + ASSERT_NE(checkChild, nullptr); + EXPECT_EQ(checkChild->GetFrameNode(), childPeer1->GetFrameNode()); + + checkChild = GetRenderNode(accessor_->getChild(peer_, &pos1)); + ASSERT_NE(checkChild, nullptr); + EXPECT_EQ(checkChild->GetFrameNode(), childPeer2->GetFrameNode()); + + checkChild = GetRenderNode(accessor_->getChild(peer_, &pos2)); + ASSERT_NE(checkChild, nullptr); + EXPECT_EQ(checkChild->GetFrameNode(), nullptr); + DestroyPeer(childPeer1); + DestroyPeer(childPeer2); +} + +/** + * @tc.name: GetFirstChildTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetFirstChildTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->getFirstChild, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto childPeer1 = CreatePeer(); + auto childUINodeRef1 = AceType::DynamicCast(childPeer1->GetFrameNode()); + + auto childPeer2 = CreatePeer(); + auto childUINodeRef2 = AceType::DynamicCast(childPeer2->GetFrameNode()); + + accessor_->appendChild(peer_, childPeer1); + accessor_->appendChild(peer_, childPeer2); + auto childList = peer_->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_2); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef1), POS_0); + EXPECT_EQ(currentUINodeRef->GetChildIndex(childUINodeRef2), POS_1); + + auto checkChild = GetRenderNode(accessor_->getFirstChild(peer_)); + ASSERT_NE(checkChild, nullptr); + EXPECT_EQ(checkChild->GetFrameNode(), childPeer1->GetFrameNode()); + DestroyPeer(childPeer1); + DestroyPeer(childPeer2); +} + +/** + * @tc.name: GetNextSiblingTest1 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetNextSiblingTest1, TestSize.Level1) +{ + ASSERT_NE(accessor_->getNextSibling, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto rootPeer = CreatePeer(); + auto rootUINodeRef = AceType::DynamicCast(rootPeer->GetFrameNode()); + + auto nextPeer = CreatePeer(); + auto nextUINodeRef = AceType::DynamicCast(nextPeer->GetFrameNode()); + + auto prevPeer = CreatePeer(); + auto prevUINodeRef = AceType::DynamicCast(prevPeer->GetFrameNode()); + + accessor_->appendChild(rootPeer, prevPeer); + accessor_->appendChild(rootPeer, peer_); + accessor_->appendChild(rootPeer, nextPeer); + auto childList = rootPeer->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_3); + + auto checkChild = GetRenderNode(accessor_->getNextSibling(peer_)); + ASSERT_NE(checkChild, nullptr); + EXPECT_EQ(checkChild->GetFrameNode(), nextPeer->GetFrameNode()); + DestroyPeer(nextPeer); + DestroyPeer(prevPeer); + DestroyPeer(rootPeer); +} + +/** + * @tc.name: GetNextSiblingTest2 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetNextSiblingTest2, TestSize.Level1) +{ + ASSERT_NE(accessor_->getNextSibling, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto rootPeer = CreatePeer(); + auto rootUINodeRef = AceType::DynamicCast(rootPeer->GetFrameNode()); + + auto nextPeer = CreatePeer(); + auto nextUINodeRef = AceType::DynamicCast(nextPeer->GetFrameNode()); + + auto prevPeer = CreatePeer(); + auto prevUINodeRef = AceType::DynamicCast(prevPeer->GetFrameNode()); + + accessor_->appendChild(rootPeer, prevPeer); + accessor_->appendChild(rootPeer, nextPeer); + accessor_->appendChild(rootPeer, peer_); + auto childList = rootPeer->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_3); + + auto checkChild = GetRenderNode(accessor_->getNextSibling(peer_)); + ASSERT_NE(checkChild, nullptr); + EXPECT_EQ(checkChild->GetFrameNode(), nullptr); + DestroyPeer(nextPeer); + DestroyPeer(prevPeer); + DestroyPeer(rootPeer); +} + +/** + * @tc.name: GetPreviousSiblingTest1 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetPreviousSiblingTest1, TestSize.Level1) +{ + ASSERT_NE(accessor_->getPreviousSibling, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto rootPeer = CreatePeer(); + auto rootUINodeRef = AceType::DynamicCast(rootPeer->GetFrameNode()); + + auto nextPeer = CreatePeer(); + auto nextUINodeRef = AceType::DynamicCast(nextPeer->GetFrameNode()); + + auto prevPeer = CreatePeer(); + auto prevUINodeRef = AceType::DynamicCast(prevPeer->GetFrameNode()); + + accessor_->appendChild(rootPeer, prevPeer); + accessor_->appendChild(rootPeer, peer_); + accessor_->appendChild(rootPeer, nextPeer); + auto childList = rootPeer->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_3); + + auto checkChild = GetRenderNode(accessor_->getPreviousSibling(peer_)); + ASSERT_NE(checkChild, nullptr); + EXPECT_EQ(checkChild->GetFrameNode(), prevPeer->GetFrameNode()); + DestroyPeer(nextPeer); + DestroyPeer(prevPeer); + DestroyPeer(rootPeer); +} + +/** + * @tc.name: GetPreviousSiblingTest2 + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetPreviousSiblingTest2, TestSize.Level1) +{ + ASSERT_NE(accessor_->getPreviousSibling, nullptr); + ASSERT_NE(accessor_->appendChild, nullptr); + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto rootPeer = CreatePeer(); + auto rootUINodeRef = AceType::DynamicCast(rootPeer->GetFrameNode()); + + auto nextPeer = CreatePeer(); + auto nextUINodeRef = AceType::DynamicCast(nextPeer->GetFrameNode()); + + auto prevPeer = CreatePeer(); + auto prevUINodeRef = AceType::DynamicCast(prevPeer->GetFrameNode()); + + accessor_->appendChild(rootPeer, peer_); + accessor_->appendChild(rootPeer, prevPeer); + accessor_->appendChild(rootPeer, nextPeer); + auto childList = rootPeer->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_3); + + auto checkChild = GetRenderNode(accessor_->getPreviousSibling(peer_)); + EXPECT_EQ(checkChild, nullptr); + DestroyPeer(nextPeer); + DestroyPeer(prevPeer); + DestroyPeer(rootPeer); +} + +/** + * @tc.name: DisposeTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, DisposeTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->dispose, nullptr); + + auto currentUINodeRef = AceType::DynamicCast(peer_->GetFrameNode()); + + auto rootPeer = CreatePeer(); + auto rootUINodeRef = AceType::DynamicCast(rootPeer->GetFrameNode()); + + auto otherPeer = CreatePeer(); + auto otherUINodeRef = AceType::DynamicCast(otherPeer->GetFrameNode()); + + accessor_->appendChild(rootPeer, peer_); + accessor_->appendChild(rootPeer, otherPeer); + auto childList = rootPeer->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_2); + EXPECT_EQ(rootUINodeRef->GetChildIndex(currentUINodeRef), POS_0); + EXPECT_EQ(rootUINodeRef->GetChildIndex(otherUINodeRef), POS_1); + + accessor_->dispose(peer_); + childList = rootPeer->GetFrameNode()->GetChildren(); + EXPECT_EQ(childList.size(), CHILD_COUNT_1); + EXPECT_EQ(rootUINodeRef->GetChildIndex(currentUINodeRef), POS_INVALID); + EXPECT_EQ(rootUINodeRef->GetChildIndex(otherUINodeRef), POS_0); + DestroyPeer(otherPeer); + DestroyPeer(rootPeer); +} + +/** + * @tc.name: InvalidateTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, DISABLED_InvalidateTest, TestSize.Level1) +{ +} + +/** + * @tc.name: GetBackgroundColorTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetBackgoundColorTest, TestSize.Level1) +{ + // valid value + ASSERT_NE(accessor_->getBackgroundColor, nullptr); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBackgroundColor(fnode, Color::RED); + auto checkColor = Converter::Convert(accessor_->getBackgroundColor(peer_)); + EXPECT_EQ(checkColor, static_cast(Color::RED.GetValue())); + + // invalid value + ASSERT_NE(accessor_->getBackgroundColor, nullptr); + checkColor = Converter::Convert(accessor_->getBackgroundColor(nullptr)); + EXPECT_EQ(checkColor, static_cast(Color::TRANSPARENT.GetValue())); +} + +/** + * @tc.name: SetBackgroundColorTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetBackgoundColorTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setBackgroundColor, nullptr); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto color = static_cast(Color::RED.GetValue()); + auto arkColor = Converter::ArkValue(color); + accessor_->setBackgroundColor(peer_, &arkColor); + auto checkColor = static_cast(ViewAbstract::GetBackgroundColor(fnode).GetValue()); + EXPECT_EQ(checkColor, color); +} + +/** + * @tc.name: GetLabelTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetLabelTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getLabel, nullptr); + auto checkLabel = Converter::Convert(accessor_->getLabel(peer_)); + EXPECT_EQ(checkLabel, ""); + + // invalid value + checkLabel = Converter::Convert(accessor_->getLabel(nullptr)); + EXPECT_EQ(checkLabel, ""); + + // valid value + const std::string label = "Label"; + peer_->label = label; + checkLabel = Converter::Convert(accessor_->getLabel(peer_)); + EXPECT_EQ(checkLabel, label); +} + +/** + * @tc.name: SetLabelTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetLabelTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setLabel, nullptr); + + // invalid value + accessor_->setLabel(peer_, nullptr); + auto checkLabel = peer_->label; + EXPECT_EQ(checkLabel, ""); + + // valid value + const std::string label = "Label"; + auto arkLabel = Converter::ArkValue(label); + accessor_->setLabel(peer_, &arkLabel); + checkLabel = peer_->label; + EXPECT_EQ(checkLabel, label); +} + +/** + * @tc.name: GetFrameTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetFrameTest, TestSize.Level1) +{ + // invalid value + ASSERT_NE(accessor_->getFrame, nullptr); + auto checkFrame = accessor_->getFrame(nullptr); + auto posX = Converter::Convert(checkFrame.x); + auto posY = Converter::Convert(checkFrame.y); + auto width = Converter::Convert(checkFrame.width); + auto height = Converter::Convert(checkFrame.height); + EXPECT_EQ(posX, 0); + EXPECT_EQ(posY, 0); + EXPECT_EQ(width, 0); + EXPECT_EQ(height, 0); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + OffsetT offset(Dimension(1, DimensionUnit::VP), Dimension(2, DimensionUnit::VP)); + ViewAbstract::SetPosition(fnode, offset); + + auto layoutProperty = fnode->GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + layoutProperty->UpdateUserDefinedIdealSize( + CalcSize(CalcLength(3, DimensionUnit::VP), CalcLength(4, DimensionUnit::VP))); + + checkFrame = accessor_->getFrame(peer_); + posX = Converter::Convert(checkFrame.x); + posY = Converter::Convert(checkFrame.y); + width = Converter::Convert(checkFrame.width); + height = Converter::Convert(checkFrame.height); + EXPECT_EQ(posX, 1); + EXPECT_EQ(posY, 2); + EXPECT_EQ(width, 3); + EXPECT_EQ(height, 4); +} + +/** + * @tc.name: SetFrameTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetFrameTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setFrame, nullptr); + + Ark_Frame arkFrame = { + .x = Converter::ArkValue(1), + .y = Converter::ArkValue(2), + .width = Converter::ArkValue(3), + .height = Converter::ArkValue(4) + }; + accessor_->setFrame(peer_, &arkFrame); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto positionValue = ViewAbstract::GetPosition(fnode); + auto posX = positionValue.GetX().Value(); + auto posY = positionValue.GetY().Value(); + EXPECT_EQ(posX, 1); + EXPECT_EQ(posY, 2); + + auto layoutProperty = fnode->GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + auto calcSizeConv = layoutProperty->GetCalcLayoutConstraint()->selfIdealSize; + ASSERT_NE(calcSizeConv.has_value(), false); + auto width = calcSizeConv.value().Width().value().GetDimension().Value(); + auto height = calcSizeConv.value().Height().value().GetDimension().Value(); + EXPECT_EQ(width, 3); + EXPECT_EQ(height, 4); +} + +/** + * @tc.name: GetMarkNodeGroupTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetMarkNodeGroupTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getMarkNodeGroup, nullptr); + auto checkValue = Converter::Convert(accessor_->getMarkNodeGroup(peer_)); + EXPECT_FALSE(checkValue); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetRenderGroup(fnode, true); + checkValue = Converter::Convert(accessor_->getMarkNodeGroup(peer_)); + EXPECT_TRUE(checkValue); + + // invalid value + checkValue = Converter::Convert(accessor_->getMarkNodeGroup(nullptr)); + EXPECT_FALSE(checkValue); +} + +/** + * @tc.name: SetMarkNodeGroupTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetMarkNodeGroupTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setMarkNodeGroup, nullptr); + accessor_->setMarkNodeGroup(peer_, ARK_TRUE); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetRenderGroup(fnode); + EXPECT_TRUE(checkValue); + + // invalid value + accessor_->setMarkNodeGroup(nullptr, ARK_FALSE); + checkValue = ViewAbstract::GetRenderGroup(fnode); + EXPECT_TRUE(checkValue); +} + +/** + * @tc.name: GetLengthMetricsUnitTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetLengthMetricsUnitTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getLengthMetricsUnit, nullptr); + auto checkValue = accessor_->getLengthMetricsUnit(peer_); + EXPECT_EQ(checkValue, Ark_LengthMetricsUnit::ARK_LENGTH_METRICS_UNIT_DEFAULT); + + // valid value + peer_->lengthMetricsUnit = RenderNodePeer::LengthMetricsUnit::PX; + checkValue = accessor_->getLengthMetricsUnit(peer_); + EXPECT_EQ(checkValue, Ark_LengthMetricsUnit::ARK_LENGTH_METRICS_UNIT_PX); + + // invalid value + checkValue = accessor_->getLengthMetricsUnit(nullptr); + EXPECT_EQ(checkValue, Ark_LengthMetricsUnit::ARK_LENGTH_METRICS_UNIT_DEFAULT); +} + +/** + * @tc.name: SetLengthMetricsUnitTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetLengthMetricsUnitTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setLengthMetricsUnit, nullptr); + accessor_->setLengthMetricsUnit(peer_, Ark_LengthMetricsUnit::ARK_LENGTH_METRICS_UNIT_PX); + EXPECT_EQ(peer_->lengthMetricsUnit, RenderNodePeer::LengthMetricsUnit::PX); + + // invalid value + accessor_->setLengthMetricsUnit(nullptr, Ark_LengthMetricsUnit::ARK_LENGTH_METRICS_UNIT_DEFAULT); + EXPECT_EQ(peer_->lengthMetricsUnit, RenderNodePeer::LengthMetricsUnit::PX); + + accessor_->setLengthMetricsUnit(peer_, Ark_LengthMetricsUnit(-1)); + EXPECT_EQ(peer_->lengthMetricsUnit, RenderNodePeer::LengthMetricsUnit::DEFAULT); +} + +/** + * @tc.name: GetShapeClipTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetShapeClipTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getShapeClip, nullptr); + auto checkValue = accessor_->getShapeClip(peer_); + EXPECT_NE(checkValue->shape, nullptr); + + // valid value + auto basicShape = OHOS::Ace::AceType::MakeRefPtr(); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetClipShape(fnode, basicShape); + checkValue = accessor_->getShapeClip(peer_); + EXPECT_EQ(checkValue->shape, basicShape); + + // invalid value + checkValue = accessor_->getShapeClip(nullptr); + EXPECT_EQ(checkValue, nullptr); +} + +/** + * @tc.name: SetShapeClipTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, DISABLED_SetShapeClipTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setShapeClip, nullptr); + + auto basicShape = OHOS::Ace::AceType::MakeRefPtr(); + auto clipPeer = PeerUtils::CreatePeer(basicShape); + accessor_->setShapeClip(peer_, clipPeer); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetClipShape(fnode); + EXPECT_EQ(checkValue, basicShape); + + // invalid value + accessor_->setShapeClip(peer_, nullptr); + checkValue = ViewAbstract::GetClipShape(fnode); + EXPECT_EQ(checkValue, basicShape); +} + +/** + * @tc.name: GetShapeMaskTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetShapeMaskTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->getShapeMask, nullptr); + // default value + auto checkValue = accessor_->getShapeMask(peer_); + EXPECT_EQ(checkValue->shape, nullptr); + + // valid value + auto basicShape = OHOS::Ace::AceType::MakeRefPtr(); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetMask(fnode, basicShape); + checkValue = accessor_->getShapeMask(peer_); + EXPECT_EQ(checkValue->shape, basicShape); + + // invalid value + checkValue = accessor_->getShapeMask(nullptr); + EXPECT_EQ(checkValue, nullptr); +} + +/** + * @tc.name: SetShapeMaskTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetShapeMaskTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setShapeMask, nullptr); + + auto basicShape = OHOS::Ace::AceType::MakeRefPtr(); + auto clipPeer = PeerUtils::CreatePeer(basicShape); + accessor_->setShapeMask(peer_, clipPeer); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetMask(fnode); + EXPECT_EQ(checkValue, basicShape); + + // invalid value + accessor_->setShapeMask(peer_, nullptr); + checkValue = ViewAbstract::GetMask(fnode); + EXPECT_EQ(checkValue, basicShape); +} + +/** + * @tc.name: GetBorderColorTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetBorderColorTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->getBorderColor, nullptr); + + Color color(0xffff0000); + BorderColorProperty borderColors = { + color, color, color, color, std::nullopt, std::nullopt + }; + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBorderColor(fnode, borderColors); + auto checkColor = Converter::Convert(accessor_->getBorderColor(peer_)); + EXPECT_EQ(checkColor.leftColor.value(), borderColors.leftColor.value()); + EXPECT_EQ(checkColor.rightColor.value(), borderColors.rightColor.value()); + EXPECT_EQ(checkColor.topColor.value(), borderColors.topColor.value()); + EXPECT_EQ(checkColor.bottomColor.value(), borderColors.bottomColor.value()); +} + +/** + * @tc.name: SetBorderColorTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetBorderColorTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setBorderColor, nullptr); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + Color color(0xffff0000); + + Ark_EdgesNumber arkColors = { + .top = Converter::ArkValue(static_cast(color.GetValue())), + .right = Converter::ArkValue(static_cast(color.GetValue())), + .bottom = Converter::ArkValue(static_cast(color.GetValue())), + .left = Converter::ArkValue(static_cast(color.GetValue())) + }; + + accessor_->setBorderColor(peer_, &arkColors); + auto checkColor = ViewAbstract::GetBorderColor(fnode); + EXPECT_EQ(checkColor.leftColor.value(), color); + EXPECT_EQ(checkColor.rightColor.value(), color); + EXPECT_EQ(checkColor.topColor.value(), color); + EXPECT_EQ(checkColor.bottomColor.value(), color); +} + +/** + * @tc.name: GetBorderWidthTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetBorderWidthTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->getBorderWidth, nullptr); + + Dimension dimen(99); + BorderWidthProperty borderWidths = { + dimen, dimen, dimen, dimen, std::nullopt, std::nullopt + }; + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBorderWidth(fnode, borderWidths); + auto checkWidth = Converter::Convert(accessor_->getBorderWidth(peer_)); + EXPECT_EQ(checkWidth.leftDimen.value(), borderWidths.leftDimen.value()); + EXPECT_EQ(checkWidth.rightDimen.value(), borderWidths.rightDimen.value()); + EXPECT_EQ(checkWidth.topDimen.value(), borderWidths.topDimen.value()); + EXPECT_EQ(checkWidth.bottomDimen.value(), borderWidths.bottomDimen.value()); +} + +/** + * @tc.name: SetBorderWidthTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetBorderWidthTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setBorderWidth, nullptr); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + Dimension dimen(99); + Ark_EdgesNumber arkWidths = { + .top = Converter::ArkValue(dimen), + .right = Converter::ArkValue(dimen), + .bottom = Converter::ArkValue(dimen), + .left = Converter::ArkValue(dimen) + }; + + accessor_->setBorderWidth(peer_, &arkWidths, 0); + auto checkWidth = ViewAbstract::GetBorderWidth(fnode); + EXPECT_EQ(checkWidth.leftDimen.value(), dimen); + EXPECT_EQ(checkWidth.rightDimen.value(), dimen); + EXPECT_EQ(checkWidth.topDimen.value(), dimen); + EXPECT_EQ(checkWidth.bottomDimen.value(), dimen); +} + +/** + * @tc.name: GetBorderStyleTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetBorderStyleTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->getBorderStyle, nullptr); + + BorderStyle style = BorderStyle::SOLID; + BorderStyleProperty borderStyles = { + style, style, style, style + }; + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBorderStyle(fnode, borderStyles); + auto checkStyle = Converter::Convert(accessor_->getBorderStyle(peer_)); + EXPECT_EQ(checkStyle.styleLeft.value(), borderStyles.styleLeft.value()); + EXPECT_EQ(checkStyle.styleRight.value(), borderStyles.styleRight.value()); + EXPECT_EQ(checkStyle.styleTop.value(), borderStyles.styleTop.value()); + EXPECT_EQ(checkStyle.styleBottom.value(), borderStyles.styleBottom.value()); +} + +/** + * @tc.name: SetBorderStyleTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetBorderStyleTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setBorderStyle, nullptr); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + Ark_BorderStyle style = Ark_BorderStyle::ARK_BORDER_STYLE_SOLID; + Ark_EdgeStyles arkStyles = { + .top = Converter::ArkValue(style), + .right = Converter::ArkValue(style), + .bottom = Converter::ArkValue(style), + .left = Converter::ArkValue(style) + }; + + accessor_->setBorderStyle(peer_, &arkStyles); + auto checkStyle = ViewAbstract::GetBorderStyle(fnode); + EXPECT_EQ(checkStyle.styleLeft.value(), Converter::OptConvert(style).value()); + EXPECT_EQ(checkStyle.styleRight.value(), Converter::OptConvert(style).value()); + EXPECT_EQ(checkStyle.styleTop.value(), Converter::OptConvert(style).value()); + EXPECT_EQ(checkStyle.styleBottom.value(), Converter::OptConvert(style).value()); + EXPECT_EQ(checkStyle.styleBottom.value(), Converter::OptConvert(style).value()); +} + +/** + * @tc.name: GetBorderRadiusTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetBorderRadiusTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->getBorderRadius, nullptr); + + Dimension dimen(9); + BorderRadiusProperty borderRadiuses = { + dimen, dimen, dimen, dimen + }; + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBorderRadius(fnode, borderRadiuses); + auto checkRadius = Converter::Convert(accessor_->getBorderRadius(peer_)); + + EXPECT_EQ(checkRadius.radiusTopLeft.value().Value(), borderRadiuses.radiusTopLeft.value().Value()); + EXPECT_EQ(checkRadius.radiusTopRight.value().Value(), borderRadiuses.radiusTopRight.value().Value()); + EXPECT_EQ(checkRadius.radiusBottomLeft.value().Value(), borderRadiuses.radiusBottomLeft.value().Value()); + EXPECT_EQ(checkRadius.radiusBottomRight.value().Value(), borderRadiuses.radiusBottomRight.value().Value()); +} + +/** + * @tc.name: SetBorderRadiusTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetBorderRadiusTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setBorderRadius, nullptr); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + + auto radius = 9.f; + Ark_BorderRadiuses_graphics arkRadiuses{ + .topLeft = Converter::ArkValue(radius), + .topRight = Converter::ArkValue(radius), + .bottomLeft = Converter::ArkValue(radius), + .bottomRight = Converter::ArkValue(radius), + }; + + accessor_->setBorderRadius(peer_, &arkRadiuses, 0); + auto checkRadius = ViewAbstract::GetBorderRadius(fnode); + EXPECT_EQ(checkRadius.radiusTopLeft.value().Value(), radius); + EXPECT_EQ(checkRadius.radiusTopRight.value().Value(), radius); + EXPECT_EQ(checkRadius.radiusBottomLeft.value().Value(), radius); + EXPECT_EQ(checkRadius.radiusBottomRight.value().Value(), radius); +} + +/** + * @tc.name: GetClipToFrameTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetClipToFrameTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getClipToFrame, nullptr); + auto checkValue = Converter::Convert(accessor_->getClipToFrame(peer_)); + EXPECT_FALSE(checkValue); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetClipEdge(fnode, true); + checkValue = Converter::Convert(accessor_->getClipToFrame(peer_)); + EXPECT_TRUE(checkValue); + + // invalid value + checkValue = Converter::Convert(accessor_->getClipToFrame(nullptr)); + EXPECT_TRUE(checkValue); +} + +/** + * @tc.name: SetClipToFrameTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetClipToFrameTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setClipToFrame, nullptr); + accessor_->setClipToFrame(peer_, ARK_TRUE); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetClip(fnode); + EXPECT_TRUE(checkValue); + + // invalid value + accessor_->setClipToFrame(nullptr, ARK_FALSE); + checkValue = ViewAbstract::GetClip(fnode); + EXPECT_TRUE(checkValue); +} + +/** + * @tc.name: GetOpacityTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetOpacityTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getOpacity, nullptr); + auto checkValue = Converter::Convert(accessor_->getOpacity(peer_)); + EXPECT_EQ(checkValue, 1.000000); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetOpacity(fnode, 0.5f); + checkValue = Converter::Convert(accessor_->getOpacity(peer_)); + EXPECT_EQ(checkValue, 0.500000); + + // invalid value + checkValue = Converter::Convert(accessor_->getOpacity(nullptr)); + EXPECT_EQ(checkValue, 1.000000); +} + +/** + * @tc.name: SetOpacityTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetOpacityTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setOpacity, nullptr); + + auto opacity = Converter::ArkValue(0.5f); + accessor_->setOpacity(peer_, &opacity); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetOpacity(fnode); + EXPECT_EQ(checkValue, 0.500000); + + // invalid value + opacity = Converter::ArkValue(2.0f); + accessor_->setOpacity(peer_, &opacity); + checkValue = ViewAbstract::GetOpacity(fnode); + EXPECT_EQ(checkValue, 1.000000); + + opacity = Converter::ArkValue(-1.0f); + accessor_->setOpacity(peer_, &opacity); + checkValue = ViewAbstract::GetOpacity(fnode); + EXPECT_EQ(checkValue, 0.000000); +} + +/** + * @tc.name: GetSizeTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetSizeTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getSize, nullptr); + auto checkValue = accessor_->getSize(peer_); + EXPECT_EQ(Converter::Convert(checkValue.width), 0.000000); + EXPECT_EQ(Converter::Convert(checkValue.height), 0.000000); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto layoutProperty = fnode->GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + + layoutProperty->UpdateUserDefinedIdealSize(CalcSize( + CalcLength(1.f, DimensionUnit::VP), CalcLength(2.f, DimensionUnit::VP))); + checkValue = accessor_->getSize(peer_); + EXPECT_EQ(Converter::Convert(checkValue.width), 1.000000); + EXPECT_EQ(Converter::Convert(checkValue.height), 2.000000); + + // invalid value + checkValue = accessor_->getSize(nullptr); + EXPECT_EQ(Converter::Convert(checkValue.width), 0.000000); + EXPECT_EQ(Converter::Convert(checkValue.height), 0.000000); +} + +/** + * @tc.name: SetSizeTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetSizeTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setSize, nullptr); + + Ark_Size size = { + .width = Converter::ArkValue(1.f), + .height = Converter::ArkValue(2.f), + }; + accessor_->setSize(peer_, &size, 0); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto layoutProperty = fnode->GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + + auto calcSizeConv = layoutProperty->GetCalcLayoutConstraint()->selfIdealSize; + ASSERT_TRUE(calcSizeConv.has_value()); + + auto width = calcSizeConv.value().Width().value_or(CalcLength()).GetDimension(); + auto height = calcSizeConv.value().Height().value_or(CalcLength()).GetDimension(); + EXPECT_EQ(width.Value(), 1.000000); + EXPECT_EQ(height.Value(), 2.000000); + + // invalid value + size = { + .width = Converter::ArkValue(-1.f), + .height = Converter::ArkValue(-2.f), + }; + accessor_->setSize(peer_, &size, 0); + + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + layoutProperty = fnode->GetLayoutProperty(); + ASSERT_NE(layoutProperty, nullptr); + + calcSizeConv = layoutProperty->GetCalcLayoutConstraint()->selfIdealSize; + ASSERT_TRUE(calcSizeConv.has_value()); + + width = calcSizeConv.value().Width().value_or(CalcLength()).GetDimension(); + height = calcSizeConv.value().Height().value_or(CalcLength()).GetDimension(); + EXPECT_EQ(width.Value(), 0.000000); + EXPECT_EQ(height.Value(), 0.000000); +} + +/** + * @tc.name: GetPositionTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetPositionTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getPosition, nullptr); + auto checkValue = Converter::Convert>(accessor_->getPosition(peer_)); + EXPECT_EQ(checkValue.first.Value(), 0.000000); + EXPECT_EQ(checkValue.second.Value(), 0.000000); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto offset = OffsetT(Dimension(10, DimensionUnit::VP), Dimension(20, DimensionUnit::VP)); + ViewAbstract::SetPosition(fnode, offset); + checkValue = Converter::Convert>(accessor_->getPosition(peer_)); + EXPECT_EQ(checkValue.first.Value(), 10.000000); + EXPECT_EQ(checkValue.second.Value(), 20.000000); + + // invalid value + checkValue = Converter::Convert>(accessor_->getPosition(nullptr)); + EXPECT_EQ(checkValue.first.Value(), 0.000000); + EXPECT_EQ(checkValue.second.Value(), 0.000000); +} + +/** + * @tc.name: SetPositionTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetPositionTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setPosition, nullptr); + + Ark_Position position = { + .x = Converter::ArkValue(1.f), + .y = Converter::ArkValue(2.f) + }; + accessor_->setPosition(peer_, &position, 0); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetPosition(fnode); + EXPECT_EQ(checkValue.GetX().Value(), 1.000000); + EXPECT_EQ(checkValue.GetY().Value(), 2.000000); + + // invalid value + accessor_->setPosition(peer_, nullptr, 0); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + checkValue = ViewAbstract::GetPosition(fnode); + EXPECT_EQ(checkValue.GetX().Value(), 1.000000); + EXPECT_EQ(checkValue.GetY().Value(), 2.000000); +} + +/** + * @tc.name: GetPivotTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetPivotTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getPivot, nullptr); + auto checkValue = accessor_->getPivot(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 0.5f); + EXPECT_EQ(Converter::Convert(checkValue.y), 0.5f); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto pivot = DimensionOffset(Dimension(0.5f), Dimension(0.7f)); + ViewAbstract::SetPivot(fnode, pivot); + checkValue = accessor_->getPivot(peer_); + EXPECT_NEAR(Converter::Convert(checkValue.x), 0.5f, FLT_EPSILON); + EXPECT_NEAR(Converter::Convert(checkValue.y), 0.7f, FLT_EPSILON); + // invalid value + checkValue = accessor_->getPivot(nullptr); + EXPECT_NEAR(Converter::Convert(checkValue.x), 0.5f, FLT_EPSILON); + EXPECT_NEAR(Converter::Convert(checkValue.y), 0.5f, FLT_EPSILON); +} + +/** + * @tc.name: SetPivotTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetPivotTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setPivot, nullptr); + + Ark_Vector2 arkPivot { + .x = Converter::ArkValue(0.5f), + .y = Converter::ArkValue(0.7f) + }; + accessor_->setPivot(peer_, &arkPivot); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto renderContext = fnode->GetRenderContext(); + ASSERT_NE(renderContext, nullptr); + auto checkValue = renderContext->GetTransformCenter(); + ASSERT_TRUE(checkValue.has_value()); + EXPECT_NEAR(checkValue.value().GetX().Value(), 0.5f, FLT_EPSILON); + EXPECT_NEAR(checkValue.value().GetY().Value(), 0.7f, FLT_EPSILON); + + // invalid value + accessor_->setPivot(peer_, nullptr); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + renderContext = fnode->GetRenderContext(); + ASSERT_NE(renderContext, nullptr); + checkValue = renderContext->GetTransformCenter(); + ASSERT_TRUE(checkValue.has_value()); + EXPECT_NEAR(checkValue.value().GetX().Value(), 0.5f, FLT_EPSILON); + EXPECT_NEAR(checkValue.value().GetY().Value(), 0.7f, FLT_EPSILON); +} + +/** + * @tc.name: GetScaleTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetScaleTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getScale, nullptr); + auto checkValue = accessor_->getScale(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 1.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 1.f); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetScale(Referenced::RawPtr(peer_->GetFrameNode()), VectorF(1.f, 2.f)); + checkValue = accessor_->getScale(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 1.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 2.f); + + // invalid value + checkValue = accessor_->getScale(nullptr); + EXPECT_EQ(Converter::Convert(checkValue.x), 1.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 1.f); +} + +/** + * @tc.name: SetScaleTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetScaleTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setScale, nullptr); + + Ark_Vector2 arkScale { + .x = Converter::ArkValue(0.5f), + .y = Converter::ArkValue(0.7f) + }; + accessor_->setScale(peer_, &arkScale); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetScale(fnode); + EXPECT_EQ(checkValue.x, 0.5f); + EXPECT_EQ(checkValue.y, 0.7f); + + // invalid value + accessor_->setScale(peer_, nullptr); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + checkValue = ViewAbstract::GetScale(fnode); + EXPECT_EQ(checkValue.x, 0.5f); + EXPECT_EQ(checkValue.y, 0.7f); + + arkScale = { + .x = Converter::ArkValue(-0.5f), + .y = Converter::ArkValue(-0.7f) + }; + accessor_->setScale(peer_, &arkScale); + + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + checkValue = ViewAbstract::GetScale(fnode); + EXPECT_EQ(checkValue.x, 1.f); + EXPECT_EQ(checkValue.y, 1.f); +} + +/** + * @tc.name: GetTranslationTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetTranslationTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getTranslation, nullptr); + auto checkValue = accessor_->getTranslation(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 0.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 0.f); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetTranslate(fnode, + TranslateOptions(CalcDimension(1.f), CalcDimension(2.f), CalcDimension(0.f))); + checkValue = accessor_->getTranslation(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 1.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 2.f); + + // invalid value + checkValue = accessor_->getTranslation(nullptr); + EXPECT_EQ(Converter::Convert(checkValue.x), 0.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 0.f); +} + +/** + * @tc.name: SetTranslationTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetTranslationTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setTranslation, nullptr); + + Ark_Vector2 arkTranslation { + .x = Converter::ArkValue(0.5f), + .y = Converter::ArkValue(0.7f) + }; + accessor_->setTranslation(peer_, &arkTranslation); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetTranslate(fnode); + EXPECT_EQ(checkValue.x.Value(), 0.5f); + EXPECT_EQ(checkValue.y.Value(), 0.7f); + + // invalid value + accessor_->setTranslation(peer_, nullptr); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + checkValue = ViewAbstract::GetTranslate(fnode); + EXPECT_EQ(checkValue.x.Value(), 0.5f); + EXPECT_EQ(checkValue.y.Value(), 0.7f); + + arkTranslation = { + .x = Converter::ArkValue(-0.5f), + .y = Converter::ArkValue(-0.7f) + }; + accessor_->setTranslation(peer_, &arkTranslation); + + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + checkValue = ViewAbstract::GetTranslate(fnode); + EXPECT_EQ(checkValue.x.Value(), 0.f); + EXPECT_EQ(checkValue.y.Value(), 0.f); +} + +/** + * @tc.name: GetRotationTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetRotationTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getRotation, nullptr); + auto checkValue = accessor_->getRotation(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 0.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 0.f); + EXPECT_EQ(Converter::Convert(checkValue.z), 0.f); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetRotate(fnode, Vector5F(1.f, 2.f, 3.f, 0.f, 0.f)); + checkValue = accessor_->getRotation(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 1.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 2.f); + EXPECT_EQ(Converter::Convert(checkValue.z), 3.f); + + // invalid value + checkValue = accessor_->getRotation(nullptr); + EXPECT_EQ(Converter::Convert(checkValue.x), 0.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 0.f); + EXPECT_EQ(Converter::Convert(checkValue.z), 0.f); +} + +/** + * @tc.name: SetRotationTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetRotationTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setRotation, nullptr); + + Ark_Vector3 arkRotation { + .x = Converter::ArkValue(0.5f), + .y = Converter::ArkValue(0.7f), + .z = Converter::ArkValue(0.9f) + }; + accessor_->setRotation(peer_, &arkRotation, 0); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetRotate(fnode); + EXPECT_EQ(checkValue.x, 0.5f); + EXPECT_EQ(checkValue.y, 0.7f); + EXPECT_EQ(checkValue.z, 0.9f); + + // invalid value + accessor_->setRotation(peer_, nullptr, 0); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + checkValue = ViewAbstract::GetRotate(fnode); + EXPECT_EQ(checkValue.x, 0.5f); + EXPECT_EQ(checkValue.y, 0.7f); + EXPECT_EQ(checkValue.z, 0.9f); + + arkRotation = { + .x = Converter::ArkValue(-0.5f), + .y = Converter::ArkValue(-0.7f), + .z = Converter::ArkValue(-0.9f) + }; + accessor_->setRotation(peer_, &arkRotation, 0); + + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + checkValue = ViewAbstract::GetRotate(fnode); + EXPECT_EQ(checkValue.x, 0.f); + EXPECT_EQ(checkValue.y, 0.f); + EXPECT_EQ(checkValue.z, 0.f); +} + +/** + * @tc.name: GetTrasformTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetTrasformTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getTransform, nullptr); + auto matrix = Matrix4(1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f); + auto checkValue = accessor_->getTransform(peer_); + EXPECT_EQ(Converter::Convert(checkValue), matrix); + + // invalid value + checkValue = accessor_->getTransform(nullptr); + EXPECT_EQ(Converter::Convert(checkValue), matrix); + + // valid value + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + matrix = Matrix4(1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f); + ViewAbstract::SetTransformMatrix(fnode, matrix); + checkValue = accessor_->getTransform(peer_); + EXPECT_EQ(Converter::Convert(checkValue), matrix); +} + +/** + * @tc.name: SetTransformTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetTransformTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setTransform, nullptr); + auto matrix = Matrix4(1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f); + + Ark_Matrix4 arkMatrix = { + .value0 = Converter::ArkValue(1.f), + .value1 = Converter::ArkValue(1.f), + .value2 = Converter::ArkValue(1.f), + .value3 = Converter::ArkValue(1.f), + .value4 = Converter::ArkValue(1.f), + .value5 = Converter::ArkValue(1.f), + .value6 = Converter::ArkValue(1.f), + .value7 = Converter::ArkValue(1.f), + .value8 = Converter::ArkValue(1.f), + .value9 = Converter::ArkValue(1.f), + .value10 = Converter::ArkValue(1.f), + .value11 = Converter::ArkValue(1.f), + .value12 = Converter::ArkValue(1.f), + .value13 = Converter::ArkValue(1.f), + .value14 = Converter::ArkValue(1.f), + .value15 = Converter::ArkValue(1.f) + }; + accessor_->setTransform(peer_, &arkMatrix); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto checkValue = ViewAbstract::GetTransform(fnode); + EXPECT_EQ(checkValue, matrix); + + // invalid value + accessor_->setRotation(peer_, nullptr, 0); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + checkValue = ViewAbstract::GetTransform(fnode); + EXPECT_EQ(checkValue, matrix); +} + +/** + * @tc.name: GetShadowColorTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetShadowColorTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getShadowColor, nullptr); + auto checkValue = accessor_->getShadowColor(peer_); + EXPECT_EQ(Converter::Convert(checkValue), Color::BLACK.GetValue()); + + // valid value + Shadow shadow; + shadow.SetColor(Color::RED); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBackShadow(fnode, shadow); + checkValue = accessor_->getShadowColor(peer_); + EXPECT_EQ(Converter::Convert(checkValue), Color::RED.GetValue()); + + // invalid value + checkValue = accessor_->getShadowColor(nullptr); + EXPECT_EQ(Converter::Convert(checkValue), Color::TRANSPARENT.GetValue()); +} + +/** + * @tc.name: SetShadowColorTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetShadowColorTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setShadowColor, nullptr); + + auto color = static_cast(Color::RED.GetValue()); + auto arkColor = Converter::ArkValue(color); + accessor_->setShadowColor(peer_, &arkColor); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + auto checkValue = shadow.value().GetColor(); + EXPECT_EQ(checkValue.GetValue(), Color::RED.GetValue()); + + // invalid value + accessor_->setShadowColor(peer_, nullptr); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + checkValue = shadow.value().GetColor(); + EXPECT_EQ(checkValue.GetValue(), Color::RED.GetValue()); +} + +/** + * @tc.name: GetShadowOffsetTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetShadowOffsetTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getShadowOffset, nullptr); + auto checkValue = accessor_->getShadowOffset(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 0.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 0.f); + + // valid value + Offset offset {1.f, 2.f}; + Shadow shadow; + shadow.SetOffset(offset); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBackShadow(fnode, shadow); + checkValue = accessor_->getShadowOffset(peer_); + EXPECT_EQ(Converter::Convert(checkValue.x), 1.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 2.f); + + // invalid value + checkValue = accessor_->getShadowOffset(nullptr); + EXPECT_EQ(Converter::Convert(checkValue.x), 0.f); + EXPECT_EQ(Converter::Convert(checkValue.y), 0.f); +} + +/** + * @tc.name: SetShadowOffsetTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetShadowOffsetTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setShadowOffset, nullptr); + + Ark_Vector2 arkOffset = { + .x = Converter::ArkValue(1.f), + .y = Converter::ArkValue(2.f) + }; + accessor_->setShadowOffset(peer_, &arkOffset, 0); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + auto checkValue = shadow.value().GetOffset(); + EXPECT_EQ(checkValue.GetX(), 1.f); + EXPECT_EQ(checkValue.GetY(), 2.f); + + // invalid value + accessor_->setShadowColor(peer_, nullptr); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + checkValue = shadow.value().GetOffset(); + EXPECT_EQ(checkValue.GetX(), 1.f); + EXPECT_EQ(checkValue.GetY(), 2.f); +} + +/** + * @tc.name: GetShadowAlphaTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetShadowAlphaTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getShadowAlpha, nullptr); + auto checkValue = accessor_->getShadowAlpha(peer_); + EXPECT_EQ(Converter::Convert(checkValue), 0); + + // valid value + peer_->shadowAlpha = 1; + checkValue = accessor_->getShadowAlpha(peer_); + EXPECT_EQ(Converter::Convert(checkValue), 1); + + // invalid value + checkValue = accessor_->getShadowAlpha(nullptr); + EXPECT_EQ(Converter::Convert(checkValue), 0); +} + +/** + * @tc.name: SetShadowAlphaTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetShadowAlphaTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setShadowAlpha, nullptr); + + auto color = static_cast(Color::TRANSPARENT.GetValue()); + auto arkColor = Converter::ArkValue(color); + accessor_->setShadowColor(peer_, &arkColor); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + auto shadowColor = shadow.value().GetColor(); + EXPECT_EQ(shadowColor.GetValue(), Color::TRANSPARENT.GetValue()); + + Ark_Number arkAlpha = Converter::ArkValue(1); + accessor_->setShadowAlpha(peer_, &arkAlpha); + + ASSERT_TRUE(peer_->shadowAlpha.has_value()); + EXPECT_EQ(peer_->shadowAlpha.value(), 1); + + shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + auto checkValue = shadow.value().GetColor().GetAlpha(); + EXPECT_EQ(checkValue, 1); +} + +/** + * @tc.name: GetShadowElevationTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetShadowElevationTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getShadowElevation, nullptr); + auto checkValue = accessor_->getShadowElevation(peer_); + EXPECT_EQ(Converter::Convert(checkValue), 0.f); + + // valid value + float elevation {1.f}; + Shadow shadow; + shadow.SetElevation(elevation); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBackShadow(fnode, shadow); + checkValue = accessor_->getShadowElevation(peer_); + EXPECT_EQ(Converter::Convert(checkValue), 1.f); + + // invalid value + checkValue = accessor_->getShadowElevation(nullptr); + EXPECT_EQ(Converter::Convert(checkValue), 0.f); +} + +/** + * @tc.name: SetShadowElevationTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetShadowElevationTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setShadowElevation, nullptr); + + Ark_Number arkElevation = Converter::ArkValue(1); + accessor_->setShadowElevation(peer_, &arkElevation); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + auto checkValue = shadow.value().GetElevation(); + EXPECT_EQ(checkValue, 1.f); + + // invalid value + accessor_->setShadowColor(peer_, nullptr); + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + checkValue = shadow.value().GetElevation(); + EXPECT_EQ(checkValue, 1.f); +} + +/** + * @tc.name: GetShadowRadiusTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, GetShadowRadiusTest, TestSize.Level1) +{ + // default value + ASSERT_NE(accessor_->getShadowRadius, nullptr); + auto checkValue = accessor_->getShadowRadius(peer_); + EXPECT_EQ(Converter::Convert(checkValue), 0.f); + + // valid value + float radius {1.f}; + Shadow shadow; + shadow.SetBlurRadius(radius); + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + ViewAbstract::SetBackShadow(fnode, shadow); + checkValue = accessor_->getShadowRadius(peer_); + EXPECT_EQ(Converter::Convert(checkValue), 1.f); + + // invalid value + checkValue = accessor_->getShadowRadius(nullptr); + EXPECT_EQ(Converter::Convert(checkValue), 0.f); +} + +/** + * @tc.name: SetShadowRadiusTest + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(RenderNodeAccessorTest, SetShadowRadiusTest, TestSize.Level1) +{ + ASSERT_NE(accessor_->setShadowRadius, nullptr); + + Ark_Number arkRadius = Converter::ArkValue(1); + accessor_->setShadowRadius(peer_, &arkRadius); + + auto fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + auto shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + auto checkValue = shadow.value().GetBlurRadius(); + EXPECT_EQ(checkValue, 1.f); + + // invalid value + arkRadius = Converter::ArkValue(-1); + accessor_->setShadowRadius(peer_, &arkRadius); + + fnode = Referenced::RawPtr(peer_->GetFrameNode()); + ASSERT_NE(fnode, nullptr); + shadow = ViewAbstract::GetShadow(fnode); + ASSERT_TRUE(shadow.has_value()); + checkValue = shadow.value().GetBlurRadius(); + EXPECT_EQ(checkValue, 0.f); +} +} // namespace OHOS::Ace::NG diff --git a/test/unittest/capi/accessors/shape_clip_accessor_test.cpp b/test/unittest/capi/accessors/shape_clip_accessor_test.cpp index f97535e62e61416a82d96b75ec6bef6e84587af8..2518eb4a82bf3db2d7a3f8f79a3ba683d4554aab 100755 --- a/test/unittest/capi/accessors/shape_clip_accessor_test.cpp +++ b/test/unittest/capi/accessors/shape_clip_accessor_test.cpp @@ -64,15 +64,11 @@ HWTEST_F(ShapeClipAccessorTest, setRectShapeTopLeftTest, TestSize.Level1) auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value()); auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value()); - ASSERT_NE(peer_->rect, nullptr); - EXPECT_EQ(peer_->rect->GetPosition().GetX(), expectedX); - EXPECT_EQ(peer_->rect->GetPosition().GetY(), expectedY); - EXPECT_EQ(peer_->rect->GetWidth(), expectedW); - EXPECT_EQ(peer_->rect->GetHeight(), expectedH); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); } } } @@ -100,15 +96,11 @@ HWTEST_F(ShapeClipAccessorTest, setRectShapeRightBottomTest, TestSize.Level1) auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE); auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->rect, nullptr); - EXPECT_EQ(peer_->rect->GetPosition().GetX(), expectedD); - EXPECT_EQ(peer_->rect->GetPosition().GetY(), expectedD); - EXPECT_EQ(peer_->rect->GetWidth(), expectedW); - EXPECT_EQ(peer_->rect->GetHeight(), expectedH); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); } } } @@ -146,24 +138,21 @@ HWTEST_F(ShapeClipAccessorTest, setRoundRectShapeTopLeftTest, TestSize.Level1) auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value()); auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value()); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->roundRect->GetPosition().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetPosition().GetY(), expectedY); - EXPECT_EQ(peer_->roundRect->GetWidth(), expectedW); - EXPECT_EQ(peer_->roundRect->GetHeight(), expectedH); - EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetY(), expectedY); - EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetY(), expectedD); - EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetY(), expectedY); - EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetY(), expectedD); - - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); + auto roundShapeRect = AceType::DynamicCast(peer_->shape); + ASSERT_NE(roundShapeRect, nullptr); + EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetX(), expectedX); + EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetY(), expectedY); + EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetX(), expectedD); + EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetY(), expectedD); + EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetX(), expectedX); + EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetY(), expectedY); + EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetX(), expectedD); + EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetY(), expectedD); } } } @@ -201,24 +190,21 @@ HWTEST_F(ShapeClipAccessorTest, setRoundRectShapeRightBottomTest, TestSize.Level auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE); auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->roundRect->GetPosition().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetPosition().GetY(), expectedD); - EXPECT_EQ(peer_->roundRect->GetWidth(), expectedW); - EXPECT_EQ(peer_->roundRect->GetHeight(), expectedH); - EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetY(), expectedD); - EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetY(), expectedY); - EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetY(), expectedD); - EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetY(), expectedY); - - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); + auto roundShapeRect = AceType::DynamicCast(peer_->shape); + ASSERT_NE(roundShapeRect, nullptr); + EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetX(), expectedD); + EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetY(), expectedD); + EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetX(), expectedX); + EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetY(), expectedY); + EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetX(), expectedD); + EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetY(), expectedD); + EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetX(), expectedX); + EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetY(), expectedY); } } } @@ -243,14 +229,12 @@ HWTEST_F(ShapeClipAccessorTest, setCircleShapeXYTest, TestSize.Level1) accessor_->setCircleShape(peer_, &circle); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->circle, nullptr); - EXPECT_EQ(peer_->circle->GetPosition().GetX(), expectedX); - EXPECT_EQ(peer_->circle->GetPosition().GetY(), expectedY); - EXPECT_EQ(peer_->circle->GetRadius(), expectedD); - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY); + auto circleShape = AceType::DynamicCast(peer_->shape); + ASSERT_NE(circleShape, nullptr); + EXPECT_EQ(circleShape->GetRadius(), expectedD); } } } @@ -274,16 +258,14 @@ HWTEST_F(ShapeClipAccessorTest, setCircleShapeRadiusTest, TestSize.Level1) accessor_->setCircleShape(peer_, &circle); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->circle, nullptr); - EXPECT_EQ(peer_->circle->GetPosition().GetX(), expectedD); - EXPECT_EQ(peer_->circle->GetPosition().GetY(), expectedD); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD); if (expectedR.IsValid()) { - EXPECT_EQ(peer_->circle->GetRadius(), expectedR); + auto circleShape = AceType::DynamicCast(peer_->shape); + ASSERT_NE(circleShape, nullptr); + EXPECT_EQ(circleShape->GetRadius(), expectedR); } - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); } } @@ -309,15 +291,11 @@ HWTEST_F(ShapeClipAccessorTest, setOvalShapeTopLeftTest, TestSize.Level1) auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value()); auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value()); - ASSERT_NE(peer_->oval, nullptr); - EXPECT_EQ(peer_->oval->GetPosition().GetX(), expectedX); - EXPECT_EQ(peer_->oval->GetPosition().GetY(), expectedY); - EXPECT_EQ(peer_->oval->GetWidth(), expectedW); - EXPECT_EQ(peer_->oval->GetHeight(), expectedH); - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); } } } @@ -345,15 +323,11 @@ HWTEST_F(ShapeClipAccessorTest, setOvalShapeRightBottomTest, TestSize.Level1) auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE); auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->oval, nullptr); - EXPECT_EQ(peer_->oval->GetPosition().GetX(), expectedD); - EXPECT_EQ(peer_->oval->GetPosition().GetY(), expectedD); - EXPECT_EQ(peer_->oval->GetWidth(), expectedW); - EXPECT_EQ(peer_->oval->GetHeight(), expectedH); - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); } } } @@ -373,12 +347,10 @@ HWTEST_F(ShapeClipAccessorTest, setCommandPathTest, TestSize.Level1) }; accessor_->setCommandPath(peer_, &path); - ASSERT_NE(peer_->path, std::nullopt); - EXPECT_EQ(peer_->path.value(), expectedP); - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); + ASSERT_NE(peer_->shape, nullptr); + auto pathShape = AceType::DynamicCast(peer_->shape); + ASSERT_NE(pathShape, nullptr); + EXPECT_EQ(pathShape->GetValue(), expectedP); } } -} // namespace OHOS::Ace::NG \ No newline at end of file +} // namespace OHOS::Ace::NG diff --git a/test/unittest/capi/accessors/shape_mask_accessor_test.cpp b/test/unittest/capi/accessors/shape_mask_accessor_test.cpp index a7c80c21ebf40afcd929f15e8eb0dfa8e4717fec..d38a8a8772e76d371355d96d23cbe11d7d8b76a2 100644 --- a/test/unittest/capi/accessors/shape_mask_accessor_test.cpp +++ b/test/unittest/capi/accessors/shape_mask_accessor_test.cpp @@ -82,15 +82,11 @@ HWTEST_F(ShapeMaskAccessorTest, setRectShapeTopLeftTest, TestSize.Level1) auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value()); auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value()); - ASSERT_NE(peer_->rect, nullptr); - EXPECT_EQ(peer_->rect->GetPosition().GetX(), expectedX); - EXPECT_EQ(peer_->rect->GetPosition().GetY(), expectedY); - EXPECT_EQ(peer_->rect->GetWidth(), expectedW); - EXPECT_EQ(peer_->rect->GetHeight(), expectedH); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); } } } @@ -118,15 +114,11 @@ HWTEST_F(ShapeMaskAccessorTest, setRectShapeRightBottomTest, TestSize.Level1) auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE); auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->rect, nullptr); - EXPECT_EQ(peer_->rect->GetPosition().GetX(), expectedD); - EXPECT_EQ(peer_->rect->GetPosition().GetY(), expectedD); - EXPECT_EQ(peer_->rect->GetWidth(), expectedW); - EXPECT_EQ(peer_->rect->GetHeight(), expectedH); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); } } } @@ -164,24 +156,21 @@ HWTEST_F(ShapeMaskAccessorTest, setRoundRectShapeTopLeftTest, TestSize.Level1) auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value()); auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value()); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->roundRect->GetPosition().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetPosition().GetY(), expectedY); - EXPECT_EQ(peer_->roundRect->GetWidth(), expectedW); - EXPECT_EQ(peer_->roundRect->GetHeight(), expectedH); - EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetY(), expectedY); - EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetY(), expectedD); - EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetY(), expectedY); - EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetY(), expectedD); - - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); + auto roundShapeRect = AceType::DynamicCast(peer_->shape); + ASSERT_NE(roundShapeRect, nullptr); + EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetX(), expectedX); + EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetY(), expectedY); + EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetX(), expectedD); + EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetY(), expectedD); + EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetX(), expectedX); + EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetY(), expectedY); + EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetX(), expectedD); + EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetY(), expectedD); } } } @@ -219,24 +208,21 @@ HWTEST_F(ShapeMaskAccessorTest, setRoundRectShapeRightBottomTest, TestSize.Level auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE); auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->roundRect->GetPosition().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetPosition().GetY(), expectedD); - EXPECT_EQ(peer_->roundRect->GetWidth(), expectedW); - EXPECT_EQ(peer_->roundRect->GetHeight(), expectedH); - EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetTopLeftRadius().GetY(), expectedD); - EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetTopRightRadius().GetY(), expectedY); - EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetX(), expectedD); - EXPECT_EQ(peer_->roundRect->GetBottomLeftRadius().GetY(), expectedD); - EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetX(), expectedX); - EXPECT_EQ(peer_->roundRect->GetBottomRightRadius().GetY(), expectedY); - - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); + auto roundShapeRect = AceType::DynamicCast(peer_->shape); + ASSERT_NE(roundShapeRect, nullptr); + EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetX(), expectedD); + EXPECT_EQ(roundShapeRect->GetTopLeftRadius().GetY(), expectedD); + EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetX(), expectedX); + EXPECT_EQ(roundShapeRect->GetTopRightRadius().GetY(), expectedY); + EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetX(), expectedD); + EXPECT_EQ(roundShapeRect->GetBottomLeftRadius().GetY(), expectedD); + EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetX(), expectedX); + EXPECT_EQ(roundShapeRect->GetBottomRightRadius().GetY(), expectedY); } } } @@ -261,14 +247,12 @@ HWTEST_F(ShapeMaskAccessorTest, setCircleShapeXYTest, TestSize.Level1) accessor_->setCircleShape(peer_, &circle); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->circle, nullptr); - EXPECT_EQ(peer_->circle->GetPosition().GetX(), expectedX); - EXPECT_EQ(peer_->circle->GetPosition().GetY(), expectedY); - EXPECT_EQ(peer_->circle->GetRadius(), expectedD); - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY); + auto circleShape = AceType::DynamicCast(peer_->shape); + ASSERT_NE(circleShape, nullptr); + EXPECT_EQ(circleShape->GetRadius(), expectedD); } } } @@ -292,16 +276,14 @@ HWTEST_F(ShapeMaskAccessorTest, setCircleShapeRadiusTest, TestSize.Level1) accessor_->setCircleShape(peer_, &circle); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->circle, nullptr); - EXPECT_EQ(peer_->circle->GetPosition().GetX(), expectedD); - EXPECT_EQ(peer_->circle->GetPosition().GetY(), expectedD); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD); + auto circleShape = AceType::DynamicCast(peer_->shape); + ASSERT_NE(circleShape, nullptr); if (expectedR.IsValid()) { - EXPECT_EQ(peer_->circle->GetRadius(), expectedR); + EXPECT_EQ(circleShape->GetRadius(), expectedR); } - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->oval, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); } } @@ -327,15 +309,11 @@ HWTEST_F(ShapeMaskAccessorTest, setOvalShapeTopLeftTest, TestSize.Level1) auto expectedW = Dimension(DEFAULT_FLOAT_VALUE - expectedX.Value()); auto expectedH = Dimension(DEFAULT_FLOAT_VALUE - expectedY.Value()); - ASSERT_NE(peer_->oval, nullptr); - EXPECT_EQ(peer_->oval->GetPosition().GetX(), expectedX); - EXPECT_EQ(peer_->oval->GetPosition().GetY(), expectedY); - EXPECT_EQ(peer_->oval->GetWidth(), expectedW); - EXPECT_EQ(peer_->oval->GetHeight(), expectedH); - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedX); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedY); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); } } } @@ -363,15 +341,11 @@ HWTEST_F(ShapeMaskAccessorTest, setOvalShapeRightBottomTest, TestSize.Level1) auto expectedW = Dimension(expectedX.Value() - DEFAULT_FLOAT_VALUE); auto expectedH = Dimension(expectedY.Value() - DEFAULT_FLOAT_VALUE); auto expectedD = Dimension(DEFAULT_FLOAT_VALUE); - ASSERT_NE(peer_->oval, nullptr); - EXPECT_EQ(peer_->oval->GetPosition().GetX(), expectedD); - EXPECT_EQ(peer_->oval->GetPosition().GetY(), expectedD); - EXPECT_EQ(peer_->oval->GetWidth(), expectedW); - EXPECT_EQ(peer_->oval->GetHeight(), expectedH); - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->path, std::nullopt); + ASSERT_NE(peer_->shape, nullptr); + EXPECT_EQ(peer_->shape->GetPosition().GetX(), expectedD); + EXPECT_EQ(peer_->shape->GetPosition().GetY(), expectedD); + EXPECT_EQ(peer_->shape->GetWidth(), expectedW); + EXPECT_EQ(peer_->shape->GetHeight(), expectedH); } } } @@ -391,12 +365,10 @@ HWTEST_F(ShapeMaskAccessorTest, setCommandPathTest, TestSize.Level1) }; accessor_->setCommandPath(peer_, &path); - ASSERT_NE(peer_->path, std::nullopt); - EXPECT_EQ(peer_->path.value(), expectedP); - EXPECT_EQ(peer_->rect, nullptr); - EXPECT_EQ(peer_->roundRect, nullptr); - EXPECT_EQ(peer_->circle, nullptr); - EXPECT_EQ(peer_->oval, nullptr); + ASSERT_NE(peer_->shape, nullptr); + auto pathShape = AceType::DynamicCast(peer_->shape); + ASSERT_NE(pathShape, nullptr); + EXPECT_EQ(pathShape->GetValue(), expectedP); } }