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/menu/menu_model_ng.h"
17
18 #include "core/common/resource/resource_parse_utils.h"
19 #include "core/components_ng/base/view_abstract.h"
20
21 namespace OHOS::Ace::NG {
22
CreateWithColorResourceObj(const RefPtr<ResourceObject> & resObj,const MenuColorType menuColorType)23 void MenuModelNG::CreateWithColorResourceObj(
24 const RefPtr<ResourceObject>& resObj, const MenuColorType menuColorType)
25 {
26 CHECK_NULL_VOID(resObj);
27 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
28 CHECK_NULL_VOID(frameNode);
29 CreateWithColorResourceObj(frameNode, resObj, menuColorType);
30 }
31
CreateWithColorResourceObj(FrameNode * frameNode,const RefPtr<ResourceObject> & resObj,const MenuColorType menuColorType)32 void MenuModelNG::CreateWithColorResourceObj(
33 FrameNode* frameNode, const RefPtr<ResourceObject>& resObj, const MenuColorType menuColorType)
34 {
35 CHECK_NULL_VOID(frameNode);
36 auto pattern = frameNode->GetPattern<MenuPattern>();
37 CHECK_NULL_VOID(pattern);
38 std::string key = "Menu" + ColorTypeToString(menuColorType);
39 pattern->RemoveResObj(key);
40 CHECK_NULL_VOID(resObj);
41 auto&& updateFunc = [pattern, key, menuColorType, weak = AceType::WeakClaim(frameNode)](
42 const RefPtr<ResourceObject>& resObj) {
43 auto node = weak.Upgrade();
44 CHECK_NULL_VOID(node);
45 std::string colorStr = pattern->GetResCacheMapByKey(key);
46 Color color;
47 if (colorStr.empty()) {
48 CHECK_NE_VOID(ResourceParseUtils::ParseResColor(resObj, color), true);
49 pattern->AddResCache(key, color.ToString());
50 } else {
51 color = Color::ColorFromString(colorStr);
52 }
53 SetMenuColorValue(menuColorType, node, color);
54 node->MarkModifyDone();
55 node->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
56 };
57 pattern->AddResObj(key, resObj, std::move(updateFunc));
58 }
59
SetMenuColorValue(MenuColorType type,RefPtr<NG::FrameNode> & node,Color & color)60 void MenuModelNG::SetMenuColorValue(
61 MenuColorType type, RefPtr<NG::FrameNode>& node, Color& color)
62 {
63 auto layoutProperty = node->GetLayoutProperty<MenuLayoutProperty>();
64 CHECK_NULL_VOID(layoutProperty);
65 switch (type) {
66 case MenuColorType::FONT_COLOR:
67 MenuModelNG::SetFontColor(&(*node), color);
68 break;
69 case MenuColorType::DIVIDER_COLOR: {
70 auto itemDivider = layoutProperty->GetItemDividerValue();
71 itemDivider.color = color;
72 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemDivider, itemDivider, &(*node));
73 break;
74 }
75 case MenuColorType::GROUP_DIVIDER_COLOR: {
76 auto itemGroupDivider = layoutProperty->GetItemGroupDividerValue();
77 itemGroupDivider.color = color;
78 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemGroupDivider, itemGroupDivider, &(*node));
79 break;
80 }
81 default:
82 break;
83 }
84 }
CreateWithDimensionResourceObj(const RefPtr<ResourceObject> & resObj,const MenuDimensionType menuDimensionType)85 void MenuModelNG::CreateWithDimensionResourceObj(
86 const RefPtr<ResourceObject>& resObj, const MenuDimensionType menuDimensionType)
87 {
88 CHECK_NULL_VOID(resObj);
89 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
90 CHECK_NULL_VOID(frameNode);
91 CreateWithDimensionResourceObj(frameNode, resObj, menuDimensionType);
92 }
CreateWithDimensionResourceObj(FrameNode * frameNode,const RefPtr<ResourceObject> & resObj,const MenuDimensionType menuDimensionType)93 void MenuModelNG::CreateWithDimensionResourceObj(
94 FrameNode* frameNode, const RefPtr<ResourceObject>& resObj, const MenuDimensionType menuDimensionType)
95 {
96 CHECK_NULL_VOID(frameNode);
97 auto pattern = frameNode->GetPattern<MenuPattern>();
98 CHECK_NULL_VOID(pattern);
99 std::string key = "Menu" + DimensionTypeToString(menuDimensionType);
100 pattern->RemoveResObj(key);
101 CHECK_NULL_VOID(resObj);
102 auto&& updateFunc = [pattern, key, menuDimensionType, weak = AceType::WeakClaim(frameNode)](
103 const RefPtr<ResourceObject>& resObj) {
104 auto node = weak.Upgrade();
105 CHECK_NULL_VOID(node);
106 std::string cacheValue = pattern->GetResCacheMapByKey(key);
107 CalcDimension result;
108 if (cacheValue.empty()) {
109 if (menuDimensionType == MenuDimensionType::FONT_SIZE) {
110 CHECK_NE_VOID(ResourceParseUtils::ParseResDimensionFpNG(resObj, result, false), true);
111 } else {
112 CHECK_NE_VOID(ResourceParseUtils::ParseResDimensionVpNG(resObj, result, false), true);
113 }
114 pattern->AddResCache(key, result.ToString());
115 } else {
116 result = CalcDimension::FromString(cacheValue);
117 }
118 SetMenuDimensionValue(menuDimensionType, node, result);
119 node->MarkModifyDone();
120 node->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
121 };
122 pattern->AddResObj(key, resObj, std::move(updateFunc));
123 }
124
SetMenuDimensionValue(MenuDimensionType type,RefPtr<NG::FrameNode> & node,CalcDimension & result)125 void MenuModelNG::SetMenuDimensionValue(
126 MenuDimensionType type, RefPtr<NG::FrameNode>& node, CalcDimension& result)
127 {
128 auto layoutProperty = node->GetLayoutProperty<MenuLayoutProperty>();
129 CHECK_NULL_VOID(layoutProperty);
130 switch (type) {
131 case MenuDimensionType::WIDTH:
132 MenuModelNG::SetWidth(&(*node), result);
133 break;
134 case MenuDimensionType::FONT_SIZE: {
135 if (result.Unit() == DimensionUnit::PERCENT) {
136 result = CalcDimension();
137 }
138 MenuModelNG::SetFontSize(&(*node), result);
139 break;
140 }
141 case MenuDimensionType::BORDER_RADIUS:
142 SetBorderRadius(&(*node), result);
143 break;
144 default:
145 break;
146 }
147 }
148
CreateWithFontFamilyResourceObj(const RefPtr<ResourceObject> & resObj,MenuFamilyType type)149 void MenuModelNG::CreateWithFontFamilyResourceObj(const RefPtr<ResourceObject>& resObj, MenuFamilyType type)
150 {
151 CHECK_NULL_VOID(resObj);
152 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
153 CHECK_NULL_VOID(frameNode);
154 CreateWithFontFamilyResourceObj(frameNode, resObj, type);
155 }
156
CreateWithFontFamilyResourceObj(FrameNode * frameNode,const RefPtr<ResourceObject> & resObj,MenuFamilyType type)157 void MenuModelNG::CreateWithFontFamilyResourceObj(
158 FrameNode* frameNode, const RefPtr<ResourceObject>& resObj, MenuFamilyType type)
159 {
160 CHECK_NULL_VOID(frameNode);
161 auto pattern = frameNode->GetPattern<MenuPattern>();
162 CHECK_NULL_VOID(pattern);
163 std::string key = "Menu" + FamilyTypeToString(type);
164 pattern->RemoveResObj(key);
165 CHECK_NULL_VOID(resObj);
166 auto&& updateFunc = [type, weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {
167 auto node = weak.Upgrade();
168 CHECK_NULL_VOID(node);
169 std::vector<std::string> fontFamilies;
170 CHECK_NE_VOID(ResourceParseUtils::ParseResFontFamilies(resObj, fontFamilies), true);
171 if (type == MenuFamilyType::FONT_FAMILY) {
172 MenuModelNG::SetFontFamily(&(*node), fontFamilies);
173 }
174 node->MarkModifyDone();
175 node->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
176 };
177 pattern->AddResObj(key, resObj, std::move(updateFunc));
178 }
179
ColorTypeToString(const MenuColorType menuColorType)180 const std::string MenuModelNG::ColorTypeToString(const MenuColorType menuColorType)
181 {
182 std::string rst;
183 switch (menuColorType) {
184 case MenuColorType::FONT_COLOR:
185 rst = "FontColor";
186 break;
187 case MenuColorType::GROUP_DIVIDER_COLOR:
188 rst = "GroupDividerColor";
189 break;
190 case MenuColorType::DIVIDER_COLOR:
191 rst = "DividerColor";
192 break;
193 default:
194 rst = "Unknown";
195 break;
196 }
197 return rst;
198 }
199
DimensionTypeToString(const MenuDimensionType menuDimensionType)200 const std::string MenuModelNG::DimensionTypeToString(const MenuDimensionType menuDimensionType)
201 {
202 std::string rst;
203 switch (menuDimensionType) {
204 case MenuDimensionType::WIDTH:
205 rst = "Width";
206 break;
207 case MenuDimensionType::FONT_SIZE:
208 rst = "FontSize";
209 break;
210 case MenuDimensionType::RADIUS_TOP_LEFT:
211 rst = "RadiusTopLeft";
212 break;
213 case MenuDimensionType::RADIUS_TOP_RIGHT:
214 rst = "RadiusTopRight";
215 break;
216 case MenuDimensionType::RADIUS_BOTTOM_LEFT:
217 rst = "RadiusBottomLeft";
218 break;
219 case MenuDimensionType::RADIUS_BOTTOM_RIGHT:
220 rst = "RadiusBottomRight";
221 break;
222 case MenuDimensionType::BORDER_RADIUS:
223 rst = "BorderRadius";
224 break;
225 default:
226 rst = "Unknown";
227 break;
228 }
229 return rst;
230 }
231
FamilyTypeToString(const MenuFamilyType type)232 const std::string MenuModelNG::FamilyTypeToString(const MenuFamilyType type)
233 {
234 std::string rst;
235 switch (type) {
236 case MenuFamilyType::FONT_FAMILY:
237 rst = "FontFamily";
238 break;
239 default:
240 rst = "Unknown";
241 break;
242 }
243 return rst;
244 }
245
Create()246 void MenuModelNG::Create()
247 {
248 auto* stack = ViewStackProcessor::GetInstance();
249 int32_t nodeId = (stack == nullptr ? 0 : stack->ClaimNodeId());
250 ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::MENU_ETS_TAG, nodeId);
251 auto menuNode = FrameNode::GetOrCreateFrameNode(V2::MENU_ETS_TAG, nodeId,
252 []() { return AceType::MakeRefPtr<InnerMenuPattern>(-1, V2::MENU_ETS_TAG, MenuType::MULTI_MENU); });
253 CHECK_NULL_VOID(menuNode);
254 ViewStackProcessor::GetInstance()->Push(menuNode);
255 if (Container::LessThanAPIVersion(PlatformVersion::VERSION_ELEVEN)) {
256 auto layoutProps = menuNode->GetLayoutProperty();
257 CHECK_NULL_VOID(layoutProps);
258 // default min width
259 layoutProps->UpdateCalcMinSize(CalcSize(CalcLength(MIN_MENU_WIDTH), std::nullopt));
260 }
261 }
262
CreateMenu()263 RefPtr<FrameNode> MenuModelNG::CreateMenu()
264 {
265 auto* stack = ViewStackProcessor::GetInstance();
266 int32_t nodeId = (stack == nullptr ? 0 : stack->ClaimNodeId());
267 auto menuNode = FrameNode::GetOrCreateFrameNode(V2::MENU_ETS_TAG, nodeId,
268 []() { return AceType::MakeRefPtr<InnerMenuPattern>(-1, V2::MENU_ETS_TAG, MenuType::MULTI_MENU); });
269 CHECK_NULL_RETURN(menuNode, nullptr);
270 if (Container::LessThanAPIVersion(PlatformVersion::VERSION_ELEVEN)) {
271 auto layoutProps = menuNode->GetLayoutProperty();
272 CHECK_NULL_RETURN(layoutProps, nullptr);
273 layoutProps->UpdateCalcMinSize(CalcSize(CalcLength(MIN_MENU_WIDTH), std::nullopt));
274 }
275 return menuNode;
276 }
277
SetFontSize(const Dimension & fontSize)278 void MenuModelNG::SetFontSize(const Dimension& fontSize)
279 {
280 if (fontSize.IsValid()) {
281 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, FontSize, fontSize);
282 } else {
283 ACE_RESET_LAYOUT_PROPERTY(MenuLayoutProperty, FontSize);
284 }
285 }
286
SetFontWeight(FontWeight weight)287 void MenuModelNG::SetFontWeight(FontWeight weight)
288 {
289 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, FontWeight, weight);
290 }
291
SetFontStyle(Ace::FontStyle style)292 void MenuModelNG::SetFontStyle(Ace::FontStyle style)
293 {
294 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, ItalicFontStyle, style);
295 }
296
SetFontColor(const std::optional<Color> & color)297 void MenuModelNG::SetFontColor(const std::optional<Color>& color)
298 {
299 if (color.has_value()) {
300 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, FontColor, color.value());
301 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, FontColorSetByUser, true);
302 } else {
303 ACE_RESET_LAYOUT_PROPERTY(MenuLayoutProperty, FontColor);
304 ACE_RESET_LAYOUT_PROPERTY(MenuLayoutProperty, FontColorSetByUser);
305 }
306 }
307
SetBorderRadius(const Dimension & radius)308 void MenuModelNG::SetBorderRadius(const Dimension& radius)
309 {
310 NG::BorderRadiusProperty borderRadius;
311 borderRadius.radiusTopLeft = radius;
312 borderRadius.radiusTopRight = radius;
313 borderRadius.radiusBottomLeft = radius;
314 borderRadius.radiusBottomRight = radius;
315 borderRadius.multiValued = true;
316 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, BorderRadius, borderRadius);
317 }
318
ResetBorderRadius()319 void MenuModelNG::ResetBorderRadius()
320 {
321 ACE_RESET_LAYOUT_PROPERTY_WITH_FLAG(MenuLayoutProperty, BorderRadius, PROPERTY_UPDATE_MEASURE);
322 }
323
SetBorderRadius(const std::optional<Dimension> & radiusTopLeft,const std::optional<Dimension> & radiusTopRight,const std::optional<Dimension> & radiusBottomLeft,const std::optional<Dimension> & radiusBottomRight)324 void MenuModelNG::SetBorderRadius(const std::optional<Dimension>& radiusTopLeft,
325 const std::optional<Dimension>& radiusTopRight, const std::optional<Dimension>& radiusBottomLeft,
326 const std::optional<Dimension>& radiusBottomRight)
327 {
328 NG::BorderRadiusProperty borderRadius;
329 borderRadius.radiusTopLeft = radiusTopLeft;
330 borderRadius.radiusTopRight = radiusTopRight;
331 borderRadius.radiusBottomLeft = radiusBottomLeft;
332 borderRadius.radiusBottomRight = radiusBottomRight;
333 borderRadius.multiValued = true;
334 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, BorderRadius, borderRadius);
335 }
336
SetBorderRadius(const NG::BorderRadiusProperty & borderRadius)337 void MenuModelNG::SetBorderRadius(const NG::BorderRadiusProperty& borderRadius)
338 {
339 if (SystemProperties::ConfigChangePerform()) {
340 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
341 CHECK_NULL_VOID(frameNode);
342 auto pattern = frameNode->GetPattern();
343 CHECK_NULL_VOID(pattern);
344 pattern->RemoveResObj("borderRadius");
345 auto&& updateFunc = [borderRadius, weak = AceType::WeakClaim(frameNode)](
346 const RefPtr<ResourceObject>& resObj) {
347 auto frameNode = weak.Upgrade();
348 if (!frameNode) {
349 return;
350 }
351 NG::BorderRadiusProperty& borderRadiusValue = const_cast<NG::BorderRadiusProperty&>(borderRadius);
352 borderRadiusValue.ReloadResources();
353 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, BorderRadius, borderRadius);
354 frameNode->MarkModifyDone();
355 frameNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
356 };
357 if (borderRadius.HasResources()) {
358 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>();
359 pattern->AddResObj("borderRadius", resObj, std::move(updateFunc));
360 }
361 }
362
363 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, BorderRadius, borderRadius);
364 }
365
SetWidth(const Dimension & width)366 void MenuModelNG::SetWidth(const Dimension& width)
367 {
368 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
369 MenuModelNG::SetWidth(frameNode, width);
370 }
371
SetFontFamily(const std::vector<std::string> & families)372 void MenuModelNG::SetFontFamily(const std::vector<std::string>& families)
373 {
374 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, FontFamily, families);
375 }
376
ResetFontFamily()377 void MenuModelNG::ResetFontFamily()
378 {
379 ACE_RESET_LAYOUT_PROPERTY_WITH_FLAG(MenuLayoutProperty, FontFamily, PROPERTY_UPDATE_MEASURE);
380 }
381
SetExpandingMode(const SubMenuExpandingMode & expandingMode)382 void MenuModelNG::SetExpandingMode(const SubMenuExpandingMode& expandingMode)
383 {
384 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, ExpandingMode, expandingMode);
385 }
386
SetExpandingMode(FrameNode * frameNode,const SubMenuExpandingMode & expandingMode)387 void MenuModelNG::SetExpandingMode(FrameNode* frameNode, const SubMenuExpandingMode& expandingMode)
388 {
389 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, ExpandingMode, expandingMode, frameNode);
390 }
391
SetExpandSymbol(const std::function<void (WeakPtr<NG::FrameNode>)> & expandSymbol)392 void MenuModelNG::SetExpandSymbol(const std::function<void(WeakPtr<NG::FrameNode>)>& expandSymbol)
393 {
394 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
395 CHECK_NULL_VOID(frameNode);
396 auto menuProperty = frameNode->GetLayoutProperty<MenuLayoutProperty>();
397 CHECK_NULL_VOID(menuProperty);
398 menuProperty->SetExpandSymbol(expandSymbol);
399 }
400
SetExpandSymbol(FrameNode * frameNode,const std::function<void (WeakPtr<NG::FrameNode>)> & expandSymbol)401 void MenuModelNG::SetExpandSymbol(FrameNode* frameNode, const std::function<void(WeakPtr<NG::FrameNode>)>& expandSymbol)
402 {
403 CHECK_NULL_VOID(frameNode);
404 auto menuProperty = frameNode->GetLayoutProperty<MenuLayoutProperty>();
405 CHECK_NULL_VOID(menuProperty);
406 menuProperty->SetExpandSymbol(expandSymbol);
407 }
408
SetItemDivider(const V2::ItemDivider & divider,const DividerMode & mode)409 void MenuModelNG::SetItemDivider(const V2::ItemDivider& divider, const DividerMode& mode)
410 {
411 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemDivider, divider);
412 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemDividerMode, mode);
413 }
414
SetItemDivider(FrameNode * frameNode,const V2::ItemDivider & divider,const DividerMode & mode)415 void MenuModelNG::SetItemDivider(FrameNode* frameNode, const V2::ItemDivider& divider, const DividerMode& mode)
416 {
417 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemDivider, divider, frameNode);
418 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemDividerMode, mode, frameNode);
419 }
420
SetItemGroupDivider(const V2::ItemDivider & divider,const DividerMode & mode)421 void MenuModelNG::SetItemGroupDivider(const V2::ItemDivider& divider, const DividerMode& mode)
422 {
423 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemGroupDivider, divider);
424 ACE_UPDATE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemGroupDividerMode, mode);
425 }
426
SetItemGroupDivider(FrameNode * frameNode,const V2::ItemDivider & divider,const DividerMode & mode)427 void MenuModelNG::SetItemGroupDivider(FrameNode* frameNode, const V2::ItemDivider& divider, const DividerMode& mode)
428 {
429 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemGroupDivider, divider, frameNode);
430 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, ItemGroupDividerMode, mode, frameNode);
431 }
432
SetFontColor(FrameNode * frameNode,const std::optional<Color> & color)433 void MenuModelNG::SetFontColor(FrameNode* frameNode, const std::optional<Color>& color)
434 {
435 if (color.has_value()) {
436 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, FontColor, color.value(), frameNode);
437 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, FontColorSetByUser, true, frameNode);
438 } else {
439 ACE_RESET_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, FontColor, frameNode);
440 ACE_RESET_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, FontColorSetByUser, frameNode);
441 }
442 }
443
SetFontSize(FrameNode * frameNode,const Dimension & fontSize)444 void MenuModelNG::SetFontSize(FrameNode* frameNode, const Dimension& fontSize)
445 {
446 if (fontSize.IsValid()) {
447 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, FontSize, fontSize, frameNode);
448 } else {
449 ACE_RESET_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, FontSize, frameNode);
450 }
451 }
452
SetFontWeight(FrameNode * frameNode,FontWeight weight)453 void MenuModelNG::SetFontWeight(FrameNode* frameNode, FontWeight weight)
454 {
455 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, FontWeight, weight, frameNode);
456 }
457
SetFontStyle(FrameNode * frameNode,Ace::FontStyle style)458 void MenuModelNG::SetFontStyle(FrameNode* frameNode, Ace::FontStyle style)
459 {
460 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, ItalicFontStyle, style, frameNode);
461 }
462
SetFontFamily(FrameNode * frameNode,const std::vector<std::string> & families)463 void MenuModelNG::SetFontFamily(FrameNode* frameNode, const std::vector<std::string>& families)
464 {
465 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, FontFamily, families, frameNode);
466 }
467
SetBorderRadius(FrameNode * frameNode,const Dimension & radius)468 void MenuModelNG::SetBorderRadius(FrameNode* frameNode, const Dimension& radius)
469 {
470 NG::BorderRadiusProperty borderRadius;
471 borderRadius.radiusTopLeft = radius;
472 borderRadius.radiusTopRight = radius;
473 borderRadius.radiusBottomLeft = radius;
474 borderRadius.radiusBottomRight = radius;
475 borderRadius.multiValued = true;
476 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, BorderRadius, borderRadius, frameNode);
477 }
478
ResetBorderRadius(FrameNode * frameNode)479 void MenuModelNG::ResetBorderRadius(FrameNode* frameNode)
480 {
481 ACE_RESET_NODE_LAYOUT_PROPERTY_WITH_FLAG(MenuLayoutProperty, BorderRadius, PROPERTY_UPDATE_MEASURE, frameNode);
482 if (SystemProperties::ConfigChangePerform()) {
483 CHECK_NULL_VOID(frameNode);
484 auto layoutProperty = frameNode->GetLayoutPropertyPtr<MenuLayoutProperty>();
485 CHECK_NULL_VOID(layoutProperty);
486 auto borderRadius = layoutProperty->GetBorderRadius();
487 CHECK_NULL_VOID(borderRadius);
488 borderRadius->ClearResources();
489 }
490 }
491
SetBorderRadius(FrameNode * frameNode,const std::optional<Dimension> & radiusTopLeft,const std::optional<Dimension> & radiusTopRight,const std::optional<Dimension> & radiusBottomLeft,const std::optional<Dimension> & radiusBottomRight)492 void MenuModelNG::SetBorderRadius(FrameNode* frameNode, const std::optional<Dimension>& radiusTopLeft,
493 const std::optional<Dimension>& radiusTopRight, const std::optional<Dimension>& radiusBottomLeft,
494 const std::optional<Dimension>& radiusBottomRight)
495 {
496 NG::BorderRadiusProperty borderRadius;
497 borderRadius.radiusTopLeft = radiusTopLeft;
498 borderRadius.radiusTopRight = radiusTopRight;
499 borderRadius.radiusBottomLeft = radiusBottomLeft;
500 borderRadius.radiusBottomRight = radiusBottomRight;
501 borderRadius.multiValued = true;
502 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, BorderRadius, borderRadius, frameNode);
503 }
504
SetBorderRadius(FrameNode * frameNode,const NG::BorderRadiusProperty & borderRadius)505 void MenuModelNG::SetBorderRadius(FrameNode* frameNode, const NG::BorderRadiusProperty& borderRadius)
506 {
507 if (SystemProperties::ConfigChangePerform()) {
508 CHECK_NULL_VOID(frameNode);
509 auto pattern = frameNode->GetPattern();
510 CHECK_NULL_VOID(pattern);
511 pattern->RemoveResObj("borderRadius");
512 auto&& updateFunc = [borderRadius, weak = AceType::WeakClaim(frameNode)](
513 const RefPtr<ResourceObject>& resObj) {
514 auto frameNode = weak.Upgrade();
515 if (!frameNode) {
516 return;
517 }
518 NG::BorderRadiusProperty& borderRadiusValue = const_cast<NG::BorderRadiusProperty&>(borderRadius);
519 borderRadiusValue.ReloadResources();
520 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, BorderRadius, borderRadius, frameNode);
521 frameNode->MarkModifyDone();
522 frameNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
523 };
524 if (borderRadius.HasResources()) {
525 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>();
526 pattern->AddResObj("borderRadius", resObj, std::move(updateFunc));
527 }
528 }
529
530 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, BorderRadius, borderRadius, frameNode);
531 }
532
SetWidth(FrameNode * frameNode,const Dimension & width)533 void MenuModelNG::SetWidth(FrameNode* frameNode, const Dimension& width)
534 {
535 CHECK_NULL_VOID(frameNode);
536 ACE_UPDATE_NODE_LAYOUT_PROPERTY(MenuLayoutProperty, MenuWidth, width, frameNode);
537 ViewAbstract::SetWidth(frameNode, NG::CalcLength(width));
538 }
539
540 } // namespace OHOS::Ace::NG
541