From d596ce523e31db7ce5ea6986262a374d32b1a471 Mon Sep 17 00:00:00 2001 From: zhanghang Date: Fri, 22 Aug 2025 13:47:37 +0800 Subject: [PATCH 1/3] =?UTF-8?q?grid=E8=A1=A5=E9=BD=90=E9=AB=98=E9=A2=91CAP?= =?UTF-8?q?I=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhanghang Change-Id: I63b3aea069688abb4f861638d12d9f6000fb8ada --- frameworks/core/common/container.cpp | 12 +- frameworks/core/common/container.h | 12 + .../pattern/grid/grid_item_model_ng.cpp | 8 + .../pattern/grid/grid_item_model_ng.h | 1 + .../pattern/grid/grid_item_pattern.h | 5 + .../pattern/grid/grid_model_ng.cpp | 81 ++- .../pattern/grid/grid_model_ng.h | 11 +- .../pattern/scrollable/scrollable_pattern.cpp | 18 + .../pattern/scrollable/scrollable_pattern.h | 2 + .../core/interfaces/arkoala/arkoala_api.h | 24 + .../native/node/grid_item_modifier.cpp | 16 + .../interfaces/native/node/grid_modifier.cpp | 367 +++++++++++++- .../interfaces/native/node/grid_modifier.h | 14 + .../core/interfaces/native/node/node_api.cpp | 19 +- interfaces/native/BUILD.gn | 2 + interfaces/native/libace.ndk.json | 24 + interfaces/native/native_node.h | 104 ++++ interfaces/native/native_type.h | 144 ++++++ interfaces/native/node/event_converter.cpp | 33 ++ interfaces/native/node/grid_layout_option.cpp | 83 +++ interfaces/native/node/grid_layout_option.h | 34 ++ interfaces/native/node/style_modifier.cpp | 226 ++++++++- test/mock/core/common/mock_container.cpp | 9 + .../core/pattern/grid/grid_attr_test_ng.cpp | 289 ++++++++++- .../scroll/scroll_pattern_test_ng_three.cpp | 37 ++ .../scrollable_pattern_test_ng_two.cpp | 31 ++ test/unittest/interfaces/BUILD.gn | 1 + test/unittest/interfaces/native_node_test.cpp | 475 +++++++++++++++++- 28 files changed, 2061 insertions(+), 21 deletions(-) create mode 100644 interfaces/native/node/grid_layout_option.cpp create mode 100644 interfaces/native/node/grid_layout_option.h diff --git a/frameworks/core/common/container.cpp b/frameworks/core/common/container.cpp index f1e27872310..b905fb3570b 100644 --- a/frameworks/core/common/container.cpp +++ b/frameworks/core/common/container.cpp @@ -29,7 +29,9 @@ #include "core/pipeline/pipeline_base.h" namespace OHOS::Ace { - +namespace { + constexpr int32_t API_VERSION_15 = 15; +} int32_t Container::CurrentId() { return ContainerScope::CurrentId(); @@ -409,6 +411,14 @@ bool Container::GreatOrEqualAPIVersion(PlatformVersion version) : GreatOrEqualAPITargetVersion(version); } +bool Container::EqualAPIVersion(PlatformVersion version) +{ + return static_cast(version) < API_VERSION_15 + ? PipelineBase::GetCurrentContext() && + PipelineBase::GetCurrentContext()->GetMinPlatformVersion() == static_cast(version) + : EqualAPITargetVersion(version); +} + bool Container::LessThanAPIVersionWithCheck(PlatformVersion version) { return PipelineBase::GetCurrentContextSafelyWithCheck() && diff --git a/frameworks/core/common/container.h b/frameworks/core/common/container.h index 3daf308fe35..0c1c778f2b4 100755 --- a/frameworks/core/common/container.h +++ b/frameworks/core/common/container.h @@ -601,6 +601,7 @@ public: */ static bool GreatOrEqualAPIVersionWithCheck(PlatformVersion version); + static bool EqualAPIVersion(PlatformVersion version); /** * @description: Compare whether the target api version of the application is less than the incoming target * version. @@ -632,6 +633,17 @@ public: return apiTargetVersion >= static_cast(version); } + static bool EqualAPITargetVersion(PlatformVersion version) + { + auto container = Current(); + if (!container) { + auto apiTargetVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion() % 1000; + return apiTargetVersion == static_cast(version); + } + auto apiTargetVersion = container->GetApiTargetVersion(); + return apiTargetVersion == static_cast(version); + } + static int32_t GetCurrentApiTargetVersion() { auto container = Current(); diff --git a/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.cpp b/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.cpp index 4bb66fa09dc..72a0e3d565b 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.cpp +++ b/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.cpp @@ -193,6 +193,14 @@ void GridItemModelNG::SetGridItemStyle(FrameNode* frameNode, GridItemStyle gridI pattern->UpdateGridItemStyle(gridItemStyle); } +GridItemStyle GridItemModelNG::GetGridItemStyle(FrameNode* frameNode) +{ + CHECK_NULL_RETURN(frameNode, GridItemStyle::NONE); + auto pattern = frameNode->GetPatternPtr(); + CHECK_NULL_RETURN(pattern, GridItemStyle::NONE); + return pattern->GetGridItemStyle(); +} + void GridItemModelNG::SetOnSelect(FrameNode* frameNode, SelectFunc&& onSelect) { CHECK_NULL_VOID(frameNode); diff --git a/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.h b/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.h index c9e00540dd7..c9ff28053c9 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.h +++ b/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.h @@ -47,6 +47,7 @@ public: static void SetColumnStart(FrameNode* frameNode, int32_t columnStart); static void SetColumnEnd(FrameNode* frameNode, int32_t columnEnd); static void SetGridItemStyle(FrameNode* frameNode, GridItemStyle gridItemStyle); + static GridItemStyle GetGridItemStyle(FrameNode* frameNode); static void SetOnSelect(FrameNode* frameNode, SelectFunc&& onSelect); static void SetSelectChangeEvent(FrameNode* frameNode, SelectFunc&& changeEvent); }; diff --git a/frameworks/core/components_ng/pattern/grid/grid_item_pattern.h b/frameworks/core/components_ng/pattern/grid/grid_item_pattern.h index 5f21bea4ea8..936675aea77 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_item_pattern.h +++ b/frameworks/core/components_ng/pattern/grid/grid_item_pattern.h @@ -161,6 +161,11 @@ public: return true; } + GridItemStyle GetGridItemStyle() + { + return gridItemStyle_; + } + protected: void OnModifyDone() override; diff --git a/frameworks/core/components_ng/pattern/grid/grid_model_ng.cpp b/frameworks/core/components_ng/pattern/grid/grid_model_ng.cpp index 0720a9482d7..cfdb05ba405 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_model_ng.cpp +++ b/frameworks/core/components_ng/pattern/grid/grid_model_ng.cpp @@ -19,11 +19,15 @@ #include "core/components_ng/base/view_abstract.h" #include "core/components_ng/pattern/grid/grid_pattern.h" #include "core/components_ng/pattern/scrollable/scrollable_model_ng.h" +#include "core/components_ng/pattern/scrollable/scrollable_properties.h" #include "core/components_ng/manager/scroll_adjust/scroll_adjust_manager.h" #include "core/common/resource/resource_parse_utils.h" namespace OHOS::Ace::NG { - +namespace { + constexpr Dimension DEFAULT_SCROLL_BAR_WIDTH = 4.0_vp; + constexpr Color DEFAULT_SCROLL_BAR_COLOR = Color(0x66182431); +} void GridModelNG::Create(const RefPtr& positionController, const RefPtr& scrollProxy) { auto* stack = ViewStackProcessor::GetInstance(); @@ -248,6 +252,15 @@ void GridModelNG::SetAlignItems(GridItemAlignment itemAlign) ACE_UPDATE_LAYOUT_PROPERTY(GridLayoutProperty, AlignItems, itemAlign); } +GridItemAlignment GridModelNG::GetAlignItems(FrameNode* frameNode) +{ + GridItemAlignment alignment = GridItemAlignment::DEFAULT; + CHECK_NULL_RETURN(frameNode, alignment); + ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE( + GridLayoutProperty, AlignItems, alignment, frameNode, alignment); + return alignment; +} + void GridModelNG::SetOnScrollToIndex(ScrollToIndexFunc&& value) { auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); @@ -454,6 +467,13 @@ void GridModelNG::SetScrollBarMode(FrameNode* frameNode, const std::optional(DisplayMode::AUTO)); + return static_cast( + frameNode->GetPaintProperty()->GetScrollBarMode().value_or(DisplayMode::AUTO)); +} + void GridModelNG::SetScrollBarWidth(FrameNode* frameNode, const std::optional& scrollBarWidth) { if (scrollBarWidth && @@ -465,6 +485,13 @@ void GridModelNG::SetScrollBarWidth(FrameNode* frameNode, const std::optionalGetPaintProperty()->GetBarWidth(); + return value.ConvertToVp(); +} + void GridModelNG::SetScrollBarColor(FrameNode* frameNode, const std::optional& scrollBarColor) { if (scrollBarColor) { @@ -474,6 +501,13 @@ void GridModelNG::SetScrollBarColor(FrameNode* frameNode, const std::optionalGetPaintProperty()->GetBarColor(); + return value.GetValue(); +} + void GridModelNG::SetCachedCount(FrameNode* frameNode, int32_t cachedCount) { if (cachedCount >= 0) { @@ -570,11 +604,30 @@ void GridModelNG::SetNestedScroll(FrameNode* frameNode, const NestedScrollOption pattern->SetNestedScroll(nestedOpt); } +NestedScrollOptions GridModelNG::GetNestedScroll(FrameNode* frameNode) +{ + NestedScrollOptions defaultOptions; + defaultOptions.forward = NestedScrollMode::SELF_ONLY; + defaultOptions.backward = NestedScrollMode::SELF_ONLY; + CHECK_NULL_RETURN(frameNode, defaultOptions); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_RETURN(pattern, defaultOptions); + return pattern->GetNestedScroll(); +} + void GridModelNG::SetScrollEnabled(FrameNode* frameNode, bool scrollEnabled) { ACE_UPDATE_NODE_LAYOUT_PROPERTY(GridLayoutProperty, ScrollEnabled, scrollEnabled, frameNode); } +bool GridModelNG::GetScrollEnabled(FrameNode* frameNode) +{ + bool value = true; + CHECK_NULL_RETURN(frameNode, value); + ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(GridLayoutProperty, ScrollEnabled, value, frameNode, value); + return value; +} + void GridModelNG::SetFriction(FrameNode* frameNode, const std::optional& value) { auto pattern = frameNode->GetPattern(); @@ -586,6 +639,23 @@ void GridModelNG::SetFriction(FrameNode* frameNode, const std::optional& pattern->SetFriction(friction.value_or(FRICTION)); } +double GridModelNG::GetFriction(FrameNode* frameNode) +{ + if (frameNode == nullptr) { + return ScrollablePattern::GetDefaultFriction(); + } + auto pattern = frameNode->GetPattern(); + if (pattern == nullptr) { + return ScrollablePattern::GetDefaultFriction(); + } + return pattern->GetFriction(); +} + +double GridModelNG::GetDefaultFriction() +{ + return ScrollablePattern::GetDefaultFriction(); +} + void GridModelNG::SetFocusWrapMode(FrameNode* frameNode, const std::optional& focusWrapMode) { if (focusWrapMode) { @@ -702,6 +772,15 @@ void GridModelNG::SetLayoutOptions(FrameNode* frameNode, GridLayoutOptions& opti ACE_UPDATE_NODE_LAYOUT_PROPERTY(GridLayoutProperty, LayoutOptions, options, frameNode); } +GridLayoutOptions GridModelNG::GetLayoutOptions(FrameNode* frameNode) +{ + GridLayoutOptions options; + CHECK_NULL_RETURN(frameNode, options); + ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE( + GridLayoutProperty, LayoutOptions, options, frameNode, options); + return options; +} + void GridModelNG::SetOnScrollBarUpdate(FrameNode* frameNode, ScrollBarUpdateFunc&& value) { CHECK_NULL_VOID(frameNode); diff --git a/frameworks/core/components_ng/pattern/grid/grid_model_ng.h b/frameworks/core/components_ng/pattern/grid/grid_model_ng.h index 518c9f03a85..d5909895698 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_model_ng.h +++ b/frameworks/core/components_ng/pattern/grid/grid_model_ng.h @@ -88,8 +88,11 @@ public: static void SetColumnsGap(FrameNode* frameNode, const Dimension& columnsGap); static void SetRowsGap(FrameNode* frameNode, const Dimension& rowsGap); static void SetScrollBarMode(FrameNode* frameNode, const std::optional& scrollBarMode); + static int32_t GetScrollBarMode(FrameNode* frameNode); static void SetScrollBarWidth(FrameNode* frameNode, const std::optional& scrollBarWidth); + static float GetScrollBarWidth(FrameNode* frameNode); static void SetScrollBarColor(FrameNode* frameNode, const std::optional& scrollBarColor); + static uint32_t GetScrollBarColor(FrameNode* frameNode); static void SetCachedCount(FrameNode* frameNode, int32_t cachedCount); static void SetShowCached(FrameNode* frameNode, bool show); static void SetLayoutDirection(FrameNode* frameNode, const std::optional& layoutDirection); @@ -105,11 +108,15 @@ public: FrameNode* frameNode, const std::optional& edgeEffect, const std::optional& alwaysEnabled, EffectEdge edge = EffectEdge::ALL); static void SetNestedScroll(FrameNode* frameNode, const NestedScrollOptions& nestedOpt); + static NestedScrollOptions GetNestedScroll(FrameNode* frameNode); static void SetScrollEnabled(FrameNode* frameNode, bool scrollEnabled); + static bool GetScrollEnabled(FrameNode* frameNode); + static void SetFriction(FrameNode* frameNode, const std::optional& value); + static double GetFriction(FrameNode* frameNode); static void SetFocusWrapMode(FrameNode* frameNode, const std::optional& focusWrapMode); static FocusWrapMode GetFocusWrapMode(FrameNode* frameNode); - static void SetFriction(FrameNode* frameNode, const std::optional& value); static void SetAlignItems(FrameNode* frameNode, const std::optional& itemAlign); + static GridItemAlignment GetAlignItems(FrameNode* frameNode); static std::string GetColumnsTemplate(FrameNode* frameNode); static std::string GetRowsTemplate(FrameNode* frameNode); static float GetColumnsGap(FrameNode* frameNode); @@ -119,6 +126,7 @@ public: static void InitScroller(FrameNode* frameNode, const RefPtr& positionController, const RefPtr& scrollProxy); static void SetLayoutOptions(FrameNode* frameNode, GridLayoutOptions& options); + static GridLayoutOptions GetLayoutOptions(FrameNode* frameNode); static void SetOnScrollBarUpdate(FrameNode* frameNode, ScrollBarUpdateFunc&& value); static void SetOnItemDragStart(FrameNode* frameNode, std::function&& value); static void SetOnItemDragEnter(FrameNode* frameNode, ItemDragEnterFunc&& value); @@ -145,6 +153,7 @@ public: static void SetOnScroll(FrameNode* frameNode, OnScrollEvent&& onScroll); static void CreateWithResourceObjScrollBarColor(FrameNode* frameNode, const RefPtr& resObj); + static double GetDefaultFriction(); private: static void AddDragFrameNodeToManager(FrameNode* frameNode); }; diff --git a/frameworks/core/components_ng/pattern/scrollable/scrollable_pattern.cpp b/frameworks/core/components_ng/pattern/scrollable/scrollable_pattern.cpp index 6ec642cc8bd..257c7acbdf5 100644 --- a/frameworks/core/components_ng/pattern/scrollable/scrollable_pattern.cpp +++ b/frameworks/core/components_ng/pattern/scrollable/scrollable_pattern.cpp @@ -1454,6 +1454,24 @@ void ScrollablePattern::SetFriction(double friction) scrollable->SetUnstaticFriction(friction_); } + +double ScrollablePattern::GetDefaultFriction() +{ + double friction = FRICTION; + if (Container::EqualAPIVersion(PlatformVersion::VERSION_ELEVEN)) { + friction = API11_FRICTION; + } else if (Container::EqualAPIVersion(PlatformVersion::VERSION_TWELVE)) { + friction = API12_FRICTION; + } else if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_THIRTEEN)) { + auto context = PipelineBase::GetCurrentContext(); + CHECK_NULL_RETURN(context, friction); + auto scrollableTheme = context->GetTheme(); + CHECK_NULL_RETURN(scrollableTheme, friction); + friction = scrollableTheme->GetFriction(); + } + return friction; +} + void ScrollablePattern::SetVelocityScale(double scale) { if (LessOrEqual(scale, 0.0)) { diff --git a/frameworks/core/components_ng/pattern/scrollable/scrollable_pattern.h b/frameworks/core/components_ng/pattern/scrollable/scrollable_pattern.h index c784c6c88bf..8864dd99a94 100644 --- a/frameworks/core/components_ng/pattern/scrollable/scrollable_pattern.h +++ b/frameworks/core/components_ng/pattern/scrollable/scrollable_pattern.h @@ -920,6 +920,8 @@ public: { return scrollBar_; } + + static double GetDefaultFriction(); protected: void SuggestOpIncGroup(bool flag); void OnAttachToFrameNodeMultiThread(); diff --git a/frameworks/core/interfaces/arkoala/arkoala_api.h b/frameworks/core/interfaces/arkoala/arkoala_api.h index f6a7ce1d0e0..12f9b3bbdf8 100644 --- a/frameworks/core/interfaces/arkoala/arkoala_api.h +++ b/frameworks/core/interfaces/arkoala/arkoala_api.h @@ -108,6 +108,7 @@ struct ArkUIGestureRecognizer; struct _ArkUIRenderNode; struct _ArkUIRenderModifier; struct _ArkUIRSProperty; +struct ArkUI_GridLayoutOptions; typedef ArkUIGestureRecognizer* ArkUIGestureRecognizerHandle; typedef ArkUIGestureRecognizerHandle* ArkUIGestureRecognizerHandleArray; @@ -150,6 +151,7 @@ typedef ArkUI_WaterFlowSectionOption* ArkUIWaterFlowSectionOption; typedef ArkUI_ListItemSwipeActionOption* ArkUIListItemSwipeActionOptionHandle; typedef ArkUI_ListItemSwipeActionItem* ArkUIListItemSwipeActionItemHandle; typedef ArkUI_ListChildrenMainSize* ArkUIListChildrenMainSize; +typedef ArkUI_GridLayoutOptions* ArkUIGridLayoutOptions; typedef ArkUI_TextPickerRangeContentArray* ArkUITextPickerRangeContentArray; typedef ArkUI_TextCascadePickerRangeContentArray* ArkUITextCascadePickerRangeContentArray; @@ -1287,6 +1289,11 @@ enum ArkUIEventSubKind { ON_GRID_START, ON_GRID_STOP, ON_GRID_SCROLL_TO_INDEX, + ON_GRID_SCROLL_FRAME_BEGIN, + ON_GRID_WILL_SCROLL, + ON_GRID_DID_SCROLL, + ON_GRID_WILL_STOP_DRAGGING, + ON_GRID_SCROLL_BAR_UPDATE, ON_SIDEBAR_CHANGE = ARKUI_MAX_EVENT_NUM * ARKUI_SIDEBAR, @@ -3820,10 +3827,13 @@ struct ArkUIGridModifier { void (*resetGridRowsGap)(ArkUINodeHandle node); void (*setGridScrollBar)(ArkUINodeHandle node, ArkUI_Int32 scrollBar); void (*resetGridScrollBar)(ArkUINodeHandle node); + ArkUI_Int32 (*getGridScrollBar)(ArkUINodeHandle node); void (*setGridScrollBarWidth)(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit); void (*resetGridScrollBarWidth)(ArkUINodeHandle node); + ArkUI_Float32 (*getGridScrollBarWidth)(ArkUINodeHandle node); void (*setGridScrollBarColor)(ArkUINodeHandle node, ArkUI_Uint32 scrollBarColor); void (*resetGridScrollBarColor)(ArkUINodeHandle node); + ArkUI_Uint32 (*getGridScrollBarColor)(ArkUINodeHandle node); void (*setGridCachedCount)(ArkUINodeHandle node, ArkUI_Int32 cachedCount); void (*resetGridCachedCount)(ArkUINodeHandle node); void (*setShowCached)(ArkUINodeHandle node, ArkUI_Bool show); @@ -3849,10 +3859,13 @@ struct ArkUIGridModifier { void (*resetEdgeEffect)(ArkUINodeHandle node); void (*setNestedScroll)(ArkUINodeHandle node, ArkUI_Int32 forward, ArkUI_Int32 backward); void (*resetNestedScroll)(ArkUINodeHandle node); + void (*getNestedScroll)(ArkUINodeHandle node, ArkUI_Int32 (*values)[2]); void (*setEnableScroll)(ArkUINodeHandle node, ArkUI_Bool scrollEnabled); void (*resetEnableScroll)(ArkUINodeHandle node); void (*setFriction)(ArkUINodeHandle node, ArkUI_Float32 friction); void (*resetFriction)(ArkUINodeHandle node); + ArkUI_Float32 (*getFriction)(ArkUINodeHandle node); + ArkUI_Float32 (*getDefaultFriction)(); void (*setGridFocusWrapMode)(ArkUINodeHandle node, ArkUI_Int32 focusWrapMode); void (*resetGridFocusWrapMode)(ArkUINodeHandle node); ArkUI_Int32 (*getGridFocusWrapMode)(ArkUINodeHandle node); @@ -3868,6 +3881,7 @@ struct ArkUIGridModifier { ArkUI_Int32 (*getCachedCount)(ArkUINodeHandle node); void (*setGridAlignItems)(ArkUINodeHandle node, ArkUI_Int32 alignItems); void (*resetGridAlignItems)(ArkUINodeHandle node); + ArkUI_Int32 (*getGridAlignItems)(ArkUINodeHandle node); void (*setSyncLoad)(ArkUINodeHandle node, ArkUI_Bool syncLoad); void (*resetSyncLoad)(ArkUINodeHandle node); ArkUI_Bool (*getSyncLoad)(ArkUINodeHandle node); @@ -3890,6 +3904,14 @@ struct ArkUIGridModifier { void (*resetOnGridItemDrop)(ArkUINodeHandle node); void (*createWithResourceObjFriction)(ArkUINodeHandle node, void* resObj); void (*createWithResourceObjScrollBarColor)(ArkUINodeHandle node, void* resObj); + + void (*resetGridEnableScrollInteraction)(ArkUINodeHandle node); + void (*setGridEnableScrollInteraction)(ArkUINodeHandle node, ArkUI_Bool value); + ArkUI_Int32 (*getGridEnableScrollInteraction)(ArkUINodeHandle node); + + void (*resetGridLayoutOptions)(ArkUINodeHandle node); + void (*setGridLayoutOptions)(ArkUINodeHandle node, ArkUIGridLayoutOptions option); + ArkUI_GridLayoutOptions (*getGridLayoutOptions)(ArkUINodeHandle node); }; struct ArkUIGridItemModifier { @@ -3906,6 +3928,8 @@ struct ArkUIGridItemModifier { void (*setGridItemColumnEnd)(ArkUINodeHandle node, ArkUI_Int32 columnEnd); void (*resetGridItemColumnEnd)(ArkUINodeHandle node); void (*setGridItemOptions)(ArkUINodeHandle node, ArkUI_Int32 style); + void (*resetGridItemOptions)(ArkUINodeHandle node); + ArkUI_Int32 (*getGridItemOptions)(ArkUINodeHandle node); void (*setGridItemOnSelect)(ArkUINodeHandle node, void* callback); void (*resetGridItemOnSelect)(ArkUINodeHandle node); }; diff --git a/frameworks/core/interfaces/native/node/grid_item_modifier.cpp b/frameworks/core/interfaces/native/node/grid_item_modifier.cpp index 9ac2ae53b04..e73d16b45a8 100644 --- a/frameworks/core/interfaces/native/node/grid_item_modifier.cpp +++ b/frameworks/core/interfaces/native/node/grid_item_modifier.cpp @@ -113,6 +113,20 @@ void SetGridItemOptions(ArkUINodeHandle node, ArkUI_Int32 style) GridItemModelNG::SetGridItemStyle(frameNode, static_cast(style)); } +void ResetGridItemOptions(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + GridItemModelNG::SetGridItemStyle(frameNode, GridItemStyle::NONE); +} + +ArkUI_Int32 GetGridItemOptions(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, 0); + return static_cast(GridItemModelNG::GetGridItemStyle(frameNode)); +} + void SetGridItemOnSelect(ArkUINodeHandle node, void* callback) { auto* frameNode = reinterpret_cast(node); @@ -149,6 +163,8 @@ const ArkUIGridItemModifier* GetGridItemModifier() .setGridItemColumnEnd = SetGridItemColumnEnd, .resetGridItemColumnEnd = ResetGridItemColumnEnd, .setGridItemOptions = SetGridItemOptions, + .resetGridItemOptions = ResetGridItemOptions, + .getGridItemOptions = GetGridItemOptions, .setGridItemOnSelect = SetGridItemOnSelect, .resetGridItemOnSelect = ResetGridItemOnSelect, }; diff --git a/frameworks/core/interfaces/native/node/grid_modifier.cpp b/frameworks/core/interfaces/native/node/grid_modifier.cpp index 139c1b3adc7..39d99c54ef2 100644 --- a/frameworks/core/interfaces/native/node/grid_modifier.cpp +++ b/frameworks/core/interfaces/native/node/grid_modifier.cpp @@ -18,6 +18,8 @@ #include "core/components_ng/pattern/grid/grid_model_ng.h" #include "core/components_ng/pattern/scrollable/scrollable_model_ng.h" #include "core/interfaces/native/node/node_adapter_impl.h" +#include "interfaces/native/node/grid_layout_option.h" +#include "node_model.h" namespace OHOS::Ace::NG { const std::string DEFAULT_ROWS_TEMPLATE = "1fr"; @@ -36,8 +38,10 @@ constexpr bool DEFAULT_MULTI_SELECTABLE = false; constexpr bool DEFAULT_SUPPORT_ANIMATION = false; constexpr Dimension DEFAULT_FADING_EDGE_LENGTH = Dimension(32.0f, DimensionUnit::VP); // default value const float ERROR_FLOAT_CODE = -1.0f; +const int32_t ERROR_INT_CODE = -1; std::string g_strValue; - +using GridSizeCallback = ArkUI_GridItemSize (*)(int32_t, void*); +using GridRectCallback = ArkUI_GridItemRect (*)(int32_t, void*); void SetGridColumnsTemplate(ArkUINodeHandle node, const char* columnsTemplate) { auto* frameNode = reinterpret_cast(node); @@ -127,6 +131,13 @@ void ResetGridScrollBar(ArkUINodeHandle node) GridModelNG::SetScrollBarMode(frameNode, DEFAULT_SCROLL_BAR); } +ArkUI_Int32 GetGridScrollBar(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE); + return GridModelNG::GetScrollBarMode(frameNode); +} + void SetGridScrollBarWidth(ArkUINodeHandle node, ArkUI_Float32 value, int32_t unit) { auto* frameNode = reinterpret_cast(node); @@ -142,6 +153,13 @@ void ResetGridScrollBarWidth(ArkUINodeHandle node) GridModelNG::SetScrollBarWidth(frameNode, DEFAULT_SCROLL_BAR_WIDTH); } +ArkUI_Float32 GetGridScrollBarWidth(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE); + return GridModelNG::GetScrollBarWidth(frameNode); +} + void SetGridScrollBarColor(ArkUINodeHandle node, uint32_t scrollBarColor) { auto* frameNode = reinterpret_cast(node); @@ -161,6 +179,13 @@ void ResetGridScrollBarColor(ArkUINodeHandle node) GridModelNG::SetScrollBarColor(frameNode, scrollBarTheme->GetForegroundColor()); } +ArkUI_Uint32 GetGridScrollBarColor(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, ERROR_INT_CODE); + return GridModelNG::GetScrollBarColor(frameNode); +} + void SetGridCachedCount(ArkUINodeHandle node, int32_t cachedCount) { auto* frameNode = reinterpret_cast(node); @@ -313,6 +338,15 @@ void ResetNestedScroll(ArkUINodeHandle node) GridModelNG::SetNestedScroll(frameNode, nestedOpt); } +void GetNestedScroll(ArkUINodeHandle node, ArkUI_Int32 (*values)[2]) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + NestedScrollOptions options = GridModelNG::GetNestedScroll(frameNode); + (*values)[0] = static_cast(options.forward); + (*values)[1] = static_cast(options.backward); +} + void SetEnableScroll(ArkUINodeHandle node, ArkUI_Bool ScrollEnabled) { auto* frameNode = reinterpret_cast(node); @@ -343,6 +377,20 @@ void ResetFriction(ArkUINodeHandle node) GridModelNG::SetFriction(frameNode, friction); } +ArkUI_Float32 GetFriction(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + if (frameNode == nullptr) { + return GridModelNG::GetDefaultFriction(); + } + return static_cast(GridModelNG::GetFriction(frameNode)); +} + +ArkUI_Float32 GetDefaultFriction() +{ + return static_cast(GridModelNG::GetDefaultFriction()); +} + void SetGridFocusWrapMode(ArkUINodeHandle node, int32_t focusWrapMode) { auto* frameNode = reinterpret_cast(node); @@ -394,6 +442,13 @@ void ResetGridAlignItems(ArkUINodeHandle node) GridModelNG::SetAlignItems(frameNode, GridItemAlignment::DEFAULT); } +ArkUI_Int32 GetGridAlignItems(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, 0); + return static_cast(GridModelNG::GetAlignItems(frameNode)); +} + void SetGridSyncLoad(ArkUINodeHandle node, ArkUI_Bool syncLoad) { auto* frameNode = reinterpret_cast(node); @@ -526,6 +581,123 @@ void ResetGridFadingEdge(ArkUINodeHandle node) NG::ScrollableModelNG::SetFadingEdge(frameNode, false, DEFAULT_FADING_EDGE_LENGTH); } +void SetGridEnableScrollInteraction(ArkUINodeHandle node, ArkUI_Bool value) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + GridModelNG::SetScrollEnabled(frameNode, value); +} + +ArkUI_Int32 GetGridEnableScrollInteraction(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, 1); + return GridModelNG::GetScrollEnabled(frameNode); +} + +void ResetGridEnableScrollInteraction(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + GridModelNG::SetScrollEnabled(frameNode, true); +} + +void SetGridLayoutOptions(ArkUINodeHandle node, ArkUIGridLayoutOptions option) +{ + CHECK_NULL_VOID(option); + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + GridLayoutOptions gridLayoutOptions; + if (option->irregularIndexes && option->size > 0) { + gridLayoutOptions.irregularIndexes.insert(option->irregularIndexes, option->irregularIndexes + option->size); + } + + if (option->onGetIrregularSizeByIndex) { + auto callback = reinterpret_cast(option->onGetIrregularSizeByIndex); + void* userData = option->userData; + gridLayoutOptions.getSizeByIndex = [callback, userData](int32_t index) -> GridItemSize { + ArkUI_GridItemSize arkSize = callback(index, userData); + return GridItemSize{arkSize.rowSpan, arkSize.columnSpan}; + }; + } + + if (option->onRectByIndexCallback) { + auto callback = reinterpret_cast(option->onRectByIndexCallback); + void* userData = option->userData; + gridLayoutOptions.getRectByIndex = [callback, userData](int32_t index) -> GridItemRect { + ArkUI_GridItemRect arkRect = callback(index, userData); + return GridItemRect{arkRect.rowStart, arkRect.rowSpan, arkRect.columnStart, arkRect.columnSpan}; + }; + } + GridModelNG::SetLayoutOptions(frameNode, gridLayoutOptions); +} + +void ResetGridLayoutOptions(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + GridLayoutOptions gridLayoutOptions; + GridModelNG::SetLayoutOptions(frameNode, gridLayoutOptions); +} + +ArkUI_GridItemSize GetIrregularSizeByIndex(int32_t index, void* userData) +{ + ArkUI_GridItemSize itemSize; + CHECK_NULL_RETURN(userData, itemSize); + auto* options = static_cast(userData); + auto size = options->getSizeByIndex(index); + itemSize.rowSpan = size.rows; + itemSize.columnSpan = size.columns; + return itemSize; +} + +ArkUI_GridItemRect GetRectByIndex(int32_t index, void* userData) +{ + ArkUI_GridItemRect itemRect; + CHECK_NULL_RETURN(userData, itemRect); + auto* options = static_cast(userData); + auto rect = options->getRectByIndex(index); + itemRect.rowStart = rect.rowStart; + itemRect.rowSpan = rect.rowSpan; + itemRect.columnStart = rect.columnStart; + itemRect.columnSpan = rect.columnSpan; + return itemRect; +} + +ArkUI_GridLayoutOptions GetGridLayoutOptions(ArkUINodeHandle node) +{ + ArkUI_GridLayoutOptions option; + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, option); + auto gridOptions = GridModelNG::GetLayoutOptions(frameNode); + if (!gridOptions.irregularIndexes.empty()) { + option.irregularIndexes = new uint32_t[gridOptions.irregularIndexes.size()]; + size_t i = 0; + for (const auto& index : gridOptions.irregularIndexes) { + option.irregularIndexes[i++] = static_cast(index); + } + option.size = gridOptions.irregularIndexes.size(); + } else { + option.irregularIndexes = nullptr; + option.size = 0; + } + + if (gridOptions.getSizeByIndex) { + option.onGetIrregularSizeByIndex = reinterpret_cast(GetIrregularSizeByIndex); + } else { + option.onGetIrregularSizeByIndex = nullptr; + } + + if (gridOptions.getRectByIndex) { + option.onRectByIndexCallback = reinterpret_cast(GetRectByIndex); + } else { + option.onRectByIndexCallback = nullptr; + } + + option.userData = &gridOptions; + return option; +} + namespace NodeModifier { const ArkUIGridModifier* GetGridModifier() { @@ -541,10 +713,13 @@ const ArkUIGridModifier* GetGridModifier() .resetGridRowsGap = ResetGridRowsGap, .setGridScrollBar = SetGridScrollBar, .resetGridScrollBar = ResetGridScrollBar, + .getGridScrollBar = GetGridScrollBar, .setGridScrollBarWidth = SetGridScrollBarWidth, .resetGridScrollBarWidth = ResetGridScrollBarWidth, + .getGridScrollBarWidth = GetGridScrollBarWidth, .setGridScrollBarColor = SetGridScrollBarColor, .resetGridScrollBarColor = ResetGridScrollBarColor, + .getGridScrollBarColor = GetGridScrollBarColor, .setGridCachedCount = SetGridCachedCount, .resetGridCachedCount = ResetGridCachedCount, .setShowCached = SetShowCached, @@ -568,10 +743,13 @@ const ArkUIGridModifier* GetGridModifier() .resetEdgeEffect = ResetEdgeEffect, .setNestedScroll = SetNestedScroll, .resetNestedScroll = ResetNestedScroll, + .getNestedScroll = GetNestedScroll, .setEnableScroll = SetEnableScroll, .resetEnableScroll = ResetEnableScroll, .setFriction = SetFriction, .resetFriction = ResetFriction, + .getFriction = GetFriction, + .getDefaultFriction = GetDefaultFriction, .setGridFocusWrapMode = SetGridFocusWrapMode, .resetGridFocusWrapMode = ResetGridFocusWrapMode, .getGridFocusWrapMode = GetGridFocusWrapMode, @@ -587,6 +765,7 @@ const ArkUIGridModifier* GetGridModifier() .getCachedCount = GetCachedCount, .setGridAlignItems = SetGridAlignItems, .resetGridAlignItems = ResetGridAlignItems, + .getGridAlignItems = GetGridAlignItems, .setSyncLoad = SetGridSyncLoad, .resetSyncLoad = ResetGridSyncLoad, .getSyncLoad = GetGridSyncLoad, @@ -608,6 +787,12 @@ const ArkUIGridModifier* GetGridModifier() .resetOnGridItemDrop = ResetOnGridItemDrop, .createWithResourceObjFriction = CreateWithResourceObjGridFriction, .createWithResourceObjScrollBarColor = CreateWithResourceObjGridScrollBarColor, + .resetGridEnableScrollInteraction = ResetGridEnableScrollInteraction, + .setGridEnableScrollInteraction = SetGridEnableScrollInteraction, + .getGridEnableScrollInteraction = GetGridEnableScrollInteraction, + .resetGridLayoutOptions = ResetGridLayoutOptions, + .setGridLayoutOptions = SetGridLayoutOptions, + .getGridLayoutOptions = GetGridLayoutOptions, }; CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line return &modifier; @@ -841,5 +1026,183 @@ void CreateWithResourceObjGridScrollBarColor(ArkUINodeHandle node, void* resObj) auto* resourceObj = reinterpret_cast(resObj); GridModelNG::CreateWithResourceObjScrollBarColor(frameNode, AceType::Claim(resourceObj)); } + +void SetOnGridWillScroll(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + int32_t nodeId = frameNode->GetId(); + auto onWillScroll = [nodeId, node, extraParam](const Dimension& offset, const ScrollState& state, + ScrollSource source) -> ScrollFrameResult { + ScrollFrameResult scrollRes { .offset = offset }; + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_WILL_SCROLL; + bool usePx = NodeModel::UsePXUnit(reinterpret_cast(extraParam)); + event.componentAsyncEvent.data[0].f32 = + usePx ? static_cast(offset.ConvertToPx()) : static_cast(offset.Value()); + event.componentAsyncEvent.data[1].i32 = static_cast(state); + event.componentAsyncEvent.data[2].i32 = static_cast(source); + SendArkUISyncEvent(&event); + scrollRes.offset = Dimension(event.componentAsyncEvent.data[0].f32, DimensionUnit::VP); + return scrollRes; + }; + ScrollableModelNG::SetOnWillScroll(frameNode, std::move(onWillScroll)); +} + +void ResetOnGridWillScroll(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + ScrollableModelNG::SetOnWillScroll(frameNode, nullptr); +} + +void SetOnGridDidScroll(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + int32_t nodeId = frameNode->GetId(); + auto setOnDidScroll = [nodeId, node, extraParam](const Dimension& offset, const ScrollState& state) -> void { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + bool usePx = NodeModel::UsePXUnit(reinterpret_cast(extraParam)); + event.componentAsyncEvent.subKind = ON_GRID_DID_SCROLL; + event.componentAsyncEvent.data[0].f32 = + usePx ? static_cast(offset.ConvertToPx()) : static_cast(offset.Value()); + event.componentAsyncEvent.data[1].i32 = static_cast(state); + SendArkUISyncEvent(&event); + }; + ScrollableModelNG::SetOnDidScroll(frameNode, std::move(setOnDidScroll)); +} + +void ResetOnGridDidScroll(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + ScrollableModelNG::SetOnDidScroll(frameNode, nullptr); +} + +void SetOnGridScrollStart(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + int32_t nodeId = frameNode->GetId(); + auto onScrollStart = [nodeId, node, extraParam]() -> void { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_START; + SendArkUISyncEvent(&event); + }; + GridModelNG::SetOnScrollStart(frameNode, std::move(onScrollStart)); +} + +void ResetOnGridScrollStart(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + GridModelNG::SetOnScrollStart(frameNode, nullptr); +} + +void SetOnGridScrollStop(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + int32_t nodeId = frameNode->GetId(); + auto onScrollStop = [nodeId, node, extraParam]() -> void { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_STOP; + SendArkUISyncEvent(&event); + }; + GridModelNG::SetOnScrollStop(frameNode, std::move(onScrollStop)); +} + +void ResetOnGridScrollStop(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + GridModelNG::SetOnScrollStop(frameNode, nullptr); +} + +void SetOnGridScrollFrameBegin(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + int32_t nodeId = frameNode->GetId(); + auto onScrollFrameBegin = [nodeId, node, extraParam]( + const Dimension& offset, const ScrollState& state) -> ScrollFrameResult { + ScrollFrameResult scrollRes { .offset = offset }; + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_SCROLL_FRAME_BEGIN; + bool usePx = NodeModel::UsePXUnit(reinterpret_cast(extraParam)); + event.componentAsyncEvent.data[0].f32 = + usePx ? static_cast(offset.ConvertToPx()) : static_cast(offset.Value()); + event.componentAsyncEvent.data[1].i32 = static_cast(state); + SendArkUISyncEvent(&event); + scrollRes.offset = usePx ? Dimension(event.componentAsyncEvent.data[0].f32, DimensionUnit::PX) + : Dimension(event.componentAsyncEvent.data[0].f32, DimensionUnit::VP); + return scrollRes; + }; + GridModelNG::SetOnScrollFrameBegin(frameNode, std::move(onScrollFrameBegin)); +} + +void ResetOnGridScrollFrameBegin(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + GridModelNG::SetOnScrollFrameBegin(frameNode, nullptr); +} + +void SetOnGridWillStopDragging(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + auto onWillStopDragging = [extraParam](const CalcDimension& velocity) -> void { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + bool usePx = NodeModel::UsePXUnit(reinterpret_cast(extraParam)); + event.componentAsyncEvent.subKind = ON_GRID_WILL_STOP_DRAGGING; + event.componentAsyncEvent.data[0].f32 = + usePx ? static_cast(velocity.ConvertToPx()) : static_cast(velocity.Value()); + SendArkUISyncEvent(&event); + }; + ScrollableModelNG::SetOnWillStopDragging(frameNode, std::move(onWillStopDragging)); +} + +void ResetOnGridWillStopDragging(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + ScrollableModelNG::SetOnWillStopDragging(frameNode, nullptr); +} + +void SetOnGridScrollBarUpdate(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + auto onGridScrollBarUpdate = + [extraParam](int32_t index, Dimension offset) -> std::pair, std::optional> { + ArkUINodeEvent event; + event.kind = MIXED_EVENT; + event.extraParam = reinterpret_cast(extraParam); + bool usePx = NodeModel::UsePXUnit(reinterpret_cast(extraParam)); + event.mixedEvent.subKind = ON_GRID_SCROLL_BAR_UPDATE; + event.mixedEvent.numberDataLength = 2; + event.mixedEvent.numberData[0].i32 = index; + event.mixedEvent.numberData[1].f32 = + usePx ? static_cast(offset.ConvertToPx()) : static_cast(offset.Value()); + SendArkUISyncEvent(&event); + return std::make_pair(std::optional(event.mixedEvent.numberReturnData[0].f32), + std::optional(event.mixedEvent.numberReturnData[1].f32)); + }; + GridModelNG::SetOnScrollBarUpdate(frameNode, std::move(onGridScrollBarUpdate)); +} } // namespace NodeModifier -} // namespace OHOS::Ace::NG +} // namespace OHOS::Ace::NG \ No newline at end of file diff --git a/frameworks/core/interfaces/native/node/grid_modifier.h b/frameworks/core/interfaces/native/node/grid_modifier.h index 4137971fa83..72ef629f56d 100644 --- a/frameworks/core/interfaces/native/node/grid_modifier.h +++ b/frameworks/core/interfaces/native/node/grid_modifier.h @@ -38,6 +38,20 @@ void SetOnGridItemDrop(ArkUINodeHandle node, void* extraParam); void ResetOnGridItemDrop(ArkUINodeHandle node); void CreateWithResourceObjGridFriction(ArkUINodeHandle node, void* resObj); void CreateWithResourceObjGridScrollBarColor(ArkUINodeHandle node, void* resObj); +void SetOnGridScrollStart(ArkUINodeHandle node, void* extraParam); +void ResetOnGridScrollStart(ArkUINodeHandle node); +void SetOnGridScrollStop(ArkUINodeHandle node, void* extraParam); +void ResetOnGridScrollStop(ArkUINodeHandle node); +void SetOnGridScrollFrameBegin(ArkUINodeHandle node, void* extraParam); +void ResetOnGridScrollFrameBegin(ArkUINodeHandle node); +void SetOnGridWillStopDragging(ArkUINodeHandle node, void* extraParam); +void ResetOnGridWillStopDragging(ArkUINodeHandle node); +void SetOnGridWillScroll(ArkUINodeHandle node, void* extraParam); +void ResetOnGridWillScroll(ArkUINodeHandle node); +void SetOnGridDidScroll(ArkUINodeHandle node, void* extraParam); +void ResetOnGridDidScroll(ArkUINodeHandle node); +void SetOnGridScrollBarUpdate(ArkUINodeHandle node, void* extraParam); +void ResetOnGridScrollBarUpdate(ArkUINodeHandle node); } #endif // FRAMEWORKS_INTERFACE_INNER_API_NATIVE_NODE_GRID_MODIFIER_H diff --git a/frameworks/core/interfaces/native/node/node_api.cpp b/frameworks/core/interfaces/native/node/node_api.cpp index 6ffbf15a3cc..febdb4c1a6a 100644 --- a/frameworks/core/interfaces/native/node/node_api.cpp +++ b/frameworks/core/interfaces/native/node/node_api.cpp @@ -28,6 +28,7 @@ #include "core/interfaces/native/node/custom_dialog_model.h" #include "core/interfaces/native/node/drag_adapter_impl.h" #include "core/interfaces/native/node/grid_modifier.h" +#include "core/interfaces/native/node/grid_item_modifier.h" #include "core/interfaces/native/node/image_animator_modifier.h" #include "core/interfaces/native/node/node_adapter_impl.h" #include "core/interfaces/native/node/node_animate.h" @@ -608,9 +609,14 @@ const ComponentAsyncEventHandler WATER_FLOW_NODE_ASYNC_EVENT_HANDLERS[] = { const ComponentAsyncEventHandler GRID_NODE_ASYNC_EVENT_HANDLERS[] = { nullptr, - nullptr, - nullptr, + NodeModifier::SetOnGridScrollStart, + NodeModifier::SetOnGridScrollStop, NodeModifier::SetOnGridScrollIndex, + NodeModifier::SetOnGridScrollFrameBegin, + NodeModifier::SetOnGridWillScroll, + NodeModifier::SetOnGridDidScroll, + NodeModifier::SetOnGridWillStopDragging, + NodeModifier::SetOnGridScrollBarUpdate, }; const ComponentAsyncEventHandler ALPHABET_INDEXER_NODE_ASYNC_EVENT_HANDLERS[] = { @@ -828,9 +834,14 @@ const ResetComponentAsyncEventHandler WATERFLOW_NODE_RESET_ASYNC_EVENT_HANDLERS[ const ResetComponentAsyncEventHandler GRID_NODE_RESET_ASYNC_EVENT_HANDLERS[] = { nullptr, - nullptr, - nullptr, + NodeModifier::ResetOnGridScrollStart, + NodeModifier::ResetOnGridScrollStop, NodeModifier::ResetOnGridScrollIndex, + NodeModifier::ResetOnGridScrollFrameBegin, + NodeModifier::ResetOnGridWillScroll, + NodeModifier::ResetOnGridDidScroll, + NodeModifier::ResetOnGridWillStopDragging, + NodeModifier::ResetOnGridScrollBarUpdate, }; const ResetComponentAsyncEventHandler ALPHABET_INDEXER_NODE_RESET_ASYNC_EVENT_HANDLERS[] = { diff --git a/interfaces/native/BUILD.gn b/interfaces/native/BUILD.gn index fec9b39df70..221b9e6a1a2 100644 --- a/interfaces/native/BUILD.gn +++ b/interfaces/native/BUILD.gn @@ -73,6 +73,7 @@ ohos_shared_library("ace_ndk") { "node/event_converter.cpp", "node/frame_information.cpp", "node/gesture_impl.cpp", + "node/grid_layout_option.cpp", "node/list_option.cpp", "node/native_drawable_descriptor.cpp", "node/native_impl.cpp", @@ -94,6 +95,7 @@ ohos_shared_library("ace_ndk") { "node/style_modifier.cpp", "node/textpicker_option.cpp", "node/waterflow_section_option.cpp", + ] external_deps = [ "bounds_checking_function:libsec_shared" ] deps = [] diff --git a/interfaces/native/libace.ndk.json b/interfaces/native/libace.ndk.json index d5de827f9ca..2072fe3fc8c 100644 --- a/interfaces/native/libace.ndk.json +++ b/interfaces/native/libace.ndk.json @@ -4122,5 +4122,29 @@ { "first_introduced": "21", "name": "OH_ArkUI_PositionEdges_GetRight" + }, + { + "first_introduced": "21", + "name": "OH_ArkUI_GridLayoutOptions_Create" + }, + { + "first_introduced": "21", + "name": "OH_ArkUI_GridLayoutOptions_Dispose" + }, + { + "first_introduced": "21", + "name": "OH_ArkUI_GridLayoutOptions_SetIrregularIndexes" + }, + { + "first_introduced": "21", + "name": "OH_ArkUI_GridLayoutOptions_GetIrregularIndexes" + }, + { + "first_introduced": "21", + "name": "OH_ArkUI_GridLayoutOptions_RegisterGetIrregularSizeByIndexCallback" + }, + { + "first_introduced": "21", + "name": "OH_ArkUI_GridLayoutOptions_RegisterGetRectByIndexCallback" } ] diff --git a/interfaces/native/native_node.h b/interfaces/native/native_node.h index bf822f73d1f..73d2754c597 100644 --- a/interfaces/native/native_node.h +++ b/interfaces/native/native_node.h @@ -6754,6 +6754,44 @@ typedef enum { */ NODE_GRID_SYNC_LOAD = 1013007, + /** + * @brief 设置Grid中GridItem的对齐方式，支持属性设置，属性重置和属性获取接口。 + * + * 属性设置方法参数{@link ArkUI_AttributeItem}格式：\n + * .value[0].i32：Grid中GridItem的对齐方式，参数类型{@link ArkUI_GridItemAlignment}。默认值：GRID_ITEM_ALIGNMENT_DEFAULT。\n + * \n + * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n + * .value[0].i32：Grid中GridItem的对齐方式，参数类型{@link ArkUI_GridItemAlignment}。\n + * + * @since 21 + */ + NODE_GRID_ALIGN_ITEMS = 1013008, + + /** + * @brief 设置Grid布局选项，支持属性设置，属性重置和属性获取接口。 + * + * 属性设置方法{@link ArkUI_AttributeItem}参数格式：\n + * .object：参数格式为{@link ArkUI_GridLayoutOptions}。\n + * \n + * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n + * .object：返回值格式为{@link ArkUI_GridLayoutOptions}。\n + * + * @since 21 + */ + NODE_GRID_LAYOUT_OPTIONS = 1013009, + + /** + * @brief 设置GridItem样式，支持属性设置、重置和获取。 + * + * 属性设置方法{@link ArkUI_AttributeItem}参数格式：\n + * .value[0].i32：GridItem样式，参数类型{@link ArkUI_GridItemStyle}。默认值：GRID_ITEM_STYLE_NONE。\n + * \n + * 属性获取方法返回值{@link ArkUI_AttributeItem}格式：\n + * .value[0].i32：GridItem样式，参数类型{@link ArkUI_GridItemStyle}。\n + * + * @since 21 + */ + NODE_GRID_ITEM_STYLE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_GRID_ITEM, /** * @brief Defines the column width of the text picker. * This attribute can be set, reset, and obtained as required through APIs. @@ -8381,6 +8419,72 @@ typedef enum { * */ NODE_IMAGE_ANIMATOR_EVENT_ON_FINISH = 19004, + + + /** + * @brief 定义ARKUI_NODE_GRID有子组件滑入或滑出Grid显示区域时触发事件枚举值。 + * + * 触发该事件的条件 ：\n + * Grid初始化时会触发一次，Grid显示区域内第一个子组件的索引值或最后一个子组件的索引值有变化时会触发。\n + * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n + * {@link ArkUI_NodeComponentEvent}中包含2个参数：\n + * ArkUI_NodeComponentEvent.data[0].i32：Grid显示区域内第一个子组件的索引值。\n + * ArkUI_NodeComponentEvent.data[1].i32：Grid显示区域内最后一个子组件的索引值。\n + * + * @since 21 + */ + NODE_GRID_ON_SCROLL_INDEX = MAX_NODE_SCOPE_NUM * ARKUI_NODE_GRID, + + /** + * @brief 定义ARKUI_NODE_GRID组件的滑动前触发事件枚举值。 + * + * 触发该事件的条件 ：\n + * 1. 滚动组件触发滚动时触发，支持键鼠操作等其他触发滚动的输入设置。\n + * 2. 通过滚动控制器API接口调用。\n + * 3. 越界回弹。\n + * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n + * {@link ArkUI_NodeComponentEvent}中包含3个参数：\n + * ArkUI_NodeComponentEvent.data[0].f32： + * 每帧滚动的偏移量，Grid内容向上滚动时偏移量为正，向下滚动时偏移量为负。 \n + * ArkUI_NodeComponentEvent.data[1].i32：当前滑动状态，参数类型{@link ArkUI_ScrollState}。\n + * ArkUI_NodeComponentEvent.data[2].i32：当前滚动的来源，参数类型{@link ArkUI_ScrollSource}。\n + * @return 不返回或返回一个number，用于设置滚动组件实际的滚动距离。 + * + * @since 21 + */ + NODE_GRID_ON_WILL_SCROLL = 1013001, + + /** + * @brief 定义ARKUI_NODE_GRID组件的滑动时触发事件枚举值。 + * + * 触发该事件的条件 ：\n + * 1. 滚动组件触发滚动时触发，支持键鼠操作等其他触发滚动的输入设置。\n + * 2. 通过滚动控制器API接口调用。\n + * 3. 越界回弹。\n + * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}对象中的联合体类型为{@link ArkUI_NodeComponentEvent}。\n + * {@link ArkUI_NodeComponentEvent}中包含2个参数：\n + * ArkUI_NodeComponentEvent.data[0].f32： + * 每帧滚动的偏移量，Grid内容向上滚动时偏移量为正，向下滚动时偏移量为负。 \n + * ArkUI_NodeComponentEvent.data[1].i32：当前滑动状态。 \n + * + * @since 21 + */ + NODE_GRID_ON_DID_SCROLL = 1013002, + + /** + * @brief 定义ARKUI_NODE_GRID组件每帧布局结束时触发用于设置滚动条的位置及长度的事件枚举值。 + * + * 事件回调发生时，事件参数{@link ArkUI_NodeEvent}。\n + * 通过OH_ArkUI_NodeEvent_GetNumberValue获取到index为0的value.i32：当前显示的网格起始位置的索引值。\n + * 通过OH_ArkUI_NodeEvent_GetNumberValue获取到index为1的value.f32：当前显示的网格起始位置元素相对网格显示起始位置的偏移，单位vp。\n + * @return 滚动条位置和长度。\n + * 可通过OH_ArkUI_NodeEvent_SetReturnNumberValue设置返回值。\n + * 返回值中index为0的value.f32表示Grid内容相对显示区域的总偏移，单位px。\n + * 返回值中index为1的value.f32表示Grid内容总长度，单位px。\n + * + * @since 21 + */ + NODE_GRID_ON_SCROLL_BAR_UPDATE = 1013003, } ArkUI_NodeEventType; /** diff --git a/interfaces/native/native_type.h b/interfaces/native/native_type.h index 4ddbbc8b1b5..051e16a738f 100644 --- a/interfaces/native/native_type.h +++ b/interfaces/native/native_type.h @@ -89,6 +89,53 @@ typedef struct ArkUI_Node* ArkUI_NodeHandle; */ typedef struct ArkUI_NativeDialog* ArkUI_NativeDialogHandle; +/** + * @brief 定义Grid组件onScrollBarUpdate事件回调返回值结构体。 + * + * @since 21 + */ +typedef struct { + /** Grid内容相对显示区域的总偏移，单位px */ + float totalOffset; + /** Grid内容总长度，单位px */ + float totalLength; +} ArkUI_GridComputedBarAttribute; + +/** + * @brief 定义Grid布局选项onGetIrregularSizeByIndex回调返回值结构体。 + * + * @since 21 + */ +typedef struct { + /** GridItem占用的行数 */ + uint32_t rowSpan; + /** GridItem占用的列数 */ + uint32_t columnSpan; +} ArkUI_GridItemSize; + +/** + * @brief 定义Grid布局选项onGetRectByIndex回调返回值结构体。 + * + * @since 21 + */ +typedef struct { + /** GridItem行起始位置 */ + uint32_t rowStart; + /** GridItem列起始位置 */ + uint32_t columnStart; + /** GridItem占用的行数 */ + uint32_t rowSpan; + /** GridItem占用的列数 */ + uint32_t columnSpan; +} ArkUI_GridItemRect; + +/** + * @brief 定义Grid布局选项。 + * + * @since 21 + */ +typedef struct ArkUI_GridLayoutOptions ArkUI_GridLayoutOptions; + /** * @brief 提供ArkUI native UI的上下文实例对象定义。 * @@ -2710,6 +2757,31 @@ typedef struct { float perspective; } ArkUI_RotationOptions; +/** + * @brief GridItem对齐方式枚举。 + * + * @since 21 + */ +typedef enum { + /** Grid的默认对齐方式。*/ + GRID_ITEM_ALIGNMENT_DEFAULT = 0, + /** 以一行中的最高的GridItem作为其他GridItem的高度。*/ + GRID_ITEM_ALIGNMENT_STRETCH = 1, +} ArkUI_GridItemAlignment; + +/** + * @brief GridItem样式枚举。 + * + * @since 21 + */ +typedef enum { + /** 无样式。*/ + GRID_ITEM_STYLE_NONE = 0, + /** 显示Hover、Press态样式。*/ + GRID_ITEM_STYLE_PLAIN = 1, +} ArkUI_GridItemStyle; + + /** * @brief defines the measure info of the custom span. * @@ -2882,6 +2954,78 @@ void* OH_ArkUI_DrawContext_GetCanvas(ArkUI_DrawContext* context); */ ArkUI_IntSize OH_ArkUI_DrawContext_GetSize(ArkUI_DrawContext* context); +/** + * @brief 创建Grid布局选项。 + * + * @return Grid布局选项。 + * @since 21 + */ +ArkUI_GridLayoutOptions* OH_ArkUI_GridLayoutOptions_Create(); + +/** + * @brief 销毁Grid布局选项。 + * + * @param option Grid布局选项。 + * @since 21 + */ +void OH_ArkUI_GridLayoutOptions_Dispose(ArkUI_GridLayoutOptions* option); + +/** + * @brief 设置Grid中不规则GridItem的索引数组。 + * + * @param option Grid布局选项。 + * @param irregularIndexes GridItem索引数组。 + * @param size GridItem索引数组大小。 + * @return 错误码。 + * {@link ARKUI_ERROR_CODE_NO_ERROR} 成功。 + * {@link ARKUI_ERROR_CODE_PARAM_INVALID} 函数参数异常。 + * 异常原因：传入参数验证失败，参数不能为空。 + * @since 21 + */ +int32_t OH_ArkUI_GridLayoutOptions_SetIrregularIndexes( + ArkUI_GridLayoutOptions* option, uint32_t* irregularIndexes, int32_t size); + +/** + * @brief 获取Grid中不规则GridIte的索引数组。当不设置OH_ArkUI_GridLayoutOptions_RegisterGetIrregularSizeByIndexCallback时， + * irregularIndexes中GridItem的默认大小为垂直滚动Grid的一整行或水平滚动Grid的一整列。 + * + * @param option Grid布局选项。 + * @param irregularIndexes GridItem索引数组。 + * @param size GridItem索引数组大小。 + * @return 错误码。 + * {@link ARKUI_ERROR_CODE_NO_ERROR} 成功。 + * {@link ARKUI_ERROR_CODE_PARAM_INVALID} 函数参数异常。 + * {@link ARKUI_ERROR_CODE_BUFFER_SIZE_ERROR} 数组大小不够。 + * 异常原因：传入参数验证失败，参数不能为空。 + * @since 21 + */ +int32_t OH_ArkUI_GridLayoutOptions_GetIrregularIndexes( + ArkUI_GridLayoutOptions* option, uint32_t* irregularIndexes, int32_t* size); + +/** + * @brief Grid布局选项通过GridItem索引获取指定Item占用的行列数。 + * + * @param option Grid布局选项。 + * @param userData 用户自定义数据。 + * @param callback 根据index获取指定Item占用的行列数。 + * itemIndex：GridItem索引值，取值范围来自{@link OH_ArkUI_GridLayoutOptions_SetIrregularIndexes}。 + * @since 21 + */ +void OH_ArkUI_GridLayoutOptions_RegisterGetIrregularSizeByIndexCallback( + ArkUI_GridLayoutOptions* option, void* userData, ArkUI_GridItemSize (*callback)(int32_t itemIndex, void* userData)); + +/** + * @brief Grid布局选项通过GridItem索引获取指定Item的起始行列和占用的行列数。 + * + * @param option Grid布局选项。 + * @param userData 用户自定义数据。 + * @param callback 根据index获取指定Item的起始行列和占用的行列数。 + * itemIndex：GridItem索引值。 + * @since 21 + */ +void OH_ArkUI_GridLayoutOptions_RegisterGetRectByIndexCallback( + ArkUI_GridLayoutOptions* option, void* userData, ArkUI_GridItemRect (*callback)(int32_t itemIndex, void* userData)); + /** * @brief Creates water flow section configuration. * diff --git a/interfaces/native/node/event_converter.cpp b/interfaces/native/node/event_converter.cpp index 5c10d783174..3b312cc406c 100644 --- a/interfaces/native/node/event_converter.cpp +++ b/interfaces/native/node/event_converter.cpp @@ -144,6 +144,8 @@ ArkUI_Int32 ConvertOriginEventType(ArkUI_NodeEventType type, int32_t nodeType) return ON_LIST_SCROLL_FRAME_BEGIN; } else if (arkUINodeType == ARKUI_NODE_WATER_FLOW) { return ON_WATER_FLOW_SCROLL_FRAME_BEGIN; + } else if (arkUINodeType == ARKUI_NODE_GRID) { + return ON_GRID_SCROLL_FRAME_BEGIN; } return ON_SCROLL_FRAME_BEGIN; case NODE_SCROLL_EVENT_ON_WILL_SCROLL: @@ -155,6 +157,8 @@ ArkUI_Int32 ConvertOriginEventType(ArkUI_NodeEventType type, int32_t nodeType) return ON_LIST_SCROLL_START; } else if (arkUINodeType == ARKUI_NODE_WATER_FLOW) { return ON_WATER_FLOW_SCROLL_START; + } else if (arkUINodeType == ARKUI_NODE_GRID) { + return ON_GRID_START; } return ON_SCROLL_START; case NODE_SCROLL_EVENT_ON_SCROLL_STOP: @@ -162,6 +166,8 @@ ArkUI_Int32 ConvertOriginEventType(ArkUI_NodeEventType type, int32_t nodeType) return ON_LIST_SCROLL_STOP; } else if (arkUINodeType == ARKUI_NODE_WATER_FLOW) { return ON_WATER_FLOW_SCROLL_STOP; + } else if (arkUINodeType == ARKUI_NODE_GRID) { + return ON_GRID_STOP; } return ON_SCROLL_STOP; case NODE_EVENT_ON_APPEAR: @@ -321,6 +327,9 @@ ArkUI_Int32 ConvertOriginEventType(ArkUI_NodeEventType type, int32_t nodeType) } return ON_SCROLL_REACH_END; case NODE_SCROLL_EVENT_ON_WILL_STOP_DRAGGING: + if (arkUINodeType == ARKUI_NODE_GRID) { + return ON_GRID_WILL_STOP_DRAGGING; + } return ON_SCROLL_WILL_STOP_DRAGGING; case NODE_SCROLL_EVENT_ON_DID_ZOOM: return ON_SCROLL_DID_ZOOM; @@ -386,6 +395,14 @@ ArkUI_Int32 ConvertOriginEventType(ArkUI_NodeEventType type, int32_t nodeType) return ON_TEXT_AREA_WILL_CHANGE; case NODE_TEXT_INPUT_ON_WILL_CHANGE: return ON_TEXT_INPUT_WILL_CHANGE; + case NODE_GRID_ON_SCROLL_INDEX: + return ON_GRID_SCROLL_TO_INDEX; + case NODE_GRID_ON_WILL_SCROLL: + return ON_GRID_WILL_SCROLL; + case NODE_GRID_ON_DID_SCROLL: + return ON_GRID_DID_SCROLL; + case NODE_GRID_ON_SCROLL_BAR_UPDATE: + return ON_GRID_SCROLL_BAR_UPDATE; default: return -1; } @@ -642,6 +659,22 @@ ArkUI_Int32 ConvertToNodeEventType(ArkUIEventSubKind type) return NODE_TEXT_AREA_ON_WILL_CHANGE; case ON_TEXT_INPUT_WILL_CHANGE: return NODE_TEXT_INPUT_ON_WILL_CHANGE; + case ON_GRID_SCROLL_FRAME_BEGIN: + return NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN; + case ON_GRID_SCROLL_TO_INDEX: + return NODE_GRID_ON_SCROLL_INDEX; + case ON_GRID_START: + return NODE_SCROLL_EVENT_ON_SCROLL_START; + case ON_GRID_STOP: + return NODE_SCROLL_EVENT_ON_SCROLL_STOP; + case ON_GRID_WILL_SCROLL: + return NODE_GRID_ON_WILL_SCROLL; + case ON_GRID_DID_SCROLL: + return NODE_GRID_ON_DID_SCROLL; + case ON_GRID_WILL_STOP_DRAGGING: + return NODE_SCROLL_EVENT_ON_WILL_STOP_DRAGGING; + case ON_GRID_SCROLL_BAR_UPDATE: + return NODE_GRID_ON_SCROLL_BAR_UPDATE; default: return -1; } diff --git a/interfaces/native/node/grid_layout_option.cpp b/interfaces/native/node/grid_layout_option.cpp new file mode 100644 index 00000000000..11ddcb18e58 --- /dev/null +++ b/interfaces/native/node/grid_layout_option.cpp @@ -0,0 +1,83 @@ +/* + * 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 "grid_layout_option.h" +#include +#include "ui/base/utils/utils.h" +#include "native_type.h" +#include "frameworks/base/log/log_wrapper.h" +#ifdef __cplusplus +extern "C" { +#endif + +ArkUI_GridLayoutOptions* OH_ArkUI_GridLayoutOptions_Create() +{ + ArkUI_GridLayoutOptions* gridLayoutOptions = new ArkUI_GridLayoutOptions(); + return gridLayoutOptions; +} + +void OH_ArkUI_GridLayoutOptions_Dispose(ArkUI_GridLayoutOptions* option) +{ + if (option != nullptr) { + delete option; + option = nullptr; + } +} + +int32_t OH_ArkUI_GridLayoutOptions_SetIrregularIndexes(ArkUI_GridLayoutOptions* option, uint32_t* irregularIndexes, + int32_t size) +{ + CHECK_NULL_RETURN(option, ARKUI_ERROR_CODE_PARAM_INVALID); + CHECK_NULL_RETURN(irregularIndexes, ARKUI_ERROR_CODE_PARAM_INVALID); + if (size < 0) { + return ARKUI_ERROR_CODE_PARAM_INVALID; + } + option->irregularIndexes = irregularIndexes; + option->size = size; + return ARKUI_ERROR_CODE_NO_ERROR; +} + +int32_t OH_ArkUI_GridLayoutOptions_GetIrregularIndexes(ArkUI_GridLayoutOptions* option, + uint32_t* irregularIndexes, int32_t* size) +{ + CHECK_NULL_RETURN(option, ARKUI_ERROR_CODE_PARAM_INVALID); + CHECK_NULL_RETURN(irregularIndexes, ARKUI_ERROR_CODE_PARAM_INVALID); + CHECK_NULL_RETURN(size, ARKUI_ERROR_CODE_PARAM_INVALID); + if (*size < option->size) { + return ARKUI_ERROR_CODE_BUFFER_SIZE_ERROR; + } + std::copy(option->irregularIndexes, option->irregularIndexes + option->size, irregularIndexes); + *size = option->size; + return ARKUI_ERROR_CODE_NO_ERROR; +} + +void OH_ArkUI_GridLayoutOptions_RegisterGetIrregularSizeByIndexCallback( + ArkUI_GridLayoutOptions* option, void* userData, ArkUI_GridItemSize (*callback)(int32_t itemIndex, void* userData)) +{ + CHECK_NULL_VOID(option); + option->onGetIrregularSizeByIndex = reinterpret_cast(callback); + option->userData = userData; +} + +void OH_ArkUI_GridLayoutOptions_RegisterGetRectByIndexCallback( + ArkUI_GridLayoutOptions* option, void* userData, ArkUI_GridItemRect (*callback)(int32_t itemIndex, void* userData)) +{ + CHECK_NULL_VOID(option); + option->onRectByIndexCallback = reinterpret_cast(callback); + option->userData = userData; +} +#ifdef __cplusplus +}; +#endif diff --git a/interfaces/native/node/grid_layout_option.h b/interfaces/native/node/grid_layout_option.h new file mode 100644 index 00000000000..4a1f46ff794 --- /dev/null +++ b/interfaces/native/node/grid_layout_option.h @@ -0,0 +1,34 @@ +/* + * 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. + */ + +#ifndef ARKUI_NATIVE_NODE_GRID_LAYOUT_OPTION_H +#define ARKUI_NATIVE_NODE_GRID_LAYOUT_OPTION_H +#include +#ifdef __cplusplus +extern "C" { +#endif + +struct ArkUI_GridLayoutOptions { + uint32_t* irregularIndexes; + int32_t size; + void* onGetIrregularSizeByIndex; + void* onRectByIndexCallback; + void* userData; +}; + +#ifdef __cplusplus +}; +#endif +#endif // ARKUI_NATIVE_NODE_GRID_LAYOUT_OPTION_H \ No newline at end of file diff --git a/interfaces/native/node/style_modifier.cpp b/interfaces/native/node/style_modifier.cpp index 679f8fe243d..813bb3842d6 100644 --- a/interfaces/native/node/style_modifier.cpp +++ b/interfaces/native/node/style_modifier.cpp @@ -23,7 +23,7 @@ #include "node_transition.h" #include "progress_option.h" #include "waterflow_section_option.h" - +#include "grid_layout_option.h" #include "base/utils/utils.h" #include "bridge/common/utils/utils.h" #include "core/components_ng/property/safe_area_insets.h" @@ -342,6 +342,8 @@ std::unordered_map ACCESSIBILITY_ROLE_CONVERT_NATIVE_MAP { "EmbeddedComponent", static_cast(ARKUI_NODE_EMBEDDED_COMPONENT) }, }; +constexpr float GRID_DEFAULT_SCROLL_BAR_WIDTH = 4.0f; +constexpr uint32_t GRID_DEFAULT_SCROLL_BAR_COLOR = 0x66182431; void ResetAttributeItem() { for (int i = 0; i < MAX_ATTRIBUTE_ITEM_LEN; ++i) { @@ -5791,14 +5793,27 @@ const ArkUI_AttributeItem* GetScrollFriction(ArkUI_NodeHandle node) } else if (node->type == ARKUI_NODE_WATER_FLOW) { g_numberValues[0].f32 = GetFullImpl()->getNodeModifiers()->getWaterFlowModifier()->getWaterFlowFriction(node->uiNodeHandle); - } + } else if (node->type == ARKUI_NODE_GRID) { + g_numberValues[0].f32 = + GetFullImpl()->getNodeModifiers()->getGridModifier()->getFriction(node->uiNodeHandle); + } return &g_attributeItem; } +void SetDefaultScrollFriction(ArkUI_NodeHandle node) +{ + if (node->type == ARKUI_NODE_GRID) { + auto* fullImpl = GetFullImpl(); + float value = fullImpl->getNodeModifiers()->getGridModifier()->getDefaultFriction(); + fullImpl->getNodeModifiers()->getGridModifier()->setFriction(node->uiNodeHandle, value); + } +} + int32_t SetScrollFriction(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) { auto actualSize = CheckAttributeItemArray(item, REQUIRED_ONE_PARAM); if (actualSize < 0 || LessOrEqual(item->value[NUM_0].f32, 0.0f)) { + SetDefaultScrollFriction(node); return ERROR_CODE_PARAM_INVALID; } auto fullImpl = GetFullImpl(); @@ -5809,6 +5824,8 @@ int32_t SetScrollFriction(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item fullImpl->getNodeModifiers()->getScrollModifier()->setScrollFriction(node->uiNodeHandle, friction); } else if (node->type == ARKUI_NODE_WATER_FLOW) { fullImpl->getNodeModifiers()->getWaterFlowModifier()->setWaterFlowFriction(node->uiNodeHandle, friction, nullptr); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setFriction(node->uiNodeHandle, friction); } return ERROR_CODE_NO_ERROR; } @@ -5824,6 +5841,8 @@ void ResetScrollFriction(ArkUI_NodeHandle node) fullImpl->getNodeModifiers()->getScrollModifier()->resetScrollFriction(node->uiNodeHandle); } else if (node->type == ARKUI_NODE_WATER_FLOW) { fullImpl->getNodeModifiers()->getWaterFlowModifier()->resetWaterFlowFriction(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->resetFriction(node->uiNodeHandle); } } @@ -5926,17 +5945,31 @@ const ArkUI_AttributeItem* GetScrollScrollBar(ArkUI_NodeHandle node) } else if (node->type == ARKUI_NODE_WATER_FLOW) { g_numberValues[0].i32 = GetFullImpl()->getNodeModifiers()->getWaterFlowModifier()->getWaterFlowScrollBar(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + g_numberValues[0].i32 = + GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridScrollBar(node->uiNodeHandle); } return &g_attributeItem; } +void SetDefaultScrollBar(ArkUI_NodeHandle node) +{ + auto fullImpl = GetFullImpl(); + if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setGridScrollBar(node->uiNodeHandle, + ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO); + } +} + int32_t SetScrollScrollBar(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) { auto actualSize = CheckAttributeItemArray(item, REQUIRED_ONE_PARAM); + auto fullImpl = GetFullImpl(); if (actualSize < 0 || !InRegion(NUM_0, NUM_2, item->value[NUM_0].i32)) { + SetDefaultScrollBar(node); return ERROR_CODE_PARAM_INVALID; } - auto fullImpl = GetFullImpl(); + auto attrVal = item->value[NUM_0].i32; if (node->type == ARKUI_NODE_LIST) { fullImpl->getNodeModifiers()->getListModifier()->setListScrollBar(node->uiNodeHandle, attrVal); @@ -5944,6 +5977,8 @@ int32_t SetScrollScrollBar(ArkUI_NodeHandle node, const ArkUI_AttributeItem* ite fullImpl->getNodeModifiers()->getScrollModifier()->setScrollScrollBar(node->uiNodeHandle, attrVal); } else if (node->type == ARKUI_NODE_WATER_FLOW) { fullImpl->getNodeModifiers()->getWaterFlowModifier()->setWaterFlowScrollBar(node->uiNodeHandle, attrVal); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setGridScrollBar(node->uiNodeHandle, attrVal); } return ERROR_CODE_NO_ERROR; } @@ -5959,6 +5994,8 @@ void ResetScrollScrollBar(ArkUI_NodeHandle node) fullImpl->getNodeModifiers()->getScrollModifier()->resetScrollScrollBar(node->uiNodeHandle); } else if (node->type == ARKUI_NODE_WATER_FLOW) { fullImpl->getNodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBar(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->resetGridScrollBar(node->uiNodeHandle); } } @@ -5973,14 +6010,27 @@ const ArkUI_AttributeItem* GetScrollScrollBarWidth(ArkUI_NodeHandle node) } else if (node->type == ARKUI_NODE_WATER_FLOW) { g_numberValues[0].f32 = GetFullImpl()->getNodeModifiers()->getWaterFlowModifier()->getWaterFlowScrollBarWidth(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + g_numberValues[0].f32 = + GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridScrollBarWidth(node->uiNodeHandle); } return &g_attributeItem; } +void SetDefaultScrollBarWidth(ArkUI_NodeHandle node) +{ + auto fullImpl = GetFullImpl(); + if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setGridScrollBarWidth(node->uiNodeHandle, + GRID_DEFAULT_SCROLL_BAR_WIDTH, GetDefaultUnit(node, UNIT_VP)); + } +} + int32_t SetScrollScrollBarWidth(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) { auto actualSize = CheckAttributeItemArray(item, REQUIRED_ONE_PARAM); if (actualSize < 0 || LessNotEqual(item->value[NUM_0].f32, NUM_0)) { + SetDefaultScrollBarWidth(node); return ERROR_CODE_PARAM_INVALID; } auto fullImpl = GetFullImpl(); @@ -5995,7 +6045,9 @@ int32_t SetScrollScrollBarWidth(ArkUI_NodeHandle node, const ArkUI_AttributeItem auto width = std::to_string(attrVal) + LENGTH_METRIC_UNIT[unit]; fullImpl->getNodeModifiers()->getWaterFlowModifier()->setWaterFlowScrollBarWidth( node->uiNodeHandle, width.c_str()); - } + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setGridScrollBarWidth(node->uiNodeHandle, attrVal, unit); + } return ERROR_CODE_NO_ERROR; } @@ -6009,6 +6061,8 @@ void ResetScrollScrollBarWidth(ArkUI_NodeHandle node) fullImpl->getNodeModifiers()->getScrollModifier()->resetScrollScrollBarWidth(node->uiNodeHandle); } else if (node->type == ARKUI_NODE_WATER_FLOW) { fullImpl->getNodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBarWidth(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->resetGridScrollBarWidth(node->uiNodeHandle); } } @@ -6023,14 +6077,27 @@ const ArkUI_AttributeItem* GetScrollScrollBarColor(ArkUI_NodeHandle node) } else if (node->type == ARKUI_NODE_WATER_FLOW) { g_numberValues[0].u32 = GetFullImpl()->getNodeModifiers()->getWaterFlowModifier()->getWaterFlowScrollBarColor(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + g_numberValues[0].u32 = + GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridScrollBarColor(node->uiNodeHandle); } return &g_attributeItem; } +void SetDefaultScrollBarColor(ArkUI_NodeHandle node) +{ + auto fullImpl = GetFullImpl(); + if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setGridScrollBarColor(node->uiNodeHandle, + GRID_DEFAULT_SCROLL_BAR_COLOR); + } +} + int32_t SetScrollScrollBarColor(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) { auto actualSize = CheckAttributeItemArray(item, REQUIRED_ONE_PARAM); if (actualSize < 0) { + SetDefaultScrollBarColor(node); return ERROR_CODE_PARAM_INVALID; } auto fullImpl = GetFullImpl(); @@ -6044,6 +6111,8 @@ int32_t SetScrollScrollBarColor(ArkUI_NodeHandle node, const ArkUI_AttributeItem auto value = Color(color).ColorToString(); fullImpl->getNodeModifiers()->getWaterFlowModifier()->setWaterFlowScrollBarColor( node->uiNodeHandle, value.c_str()); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setGridScrollBarColor(node->uiNodeHandle, color); } return ERROR_CODE_NO_ERROR; } @@ -6059,6 +6128,8 @@ void ResetScrollScrollBarColor(ArkUI_NodeHandle node) fullImpl->getNodeModifiers()->getScrollModifier()->resetScrollScrollBarColor(node->uiNodeHandle); } else if (node->type == ARKUI_NODE_WATER_FLOW) { fullImpl->getNodeModifiers()->getWaterFlowModifier()->resetWaterFlowScrollBarColor(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->resetGridScrollBarColor(node->uiNodeHandle); } } @@ -6181,14 +6252,27 @@ const ArkUI_AttributeItem* GetScrollEnableScrollInteraction(ArkUI_NodeHandle nod g_numberValues[0].i32 = GetFullImpl()->getNodeModifiers()->getWaterFlowModifier()->getWaterFlowEnableScrollInteraction( node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + g_numberValues[0].i32 = + GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridEnableScrollInteraction(node->uiNodeHandle); } return &g_attributeItem; } +void SetDefalutEnableScrollInteraction(ArkUI_NodeHandle node) +{ + auto fullImpl = GetFullImpl(); + if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setGridEnableScrollInteraction( + node->uiNodeHandle, true); + } +} + int32_t SetScrollEnableScrollInteraction(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) { auto actualSize = CheckAttributeItemArray(item, REQUIRED_ONE_PARAM); if (actualSize < 0 || !InRegion(NUM_0, NUM_1, item->value[0].i32)) { + SetDefalutEnableScrollInteraction(node); return ERROR_CODE_PARAM_INVALID; } auto fullImpl = GetFullImpl(); @@ -6202,6 +6286,9 @@ int32_t SetScrollEnableScrollInteraction(ArkUI_NodeHandle node, const ArkUI_Attr } else if (node->type == ARKUI_NODE_WATER_FLOW) { fullImpl->getNodeModifiers()->getWaterFlowModifier()->setWaterFlowEnableScrollInteraction( node->uiNodeHandle, enableScrollInteraction); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setGridEnableScrollInteraction( + node->uiNodeHandle, enableScrollInteraction); } return ERROR_CODE_NO_ERROR; } @@ -6217,6 +6304,8 @@ void ResetScrollEnableScrollInteraction(ArkUI_NodeHandle node) fullImpl->getNodeModifiers()->getScrollModifier()->resetEnableScrollInteraction(node->uiNodeHandle); } else if (node->type == ARKUI_NODE_WATER_FLOW) { fullImpl->getNodeModifiers()->getWaterFlowModifier()->resetWaterFlowEnableScrollInteraction(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->resetGridEnableScrollInteraction(node->uiNodeHandle); } } @@ -6236,6 +6325,8 @@ int32_t SetScrollNestedScroll(ArkUI_NodeHandle node, const ArkUI_AttributeItem* node->uiNodeHandle, first, second); } else if (node->type == ARKUI_NODE_LIST) { fullImpl->getNodeModifiers()->getListModifier()->setListNestedScroll(node->uiNodeHandle, first, second); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->setNestedScroll(node->uiNodeHandle, first, second); } else { fullImpl->getNodeModifiers()->getScrollModifier()->setScrollNestedScroll(node->uiNodeHandle, first, second); } @@ -6250,6 +6341,8 @@ const ArkUI_AttributeItem* GetScrollNestedScroll(ArkUI_NodeHandle node) node->uiNodeHandle, &values); } else if (node->type == ARKUI_NODE_LIST) { GetFullImpl()->getNodeModifiers()->getListModifier()->getListNestedScroll(node->uiNodeHandle, &values); + } else if (node->type == ARKUI_NODE_GRID) { + GetFullImpl()->getNodeModifiers()->getGridModifier()->getNestedScroll(node->uiNodeHandle, &values); } else { GetFullImpl()->getNodeModifiers()->getScrollModifier()->getScrollNestedScroll(node->uiNodeHandle, &values); } @@ -6267,6 +6360,8 @@ void ResetScrollNestedScroll(ArkUI_NodeHandle node) fullImpl->getNodeModifiers()->getWaterFlowModifier()->resetWaterFlowNestedScroll(node->uiNodeHandle); } else if (node->type == ARKUI_NODE_LIST) { GetFullImpl()->getNodeModifiers()->getListModifier()->resetListNestedScroll(node->uiNodeHandle); + } else if (node->type == ARKUI_NODE_GRID) { + fullImpl->getNodeModifiers()->getGridModifier()->resetNestedScroll(node->uiNodeHandle); } else { fullImpl->getNodeModifiers()->getScrollModifier()->resetScrollNestedScroll(node->uiNodeHandle); } @@ -16067,6 +16162,83 @@ const ArkUI_AttributeItem* GetGridFocusWrapMode(ArkUI_NodeHandle node) return &g_attributeItem; } +int32_t SetGridAlignItems(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) +{ + ArkUI_Int32 alignment = GRID_ITEM_ALIGNMENT_DEFAULT; + if (item == nullptr || item->size < NUM_1 || !InRegion(NUM_0, NUM_1, item->value[NUM_0].i32)) { + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridAlignItems(node->uiNodeHandle, alignment); + return ERROR_CODE_PARAM_INVALID; + } else { + alignment = item->value[0].i32; + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridAlignItems(node->uiNodeHandle, alignment); + return ERROR_CODE_NO_ERROR; + } +} + +void ResetGridAlignItems(ArkUI_NodeHandle node) +{ + auto* fullImpl = GetFullImpl(); + fullImpl->getNodeModifiers()->getGridModifier()->resetGridAlignItems(node->uiNodeHandle); +} + +const ArkUI_AttributeItem* GetGridAlignItems(ArkUI_NodeHandle node) +{ + ArkUI_Int32 value = GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridAlignItems(node->uiNodeHandle); + g_numberValues[0].i32 = value; + return &g_attributeItem; +} + +int32_t SetGridLayoutOptions(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) +{ + CHECK_NULL_RETURN(item, ERROR_CODE_PARAM_INVALID); + CHECK_NULL_RETURN(item->object, ERROR_CODE_PARAM_INVALID); + auto* gridLayoutOptions = reinterpret_cast(item->object); + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridLayoutOptions( + node->uiNodeHandle, gridLayoutOptions); + return ERROR_CODE_NO_ERROR; +} + +void ResetGridLayoutOptions(ArkUI_NodeHandle node) +{ + // already check in entry point. + auto* fullImpl = GetFullImpl(); + fullImpl->getNodeModifiers()->getGridModifier()->resetGridLayoutOptions(node->uiNodeHandle); +} + +const ArkUI_AttributeItem* GetGridLayoutOptions(ArkUI_NodeHandle node) +{ + static ArkUI_GridLayoutOptions options = + GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridLayoutOptions(node->uiNodeHandle); + g_attributeItem.object = &options; + return &g_attributeItem; +} + +int32_t SetGridItemOptions(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) +{ + ArkUI_Int32 alignment = GRID_ITEM_STYLE_NONE; + if (item == nullptr || item->size < NUM_1 || !InRegion(NUM_0, NUM_1, item->value[NUM_0].i32)) { + GetFullImpl()->getNodeModifiers()->getGridItemModifier()->setGridItemOptions(node->uiNodeHandle, alignment); + return ERROR_CODE_PARAM_INVALID; + } else { + alignment = item->value[0].i32; + GetFullImpl()->getNodeModifiers()->getGridItemModifier()->setGridItemOptions(node->uiNodeHandle, alignment); + return ERROR_CODE_NO_ERROR; + } +} + +void ResetGridItemOptions(ArkUI_NodeHandle node) +{ + auto* fullImpl = GetFullImpl(); + fullImpl->getNodeModifiers()->getGridItemModifier()->resetGridItemOptions(node->uiNodeHandle); +} + +const ArkUI_AttributeItem* GetGridItemOptions(ArkUI_NodeHandle node) +{ + ArkUI_Int32 value = GetFullImpl()->getNodeModifiers()->getGridItemModifier()->getGridItemOptions(node->uiNodeHandle); + g_numberValues[0].i32 = value; + return &g_attributeItem; +} + bool CheckIfAttributeLegal(ArkUI_NodeHandle node, int32_t type) { if (node->type == ARKUI_NODE_SPAN) { @@ -17737,10 +17909,21 @@ int32_t SetRelativeContainerAttribute(ArkUI_NodeHandle node, int32_t subTypeId, return setters[subTypeId](node, item); } +int32_t SetGridItemAttribute(ArkUI_NodeHandle node, int32_t subTypeId, const ArkUI_AttributeItem* item) +{ + static Setter* setters[] = { SetGridItemOptions }; + if (static_cast(subTypeId) >= sizeof(setters) / sizeof(Setter*)) { + TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "GridItem node attribute: %{public}d NOT IMPLEMENT", subTypeId); + return ERROR_CODE_NATIVE_IMPL_TYPE_NOT_SUPPORTED; + } + return setters[subTypeId](node, item); +} + int32_t SetGridAttribute(ArkUI_NodeHandle node, int32_t subTypeId, const ArkUI_AttributeItem* item) { static Setter* setters[] = { SetGridColumnsTemplate, SetGridRowsTemplate, SetGridColumnsGap, SetGridRowsGap, - SetGridNodeAdapter, SetGridCachedCount, SetGridFocusWrapMode, SetGridSyncLoad }; + SetGridNodeAdapter, SetGridCachedCount, SetGridFocusWrapMode, SetGridSyncLoad, SetGridAlignItems, + SetGridLayoutOptions }; if (static_cast(subTypeId) >= sizeof(setters) / sizeof(Setter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Grid node attribute: %{public}d NOT IMPLEMENT", subTypeId); return ERROR_CODE_NATIVE_IMPL_TYPE_NOT_SUPPORTED; @@ -17758,10 +17941,21 @@ void ResetRelativeContainerAttribute(ArkUI_NodeHandle node, int32_t subTypeId) return resetters[subTypeId](node); } +void ResetGridItemAttribute(ArkUI_NodeHandle node, int32_t subTypeId) +{ + static Resetter* resetters[] = { ResetGridItemOptions }; + if (static_cast(subTypeId) >= sizeof(resetters) / sizeof(Resetter*)) { + TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "GridItem node attribute: %{public}d NOT IMPLEMENT", subTypeId); + return; + } + return resetters[subTypeId](node); +} + void ResetGridAttribute(ArkUI_NodeHandle node, int32_t subTypeId) { static Resetter* resetters[] = { ResetGridColumnsTemplate, ResetGridRowsTemplate, ResetGridColumnsGap, - ResetGridRowsGap, ResetGridNodeAdapter, ResetGridCachedCount, ResetGridFocusWrapMode, ResetGridSyncLoad }; + ResetGridRowsGap, ResetGridNodeAdapter, ResetGridCachedCount, ResetGridFocusWrapMode, ResetGridSyncLoad, + ResetGridAlignItems, ResetGridLayoutOptions }; if (static_cast(subTypeId) >= sizeof(resetters) / sizeof(Resetter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Grid node attribute: %{public}d NOT IMPLEMENT", subTypeId); return; @@ -17780,10 +17974,22 @@ const ArkUI_AttributeItem* GetRelativeContainerAttribute(ArkUI_NodeHandle node, return getters[subTypeId](node); } +const ArkUI_AttributeItem* GetGridItemAttribute(ArkUI_NodeHandle node, int32_t subTypeId) +{ + static Getter* getters[] = { GetGridItemOptions }; + if (static_cast(subTypeId) >= sizeof(getters) / sizeof(Getter*)) { + TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "GridItem node attribute: %{public}d NOT IMPLEMENT", subTypeId); + return nullptr; + } + g_attributeItem.size = RETURN_SIZE_ONE; + return getters[subTypeId](node); +} + const ArkUI_AttributeItem* GetGridAttribute(ArkUI_NodeHandle node, int32_t subTypeId) { static Getter* getters[] = { GetGridColumnsTemplate, GetGridRowsTemplate, GetGridColumnsGap, GetGridRowsGap, - GetGridNodeAdapter, GetGridCachedCount, GetGridFocusWrapMode, GetGridSyncLoad }; + GetGridNodeAdapter, GetGridCachedCount, GetGridFocusWrapMode, GetGridSyncLoad, GetGridAlignItems, + GetGridLayoutOptions }; if (static_cast(subTypeId) >= sizeof(getters) / sizeof(Getter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Grid node attribute: %{public}d NOT IMPLEMENT", subTypeId); return nullptr; @@ -17838,7 +18044,7 @@ int32_t SetNodeAttribute(ArkUI_NodeHandle node, ArkUI_NodeAttributeType type, co SetXComponentAttribute, SetCheckboxGroupAttribute, SetStackAttribute, SetSwiperAttribute, SetScrollAttribute, SetListAttribute, SetListItemAttribute, SetListItemGroupAttribute, SetColumnAttribute, SetRowAttribute, SetFlexAttribute, SetRefreshAttribute, SetWaterFlowAttribute, nullptr, SetRelativeContainerAttribute, - SetGridAttribute, nullptr, nullptr, SetEmbeddedComponentAttribute }; + SetGridAttribute, SetGridItemAttribute, nullptr, SetEmbeddedComponentAttribute }; int32_t subTypeClass = type / MAX_NODE_SCOPE_NUM; int32_t subTypeId = type % MAX_NODE_SCOPE_NUM; int32_t nodeSubTypeClass = @@ -17868,7 +18074,7 @@ const ArkUI_AttributeItem* GetNodeAttribute(ArkUI_NodeHandle node, ArkUI_NodeAtt GetCalendarPickerAttribute, GetSliderAttribute, GetRadioAttribute, GetImageAnimatorAttribute, GetXComponentAttribute, GetCheckboxGroupAttribute, GetStackAttribute, GetSwiperAttribute, GetScrollAttribute, GetListAttribute, nullptr, GetListItemGroupAttribute, GetColumnAttribute, GetRowAttribute, GetFlexAttribute, - GetRefreshAttribute, GetWaterFlowAttribute, nullptr, GetRelativeContainerAttribute, GetGridAttribute }; + GetRefreshAttribute, GetWaterFlowAttribute, nullptr, GetRelativeContainerAttribute, GetGridAttribute, GetGridItemAttribute }; int32_t subTypeClass = type / MAX_NODE_SCOPE_NUM; int32_t subTypeId = type % MAX_NODE_SCOPE_NUM; int32_t nodeSubTypeClass = @@ -17895,7 +18101,7 @@ int32_t ResetNodeAttribute(ArkUI_NodeHandle node, ArkUI_NodeAttributeType type) ResetImageAnimatorAttribute, ResetXComponentAttribute, ResetCheckboxGroupAttribute, ResetStackAttribute, ResetSwiperAttribute, ResetScrollAttribute, ResetListAttribute, ResetListItemAttribute, ResetListItemGroupAttribute, ResetColumnAttribute, ResetRowAttribute, ResetFlexAttribute, ResetRefreshAttribute, - ResetWaterFlowAttribute, nullptr, ResetRelativeContainerAttribute, ResetGridAttribute }; + ResetWaterFlowAttribute, nullptr, ResetRelativeContainerAttribute, ResetGridAttribute, ResetGridItemAttribute }; int32_t subTypeClass = type / MAX_NODE_SCOPE_NUM; int32_t subTypeId = type % MAX_NODE_SCOPE_NUM; int32_t nodeSubTypeClass = diff --git a/test/mock/core/common/mock_container.cpp b/test/mock/core/common/mock_container.cpp index 4ca6cf9cb17..fc477f47fa9 100755 --- a/test/mock/core/common/mock_container.cpp +++ b/test/mock/core/common/mock_container.cpp @@ -22,6 +22,7 @@ namespace OHOS::Ace { namespace { int32_t g_id = 0; +constexpr int32_t API_15 = 15; } // namespace RefPtr MockContainer::container_; @@ -246,6 +247,14 @@ bool Container::GreatOrEqualAPIVersionWithCheck(PlatformVersion version) : GreatOrEqualAPITargetVersion(version); } +bool Container::EqualAPIVersion(PlatformVersion version) +{ + return static_cast(version) < API_15 + ? PipelineBase::GetCurrentContext() && + PipelineBase::GetCurrentContext()->GetMinPlatformVersion() == static_cast(version) + : EqualAPITargetVersion(version); +} + sptr Container::GetToken() { return nullptr; diff --git a/test/unittest/core/pattern/grid/grid_attr_test_ng.cpp b/test/unittest/core/pattern/grid/grid_attr_test_ng.cpp index e958030cb50..3b2c121d23d 100644 --- a/test/unittest/core/pattern/grid/grid_attr_test_ng.cpp +++ b/test/unittest/core/pattern/grid/grid_attr_test_ng.cpp @@ -12,8 +12,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - +#include #include "grid_test_ng.h" +#include "test/mock/core/common/mock_theme_manager.h" +#include "test/mock/core/pipeline/mock_pipeline_context.h" #include "test/mock/core/render/mock_render_context.h" #include "core/components_ng/pattern/grid/grid_item_pattern.h" @@ -21,6 +23,16 @@ namespace OHOS::Ace::NG { namespace { const InspectorFilter filter; +constexpr Dimension DEFAULT_SCROLL_WIDTH = 4.0_vp; +constexpr Dimension TEST_10_VP = 10.0_vp; +constexpr Dimension TEST_20_VP = 20.0_vp; +constexpr Color DEFAULT_SCROLL_BAR_COLOR = Color(0x66182431); +constexpr int32_t API_10 = 10; +constexpr int32_t API_11 = 11; +constexpr int32_t API_12 = 12; +constexpr int32_t API_13 = 13; +constexpr double DEFAULT_FRICTION_API11 = 0.7; +constexpr double DEFAULT_FRICTION_API12 = 0.75; } // namespace class GridAttrTestNg : public GridTestNg { @@ -1192,4 +1204,279 @@ HWTEST_F(GridAttrTestNg, Property005, TestSize.Level1) EXPECT_EQ(json->GetString("selected"), "true"); EXPECT_EQ(json->GetString("selectable"), "true"); } + +/** + * @tc.name: GridItemStyleTest001 + * @tc.desc: GridItem get itemStyle test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridItemStyleTest001, TestSize.Level1) +{ + GridModelNG model = CreateGrid(); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + + auto itemModel = CreateGridItem(60, 550); + auto node = GetChildFrameNode(frameNode_, 0); + auto pattern = node->GetPattern(); + ASSERT_NE(pattern, nullptr); + itemModel.SetGridItemStyle(node.GetRawPtr(), GridItemStyle::NONE); + auto itemStyle = itemModel.GetGridItemStyle(node.GetRawPtr()); + EXPECT_EQ(itemStyle, GridItemStyle::NONE); + auto gridItemPattern = GetChildPattern(frameNode_, 0); + ASSERT_NE(gridItemPattern, nullptr); + EXPECT_EQ(gridItemPattern->GetGridItemStyle(), GridItemStyle::NONE); + + itemModel.SetGridItemStyle(node.GetRawPtr(), GridItemStyle::PLAIN); + itemStyle = itemModel.GetGridItemStyle(node.GetRawPtr()); + EXPECT_EQ(itemStyle, GridItemStyle::PLAIN); + EXPECT_EQ(gridItemPattern->GetGridItemStyle(), GridItemStyle::PLAIN); + + itemStyle = itemModel.GetGridItemStyle(nullptr); + EXPECT_EQ(itemStyle, GridItemStyle::NONE); + + node->pattern_ = nullptr; + itemStyle = itemModel.GetGridItemStyle(node.GetRawPtr()); + EXPECT_EQ(itemStyle, GridItemStyle::NONE); + node->pattern_ = pattern; +} + +/** + * @tc.name: GridModelNGTest001 + * @tc.desc: GridModelNG GetAlignItems test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridModelNGTest001, TestSize.Level1) +{ + GridModelNG gridModel = CreateGrid(); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + + auto node = AceType::RawPtr(frameNode_); + ASSERT_NE(node, nullptr); + + gridModel.SetAlignItems(node, GridItemAlignment::DEFAULT); + EXPECT_EQ(gridModel.GetAlignItems(node), GridItemAlignment::DEFAULT); + + gridModel.SetAlignItems(node, GridItemAlignment::STRETCH); + EXPECT_EQ(gridModel.GetAlignItems(node), GridItemAlignment::STRETCH); + + EXPECT_EQ(gridModel.GetAlignItems(nullptr), GridItemAlignment::DEFAULT); +} + +/** + * @tc.name: GridModelNGTest002 + * @tc.desc: GridModelNG GetScrollBarMode test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridModelNGTest002, TestSize.Level1) +{ + GridModelNG gridModel = CreateGrid(); + gridModel.SetColumnsTemplate("1fr 1fr"); + gridModel.SetScrollBarMode(DisplayMode::ON); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + + auto node = AceType::RawPtr(frameNode_); + ASSERT_NE(node, nullptr); + gridModel.SetScrollBarMode(node, DisplayMode::AUTO); + EXPECT_EQ(gridModel.GetScrollBarMode(node), static_cast(DisplayMode::AUTO)); + + gridModel.SetScrollBarMode(node, DisplayMode::ON); + EXPECT_EQ(gridModel.GetScrollBarMode(node), static_cast(DisplayMode::ON)); + + gridModel.SetScrollBarMode(node, DisplayMode::OFF); + EXPECT_EQ(gridModel.GetScrollBarMode(node), static_cast(DisplayMode::OFF)); + + EXPECT_EQ(gridModel.GetScrollBarMode(nullptr), static_cast(DisplayMode::AUTO)); +} + +/** + * @tc.name: GridModelNGTest003 + * @tc.desc: GridModelNG GetScrollBarWidth test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridModelNGTest003, TestSize.Level1) +{ + GridModelNG gridModel = CreateGrid(); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + auto themeManager = AceType::MakeRefPtr(); + MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); + auto theme = AceType::MakeRefPtr(); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(theme)); + auto node = AceType::RawPtr(frameNode_); + gridModel.SetScrollBarWidth(node, TEST_10_VP); + EXPECT_EQ(gridModel.GetScrollBarWidth(node), TEST_10_VP.ConvertToVp()); + + gridModel.SetScrollBarWidth(node, TEST_20_VP); + EXPECT_EQ(gridModel.GetScrollBarWidth(node), TEST_20_VP.ConvertToVp()); + + EXPECT_EQ(gridModel.GetScrollBarWidth(nullptr), DEFAULT_SCROLL_WIDTH.ConvertToVp()); +} + +/** + * @tc.name: GridModelNGTest004 + * @tc.desc: GridModelNG GetScrollBarWidth test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridModelNGTest004, TestSize.Level1) +{ + GridModelNG gridModel = CreateGrid(); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + + auto themeManager = AceType::MakeRefPtr(); + MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); + auto theme = AceType::MakeRefPtr(); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(theme)); + + auto node = AceType::RawPtr(frameNode_); + ASSERT_NE(node, nullptr); + gridModel.SetScrollBarColor(node, Color::RED); + EXPECT_EQ(gridModel.GetScrollBarColor(node), Color::RED.GetValue()); + + gridModel.SetScrollBarColor(node, Color::BLUE); + EXPECT_EQ(gridModel.GetScrollBarColor(node), Color::BLUE.GetValue()); + + EXPECT_EQ(gridModel.GetScrollBarColor(nullptr), DEFAULT_SCROLL_BAR_COLOR.GetValue()); +} + +/** + * @tc.name: GridModelNGTest005 + * @tc.desc: GridModelNG GetNestedScroll test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridModelNGTest005, TestSize.Level1) +{ + GridModelNG gridModel = CreateGrid(); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + + auto node = AceType::RawPtr(frameNode_); + ASSERT_NE(node, nullptr); + auto pattern = node->GetPattern(); + ASSERT_NE(pattern, nullptr); + NestedScrollOptions retNestedScrollOptions = gridModel.GetNestedScroll(node); + EXPECT_EQ(retNestedScrollOptions.forward, NestedScrollMode::SELF_ONLY); + EXPECT_EQ(retNestedScrollOptions.backward, NestedScrollMode::SELF_ONLY); + + NestedScrollOptions nestedScrollOptions; + nestedScrollOptions.forward = NestedScrollMode::PARENT_FIRST; + nestedScrollOptions.backward = NestedScrollMode::PARENT_FIRST; + + gridModel.SetNestedScroll(node, nestedScrollOptions); + retNestedScrollOptions = gridModel.GetNestedScroll(node); + EXPECT_EQ(retNestedScrollOptions.forward, NestedScrollMode::PARENT_FIRST); + EXPECT_EQ(retNestedScrollOptions.backward, NestedScrollMode::PARENT_FIRST); + + retNestedScrollOptions = gridModel.GetNestedScroll(nullptr); + EXPECT_EQ(retNestedScrollOptions.forward, NestedScrollMode::SELF_ONLY); + EXPECT_EQ(retNestedScrollOptions.backward, NestedScrollMode::SELF_ONLY); + + node->pattern_ = nullptr; + retNestedScrollOptions = gridModel.GetNestedScroll(node); + EXPECT_EQ(retNestedScrollOptions.forward, NestedScrollMode::SELF_ONLY); + EXPECT_EQ(retNestedScrollOptions.backward, NestedScrollMode::SELF_ONLY); + node->pattern_ = pattern; +} + +/** + * @tc.name: GridModelNGTest006 + * @tc.desc: GridModelNG GetScrollEnabled test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridModelNGTest006, TestSize.Level1) +{ + GridModelNG gridModel = CreateGrid(); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + + auto node = AceType::RawPtr(frameNode_); + ASSERT_NE(node, nullptr); + gridModel.SetScrollEnabled(node, true); + EXPECT_TRUE(gridModel.GetScrollEnabled(node)); + + gridModel.SetScrollEnabled(node, false); + EXPECT_FALSE(gridModel.GetScrollEnabled(node)); + + EXPECT_TRUE(gridModel.GetScrollEnabled(nullptr)); +} + +/** + * @tc.name: GridModelNGTest007 + * @tc.desc: GridModelNG GetFriction test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridModelNGTest007, TestSize.Level1) +{ + GridModelNG gridModel = CreateGrid(); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + + auto node = AceType::RawPtr(frameNode_); + ASSERT_NE(node, nullptr); + auto pattern = node->GetPattern(); + ASSERT_NE(pattern, nullptr); + gridModel.SetFriction(node, 0.8); + EXPECT_EQ(gridModel.GetFriction(node), 0.8); + + auto themeManager = AceType::MakeRefPtr(); + MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); + auto theme = AceType::MakeRefPtr(); + EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(theme)); + auto friction = theme->GetFriction(); + + node->pattern_ = nullptr; + auto pipeline = MockPipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + pipeline->SetMinPlatformVersion(API_10); + EXPECT_EQ(gridModel.GetFriction(nullptr), FRICTION); + EXPECT_EQ(gridModel.GetFriction(node), FRICTION); + + pipeline->SetMinPlatformVersion(API_11); + EXPECT_EQ(gridModel.GetFriction(nullptr), DEFAULT_FRICTION_API11); + EXPECT_EQ(gridModel.GetFriction(node), DEFAULT_FRICTION_API11); + + pipeline->SetMinPlatformVersion(API_12); + EXPECT_EQ(gridModel.GetFriction(nullptr), DEFAULT_FRICTION_API12); + EXPECT_EQ(gridModel.GetFriction(node), DEFAULT_FRICTION_API12); + + pipeline->SetApiTargetVersion(API_13); + EXPECT_EQ(gridModel.GetFriction(nullptr), friction); + EXPECT_EQ(gridModel.GetFriction(node), friction); + node->pattern_ = pattern; +} + +/** + * @tc.name: GridModelNGTest008 + * @tc.desc: GridModelNG GetLayoutOptions test. + * @tc.type: FUNC + */ +HWTEST_F(GridAttrTestNg, GridModelNGTest008, TestSize.Level1) +{ + GridModelNG gridModel = CreateGrid(); + CreateFixedItems(10, GridItemStyle::PLAIN); + CreateDone(); + + auto node = AceType::RawPtr(frameNode_); + ASSERT_NE(node, nullptr); + GridLayoutOptions option; + option.irregularIndexes = { 6, 1, 3, 4, 5, 0 }; + GetSizeByIndex onGetIrregularSizeByIndex = [](int32_t index) { + if (index == 3) { + return GridItemSize { 1, 2 }; + } + return GridItemSize { 1, 4 }; + }; + option.getSizeByIndex = std::move(onGetIrregularSizeByIndex); + gridModel.SetLayoutOptions(node, option); + auto retOption = gridModel.GetLayoutOptions(node); + EXPECT_EQ(retOption.irregularIndexes, option.irregularIndexes); + ASSERT_NE(retOption.getSizeByIndex, nullptr); + EXPECT_EQ(retOption.getSizeByIndex(3).rows, 1); + EXPECT_EQ(retOption.getSizeByIndex(3).columns, 2); + EXPECT_EQ(retOption.getSizeByIndex(0).rows, 1); + EXPECT_EQ(retOption.getSizeByIndex(0).columns, 4); +} } // namespace OHOS::Ace::NG diff --git a/test/unittest/core/pattern/scroll/scroll_pattern_test_ng_three.cpp b/test/unittest/core/pattern/scroll/scroll_pattern_test_ng_three.cpp index 96e0a2771dd..0774803d2ee 100644 --- a/test/unittest/core/pattern/scroll/scroll_pattern_test_ng_three.cpp +++ b/test/unittest/core/pattern/scroll/scroll_pattern_test_ng_three.cpp @@ -17,6 +17,14 @@ #include "scroll_test_ng.h" namespace OHOS::Ace::NG { +namespace { +constexpr int32_t API_10 = 10; +constexpr int32_t API_11 = 11; +constexpr int32_t API_12 = 12; +constexpr int32_t API_13 = 13; +constexpr float DEFAULT_FRICTION_API11 = 0.7; +constexpr float DEFAULT_FRICTION_API12 = 0.75; +} // namespace // using namespace testing; // using namespace testing::ext; @@ -366,4 +374,33 @@ TEST_F(ScrollPatternThreeTestNg, FireObserverOnDidScroll) ScrollTo(ITEM_MAIN_SIZE); EXPECT_TRUE(isCallback); } + + +/** + * @tc.name: GetDefaultFriction + * @tc.desc: Test ScrollPattern GetDefaultFriction + * @tc.type: FUNC + */ +HWTEST_F(ScrollPatternThreeTestNg, GetDefaultFriction, TestSize.Level1) +{ + auto scrollPattern = AceType::MakeRefPtr(); + auto frameNode = FrameNode::CreateFrameNode(V2::SCROLL_ETS_TAG, 2, scrollPattern); + ASSERT_NE(frameNode, nullptr); + + AceApplicationInfo::GetInstance().SetApiTargetVersion(API_10); + EXPECT_EQ(scrollPattern->GetDefaultFriction(), FRICTION); + AceApplicationInfo::GetInstance().SetApiTargetVersion(API_11); + EXPECT_EQ(scrollPattern->GetDefaultFriction(), API11_FRICTION); + + AceApplicationInfo::GetInstance().SetApiTargetVersion(API_12); + EXPECT_EQ(scrollPattern->GetDefaultFriction(), API12_FRICTION); + + AceApplicationInfo::GetInstance().SetApiTargetVersion(API_13); + auto context = PipelineBase::GetCurrentContext(); + ASSERT_NE(context, nullptr); + auto scrollableTheme = context->GetTheme(); + ASSERT_NE(scrollableTheme, nullptr); + auto friction = scrollableTheme->GetFriction(); + EXPECT_EQ(scrollPattern->GetDefaultFriction(), friction); +} } // namespace OHOS::Ace::NG \ No newline at end of file diff --git a/test/unittest/core/pattern/scrollable/scrollable_pattern_test_ng_two.cpp b/test/unittest/core/pattern/scrollable/scrollable_pattern_test_ng_two.cpp index 0a712d28e04..bf0f369bea1 100644 --- a/test/unittest/core/pattern/scrollable/scrollable_pattern_test_ng_two.cpp +++ b/test/unittest/core/pattern/scrollable/scrollable_pattern_test_ng_two.cpp @@ -24,6 +24,15 @@ #include "test/mock/core/pipeline/mock_pipeline_context.h" namespace OHOS::Ace::NG { +namespace { +#ifndef WEARABLE_PRODUCT +constexpr double FRICTION = 0.6; +constexpr double API11_FRICTION = 0.7; +constexpr double API12_FRICTION = 0.75; +#else +constexpr double FRICTION = 0.9; +#endif +} using namespace testing; using namespace testing::ext; @@ -548,4 +557,26 @@ HWTEST_F(ScrollableTestNg, HandleExtScroll008, TestSize.Level1) scrollablePattern->HandleExtScroll(); EXPECT_EQ(scrollablePattern->isNeedCollectOffset_, true); } + +HWTEST_F(ScrollableTestNg, GetDefaultFriction, TestSize.Level1) +{ + AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast(PlatformVersion::VERSION_TEN)); + RefPtr scrollablePattern = AceType::MakeRefPtr(); + EXPECT_EQ(scrollablePattern->GetDefaultFriction(), OHOS::Ace::NG::FRICTION); + + AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast(PlatformVersion::VERSION_ELEVEN)); + EXPECT_EQ(scrollablePattern->GetDefaultFriction(), OHOS::Ace::NG::API11_FRICTION); + + AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast(PlatformVersion::VERSION_TWELVE)); + EXPECT_EQ(scrollablePattern->GetDefaultFriction(), OHOS::Ace::NG::API12_FRICTION); + + AceApplicationInfo::GetInstance().SetApiTargetVersion( + static_cast(PlatformVersion::version::VERSION_THIRTEEN)); + auto context = PipelineBase::GetCurrentContext(); + CHECK_NULL_RETURN(context, friction); + auto scrollableTheme = context->GetTheme(); + CHECK_NULL_RETURN(scrollableTheme, friction); + auto friction = scrollableTheme->GetFriction(); + EXPECT_EQ(scrollablePattern->GetDefaultFriction(), friction); +} } // namespace OHOS::Ace::NG \ No newline at end of file diff --git a/test/unittest/interfaces/BUILD.gn b/test/unittest/interfaces/BUILD.gn index 093ed091fe8..8390a52cd10 100644 --- a/test/unittest/interfaces/BUILD.gn +++ b/test/unittest/interfaces/BUILD.gn @@ -240,6 +240,7 @@ ohos_unittest("native_node_napi_test") { "$ace_root/interfaces/native/node/dialog_model.cpp", "$ace_root/interfaces/native/node/event_converter.cpp", "$ace_root/interfaces/native/node/gesture_impl.cpp", + "$ace_root/interfaces/native/node/grid_layout_option.cpp", "$ace_root/interfaces/native/node/native_impl.cpp", "$ace_root/interfaces/native/node/native_node_extented.cpp", "$ace_root/interfaces/native/node/native_node_napi.cpp", diff --git a/test/unittest/interfaces/native_node_test.cpp b/test/unittest/interfaces/native_node_test.cpp index 67b9c1b38c2..f1fb6438976 100644 --- a/test/unittest/interfaces/native_node_test.cpp +++ b/test/unittest/interfaces/native_node_test.cpp @@ -1878,6 +1878,24 @@ HWTEST_F(NativeNodeTest, NativeNodeTest006, TestSize.Level1) EXPECT_EQ(ret, static_cast(ON_CHECKBOX_GROUP_CHANGE)); ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_AXIS, nodeType); EXPECT_EQ(ret, static_cast(ON_AXIS)); + + nodeType = static_cast(ARKUI_NODE_GRID); + ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_GRID_ON_SCROLL_BAR_UPDATE, nodeType); + EXPECT_EQ(ret, static_cast(ON_GRID_SCROLL_BAR_UPDATE)); + ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN, nodeType); + EXPECT_EQ(ret, static_cast(ON_GRID_SCROLL_FRAME_BEGIN)); + ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_GRID_ON_SCROLL_INDEX, nodeType); + EXPECT_EQ(ret, static_cast(ON_GRID_SCROLL_TO_INDEX)); + ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_START, nodeType); + EXPECT_EQ(ret, static_cast(ON_GRID_START)); + ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_SCROLL_STOP, nodeType); + EXPECT_EQ(ret, static_cast(ON_GRID_STOP)); + ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_GRID_ON_WILL_SCROLL, nodeType); + EXPECT_EQ(ret, static_cast(ON_GRID_WILL_SCROLL)); + ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_GRID_ON_DID_SCROLL, nodeType); + EXPECT_EQ(ret, static_cast(ON_GRID_DID_SCROLL)); + ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_SCROLL_EVENT_ON_WILL_STOP_DRAGGING, nodeType); + EXPECT_EQ(ret, static_cast(ON_GRID_WILL_STOP_DRAGGING)); } /** @@ -2086,6 +2104,22 @@ HWTEST_F(NativeNodeTest, NativeNodeTest007, TestSize.Level1) EXPECT_EQ(ret, static_cast(NODE_IMAGE_ANIMATOR_EVENT_ON_REPEAT)); ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_IMAGE_ANIMATOR_ON_FINISH); EXPECT_EQ(ret, static_cast(NODE_IMAGE_ANIMATOR_EVENT_ON_FINISH)); + ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_GRID_SCROLL_FRAME_BEGIN); + EXPECT_EQ(ret, static_cast(NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN)); + ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_GRID_SCROLL_TO_INDEX); + EXPECT_EQ(ret, static_cast(NODE_GRID_ON_SCROLL_INDEX)); + ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_GRID_START); + EXPECT_EQ(ret, static_cast(NODE_SCROLL_EVENT_ON_SCROLL_START)); + ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_GRID_STOP); + EXPECT_EQ(ret, static_cast(NODE_SCROLL_EVENT_ON_SCROLL_STOP)); + ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_GRID_WILL_SCROLL); + EXPECT_EQ(ret, static_cast(NODE_GRID_ON_WILL_SCROLL)); + ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_GRID_DID_SCROLL); + EXPECT_EQ(ret, static_cast(NODE_GRID_ON_DID_SCROLL)); + ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_GRID_WILL_STOP_DRAGGING); + EXPECT_EQ(ret, static_cast(NODE_SCROLL_EVENT_ON_WILL_STOP_DRAGGING)); + ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_GRID_SCROLL_BAR_UPDATE); + EXPECT_EQ(ret, static_cast(NODE_GRID_ON_SCROLL_BAR_UPDATE)); ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_KEY_EVENT); EXPECT_EQ(ret, static_cast(NODE_ON_KEY_EVENT)); ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ArkUIEventSubKind::ON_KEY_PREIME); @@ -3964,7 +3998,7 @@ HWTEST_F(NativeNodeTest, NativeNodeTest034, TestSize.Level1) EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_ROW_GAP), nullptr); EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_NODE_ADAPTER), nullptr); EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_CACHED_COUNT), nullptr); - + nodeAPI->disposeNode(rootNode); } @@ -8550,6 +8584,23 @@ HWTEST_F(NativeNodeTest, NativeNodeScrollOnWillStopDraggingTest004, TestSize.Lev nodeAPI->disposeNode(scroll); } +/** + * @tc.name: NativeNodeScrollOnWillStopDraggingTest005 + * @tc.desc: Test Grid onWillStopDragging event. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeScrollOnWillStopDraggingTest005, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto scroll = nodeAPI->createNode(ARKUI_NODE_GRID); + + auto ret = nodeAPI->registerNodeEvent(scroll, NODE_SCROLL_EVENT_ON_WILL_STOP_DRAGGING, 1, nullptr); + EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); + nodeAPI->unregisterNodeEvent(scroll, NODE_SCROLL_EVENT_ON_WILL_STOP_DRAGGING); + nodeAPI->disposeNode(scroll); +} + /** * @tc.name: NativeNodeScrollableEdgeEffectTest001 * @tc.desc: Test Scrollable EdgeEffect. @@ -8730,5 +8781,427 @@ HWTEST_F(NativeNodeTest, NativeNodeOverlayTest002, TestSize.Level1) nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &item4); overlayVal = nodeAPI->getAttribute(rootNode, NODE_OVERLAY); EXPECT_EQ(overlayVal->value[0].i32, static_cast(ARKUI_ALIGNMENT_BOTTOM_END)); + +/** + * @tc.name: NativeNodeAlignitems + * @tc.desc: Test alignitems function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeAlignitems, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + //set get and reset + ArkUI_NumberValue value[] = {{ .i32 = 1 }}; + ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"}; + nodeAPI->setAttribute(rootNode, NODE_GRID_ALIGN_ITEMS, &item); + auto result = nodeAPI->getAttribute(rootNode, NODE_GRID_ALIGN_ITEMS); + EXPECT_EQ(result->value[0].i32, 1); + EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_ALIGN_ITEMS), ARKUI_ERROR_CODE_NO_ERROR); + result = nodeAPI->getAttribute(rootNode, NODE_GRID_ALIGN_ITEMS); + EXPECT_EQ(result->value[0].i32, 0); + + // set invalid value + value[0].i32 = -1; + nodeAPI->setAttribute(rootNode, NODE_GRID_ALIGN_ITEMS, &item); + result = nodeAPI->getAttribute(rootNode, NODE_GRID_ALIGN_ITEMS); + EXPECT_EQ(result->value[0].i32, 0); + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeNodeEnableScrollinteraction + * @tc.desc: Test enableScrollinteraction function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeEnableScrollinteraction, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + //set get and reset + ArkUI_NumberValue value[] = {{ .i32 = true }}; + ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"}; + nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item); + auto result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION); + EXPECT_TRUE(result->value[0].i32); + + value[0].i32 = false; + nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION); + EXPECT_FALSE(result->value[0].i32); + + EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), ARKUI_ERROR_CODE_NO_ERROR); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION); + EXPECT_TRUE(result->value[0].i32); + + // set invalid value + value[0].i32 = -1; + nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION); + EXPECT_TRUE(result->value[0].i32); + + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeFriction + * @tc.desc: Test friction function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeFriction, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + //set get and reset + ArkUI_NumberValue value[] = {{ .f32 = 0.5 }}; + ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"}; + nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item); + auto result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION); + EXPECT_EQ(result->value[0].f32, 0.5); + + EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_FRICTION), ARKUI_ERROR_CODE_NO_ERROR); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION); + EXPECT_EQ(result->value[0].f32, FRICTION); + + // set invalid value + value[0].f32 = -1.0f; + EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION); + EXPECT_EQ(result->value[0].f32, FRICTION); + + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeNodeGridLayoutOptions + * @tc.desc: Test gridLayoutOptions function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridLayoutOptions, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + // set get and reset + auto option = OH_ArkUI_GridLayoutOptions_Create(); + uint32_t irregularIndexes[] = { 0, 7 }; + EXPECT_EQ(OH_ArkUI_GridLayoutOptions_SetIrregularIndexes(option, irregularIndexes, 2), ARKUI_ERROR_CODE_NO_ERROR); + + ArkUI_AttributeItem item = { .object = option }; + nodeAPI->setAttribute(rootNode, NODE_GRID_LAYOUT_OPTIONS, &item); + auto result = nodeAPI->getAttribute(rootNode, NODE_GRID_LAYOUT_OPTIONS); + auto retOption = reinterpret_cast(result->object); + ASSERT_NE(retOption, nullptr); + uint32_t retIrregularIndexes[2] = {}; + int size = 2; + EXPECT_EQ(OH_ArkUI_GridLayoutOptions_GetIrregularIndexes(retOption, retIrregularIndexes, &size), + ARKUI_ERROR_CODE_NO_ERROR); + EXPECT_EQ(retIrregularIndexes[0], irregularIndexes[0]); + EXPECT_EQ(retIrregularIndexes[1], irregularIndexes[1]); + + uint32_t retIndexes[4] = {}; + int32_t retSize = 4; + EXPECT_EQ(OH_ArkUI_GridLayoutOptions_GetIrregularIndexes(option, retIndexes, &retSize), ARKUI_ERROR_CODE_NO_ERROR); + EXPECT_EQ(retSize, 2); + EXPECT_EQ(retIndexes[0], irregularIndexes[0]); + EXPECT_EQ(retIndexes[1], irregularIndexes[1]); + + // set invalid value + uint32_t invalidIndexes[1] = {}; + int invalidSize = 1; + EXPECT_EQ(OH_ArkUI_GridLayoutOptions_GetIrregularIndexes(option, invalidIndexes, &invalidSize), + ARKUI_ERROR_CODE_BUFFER_SIZE_ERROR); + + EXPECT_EQ( + OH_ArkUI_GridLayoutOptions_SetIrregularIndexes(nullptr, irregularIndexes, 2), ARKUI_ERROR_CODE_PARAM_INVALID); + EXPECT_EQ(OH_ArkUI_GridLayoutOptions_SetIrregularIndexes(option, nullptr, 2), ARKUI_ERROR_CODE_PARAM_INVALID); + EXPECT_EQ( + OH_ArkUI_GridLayoutOptions_SetIrregularIndexes(option, irregularIndexes, -1), ARKUI_ERROR_CODE_PARAM_INVALID); + + OH_ArkUI_GridLayoutOptions_Dispose(option); + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeNodeNestedScroll + * @tc.desc: Test nestedScroll function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeNestedScroll, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + // set get and reset + ArkUI_NumberValue scrollnested[] = { { .i32 = ARKUI_SCROLL_NESTED_MODE_SELF_FIRST }, + { .i32 = ARKUI_SCROLL_NESTED_MODE_PARENT_FIRST } }; + ArkUI_AttributeItem scrollnestedItem = { scrollnested, sizeof(scrollnested) / sizeof(ArkUI_NumberValue) }; + EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &scrollnestedItem), ARKUI_ERROR_CODE_NO_ERROR); + auto result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL); + EXPECT_EQ(result->value[0].i32, ARKUI_SCROLL_NESTED_MODE_SELF_FIRST); + EXPECT_EQ(result->value[1].i32, ARKUI_SCROLL_NESTED_MODE_PARENT_FIRST); + + EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL); + EXPECT_EQ(result->value[0].i32, ARKUI_SCROLL_NESTED_MODE_SELF_ONLY); + EXPECT_EQ(result->value[1].i32, ARKUI_SCROLL_NESTED_MODE_SELF_ONLY); + // set invalid value + ArkUI_NumberValue invalidScrollnested[] = { { .i32 = -1 }, { .i32 = -1 } }; + ArkUI_AttributeItem invalidScrollnestedItem = { invalidScrollnested, + sizeof(invalidScrollnested) / sizeof(ArkUI_NumberValue) }; + EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &invalidScrollnestedItem), + ARKUI_ERROR_CODE_PARAM_INVALID); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL); + EXPECT_EQ(result->value[0].i32, ARKUI_SCROLL_NESTED_MODE_SELF_ONLY); + EXPECT_EQ(result->value[1].i32, ARKUI_SCROLL_NESTED_MODE_SELF_ONLY); + + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeNodeScrollBar + * @tc.desc: Test scrollbar function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeScrollBar, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + //set get and reset + ArkUI_NumberValue value[] = {{ .i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_ON }}; + ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"}; + nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item); + auto result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE); + EXPECT_EQ(result->value[0].i32, ARKUI_SCROLL_BAR_DISPLAY_MODE_ON); + + value[0].i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_OFF; + EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item), ARKUI_ERROR_CODE_NO_ERROR); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE); + EXPECT_EQ(result->value[0].i32, ARKUI_SCROLL_BAR_DISPLAY_MODE_OFF); + + EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), ARKUI_ERROR_CODE_NO_ERROR); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE); + EXPECT_EQ(result->value[0].i32, ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO); + + // set invalid value + value[0].i32 = -1; + EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item), ARKUI_ERROR_CODE_PARAM_INVALID); + result = nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE); + EXPECT_EQ(result->value[0].i32, ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO); + + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeNodeScrollBarColor + * @tc.desc: Test scrollBarColor function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeScrollBarColor, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + //set and get + ArkUI_NumberValue value[] = {{ .u32 = 0xFFFF0000 }}; + ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"}; + EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item), ARKUI_ERROR_CODE_NO_ERROR); + EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_COLOR), nullptr); + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeNodeScrollBarWidth + * @tc.desc: Test scrollBarWidth function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeScrollBarWidth, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + //set get and reset + ArkUI_NumberValue value[] = {{ .f32 = 1.0f }}; + ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"}; + nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item); + EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), nullptr); + + // set invalid value + value[0] = { .f32 = -1.0f }; + EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item), ERROR_CODE_PARAM_INVALID); + EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), nullptr); + + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeNodeGridltemOptions + * @tc.desc: Test gridltemOptions function. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridltemOptions, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID); + ASSERT_NE(rootNode, nullptr); + + //set get and reset + ArkUI_NumberValue value[] = {{ .i32 = GRID_ITEM_STYLE_PLAIN }}; + ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"}; + nodeAPI->setAttribute(rootNode, NODE_GRID_ITEM_STYLE, &item); + auto result = nodeAPI->getAttribute(rootNode, NODE_GRID_ITEM_STYLE); + EXPECT_EQ(result->value[0].i32, GRID_ITEM_STYLE_PLAIN); + + EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_ITEM_STYLE), ARKUI_ERROR_CODE_NO_ERROR); + result = nodeAPI->getAttribute(rootNode, NODE_GRID_ITEM_STYLE); + EXPECT_EQ(result->value[0].i32, GRID_ITEM_STYLE_NONE); + + // set invalid value + value[0].i32 = -1.0f; + nodeAPI->setAttribute(rootNode, NODE_GRID_ITEM_STYLE, &item); + result = nodeAPI->getAttribute(rootNode, NODE_GRID_ITEM_STYLE); + EXPECT_EQ(result->value[0].i32, GRID_ITEM_STYLE_NONE); + + nodeAPI->disposeNode(rootNode); +} + +/** + * @tc.name: NativeNodeGridOnScrollBarUpdate + * @tc.desc: Test Grid onScrollBarUpdate event. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridOnScrollBarUpdate, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto scroll = nodeAPI->createNode(ARKUI_NODE_GRID); + + auto ret = nodeAPI->registerNodeEvent(scroll, NODE_GRID_ON_SCROLL_BAR_UPDATE, 1, nullptr); + EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); + nodeAPI->unregisterNodeEvent(scroll, NODE_GRID_ON_SCROLL_BAR_UPDATE); + nodeAPI->disposeNode(scroll); +} + +/** + * @tc.name: NativeNodeGridOnScrollFrameBegin + * @tc.desc: Test Grid onScrollFrameBegin event. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridOnScrollFrameBegin, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto scroll = nodeAPI->createNode(ARKUI_NODE_GRID); + + auto ret = nodeAPI->registerNodeEvent(scroll, NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN, 1, nullptr); + EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); + nodeAPI->unregisterNodeEvent(scroll, NODE_SCROLL_EVENT_ON_SCROLL_FRAME_BEGIN); + nodeAPI->disposeNode(scroll); +} + +/** + * @tc.name: NativeNodeGridOnScrollindex + * @tc.desc: Test Grid onScrollindex event. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridOnScrollindex, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto scroll = nodeAPI->createNode(ARKUI_NODE_GRID); + + auto ret = nodeAPI->registerNodeEvent(scroll, NODE_GRID_ON_SCROLL_INDEX, 1, nullptr); + EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); + nodeAPI->unregisterNodeEvent(scroll, NODE_GRID_ON_SCROLL_INDEX); + nodeAPI->disposeNode(scroll); +} + +/** + * @tc.name: NativeNodeGridOnScrollStart + * @tc.desc: Test Grid onScrollStart event. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridOnScrollStart, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto scroll = nodeAPI->createNode(ARKUI_NODE_GRID); + + auto ret = nodeAPI->registerNodeEvent(scroll, NODE_SCROLL_EVENT_ON_SCROLL_START, 1, nullptr); + EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); + nodeAPI->unregisterNodeEvent(scroll, NODE_SCROLL_EVENT_ON_SCROLL_START); + nodeAPI->disposeNode(scroll); +} + +/** + * @tc.name: NativeNodeGridOnScrollStop + * @tc.desc: Test Grid onScrollStop event. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridOnScrollStop, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto scroll = nodeAPI->createNode(ARKUI_NODE_GRID); + + auto ret = nodeAPI->registerNodeEvent(scroll, NODE_SCROLL_EVENT_ON_SCROLL_STOP, 1, nullptr); + EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); + nodeAPI->unregisterNodeEvent(scroll, NODE_SCROLL_EVENT_ON_SCROLL_STOP); + nodeAPI->disposeNode(scroll); +} + +/** + * @tc.name: NativeNodeGridOnWillScroll + * @tc.desc: Test Grid onWillScroll event. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridOnWillScroll, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto scroll = nodeAPI->createNode(ARKUI_NODE_GRID); + + auto ret = nodeAPI->registerNodeEvent(scroll, NODE_GRID_ON_WILL_SCROLL, 1, nullptr); + EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); + nodeAPI->unregisterNodeEvent(scroll, NODE_GRID_ON_WILL_SCROLL); + nodeAPI->disposeNode(scroll); +} + +/** + * @tc.name: NativeNodeGridOnDidScroll + * @tc.desc: Test Grid onDidScroll event. + * @tc.type: FUNC + */ +HWTEST_F(NativeNodeTest, NativeNodeGridOnDidScroll, TestSize.Level1) +{ + auto nodeAPI = reinterpret_cast( + OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); + auto scroll = nodeAPI->createNode(ARKUI_NODE_GRID); + + auto ret = nodeAPI->registerNodeEvent(scroll, NODE_GRID_ON_DID_SCROLL, 1, nullptr); + EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); + nodeAPI->unregisterNodeEvent(scroll, NODE_GRID_ON_DID_SCROLL); + nodeAPI->disposeNode(scroll); } } // namespace OHOS::Ace -- Gitee From c5280d33a4dc348d300188de0171e819c1855704 Mon Sep 17 00:00:00 2001 From: zhanghang Date: Mon, 1 Sep 2025 14:36:05 +0800 Subject: [PATCH 2/3] =?UTF-8?q?=E6=B7=BB=E5=8A=A0capi=20middle?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhanghang --- .../pattern/grid/grid_item_model_ng.cpp | 16 ++++ .../pattern/grid/grid_item_model_ng.h | 2 + .../pattern/grid/grid_model_ng.cpp | 24 +++++ .../pattern/grid/grid_model_ng.h | 3 + .../native/node/grid_item_modifier.cpp | 32 +++++++ .../native/node/grid_item_modifier.h | 2 + .../interfaces/native/node/grid_modifier.cpp | 92 +++++++++++++++++++ interfaces/native/native_node.h | 23 +++++ interfaces/native/node/style_modifier.cpp | 84 +++++++++++++++++ 9 files changed, 278 insertions(+) diff --git a/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.cpp b/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.cpp index 72a0e3d565b..e51f65d6a8b 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.cpp +++ b/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.cpp @@ -154,6 +154,14 @@ void GridItemModelNG::SetSelectable(FrameNode* frameNode, bool selectable) pattern->SetSelectable(selectable); } +bool GridItemModelNG::GetSelectable(FrameNode* frameNode) +{ + CHECK_NULL_RETURN(frameNode, false); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_RETURN(pattern, false); + return pattern->Selectable(); +} + void GridItemModelNG::SetSelected(FrameNode* frameNode, bool selected) { CHECK_NULL_VOID(frameNode); @@ -165,6 +173,14 @@ void GridItemModelNG::SetSelected(FrameNode* frameNode, bool selected) eventHub->SetCurrentUIState(UI_STATE_SELECTED, selected); } +bool GridItemModelNG::GetSelected(FrameNode* frameNode) +{ + CHECK_NULL_RETURN(frameNode, false); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_RETURN(pattern, false); + return pattern->IsSelected(); +} + void GridItemModelNG::SetRowStart(FrameNode* frameNode, int32_t rowStart) { ACE_UPDATE_NODE_LAYOUT_PROPERTY(GridItemLayoutProperty, RowStart, rowStart, frameNode); diff --git a/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.h b/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.h index c9ff28053c9..62e2cadc86b 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.h +++ b/frameworks/core/components_ng/pattern/grid/grid_item_model_ng.h @@ -41,7 +41,9 @@ public: static RefPtr CreateGridItem(int32_t nodeId); static void SetForceRebuild(FrameNode* frameNode, bool value); static void SetSelectable(FrameNode* frameNode, bool selectable); + static bool GetSelectable(FrameNode* frameNode); static void SetSelected(FrameNode* frameNode, bool selected); + static bool GetSelected(FrameNode* frameNode); static void SetRowStart(FrameNode* frameNode, int32_t rowStart); static void SetRowEnd(FrameNode* frameNode, int32_t rowEnd); static void SetColumnStart(FrameNode* frameNode, int32_t columnStart); diff --git a/frameworks/core/components_ng/pattern/grid/grid_model_ng.cpp b/frameworks/core/components_ng/pattern/grid/grid_model_ng.cpp index cfdb05ba405..c9b4b2fc538 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_model_ng.cpp +++ b/frameworks/core/components_ng/pattern/grid/grid_model_ng.cpp @@ -531,6 +531,14 @@ void GridModelNG::SetEditable(FrameNode* frameNode, bool editMode) ACE_UPDATE_NODE_LAYOUT_PROPERTY(GridLayoutProperty, Editable, editMode, frameNode); } +bool GridModelNG::GetEditable(FrameNode* frameNode) +{ + bool editMode = false; + CHECK_NULL_RETURN(frameNode, editMode); + ACE_GET_NODE_LAYOUT_PROPERTY_WITH_DEFAULT_VALUE(GridLayoutProperty, Editable, editMode, frameNode, editMode); + return editMode; +} + void GridModelNG::SetMultiSelectable(FrameNode* frameNode, bool multiSelectable) { auto pattern = frameNode->GetPattern(); @@ -538,6 +546,14 @@ void GridModelNG::SetMultiSelectable(FrameNode* frameNode, bool multiSelectable) pattern->SetMultiSelectable(multiSelectable); } +bool GridModelNG::GetMultiSelectable(FrameNode* frameNode) +{ + CHECK_NULL_RETURN(frameNode, false); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_RETURN(pattern, false); + return pattern->MultiSelectable(); +} + void GridModelNG::SetMaxCount(FrameNode* frameNode, int32_t maxCount) { if (maxCount >= 1) { @@ -577,6 +593,14 @@ void GridModelNG::SetSupportAnimation(FrameNode* frameNode, bool supportAnimatio pattern->SetSupportAnimation(supportAnimation); } +bool GridModelNG::GetSupportAnimation(FrameNode* frameNode) +{ + CHECK_NULL_RETURN(frameNode, false); + auto pattern = frameNode->GetPattern(); + CHECK_NULL_RETURN(pattern, false); + return pattern->SupportAnimation(); +} + EdgeEffect GridModelNG::GetEdgeEffect(FrameNode* frameNode) { CHECK_NULL_RETURN(frameNode, EdgeEffect::NONE); diff --git a/frameworks/core/components_ng/pattern/grid/grid_model_ng.h b/frameworks/core/components_ng/pattern/grid/grid_model_ng.h index d5909895698..23f9e15d373 100644 --- a/frameworks/core/components_ng/pattern/grid/grid_model_ng.h +++ b/frameworks/core/components_ng/pattern/grid/grid_model_ng.h @@ -100,8 +100,11 @@ public: static void SetMinCount(FrameNode* frameNode, int32_t minCount); static void SetCellLength(FrameNode* frameNode, int32_t cellLength); static void SetEditable(FrameNode* frameNode, bool editMode); + static bool GetEditable(FrameNode* frameNode); static void SetMultiSelectable(FrameNode* frameNode, bool multiSelectable); + static bool GetMultiSelectable(FrameNode* frameNode); static void SetSupportAnimation(FrameNode* frameNode, bool supportAnimation); + static bool GetSupportAnimation(FrameNode* frameNode); static EdgeEffect GetEdgeEffect(FrameNode* frameNode); static bool GetAlwaysEnabled(FrameNode* frameNode); static void SetEdgeEffect( diff --git a/frameworks/core/interfaces/native/node/grid_item_modifier.cpp b/frameworks/core/interfaces/native/node/grid_item_modifier.cpp index e73d16b45a8..6be5900eaf0 100644 --- a/frameworks/core/interfaces/native/node/grid_item_modifier.cpp +++ b/frameworks/core/interfaces/native/node/grid_item_modifier.cpp @@ -36,6 +36,14 @@ void ResetGridItemSelectable(ArkUINodeHandle node) GridItemModelNG::SetSelectable(frameNode, true); } +ArkUI_Bool GetGridItemSelectable(ArkUINodeHandle node) +{ + CHECK_NULL_RETURN(node, false); + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, false); + return GridItemModelNG::GetSelectable(); +} + void SetGridItemSelected(ArkUINodeHandle node, ArkUI_Bool selected) { auto* frameNode = reinterpret_cast(node); @@ -50,6 +58,14 @@ void ResetGridItemSelected(ArkUINodeHandle node) GridItemModelNG::SetSelected(frameNode, false); } +ArkUI_Bool GetGridItemSelected(ArkUINodeHandle node) +{ + CHECK_NULL_RETURN(node, false); + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, false); + return GridItemModelNG::GetSelected(); +} + void SetGridItemRowStart(ArkUINodeHandle node, int32_t rowStart) { auto* frameNode = reinterpret_cast(node); @@ -152,6 +168,7 @@ const ArkUIGridItemModifier* GetGridItemModifier() static const ArkUIGridItemModifier modifier = { .setGridItemSelectable = SetGridItemSelectable, .resetGridItemSelectable = ResetGridItemSelectable, + .getGridItemSelectable = GetGridItemSelectable, .setGridItemSelected = SetGridItemSelected, .resetGridItemSelected = ResetGridItemSelected, .setGridItemRowStart = SetGridItemRowStart, @@ -192,5 +209,20 @@ const CJUIGridItemModifier* GetCJUIGridItemModifier() CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line return &modifier; } + +void SetGridOnItemSelect(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + auto onEvent = [node, extraParam](bool isSelected) { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GIRD_ITEM_SELECT; + event.componentAsyncEvent.data[0].i32 = isSelected; + SendArkUISyncEvent(&event); + }; + GridItemModelNG::SetOnSelect(frameNode, std::move(onEvent)); +} } } // namespace OHOS::Ace::NG diff --git a/frameworks/core/interfaces/native/node/grid_item_modifier.h b/frameworks/core/interfaces/native/node/grid_item_modifier.h index 8291c47ec4d..be43f5cc2c1 100644 --- a/frameworks/core/interfaces/native/node/grid_item_modifier.h +++ b/frameworks/core/interfaces/native/node/grid_item_modifier.h @@ -20,6 +20,8 @@ namespace OHOS::Ace::NG::NodeModifier { const ArkUIGridItemModifier* GetGridItemModifier(); const CJUIGridItemModifier* GetCJUIGridItemModifier(); + +void SetGridOnItemSelect(ArkUINodeHandle node, void* extraParam); } #endif // FRAMEWORKS_INTERFACE_INNER_API_NATIVE_NODE_GRID_ITEM_MODIFIER_H \ No newline at end of file diff --git a/frameworks/core/interfaces/native/node/grid_modifier.cpp b/frameworks/core/interfaces/native/node/grid_modifier.cpp index 39d99c54ef2..edf9f1dc957 100644 --- a/frameworks/core/interfaces/native/node/grid_modifier.cpp +++ b/frameworks/core/interfaces/native/node/grid_modifier.cpp @@ -727,8 +727,10 @@ const ArkUIGridModifier* GetGridModifier() .getShowCached = GetShowCached, .setGridEditMode = SetGridEditMode, .resetGridEditMode = ResetGridEditMode, + .getGridEditMode = GetGridEditMode, .setGridMultiSelectable = SetGridMultiSelectable, .resetGridMultiSelectable = ResetGridMultiSelectable, + .getGridMultiSelectable = GetGridMultiSelectable, .setGridMaxCount = SetGridMaxCount, .resetGridMaxCount = ResetGridMaxCount, .setGridMinCount = SetGridMinCount, @@ -739,6 +741,7 @@ const ArkUIGridModifier* GetGridModifier() .resetGridLayoutDirection = ResetGridLayoutDirection, .setGridSupportAnimation = SetGridSupportAnimation, .resetGridSupportAnimation = ResetGridSupportAnimation, + .getGridsupportanimation = GetGridSupportAnimation, .setEdgeEffect = SetEdgeEffect, .resetEdgeEffect = ResetEdgeEffect, .setNestedScroll = SetNestedScroll, @@ -822,6 +825,7 @@ const CJUIGridModifier* GetCJUIGridModifier() .resetGridEditMode = ResetGridEditMode, .setGridMultiSelectable = SetGridMultiSelectable, .resetGridMultiSelectable = ResetGridMultiSelectable, + .getGridMultiSelectable = GetGridMultiSelectable, .setGridMaxCount = SetGridMaxCount, .resetGridMaxCount = ResetGridMaxCount, .setGridMinCount = SetGridMinCount, @@ -914,6 +918,23 @@ void ResetOnGridScrollBarUpdate(ArkUINodeHandle node) GridModelNG::SetOnScrollBarUpdate(frameNode, nullptr); } +void SetGridOnItemDragStart(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + auto onEvent = [node, extraParam](const ItemDragInfo& dragInfo, int32_t itemIndex) { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_ITEM_DRAG_START; + event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); + event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); + event.componentAsyncEvent.data[2].i32 = itemIndex; + SendArkUISyncEvent(&event); + }; + GridModelNG::SetOnItemDragStart(frameNode, std::move(onEvent)); +} + void SetOnGridItemDragStart(ArkUINodeHandle node, void* extraParam) { auto* frameNode = reinterpret_cast(node); @@ -933,6 +954,22 @@ void ResetOnGridItemDragStart(ArkUINodeHandle node) GridModelNG::SetOnItemDragStart(frameNode, nullptr); } +void SetGridOnItemDragEnter(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + auto onEvent = [node, extraParam](const ItemDragInfo& dragInfo) { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_ITEM_DRAG_ENTER; + event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); + event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); + SendArkUISyncEvent(&event); + }; + GridModelNG::SetOnItemDragEnter(frameNode, std::move(onEvent)); +} + void SetOnGridItemDragEnter(ArkUINodeHandle node, void* extraParam) { auto* frameNode = reinterpret_cast(node); @@ -952,6 +989,24 @@ void ResetOnGridItemDragEnter(ArkUINodeHandle node) GridModelNG::SetOnItemDragEnter(frameNode, nullptr); } +void SetGridOnItemDragMove(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + auto onEvent = [node, extraParam](const ItemDragInfo& dragInfo, int32_t itemIndex, int32_t insertIndex) { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_ITEM_DRAG_MOVE; + event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); + event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); + event.componentAsyncEvent.data[2].i32 = itemIndex; + event.componentAsyncEvent.data[3].i32 = insertIndex; + SendArkUISyncEvent(&event); + }; + GridModelNG::SetOnItemDragMove(frameNode, std::move(onEvent)); +} + void SetOnGridItemDragMove(ArkUINodeHandle node, void* extraParam) { auto* frameNode = reinterpret_cast(node); @@ -971,6 +1026,23 @@ void ResetOnGridItemDragMove(ArkUINodeHandle node) GridModelNG::SetOnItemDragMove(frameNode, nullptr); } +void SetGridOnItemDragLeave(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + auto onEvent = [node, extraParam](const ItemDragInfo& dragInfo, int32_t itemIndex) { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_ITEM_DRAG_MOVE; + event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); + event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); + event.componentAsyncEvent.data[2].i32 = itemIndex; + SendArkUISyncEvent(&event); + }; + GridModelNG::SetOnItemDragLeave(frameNode, std::move(onEvent)); +} + void SetOnGridItemDragLeave(ArkUINodeHandle node, void* extraParam) { auto* frameNode = reinterpret_cast(node); @@ -990,6 +1062,26 @@ void ResetOnGridItemDragLeave(ArkUINodeHandle node) GridModelNG::SetOnItemDragLeave(frameNode, nullptr); } +void SetGridOnItemDrop(ArkUINodeHandle node, void* extraParam) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_VOID(frameNode); + auto onEvent = [node, extraParam]( + const ItemDragInfo& dragInfo, int32_t itemIndex, int32_t insertIndex, bool isSuccess) { + ArkUINodeEvent event; + event.kind = COMPONENT_ASYNC_EVENT; + event.extraParam = reinterpret_cast(extraParam); + event.componentAsyncEvent.subKind = ON_GRID_ITEM_DROP; + event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); + event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); + event.componentAsyncEvent.data[2].i32 = itemIndex; + event.componentAsyncEvent.data[3].i32 = insertIndex; + event.componentAsyncEvent.data[4].i32 = isSuccess; + SendArkUISyncEvent(&event); + }; + GridModelNG::SetOnItemDrop(frameNode, std::move(onEvent)); +} + void SetOnGridItemDrop(ArkUINodeHandle node, void* extraParam) { auto* frameNode = reinterpret_cast(node); diff --git a/interfaces/native/native_node.h b/interfaces/native/native_node.h index 73d2754c597..c6ef9bdc6d2 100644 --- a/interfaces/native/native_node.h +++ b/interfaces/native/native_node.h @@ -6780,6 +6780,26 @@ typedef enum { */ NODE_GRID_LAYOUT_OPTIONS = 1013009, + NODE_GRID_EDIT_MODE = 1013010, + + NODE_GRID_MULTI_SELECTABLE = 1013011, + + NODE_GRID_ON_ITEM_DRAG_ENTER = 1013012, + + NODE_GRID_ON_ITEM_DRAG_LEAVE = 1013013, + + NODE_GRID_ON_ITEM_DRAG_MOVE = 1013014, + + NODE_GRID_ON_ITEM_DRAG_START = 1013015, + + NODE_GRID_ON_ITEM_DRAG_DROP = 1013016, + + NODE_GRID_SUPPORT_ANIMATION = 1013017, + + NODE_GRID_SELECTABLE = 1013018, + + NODE_GRID_SELECTED = 1013019, + /** * @brief 设置GridItem样式，支持属性设置、重置和获取。 * @@ -6792,6 +6812,9 @@ typedef enum { * @since 21 */ NODE_GRID_ITEM_STYLE = MAX_NODE_SCOPE_NUM * ARKUI_NODE_GRID_ITEM, + + NODE_GRID_ON_SELECT, + /** * @brief Defines the column width of the text picker. * This attribute can be set, reset, and obtained as required through APIs. diff --git a/interfaces/native/node/style_modifier.cpp b/interfaces/native/node/style_modifier.cpp index 813bb3842d6..48f30aefbc2 100644 --- a/interfaces/native/node/style_modifier.cpp +++ b/interfaces/native/node/style_modifier.cpp @@ -16213,6 +16213,90 @@ const ArkUI_AttributeItem* GetGridLayoutOptions(ArkUI_NodeHandle node) return &g_attributeItem; } +int32_t SetGridEditMode(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) +{ + ArkUI_Bool editMode = false; + if (item == nullptr || item->size < NUM_1 || !InRegion(NUM_0, NUM_1, item->value[NUM_0].i32)) { + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridEditMode(node->uiNodeHandle, editMode); + return ERROR_CODE_PARAM_INVALID; + } else { + editMode = item->value[0].i32; + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridEditMode(node->uiNodeHandle, editMode); + return ERROR_CODE_NO_ERROR; + } +} + +void ResetGridEditMode(ArkUI_NodeHandle node) +{ + auto* fullImpl = GetFullImpl(); + fullImpl->getNodeModifiers()->getGridModifier()->resetGridEditMode(node->uiNodeHandle); +} + +const ArkUI_AttributeItem* GetGridEditMode(ArkUI_NodeHandle node) +{ + ArkUI_Bool value = GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridEditMode(node->uiNodeHandle); + g_numberValues[0].i32 = value; + return &g_attributeItem; +} + +int32_t SetGridMultiSelectable(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) +{ + ArkUI_Bool multiSelectable = false; + if (item == nullptr || item->size < NUM_1 || !InRegion(NUM_0, NUM_1, item->value[NUM_0].i32)) { + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridMultiSelectable( + node->uiNodeHandle, multiSelectable); + return ERROR_CODE_PARAM_INVALID; + } else { + multiSelectable = item->value[0].i32; + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridMultiSelectable( + node->uiNodeHandle, multiSelectable); + return ERROR_CODE_NO_ERROR; + } +} + +void ResetGridMultiSelectable(ArkUI_NodeHandle node) +{ + auto* fullImpl = GetFullImpl(); + fullImpl->getNodeModifiers()->getGridModifier()->resetGridMultiSelectable(node->uiNodeHandle); +} + +const ArkUI_AttributeItem* GetGridMultiSelectable(ArkUI_NodeHandle node) +{ + ArkUI_Int32 value = + GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridMultiSelectable(node->uiNodeHandle); + g_numberValues[0].i32 = value; + return &g_attributeItem; +} + +int32_t SetGridSupportAnimation(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) +{ + ArkUI_Bool supportAnimation = false; + if (item == nullptr || item->size < NUM_1 || !InRegion(NUM_0, NUM_1, item->value[NUM_0].i32)) { + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridSupportAnimation( + node->uiNodeHandle, supportAnimation); + return ERROR_CODE_PARAM_INVALID; + } else { + supportAnimation = item->value[0].i32; + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridSupportAnimation( + node->uiNodeHandle, supportAnimation); + return ERROR_CODE_NO_ERROR; + } +} + +void ResetGridSupportAnimation(ArkUI_NodeHandle node) +{ + auto* fullImpl = GetFullImpl(); + fullImpl->getNodeModifiers()->getGridModifier()->resetGridSupportAnimation(node->uiNodeHandle); +} + +const ArkUI_AttributeItem* GetGridSupportAnimation(ArkUI_NodeHandle node) +{ + ArkUI_Int32 value = + GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridSupportAnimation(node->uiNodeHandle); + g_numberValues[0].i32 = value; + return &g_attributeItem; +} + int32_t SetGridItemOptions(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) { ArkUI_Int32 alignment = GRID_ITEM_STYLE_NONE; -- Gitee From e0952444f68d07f107a18a7084d5409bb0f21be9 Mon Sep 17 00:00:00 2001 From: zhanghang Date: Thu, 4 Sep 2025 10:22:21 +0800 Subject: [PATCH 3/3] middle Signed-off-by: zhanghang Change-Id: I19897dc0255b482d876e2c728fdfe65bd4083127 --- .../src/generated/legacy/arkoala_api_legacy.h | 2 + .../core/interfaces/arkoala/arkoala_api.h | 11 ++ .../native/node/grid_item_modifier.cpp | 6 +- .../interfaces/native/node/grid_modifier.cpp | 32 +++++- interfaces/native/node/style_modifier.cpp | 104 ++++++++++++++---- 5 files changed, 127 insertions(+), 28 deletions(-) diff --git a/frameworks/bridge/arkts_frontend/koala_projects/arkoala/framework/native/src/generated/legacy/arkoala_api_legacy.h b/frameworks/bridge/arkts_frontend/koala_projects/arkoala/framework/native/src/generated/legacy/arkoala_api_legacy.h index 4cf1b0c8134..1dd541424be 100644 --- a/frameworks/bridge/arkts_frontend/koala_projects/arkoala/framework/native/src/generated/legacy/arkoala_api_legacy.h +++ b/frameworks/bridge/arkts_frontend/koala_projects/arkoala/framework/native/src/generated/legacy/arkoala_api_legacy.h @@ -1962,8 +1962,10 @@ struct ArkUIGridModifier { void (*resetGridCachedCount)(ArkUINodeHandle node); void (*setGridEditMode)(ArkUINodeHandle node, ArkUI_Bool editMode); void (*resetGridEditMode)(ArkUINodeHandle node); + ArkUI_Bool (*getGridEditMode)(ArkUINodeHandle node); void (*setGridMultiSelectable)(ArkUINodeHandle node, ArkUI_Bool multiSelectable); void (*resetGridMultiSelectable)(ArkUINodeHandle node); + ArkUI_Bool (*getGridMultiSelectable)(ArkUINodeHandle node); void (*setGridMaxCount)(ArkUINodeHandle node, ArkUI_Int32 maxCount); void (*resetGridMaxCount)(ArkUINodeHandle node); void (*setGridMinCount)(ArkUINodeHandle node, ArkUI_Int32 minCount); diff --git a/frameworks/core/interfaces/arkoala/arkoala_api.h b/frameworks/core/interfaces/arkoala/arkoala_api.h index 12f9b3bbdf8..019d52a630f 100644 --- a/frameworks/core/interfaces/arkoala/arkoala_api.h +++ b/frameworks/core/interfaces/arkoala/arkoala_api.h @@ -1294,6 +1294,12 @@ enum ArkUIEventSubKind { ON_GRID_DID_SCROLL, ON_GRID_WILL_STOP_DRAGGING, ON_GRID_SCROLL_BAR_UPDATE, + ON_GRID_DRAG_ITEM_ENTER, + ON_GRID_DRAG_ITEM_LEAVE, + ON_GRID_DRAG_ITEM_MOVE, + ON_GRID_DRAG_ITEM_START, + ON_GRID_ITEM_DROP, + ON_GIRD_ITEM_SELECT = ARKUI_MAX_EVENT_NUM * ARKUI_GRID_ITEM, ON_SIDEBAR_CHANGE = ARKUI_MAX_EVENT_NUM * ARKUI_SIDEBAR, @@ -3841,8 +3847,10 @@ struct ArkUIGridModifier { ArkUI_Bool (*getShowCached)(ArkUINodeHandle node); void (*setGridEditMode)(ArkUINodeHandle node, ArkUI_Bool editMode); void (*resetGridEditMode)(ArkUINodeHandle node); + ArkUI_Bool (*getGridEditMode)(ArkUINodeHandle node); void (*setGridMultiSelectable)(ArkUINodeHandle node, ArkUI_Bool multiSelectable); void (*resetGridMultiSelectable)(ArkUINodeHandle node); + ArkUI_Bool (*getGridMultiSelectable)(ArkUINodeHandle node); void (*setGridMaxCount)(ArkUINodeHandle node, ArkUI_Int32 maxCount); void (*resetGridMaxCount)(ArkUINodeHandle node); void (*setGridMinCount)(ArkUINodeHandle node, ArkUI_Int32 minCount); @@ -3853,6 +3861,7 @@ struct ArkUIGridModifier { void (*resetGridLayoutDirection)(ArkUINodeHandle node); void (*setGridSupportAnimation)(ArkUINodeHandle node, ArkUI_Bool supportAnimation); void (*resetGridSupportAnimation)(ArkUINodeHandle node); + ArkUI_Bool (*getGridSupportAnimation)(ArkUINodeHandle node); void (*setEdgeEffect)( ArkUINodeHandle node, ArkUI_Int32 edgeEffect, ArkUI_Bool alwaysEnabled, ArkUI_Int32 effectEdge); @@ -3917,8 +3926,10 @@ struct ArkUIGridModifier { struct ArkUIGridItemModifier { void (*setGridItemSelectable)(ArkUINodeHandle node, ArkUI_Bool selectable); void (*resetGridItemSelectable)(ArkUINodeHandle node); + ArkUI_Bool (*getGridItemSelectable)(ArkUINodeHandle node); void (*setGridItemSelected)(ArkUINodeHandle node, ArkUI_Bool selected); void (*resetGridItemSelected)(ArkUINodeHandle node); + ArkUI_Bool (*getGridItemSelected)(ArkUINodeHandle node); void (*setGridItemRowStart)(ArkUINodeHandle node, ArkUI_Int32 rowStart); void (*resetGridItemRowStart)(ArkUINodeHandle node); void (*setGridItemRowEnd)(ArkUINodeHandle node, ArkUI_Int32 rowEnd); diff --git a/frameworks/core/interfaces/native/node/grid_item_modifier.cpp b/frameworks/core/interfaces/native/node/grid_item_modifier.cpp index 6be5900eaf0..5641cc8104a 100644 --- a/frameworks/core/interfaces/native/node/grid_item_modifier.cpp +++ b/frameworks/core/interfaces/native/node/grid_item_modifier.cpp @@ -41,7 +41,7 @@ ArkUI_Bool GetGridItemSelectable(ArkUINodeHandle node) CHECK_NULL_RETURN(node, false); auto* frameNode = reinterpret_cast(node); CHECK_NULL_RETURN(frameNode, false); - return GridItemModelNG::GetSelectable(); + return GridItemModelNG::GetSelectable(frameNode); } void SetGridItemSelected(ArkUINodeHandle node, ArkUI_Bool selected) @@ -63,7 +63,7 @@ ArkUI_Bool GetGridItemSelected(ArkUINodeHandle node) CHECK_NULL_RETURN(node, false); auto* frameNode = reinterpret_cast(node); CHECK_NULL_RETURN(frameNode, false); - return GridItemModelNG::GetSelected(); + return GridItemModelNG::GetSelected(frameNode); } void SetGridItemRowStart(ArkUINodeHandle node, int32_t rowStart) @@ -161,6 +161,7 @@ void ResetGridItemOnSelect(ArkUINodeHandle node) CHECK_NULL_VOID(frameNode); GridItemModelNG::SetOnSelect(frameNode, nullptr); } + namespace NodeModifier { const ArkUIGridItemModifier* GetGridItemModifier() { @@ -171,6 +172,7 @@ const ArkUIGridItemModifier* GetGridItemModifier() .getGridItemSelectable = GetGridItemSelectable, .setGridItemSelected = SetGridItemSelected, .resetGridItemSelected = ResetGridItemSelected, + .getGridItemSelected = GetGridItemSelected, .setGridItemRowStart = SetGridItemRowStart, .resetGridItemRowStart = ResetGridItemRowStart, .setGridItemRowEnd = SetGridItemRowEnd, diff --git a/frameworks/core/interfaces/native/node/grid_modifier.cpp b/frameworks/core/interfaces/native/node/grid_modifier.cpp index edf9f1dc957..35cd7f54e11 100644 --- a/frameworks/core/interfaces/native/node/grid_modifier.cpp +++ b/frameworks/core/interfaces/native/node/grid_modifier.cpp @@ -214,6 +214,13 @@ void ResetGridEditMode(ArkUINodeHandle node) GridModelNG::SetEditable(frameNode, DEFAULT_EDIT_MODE); } +ArkUI_Bool GetGridEditMode(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, 0); + return GridModelNG::GetEditable(frameNode); +} + void SetGridMultiSelectable(ArkUINodeHandle node, ArkUI_Bool multiSelectable) { auto* frameNode = reinterpret_cast(node); @@ -228,6 +235,13 @@ void ResetGridMultiSelectable(ArkUINodeHandle node) GridModelNG::SetMultiSelectable(frameNode, DEFAULT_MULTI_SELECTABLE); } +ArkUI_Bool GetGridMultiSelectable(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, 0); + return GridModelNG::GetMultiSelectable(frameNode); +} + void SetGridMaxCount(ArkUINodeHandle node, int32_t maxCount) { auto* frameNode = reinterpret_cast(node); @@ -299,6 +313,13 @@ void ResetGridSupportAnimation(ArkUINodeHandle node) GridModelNG::SetSupportAnimation(frameNode, DEFAULT_SUPPORT_ANIMATION); } +ArkUI_Bool GetGridSupportAnimation(ArkUINodeHandle node) +{ + auto* frameNode = reinterpret_cast(node); + CHECK_NULL_RETURN(frameNode, 0); + return GridModelNG::GetSupportAnimation(frameNode); +} + void SetEdgeEffect(ArkUINodeHandle node, int32_t edgeEffect, ArkUI_Bool alwaysEnabled, ArkUI_Int32 edge) { auto* frameNode = reinterpret_cast(node); @@ -741,7 +762,7 @@ const ArkUIGridModifier* GetGridModifier() .resetGridLayoutDirection = ResetGridLayoutDirection, .setGridSupportAnimation = SetGridSupportAnimation, .resetGridSupportAnimation = ResetGridSupportAnimation, - .getGridsupportanimation = GetGridSupportAnimation, + .getGridSupportAnimation = GetGridSupportAnimation, .setEdgeEffect = SetEdgeEffect, .resetEdgeEffect = ResetEdgeEffect, .setNestedScroll = SetNestedScroll, @@ -825,7 +846,6 @@ const CJUIGridModifier* GetCJUIGridModifier() .resetGridEditMode = ResetGridEditMode, .setGridMultiSelectable = SetGridMultiSelectable, .resetGridMultiSelectable = ResetGridMultiSelectable, - .getGridMultiSelectable = GetGridMultiSelectable, .setGridMaxCount = SetGridMaxCount, .resetGridMaxCount = ResetGridMaxCount, .setGridMinCount = SetGridMinCount, @@ -926,7 +946,7 @@ void SetGridOnItemDragStart(ArkUINodeHandle node, void* extraParam) ArkUINodeEvent event; event.kind = COMPONENT_ASYNC_EVENT; event.extraParam = reinterpret_cast(extraParam); - event.componentAsyncEvent.subKind = ON_GRID_ITEM_DRAG_START; + event.componentAsyncEvent.subKind = ON_GRID_DRAG_ITEM_START; event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); event.componentAsyncEvent.data[2].i32 = itemIndex; @@ -962,7 +982,7 @@ void SetGridOnItemDragEnter(ArkUINodeHandle node, void* extraParam) ArkUINodeEvent event; event.kind = COMPONENT_ASYNC_EVENT; event.extraParam = reinterpret_cast(extraParam); - event.componentAsyncEvent.subKind = ON_GRID_ITEM_DRAG_ENTER; + event.componentAsyncEvent.subKind = ON_GRID_DRAG_ITEM_ENTER; event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); SendArkUISyncEvent(&event); @@ -997,7 +1017,7 @@ void SetGridOnItemDragMove(ArkUINodeHandle node, void* extraParam) ArkUINodeEvent event; event.kind = COMPONENT_ASYNC_EVENT; event.extraParam = reinterpret_cast(extraParam); - event.componentAsyncEvent.subKind = ON_GRID_ITEM_DRAG_MOVE; + event.componentAsyncEvent.subKind = ON_GRID_DRAG_ITEM_MOVE; event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); event.componentAsyncEvent.data[2].i32 = itemIndex; @@ -1034,7 +1054,7 @@ void SetGridOnItemDragLeave(ArkUINodeHandle node, void* extraParam) ArkUINodeEvent event; event.kind = COMPONENT_ASYNC_EVENT; event.extraParam = reinterpret_cast(extraParam); - event.componentAsyncEvent.subKind = ON_GRID_ITEM_DRAG_MOVE; + event.componentAsyncEvent.subKind = ON_GRID_DRAG_ITEM_MOVE; event.componentAsyncEvent.data[0].i32 = dragInfo.GetX(); event.componentAsyncEvent.data[1].i32 = dragInfo.GetY(); event.componentAsyncEvent.data[2].i32 = itemIndex; diff --git a/interfaces/native/node/style_modifier.cpp b/interfaces/native/node/style_modifier.cpp index 48f30aefbc2..dae271f0d5b 100644 --- a/interfaces/native/node/style_modifier.cpp +++ b/interfaces/native/node/style_modifier.cpp @@ -16215,15 +16215,16 @@ const ArkUI_AttributeItem* GetGridLayoutOptions(ArkUI_NodeHandle node) int32_t SetGridEditMode(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) { - ArkUI_Bool editMode = false; - if (item == nullptr || item->size < NUM_1 || !InRegion(NUM_0, NUM_1, item->value[NUM_0].i32)) { - GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridEditMode(node->uiNodeHandle, editMode); + CHECK_NULL_RETURN(item, ERROR_CODE_PARAM_INVALID); + if (item->size < NUM_1) { return ERROR_CODE_PARAM_INVALID; - } else { + } + ArkUI_Bool editMode = DEFAULT_FALSE; + if (InRegion(DEFAULT_FALSE, DEFAULT_TRUE, item->value[0].i32)) { editMode = item->value[0].i32; - GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridEditMode(node->uiNodeHandle, editMode); - return ERROR_CODE_NO_ERROR; } + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridEditMode(node->uiNodeHandle, editMode); + return ERROR_CODE_NO_ERROR; } void ResetGridEditMode(ArkUI_NodeHandle node) @@ -16236,22 +16237,23 @@ const ArkUI_AttributeItem* GetGridEditMode(ArkUI_NodeHandle node) { ArkUI_Bool value = GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridEditMode(node->uiNodeHandle); g_numberValues[0].i32 = value; + g_attributeItem.size = 1; return &g_attributeItem; } int32_t SetGridMultiSelectable(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) { - ArkUI_Bool multiSelectable = false; - if (item == nullptr || item->size < NUM_1 || !InRegion(NUM_0, NUM_1, item->value[NUM_0].i32)) { - GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridMultiSelectable( - node->uiNodeHandle, multiSelectable); + CHECK_NULL_RETURN(item, ERROR_CODE_PARAM_INVALID); + if (item->size < NUM_1) { return ERROR_CODE_PARAM_INVALID; - } else { + } + + ArkUI_Bool multiSelectable = DEFAULT_FALSE; + if (InRegion(DEFAULT_FALSE, DEFAULT_TRUE, item->value[0].i32)) { multiSelectable = item->value[0].i32; - GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridMultiSelectable( - node->uiNodeHandle, multiSelectable); - return ERROR_CODE_NO_ERROR; } + GetFullImpl()->getNodeModifiers()->getGridModifier()->setGridMultiSelectable(node->uiNodeHandle, multiSelectable); + return ERROR_CODE_NO_ERROR; } void ResetGridMultiSelectable(ArkUI_NodeHandle node) @@ -16265,6 +16267,7 @@ const ArkUI_AttributeItem* GetGridMultiSelectable(ArkUI_NodeHandle node) ArkUI_Int32 value = GetFullImpl()->getNodeModifiers()->getGridModifier()->getGridMultiSelectable(node->uiNodeHandle); g_numberValues[0].i32 = value; + g_attributeItem.size = RETURN_SIZE_ONE; return &g_attributeItem; } @@ -16323,6 +16326,65 @@ const ArkUI_AttributeItem* GetGridItemOptions(ArkUI_NodeHandle node) return &g_attributeItem; } +int32_t SetGridItemSelectable(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) +{ + CHECK_NULL_RETURN(item, ERROR_CODE_PARAM_INVALID); + if (item->size < NUM_1) { + return ERROR_CODE_PARAM_INVALID; + } + + ArkUI_Bool selectable = DEFAULT_TRUE; + if (InRegion(DEFAULT_FALSE, DEFAULT_TRUE, item->value[0].i32)) { + selectable = item->value[0].i32; + } + GetFullImpl()->getNodeModifiers()->getGridItemModifier()->setGridItemSelectable(node->uiNodeHandle, selectable); + return ERROR_CODE_NO_ERROR; +} + +void ResetGridItemSelectable(ArkUI_NodeHandle node) +{ + auto* fullImpl = GetFullImpl(); + fullImpl->getNodeModifiers()->getGridItemModifier()->resetGridItemSelectable(node->uiNodeHandle); +} + +const ArkUI_AttributeItem* GetGridItemSelectable(ArkUI_NodeHandle node) +{ + ArkUI_Bool selectable = GetFullImpl()->getNodeModifiers()->getGridItemModifier()->getGridItemSelectable(node->uiNodeHandle); + g_numberValues[0].i32 = selectable; + g_attributeItem.size = RETURN_SIZE_ONE; + return &g_attributeItem; +} + +// +int32_t SetGridItemSelected(ArkUI_NodeHandle node, const ArkUI_AttributeItem* item) +{ + CHECK_NULL_RETURN(item, ERROR_CODE_PARAM_INVALID); + if (item->size < NUM_1) { + return ERROR_CODE_PARAM_INVALID; + } + + ArkUI_Bool selected = DEFAULT_FALSE; + if (InRegion(DEFAULT_FALSE, DEFAULT_TRUE, item->value[0].i32)) { + selected = item->value[0].i32; + } + GetFullImpl()->getNodeModifiers()->getGridItemModifier()->setGridItemSelected(node->uiNodeHandle, selected); + return ERROR_CODE_NO_ERROR; +} + +void ResetGridItemSelected(ArkUI_NodeHandle node) +{ + auto* fullImpl = GetFullImpl(); + fullImpl->getNodeModifiers()->getGridItemModifier()->resetGridItemSelected(node->uiNodeHandle); +} + +const ArkUI_AttributeItem* GetGridItemSelected(ArkUI_NodeHandle node) +{ + ArkUI_Bool selected = GetFullImpl()->getNodeModifiers()->getGridItemModifier()->getGridItemSelected(node->uiNodeHandle); + g_numberValues[0].i32 = selected; + g_attributeItem.size = RETURN_SIZE_ONE; + return &g_attributeItem; +} + bool CheckIfAttributeLegal(ArkUI_NodeHandle node, int32_t type) { if (node->type == ARKUI_NODE_SPAN) { @@ -17995,7 +18057,7 @@ int32_t SetRelativeContainerAttribute(ArkUI_NodeHandle node, int32_t subTypeId, int32_t SetGridItemAttribute(ArkUI_NodeHandle node, int32_t subTypeId, const ArkUI_AttributeItem* item) { - static Setter* setters[] = { SetGridItemOptions }; + static Setter* setters[] = { SetGridItemOptions, SetGridItemSelectable, SetGridItemSelected }; if (static_cast(subTypeId) >= sizeof(setters) / sizeof(Setter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "GridItem node attribute: %{public}d NOT IMPLEMENT", subTypeId); return ERROR_CODE_NATIVE_IMPL_TYPE_NOT_SUPPORTED; @@ -18007,7 +18069,8 @@ int32_t SetGridAttribute(ArkUI_NodeHandle node, int32_t subTypeId, const ArkUI_A { static Setter* setters[] = { SetGridColumnsTemplate, SetGridRowsTemplate, SetGridColumnsGap, SetGridRowsGap, SetGridNodeAdapter, SetGridCachedCount, SetGridFocusWrapMode, SetGridSyncLoad, SetGridAlignItems, - SetGridLayoutOptions }; + SetGridLayoutOptions, SetGridEditMode, SetGridMultiSelectable, SetGridSupportAnimation + }; if (static_cast(subTypeId) >= sizeof(setters) / sizeof(Setter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Grid node attribute: %{public}d NOT IMPLEMENT", subTypeId); return ERROR_CODE_NATIVE_IMPL_TYPE_NOT_SUPPORTED; @@ -18027,7 +18090,7 @@ void ResetRelativeContainerAttribute(ArkUI_NodeHandle node, int32_t subTypeId) void ResetGridItemAttribute(ArkUI_NodeHandle node, int32_t subTypeId) { - static Resetter* resetters[] = { ResetGridItemOptions }; + static Resetter* resetters[] = { ResetGridItemOptions, ResetGridItemSelectable, ResetGridItemSelected }; if (static_cast(subTypeId) >= sizeof(resetters) / sizeof(Resetter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "GridItem node attribute: %{public}d NOT IMPLEMENT", subTypeId); return; @@ -18039,7 +18102,8 @@ void ResetGridAttribute(ArkUI_NodeHandle node, int32_t subTypeId) { static Resetter* resetters[] = { ResetGridColumnsTemplate, ResetGridRowsTemplate, ResetGridColumnsGap, ResetGridRowsGap, ResetGridNodeAdapter, ResetGridCachedCount, ResetGridFocusWrapMode, ResetGridSyncLoad, - ResetGridAlignItems, ResetGridLayoutOptions }; + ResetGridAlignItems, ResetGridLayoutOptions, ResetGridEditMode, ResetGridMultiSelectable, + ResetGridSupportAnimation }; if (static_cast(subTypeId) >= sizeof(resetters) / sizeof(Resetter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Grid node attribute: %{public}d NOT IMPLEMENT", subTypeId); return; @@ -18060,7 +18124,7 @@ const ArkUI_AttributeItem* GetRelativeContainerAttribute(ArkUI_NodeHandle node, const ArkUI_AttributeItem* GetGridItemAttribute(ArkUI_NodeHandle node, int32_t subTypeId) { - static Getter* getters[] = { GetGridItemOptions }; + static Getter* getters[] = { GetGridItemOptions, GetGridItemSelectable, GetGridItemSelected }; if (static_cast(subTypeId) >= sizeof(getters) / sizeof(Getter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "GridItem node attribute: %{public}d NOT IMPLEMENT", subTypeId); return nullptr; @@ -18073,7 +18137,7 @@ const ArkUI_AttributeItem* GetGridAttribute(ArkUI_NodeHandle node, int32_t subTy { static Getter* getters[] = { GetGridColumnsTemplate, GetGridRowsTemplate, GetGridColumnsGap, GetGridRowsGap, GetGridNodeAdapter, GetGridCachedCount, GetGridFocusWrapMode, GetGridSyncLoad, GetGridAlignItems, - GetGridLayoutOptions }; + GetGridLayoutOptions, GetGridEditMode, GetGridMultiSelectable, GetGridSupportAnimation }; if (static_cast(subTypeId) >= sizeof(getters) / sizeof(Getter*)) { TAG_LOGE(AceLogTag::ACE_NATIVE_NODE, "Grid node attribute: %{public}d NOT IMPLEMENT", subTypeId); return nullptr; -- Gitee