1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "core/components_ng/pattern/navigation/navigation_model_ng.h"
17
18 #include "base/i18n/localization.h"
19 #include "base/memory/ace_type.h"
20 #include "base/memory/referenced.h"
21 #include "base/utils/utils.h"
22 #include "core/common/ace_application_info.h"
23 #include "core/common/force_split/force_split_utils.h"
24 #include "core/common/resource/resource_parse_utils.h"
25 #include "core/components/common/properties/alignment.h"
26 #include "core/components/common/properties/color.h"
27 #include "core/components/common/properties/shadow.h"
28 #include "core/components/common/properties/shadow_config.h"
29 #include "core/components_ng/base/frame_node.h"
30 #include "core/components_ng/base/view_stack_processor.h"
31 #include "core/components_ng/pattern/button/button_layout_property.h"
32 #include "core/components_ng/pattern/button/button_pattern.h"
33 #include "core/components_ng/pattern/custom/custom_node.h"
34 #include "core/components_ng/pattern/divider/divider_layout_property.h"
35 #include "core/components_ng/pattern/divider/divider_pattern.h"
36 #include "core/components_ng/pattern/divider/divider_render_property.h"
37 #include "core/components_ng/pattern/image/image_layout_property.h"
38 #include "core/components_ng/pattern/image/image_pattern.h"
39 #include "core/components_ng/pattern/linear_layout/linear_layout_pattern.h"
40 #include "core/components_ng/pattern/menu/menu_view.h"
41 #include "core/components_ng/pattern/navigation/bar_item_event_hub.h"
42 #include "core/components_ng/pattern/navigation/bar_item_node.h"
43 #include "core/components_ng/pattern/navigation/bar_item_pattern.h"
44 #include "core/components_ng/pattern/navigation/nav_bar_layout_property.h"
45 #include "core/components_ng/pattern/navigation/nav_bar_pattern.h"
46 #include "core/components_ng/pattern/navigation/navdestination_content_pattern.h"
47 #include "core/components_ng/pattern/navigation/navigation_content_pattern.h"
48 #include "core/components_ng/pattern/navigation/navigation_declaration.h"
49 #include "core/components_ng/pattern/navigation/navigation_drag_bar_pattern.h"
50 #include "core/components_ng/pattern/navigation/navigation_event_hub.h"
51 #include "core/components_ng/pattern/navigation/navigation_layout_property.h"
52 #include "core/components_ng/pattern/navigation/navigation_title_util.h"
53 #include "core/components_ng/pattern/navigation/navigation_pattern.h"
54 #include "core/components_ng/pattern/navigation/title_bar_node.h"
55 #include "core/components_ng/pattern/navigation/title_bar_pattern.h"
56 #include "core/components_ng/pattern/navigation/navigation_toolbar_util.h"
57 #include "core/components_ng/pattern/navigation/tool_bar_node.h"
58 #include "core/components_ng/pattern/navigation/tool_bar_pattern.h"
59 #include "core/components_ng/pattern/navigator/navigator_event_hub.h"
60 #include "core/components_ng/pattern/navigator/navigator_pattern.h"
61 #include "core/components_ng/pattern/navrouter/navdestination_group_node.h"
62 #include "core/components_ng/pattern/navrouter/navdestination_layout_property.h"
63 #include "core/components_ng/pattern/navrouter/navrouter_group_node.h"
64 #include "core/components_ng/pattern/select/select_model.h"
65 #include "core/components_ng/pattern/text/text_pattern.h"
66 #include "frameworks/base/system_bar/system_bar_style.h"
67 #include "frameworks/bridge/common/utils/engine_helper.h"
68
69 namespace OHOS::Ace::NG {
70 namespace {
71 constexpr int32_t DEFAULT_NAV_BAR_WIDTH_VALUE = 240;
72
CreateBarItemTextNode(const std::string & text)73 RefPtr<FrameNode> CreateBarItemTextNode(const std::string& text)
74 {
75 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
76 auto textNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, nodeId, AceType::MakeRefPtr<TextPattern>());
77 CHECK_NULL_RETURN(textNode, nullptr);
78 auto textLayoutProperty = textNode->GetLayoutProperty<TextLayoutProperty>();
79 CHECK_NULL_RETURN(textLayoutProperty, nullptr);
80 textLayoutProperty->UpdateContent(text);
81 textLayoutProperty->UpdateFontSize(TEXT_FONT_SIZE);
82 textLayoutProperty->UpdateTextColor(TEXT_COLOR);
83 textLayoutProperty->UpdateTextAlign(TextAlign::CENTER);
84 return textNode;
85 }
86
CreateBarItemIconNode(const std::string & src)87 RefPtr<FrameNode> CreateBarItemIconNode(const std::string& src)
88 {
89 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
90 ImageSourceInfo info(src);
91 auto iconNode = FrameNode::CreateFrameNode(V2::IMAGE_ETS_TAG, nodeId, AceType::MakeRefPtr<ImagePattern>());
92 CHECK_NULL_RETURN(iconNode, nullptr);
93 auto imageLayoutProperty = iconNode->GetLayoutProperty<ImageLayoutProperty>();
94 CHECK_NULL_RETURN(imageLayoutProperty, nullptr);
95 auto theme = NavigationGetTheme();
96 CHECK_NULL_RETURN(theme, nullptr);
97
98 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
99 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
100 CHECK_NULL_RETURN(navigationGroupNode, nullptr);
101 auto hub = navigationGroupNode->GetOrCreateEventHub<EventHub>();
102 CHECK_NULL_RETURN(hub, nullptr);
103 if (!hub->IsEnabled()) {
104 info.SetFillColor(theme->GetMenuIconColor().BlendOpacity(theme->GetAlphaDisabled()));
105 } else {
106 info.SetFillColor(theme->GetMenuIconColor());
107 }
108 imageLayoutProperty->UpdateImageSourceInfo(info);
109
110 auto iconSize = theme->GetMenuIconSize();
111 imageLayoutProperty->UpdateUserDefinedIdealSize(CalcSize(CalcLength(iconSize), CalcLength(iconSize)));
112 iconNode->MarkModifyDone();
113 return iconNode;
114 }
115
UpdateBarItemNodeWithItem(const RefPtr<BarItemNode> & barItemNode,const BarItem & barItem)116 void UpdateBarItemNodeWithItem(const RefPtr<BarItemNode>& barItemNode, const BarItem& barItem)
117 {
118 if (barItem.text.has_value() && !barItem.text.value().empty()) {
119 auto textNode = CreateBarItemTextNode(barItem.text.value());
120 CHECK_NULL_VOID(textNode);
121 barItemNode->SetTextNode(textNode);
122 if (!barItemNode->IsHideText()) {
123 barItemNode->AddChild(textNode);
124 }
125 }
126 if (barItem.icon.has_value() && !barItem.icon.value().empty()) {
127 auto iconNode = CreateBarItemIconNode(barItem.icon.value());
128 barItemNode->SetIconNode(iconNode);
129 barItemNode->AddChild(iconNode);
130 }
131 if (barItem.action) {
132 auto eventHub = barItemNode->GetOrCreateEventHub<BarItemEventHub>();
133 CHECK_NULL_VOID(eventHub);
134 eventHub->SetItemAction(barItem.action);
135 }
136 auto barItemPattern = barItemNode->GetPattern<BarItemPattern>();
137 barItemNode->MarkModifyDone();
138 }
139
UpdateOldBarItems(const RefPtr<UINode> & oldBarContainer,const std::vector<BarItem> & newBarItems)140 void UpdateOldBarItems(const RefPtr<UINode>& oldBarContainer, const std::vector<BarItem>& newBarItems)
141 {
142 auto oldBarItems = oldBarContainer->GetChildren();
143 auto prevChildrenSize = static_cast<int32_t>(oldBarItems.size());
144 auto newChildrenSize = static_cast<int32_t>(newBarItems.size());
145 auto oldIter = oldBarItems.begin();
146 auto newIter = newBarItems.begin();
147 // if old container has m items and incoming array has n items
148 // we update first min(m, n) items in the old container
149 for (int32_t i = 0; i < std::min(prevChildrenSize, newChildrenSize); i++) {
150 do {
151 auto oldBarItem = AceType::DynamicCast<BarItemNode>(*oldIter);
152 BarItem newBarItem = *newIter;
153 if (!oldBarItem) {
154 break;
155 }
156 if (newBarItem.text.has_value()) {
157 oldBarItem->UpdateText(newBarItem.text.value());
158 if (oldBarItem->GetTextNode()) {
159 auto textNode = AceType::DynamicCast<FrameNode>(oldBarItem->GetTextNode());
160 CHECK_NULL_VOID(textNode);
161 auto textLayoutProperty = textNode->GetLayoutProperty<TextLayoutProperty>();
162 CHECK_NULL_VOID(textLayoutProperty);
163 textLayoutProperty->UpdateContent(newBarItem.text.value());
164 textNode->MarkModifyDone();
165 } else {
166 auto textNode = CreateBarItemTextNode(newBarItem.text.value());
167 oldBarItem->SetTextNode(textNode);
168 oldBarItem->AddChild(textNode);
169 oldBarItem->MarkModifyDone();
170 }
171 } else {
172 oldBarItem->ResetText();
173 if (oldBarItem->GetTextNode()) {
174 auto textNode = AceType::DynamicCast<FrameNode>(oldBarItem->GetTextNode());
175 CHECK_NULL_VOID(textNode);
176 oldBarItem->RemoveChild(textNode);
177 }
178 }
179 if (newBarItem.icon.has_value()) {
180 oldBarItem->UpdateIconSrc(newBarItem.icon.value());
181 if (oldBarItem->GetIconNode()) {
182 auto iconNode = AceType::DynamicCast<FrameNode>(oldBarItem->GetIconNode());
183 CHECK_NULL_VOID(iconNode);
184 auto imageLayoutProperty = iconNode->GetLayoutProperty<ImageLayoutProperty>();
185 CHECK_NULL_VOID(imageLayoutProperty);
186 imageLayoutProperty->UpdateImageSourceInfo(ImageSourceInfo(newBarItem.icon.value()));
187 iconNode->MarkModifyDone();
188 } else {
189 auto iconNode = CreateBarItemIconNode(newBarItem.icon.value());
190 oldBarItem->SetIconNode(iconNode);
191 oldBarItem->AddChild(iconNode);
192 oldBarItem->MarkModifyDone();
193 }
194 } else {
195 oldBarItem->ResetIconSrc();
196 if (oldBarItem->GetIconNode()) {
197 auto iconNode = AceType::DynamicCast<FrameNode>(oldBarItem->GetIconNode());
198 CHECK_NULL_VOID(iconNode);
199 oldBarItem->RemoveChild(iconNode);
200 }
201 }
202 } while (false);
203 oldIter++;
204 newIter++;
205 }
206 // if m > n, we remove (m - n) children from the back of old container
207 if (prevChildrenSize > newChildrenSize) {
208 for (int32_t i = 0; i < prevChildrenSize - newChildrenSize; i++) {
209 oldBarContainer->RemoveChild(oldBarItems.back());
210 oldBarItems.pop_back();
211 }
212 } else if (prevChildrenSize < newChildrenSize) {
213 // if m < n, we add (n - m) children created by info in new item list
214 for (int32_t i = 0; i < newChildrenSize - prevChildrenSize; i++) {
215 auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
216 auto barItemNode = BarItemNode::GetOrCreateBarItemNode(
217 V2::BAR_ITEM_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<BarItemPattern>(); });
218 UpdateBarItemNodeWithItem(barItemNode, *newIter);
219 oldBarContainer->AddChild(barItemNode);
220 newIter++;
221 }
222 }
223 auto container = AceType::DynamicCast<TitleBarNode>(oldBarContainer);
224 CHECK_NULL_VOID(container);
225 container->MarkModifyDone();
226 }
227
SetNeedResetTitleProperty(const RefPtr<FrameNode> & titleBarNode)228 void SetNeedResetTitleProperty(const RefPtr<FrameNode>& titleBarNode)
229 {
230 CHECK_NULL_VOID(titleBarNode);
231 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
232 CHECK_NULL_VOID(titleBarPattern);
233 titleBarPattern->SetNeedResetMainTitleProperty(true);
234 titleBarPattern->SetNeedResetSubTitleProperty(true);
235 }
236 } // namespace
237 bool NavigationModelNG::navBarWidthDoubleBind_ = false;
238
Create(bool useHomeDestination)239 void NavigationModelNG::Create(bool useHomeDestination)
240 {
241 TAG_LOGD(AceLogTag::ACE_NAVIGATION, "create navigation and %{public}s HomeNavDestination",
242 (useHomeDestination ? "use" : "don't use"));
243 auto* stack = ViewStackProcessor::GetInstance();
244 // navigation node
245 int32_t nodeId = stack->ClaimNodeId();
246 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::NAVIGATION_VIEW_ETS_TAG, nodeId);
247 auto navigationGroupNode = NavigationRegister::GetInstance()->GetOrCreateGroupNode(
248 V2::NAVIGATION_VIEW_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<NavigationPattern>(); });
249 CHECK_NULL_VOID(navigationGroupNode);
250 auto useHomeDest = navigationGroupNode->GetUseHomeDestination();
251 if (!useHomeDest.has_value()) {
252 useHomeDest = useHomeDestination;
253 navigationGroupNode->SetUseHomeDestinatoin(useHomeDestination);
254 }
255 if (!useHomeDest.value() && !CreateNavBarNodeIfNeeded(navigationGroupNode)) { // navBar node
256 return;
257 }
258 if (!CreatePrimaryContentIfNeeded(navigationGroupNode) || // primaryContent node
259 !CreateForceSplitPlaceHolderIfNeeded(navigationGroupNode) || // forcesplit placeHolder node
260 !CreateContentNodeIfNeeded(navigationGroupNode) || // content node
261 !CreateDividerNodeIfNeeded(navigationGroupNode)) { // divider node
262 return;
263 }
264
265 stack->Push(navigationGroupNode);
266 auto navigationLayoutProperty = navigationGroupNode->GetLayoutProperty<NavigationLayoutProperty>();
267 if (!navigationLayoutProperty->HasNavigationMode()) {
268 navigationLayoutProperty->UpdateNavigationMode(NavigationMode::AUTO);
269 }
270
271 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
272 if (navigationPattern && !navigationPattern->GetUserSetNavBarWidthFlag()) {
273 navigationLayoutProperty->UpdateNavBarWidth(DEFAULT_NAV_BAR_WIDTH);
274 }
275 }
276
CreatePrimaryContentIfNeeded(const RefPtr<NavigationGroupNode> & navigationGroupNode)277 bool NavigationModelNG::CreatePrimaryContentIfNeeded(const RefPtr<NavigationGroupNode>& navigationGroupNode)
278 {
279 CHECK_NULL_RETURN(navigationGroupNode, false);
280 auto context = navigationGroupNode->GetContext();
281 CHECK_NULL_RETURN(context, false);
282 auto manager = context->GetNavigationManager();
283 CHECK_NULL_RETURN(manager, false);
284 if (!manager->IsForceSplitSupported()) {
285 return true;
286 }
287 if (navigationGroupNode->GetPrimaryContentNode()) {
288 return true;
289 }
290 int32_t contentId = ElementRegister::GetInstance()->MakeUniqueId();
291 auto contentNode = FrameNode::GetOrCreateFrameNode(
292 V2::PRIMARY_CONTENT_NODE_ETS_TAG, contentId, []() { return AceType::MakeRefPtr<NavigationContentPattern>(); });
293 contentNode->GetLayoutProperty()->UpdateAlignment(Alignment::TOP_LEFT);
294 contentNode->GetOrCreateEventHub<EventHub>()->GetOrCreateGestureEventHub()->SetHitTestMode(
295 HitTestMode::HTMTRANSPARENT_SELF);
296 navigationGroupNode->AddChild(contentNode);
297 navigationGroupNode->SetPrimaryContentNode(contentNode);
298 return true;
299 }
300
CreateForceSplitPlaceHolderIfNeeded(const RefPtr<NavigationGroupNode> & navigationGroupNode)301 bool NavigationModelNG::CreateForceSplitPlaceHolderIfNeeded(const RefPtr<NavigationGroupNode>& navigationGroupNode)
302 {
303 CHECK_NULL_RETURN(navigationGroupNode, false);
304 auto context = navigationGroupNode->GetContext();
305 CHECK_NULL_RETURN(context, false);
306 auto manager = context->GetNavigationManager();
307 CHECK_NULL_RETURN(manager, false);
308 if (!manager->IsForceSplitSupported()) {
309 return true;
310 }
311 if (navigationGroupNode->GetForceSplitPlaceHolderNode()) {
312 return true;
313 }
314 auto phNode = ForceSplitUtils::CreatePlaceHolderNode();
315 CHECK_NULL_RETURN(phNode, false);
316 navigationGroupNode->AddChild(phNode);
317 navigationGroupNode->SetForceSplitPlaceHolderNode(phNode);
318 return true;
319 }
320
CreateNavBarNodeIfNeeded(const RefPtr<NavigationGroupNode> & navigationGroupNode)321 bool NavigationModelNG::CreateNavBarNodeIfNeeded(const RefPtr<NavigationGroupNode>& navigationGroupNode)
322 {
323 if (!navigationGroupNode->GetNavBarNode()) {
324 int32_t navBarNodeId = ElementRegister::GetInstance()->MakeUniqueId();
325 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::NAVBAR_ETS_TAG, navBarNodeId);
326 auto navBarNode = NavBarNode::GetOrCreateNavBarNode(
327 V2::NAVBAR_ETS_TAG, navBarNodeId, []() { return AceType::MakeRefPtr<NavBarPattern>(); });
328 navBarNode->SetJSViewActive(true);
329 auto navBarRenderContext = navBarNode->GetRenderContext();
330 CHECK_NULL_RETURN(navBarRenderContext, false);
331 navBarRenderContext->UpdateClipEdge(true);
332 navigationGroupNode->AddChild(navBarNode);
333 navigationGroupNode->SetNavBarNode(navBarNode);
334 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
335 CHECK_NULL_RETURN(navBarPattern, false);
336 navBarPattern->SetNavigationNode(navigationGroupNode);
337
338 if (!CreateNavBarNodeChildsIfNeeded(navBarNode)) {
339 return false;
340 }
341
342 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
343 CHECK_NULL_RETURN(navBarLayoutProperty, false);
344 navBarLayoutProperty->UpdateTitleMode(NavigationTitleMode::FREE);
345 }
346
347 return true;
348 }
349
CreateNavBarNodeChildsIfNeeded(const RefPtr<NavBarNode> & navBarNode)350 bool NavigationModelNG::CreateNavBarNodeChildsIfNeeded(const RefPtr<NavBarNode>& navBarNode)
351 {
352 // titleBar node
353 if (!navBarNode->GetTitleBarNode()) {
354 int32_t titleBarNodeId = ElementRegister::GetInstance()->MakeUniqueId();
355 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::TITLE_BAR_ETS_TAG, titleBarNodeId);
356 auto titleBarNode = TitleBarNode::GetOrCreateTitleBarNode(
357 V2::TITLE_BAR_ETS_TAG, titleBarNodeId, []() { return AceType::MakeRefPtr<TitleBarPattern>(); });
358 navBarNode->AddChild(titleBarNode);
359 navBarNode->SetTitleBarNode(titleBarNode);
360 }
361
362 // navBar content node
363 if (!navBarNode->GetContentNode()) {
364 int32_t navBarContentNodeId = ElementRegister::GetInstance()->MakeUniqueId();
365 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::NAVBAR_CONTENT_ETS_TAG, navBarContentNodeId);
366 auto navBarContentNode = FrameNode::GetOrCreateFrameNode(V2::NAVBAR_CONTENT_ETS_TAG, navBarContentNodeId,
367 []() { return AceType::MakeRefPtr<NavDestinationContentPattern>(true); });
368 auto navBarContentRenderContext = navBarContentNode->GetRenderContext();
369 CHECK_NULL_RETURN(navBarContentRenderContext, false);
370 navBarContentRenderContext->UpdateClipEdge(true);
371 navBarNode->AddChild(navBarContentNode);
372 navBarNode->SetContentNode(navBarContentNode);
373
374 if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_ELEVEN)) {
375 SafeAreaExpandOpts opts = { .type = SAFE_AREA_TYPE_SYSTEM | SAFE_AREA_TYPE_CUTOUT,
376 .edges = SAFE_AREA_EDGE_ALL };
377 navBarContentNode->GetLayoutProperty()->UpdateSafeAreaExpandOpts(opts);
378 }
379 }
380
381 // toolBar node
382 if (!navBarNode->GetToolBarNode()) {
383 int32_t toolBarNodeId = ElementRegister::GetInstance()->MakeUniqueId();
384 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::TOOL_BAR_ETS_TAG, toolBarNodeId);
385 auto toolBarNode = NavToolbarNode::GetOrCreateToolbarNode(
386 V2::TOOL_BAR_ETS_TAG, toolBarNodeId, []() { return AceType::MakeRefPtr<NavToolbarPattern>(); });
387 toolBarNode->MarkModifyDone();
388 auto property = toolBarNode->GetLayoutProperty();
389 CHECK_NULL_RETURN(property, false);
390 property->UpdateVisibility(VisibleType::GONE);
391 navBarNode->AddChild(toolBarNode);
392 navBarNode->SetToolBarNode(toolBarNode);
393 navBarNode->SetPreToolBarNode(toolBarNode);
394 navBarNode->UpdatePrevToolBarIsCustom(false);
395 }
396
397 return true;
398 }
399
CreateContentNodeIfNeeded(const RefPtr<NavigationGroupNode> & navigationGroupNode)400 bool NavigationModelNG::CreateContentNodeIfNeeded(const RefPtr<NavigationGroupNode>& navigationGroupNode)
401 {
402 if (!navigationGroupNode->GetContentNode()) {
403 int32_t contentNodeId = ElementRegister::GetInstance()->MakeUniqueId();
404 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::NAVIGATION_CONTENT_ETS_TAG, contentNodeId);
405 auto contentNode = FrameNode::GetOrCreateFrameNode(V2::NAVIGATION_CONTENT_ETS_TAG, contentNodeId,
406 []() { return AceType::MakeRefPtr<NavigationContentPattern>(); });
407 contentNode->GetLayoutProperty()->UpdateAlignment(Alignment::TOP_LEFT);
408 contentNode->GetOrCreateEventHub<EventHub>()->GetOrCreateGestureEventHub()->SetHitTestMode(
409 HitTestMode::HTMTRANSPARENT_SELF);
410 navigationGroupNode->AddChild(contentNode);
411 navigationGroupNode->SetContentNode(contentNode);
412 }
413
414 return true;
415 }
416
CreateDividerNodeIfNeeded(const RefPtr<NavigationGroupNode> & navigationGroupNode)417 bool NavigationModelNG::CreateDividerNodeIfNeeded(const RefPtr<NavigationGroupNode>& navigationGroupNode)
418 {
419 if (!navigationGroupNode->GetDividerNode()) {
420 int32_t dividerNodeId = ElementRegister::GetInstance()->MakeUniqueId();
421 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::DIVIDER_ETS_TAG, dividerNodeId);
422 auto dividerNode = FrameNode::GetOrCreateFrameNode(
423 V2::DIVIDER_ETS_TAG, dividerNodeId, []() { return AceType::MakeRefPtr<DividerPattern>(); });
424 navigationGroupNode->AddChild(dividerNode);
425 navigationGroupNode->SetDividerNode(dividerNode);
426
427 if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_ELEVEN)) {
428 SafeAreaExpandOpts opts = { .type = SAFE_AREA_TYPE_SYSTEM | SAFE_AREA_TYPE_CUTOUT,
429 .edges = SAFE_AREA_EDGE_ALL };
430 dividerNode->GetLayoutProperty()->UpdateSafeAreaExpandOpts(opts);
431 }
432
433 auto dividerLayoutProperty = dividerNode->GetLayoutProperty<DividerLayoutProperty>();
434 CHECK_NULL_RETURN(dividerLayoutProperty, false);
435 dividerLayoutProperty->UpdateStrokeWidth(DIVIDER_WIDTH);
436 dividerLayoutProperty->UpdateVertical(true);
437 auto dividerRenderProperty = dividerNode->GetPaintProperty<DividerRenderProperty>();
438 CHECK_NULL_RETURN(dividerRenderProperty, false);
439 auto theme = NavigationGetTheme();
440 CHECK_NULL_RETURN(theme, false);
441 dividerRenderProperty->UpdateDividerColor(Color::TRANSPARENT);
442 dividerNode->GetRenderContext()->UpdateBackgroundColor(theme->GetNavigationDividerColor());
443 }
444
445 return true;
446 }
447
ParseCommonTitle(bool hasSubTitle,bool hasMainTitle,const std::string & subtitle,const std::string & title,bool ignoreMainTitle)448 bool NavigationModelNG::ParseCommonTitle(
449 bool hasSubTitle, bool hasMainTitle, const std::string& subtitle, const std::string& title, bool ignoreMainTitle)
450 {
451 if (!hasSubTitle && !hasMainTitle) {
452 return false;
453 }
454 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
455 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
456 CHECK_NULL_RETURN(navigationGroupNode, false);
457 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
458 CHECK_NULL_RETURN(navBarNode, false);
459 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
460 CHECK_NULL_RETURN(titleBarNode, false);
461 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
462 CHECK_NULL_RETURN(titleBarPattern, false);
463 titleBarPattern->SetIsTitleChanged(true);
464 if (navBarNode->GetPrevTitleIsCustomValue(false)) {
465 titleBarNode->RemoveChild(titleBarNode->GetTitle());
466 titleBarNode->SetTitle(nullptr);
467 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
468 CHECK_NULL_RETURN(titleBarLayoutProperty, false);
469 if (titleBarLayoutProperty->HasTitleHeight()) {
470 titleBarLayoutProperty->ResetTitleHeight();
471 navBarNode->GetLayoutProperty<NavBarLayoutProperty>()->ResetTitleMode();
472 }
473 }
474 navBarNode->UpdatePrevTitleIsCustom(false);
475 if (titleBarPattern->IsFirstTimeSetSystemTitle()) {
476 titleBarPattern->SetIsFirstTimeSetSystemTitle(false);
477 titleBarPattern->MarkIsInitialTitle(true);
478 }
479
480 // create or update main title
481 do {
482 if (ignoreMainTitle) {
483 break;
484 }
485 auto mainTitle = AceType::DynamicCast<FrameNode>(titleBarNode->GetTitle());
486 if (!hasMainTitle) {
487 // remove main title if any.
488 titleBarNode->RemoveChild(mainTitle);
489 titleBarNode->SetTitle(nullptr);
490 break;
491 }
492
493 if (mainTitle) {
494 // update main title
495 auto textLayoutProperty = mainTitle->GetLayoutProperty<TextLayoutProperty>();
496 textLayoutProperty->UpdateMaxLines(hasSubTitle ? 1 : TITLEBAR_MAX_LINES);
497 textLayoutProperty->UpdateContent(title);
498 break;
499 }
500 // create and init main title
501 mainTitle = FrameNode::CreateFrameNode(
502 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
503 auto textLayoutProperty = mainTitle->GetLayoutProperty<TextLayoutProperty>();
504 textLayoutProperty->UpdateContent(title);
505 titleBarPattern->SetNeedResetMainTitleProperty(true);
506 titleBarNode->SetTitle(mainTitle);
507 titleBarNode->AddChild(mainTitle);
508 } while (false);
509
510 // create or update subtitle
511 auto subTitle = AceType::DynamicCast<FrameNode>(titleBarNode->GetSubtitle());
512 if (!hasSubTitle) {
513 // remove subtitle if any.
514 titleBarNode->RemoveChild(subTitle);
515 titleBarNode->SetSubtitle(nullptr);
516 return true;
517 }
518 if (subTitle) {
519 // update subtitle
520 auto textLayoutProperty = subTitle->GetLayoutProperty<TextLayoutProperty>();
521 textLayoutProperty->UpdateContent(subtitle);
522 } else {
523 // create and init subtitle
524 subTitle = FrameNode::CreateFrameNode(
525 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
526 auto textLayoutProperty = subTitle->GetLayoutProperty<TextLayoutProperty>();
527 textLayoutProperty->UpdateContent(subtitle);
528 titleBarPattern->SetNeedResetSubTitleProperty(true);
529 titleBarNode->SetSubtitle(subTitle);
530 titleBarNode->AddChild(subTitle);
531 }
532 return true;
533 }
534
ParseCommonTitle(bool hasSubTitle,bool hasMainTitle,const RefPtr<ResourceObject> & subResObj,const RefPtr<ResourceObject> & mainResObj)535 bool NavigationModelNG::ParseCommonTitle(bool hasSubTitle, bool hasMainTitle, const RefPtr<ResourceObject>& subResObj,
536 const RefPtr<ResourceObject>& mainResObj)
537 {
538 if (!hasSubTitle && !hasMainTitle) {
539 return false;
540 }
541 std::string subtitle = "";
542 std::string title = "";
543 if (hasSubTitle) {
544 ResourceParseUtils::ParseResString(subResObj, subtitle);
545 }
546 ResourceParseUtils::ParseResString(mainResObj, title);
547 ParseCommonTitle(hasSubTitle, hasMainTitle, subtitle, title);
548 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
549 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
550 CHECK_NULL_RETURN(navigationGroupNode, false);
551 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
552 CHECK_NULL_RETURN(navBarNode, false);
553 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
554 CHECK_NULL_RETURN(titleBarNode, false);
555 UpdateMainTitle(titleBarNode, mainResObj);
556 UpdateSubTitle(titleBarNode, subResObj);
557 return true;
558 }
559
UpdateMainTitle(const RefPtr<NG::TitleBarNode> & titleBarNode,const RefPtr<ResourceObject> & mainResObj)560 void NavigationModelNG::UpdateMainTitle(
561 const RefPtr<NG::TitleBarNode>& titleBarNode, const RefPtr<ResourceObject>& mainResObj)
562 {
563 std::string key = "navigation.title.commonMainTitle";
564 auto updateFunc = [this, key, weak = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
565 const RefPtr<ResourceObject>& mainResObj) mutable {
566 auto titleBarNode = weak.Upgrade();
567 CHECK_NULL_VOID(titleBarNode);
568 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
569 CHECK_NULL_VOID(titleBarPattern);
570 std::string title = titleBarPattern->GetResCacheMapByKey(key);
571 if (title.empty()) {
572 ResourceParseUtils::ParseResString(mainResObj, title);
573 titleBarPattern->AddResCache(key, title);
574 }
575 auto mainTitle = AceType::DynamicCast<FrameNode>(titleBarNode->GetTitle());
576 if (mainTitle) {
577 auto textLayoutProperty = mainTitle->GetLayoutProperty<NG::TextLayoutProperty>();
578 textLayoutProperty->UpdateContent(title);
579 titleBarNode->MarkModifyDone();
580 titleBarNode->MarkDirtyNode();
581 }
582 };
583 CHECK_NULL_VOID(titleBarNode);
584 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
585 CHECK_NULL_VOID(titleBarPattern);
586 titleBarPattern->AddResObj(key, mainResObj, std::move(updateFunc));
587 }
588
UpdateSubTitle(const RefPtr<NG::TitleBarNode> & titleBarNode,const RefPtr<ResourceObject> & resObj)589 void NavigationModelNG::UpdateSubTitle(
590 const RefPtr<NG::TitleBarNode>& titleBarNode, const RefPtr<ResourceObject>& resObj)
591 {
592 std::string key = "navigation.title.commonSubTitle";
593 auto updateFunc = [key, weak = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
594 const RefPtr<ResourceObject>& resObj) {
595 auto titleBarNode = weak.Upgrade();
596 CHECK_NULL_VOID(titleBarNode);
597 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
598 CHECK_NULL_VOID(titleBarPattern);
599 std::string subTitleValue = titleBarPattern->GetResCacheMapByKey(key);
600 if (subTitleValue.empty()) {
601 ResourceParseUtils::ParseResString(resObj, subTitleValue);
602 titleBarPattern->AddResCache(key, subTitleValue);
603 }
604 auto subTitle = AceType::DynamicCast<FrameNode>(titleBarNode->GetSubtitle());
605 if (subTitle) {
606 auto textLayoutProperty = subTitle->GetLayoutProperty<TextLayoutProperty>();
607 textLayoutProperty->UpdateContent(subTitleValue);
608 titleBarNode->MarkModifyDone();
609 titleBarNode->MarkDirtyNode();
610 }
611 };
612 CHECK_NULL_VOID(titleBarNode);
613 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
614 CHECK_NULL_VOID(titleBarPattern);
615 titleBarPattern->AddResObj(key, resObj, std::move(updateFunc));
616 }
617
SetTitle(const std::string & title,bool hasSubTitle)618 void NavigationModelNG::SetTitle(const std::string& title, bool hasSubTitle) {}
619
SetCustomTitle(const RefPtr<AceType> & customNode)620 void NavigationModelNG::SetCustomTitle(const RefPtr<AceType>& customNode)
621 {
622 auto customTitle = AceType::DynamicCast<NG::UINode>(customNode);
623 CHECK_NULL_VOID(customTitle);
624 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
625 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
626 CHECK_NULL_VOID(navigationGroupNode);
627 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
628 CHECK_NULL_VOID(navBarNode);
629 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
630 CHECK_NULL_VOID(titleBarNode);
631
632 if (!navBarNode->GetPrevTitleIsCustomValue(false)) {
633 titleBarNode->RemoveChild(titleBarNode->GetTitle());
634 titleBarNode->RemoveChild(titleBarNode->GetSubtitle());
635 titleBarNode->SetTitle(nullptr);
636 titleBarNode->SetSubtitle(nullptr);
637 }
638 navBarNode->UpdatePrevTitleIsCustom(true);
639
640 auto currentTitle = titleBarNode->GetTitle();
641 if (currentTitle && customTitle->GetId() == currentTitle->GetId()) {
642 // do nothing
643 return;
644 }
645 // update custom title
646 titleBarNode->RemoveChild(currentTitle);
647 titleBarNode->SetTitle(customTitle);
648 titleBarNode->AddChild(customTitle);
649 titleBarNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
650 }
651
SetTitleHeight(const Dimension & height,bool isValid)652 void NavigationModelNG::SetTitleHeight(const Dimension& height, bool isValid)
653 {
654 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
655 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
656 CHECK_NULL_VOID(navigationGroupNode);
657 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
658 CHECK_NULL_VOID(navBarNode);
659 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
660 CHECK_NULL_VOID(titleBarNode);
661 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
662 CHECK_NULL_VOID(titleBarLayoutProperty);
663 if (!isValid) {
664 titleBarLayoutProperty->ResetTitleHeight();
665 return;
666 }
667 titleBarLayoutProperty->UpdateTitleHeight(height);
668 SetHideBackButton(true);
669 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
670 CHECK_NULL_VOID(navBarLayoutProperty);
671 navBarLayoutProperty->UpdateTitleMode(static_cast<NG::NavigationTitleMode>(NavigationTitleMode::MINI));
672 }
673
SetTitleHeight(const Dimension & height,const RefPtr<ResourceObject> & resObj)674 void NavigationModelNG::SetTitleHeight(const Dimension& height, const RefPtr<ResourceObject>& resObj)
675 {
676 SetTitleHeight(height);
677 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
678 CHECK_NULL_VOID(frameNode);
679 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
680 CHECK_NULL_VOID(navigationGroupNode);
681 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
682 CHECK_NULL_VOID(navBarNode);
683 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
684 CHECK_NULL_VOID(titleBarNode);
685 auto updateFunc = [this, weak = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
686 const RefPtr<ResourceObject>& resObj) {
687 auto titleBarNode = weak.Upgrade();
688 CHECK_NULL_VOID(titleBarNode);
689 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
690 CHECK_NULL_VOID(titleBarLayoutProperty);
691 CalcDimension height = ParseTitleHeight(titleBarNode, resObj);
692 titleBarLayoutProperty->UpdateTitleHeight(height);
693 SetHideBackButton(true);
694 titleBarNode->MarkModifyDone();
695 titleBarNode->MarkDirtyNode();
696 };
697 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
698 CHECK_NULL_VOID(titleBarPattern);
699 titleBarPattern->AddResObj("navigation.title.customtitle", resObj, std::move(updateFunc));
700 }
701
ParseTitleHeight(const RefPtr<NG::TitleBarNode> & titleBarNode,const RefPtr<ResourceObject> & resObj)702 CalcDimension NavigationModelNG::ParseTitleHeight(
703 const RefPtr<NG::TitleBarNode>& titleBarNode, const RefPtr<ResourceObject>& resObj)
704 {
705 CHECK_NULL_RETURN(titleBarNode, Dimension());
706 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
707 CHECK_NULL_RETURN(titleBarPattern, Dimension());
708 std::string heightValue;
709 std::string key = "navigation.title.customtitle";
710 std::string heightString = titleBarPattern->GetResCacheMapByKey(key);
711 if (heightString.empty() && ResourceParseUtils::ParseResString(resObj, heightValue)) {
712 titleBarPattern->AddResCache(key, heightValue);
713 } else {
714 heightValue = heightString;
715 }
716 if (heightValue == NG::TITLE_MAIN_WITH_SUB) {
717 return NG::DOUBLE_LINE_TITLEBAR_HEIGHT;
718 }
719 if (heightValue == NG::TITLE_MAIN) {
720 return NG::SINGLE_LINE_TITLEBAR_HEIGHT;
721 }
722
723 CalcDimension height;
724 if (heightString.empty()) {
725 bool isValid = ResourceParseUtils::ParseResDimensionVpNG(resObj, height);
726 titleBarPattern->AddResCache(key, height.ToString());
727 if (!isValid || height.Value() < 0) {
728 return Dimension();
729 }
730 } else {
731 height = StringUtils::StringToCalcDimension(heightString);
732 }
733 return height;
734 }
735
CreateSymbolBackIcon(const RefPtr<FrameNode> & backButtonNode,NavigationGroupNode * navigationGroupNode)736 void CreateSymbolBackIcon(const RefPtr<FrameNode>& backButtonNode, NavigationGroupNode* navigationGroupNode)
737 {
738 auto theme = NavigationGetTheme();
739 CHECK_NULL_VOID(theme);
740 auto symbolNode = FrameNode::GetOrCreateFrameNode(V2::SYMBOL_ETS_TAG,
741 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<TextPattern>(); });
742 CHECK_NULL_VOID(symbolNode);
743 auto symbolProperty = symbolNode->GetLayoutProperty<TextLayoutProperty>();
744 CHECK_NULL_VOID(symbolProperty);
745 symbolProperty->UpdateSymbolSourceInfo(SymbolSourceInfo(theme->GetBackSymbolId()));
746 auto navigationEventHub = navigationGroupNode->GetOrCreateEventHub<EventHub>();
747 CHECK_NULL_VOID(navigationEventHub);
748 if (!navigationEventHub->IsEnabled()) {
749 symbolProperty->UpdateSymbolColorList(
750 { theme->GetBackButtonIconColor().BlendOpacity(theme->GetAlphaDisabled()) });
751 } else {
752 symbolProperty->UpdateSymbolColorList({ theme->GetBackButtonIconColor() });
753 }
754 symbolNode->MountToParent(backButtonNode);
755 symbolNode->MarkModifyDone();
756 }
757
CreateImageBackIcon(const RefPtr<FrameNode> & backButtonNode,NavigationGroupNode * navigationGroupNode)758 void CreateImageBackIcon(const RefPtr<FrameNode>& backButtonNode, NavigationGroupNode* navigationGroupNode)
759 {
760 auto theme = NavigationGetTheme();
761 CHECK_NULL_VOID(theme);
762 auto backButtonImageNode = FrameNode::CreateFrameNode(V2::BACK_BUTTON_IMAGE_ETS_TAG,
763 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>());
764 CHECK_NULL_VOID(backButtonImageNode);
765
766 auto backButtonImageLayoutProperty = backButtonImageNode->GetLayoutProperty<ImageLayoutProperty>();
767 CHECK_NULL_VOID(backButtonImageLayoutProperty);
768
769 ImageSourceInfo imageSourceInfo;
770 auto iconColor = theme->GetBackButtonIconColor();
771 auto backReourceId = theme->GetBackResourceId();
772
773 imageSourceInfo.SetResourceId(backReourceId);
774 auto navigationEventHub = navigationGroupNode->GetOrCreateEventHub<EventHub>();
775 CHECK_NULL_VOID(navigationEventHub);
776 if (!navigationEventHub->IsEnabled()) {
777 imageSourceInfo.SetFillColor(iconColor.BlendOpacity(theme->GetAlphaDisabled()));
778 } else {
779 imageSourceInfo.SetFillColor(iconColor);
780 }
781 backButtonImageLayoutProperty->UpdateImageSourceInfo(imageSourceInfo);
782 backButtonImageLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT);
783
784 backButtonImageNode->MountToParent(backButtonNode);
785 backButtonImageNode->MarkModifyDone();
786 }
787
SetTitleMode(NG::NavigationTitleMode mode)788 void NavigationModelNG::SetTitleMode(NG::NavigationTitleMode mode)
789 {
790 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
791 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
792 CHECK_NULL_VOID(navigationGroupNode);
793 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
794 CHECK_NULL_VOID(navBarNode);
795 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
796 CHECK_NULL_VOID(navBarLayoutProperty);
797 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
798 CHECK_NULL_VOID(titleBarNode);
799 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
800 CHECK_NULL_VOID(titleBarLayoutProperty);
801 const auto& titleHeightProperty = titleBarLayoutProperty->GetTitleHeight();
802 if (titleHeightProperty.has_value()) {
803 mode = NavigationTitleMode::MINI;
804 }
805 if (!navBarLayoutProperty->HasTitleMode() || navBarLayoutProperty->GetTitleModeValue() != mode) {
806 SetNeedResetTitleProperty(titleBarNode);
807 }
808 navBarLayoutProperty->UpdateTitleMode(static_cast<NG::NavigationTitleMode>(mode));
809 auto backButtonNode = AceType::DynamicCast<FrameNode>(titleBarNode->GetBackButton());
810 if (mode != NavigationTitleMode::MINI) {
811 // remove back button if any.
812 titleBarNode->RemoveChild(backButtonNode);
813 titleBarNode->SetBackButton(nullptr);
814 return;
815 }
816
817 if (backButtonNode != nullptr) {
818 return;
819 }
820 // create back button
821 bool result = CreateBackButtonNode(backButtonNode);
822 CHECK_NULL_VOID(result);
823
824 if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_TWELVE) &&
825 SystemProperties::IsNeedSymbol()) {
826 CreateSymbolBackIcon(backButtonNode, navigationGroupNode);
827 } else {
828 CreateImageBackIcon(backButtonNode, navigationGroupNode);
829 }
830
831 //read navigation back button
832 auto theme = NavigationGetTheme();
833 std::string message = theme ? theme->GetNavigationBack() : "";
834 NavigationTitleUtil::SetAccessibility(backButtonNode, message);
835
836 backButtonNode->MarkModifyDone();
837 titleBarNode->SetBackButton(backButtonNode);
838 titleBarNode->AddChild(backButtonNode, 0);
839 }
840
CreateBackButtonNode(RefPtr<FrameNode> & backButtonNode)841 bool NavigationModelNG::CreateBackButtonNode(RefPtr<FrameNode>& backButtonNode)
842 {
843 auto buttonPattern = AceType::MakeRefPtr<NG::ButtonPattern>();
844 CHECK_NULL_RETURN(buttonPattern, false);
845 auto theme = NavigationGetTheme();
846 CHECK_NULL_RETURN(theme, false);
847 buttonPattern->SetSkipColorConfigurationUpdate();
848 buttonPattern->setComponentButtonType(ComponentButtonType::NAVIGATION);
849 if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_TWELVE)) {
850 buttonPattern->SetBlendColor(theme->GetBackgroundPressedColor(), theme->GetBackgroundHoverColor());
851 buttonPattern->SetFocusBorderColor(theme->GetBackgroundFocusOutlineColor());
852 buttonPattern->SetFocusBorderWidth(theme->GetBackgroundFocusOutlineWeight());
853 }
854 backButtonNode = FrameNode::CreateFrameNode(
855 V2::BACK_BUTTON_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), buttonPattern);
856 auto focusHub = backButtonNode->GetOrCreateFocusHub();
857 CHECK_NULL_RETURN(focusHub, false);
858 focusHub->SetFocusDependence(FocusDependence::SELF);
859 auto gestureEventHub = backButtonNode->GetOrCreateGestureEventHub();
860 CHECK_NULL_RETURN(gestureEventHub, false);
861 auto context = PipelineContext::GetCurrentContext();
862 auto clickCallback = [weakContext = WeakPtr<PipelineContext>(context)](GestureEvent& /* info */) {
863 auto context = weakContext.Upgrade();
864 CHECK_NULL_VOID(context);
865 bool result = context->OnBackPressed();
866 if (!result) {
867 auto delegate = EngineHelper::GetCurrentDelegate();
868 CHECK_NULL_VOID(delegate);
869 delegate->Back("");
870 }
871 };
872 gestureEventHub->AddClickEvent(AceType::MakeRefPtr<ClickEvent>(clickCallback));
873 return UpdateBackButtonProperty(backButtonNode);
874 }
875
UpdateBackButtonProperty(const RefPtr<FrameNode> & backButtonNode)876 bool NavigationModelNG::UpdateBackButtonProperty(const RefPtr<FrameNode>& backButtonNode)
877 {
878 auto backButtonLayoutProperty = backButtonNode->GetLayoutProperty<ButtonLayoutProperty>();
879 CHECK_NULL_RETURN(backButtonLayoutProperty, false);
880 auto renderContext = backButtonNode->GetRenderContext();
881 CHECK_NULL_RETURN(renderContext, false);
882 auto backButtonWidth = BACK_BUTTON_SIZE;
883 auto backButtonHeight = BACK_BUTTON_SIZE;
884 auto backButtonRadiusSize = BUTTON_RADIUS_SIZE;
885 auto backButtonPadding = BUTTON_PADDING;
886 auto backButtonColor = Color::TRANSPARENT;
887 auto theme = NavigationGetTheme();
888 CHECK_NULL_RETURN(theme, false);
889 if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
890 backButtonWidth = theme->GetIconBackgroundWidth();
891 backButtonHeight = theme->GetIconBackgroundHeight();
892 backButtonRadiusSize = theme->GetCornerRadius();
893 backButtonPadding = MENU_BUTTON_PADDING;
894 backButtonColor = theme->GetCompBackgroundColor();
895 }
896 backButtonLayoutProperty->UpdateUserDefinedIdealSize(
897 CalcSize(CalcLength(backButtonWidth), CalcLength(backButtonHeight)));
898 backButtonLayoutProperty->UpdateBorderRadius(BorderRadiusProperty(backButtonRadiusSize));
899 renderContext->UpdateBackgroundColor(backButtonColor);
900 PaddingProperty padding;
901 padding.SetEdges(CalcLength(backButtonPadding));
902 backButtonLayoutProperty->UpdatePadding(padding);
903 backButtonLayoutProperty->UpdateType(ButtonType::NORMAL);
904 backButtonLayoutProperty->UpdateMeasureType(MeasureType::MATCH_PARENT);
905 return true;
906 }
907
SetSubtitle(const std::string & subtitle)908 void NavigationModelNG::SetSubtitle(const std::string& subtitle)
909 {
910 ParseCommonTitle(true, false, subtitle, "", true);
911 }
912
SetEnableModeChangeAnimation(bool isEnable)913 void NavigationModelNG::SetEnableModeChangeAnimation(bool isEnable)
914 {
915 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
916 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
917 CHECK_NULL_VOID(navigationGroupNode);
918 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, EnableModeChangeAnimation, isEnable, navigationGroupNode);
919 }
920
SetSplitPlaceholder(const RefPtr<NG::UINode> & splitPlaceholder)921 void NavigationModelNG::SetSplitPlaceholder(const RefPtr<NG::UINode>& splitPlaceholder)
922 {
923 CHECK_NULL_VOID(splitPlaceholder);
924 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
925 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
926 CHECK_NULL_VOID(navigationGroupNode);
927 if (!navigationGroupNode->GetPlaceholderContentNode()) {
928 int32_t placeholderContentNodeId = ElementRegister::GetInstance()->MakeUniqueId();
929 auto placeholderContentNode = FrameNode::GetOrCreateFrameNode(V2::SPLIT_PLACEHOLDER_CONTENT_ETS_TAG,
930 placeholderContentNodeId, []() { return AceType::MakeRefPtr<Pattern>(); });
931 placeholderContentNode->GetLayoutProperty()->UpdateAlignment(Alignment::TOP_LEFT);
932 SafeAreaExpandOpts opts = { .type = SAFE_AREA_TYPE_SYSTEM | SAFE_AREA_TYPE_CUTOUT,
933 .edges = SAFE_AREA_EDGE_ALL };
934 placeholderContentNode->GetLayoutProperty()->UpdateSafeAreaExpandOpts(opts);
935 const auto& eventHub = placeholderContentNode->GetOrCreateEventHub<EventHub>();
936 if (eventHub) {
937 eventHub->SetEnabled(false);
938 }
939 auto focusHub = placeholderContentNode->GetOrCreateFocusHub();
940 if (focusHub) {
941 focusHub->SetFocusable(false);
942 }
943 auto renderContext = placeholderContentNode->GetRenderContext();
944 CHECK_NULL_VOID(renderContext);
945 renderContext->SetClipToBounds(true);
946 renderContext->UpdateZIndex(-1);
947 navigationGroupNode->AddChild(placeholderContentNode);
948 navigationGroupNode->SetPlaceholderContentNode(placeholderContentNode);
949 }
950 navigationGroupNode->SetSplitPlaceholder(splitPlaceholder);
951 }
952
ResetSplitPlaceholder()953 void NavigationModelNG::ResetSplitPlaceholder()
954 {
955 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
956 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
957 CHECK_NULL_VOID(navigationGroupNode);
958 navigationGroupNode->ResetSplitPlaceholder();
959 }
960
SetHideTitleBar(bool hideTitleBar,bool animated)961 void NavigationModelNG::SetHideTitleBar(bool hideTitleBar, bool animated)
962 {
963 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
964 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
965 CHECK_NULL_VOID(navigationGroupNode);
966 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
967 CHECK_NULL_VOID(navBarNode);
968 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
969 CHECK_NULL_VOID(navBarLayoutProperty);
970 navBarLayoutProperty->UpdateHideTitleBar(hideTitleBar);
971 navBarLayoutProperty->UpdateIsAnimatedTitleBar(animated);
972 }
973
SetHideNavBar(bool hideNavBar)974 void NavigationModelNG::SetHideNavBar(bool hideNavBar)
975 {
976 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
977 RefPtr<NavigationGroupNode> navigationGroupNode =
978 Referenced::Claim<NavigationGroupNode>(AceType::DynamicCast<NavigationGroupNode>(frameNode));
979 CHECK_NULL_VOID(navigationGroupNode);
980 SetHideNavBarInner(navigationGroupNode, hideNavBar);
981 }
982
SetEnableToolBarAdaptation(bool enable)983 void NavigationModelNG::SetEnableToolBarAdaptation(bool enable)
984 {
985 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, EnableToolBarAdaptation, enable);
986 }
987
SetBackButtonIcon(const std::function<void (WeakPtr<NG::FrameNode>)> & symbolApply,const std::string & src,const ImageOption & imageOption,RefPtr<PixelMap> & pixMap,const std::vector<std::string> & nameList,bool userDefinedAccessibilityText,const std::string & backButtonAccessibilityText)988 void NavigationModelNG::SetBackButtonIcon(const std::function<void(WeakPtr<NG::FrameNode>)>& symbolApply,
989 const std::string& src, const ImageOption& imageOption, RefPtr<PixelMap>& pixMap,
990 const std::vector<std::string>& nameList, bool userDefinedAccessibilityText,
991 const std::string& backButtonAccessibilityText)
992 {
993 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
994 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
995 CHECK_NULL_VOID(navigationGroupNode);
996
997 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
998 CHECK_NULL_VOID(navBarNode);
999 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
1000 CHECK_NULL_VOID(titleBarNode);
1001 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
1002 CHECK_NULL_VOID(titleBarLayoutProperty);
1003 ImageSourceInfo imageSourceInfo(src, nameList[0], nameList[1]);
1004 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, NoPixMap, imageOption.noPixMap);
1005 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, ImageSource, imageSourceInfo);
1006 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, PixelMap, pixMap);
1007 titleBarLayoutProperty->UpdateImageSource(imageSourceInfo);
1008 titleBarLayoutProperty->UpdateNoPixMap(imageOption.noPixMap);
1009 titleBarLayoutProperty->UpdatePixelMap(pixMap);
1010 titleBarLayoutProperty->SetBackIconSymbol(symbolApply);
1011 titleBarLayoutProperty->UpdateIsValidImage(imageOption.isValidImage);
1012 auto backButtonNode = AceType::DynamicCast<FrameNode>(titleBarNode->GetBackButton());
1013 CHECK_NULL_VOID(backButtonNode);
1014 if (userDefinedAccessibilityText) {
1015 NavigationTitleUtil::SetAccessibility(backButtonNode, backButtonAccessibilityText);
1016 } else {
1017 auto theme = NavigationGetTheme();
1018 std::string message = theme ? theme->GetNavigationBack() : "";
1019 NavigationTitleUtil::SetAccessibility(backButtonNode, message);
1020 }
1021 }
1022
SetBackButtonIcon(const std::function<void (WeakPtr<NG::FrameNode>)> & symbolApply,const RefPtr<ResourceObject> & resObj,const ImageOption & imageOption,RefPtr<PixelMap> & pixMap,const std::vector<std::string> & nameList,bool userDefinedAccessibilityText,const std::string & backButtonAccessibilityText)1023 void NavigationModelNG::SetBackButtonIcon(const std::function<void(WeakPtr<NG::FrameNode>)>& symbolApply,
1024 const RefPtr<ResourceObject>& resObj, const ImageOption& imageOption, RefPtr<PixelMap>& pixMap,
1025 const std::vector<std::string>& nameList, bool userDefinedAccessibilityText,
1026 const std::string& backButtonAccessibilityText)
1027 {
1028 std::string result;
1029 ResourceParseUtils::ParseResMedia(resObj, result);
1030 SetBackButtonIcon(symbolApply, result, imageOption, pixMap, nameList, userDefinedAccessibilityText,
1031 backButtonAccessibilityText);
1032 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1033 CHECK_NULL_VOID(frameNode);
1034 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1035 CHECK_NULL_VOID(navigationGroupNode);
1036 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1037 CHECK_NULL_VOID(navBarNode);
1038 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
1039 CHECK_NULL_VOID(titleBarNode);
1040 std::string key = "navigation.backButtonIcon.icon";
1041 auto updateFunc = [key, nameList, weakTitleBarNode = AceType::WeakClaim(AceType::RawPtr(titleBarNode)),
1042 weakFrameNode = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
1043 auto titleBarNode = weakTitleBarNode.Upgrade();
1044 CHECK_NULL_VOID(titleBarNode);
1045 auto titleBarPattern = titleBarNode->GetPattern();
1046 CHECK_NULL_VOID(titleBarPattern);
1047 std::string result = titleBarPattern->GetResCacheMapByKey(key);
1048 if (result.empty()) {
1049 ResourceParseUtils::ParseResMedia(resObj, result);
1050 titleBarPattern->AddResCache(key, result);
1051 }
1052 ImageSourceInfo imageSourceInfo(result, nameList[0], nameList[1]);
1053 auto frameNode = weakFrameNode.Upgrade();
1054 CHECK_NULL_VOID(frameNode);
1055 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, ImageSource, imageSourceInfo, frameNode);
1056 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
1057 CHECK_NULL_VOID(titleBarLayoutProperty);
1058 titleBarLayoutProperty->UpdateImageSource(imageSourceInfo);
1059 titleBarNode->MarkModifyDone();
1060 titleBarNode->MarkDirtyNode();
1061 };
1062 auto titleBarPattern = titleBarNode->GetPattern();
1063 CHECK_NULL_VOID(titleBarPattern);
1064 titleBarPattern->AddResObj(key, resObj, std::move(updateFunc));
1065 }
1066
SetBackButtonIconSrcAndTextRes(const std::function<void (WeakPtr<NG::FrameNode>)> & symbolApply,const RefPtr<ResourceObject> & backButtonIconResObj,const ImageOption & imageOption,RefPtr<PixelMap> & pixMap,const std::vector<std::string> & nameList,bool userDefinedAccessibilityText,const RefPtr<ResourceObject> & backButtonTextResObj)1067 void NavigationModelNG::SetBackButtonIconSrcAndTextRes(const std::function<void(WeakPtr<NG::FrameNode>)>& symbolApply,
1068 const RefPtr<ResourceObject>& backButtonIconResObj, const ImageOption& imageOption, RefPtr<PixelMap>& pixMap,
1069 const std::vector<std::string>& nameList, bool userDefinedAccessibilityText,
1070 const RefPtr<ResourceObject>& backButtonTextResObj)
1071 {
1072 std::string result;
1073 ResourceParseUtils::ParseResMedia(backButtonIconResObj, result);
1074 std::string backButtonAccessibilityText;
1075 ResourceParseUtils::ParseResMedia(backButtonTextResObj, backButtonAccessibilityText);
1076 SetBackButtonIcon(symbolApply, result, imageOption, pixMap, nameList, true, backButtonAccessibilityText);
1077
1078 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1079 CHECK_NULL_VOID(frameNode);
1080 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1081 CHECK_NULL_VOID(navigationGroupNode);
1082 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1083 CHECK_NULL_VOID(navBarNode);
1084 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
1085 CHECK_NULL_VOID(titleBarNode);
1086 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
1087 CHECK_NULL_VOID(titleBarLayoutProperty);
1088 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
1089 CHECK_NULL_VOID(titleBarPattern);
1090 UpdateBackButtonIcon(nameList, frameNode, backButtonIconResObj);
1091 UpdateBackButtonIconText(userDefinedAccessibilityText, titleBarNode, backButtonTextResObj);
1092 }
1093
UpdateBackButtonIcon(const std::vector<std::string> & nameList,NG::FrameNode * frameNode,const RefPtr<ResourceObject> & backButtonIconResObj)1094 void NavigationModelNG::UpdateBackButtonIcon(const std::vector<std::string>& nameList,
1095 NG::FrameNode* frameNode, const RefPtr<ResourceObject>& backButtonIconResObj)
1096 {
1097 CHECK_NULL_VOID(frameNode);
1098 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1099 CHECK_NULL_VOID(navigationGroupNode);
1100 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1101 CHECK_NULL_VOID(navBarNode);
1102 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
1103 CHECK_NULL_VOID(titleBarNode);
1104 std::string key = "navigation.backButtonIcon.icon";
1105 auto updateFunc = [key, nameList, weakFrameNode = AceType::WeakClaim(frameNode),
1106 weakTitleBarNode = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
1107 const RefPtr<ResourceObject>& backButtonIconResObj) {
1108 auto titleBarNode = weakTitleBarNode.Upgrade();
1109 CHECK_NULL_VOID(titleBarNode);
1110 auto titleBarPattern = titleBarNode->GetPattern();
1111 CHECK_NULL_VOID(titleBarPattern);
1112 std::string result = titleBarPattern->GetResCacheMapByKey(key);
1113 if (result.empty()) {
1114 ResourceParseUtils::ParseResMedia(backButtonIconResObj, result);
1115 titleBarPattern->AddResCache(key, result);
1116 }
1117 ImageSourceInfo imageSourceInfo(result, nameList[0], nameList[1]);
1118 auto frameNode = weakFrameNode.Upgrade();
1119 CHECK_NULL_VOID(frameNode);
1120 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, ImageSource, imageSourceInfo, frameNode);
1121 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
1122 CHECK_NULL_VOID(titleBarLayoutProperty);
1123 titleBarLayoutProperty->UpdateImageSource(imageSourceInfo);
1124 titleBarNode->MarkModifyDone();
1125 titleBarNode->MarkDirtyNode();
1126 };
1127 auto titleBarPattern = titleBarNode->GetPattern();
1128 CHECK_NULL_VOID(titleBarPattern);
1129 titleBarPattern->AddResObj(key, backButtonIconResObj, std::move(updateFunc));
1130 }
1131
UpdateBackButtonIconText(bool userDefinedAccessibilityText,const RefPtr<NG::TitleBarNode> & titleBarNode,const RefPtr<ResourceObject> & backButtonTextResObj)1132 void NavigationModelNG::UpdateBackButtonIconText(bool userDefinedAccessibilityText,
1133 const RefPtr<NG::TitleBarNode>& titleBarNode, const RefPtr<ResourceObject>& backButtonTextResObj)
1134 {
1135 std::string key = "navigation.backButtonIcon.accessibilityText";
1136 auto updateFunc = [key, userDefinedAccessibilityText, weak = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
1137 const RefPtr<ResourceObject>& backButtonTextResObj) {
1138 auto titleBarNode = weak.Upgrade();
1139 CHECK_NULL_VOID(titleBarNode);
1140 auto backButtonNode = AceType::DynamicCast<FrameNode>(titleBarNode->GetBackButton());
1141 CHECK_NULL_VOID(backButtonNode);
1142 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
1143 CHECK_NULL_VOID(titleBarPattern);
1144 std::string backButtonAccessibilityText = titleBarPattern->GetResCacheMapByKey(key);
1145 if (backButtonAccessibilityText.empty()) {
1146 ResourceParseUtils::ParseResString(backButtonTextResObj, backButtonAccessibilityText);
1147 titleBarPattern->AddResCache(key, backButtonAccessibilityText);
1148 }
1149 if (userDefinedAccessibilityText) {
1150 NavigationTitleUtil::SetAccessibility(backButtonNode, backButtonAccessibilityText);
1151 } else {
1152 std::string message = Localization::GetInstance()->GetEntryLetters("navigation.back");
1153 NavigationTitleUtil::SetAccessibility(backButtonNode, message);
1154 }
1155 titleBarNode->MarkModifyDone();
1156 titleBarNode->MarkDirtyNode();
1157 };
1158 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
1159 CHECK_NULL_VOID(titleBarPattern);
1160 titleBarPattern->AddResObj(key, backButtonTextResObj, std::move(updateFunc));
1161 }
1162
SetBackButtonIconTextRes(const std::function<void (WeakPtr<NG::FrameNode>)> & symbolApply,const std::string & src,const ImageOption & imageOption,RefPtr<PixelMap> & pixMap,const std::vector<std::string> & nameList,bool userDefinedAccessibilityText,const RefPtr<ResourceObject> & resObj)1163 void NavigationModelNG::SetBackButtonIconTextRes(const std::function<void(WeakPtr<NG::FrameNode>)>& symbolApply,
1164 const std::string& src, const ImageOption& imageOption, RefPtr<PixelMap>& pixMap,
1165 const std::vector<std::string>& nameList, bool userDefinedAccessibilityText,
1166 const RefPtr<ResourceObject>& resObj)
1167 {
1168 std::string backButtonAccessibilityText;
1169 ResourceParseUtils::ParseResString(resObj, backButtonAccessibilityText);
1170 SetBackButtonIcon(symbolApply, src, imageOption, pixMap, nameList, true, backButtonAccessibilityText);
1171 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1172 CHECK_NULL_VOID(frameNode);
1173 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1174 CHECK_NULL_VOID(navigationGroupNode);
1175 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1176 CHECK_NULL_VOID(navBarNode);
1177 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
1178 CHECK_NULL_VOID(titleBarNode);
1179 std::string key = "navigation.backButtonIcon.accessibilityText";
1180 auto updateFunc = [key, userDefinedAccessibilityText, weak = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
1181 const RefPtr<ResourceObject>& resObj) {
1182 auto titleBarNode = weak.Upgrade();
1183 CHECK_NULL_VOID(titleBarNode);
1184 auto backButtonNode = AceType::DynamicCast<FrameNode>(titleBarNode->GetBackButton());
1185 CHECK_NULL_VOID(backButtonNode);
1186 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
1187 CHECK_NULL_VOID(titleBarPattern);
1188 std::string backButtonAccessibilityText = titleBarPattern->GetResCacheMapByKey(key);
1189 if (backButtonAccessibilityText.empty()) {
1190 ResourceParseUtils::ParseResString(resObj, backButtonAccessibilityText);
1191 titleBarPattern->AddResCache(key, backButtonAccessibilityText);
1192 }
1193 if (userDefinedAccessibilityText) {
1194 NavigationTitleUtil::SetAccessibility(backButtonNode, backButtonAccessibilityText);
1195 } else {
1196 std::string message = Localization::GetInstance()->GetEntryLetters("navigation.back");
1197 NavigationTitleUtil::SetAccessibility(backButtonNode, message);
1198 }
1199 titleBarNode->MarkModifyDone();
1200 titleBarNode->MarkDirtyNode();
1201 };
1202 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
1203 CHECK_NULL_VOID(titleBarPattern);
1204 titleBarPattern->AddResObj(key, resObj, std::move(updateFunc));
1205 }
1206
SetHideBackButton(bool hideBackButton)1207 void NavigationModelNG::SetHideBackButton(bool hideBackButton)
1208 {
1209 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1210 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1211 CHECK_NULL_VOID(navigationGroupNode);
1212 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1213 CHECK_NULL_VOID(navBarNode);
1214 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
1215 CHECK_NULL_VOID(navBarLayoutProperty);
1216 if (!navBarLayoutProperty->HasHideBackButton() ||
1217 (hideBackButton != navBarLayoutProperty->GetHideBackButtonValue())) {
1218 SetNeedResetTitleProperty(AceType::DynamicCast<FrameNode>(navBarNode->GetTitleBarNode()));
1219 }
1220 navBarLayoutProperty->UpdateHideBackButton(hideBackButton);
1221 }
1222
SetHideToolBar(bool hideToolBar,bool animated)1223 void NavigationModelNG::SetHideToolBar(bool hideToolBar, bool animated)
1224 {
1225 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1226 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1227 CHECK_NULL_VOID(navigationGroupNode);
1228 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1229 CHECK_NULL_VOID(navBarNode);
1230 auto navBarLayoutProperty = navBarNode->GetLayoutPropertyPtr<NavBarLayoutProperty>();
1231 CHECK_NULL_VOID(navBarLayoutProperty);
1232 navBarLayoutProperty->UpdateHideToolBar(hideToolBar);
1233 navBarLayoutProperty->UpdateIsAnimatedToolBar(animated);
1234 }
1235
SetCustomToolBar(const RefPtr<AceType> & customNode)1236 void NavigationModelNG::SetCustomToolBar(const RefPtr<AceType>& customNode)
1237 {
1238 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1239 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1240 CHECK_NULL_VOID(navigationGroupNode);
1241 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1242 NavigationToolbarUtil::SetCustomToolBar(navBarNode, customNode);
1243 }
1244
NeedSetItems()1245 bool NavigationModelNG::NeedSetItems()
1246 {
1247 return true;
1248 }
1249
SetToolBarItems(std::vector<NG::BarItem> && toolBarItems)1250 void NavigationModelNG::SetToolBarItems(std::vector<NG::BarItem>&& toolBarItems)
1251 {
1252 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1253 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1254 CHECK_NULL_VOID(navigationGroupNode);
1255 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1256 CHECK_NULL_VOID(navBarNode);
1257 if (navBarNode->GetPrevToolBarIsCustom().value_or(false)) {
1258 navBarNode->UpdateToolBarNodeOperation(ChildNodeOperation::REPLACE);
1259 } else {
1260 if (navBarNode->GetPreToolBarNode() &&
1261 static_cast<int32_t>(navBarNode->GetPreToolBarNode()->GetChildren().size()) != 0) {
1262 UpdateOldBarItems(navBarNode->GetPreToolBarNode(), toolBarItems);
1263 navBarNode->SetToolBarNode(navBarNode->GetPreToolBarNode());
1264 navBarNode->UpdateToolBarNodeOperation(ChildNodeOperation::NONE);
1265 return;
1266 }
1267 navBarNode->UpdateToolBarNodeOperation(ChildNodeOperation::REPLACE);
1268 }
1269 auto toolBarNode = AceType::DynamicCast<NavToolbarNode>(navBarNode->GetPreToolBarNode());
1270 CHECK_NULL_VOID(toolBarNode);
1271 auto rowProperty = toolBarNode->GetLayoutProperty<LinearLayoutProperty>();
1272 CHECK_NULL_VOID(rowProperty);
1273 rowProperty->UpdateMainAxisAlign(FlexAlign::SPACE_EVENLY);
1274 for (const auto& toolBarItem : toolBarItems) {
1275 int32_t barItemNodeId = ElementRegister::GetInstance()->MakeUniqueId();
1276 auto barItemNode = BarItemNode::GetOrCreateBarItemNode(
1277 V2::BAR_ITEM_ETS_TAG, barItemNodeId, []() { return AceType::MakeRefPtr<BarItemPattern>(); });
1278 barItemNode->SetIsHideItemText(toolBarNode->IsHideItemText());
1279 UpdateBarItemNodeWithItem(barItemNode, toolBarItem);
1280 toolBarNode->AddChild(barItemNode);
1281 }
1282 bool hasValidContent = !toolBarNode->GetChildren().empty();
1283 toolBarNode->SetHasValidContent(hasValidContent);
1284 rowProperty->UpdateVisibility(hasValidContent ? VisibleType::VISIBLE : VisibleType::GONE);
1285 navBarNode->SetToolBarNode(toolBarNode);
1286 navBarNode->SetPreToolBarNode(toolBarNode);
1287 navBarNode->UpdatePrevToolBarIsCustom(false);
1288 }
1289
SetToolbarConfiguration(std::vector<NG::BarItem> && toolBarItems,MoreButtonOptions && opt)1290 void NavigationModelNG::SetToolbarConfiguration(std::vector<NG::BarItem>&& toolBarItems, MoreButtonOptions&& opt)
1291 {
1292 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1293 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1294 CHECK_NULL_VOID(navigationGroupNode);
1295 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1296 auto localOpt = opt;
1297 NavigationToolbarUtil::SetToolbarMoreButtonOptions(navBarNode, std::move(opt));
1298 bool enabled = false;
1299 auto hub = navigationGroupNode->GetOrCreateEventHub<EventHub>();
1300 if (hub) {
1301 enabled = hub->IsEnabled();
1302 }
1303 FieldProperty fieldProperty;
1304 fieldProperty.parentId = navigationGroupNode->GetInspectorId().value_or("");
1305 fieldProperty.field = NG::NAV_FIELD;
1306 auto localToolBarItems = toolBarItems;
1307 NavigationToolbarUtil::SetToolbarConfiguration(navBarNode, std::move(toolBarItems), enabled, fieldProperty);
1308 if (!SystemProperties::ConfigChangePerform()) {
1309 return;
1310 }
1311 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
1312 auto updateFunc = [enabled, fieldProperty, weakNavBarNode = AceType::WeakClaim(AceType::RawPtr(navBarNode)),
1313 localToolBarItems, localOpt](const RefPtr<ResourceObject>& resObj) mutable {
1314 auto navBarNode = weakNavBarNode.Upgrade();
1315 CHECK_NULL_VOID(navBarNode);
1316 if (localOpt.bgOptions.blurStyleOption.has_value()) {
1317 localOpt.bgOptions.blurStyleOption->ReloadResources();
1318 }
1319 if (localOpt.bgOptions.effectOption.has_value()) {
1320 localOpt.bgOptions.effectOption->ReloadResources();
1321 }
1322 auto localOptCopy = localOpt;
1323 NavigationToolbarUtil::SetToolbarMoreButtonOptions(navBarNode, std::move(localOptCopy));
1324 for (auto& item : localToolBarItems) {
1325 item.ReloadResources();
1326 }
1327 auto toolBarItemCopy = localToolBarItems;
1328 NavigationToolbarUtil::SetToolbarConfiguration(navBarNode, std::move(toolBarItemCopy), enabled, fieldProperty);
1329 navBarNode->MarkModifyDone();
1330 navBarNode->MarkDirtyNode();
1331 };
1332 auto pattern = navBarNode->GetPattern();
1333 CHECK_NULL_VOID(pattern);
1334 pattern->AddResObj("navigation.toolbarConfiguration", resObj, std::move(updateFunc));
1335 }
1336
SetToolbarConfiguration(std::vector<NG::BarItem> && toolBarItems)1337 void NavigationModelNG::SetToolbarConfiguration(std::vector<NG::BarItem>&& toolBarItems)
1338 {
1339 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1340 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1341 CHECK_NULL_VOID(navigationGroupNode);
1342 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1343 bool enabled = false;
1344 auto hub = navigationGroupNode->GetOrCreateEventHub<EventHub>();
1345 if (hub) {
1346 enabled = hub->IsEnabled();
1347 }
1348 FieldProperty fieldProperty;
1349 fieldProperty.parentId = navigationGroupNode->GetInspectorId().value_or("");
1350 fieldProperty.field = NG::NAV_FIELD;
1351 NavigationToolbarUtil::SetToolbarConfiguration(navBarNode, std::move(toolBarItems), enabled, fieldProperty);
1352 }
1353
SetMenuItems(std::vector<NG::BarItem> && menuItems)1354 void NavigationModelNG::SetMenuItems(std::vector<NG::BarItem>&& menuItems)
1355 {
1356 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1357 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1358 CHECK_NULL_VOID(navigationGroupNode);
1359 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1360 CHECK_NULL_VOID(navBarNode);
1361 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
1362 CHECK_NULL_VOID(titleBarNode);
1363 // if previous menu is custom, just remove it and create new menu, otherwise update old menu
1364 if (navBarNode->GetPrevMenuIsCustom().value_or(false)) {
1365 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::REPLACE);
1366 } else {
1367 if (navBarNode->GetMenu()) {
1368 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::REPLACE);
1369 } else {
1370 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::ADD);
1371 }
1372 }
1373 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
1374 CHECK_NULL_VOID(navBarPattern);
1375 navBarPattern->SetTitleBarMenuItems(menuItems);
1376 navBarPattern->SetMenuNodeId(ElementRegister::GetInstance()->MakeUniqueId());
1377 navBarPattern->SetLandscapeMenuNodeId(ElementRegister::GetInstance()->MakeUniqueId());
1378 navBarNode->UpdatePrevMenuIsCustom(false);
1379 if (!SystemProperties::ConfigChangePerform()) {
1380 return;
1381 }
1382 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
1383 auto updateFunc = [wekNavBarNode = AceType::WeakClaim(AceType::RawPtr(navBarNode)), menuItems](
1384 const RefPtr<ResourceObject>& resObj) mutable {
1385 for (BarItem& item : menuItems) {
1386 item.ReloadResources();
1387 }
1388 auto navBarNode = wekNavBarNode.Upgrade();
1389 CHECK_NULL_VOID(navBarNode);
1390 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
1391 CHECK_NULL_VOID(navBarPattern);
1392 navBarPattern->SetTitleBarMenuItems(menuItems);
1393 navBarNode->MarkModifyDone();
1394 navBarNode->MarkDirtyNode();
1395 };
1396 navBarPattern->AddResObj("navigation.menuItems", resObj, std::move(updateFunc));
1397 }
1398
SetCustomMenu(const RefPtr<AceType> & customNode)1399 void NavigationModelNG::SetCustomMenu(const RefPtr<AceType>& customNode)
1400 {
1401 auto customMenu = AceType::DynamicCast<NG::UINode>(customNode);
1402 CHECK_NULL_VOID(customMenu);
1403 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1404 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1405 CHECK_NULL_VOID(navigationGroupNode);
1406 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1407 CHECK_NULL_VOID(navBarNode);
1408 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
1409 CHECK_NULL_VOID(titleBarNode);
1410 // if previous menu exists, remove it if their ids are not the same
1411 // if previous node is not custom, their ids must not be the same
1412 if (navBarNode->GetMenu()) {
1413 if (customMenu->GetId() == navBarNode->GetMenu()->GetId()) {
1414 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::NONE);
1415 return;
1416 }
1417 navBarNode->SetMenu(customMenu);
1418 navBarNode->UpdatePrevMenuIsCustom(true);
1419 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::REPLACE);
1420 return;
1421 }
1422 navBarNode->SetMenu(customMenu);
1423 navBarNode->UpdatePrevMenuIsCustom(true);
1424 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::ADD);
1425 }
1426
SetOnTitleModeChange(std::function<void (NG::NavigationTitleMode)> && onTitleModeChange,std::function<void (const BaseEventInfo * baseInfo)> && eventInfo)1427 void NavigationModelNG::SetOnTitleModeChange(std::function<void(NG::NavigationTitleMode)>&& onTitleModeChange,
1428 std::function<void(const BaseEventInfo* baseInfo)>&& eventInfo)
1429 {
1430 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1431 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1432 CHECK_NULL_VOID(navigationGroupNode);
1433 auto eventHub = navigationGroupNode->GetOrCreateEventHub<NavigationEventHub>();
1434 CHECK_NULL_VOID(eventHub);
1435 eventHub->SetOnTitleModeChange(std::move(eventInfo));
1436 }
1437
SetOnNavBarWidthChangeEvent(OnNavBarWidthChangeEvent event)1438 void NavigationModelNG::SetOnNavBarWidthChangeEvent(OnNavBarWidthChangeEvent event)
1439 {
1440 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1441 CHECK_NULL_VOID(frameNode);
1442 auto eventHub = frameNode->GetOrCreateEventHub<NavigationEventHub>();
1443 CHECK_NULL_VOID(eventHub);
1444 eventHub->SetOnNavBarWidthChangeEvent(std::move(event));
1445 }
1446
SetUsrNavigationMode(NavigationMode mode)1447 void NavigationModelNG::SetUsrNavigationMode(NavigationMode mode)
1448 {
1449 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, UsrNavigationMode, mode);
1450 SetToolbarNavigationMode(mode);
1451 }
1452
SetToolbarNavigationMode(NavigationMode mode)1453 void NavigationModelNG::SetToolbarNavigationMode(NavigationMode mode)
1454 {
1455 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1456 CHECK_NULL_VOID(frameNode);
1457 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1458 CHECK_NULL_VOID(navigationGroupNode);
1459 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1460 CHECK_NULL_VOID(pattern);
1461 pattern->SetToolbarManagerNavigationMode(mode);
1462 }
1463
SetNavBarPosition(NG::NavBarPosition mode)1464 void NavigationModelNG::SetNavBarPosition(NG::NavBarPosition mode)
1465 {
1466 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, NavBarPosition, static_cast<NG::NavBarPosition>(mode));
1467 }
1468
SetNavBarWidth(const Dimension & value,bool isDoubleBind)1469 void NavigationModelNG::SetNavBarWidth(const Dimension& value, bool isDoubleBind)
1470 {
1471 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, NavBarWidth, value);
1472 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1473 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1474 CHECK_NULL_VOID(navigationGroupNode);
1475 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1476 CHECK_NULL_VOID(navigationPattern);
1477 navBarWidthDoubleBind_ = isDoubleBind;
1478 if (IsDoubleBindBlock(navigationPattern)) {
1479 return;
1480 }
1481 navigationPattern->SetUserSetNavBarWidthFlag(true);
1482 if (navigationPattern->GetInitNavBarWidth() != value) {
1483 navigationPattern->SetInitNavBarWidth(value);
1484 }
1485 }
1486
SetNavBarWidth(const RefPtr<ResourceObject> & navBarWidthResObj)1487 void NavigationModelNG::SetNavBarWidth(const RefPtr<ResourceObject>& navBarWidthResObj)
1488 {
1489 CalcDimension navBarWidth;
1490 ResourceParseUtils::ParseResDimensionVpNG(navBarWidthResObj, navBarWidth);
1491 if (navBarWidth.Value() <= 0) {
1492 navBarWidth.SetValue(DEFAULT_NAV_BAR_WIDTH_VALUE);
1493 }
1494 SetNavBarWidth(navBarWidth, false);
1495 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1496 CHECK_NULL_VOID(frameNode);
1497 std::string key = "navigation.navBarWidth";
1498 auto updateNavBarWidthFunc = [key, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
1499 auto frameNode = weak.Upgrade();
1500 CHECK_NULL_VOID(frameNode);
1501 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1502 CHECK_NULL_VOID(navigationGroupNode);
1503 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1504 CHECK_NULL_VOID(navigationPattern);
1505 CalcDimension navBarWidth;
1506 std::string navBarWidthString = navigationPattern->GetResCacheMapByKey(key);
1507 if (navBarWidthString.empty()) {
1508 ResourceParseUtils::ParseResDimensionVpNG(resObj, navBarWidth);
1509 navigationPattern->AddResCache(key, navBarWidth.ToString());
1510 } else {
1511 navBarWidth = StringUtils::StringToCalcDimension(navBarWidthString);
1512 }
1513 if (navBarWidth.Value() <= 0) {
1514 navBarWidth.SetValue(DEFAULT_NAV_BAR_WIDTH_VALUE);
1515 }
1516 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, NavBarWidth, navBarWidth, frameNode);
1517 navigationPattern->SetUserSetNavBarWidthFlag(true);
1518 if (navigationPattern->GetInitNavBarWidth() != navBarWidth) {
1519 navigationPattern->SetInitNavBarWidth(navBarWidth);
1520 }
1521 navigationGroupNode->MarkModifyDone();
1522 navigationGroupNode->MarkDirtyNode();
1523 };
1524 auto pattern = frameNode->GetPattern<NavigationPattern>();
1525 CHECK_NULL_VOID(pattern);
1526 pattern->AddResObj(key, navBarWidthResObj, std::move(updateNavBarWidthFunc));
1527 }
1528
SetMinNavBarWidth(const Dimension & value)1529 void NavigationModelNG::SetMinNavBarWidth(const Dimension& value)
1530 {
1531 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1532 CHECK_NULL_VOID(frameNode);
1533 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1534 CHECK_NULL_VOID(navigationGroupNode);
1535 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1536 CHECK_NULL_VOID(navigationPattern);
1537 if (IsDoubleBindBlock(navigationPattern)) {
1538 return;
1539 }
1540 navigationPattern->SetIfNeedInit(true);
1541 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, MinNavBarWidth, value);
1542 }
1543
SetMinNavBarWidth(const RefPtr<ResourceObject> & minNavBarWidthResObj)1544 void NavigationModelNG::SetMinNavBarWidth(const RefPtr<ResourceObject>& minNavBarWidthResObj)
1545 {
1546 CalcDimension minNavBarWidth;
1547 ResourceParseUtils::ParseResDimensionVpNG(minNavBarWidthResObj, minNavBarWidth);
1548 if (LessNotEqual(minNavBarWidth.Value(), 0.0)) {
1549 minNavBarWidth.SetValue(0);
1550 }
1551 SetMinNavBarWidth(minNavBarWidth);
1552 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1553 CHECK_NULL_VOID(frameNode);
1554 std::string key = "navigation.navBarWidthRange.minNavBarWidth";
1555 auto updateMinNavBarWidthFunc = [key, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
1556 auto frameNode = weak.Upgrade();
1557 CHECK_NULL_VOID(frameNode);
1558 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1559 CHECK_NULL_VOID(navigationGroupNode);
1560 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1561 CHECK_NULL_VOID(navigationPattern);
1562 CalcDimension minNavBarWidth;
1563 std::string minNavBarWidthString = navigationPattern->GetResCacheMapByKey(key);
1564 if (minNavBarWidthString.empty()) {
1565 ResourceParseUtils::ParseResDimensionVpNG(resObj, minNavBarWidth);
1566 navigationPattern->AddResCache(key, minNavBarWidth.ToString());
1567 } else {
1568 minNavBarWidth = StringUtils::StringToCalcDimension(minNavBarWidthString);
1569 }
1570 if (LessNotEqual(minNavBarWidth.Value(), 0.0)) {
1571 minNavBarWidth.SetValue(0);
1572 }
1573 navigationPattern->SetIfNeedInit(true);
1574 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MinNavBarWidth, minNavBarWidth, frameNode);
1575 navigationGroupNode->MarkModifyDone();
1576 navigationGroupNode->MarkDirtyNode();
1577 };
1578 auto pattern = frameNode->GetPattern<NavigationPattern>();
1579 CHECK_NULL_VOID(pattern);
1580 pattern->AddResObj(key, minNavBarWidthResObj, std::move(updateMinNavBarWidthFunc));
1581 }
1582
SetMaxNavBarWidth(const Dimension & value)1583 void NavigationModelNG::SetMaxNavBarWidth(const Dimension& value)
1584 {
1585 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1586 CHECK_NULL_VOID(frameNode);
1587 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1588 CHECK_NULL_VOID(navigationGroupNode);
1589 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1590 CHECK_NULL_VOID(navigationPattern);
1591 if (IsDoubleBindBlock(navigationPattern)) {
1592 return;
1593 }
1594 navigationPattern->SetIfNeedInit(true);
1595 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, MaxNavBarWidth, value);
1596 }
1597
SetMaxNavBarWidth(const RefPtr<ResourceObject> & maxNavBarWidthResObj)1598 void NavigationModelNG::SetMaxNavBarWidth(const RefPtr<ResourceObject>& maxNavBarWidthResObj)
1599 {
1600 CalcDimension maxNavBarWidth;
1601 ResourceParseUtils::ParseResDimensionVpNG(maxNavBarWidthResObj, maxNavBarWidth);
1602 if (LessNotEqual(maxNavBarWidth.Value(), 0.0)) {
1603 maxNavBarWidth.SetValue(0);
1604 }
1605 SetMaxNavBarWidth(maxNavBarWidth);
1606 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1607 CHECK_NULL_VOID(frameNode);
1608 std::string key = "navigation.navBarWidthRange.maxNavBarWidth";
1609 auto updateMaxNavBarWidthFunc = [key, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
1610 auto frameNode = weak.Upgrade();
1611 CHECK_NULL_VOID(frameNode);
1612 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1613 CHECK_NULL_VOID(navigationGroupNode);
1614 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1615 CHECK_NULL_VOID(navigationPattern);
1616 CalcDimension maxNavBarWidth;
1617 std::string maxNavBarWidthString = navigationPattern->GetResCacheMapByKey(key);
1618 if (maxNavBarWidthString.empty()) {
1619 ResourceParseUtils::ParseResDimensionVpNG(resObj, maxNavBarWidth);
1620 navigationPattern->AddResCache(key, maxNavBarWidth.ToString());
1621 } else {
1622 maxNavBarWidth = StringUtils::StringToCalcDimension(maxNavBarWidthString);
1623 }
1624 if (LessNotEqual(maxNavBarWidth.Value(), 0.0)) {
1625 maxNavBarWidth.SetValue(0);
1626 }
1627 navigationPattern->SetIfNeedInit(true);
1628 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MaxNavBarWidth, maxNavBarWidth, frameNode);
1629 navigationGroupNode->MarkModifyDone();
1630 navigationGroupNode->MarkDirtyNode();
1631 };
1632 auto pattern = frameNode->GetPattern<NavigationPattern>();
1633 CHECK_NULL_VOID(pattern);
1634 pattern->AddResObj(key, maxNavBarWidthResObj, std::move(updateMaxNavBarWidthFunc));
1635 }
1636
SetMinContentWidth(const Dimension & value)1637 void NavigationModelNG::SetMinContentWidth(const Dimension& value)
1638 {
1639 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1640 CHECK_NULL_VOID(frameNode);
1641 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1642 CHECK_NULL_VOID(navigationGroupNode);
1643 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1644 CHECK_NULL_VOID(navigationPattern);
1645 navigationPattern->SetIfNeedInit(true);
1646 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, MinContentWidth, value);
1647 }
1648
SetMinContentWidth(const RefPtr<ResourceObject> & minContentWidthResObj)1649 void NavigationModelNG::SetMinContentWidth(const RefPtr<ResourceObject>& minContentWidthResObj)
1650 {
1651 CalcDimension minContentWidth;
1652 ResourceParseUtils::ParseResDimensionVpNG(minContentWidthResObj, minContentWidth);
1653 if (LessNotEqual(minContentWidth.Value(), 0.0)) {
1654 minContentWidth = DEFAULT_MIN_CONTENT_WIDTH;
1655 }
1656 SetMinContentWidth(minContentWidth);
1657 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1658 CHECK_NULL_VOID(frameNode);
1659 std::string key = "navigation.minContentWidth";
1660 auto updateMinContentWidthFunc = [key, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
1661 auto frameNode = weak.Upgrade();
1662 CHECK_NULL_VOID(frameNode);
1663 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1664 CHECK_NULL_VOID(navigationGroupNode);
1665 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1666 CHECK_NULL_VOID(navigationPattern);
1667 CalcDimension minContentWidth;
1668 std::string minContentWidthString = navigationPattern->GetResCacheMapByKey(key);
1669 if (minContentWidthString.empty()) {
1670 ResourceParseUtils::ParseResDimensionVpNG(resObj, minContentWidth);
1671 navigationPattern->AddResCache(key, minContentWidth.ToString());
1672 } else {
1673 minContentWidth = StringUtils::StringToCalcDimension(minContentWidthString);
1674 }
1675 if (LessNotEqual(minContentWidth.Value(), 0.0)) {
1676 minContentWidth = DEFAULT_MIN_CONTENT_WIDTH;
1677 }
1678 navigationPattern->SetIfNeedInit(true);
1679 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MinContentWidth, minContentWidth, frameNode);
1680 navigationGroupNode->MarkModifyDone();
1681 navigationGroupNode->MarkDirtyNode();
1682 };
1683 auto pattern = frameNode->GetPattern<NavigationPattern>();
1684 CHECK_NULL_VOID(pattern);
1685 pattern->AddResObj(key, minContentWidthResObj, std::move(updateMinContentWidthFunc));
1686 }
1687
SetOnNavBarStateChange(std::function<void (bool)> && onNavBarStateChange)1688 void NavigationModelNG::SetOnNavBarStateChange(std::function<void(bool)>&& onNavBarStateChange)
1689 {
1690 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1691 CHECK_NULL_VOID(frameNode);
1692 auto navigationEventHub = AceType::DynamicCast<NavigationEventHub>(frameNode->GetOrCreateEventHub<EventHub>());
1693 CHECK_NULL_VOID(navigationEventHub);
1694 navigationEventHub->SetOnNavBarStateChange(std::move(onNavBarStateChange));
1695 }
1696
SetOnNavigationModeChange(std::function<void (NavigationMode)> && modeChange)1697 void NavigationModelNG::SetOnNavigationModeChange(std::function<void(NavigationMode)>&& modeChange)
1698 {
1699 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1700 CHECK_NULL_VOID(frameNode);
1701 auto navigationEventHub = AceType::DynamicCast<NavigationEventHub>(frameNode->GetOrCreateEventHub<EventHub>());
1702 CHECK_NULL_VOID(navigationEventHub);
1703 navigationEventHub->SetOnNavigationModeChange(std::move(modeChange));
1704 }
1705
SetNavigationMode(NavigationMode mode)1706 void NavigationModelNG::SetNavigationMode(NavigationMode mode)
1707 {
1708 ACE_UPDATE_LAYOUT_PROPERTY(NavigationLayoutProperty, NavigationMode, mode);
1709 SetToolbarNavigationMode(mode);
1710 }
1711
SetNavigationStack(const RefPtr<NG::NavigationStack> & navigationStack)1712 void NavigationModelNG::SetNavigationStack(const RefPtr<NG::NavigationStack>& navigationStack)
1713 {
1714 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1715 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1716 CHECK_NULL_VOID(navigationGroupNode);
1717 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1718 CHECK_NULL_VOID(pattern);
1719 const auto& stack = pattern->GetNavigationStack();
1720 if (stack) {
1721 stack->UpdateStackInfo(navigationStack);
1722 } else {
1723 pattern->SetNavigationStack(navigationStack);
1724 }
1725 }
1726
SetNavigationStackWithCreatorAndUpdater(std::function<RefPtr<NG::NavigationStack> ()> creator,std::function<void (RefPtr<NG::NavigationStack>)> updater)1727 void NavigationModelNG::SetNavigationStackWithCreatorAndUpdater(
1728 std::function<RefPtr<NG::NavigationStack>()> creator, std::function<void(RefPtr<NG::NavigationStack>)> updater)
1729 {
1730 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1731 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1732 CHECK_NULL_VOID(navigationGroupNode);
1733 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1734 CHECK_NULL_VOID(pattern);
1735 RefPtr<NavigationStack> stack = pattern->GetNavigationStack();
1736 if (!stack) {
1737 stack = creator();
1738 pattern->SetNavigationStack(stack);
1739 }
1740 updater(stack);
1741 }
1742
UseHomeDestination() const1743 bool NavigationModelNG::UseHomeDestination() const
1744 {
1745 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1746 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1747 CHECK_NULL_RETURN(navigationGroupNode, false);
1748 auto useHomeDest = navigationGroupNode->GetUseHomeDestination();
1749 return useHomeDest.has_value() && useHomeDest.value();
1750 }
1751
SetHomePathInfoWithCallback(std::function<void (const RefPtr<NavigationStack> &)> && setHomePathInfoCallback)1752 void NavigationModelNG::SetHomePathInfoWithCallback(
1753 std::function<void(const RefPtr<NavigationStack>&)>&& setHomePathInfoCallback)
1754 {
1755 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1756 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1757 CHECK_NULL_VOID(navigationGroupNode);
1758 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1759 CHECK_NULL_VOID(pattern);
1760 auto stack = pattern->GetNavigationStack();
1761 if (setHomePathInfoCallback) {
1762 setHomePathInfoCallback(stack);
1763 }
1764 }
1765
SetNavigationStack()1766 void NavigationModelNG::SetNavigationStack()
1767 {
1768 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1769 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1770 CHECK_NULL_VOID(navigationGroupNode);
1771 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1772 CHECK_NULL_VOID(pattern);
1773 auto navigationStack = pattern->GetNavigationStack();
1774 if (!navigationStack) {
1775 auto navigationStack = AceType::MakeRefPtr<NavigationStack>();
1776 pattern->SetNavigationStack(navigationStack);
1777 }
1778 }
1779
SetNavigationPathInfo(const std::string & moduleName,const std::string & pagePath)1780 void NavigationModelNG::SetNavigationPathInfo(const std::string& moduleName, const std::string& pagePath)
1781 {
1782 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1783 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1784 CHECK_NULL_VOID(navigationGroupNode);
1785 navigationGroupNode->SetNavigationPathInfo(moduleName, pagePath);
1786 }
1787
SetNavigationStackProvided(bool provided)1788 void NavigationModelNG::SetNavigationStackProvided(bool provided)
1789 {
1790 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1791 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1792 CHECK_NULL_VOID(navigationGroupNode);
1793 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1794 CHECK_NULL_VOID(pattern);
1795 pattern->SetNavigationStackProvided(provided);
1796 }
1797
SetNavDestination(std::function<void (std::string)> && builder)1798 void NavigationModelNG::SetNavDestination(std::function<void(std::string)>&& builder)
1799 {
1800 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1801 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1802 CHECK_NULL_VOID(navigationGroupNode);
1803 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1804 CHECK_NULL_VOID(pattern);
1805 pattern->SetNavDestination(std::move(builder));
1806 }
1807
GetNavigationStack()1808 RefPtr<NG::NavigationStack> NavigationModelNG::GetNavigationStack()
1809 {
1810 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1811 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1812 CHECK_NULL_RETURN(navigationGroupNode, nullptr);
1813 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1814 CHECK_NULL_RETURN(pattern, nullptr);
1815 return pattern->GetNavigationStack();
1816 }
1817
GetNavigationStack(FrameNode * frameNode)1818 RefPtr<NG::NavigationStack> NavigationModelNG::GetNavigationStack(FrameNode* frameNode)
1819 {
1820 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1821 CHECK_NULL_RETURN(navigationGroupNode, nullptr);
1822 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1823 CHECK_NULL_RETURN(pattern, nullptr);
1824 return pattern->GetNavigationStack();
1825 }
1826
SetMenuCount(int32_t menuCount)1827 void NavigationModelNG::SetMenuCount(int32_t menuCount)
1828 {
1829 return;
1830 }
1831
SetOnTitleModeChange(FrameNode * frameNode,std::function<void (NG::NavigationTitleMode)> && onTitleModeChange,std::function<void (const BaseEventInfo * baseInfo)> && eventInfo)1832 void NavigationModelNG::SetOnTitleModeChange(FrameNode* frameNode,
1833 std::function<void(NG::NavigationTitleMode)>&& onTitleModeChange,
1834 std::function<void(const BaseEventInfo* baseInfo)>&& eventInfo)
1835 {
1836 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1837 CHECK_NULL_VOID(navigationGroupNode);
1838 auto eventHub = navigationGroupNode->GetEventHub<NavigationEventHub>();
1839 CHECK_NULL_VOID(eventHub);
1840 eventHub->SetOnTitleModeChange(std::move(eventInfo));
1841 }
1842
SetOnNavigationModeChange(FrameNode * frameNode,std::function<void (NavigationMode)> && modeChange)1843 void NavigationModelNG::SetOnNavigationModeChange(FrameNode* frameNode,
1844 std::function<void(NavigationMode)>&& modeChange)
1845 {
1846 auto navigationEventHub = AceType::DynamicCast<NavigationEventHub>(frameNode->GetEventHub<EventHub>());
1847 CHECK_NULL_VOID(navigationEventHub);
1848 navigationEventHub->SetOnNavigationModeChange(std::move(modeChange));
1849 }
1850
SetIsCustomAnimation(FrameNode * frameNode,bool isCustom)1851 void NavigationModelNG::SetIsCustomAnimation(FrameNode* frameNode, bool isCustom)
1852 {
1853 CHECK_NULL_VOID(frameNode);
1854 auto pattern = frameNode->GetPattern<NavigationPattern>();
1855 CHECK_NULL_VOID(pattern);
1856 pattern->SetIsCustomAnimation(isCustom);
1857 }
1858
SetToolBarItems(FrameNode * frameNode,std::vector<NG::BarItem> && toolBarItems)1859 void NavigationModelNG::SetToolBarItems(FrameNode* frameNode, std::vector<NG::BarItem>&& toolBarItems)
1860 {
1861 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1862 CHECK_NULL_VOID(navigationGroupNode);
1863 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1864 CHECK_NULL_VOID(navBarNode);
1865 if (navBarNode->GetPrevToolBarIsCustom().value_or(false)) {
1866 navBarNode->UpdateToolBarNodeOperation(ChildNodeOperation::REPLACE);
1867 } else {
1868 if (navBarNode->GetPreToolBarNode() &&
1869 static_cast<int32_t>(navBarNode->GetPreToolBarNode()->GetChildren().size()) != 0) {
1870 UpdateOldBarItems(navBarNode->GetPreToolBarNode(), toolBarItems);
1871 navBarNode->SetToolBarNode(navBarNode->GetPreToolBarNode());
1872 navBarNode->UpdateToolBarNodeOperation(ChildNodeOperation::NONE);
1873 return;
1874 }
1875 navBarNode->UpdateToolBarNodeOperation(ChildNodeOperation::REPLACE);
1876 }
1877 auto toolBarNode = AceType::DynamicCast<NavToolbarNode>(navBarNode->GetPreToolBarNode());
1878 CHECK_NULL_VOID(toolBarNode);
1879 auto rowProperty = toolBarNode->GetLayoutProperty<LinearLayoutProperty>();
1880 CHECK_NULL_VOID(rowProperty);
1881 rowProperty->UpdateMainAxisAlign(FlexAlign::SPACE_EVENLY);
1882 for (const auto& toolBarItem : toolBarItems) {
1883 int32_t barItemNodeId = ElementRegister::GetInstance()->MakeUniqueId();
1884 auto barItemNode = BarItemNode::GetOrCreateBarItemNode(
1885 V2::BAR_ITEM_ETS_TAG, barItemNodeId, []() { return AceType::MakeRefPtr<BarItemPattern>(); });
1886 barItemNode->SetIsHideItemText(toolBarNode->IsHideItemText());
1887 UpdateBarItemNodeWithItem(barItemNode, toolBarItem);
1888 toolBarNode->AddChild(barItemNode);
1889 }
1890 bool hasValidContent = !toolBarNode->GetChildren().empty();
1891 toolBarNode->SetHasValidContent(hasValidContent);
1892 rowProperty->UpdateVisibility(hasValidContent ? VisibleType::VISIBLE : VisibleType::GONE);
1893 navBarNode->SetToolBarNode(toolBarNode);
1894 navBarNode->SetPreToolBarNode(toolBarNode);
1895 navBarNode->UpdatePrevToolBarIsCustom(false);
1896 }
1897
SetOnNavBarStateChange(FrameNode * frameNode,std::function<void (bool)> && onNavBarStateChange)1898 void NavigationModelNG::SetOnNavBarStateChange(FrameNode* frameNode, std::function<void(bool)>&& onNavBarStateChange)
1899 {
1900 CHECK_NULL_VOID(frameNode);
1901 auto navigationEventHub = AceType::DynamicCast<NavigationEventHub>(frameNode->GetEventHub<EventHub>());
1902 CHECK_NULL_VOID(navigationEventHub);
1903 navigationEventHub->SetOnNavBarStateChange(std::move(onNavBarStateChange));
1904 }
1905
SetHideToolBar(FrameNode * frameNode,bool hideToolBar,bool animated)1906 void NavigationModelNG::SetHideToolBar(FrameNode* frameNode, bool hideToolBar, bool animated)
1907 {
1908 CHECK_NULL_VOID(frameNode);
1909 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1910 CHECK_NULL_VOID(navigationGroupNode);
1911 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1912 CHECK_NULL_VOID(navBarNode);
1913 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
1914 CHECK_NULL_VOID(navBarLayoutProperty);
1915 navBarLayoutProperty->UpdateHideToolBar(hideToolBar);
1916 navBarLayoutProperty->UpdateIsAnimatedToolBar(animated);
1917 }
1918
ResetResObj(FrameNode * frameNode,NavigationPatternType type,const std::string & key)1919 void NavigationModelNG::ResetResObj(FrameNode* frameNode, NavigationPatternType type, const std::string& key)
1920 {
1921 if (!SystemProperties::ConfigChangePerform()) {
1922 return;
1923 }
1924 CHECK_NULL_VOID(frameNode);
1925 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1926 CHECK_NULL_VOID(navigationGroupNode);
1927 RefPtr<Pattern> pattern = nullptr;
1928 if (type == NavigationPatternType::NAV_BAR) {
1929 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1930 CHECK_NULL_VOID(navBarNode);
1931 pattern = navBarNode->GetPattern<NavBarPattern>();
1932 } else if (type == NavigationPatternType::TITLE_BAR) {
1933 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
1934 CHECK_NULL_VOID(navBarNode);
1935 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
1936 CHECK_NULL_VOID(titleBarNode);
1937 pattern = titleBarNode->GetPattern<TitleBarPattern>();
1938 } else if (type == NavigationPatternType::NAVIGATION) {
1939 pattern = navigationGroupNode->GetPattern<NavigationPattern>();
1940 }
1941 CHECK_NULL_VOID(pattern);
1942 pattern->RemoveResObj(key);
1943 }
1944
SetMinContentWidth(FrameNode * frameNode,const Dimension & value)1945 void NavigationModelNG::SetMinContentWidth(FrameNode* frameNode, const Dimension& value)
1946 {
1947 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1948 CHECK_NULL_VOID(navigationGroupNode);
1949 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1950 CHECK_NULL_VOID(navigationPattern);
1951 navigationPattern->SetIfNeedInit(true);
1952 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MinContentWidth, value, frameNode);
1953 }
1954
SetMinContentWidth(FrameNode * frameNode,const RefPtr<ResourceObject> & minContentWidthResObj)1955 void NavigationModelNG::SetMinContentWidth(FrameNode* frameNode, const RefPtr<ResourceObject>& minContentWidthResObj)
1956 {
1957 CHECK_NULL_VOID(frameNode);
1958 CalcDimension minContentWidth;
1959 ResourceParseUtils::ParseResDimensionVpNG(minContentWidthResObj, minContentWidth);
1960 if (LessNotEqual(minContentWidth.Value(), 0.0)) {
1961 minContentWidth = DEFAULT_MIN_CONTENT_WIDTH;
1962 }
1963 SetMinContentWidth(frameNode, minContentWidth);
1964 std::string key = "navigation.minContentWidth";
1965 auto updateMinContentWidthFunc = [key, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
1966 auto frameNode = weak.Upgrade();
1967 CHECK_NULL_VOID(frameNode);
1968 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1969 CHECK_NULL_VOID(navigationGroupNode);
1970 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1971 CHECK_NULL_VOID(navigationPattern);
1972 CalcDimension minContentWidth;
1973 std::string minContentWidthString = navigationPattern->GetResCacheMapByKey(key);
1974 if (minContentWidthString.empty()) {
1975 ResourceParseUtils::ParseResDimensionVpNG(resObj, minContentWidth);
1976 navigationPattern->AddResCache(key, minContentWidth.ToString());
1977 } else {
1978 minContentWidth = StringUtils::StringToCalcDimension(minContentWidthString);
1979 }
1980 if (LessNotEqual(minContentWidth.Value(), 0.0)) {
1981 minContentWidth = DEFAULT_MIN_CONTENT_WIDTH;
1982 }
1983 navigationPattern->SetIfNeedInit(true);
1984 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MinContentWidth, minContentWidth, frameNode);
1985 navigationGroupNode->MarkModifyDone();
1986 navigationGroupNode->MarkDirtyNode();
1987 };
1988 auto pattern = frameNode->GetPattern<NavigationPattern>();
1989 CHECK_NULL_VOID(pattern);
1990 pattern->AddResObj(key, minContentWidthResObj, std::move(updateMinContentWidthFunc));
1991 }
1992
SetMinNavBarWidth(FrameNode * frameNode,const Dimension & value)1993 void NavigationModelNG::SetMinNavBarWidth(FrameNode* frameNode, const Dimension& value)
1994 {
1995 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
1996 CHECK_NULL_VOID(navigationGroupNode);
1997 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
1998 CHECK_NULL_VOID(navigationPattern);
1999 if (IsDoubleBindBlock(navigationPattern)) {
2000 return;
2001 }
2002 navigationPattern->SetIfNeedInit(true);
2003 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MinNavBarWidth, value, frameNode);
2004 }
2005
SetMinNavBarWidth(FrameNode * frameNode,const RefPtr<ResourceObject> & minNavBarWidthResObj)2006 void NavigationModelNG::SetMinNavBarWidth(FrameNode* frameNode, const RefPtr<ResourceObject>& minNavBarWidthResObj)
2007 {
2008 CHECK_NULL_VOID(frameNode);
2009 CalcDimension minNavBarWidth;
2010 ResourceParseUtils::ParseResDimensionVpNG(minNavBarWidthResObj, minNavBarWidth);
2011 if (LessNotEqual(minNavBarWidth.Value(), 0.0)) {
2012 minNavBarWidth.SetValue(0);
2013 }
2014 SetMinNavBarWidth(frameNode, minNavBarWidth);
2015 std::string key = "navigation.navBarWidthRange.minNavBarWidth";
2016 auto updateMinNavBarWidthFunc = [key, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
2017 auto frameNode = weak.Upgrade();
2018 CHECK_NULL_VOID(frameNode);
2019 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2020 CHECK_NULL_VOID(navigationGroupNode);
2021 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
2022 CHECK_NULL_VOID(navigationPattern);
2023 CalcDimension minNavBarWidth;
2024 std::string minNavBarWidthString = navigationPattern->GetResCacheMapByKey(key);
2025 if (minNavBarWidthString.empty()) {
2026 ResourceParseUtils::ParseResDimensionVpNG(resObj, minNavBarWidth);
2027 navigationPattern->AddResCache(key, minNavBarWidth.ToString());
2028 } else {
2029 minNavBarWidth = StringUtils::StringToCalcDimension(minNavBarWidthString);
2030 }
2031 if (LessNotEqual(minNavBarWidth.Value(), 0.0)) {
2032 minNavBarWidth.SetValue(0);
2033 }
2034 navigationPattern->SetIfNeedInit(true);
2035 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MinNavBarWidth, minNavBarWidth, frameNode);
2036 navigationGroupNode->MarkModifyDone();
2037 navigationGroupNode->MarkDirtyNode();
2038 };
2039 auto pattern = frameNode->GetPattern<NavigationPattern>();
2040 CHECK_NULL_VOID(pattern);
2041 pattern->AddResObj(key, minNavBarWidthResObj, std::move(updateMinNavBarWidthFunc));
2042 }
2043
SetMaxNavBarWidth(FrameNode * frameNode,const Dimension & value)2044 void NavigationModelNG::SetMaxNavBarWidth(FrameNode* frameNode, const Dimension& value)
2045 {
2046 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2047 CHECK_NULL_VOID(navigationGroupNode);
2048 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
2049 CHECK_NULL_VOID(navigationPattern);
2050 if (IsDoubleBindBlock(navigationPattern)) {
2051 return;
2052 }
2053 navigationPattern->SetIfNeedInit(true);
2054 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MaxNavBarWidth, value, frameNode);
2055 }
2056
SetMaxNavBarWidth(FrameNode * frameNode,const RefPtr<ResourceObject> & maxNavBarWidthResObj)2057 void NavigationModelNG::SetMaxNavBarWidth(FrameNode* frameNode, const RefPtr<ResourceObject>& maxNavBarWidthResObj)
2058 {
2059 CHECK_NULL_VOID(frameNode);
2060 CalcDimension maxNavBarWidth;
2061 ResourceParseUtils::ParseResDimensionVpNG(maxNavBarWidthResObj, maxNavBarWidth);
2062 if (LessNotEqual(maxNavBarWidth.Value(), 0.0)) {
2063 maxNavBarWidth.SetValue(0);
2064 }
2065 SetMaxNavBarWidth(frameNode, maxNavBarWidth);
2066 std::string key = "navigation.navBarWidthRange.maxNavBarWidth";
2067 auto updateMaxNavBarWidthFunc = [key, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
2068 auto frameNode = weak.Upgrade();
2069 CHECK_NULL_VOID(frameNode);
2070 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2071 CHECK_NULL_VOID(navigationGroupNode);
2072 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
2073 CHECK_NULL_VOID(navigationPattern);
2074 CalcDimension maxNavBarWidth;
2075 std::string maxNavBarWidthString = navigationPattern->GetResCacheMapByKey(key);
2076 if (maxNavBarWidthString.empty()) {
2077 ResourceParseUtils::ParseResDimensionVpNG(resObj, maxNavBarWidth);
2078 navigationPattern->AddResCache(key, maxNavBarWidth.ToString());
2079 } else {
2080 maxNavBarWidth = StringUtils::StringToCalcDimension(maxNavBarWidthString);
2081 }
2082 if (LessNotEqual(maxNavBarWidth.Value(), 0.0)) {
2083 maxNavBarWidth.SetValue(0);
2084 }
2085 navigationPattern->SetIfNeedInit(true);
2086 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, MaxNavBarWidth, maxNavBarWidth, frameNode);
2087 navigationGroupNode->MarkModifyDone();
2088 navigationGroupNode->MarkDirtyNode();
2089 };
2090 auto pattern = frameNode->GetPattern<NavigationPattern>();
2091 CHECK_NULL_VOID(pattern);
2092 pattern->AddResObj(key, maxNavBarWidthResObj, std::move(updateMaxNavBarWidthFunc));
2093 }
2094
SetNavBarWidth(FrameNode * frameNode,const Dimension & value)2095 void NavigationModelNG::SetNavBarWidth(FrameNode* frameNode, const Dimension& value)
2096 {
2097 CHECK_NULL_VOID(frameNode);
2098 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, NavBarWidth, value, frameNode);
2099 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2100 CHECK_NULL_VOID(navigationGroupNode);
2101 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
2102 CHECK_NULL_VOID(navigationPattern);
2103 if (IsDoubleBindBlock(navigationPattern)) {
2104 return;
2105 }
2106 navigationPattern->SetUserSetNavBarWidthFlag(true);
2107 if (navigationPattern->GetInitNavBarWidth() != value) {
2108 navigationPattern->SetInitNavBarWidth(value);
2109 }
2110 }
2111
SetNavBarWidth(FrameNode * frameNode,const RefPtr<ResourceObject> & navBarWidthResObj)2112 void NavigationModelNG::SetNavBarWidth(FrameNode* frameNode, const RefPtr<ResourceObject>& navBarWidthResObj)
2113 {
2114 CHECK_NULL_VOID(frameNode);
2115 CalcDimension navBarWidth;
2116 ResourceParseUtils::ParseResDimensionVpNG(navBarWidthResObj, navBarWidth);
2117 if (navBarWidth.Value() <= 0) {
2118 navBarWidth.SetValue(DEFAULT_NAV_BAR_WIDTH_VALUE);
2119 }
2120 SetNavBarWidth(frameNode, navBarWidth);
2121 std::string key = "navigation.navBarWidth";
2122 auto updateNavBarWidthFunc = [key, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
2123 auto frameNode = weak.Upgrade();
2124 CHECK_NULL_VOID(frameNode);
2125 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2126 CHECK_NULL_VOID(navigationGroupNode);
2127 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
2128 CHECK_NULL_VOID(navigationPattern);
2129 CalcDimension navBarWidth;
2130 std::string navBarWidthString = navigationPattern->GetResCacheMapByKey(key);
2131 if (navBarWidthString.empty()) {
2132 ResourceParseUtils::ParseResDimensionVpNG(resObj, navBarWidth);
2133 navigationPattern->AddResCache(key, navBarWidth.ToString());
2134 } else {
2135 navBarWidth = StringUtils::StringToCalcDimension(navBarWidthString);
2136 }
2137 if (navBarWidth.Value() <= 0) {
2138 navBarWidth.SetValue(DEFAULT_NAV_BAR_WIDTH_VALUE);
2139 }
2140 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, NavBarWidth, navBarWidth, frameNode);
2141 navigationPattern->SetUserSetNavBarWidthFlag(true);
2142 if (navigationPattern->GetInitNavBarWidth() != navBarWidth) {
2143 navigationPattern->SetInitNavBarWidth(navBarWidth);
2144 }
2145 navigationGroupNode->MarkModifyDone();
2146 navigationGroupNode->MarkDirtyNode();
2147 };
2148 auto pattern = frameNode->GetPattern<NavigationPattern>();
2149 CHECK_NULL_VOID(pattern);
2150 pattern->AddResObj(key, navBarWidthResObj, std::move(updateNavBarWidthFunc));
2151 }
2152
SetNavBarPosition(FrameNode * frameNode,NG::NavBarPosition mode)2153 void NavigationModelNG::SetNavBarPosition(FrameNode* frameNode, NG::NavBarPosition mode)
2154 {
2155 ACE_UPDATE_NODE_LAYOUT_PROPERTY(
2156 NavigationLayoutProperty, NavBarPosition, static_cast<NG::NavBarPosition>(mode), frameNode);
2157 }
2158
SetUsrNavigationMode(FrameNode * frameNode,NavigationMode mode)2159 void NavigationModelNG::SetUsrNavigationMode(FrameNode* frameNode, NavigationMode mode)
2160 {
2161 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, UsrNavigationMode, mode, frameNode);
2162 }
2163
SetBackButtonIcon(FrameNode * frameNode,const std::function<void (WeakPtr<NG::FrameNode>)> & symbolApply,const std::string & src,const ImageOption & imageOption,RefPtr<PixelMap> & pixMap)2164 void NavigationModelNG::SetBackButtonIcon(FrameNode* frameNode,
2165 const std::function<void(WeakPtr<NG::FrameNode>)>& symbolApply, const std::string& src,
2166 const ImageOption& imageOption, RefPtr<PixelMap>& pixMap)
2167 {
2168 CHECK_NULL_VOID(frameNode);
2169 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2170 CHECK_NULL_VOID(navigationGroupNode);
2171
2172 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2173 CHECK_NULL_VOID(navBarNode);
2174 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2175 CHECK_NULL_VOID(titleBarNode);
2176 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
2177 CHECK_NULL_VOID(titleBarLayoutProperty);
2178 ImageSourceInfo imageSourceInfo(src);
2179 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, NoPixMap, imageOption.noPixMap, frameNode);
2180 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, ImageSource, imageSourceInfo, frameNode);
2181 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, PixelMap, pixMap, frameNode);
2182 titleBarLayoutProperty->UpdateImageSource(imageSourceInfo);
2183 titleBarLayoutProperty->UpdateNoPixMap(imageOption.noPixMap);
2184 titleBarLayoutProperty->UpdatePixelMap(pixMap);
2185 titleBarLayoutProperty->SetBackIconSymbol(symbolApply);
2186 titleBarLayoutProperty->UpdateIsValidImage(imageOption.isValidImage);
2187 }
2188
SetBackButtonIcon(FrameNode * frameNode,const std::function<void (WeakPtr<NG::FrameNode>)> & symbolApply,const ImageOption & imageOption,RefPtr<PixelMap> & pixMap,const RefPtr<ResourceObject> & backButtonIconResObj)2189 void NavigationModelNG::SetBackButtonIcon(FrameNode* frameNode,
2190 const std::function<void(WeakPtr<NG::FrameNode>)>& symbolApply, const ImageOption& imageOption,
2191 RefPtr<PixelMap>& pixMap, const RefPtr<ResourceObject>& backButtonIconResObj)
2192 {
2193 CHECK_NULL_VOID(frameNode);
2194 std::string result;
2195 ResourceParseUtils::ParseResMedia(backButtonIconResObj, result);
2196 SetBackButtonIcon(frameNode, symbolApply, result, imageOption, pixMap);
2197 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2198 CHECK_NULL_VOID(navigationGroupNode);
2199 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2200 CHECK_NULL_VOID(navBarNode);
2201 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2202 CHECK_NULL_VOID(titleBarNode);
2203 std::string key = "navigation.backButtonIcon.icon";
2204 auto updateFunc = [key, weakFrameNode = AceType::WeakClaim(frameNode),
2205 weakTitleBarNode = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
2206 const RefPtr<ResourceObject>& backButtonIconResObj) {
2207 auto titleBarNode = weakTitleBarNode.Upgrade();
2208 CHECK_NULL_VOID(titleBarNode);
2209 auto pattern = titleBarNode->GetPattern<TitleBarPattern>();
2210 CHECK_NULL_VOID(pattern);
2211 std::string result = pattern->GetResCacheMapByKey(key);
2212 if (result.empty()) {
2213 ResourceParseUtils::ParseResMedia(backButtonIconResObj, result);
2214 pattern->AddResCache(key, result);
2215 }
2216 ImageSourceInfo imageSourceInfo(result);
2217 auto frameNode = weakFrameNode.Upgrade();
2218 CHECK_NULL_VOID(frameNode);
2219 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, ImageSource, imageSourceInfo, frameNode);
2220 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
2221 CHECK_NULL_VOID(titleBarLayoutProperty);
2222 titleBarLayoutProperty->UpdateImageSource(imageSourceInfo);
2223 titleBarNode->MarkModifyDone();
2224 titleBarNode->MarkDirtyNode();
2225 };
2226 auto pattern = titleBarNode->GetPattern<TitleBarPattern>();
2227 CHECK_NULL_VOID(pattern);
2228 pattern->AddResObj(key, backButtonIconResObj, std::move(updateFunc));
2229 }
2230
SetHideNavBarInner(const RefPtr<NavigationGroupNode> & navigationGroupNode,bool hideNavBar)2231 void NavigationModelNG::SetHideNavBarInner(
2232 const RefPtr<NavigationGroupNode>& navigationGroupNode, bool hideNavBar)
2233 {
2234 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
2235 CHECK_NULL_VOID(pattern);
2236 auto navigationLayoutProperty = navigationGroupNode->GetLayoutProperty<NavigationLayoutProperty>();
2237 CHECK_NULL_VOID(navigationLayoutProperty);
2238
2239 auto lastHideNavBarValue = navigationLayoutProperty->GetHideNavBar();
2240 if (lastHideNavBarValue.has_value()) {
2241 pattern->SetNavBarVisibilityChange(hideNavBar != lastHideNavBarValue.value());
2242 } else {
2243 pattern->SetNavBarVisibilityChange(true);
2244 }
2245 auto navBarOrHomeDestNode =
2246 AceType::DynamicCast<NavDestinationNodeBase>(navigationGroupNode->GetNavBarOrHomeDestinationNode());
2247 if (navBarOrHomeDestNode) {
2248 navBarOrHomeDestNode->SetJSViewActive(!hideNavBar);
2249 if (pattern->GetNavBarVisibilityChange()) {
2250 navBarOrHomeDestNode->MarkDirtyNode();
2251 }
2252 }
2253 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, HideNavBar, hideNavBar, navigationGroupNode);
2254 }
2255
SetHideNavBar(FrameNode * frameNode,bool hideNavBar)2256 void NavigationModelNG::SetHideNavBar(FrameNode* frameNode, bool hideNavBar)
2257 {
2258 auto navigationGroupNode =
2259 Referenced::Claim<NavigationGroupNode>(AceType::DynamicCast<NavigationGroupNode>(frameNode));
2260 CHECK_NULL_VOID(navigationGroupNode);
2261 SetHideNavBarInner(navigationGroupNode, hideNavBar);
2262 }
2263
SetEnableModeChangeAnimation(FrameNode * frameNode,bool isEnable)2264 void NavigationModelNG::SetEnableModeChangeAnimation(FrameNode* frameNode, bool isEnable)
2265 {
2266 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2267 CHECK_NULL_VOID(navigationGroupNode);
2268 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, EnableModeChangeAnimation, isEnable, navigationGroupNode);
2269 }
2270
SetHideTitleBar(FrameNode * frameNode,bool hideTitleBar,bool animated)2271 void NavigationModelNG::SetHideTitleBar(FrameNode* frameNode, bool hideTitleBar, bool animated)
2272 {
2273 CHECK_NULL_VOID(frameNode);
2274 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2275 CHECK_NULL_VOID(navigationGroupNode);
2276 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2277 CHECK_NULL_VOID(navBarNode);
2278 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
2279 CHECK_NULL_VOID(navBarLayoutProperty);
2280 navBarLayoutProperty->UpdateHideTitleBar(hideTitleBar);
2281 navBarLayoutProperty->UpdateIsAnimatedTitleBar(animated);
2282 }
2283
SetSplitPlaceholder(FrameNode * frameNode,FrameNode * splitPlaceholder)2284 void NavigationModelNG::SetSplitPlaceholder(FrameNode* frameNode, FrameNode* splitPlaceholder)
2285 {
2286 CHECK_NULL_VOID(splitPlaceholder);
2287 CHECK_NULL_VOID(frameNode);
2288 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2289 CHECK_NULL_VOID(navigationGroupNode);
2290 if (!navigationGroupNode->GetPlaceholderContentNode()) {
2291 int32_t placeholderContentNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2292 auto placeholderContentNode = FrameNode::GetOrCreateFrameNode(V2::SPLIT_PLACEHOLDER_CONTENT_ETS_TAG,
2293 placeholderContentNodeId, []() { return AceType::MakeRefPtr<Pattern>(); });
2294 placeholderContentNode->GetLayoutProperty()->UpdateAlignment(Alignment::TOP_LEFT);
2295 SafeAreaExpandOpts opts = { .type = SAFE_AREA_TYPE_SYSTEM | SAFE_AREA_TYPE_CUTOUT,
2296 .edges = SAFE_AREA_EDGE_ALL };
2297 placeholderContentNode->GetLayoutProperty()->UpdateSafeAreaExpandOpts(opts);
2298 const auto& eventHub = placeholderContentNode->GetEventHub<EventHub>();
2299 if (eventHub) {
2300 eventHub->SetEnabled(false);
2301 }
2302 auto focusHub = placeholderContentNode->GetOrCreateFocusHub();
2303 if (focusHub) {
2304 focusHub->SetFocusable(false);
2305 }
2306 auto renderContext = placeholderContentNode->GetRenderContext();
2307 CHECK_NULL_VOID(renderContext);
2308 renderContext->SetClipToBounds(true);
2309 renderContext->UpdateZIndex(-1);
2310 navigationGroupNode->AddChild(placeholderContentNode);
2311 navigationGroupNode->SetPlaceholderContentNode(placeholderContentNode);
2312 }
2313 auto splitPlaceholderNode = AceType::Claim<UINode>(splitPlaceholder);
2314 CHECK_NULL_VOID(splitPlaceholderNode);
2315 navigationGroupNode->SetSplitPlaceholder(splitPlaceholderNode);
2316 }
2317
ResetSplitPlaceholder(FrameNode * frameNode)2318 void NavigationModelNG::ResetSplitPlaceholder(FrameNode* frameNode)
2319 {
2320 CHECK_NULL_VOID(frameNode);
2321 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2322 CHECK_NULL_VOID(navigationGroupNode);
2323 navigationGroupNode->ResetSplitPlaceholder();
2324 }
2325
SetSubtitle(FrameNode * frameNode,const std::string & subtitle)2326 void NavigationModelNG::SetSubtitle(FrameNode* frameNode, const std::string& subtitle)
2327 {
2328 CHECK_NULL_VOID(frameNode);
2329 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2330 CHECK_NULL_VOID(navigationGroupNode);
2331 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2332 CHECK_NULL_VOID(navBarNode);
2333 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2334 CHECK_NULL_VOID(titleBarNode);
2335 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
2336 CHECK_NULL_VOID(titleBarPattern);
2337 if (navBarNode->GetPrevTitleIsCustomValue(false)) {
2338 titleBarNode->RemoveChild(titleBarNode->GetTitle());
2339 titleBarNode->SetTitle(nullptr);
2340 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
2341 CHECK_NULL_VOID(titleBarLayoutProperty);
2342 if (titleBarLayoutProperty->HasTitleHeight()) {
2343 titleBarLayoutProperty->ResetTitleHeight();
2344 navBarNode->GetLayoutProperty<NavBarLayoutProperty>()->ResetTitleMode();
2345 }
2346 }
2347 navBarNode->UpdatePrevTitleIsCustom(false);
2348 // create or update subtitle
2349 auto subTitle = AceType::DynamicCast<FrameNode>(titleBarNode->GetSubtitle());
2350 if (subTitle) {
2351 // update subtitle
2352 auto textLayoutProperty = subTitle->GetLayoutProperty<TextLayoutProperty>();
2353 textLayoutProperty->UpdateContent(subtitle);
2354 auto renderContext = subTitle->GetRenderContext();
2355 renderContext->UpdateOpacity(1.0);
2356 } else {
2357 // create and init subtitle
2358 subTitle = FrameNode::CreateFrameNode(
2359 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
2360 auto textLayoutProperty = subTitle->GetLayoutProperty<TextLayoutProperty>();
2361 textLayoutProperty->UpdateContent(subtitle);
2362 titleBarPattern->SetNeedResetSubTitleProperty(true);
2363 titleBarNode->SetSubtitle(subTitle);
2364 titleBarNode->AddChild(subTitle);
2365 }
2366 }
2367
SetHideBackButton(FrameNode * frameNode,bool hideBackButton)2368 void NavigationModelNG::SetHideBackButton(FrameNode* frameNode, bool hideBackButton)
2369 {
2370 CHECK_NULL_VOID(frameNode);
2371 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2372 CHECK_NULL_VOID(navigationGroupNode);
2373 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2374 CHECK_NULL_VOID(navBarNode);
2375 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
2376 CHECK_NULL_VOID(navBarLayoutProperty);
2377 if (!navBarLayoutProperty->HasHideBackButton() ||
2378 (hideBackButton != navBarLayoutProperty->GetHideBackButtonValue())) {
2379 SetNeedResetTitleProperty(AceType::DynamicCast<FrameNode>(navBarNode->GetTitleBarNode()));
2380 }
2381 navBarLayoutProperty->UpdateHideBackButton(hideBackButton);
2382 }
2383
SetTitleMode(FrameNode * frameNode,NG::NavigationTitleMode mode)2384 void NavigationModelNG::SetTitleMode(FrameNode* frameNode, NG::NavigationTitleMode mode)
2385 {
2386 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2387 CHECK_NULL_VOID(navigationGroupNode);
2388 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2389 CHECK_NULL_VOID(navBarNode);
2390 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
2391 CHECK_NULL_VOID(navBarLayoutProperty);
2392 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2393 CHECK_NULL_VOID(titleBarNode);
2394 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
2395 CHECK_NULL_VOID(titleBarLayoutProperty);
2396 const auto& titleHeightProperty = titleBarLayoutProperty->GetTitleHeight();
2397 if (titleHeightProperty.has_value()) {
2398 mode = NavigationTitleMode::MINI;
2399 }
2400 if (!navBarLayoutProperty->HasTitleMode() || navBarLayoutProperty->GetTitleModeValue() != mode) {
2401 SetNeedResetTitleProperty(titleBarNode);
2402 }
2403 navBarLayoutProperty->UpdateTitleMode(static_cast<NG::NavigationTitleMode>(mode));
2404 auto backButtonNode = AceType::DynamicCast<FrameNode>(titleBarNode->GetBackButton());
2405 if (mode != NavigationTitleMode::MINI) {
2406 // remove back button if any.
2407 titleBarNode->RemoveChild(backButtonNode);
2408 titleBarNode->SetBackButton(nullptr);
2409 return;
2410 }
2411
2412 if (backButtonNode != nullptr) {
2413 return;
2414 }
2415 // create back button
2416 bool result = CreateBackButtonNode(backButtonNode);
2417 CHECK_NULL_VOID(result);
2418
2419 if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_TWELVE) &&
2420 SystemProperties::IsNeedSymbol()) {
2421 CreateSymbolBackIcon(backButtonNode, navigationGroupNode);
2422 } else {
2423 CreateImageBackIcon(backButtonNode, navigationGroupNode);
2424 }
2425
2426 //read navigation back button
2427 auto theme = NavigationGetTheme();
2428 std::string message = theme ? theme->GetNavigationBack() : "";
2429 NavigationTitleUtil::SetAccessibility(backButtonNode, message);
2430
2431 backButtonNode->MarkModifyDone();
2432 titleBarNode->SetBackButton(backButtonNode);
2433 titleBarNode->AddChild(backButtonNode, 0);
2434 }
2435
SetRecoverable(FrameNode * frameNode,bool recoverable)2436 void NavigationModelNG::SetRecoverable(FrameNode* frameNode, bool recoverable)
2437 {
2438 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2439 CHECK_NULL_VOID(navigationGroupNode);
2440 navigationGroupNode->SetRecoverable(recoverable);
2441 }
2442
SetRecoverable(bool recoverable)2443 void NavigationModelNG::SetRecoverable(bool recoverable)
2444 {
2445 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(
2446 ViewStackProcessor::GetInstance()->GetMainFrameNode());
2447 CHECK_NULL_VOID(navigationGroupNode);
2448 navigationGroupNode->SetRecoverable(recoverable);
2449 }
2450
SetEnableDragBar(FrameNode * frameNode,bool enableDragBar)2451 void NavigationModelNG::SetEnableDragBar(FrameNode* frameNode, bool enableDragBar)
2452 {
2453 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2454 CHECK_NULL_VOID(navigationGroupNode);
2455 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
2456 CHECK_NULL_VOID(pattern);
2457 DeviceType deviceType = SystemProperties::GetDeviceType();
2458 if (deviceType == DeviceType::TWO_IN_ONE) {
2459 enableDragBar = false;
2460 }
2461 pattern->SetEnableDragBar(enableDragBar);
2462 }
2463
SetEnableToolBarAdaptation(FrameNode * frameNode,bool enable)2464 void NavigationModelNG::SetEnableToolBarAdaptation(FrameNode* frameNode, bool enable)
2465 {
2466 ACE_UPDATE_NODE_LAYOUT_PROPERTY(NavigationLayoutProperty, EnableToolBarAdaptation, enable, frameNode);
2467 }
2468
SetEnableDragBar(bool enableDragBar)2469 void NavigationModelNG::SetEnableDragBar(bool enableDragBar)
2470 {
2471 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2472 CHECK_NULL_VOID(frameNode);
2473 auto pattern = frameNode->GetPattern<NavigationPattern>();
2474 CHECK_NULL_VOID(pattern);
2475 DeviceType deviceType = SystemProperties::GetDeviceType();
2476 if (deviceType == DeviceType::TWO_IN_ONE) {
2477 enableDragBar = false;
2478 }
2479 pattern->SetEnableDragBar(enableDragBar);
2480 }
2481
SetIsCustomAnimation(bool isCustom)2482 void NavigationModelNG::SetIsCustomAnimation(bool isCustom)
2483 {
2484 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2485 CHECK_NULL_VOID(frameNode);
2486 auto pattern = frameNode->GetPattern<NavigationPattern>();
2487 CHECK_NULL_VOID(pattern);
2488 pattern->SetIsCustomAnimation(isCustom);
2489 }
2490
SetCustomTransition(NavigationTransitionEvent && customTransition)2491 void NavigationModelNG::SetCustomTransition(NavigationTransitionEvent&& customTransition)
2492 {
2493 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2494 CHECK_NULL_VOID(frameNode);
2495 auto pattern = frameNode->GetPattern<NavigationPattern>();
2496 CHECK_NULL_VOID(pattern);
2497 pattern->SetNavigationTransition(std::move(customTransition));
2498 }
2499
ResetResObj(NavigationPatternType type,const std::string & key)2500 void NavigationModelNG::ResetResObj(NavigationPatternType type, const std::string& key)
2501 {
2502 if (!SystemProperties::ConfigChangePerform()) {
2503 return;
2504 }
2505 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2506 CHECK_NULL_VOID(frameNode);
2507 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2508 CHECK_NULL_VOID(navigationGroupNode);
2509 RefPtr<Pattern> pattern = nullptr;
2510 if (type == NavigationPatternType::NAV_BAR) {
2511 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2512 CHECK_NULL_VOID(navBarNode);
2513 pattern = navBarNode->GetPattern<NavBarPattern>();
2514 } else if (type == NavigationPatternType::TITLE_BAR) {
2515 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2516 CHECK_NULL_VOID(navBarNode);
2517 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2518 CHECK_NULL_VOID(titleBarNode);
2519 pattern = titleBarNode->GetPattern<TitleBarPattern>();
2520 } else if (type == NavigationPatternType::NAVIGATION) {
2521 pattern = navigationGroupNode->GetPattern<NavigationPattern>();
2522 }
2523 CHECK_NULL_VOID(pattern);
2524 pattern->RemoveResObj(key);
2525 }
2526
SetTitlebarOptions(NavigationTitlebarOptions && opt)2527 void NavigationModelNG::SetTitlebarOptions(NavigationTitlebarOptions&& opt)
2528 {
2529 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2530 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2531 CHECK_NULL_VOID(navigationGroupNode);
2532 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2533 CHECK_NULL_VOID(navBarNode);
2534 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
2535 CHECK_NULL_VOID(navBarPattern);
2536 navBarPattern->SetTitleBarStyle(opt.brOptions.barStyle);
2537 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2538 CHECK_NULL_VOID(titleBarNode);
2539 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
2540 CHECK_NULL_VOID(titleBarPattern);
2541 titleBarPattern->SetTitlebarOptions(opt);
2542 if (!SystemProperties::ConfigChangePerform()) {
2543 return;
2544 }
2545 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
2546 auto updateFunc = [weakFrameNode = AceType::WeakClaim(frameNode),
2547 weakTitleBarPattern = AceType::WeakClaim(AceType::RawPtr(titleBarPattern)),
2548 opt](const RefPtr<ResourceObject>& resObj) mutable {
2549 opt.bgOptions.ReloadResources();
2550 if (opt.bgOptions.blurStyleOption.has_value()) {
2551 opt.bgOptions.blurStyleOption->ReloadResources();
2552 }
2553 if (opt.bgOptions.effectOption.has_value()) {
2554 opt.bgOptions.effectOption->ReloadResources();
2555 }
2556 auto titleBarPattern = weakTitleBarPattern.Upgrade();
2557 CHECK_NULL_VOID(titleBarPattern);
2558
2559 titleBarPattern->SetTitlebarOptions(opt);
2560 auto frameNode = weakFrameNode.Upgrade();
2561 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2562 CHECK_NULL_VOID(navigationGroupNode);
2563 navigationGroupNode->MarkModifyDone();
2564 navigationGroupNode->MarkDirtyNode();
2565 };
2566 auto pattern = navigationGroupNode->GetPattern();
2567 CHECK_NULL_VOID(pattern);
2568 pattern->AddResObj("navigation.navigationTitlebarOptions", resObj, std::move(updateFunc));
2569 }
2570
SetHideItemText(bool isHideItemText)2571 void NavigationModelNG::SetHideItemText(bool isHideItemText)
2572 {
2573 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2574 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2575 CHECK_NULL_VOID(navigationGroupNode);
2576 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2577 NavigationToolbarUtil::SetHideItemText(navBarNode, isHideItemText);
2578 }
2579
SetToolbarOptions(NavigationToolbarOptions && opt)2580 void NavigationModelNG::SetToolbarOptions(NavigationToolbarOptions&& opt)
2581 {
2582 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2583 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2584 CHECK_NULL_VOID(navigationGroupNode);
2585 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2586 NavigationToolbarUtil::SetToolbarOptions(navBarNode, std::move(opt));
2587 }
2588
SetToolbarMorebuttonOptions(MoreButtonOptions && opt)2589 void NavigationModelNG::SetToolbarMorebuttonOptions(MoreButtonOptions&& opt)
2590 {
2591 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2592 CHECK_NULL_VOID(frameNode);
2593 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2594 CHECK_NULL_VOID(navigationGroupNode);
2595 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2596 CHECK_NULL_VOID(navBarNode);
2597 NavigationToolbarUtil::SetToolbarMoreButtonOptions(navBarNode, std::move(opt));
2598 }
2599
SetMenuOptions(NavigationMenuOptions && opt)2600 void NavigationModelNG::SetMenuOptions(NavigationMenuOptions&& opt)
2601 {
2602 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2603 CHECK_NULL_VOID(frameNode);
2604 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2605 CHECK_NULL_VOID(navigationGroupNode);
2606 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2607 CHECK_NULL_VOID(navBarNode);
2608 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
2609 CHECK_NULL_VOID(navBarPattern);
2610 navBarPattern->SetMenuOptions(opt);
2611 if (!SystemProperties::ConfigChangePerform()) {
2612 return;
2613 }
2614 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
2615 auto updateFunc = [weakFrameNode = AceType::WeakClaim(frameNode),
2616 weakNavBarPattern = AceType::WeakClaim(AceType::RawPtr(navBarPattern)),
2617 opt](const RefPtr<ResourceObject>& resObj) mutable {
2618 opt.mbOptions.bgOptions.ReloadResources();
2619 if (opt.mbOptions.bgOptions.blurStyleOption.has_value()) {
2620 opt.mbOptions.bgOptions.blurStyleOption->ReloadResources();
2621 }
2622 if (opt.mbOptions.bgOptions.effectOption.has_value()) {
2623 opt.mbOptions.bgOptions.effectOption->ReloadResources();
2624 }
2625 auto navBarPattern = weakNavBarPattern.Upgrade();
2626 CHECK_NULL_VOID(navBarPattern);
2627
2628 navBarPattern->SetMenuOptions(opt);
2629 auto frameNode = weakFrameNode.Upgrade();
2630 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2631 CHECK_NULL_VOID(navigationGroupNode);
2632 navigationGroupNode->MarkModifyDone();
2633 navigationGroupNode->MarkDirtyNode();
2634 };
2635 navBarPattern->AddResObj("navigation.navigationMenuOptions", resObj, std::move(updateFunc));
2636 }
2637
SetIgnoreLayoutSafeArea(const NG::IgnoreLayoutSafeAreaOpts & opts)2638 void NavigationModelNG::SetIgnoreLayoutSafeArea(const NG::IgnoreLayoutSafeAreaOpts& opts)
2639 {
2640 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2641 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2642 CHECK_NULL_VOID(navigationGroupNode);
2643 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2644 CHECK_NULL_VOID(navBarNode);
2645 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
2646 CHECK_NULL_VOID(navBarLayoutProperty);
2647 navBarLayoutProperty->UpdateIgnoreLayoutSafeAreaOpts(opts);
2648 auto content = AceType::DynamicCast<FrameNode>(navBarNode->GetContentNode());
2649 CHECK_NULL_VOID(content);
2650 auto contentLayoutProperty = content->GetLayoutProperty();
2651 CHECK_NULL_VOID(contentLayoutProperty);
2652 contentLayoutProperty->UpdateIgnoreLayoutSafeAreaOpts(opts);
2653 }
2654
SetIgnoreLayoutSafeArea(FrameNode * frameNode,const NG::IgnoreLayoutSafeAreaOpts & opts)2655 void NavigationModelNG::SetIgnoreLayoutSafeArea(FrameNode* frameNode, const NG::IgnoreLayoutSafeAreaOpts& opts)
2656 {
2657 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2658 CHECK_NULL_VOID(navigationGroupNode);
2659 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2660 CHECK_NULL_VOID(navBarNode);
2661 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
2662 CHECK_NULL_VOID(navBarLayoutProperty);
2663 navBarLayoutProperty->UpdateIgnoreLayoutSafeAreaOpts(opts);
2664 auto content = AceType::DynamicCast<FrameNode>(navBarNode->GetContentNode());
2665 CHECK_NULL_VOID(content);
2666 auto contentLayoutProperty = content->GetLayoutProperty();
2667 CHECK_NULL_VOID(contentLayoutProperty);
2668 contentLayoutProperty->UpdateIgnoreLayoutSafeAreaOpts(opts);
2669 }
2670
SetSystemBarStyle(const RefPtr<SystemBarStyle> & style)2671 void NavigationModelNG::SetSystemBarStyle(const RefPtr<SystemBarStyle>& style)
2672 {
2673 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2674 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2675 CHECK_NULL_VOID(navigationGroupNode);
2676 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
2677 CHECK_NULL_VOID(pattern);
2678 pattern->SetSystemBarStyle(style);
2679 }
2680
CreateFrameNode(int32_t nodeId)2681 RefPtr<FrameNode> NavigationModelNG::CreateFrameNode(int32_t nodeId)
2682 {
2683 auto navigationGroupNode = NavigationRegister::GetInstance()->GetOrCreateGroupNode(
2684 V2::NAVIGATION_VIEW_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<NavigationPattern>(); });
2685 // navBar node
2686 if (!navigationGroupNode->GetNavBarNode()) {
2687 int32_t navBarNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2688 auto navBarNode = NavBarNode::GetOrCreateNavBarNode(
2689 V2::NAVBAR_ETS_TAG, navBarNodeId, []() { return AceType::MakeRefPtr<NavBarPattern>(); });
2690 auto navBarRenderContext = navBarNode->GetRenderContext();
2691 CHECK_NULL_RETURN(navBarRenderContext, nullptr);
2692 navBarRenderContext->UpdateClipEdge(true);
2693 navigationGroupNode->AddChild(navBarNode);
2694 navigationGroupNode->SetNavBarNode(navBarNode);
2695
2696 // titleBar node
2697 if (!navBarNode->GetTitleBarNode()) {
2698 int32_t titleBarNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2699 auto titleBarNode = TitleBarNode::GetOrCreateTitleBarNode(
2700 V2::TITLE_BAR_ETS_TAG, titleBarNodeId, []() { return AceType::MakeRefPtr<TitleBarPattern>(); });
2701 navBarNode->AddChild(titleBarNode);
2702 navBarNode->SetTitleBarNode(titleBarNode);
2703 }
2704
2705 // navBar content node
2706 if (!navBarNode->GetContentNode()) {
2707 int32_t navBarContentNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2708 auto navBarContentNode = FrameNode::GetOrCreateFrameNode(V2::NAVBAR_CONTENT_ETS_TAG, navBarContentNodeId,
2709 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
2710 auto navBarContentRenderContext = navBarContentNode->GetRenderContext();
2711 CHECK_NULL_RETURN(navBarContentRenderContext, nullptr);
2712 navBarContentRenderContext->UpdateClipEdge(true);
2713 navBarNode->AddChild(navBarContentNode);
2714 navBarNode->SetContentNode(navBarContentNode);
2715 }
2716
2717 // toolBar node
2718 if (!navBarNode->GetToolBarNode()) {
2719 int32_t toolBarNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2720 auto toolBarNode = NavToolbarNode::GetOrCreateToolbarNode(
2721 V2::TOOL_BAR_ETS_TAG, toolBarNodeId, []() { return AceType::MakeRefPtr<NavToolbarPattern>(); });
2722 navBarNode->AddChild(toolBarNode);
2723 navBarNode->SetToolBarNode(toolBarNode);
2724 navBarNode->SetPreToolBarNode(toolBarNode);
2725 navBarNode->UpdatePrevToolBarIsCustom(false);
2726 }
2727 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
2728 CHECK_NULL_RETURN(navBarLayoutProperty, nullptr);
2729 navBarLayoutProperty->UpdateTitleMode(NavigationTitleMode::FREE);
2730 }
2731
2732 // content node
2733 if (!navigationGroupNode->GetContentNode()) {
2734 int32_t contentNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2735 auto contentNode = FrameNode::GetOrCreateFrameNode(V2::NAVIGATION_CONTENT_ETS_TAG, contentNodeId,
2736 []() { return AceType::MakeRefPtr<NavigationContentPattern>(); });
2737 contentNode->GetLayoutProperty()->UpdateAlignment(Alignment::TOP_LEFT);
2738 contentNode->GetOrCreateEventHub<EventHub>()->GetOrCreateGestureEventHub()->SetHitTestMode(
2739 HitTestMode::HTMTRANSPARENT_SELF);
2740 navigationGroupNode->AddChild(contentNode);
2741 navigationGroupNode->SetContentNode(contentNode);
2742 }
2743
2744 // divider node
2745 if (!navigationGroupNode->GetDividerNode()) {
2746 int32_t dividerNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2747 auto dividerNode = FrameNode::GetOrCreateFrameNode(
2748 V2::DIVIDER_ETS_TAG, dividerNodeId, []() { return AceType::MakeRefPtr<DividerPattern>(); });
2749 navigationGroupNode->AddChild(dividerNode);
2750 navigationGroupNode->SetDividerNode(dividerNode);
2751
2752 auto dividerLayoutProperty = dividerNode->GetLayoutProperty<DividerLayoutProperty>();
2753 CHECK_NULL_RETURN(dividerLayoutProperty, nullptr);
2754 dividerLayoutProperty->UpdateStrokeWidth(DIVIDER_WIDTH);
2755 dividerLayoutProperty->UpdateVertical(true);
2756 auto dividerRenderProperty = dividerNode->GetPaintProperty<DividerRenderProperty>();
2757 CHECK_NULL_RETURN(dividerRenderProperty, nullptr);
2758 }
2759 auto navigationLayoutProperty = navigationGroupNode->GetLayoutProperty<NavigationLayoutProperty>();
2760 if (!navigationLayoutProperty->HasNavigationMode()) {
2761 navigationLayoutProperty->UpdateNavigationMode(NavigationMode::AUTO);
2762 }
2763
2764 auto navigationPattern = navigationGroupNode->GetPattern<NavigationPattern>();
2765 if (navigationPattern && !navigationPattern->GetUserSetNavBarWidthFlag()) {
2766 navigationLayoutProperty->UpdateNavBarWidth(DEFAULT_NAV_BAR_WIDTH);
2767 }
2768 SetNavigationStack(AceType::RawPtr(navigationGroupNode));
2769
2770 return navigationGroupNode;
2771 }
2772
SetNavigationStack(FrameNode * frameNode)2773 void NavigationModelNG::SetNavigationStack(FrameNode* frameNode)
2774 {
2775 CHECK_NULL_VOID(frameNode);
2776 auto pattern = frameNode->GetPattern<NavigationPattern>();
2777 CHECK_NULL_VOID(pattern);
2778 auto navigationStack = pattern->GetNavigationStack();
2779 if (!navigationStack) {
2780 auto navigationStack = AceType::MakeRefPtr<NavigationStack>();
2781 pattern->SetNavigationStack(std::move(navigationStack));
2782 }
2783 }
2784
ParseCommonTitle(FrameNode * frameNode,const NG::NavigationTitleInfo & titleInfo,bool ignoreMainTitle)2785 void NavigationModelNG::ParseCommonTitle(FrameNode* frameNode, const NG::NavigationTitleInfo& titleInfo,
2786 bool ignoreMainTitle)
2787 {
2788 if (!titleInfo.hasSubTitle && !titleInfo.hasMainTitle) {
2789 return;
2790 }
2791 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2792 CHECK_NULL_VOID(navigationGroupNode);
2793 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2794 CHECK_NULL_VOID(navBarNode);
2795 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2796 CHECK_NULL_VOID(titleBarNode);
2797 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
2798 CHECK_NULL_VOID(titleBarPattern);
2799 titleBarPattern->SetIsTitleChanged(true);
2800 if (navBarNode->GetPrevTitleIsCustomValue(false)) {
2801 titleBarNode->RemoveChild(titleBarNode->GetTitle());
2802 titleBarNode->SetTitle(nullptr);
2803 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
2804 CHECK_NULL_VOID(titleBarLayoutProperty);
2805 if (titleBarLayoutProperty->HasTitleHeight()) {
2806 titleBarLayoutProperty->ResetTitleHeight();
2807 navBarNode->GetLayoutProperty<NavBarLayoutProperty>()->ResetTitleMode();
2808 }
2809 }
2810 navBarNode->UpdatePrevTitleIsCustom(false);
2811 if (titleBarPattern->IsFirstTimeSetSystemTitle()) {
2812 titleBarPattern->SetIsFirstTimeSetSystemTitle(false);
2813 titleBarPattern->MarkIsInitialTitle(true);
2814 }
2815
2816 // create or update main title
2817 NavigationTitleUtil::CreateOrUpdateMainTitle(titleBarNode, titleInfo, ignoreMainTitle);
2818
2819 // create or update subtitle
2820 NavigationTitleUtil::CreateOrUpdateSubtitle(titleBarNode, titleInfo);
2821 return;
2822 }
2823
ParseCommonTitle(FrameNode * frameNode,const RefPtr<ResourceObject> & titleResObj,const RefPtr<ResourceObject> & subtitleResObj)2824 void NavigationModelNG::ParseCommonTitle(
2825 FrameNode* frameNode, const RefPtr<ResourceObject>& titleResObj, const RefPtr<ResourceObject>& subtitleResObj)
2826 {
2827 CHECK_NULL_VOID(frameNode);
2828 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2829 CHECK_NULL_VOID(navigationGroupNode);
2830 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2831 CHECK_NULL_VOID(navBarNode);
2832 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2833 CHECK_NULL_VOID(titleBarNode);
2834 std::string subtitle = "";
2835 std::string title = "";
2836 bool hasSubTitle = false;
2837 bool hasMainTitle = false;
2838
2839 if (subtitleResObj) {
2840 hasSubTitle = ResourceParseUtils::ParseResString(subtitleResObj, subtitle);
2841 }
2842 hasMainTitle = ResourceParseUtils::ParseResString(titleResObj, title);
2843 if (!hasSubTitle && !hasMainTitle) {
2844 return;
2845 }
2846 NG::NavigationTitleInfo ngTitleInfo = { hasSubTitle, hasMainTitle, subtitle, title };
2847 ParseCommonTitle(frameNode, ngTitleInfo);
2848 UpdateMainTitleInfo(titleBarNode, titleResObj);
2849 if (subtitleResObj) {
2850 UpdateSubTitleInfo(titleBarNode, subtitleResObj);
2851 }
2852 return;
2853 }
2854
UpdateMainTitleInfo(const RefPtr<NG::TitleBarNode> & titleBarNode,const RefPtr<ResourceObject> & mainResObj)2855 void NavigationModelNG::UpdateMainTitleInfo(
2856 const RefPtr<NG::TitleBarNode>& titleBarNode, const RefPtr<ResourceObject>& mainResObj)
2857 {
2858 CHECK_NULL_VOID(titleBarNode);
2859 std::string key = "navigation.title.commonMainTitle";
2860 auto updateFunc = [key, weak = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
2861 const RefPtr<ResourceObject>& mainResObj) mutable {
2862 auto titleBarNode = weak.Upgrade();
2863 CHECK_NULL_VOID(titleBarNode);
2864 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
2865 CHECK_NULL_VOID(titleBarPattern);
2866 std::string title = titleBarPattern->GetResCacheMapByKey(key);
2867 if (title.empty()) {
2868 ResourceParseUtils::ParseResString(mainResObj, title);
2869 titleBarPattern->AddResCache(key, title);
2870 }
2871 auto mainTitle = AceType::DynamicCast<FrameNode>(titleBarNode->GetTitle());
2872 if (mainTitle) {
2873 auto textLayoutProperty = mainTitle->GetLayoutProperty<NG::TextLayoutProperty>();
2874 textLayoutProperty->UpdateContent(title);
2875 titleBarNode->MarkModifyDone();
2876 titleBarNode->MarkDirtyNode();
2877 }
2878 };
2879 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
2880 CHECK_NULL_VOID(titleBarPattern);
2881 titleBarPattern->AddResObj(key, mainResObj, std::move(updateFunc));
2882 }
2883
UpdateSubTitleInfo(const RefPtr<NG::TitleBarNode> & titleBarNode,const RefPtr<ResourceObject> & resObj)2884 void NavigationModelNG::UpdateSubTitleInfo(
2885 const RefPtr<NG::TitleBarNode>& titleBarNode, const RefPtr<ResourceObject>& resObj)
2886 {
2887 CHECK_NULL_VOID(titleBarNode);
2888 std::string key = "navigation.title.commonSubTitle";
2889 auto updateFunc = [key, weak = AceType::WeakClaim(AceType::RawPtr(titleBarNode))](
2890 const RefPtr<ResourceObject>& resObj) {
2891 auto titleBarNode = weak.Upgrade();
2892 CHECK_NULL_VOID(titleBarNode);
2893 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
2894 CHECK_NULL_VOID(titleBarPattern);
2895 std::string subTitleValue = titleBarPattern->GetResCacheMapByKey(key);
2896 if (subTitleValue.empty()) {
2897 ResourceParseUtils::ParseResString(resObj, subTitleValue);
2898 titleBarPattern->AddResCache(key, subTitleValue);
2899 }
2900 auto subTitleNode = AceType::DynamicCast<FrameNode>(titleBarNode->GetSubtitle());
2901 if (subTitleNode) {
2902 auto textLayoutProperty = subTitleNode->GetLayoutProperty<TextLayoutProperty>();
2903 textLayoutProperty->UpdateContent(subTitleValue);
2904 titleBarNode->MarkModifyDone();
2905 titleBarNode->MarkDirtyNode();
2906 }
2907 };
2908 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
2909 CHECK_NULL_VOID(titleBarPattern);
2910 titleBarPattern->AddResObj(key, resObj, std::move(updateFunc));
2911 }
2912
SetTitlebarOptions(FrameNode * frameNode,NavigationTitlebarOptions && opt)2913 void NavigationModelNG::SetTitlebarOptions(FrameNode* frameNode, NavigationTitlebarOptions&& opt)
2914 {
2915 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2916 CHECK_NULL_VOID(navigationGroupNode);
2917 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2918 CHECK_NULL_VOID(navBarNode);
2919 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
2920 CHECK_NULL_VOID(navBarPattern);
2921 navBarPattern->SetTitleBarStyle(opt.brOptions.barStyle);
2922 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2923 CHECK_NULL_VOID(titleBarNode);
2924 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
2925 CHECK_NULL_VOID(titleBarPattern);
2926 titleBarPattern->SetTitlebarOptions(opt);
2927 }
2928
SetMenuItems(FrameNode * frameNode,std::vector<NG::BarItem> && menuItems)2929 void NavigationModelNG::SetMenuItems(FrameNode* frameNode, std::vector<NG::BarItem>&& menuItems)
2930 {
2931 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2932 CHECK_NULL_VOID(navigationGroupNode);
2933 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2934 CHECK_NULL_VOID(navBarNode);
2935 // if previous menu is custom, just remove it and create new menu, otherwise update old menu
2936 if (navBarNode->GetPrevMenuIsCustom().value_or(false)) {
2937 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::REPLACE);
2938 } else {
2939 if (navBarNode->GetMenu()) {
2940 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::REPLACE);
2941 } else {
2942 navBarNode->UpdateMenuNodeOperation(ChildNodeOperation::ADD);
2943 }
2944 }
2945 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
2946 CHECK_NULL_VOID(navBarPattern);
2947 navBarPattern->SetTitleBarMenuItems(menuItems);
2948 navBarPattern->SetMenuNodeId(ElementRegister::GetInstance()->MakeUniqueId());
2949 navBarPattern->SetLandscapeMenuNodeId(ElementRegister::GetInstance()->MakeUniqueId());
2950 navBarNode->UpdatePrevMenuIsCustom(false);
2951 }
2952
SetMenuItemAction(FrameNode * frameNode,std::function<void ()> && action,uint32_t index)2953 void NavigationModelNG::SetMenuItemAction(FrameNode* frameNode, std::function<void()>&& action, uint32_t index)
2954 {
2955 CHECK_NULL_VOID(action);
2956 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2957 CHECK_NULL_VOID(navigationGroupNode);
2958 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2959 CHECK_NULL_VOID(navBarNode);
2960 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
2961 CHECK_NULL_VOID(navBarPattern);
2962 auto menuItems = navBarPattern->GetTitleBarMenuItems();
2963 if (menuItems.size() > index) {
2964 menuItems.at(index).action = action;
2965 navBarPattern->SetTitleBarMenuItems(menuItems);
2966 }
2967 }
2968
SetMenuItemSymbol(FrameNode * frameNode,std::function<void (WeakPtr<NG::FrameNode>)> && symbol,uint32_t index)2969 void NavigationModelNG::SetMenuItemSymbol(FrameNode* frameNode,
2970 std::function<void(WeakPtr<NG::FrameNode>)>&& symbol, uint32_t index)
2971 {
2972 CHECK_NULL_VOID(symbol);
2973 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2974 CHECK_NULL_VOID(navigationGroupNode);
2975 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2976 CHECK_NULL_VOID(navBarNode);
2977 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
2978 CHECK_NULL_VOID(navBarPattern);
2979 auto menuItems = navBarPattern->GetTitleBarMenuItems();
2980 if (menuItems.size() > index) {
2981 menuItems.at(index).iconSymbol = symbol;
2982 navBarPattern->SetTitleBarMenuItems(menuItems);
2983 }
2984 }
2985
SetCustomTitle(FrameNode * frameNode,const RefPtr<AceType> & customNode)2986 void NavigationModelNG::SetCustomTitle(FrameNode* frameNode, const RefPtr<AceType>& customNode)
2987 {
2988 auto customTitle = AceType::DynamicCast<NG::UINode>(customNode);
2989 CHECK_NULL_VOID(customTitle);
2990 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
2991 CHECK_NULL_VOID(navigationGroupNode);
2992 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
2993 CHECK_NULL_VOID(navBarNode);
2994 navBarNode->UpdatePrevTitleIsCustom(true);
2995 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
2996 CHECK_NULL_VOID(titleBarNode);
2997 if (!navBarNode->GetPrevTitleIsCustomValue(false)) {
2998 titleBarNode->RemoveChild(titleBarNode->GetTitle());
2999 titleBarNode->RemoveChild(titleBarNode->GetSubtitle());
3000 titleBarNode->SetTitle(nullptr);
3001 titleBarNode->SetSubtitle(nullptr);
3002 }
3003 auto currentTitle = titleBarNode->GetTitle();
3004 if (currentTitle && customTitle->GetId() == currentTitle->GetId()) {
3005 // do nothing
3006 return;
3007 }
3008 // update custom title
3009 titleBarNode->RemoveChild(currentTitle);
3010 titleBarNode->SetTitle(customTitle);
3011 titleBarNode->AddChild(customTitle);
3012 titleBarNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
3013 }
3014
GetCustomTitle(FrameNode * frameNode)3015 RefPtr<FrameNode> NavigationModelNG::GetCustomTitle(FrameNode* frameNode)
3016 {
3017 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
3018 CHECK_NULL_RETURN(navigationGroupNode, nullptr);
3019 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
3020 CHECK_NULL_RETURN(navBarNode, nullptr);
3021 navBarNode->UpdatePrevTitleIsCustom(true);
3022 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
3023 CHECK_NULL_RETURN(titleBarNode, nullptr);
3024 auto title = AceType::DynamicCast<FrameNode>(titleBarNode->GetTitle());
3025 return title;
3026 }
3027
SetTitleHeight(FrameNode * frameNode,const Dimension & height,bool isValid)3028 void NavigationModelNG::SetTitleHeight(FrameNode* frameNode, const Dimension& height, bool isValid)
3029 {
3030 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
3031 CHECK_NULL_VOID(navigationGroupNode);
3032 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
3033 CHECK_NULL_VOID(navBarNode);
3034 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
3035 CHECK_NULL_VOID(titleBarNode);
3036 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
3037 CHECK_NULL_VOID(titleBarLayoutProperty);
3038 if (!isValid) {
3039 titleBarLayoutProperty->ResetTitleHeight();
3040 return;
3041 }
3042 titleBarLayoutProperty->UpdateTitleHeight(height);
3043 auto navBarLayoutProperty = navBarNode->GetLayoutProperty<NavBarLayoutProperty>();
3044 CHECK_NULL_VOID(navBarLayoutProperty);
3045 if (!navBarLayoutProperty->HasHideBackButton() || navBarLayoutProperty->GetHideBackButtonValue() != true) {
3046 auto titleBarPattern = titleBarNode->GetPattern<TitleBarPattern>();
3047 CHECK_NULL_VOID(titleBarPattern);
3048 titleBarPattern->SetNeedResetMainTitleProperty(true);
3049 titleBarPattern->SetNeedResetSubTitleProperty(true);
3050 }
3051 navBarLayoutProperty->UpdateHideBackButton(true);
3052 navBarLayoutProperty->UpdateTitleMode(static_cast<NG::NavigationTitleMode>(NavigationTitleMode::MINI));
3053 }
3054
SetOnCoordScrollStartAction(FrameNode * frameNode,std::function<void ()> && onCoordScrollStart)3055 void NavigationModelNG::SetOnCoordScrollStartAction(FrameNode* frameNode, std::function<void()>&& onCoordScrollStart)
3056 {
3057 CHECK_NULL_VOID(onCoordScrollStart);
3058 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
3059 CHECK_NULL_VOID(navigationGroupNode);
3060 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
3061 CHECK_NULL_VOID(navBarNode);
3062 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
3063 CHECK_NULL_VOID(navBarPattern);
3064 auto navBarEventHub = navBarPattern->GetOrCreateEventHub<NavBarEventHub>();
3065 CHECK_NULL_VOID(navBarEventHub);
3066 navBarEventHub->SetOnCoordScrollStartAction(std::move(onCoordScrollStart));
3067 }
3068
SetOnCoordScrollUpdateAction(FrameNode * frameNode,std::function<void (float)> && onCoordScrollUpdate)3069 void NavigationModelNG::SetOnCoordScrollUpdateAction(
3070 FrameNode* frameNode, std::function<void(float)>&& onCoordScrollUpdate)
3071 {
3072 CHECK_NULL_VOID(onCoordScrollUpdate);
3073 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
3074 CHECK_NULL_VOID(navigationGroupNode);
3075 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
3076 CHECK_NULL_VOID(navBarNode);
3077 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
3078 CHECK_NULL_VOID(navBarPattern);
3079 auto navBarEventHub = navBarPattern->GetOrCreateEventHub<NavBarEventHub>();
3080 CHECK_NULL_VOID(navBarEventHub);
3081 navBarEventHub->SetOnCoordScrollUpdateAction(std::move(onCoordScrollUpdate));
3082 }
3083
SetOnCoordScrollEndAction(FrameNode * frameNode,std::function<void ()> && onCoordScrollEnd)3084 void NavigationModelNG::SetOnCoordScrollEndAction(FrameNode* frameNode, std::function<void()>&& onCoordScrollEnd)
3085 {
3086 CHECK_NULL_VOID(onCoordScrollEnd);
3087 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
3088 CHECK_NULL_VOID(navigationGroupNode);
3089 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
3090 CHECK_NULL_VOID(navBarNode);
3091 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
3092 CHECK_NULL_VOID(navBarPattern);
3093 auto navBarEventHub = navBarPattern->GetOrCreateEventHub<NavBarEventHub>();
3094 CHECK_NULL_VOID(navBarEventHub);
3095 navBarEventHub->SetOnCoordScrollEndAction(std::move(onCoordScrollEnd));
3096 }
3097
SetSystemBarStyle(FrameNode * frameNode,const RefPtr<SystemBarStyle> & style)3098 void NavigationModelNG::SetSystemBarStyle(FrameNode* frameNode, const RefPtr<SystemBarStyle>& style)
3099 {
3100 CHECK_NULL_VOID(frameNode);
3101 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
3102 CHECK_NULL_VOID(navigationGroupNode);
3103 auto pattern = navigationGroupNode->GetPattern<NavigationPattern>();
3104 CHECK_NULL_VOID(pattern);
3105 pattern->SetSystemBarStyle(style);
3106 }
3107
IsDoubleBindBlock(const RefPtr<NavigationPattern> & navigationPattern)3108 bool NavigationModelNG::IsDoubleBindBlock(const RefPtr<NavigationPattern>& navigationPattern)
3109 {
3110 return navBarWidthDoubleBind_ && navigationPattern->GetIsInDividerDrag();
3111 }
3112
SetIsCustomTitleBarSize(FrameNode * frameNode,bool isCustom)3113 void NavigationModelNG::SetIsCustomTitleBarSize(FrameNode* frameNode, bool isCustom)
3114 {
3115 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
3116 CHECK_NULL_VOID(navigationGroupNode);
3117 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
3118 CHECK_NULL_VOID(navBarNode);
3119 auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navBarNode->GetTitleBarNode());
3120 CHECK_NULL_VOID(titleBarNode);
3121 auto titleBarLayoutProperty = titleBarNode->GetLayoutProperty<TitleBarLayoutProperty>();
3122 CHECK_NULL_VOID(titleBarLayoutProperty);
3123 titleBarLayoutProperty->UpdateIsCustomTitleBarSize(isCustom);
3124 }
3125
SetBeforeCreateLayoutWrapperCallBack(FrameNode * frameNode,std::function<void ()> && beforeCreateLayoutWrapper)3126 void NavigationModelNG::SetBeforeCreateLayoutWrapperCallBack(
3127 FrameNode* frameNode, std::function<void()>&& beforeCreateLayoutWrapper)
3128 {
3129 CHECK_NULL_VOID(beforeCreateLayoutWrapper);
3130 auto navigationGroupNode = AceType::DynamicCast<NavigationGroupNode>(frameNode);
3131 CHECK_NULL_VOID(navigationGroupNode);
3132 auto navBarNode = AceType::DynamicCast<NavBarNode>(navigationGroupNode->GetNavBarNode());
3133 CHECK_NULL_VOID(navBarNode);
3134 auto navBarPattern = navBarNode->GetPattern<NavBarPattern>();
3135 CHECK_NULL_VOID(navBarPattern);
3136 auto navBarEventHub = navBarPattern->GetOrCreateEventHub<NavBarEventHub>();
3137 CHECK_NULL_VOID(navBarEventHub);
3138 navBarEventHub->SetBeforeCreateLayoutWrapperCallBack(std::move(beforeCreateLayoutWrapper));
3139 }
3140 } // namespace OHOS::Ace::NG
3141