• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2022 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 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_FOCUS_HUB_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_FOCUS_HUB_H
18 
19 #include "base/memory/ace_type.h"
20 #include "core/components_ng/base/geometry_node.h"
21 #include "core/components_ng/event/focus_box.h"
22 #include "core/components_ng/event/touch_event.h"
23 #include "core/event/key_event.h"
24 #include "core/gestures/gesture_event.h"
25 
26 namespace OHOS::Ace::NG {
27 
28 class FrameNode;
29 class FocusHub;
30 class EventHub;
31 class FocusView;
32 class FocusManager;
33 
34 using TabIndexNodeList = std::list<std::pair<int32_t, WeakPtr<FocusHub>>>;
35 constexpr int32_t DEFAULT_TAB_FOCUSED_INDEX = -2;
36 constexpr int32_t NONE_TAB_FOCUSED_INDEX = -1;
37 constexpr int32_t MASK_FOCUS_STEP_FORWARD = 0x10;
38 constexpr int32_t MASK_FOCUS_STEP_TAB = 0x5;
39 
40 enum class FocusType : int32_t {
41     DISABLE = 0,
42     NODE = 1,
43     SCOPE = 2,
44 };
45 enum class FocusNodeType : int32_t {
46     DEFAULT = 0,
47     GROUP_DEFAULT = 1,
48 };
49 enum class ScopeType : int32_t {
50     OTHERS = 0,
51     FLEX = 1,
52     PROJECT_AREA = 2,
53 };
54 enum class FocusStep : int32_t {
55     NONE = 0x0,
56     LEFT = 0x1,
57     UP = 0x2,
58     RIGHT = 0x11,
59     DOWN = 0x12,
60     LEFT_END = 0x3,
61     UP_END = 0x4,
62     RIGHT_END = 0X13,
63     DOWN_END = 0x14,
64     SHIFT_TAB = 0x5,
65     TAB = 0x15,
66 };
67 enum class RequestFocusResult : int32_t {
68     DEFAULT = 0,
69     NON_FOCUSABLE = 1,
70     NON_FOCUSABLE_ANCESTOR = 2,
71     NON_EXIST = 3,
72     NON_FOCUSABLE_BY_TAB = 4,
73 };
74 enum class SwitchingStartReason : int32_t {
75     DEFAULT = 0,
76     WINDOW_FOCUS = 1,
77     REQUEST_FOCUS = 2,
78     LOST_FOCUS_TO_VIEW_ROOT = 3,
79     REMOVE_SELF = 4,
80     REMOVE_CHILD = 5,
81 };
82 enum class SwitchingEndReason : int32_t {
83     DEFAULT = 0,
84     FOCUS_GUARD_DESTROY = 1,
85     DEPENDENCE_SELF = 2,
86     NO_FOCUSABLE_CHILD = 3,
87     NODE_FOCUS = 4,
88 };
89 enum class SwitchingUpdateReason : int32_t {
90     DEFAULT = 0,
91     SWITCH_FOCUS = 1,
92     ON_FOCUS_NODE = 2,
93 };
94 
95 using GetNextFocusNodeFunc = std::function<void(FocusStep, const WeakPtr<FocusHub>&, WeakPtr<FocusHub>&)>;
96 
97 enum class FocusStyleType : int32_t {
98     NONE = -1,
99     INNER_BORDER = 0,
100     OUTER_BORDER = 1,
101     CUSTOM_BORDER = 2,
102     CUSTOM_REGION = 3,
103     FORCE_BORDER = 4,
104     FORCE_NONE = 5,
105 };
106 
107 enum class OnKeyEventType : int32_t {
108     DEFAULT = 0,
109     CONTEXT_MENU = 1,
110 };
111 
112 enum class FocusDependence : int32_t {
113     CHILD = 0,
114     SELF = 1,
115     AUTO = 2,
116 };
117 
118 enum class FocusPriority : int32_t {
119     AUTO = 0,
120     PRIOR = 2000,
121     PREVIOUS = 3000,
122 };
123 
124 class ACE_EXPORT FocusPaintParam : public virtual AceType {
125     DECLARE_ACE_TYPE(FocusPaintParam, AceType)
126 
127 public:
128     FocusPaintParam() = default;
129     ~FocusPaintParam() override = default;
130 
HasPaintRect()131     bool HasPaintRect() const
132     {
133         return paintRect.has_value();
134     }
GetPaintRect()135     const RoundRect& GetPaintRect() const
136     {
137         return paintRect.value();
138     }
139 
HasPaintColor()140     bool HasPaintColor() const
141     {
142         return paintColor.has_value();
143     }
GetPaintColor()144     const Color& GetPaintColor() const
145     {
146         return paintColor.value();
147     }
148 
HasPaintWidth()149     bool HasPaintWidth() const
150     {
151         return paintWidth.has_value();
152     }
GetPaintWidth()153     const Dimension& GetPaintWidth() const
154     {
155         return paintWidth.value();
156     }
157 
HasFocusPadding()158     bool HasFocusPadding() const
159     {
160         return focusPadding.has_value();
161     }
GetFocusPadding()162     const Dimension& GetFocusPadding() const
163     {
164         return focusPadding.value();
165     }
SetPaintRect(const RoundRect & rect)166     void SetPaintRect(const RoundRect& rect)
167     {
168         paintRect = rect;
169     }
SetPaintColor(const Color & color)170     void SetPaintColor(const Color& color)
171     {
172         paintColor = color;
173     }
SetPaintWidth(const Dimension & width)174     void SetPaintWidth(const Dimension& width)
175     {
176         paintWidth = width;
177     }
SetFocusPadding(const Dimension & padding)178     void SetFocusPadding(const Dimension& padding)
179     {
180         focusPadding = padding;
181     }
182 
183 private:
184     std::optional<RoundRect> paintRect;
185     std::optional<Color> paintColor;
186     std::optional<Dimension> paintWidth;
187     std::optional<Dimension> focusPadding;
188 };
189 
190 class ACE_EXPORT FocusPattern : public virtual AceType {
191     DECLARE_ACE_TYPE(FocusPattern, AceType)
192 
193 public:
194     FocusPattern() = default;
FocusPattern(FocusType focusType,bool focusable)195     FocusPattern(FocusType focusType, bool focusable) : focusType_(focusType), focusable_(focusable) {}
FocusPattern(FocusType focusType,bool focusable,FocusStyleType styleType)196     FocusPattern(FocusType focusType, bool focusable, FocusStyleType styleType)
197         : focusType_(focusType), focusable_(focusable), styleType_(styleType)
198     {}
FocusPattern(FocusType focusType,bool focusable,FocusStyleType styleType,const FocusPaintParam & paintParams)199     FocusPattern(FocusType focusType, bool focusable, FocusStyleType styleType, const FocusPaintParam& paintParams)
200         : focusType_(focusType), focusable_(focusable), styleType_(styleType)
201     {
202         if (!paintParams_) {
203             paintParams_ = std::make_unique<FocusPaintParam>();
204         }
205         if (paintParams.HasPaintRect()) {
206             paintParams_->SetPaintRect(paintParams.GetPaintRect());
207         }
208         if (paintParams.HasPaintColor()) {
209             paintParams_->SetPaintColor(paintParams.GetPaintColor());
210         }
211         if (paintParams.HasPaintWidth()) {
212             paintParams_->SetPaintWidth(paintParams.GetPaintWidth());
213         }
214         if (paintParams.HasFocusPadding()) {
215             paintParams_->SetFocusPadding(paintParams.GetFocusPadding());
216         }
217     }
FocusPattern(const FocusPattern & focusPattern)218     FocusPattern(const FocusPattern& focusPattern)
219     {
220         focusType_ = focusPattern.GetFocusType();
221         focusable_ = focusPattern.GetFocusable();
222         styleType_ = focusPattern.GetStyleType();
223         if (focusPattern.GetFocusPaintParams()) {
224             SetFocusPaintParams(*focusPattern.GetFocusPaintParams());
225         }
226         isFocusActiveWhenFocused_ = focusPattern.GetIsFocusActiveWhenFocused();
227     }
228     ~FocusPattern() override = default;
229 
GetFocusType()230     FocusType GetFocusType() const
231     {
232         return focusType_;
233     }
SetFocusType(FocusType type)234     void SetFocusType(FocusType type)
235     {
236         focusType_ = type;
237     }
238 
GetFocusable()239     bool GetFocusable() const
240     {
241         return focusable_;
242     }
SetFocusable(bool focusable)243     void SetFocusable(bool focusable)
244     {
245         focusable_ = focusable;
246     }
247 
GetStyleType()248     FocusStyleType GetStyleType() const
249     {
250         return styleType_;
251     }
SetStyleType(FocusStyleType styleType)252     void SetStyleType(FocusStyleType styleType)
253     {
254         styleType_ = styleType;
255     }
256 
GetFocusPaintParams()257     const std::unique_ptr<FocusPaintParam>& GetFocusPaintParams() const
258     {
259         return paintParams_;
260     }
SetFocusPaintParams(const FocusPaintParam & paintParams)261     void SetFocusPaintParams(const FocusPaintParam& paintParams)
262     {
263         if (!paintParams_) {
264             paintParams_ = std::make_unique<FocusPaintParam>();
265         }
266         if (paintParams.HasPaintRect()) {
267             paintParams_->SetPaintRect(paintParams.GetPaintRect());
268         }
269         if (paintParams.HasPaintColor()) {
270             paintParams_->SetPaintColor(paintParams.GetPaintColor());
271         }
272         if (paintParams.HasPaintWidth()) {
273             paintParams_->SetPaintWidth(paintParams.GetPaintWidth());
274         }
275         if (paintParams.HasFocusPadding()) {
276             paintParams_->SetFocusPadding(paintParams.GetFocusPadding());
277         }
278     }
279 
GetIsFocusActiveWhenFocused()280     bool GetIsFocusActiveWhenFocused() const
281     {
282         return isFocusActiveWhenFocused_;
283     }
SetIsFocusActiveWhenFocused(bool value)284     void SetIsFocusActiveWhenFocused(bool value)
285     {
286         isFocusActiveWhenFocused_ = value;
287     }
288 
289 private:
290     FocusType focusType_ = FocusType::DISABLE;
291     bool focusable_ = false;
292     FocusStyleType styleType_ = FocusStyleType::NONE;
293     std::unique_ptr<FocusPaintParam> paintParams_ = nullptr;
294     bool isFocusActiveWhenFocused_ = false;
295 };
296 
297 enum class ScopeFocusDirection {
298     VERTICAL = 0,
299     HORIZONTAL,
300     UNIVERSAL,
301 };
302 
303 struct ScopeFocusAlgorithm final {
304     ScopeFocusAlgorithm() = default;
ScopeFocusAlgorithmfinal305     ScopeFocusAlgorithm(bool isVertical, bool isLeftToRight, ScopeType scopeType)
306         : isVertical(isVertical), isLeftToRight(isLeftToRight), scopeType(scopeType)
307     {}
ScopeFocusAlgorithmfinal308     ScopeFocusAlgorithm(bool isVertical, bool isLeftToRight, ScopeType scopeType, GetNextFocusNodeFunc&& function)
309         : isVertical(isVertical), isLeftToRight(isLeftToRight), scopeType(scopeType),
310           getNextFocusNode(std::move(function))
311     {}
ScopeFocusAlgorithmfinal312     ScopeFocusAlgorithm(ScopeFocusDirection direction, bool isVertical, bool isLeftToRight, ScopeType scopeType)
313         : direction(direction), isVertical(isVertical), isLeftToRight(isLeftToRight), scopeType(scopeType)
314     {}
ScopeFocusAlgorithmfinal315     ScopeFocusAlgorithm(ScopeFocusDirection direction, bool isVertical, bool isLeftToRight, ScopeType scopeType,
316         GetNextFocusNodeFunc&& function)
317         : direction(direction), isVertical(isVertical), isLeftToRight(isLeftToRight), scopeType(scopeType),
318           getNextFocusNode(std::move(function))
319     {}
320     ~ScopeFocusAlgorithm() = default;
321 
322     // isVertical will be deleted
323     ScopeFocusDirection direction { ScopeFocusDirection::VERTICAL };
324     bool isVertical { true };
325     bool isLeftToRight { true };
326     ScopeType scopeType { ScopeType::OTHERS };
327     GetNextFocusNodeFunc getNextFocusNode;
328 };
329 
330 class ACE_EXPORT FocusCallbackEvents : public virtual AceType {
331     DECLARE_ACE_TYPE(FocusCallbackEvents, AceType)
332 public:
333     FocusCallbackEvents() = default;
334     ~FocusCallbackEvents() override = default;
335 
336     OnFocusFunc onFocusCallback_;
337     OnFocusFunc onJSFrameNodeFocusCallback_;
338     OnBlurFunc onBlurCallback_;
339     OnBlurFunc onJSFrameNodeBlurCallback_;
340     OnKeyCallbackFunc onKeyEventCallback_;
341     OnKeyCallbackFunc onJSFrameNodeKeyEventCallback_;
342     OnKeyPreImeFunc onKeyPreImeCallback_;
343     GestureEventFunc onClickEventCallback_;
344 
345     WeakPtr<FocusHub> defaultFocusNode_;
346 
347     std::optional<bool> isFocusOnTouch_;
348     bool isDefaultFocus_ = { false };
349     bool isDefaultHasFocused_ = { false };
350     bool isDefaultGroupFocus_ = { false };
351     bool isDefaultGroupHasFocused_ { false };
352 
353     int32_t tabIndex_ = 0;
354 };
355 
356 class ACE_EXPORT FocusHub : public virtual AceType {
DECLARE_ACE_TYPE(FocusHub,AceType)357     DECLARE_ACE_TYPE(FocusHub, AceType)
358 public:
359     explicit FocusHub(const WeakPtr<EventHub>& eventHub, FocusType type = FocusType::DISABLE, bool focusable = false)
360         : eventHub_(eventHub), focusable_(focusable), focusType_(type)
361     {}
FocusHub(const WeakPtr<EventHub> & eventHub,const FocusPattern & focusPattern)362     explicit FocusHub(const WeakPtr<EventHub>& eventHub, const FocusPattern& focusPattern)
363     {
364         eventHub_ = eventHub;
365         focusable_ = focusPattern.GetFocusable();
366         focusType_ = focusPattern.GetFocusType();
367         focusStyleType_ = focusPattern.GetStyleType();
368         if (focusPattern.GetFocusPaintParams()) {
369             SetFocusPaintParamsPtr(focusPattern.GetFocusPaintParams());
370         }
371         isFocusActiveWhenFocused_ = focusPattern.GetIsFocusActiveWhenFocused();
372     }
373     ~FocusHub() override = default;
374 
375     static constexpr int32_t SCROLL_TO_HEAD = -1;
376     static constexpr int32_t SCROLL_TO_TAIL = -2;
377 
SetFocusStyleType(FocusStyleType type)378     void SetFocusStyleType(FocusStyleType type)
379     {
380         focusStyleType_ = type;
381     }
GetFocusStyleType()382     FocusStyleType GetFocusStyleType() const
383     {
384         return focusStyleType_;
385     }
386 
GetBlurReason()387     BlurReason GetBlurReason() const
388     {
389         return blurReason_;
390     }
391 
SetFocusPaintParamsPtr(const std::unique_ptr<FocusPaintParam> & paramsPtr)392     void SetFocusPaintParamsPtr(const std::unique_ptr<FocusPaintParam>& paramsPtr)
393     {
394         CHECK_NULL_VOID(paramsPtr);
395         if (!focusPaintParamsPtr_) {
396             focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
397         }
398         if (paramsPtr->HasPaintRect()) {
399             focusPaintParamsPtr_->SetPaintRect(paramsPtr->GetPaintRect());
400         }
401         if (paramsPtr->HasPaintColor()) {
402             focusPaintParamsPtr_->SetPaintColor(paramsPtr->GetPaintColor());
403         }
404         if (paramsPtr->HasPaintWidth()) {
405             focusPaintParamsPtr_->SetPaintWidth(paramsPtr->GetPaintWidth());
406         }
407         if (paramsPtr->HasFocusPadding()) {
408             focusPaintParamsPtr_->SetFocusPadding(paramsPtr->GetFocusPadding());
409         }
410     }
411 
HasPaintRect()412     bool HasPaintRect() const
413     {
414         return focusPaintParamsPtr_ ? focusPaintParamsPtr_->HasPaintRect() : false;
415     }
GetPaintRect()416     RoundRect GetPaintRect() const
417     {
418         CHECK_NULL_RETURN(focusPaintParamsPtr_, RoundRect());
419         return focusPaintParamsPtr_->GetPaintRect();
420     }
421 
HasPaintColor()422     bool HasPaintColor() const
423     {
424         return focusPaintParamsPtr_ ? focusPaintParamsPtr_->HasPaintColor() : false;
425     }
GetPaintColor()426     const Color& GetPaintColor() const
427     {
428         CHECK_NULL_RETURN(focusPaintParamsPtr_, Color::TRANSPARENT);
429         return focusPaintParamsPtr_->GetPaintColor();
430     }
431 
HasPaintWidth()432     bool HasPaintWidth() const
433     {
434         return focusPaintParamsPtr_ ? focusPaintParamsPtr_->HasPaintWidth() : false;
435     }
GetPaintWidth()436     Dimension GetPaintWidth() const
437     {
438         CHECK_NULL_RETURN(focusPaintParamsPtr_, Dimension());
439         return focusPaintParamsPtr_->GetPaintWidth();
440     }
441 
HasFocusPadding()442     bool HasFocusPadding() const
443     {
444         return focusPaintParamsPtr_ ? focusPaintParamsPtr_->HasFocusPadding() : false;
445     }
446 
HasBackwardFocusMovement()447     bool HasBackwardFocusMovement() const
448     {
449         return hasBackwardMovement_;
450     }
451 
HasForwardFocusMovement()452     bool HasForwardFocusMovement() const
453     {
454         return hasForwardMovement_;
455     }
456 
ClearFocusMovementFlags()457     void ClearFocusMovementFlags()
458     {
459         hasBackwardMovement_ = false;
460         hasForwardMovement_ = false;
461     }
462 
463     bool HasBackwardFocusMovementInChildren();
464     bool HasForwardFocusMovementInChildren();
465     void ClearFocusMovementFlagsInChildren();
466 
GetFocusPadding()467     Dimension GetFocusPadding() const
468     {
469         CHECK_NULL_RETURN(focusPaintParamsPtr_, Dimension());
470         return focusPaintParamsPtr_->GetFocusPadding();
471     }
SetPaintRect(const RoundRect & rect)472     void SetPaintRect(const RoundRect& rect)
473     {
474         if (!focusPaintParamsPtr_) {
475             focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
476         }
477         CHECK_NULL_VOID(focusPaintParamsPtr_);
478         focusPaintParamsPtr_->SetPaintRect(rect);
479     }
SetPaintColor(const Color & color)480     void SetPaintColor(const Color& color)
481     {
482         if (!focusPaintParamsPtr_) {
483             focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
484         }
485         CHECK_NULL_VOID(focusPaintParamsPtr_);
486         focusPaintParamsPtr_->SetPaintColor(color);
487     }
SetPaintWidth(const Dimension & width)488     void SetPaintWidth(const Dimension& width)
489     {
490         if (!focusPaintParamsPtr_) {
491             focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
492         }
493         CHECK_NULL_VOID(focusPaintParamsPtr_);
494         focusPaintParamsPtr_->SetPaintWidth(width);
495     }
SetFocusPadding(const Dimension & padding)496     void SetFocusPadding(const Dimension& padding)
497     {
498         if (!focusPaintParamsPtr_) {
499             focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
500         }
501         CHECK_NULL_VOID(focusPaintParamsPtr_);
502         focusPaintParamsPtr_->SetFocusPadding(padding);
503     }
504 
505     RefPtr<FocusManager> GetFocusManager() const;
506     RefPtr<FrameNode> GetFrameNode() const;
507     RefPtr<GeometryNode> GetGeometryNode() const;
508     RefPtr<FocusHub> GetParentFocusHub() const;
509     RefPtr<FocusHub> GetRootFocusHub();
510     std::string GetFrameName() const;
511     int32_t GetFrameId() const;
512 
513     bool HandleKeyEvent(const KeyEvent& keyEvent);
514     bool RequestFocusImmediately(bool isJudgeRootTree = false);
515     void RequestFocus() const;
516     void SwitchFocus(const RefPtr<FocusHub>& focusNode);
517 
518     static void LostFocusToViewRoot();
519 
520     bool IsViewRootScope();
521     void LostFocus(BlurReason reason = BlurReason::FOCUS_SWITCH);
522     void LostSelfFocus();
523     void RemoveSelf(BlurReason reason = BlurReason::FRAME_DESTROY);
524     void RemoveChild(const RefPtr<FocusHub>& focusNode, BlurReason reason = BlurReason::FRAME_DESTROY);
525     bool GoToNextFocusLinear(FocusStep step, const RectF& rect = RectF());
526     bool TryRequestFocus(const RefPtr<FocusHub>& focusNode, const RectF& rect, FocusStep step = FocusStep::NONE);
InheritFocus()527     void InheritFocus()
528     {
529         OnFocusScope(true);
530     }
531 
532     void CollectTabIndexNodes(TabIndexNodeList& tabIndexNodes);
533     bool GoToFocusByTabNodeIdx(TabIndexNodeList& tabIndexNodes, int32_t tabNodeIdx);
534     bool HandleFocusByTabIndex(const KeyEvent& event);
535     RefPtr<FocusHub> GetChildFocusNodeByType(FocusNodeType nodeType = FocusNodeType::DEFAULT);
536     RefPtr<FocusHub> GetChildFocusNodeById(const std::string& id);
537     bool TriggerFocusScroll();
538     int32_t GetFocusingTabNodeIdx(TabIndexNodeList& tabIndexNodes) const;
539     bool RequestFocusImmediatelyById(const std::string& id, bool isSyncRequest = false);
540     RefPtr<FocusView> GetFirstChildFocusView();
541 
542     bool IsFocusableByTab();
543     bool IsFocusableNodeByTab();
544     bool IsFocusableScopeByTab();
545 
546     bool IsFocusableWholePath();
547     bool IsSelfFocusableWholePath();
548     bool IsOnRootTree() const;
549 
550     bool IsFocusable();
551     bool IsFocusableNode();
552     bool IsFocusableScope();
553 
554     bool IsSyncRequestFocusable();
555     bool IsSyncRequestFocusableNode();
556     bool IsSyncRequestFocusableScope();
557 
IsParentFocusable()558     bool IsParentFocusable() const
559     {
560         return parentFocusable_;
561     }
562     void SetParentFocusable(bool parentFocusable);
563 
564     void SetFocusable(bool focusable, bool isExplicit = true);
565 
GetFocusable()566     bool GetFocusable() const
567     {
568         return focusable_;
569     }
570 
571     void SetShow(bool show);
572     void SetEnabled(bool enabled);
573 
574     bool IsShow() const;
575 
576     bool IsEnabled() const;
577 
IsCurrentFocus()578     bool IsCurrentFocus() const
579     {
580         return currentFocus_;
581     }
582     bool IsCurrentFocusWholePath();
583 
584     bool HasFocusedChild();
585 
ClearUserOnFocus()586     void ClearUserOnFocus()
587     {
588         if (focusCallbackEvents_ && focusCallbackEvents_->onFocusCallback_) {
589             focusCallbackEvents_->onFocusCallback_ = nullptr;
590         }
591     }
592 
SetOnFocusCallback(OnFocusFunc && onFocusCallback)593     void SetOnFocusCallback(OnFocusFunc&& onFocusCallback)
594     {
595         if (!focusCallbackEvents_) {
596             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
597         }
598         focusCallbackEvents_->onFocusCallback_ = std::move(onFocusCallback);
599     }
GetOnFocusCallback()600     OnFocusFunc GetOnFocusCallback()
601     {
602         return focusCallbackEvents_ ? focusCallbackEvents_->onFocusCallback_ : nullptr;
603     }
604 
ClearJSFrameNodeOnFocusCallback()605     void ClearJSFrameNodeOnFocusCallback()
606     {
607         if (focusCallbackEvents_) {
608             focusCallbackEvents_->onJSFrameNodeFocusCallback_ = nullptr;
609         }
610     }
SetJSFrameNodeOnFocusCallback(OnFocusFunc && onFocusCallback)611     void SetJSFrameNodeOnFocusCallback(OnFocusFunc&& onFocusCallback)
612     {
613         if (!focusCallbackEvents_) {
614             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
615         }
616         focusCallbackEvents_->onJSFrameNodeFocusCallback_ = std::move(onFocusCallback);
617     }
GetOnJSFrameNodeFocusCallback()618     OnFocusFunc GetOnJSFrameNodeFocusCallback()
619     {
620         return focusCallbackEvents_ ? focusCallbackEvents_->onJSFrameNodeFocusCallback_ : nullptr;
621     }
622 
ClearUserOnBlur()623     void ClearUserOnBlur()
624     {
625         if (focusCallbackEvents_ && focusCallbackEvents_->onBlurCallback_) {
626             focusCallbackEvents_->onBlurCallback_ = nullptr;
627         }
628     }
629 
SetOnBlurCallback(OnBlurFunc && onBlurCallback)630     void SetOnBlurCallback(OnBlurFunc&& onBlurCallback)
631     {
632         if (!focusCallbackEvents_) {
633             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
634         }
635         focusCallbackEvents_->onBlurCallback_ = std::move(onBlurCallback);
636     }
637 
GetOnBlurCallback()638     OnBlurFunc GetOnBlurCallback()
639     {
640         return focusCallbackEvents_ ? focusCallbackEvents_->onBlurCallback_ : nullptr;
641     }
642 
ClearJSFrameNodeOnBlurCallback()643     void ClearJSFrameNodeOnBlurCallback()
644     {
645         if (focusCallbackEvents_) {
646             focusCallbackEvents_->onJSFrameNodeBlurCallback_ = nullptr;
647         }
648     }
SetJSFrameNodeOnBlurCallback(OnBlurFunc && onBlurCallback)649     void SetJSFrameNodeOnBlurCallback(OnBlurFunc&& onBlurCallback)
650     {
651         if (!focusCallbackEvents_) {
652             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
653         }
654         focusCallbackEvents_->onJSFrameNodeBlurCallback_ = std::move(onBlurCallback);
655     }
GetOnJSFrameNodeBlurCallback()656     OnBlurFunc GetOnJSFrameNodeBlurCallback()
657     {
658         return focusCallbackEvents_ ? focusCallbackEvents_->onJSFrameNodeBlurCallback_ : nullptr;
659     }
660 
SetOnKeyCallback(OnKeyCallbackFunc && onKeyCallback)661     void SetOnKeyCallback(OnKeyCallbackFunc&& onKeyCallback)
662     {
663         if (!focusCallbackEvents_) {
664             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
665         }
666         focusCallbackEvents_->onKeyEventCallback_ = std::move(onKeyCallback);
667     }
668 
ClearUserOnKey()669     void ClearUserOnKey()
670     {
671         if (focusCallbackEvents_ && focusCallbackEvents_->onKeyEventCallback_) {
672             focusCallbackEvents_->onKeyEventCallback_ = nullptr;
673         }
674     }
675 
GetOnKeyCallback()676     OnKeyCallbackFunc GetOnKeyCallback()
677     {
678         return focusCallbackEvents_ ? focusCallbackEvents_->onKeyEventCallback_ : nullptr;
679     }
680 
SetOnKeyPreImeCallback(OnKeyPreImeFunc && onKeyCallback)681     void SetOnKeyPreImeCallback(OnKeyPreImeFunc&& onKeyCallback)
682     {
683         if (!focusCallbackEvents_) {
684             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
685         }
686         focusCallbackEvents_->onKeyPreImeCallback_ = std::move(onKeyCallback);
687     }
688 
ClearOnKeyPreIme()689     void ClearOnKeyPreIme()
690     {
691         if (focusCallbackEvents_ && focusCallbackEvents_->onKeyPreImeCallback_) {
692             focusCallbackEvents_->onKeyPreImeCallback_ = nullptr;
693         }
694     }
695 
GetOnKeyPreIme()696     OnKeyPreImeFunc GetOnKeyPreIme()
697     {
698         return focusCallbackEvents_ ? focusCallbackEvents_->onKeyPreImeCallback_ : nullptr;
699     }
700 
ClearJSFrameNodeOnKeyCallback()701     void ClearJSFrameNodeOnKeyCallback()
702     {
703         if (focusCallbackEvents_) {
704             focusCallbackEvents_->onJSFrameNodeKeyEventCallback_ = nullptr;
705         }
706     }
707 
SetJSFrameNodeOnKeyCallback(OnKeyCallbackFunc && onKeyCallback)708     void SetJSFrameNodeOnKeyCallback(OnKeyCallbackFunc&& onKeyCallback)
709     {
710         if (!focusCallbackEvents_) {
711             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
712         }
713         focusCallbackEvents_->onJSFrameNodeKeyEventCallback_ = std::move(onKeyCallback);
714     }
715 
GetOnJSFrameNodeKeyCallback()716     OnKeyCallbackFunc GetOnJSFrameNodeKeyCallback()
717     {
718         return focusCallbackEvents_ ? focusCallbackEvents_->onJSFrameNodeKeyEventCallback_ : nullptr;
719     }
720 
SetOnClickCallback(GestureEventFunc && onClickCallback)721     void SetOnClickCallback(GestureEventFunc&& onClickCallback)
722     {
723         if (!focusCallbackEvents_) {
724             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
725         }
726         focusCallbackEvents_->onClickEventCallback_ = std::move(onClickCallback);
727     }
GetOnClickCallback()728     GestureEventFunc GetOnClickCallback()
729     {
730         return focusCallbackEvents_ ? focusCallbackEvents_->onClickEventCallback_ : nullptr;
731     }
732 
SetOnFocusInternal(OnFocusFunc && onFocusInternal)733     void SetOnFocusInternal(OnFocusFunc&& onFocusInternal)
734     {
735         onFocusInternal_ = std::move(onFocusInternal);
736     }
SetOnBlurInternal(OnBlurFunc && onBlurInternal)737     void SetOnBlurInternal(OnBlurFunc&& onBlurInternal)
738     {
739         onBlurInternal_ = std::move(onBlurInternal);
740     }
SetOnBlurReasonInternal(OnBlurReasonFunc && onBlurReasonInternal)741     void SetOnBlurReasonInternal(OnBlurReasonFunc&& onBlurReasonInternal)
742     {
743         onBlurReasonInternal_ = std::move(onBlurReasonInternal);
744     }
SetOnPreFocusCallback(OnPreFocusFunc && onPreFocusCallback)745     void SetOnPreFocusCallback(OnPreFocusFunc&& onPreFocusCallback)
746     {
747         onPreFocusCallback_ = std::move(onPreFocusCallback);
748     }
749 
SetOnClearFocusStateInternal(OnClearFocusStateFunc && onClearFocusCallback)750     void SetOnClearFocusStateInternal(OnClearFocusStateFunc&& onClearFocusCallback)
751     {
752         onClearFocusStateCallback_ = std::move(onClearFocusCallback);
753     }
754 
SetOnPaintFocusStateInternal(OnPaintFocusStateFunc && onPaintFocusCallback)755     void SetOnPaintFocusStateInternal(OnPaintFocusStateFunc&& onPaintFocusCallback)
756     {
757         onPaintFocusStateCallback_ = std::move(onPaintFocusCallback);
758     }
759 
760     void SetOnKeyEventInternal(OnKeyEventFunc&& onKeyEvent, OnKeyEventType type = OnKeyEventType::DEFAULT)
761     {
762         onKeyEventsInternal_[type] = std::move(onKeyEvent);
763     }
764 
FindContextMenuOnKeyEvent(OnKeyEventType type)765     bool FindContextMenuOnKeyEvent(OnKeyEventType type)
766     {
767         return (onKeyEventsInternal_.find(type) != onKeyEventsInternal_.end());
768     }
769 
ProcessOnKeyEventInternal(const KeyEvent & event)770     bool ProcessOnKeyEventInternal(const KeyEvent& event)
771     {
772         bool result = false;
773         for (const auto& onKeyEvent : onKeyEventsInternal_) {
774             auto callback = onKeyEvent.second;
775             if (callback && callback(event)) {
776                 result = true;
777             }
778         }
779         return result;
780     }
781 
782     void GetChildrenFocusHub(std::list<RefPtr<FocusHub>>& focusNodes);
783 
784     std::list<RefPtr<FocusHub>>::iterator FlushChildrenFocusHub(std::list<RefPtr<FocusHub>>& focusNodes);
785 
GetChildren()786     std::list<RefPtr<FocusHub>> GetChildren()
787     {
788         std::list<RefPtr<FocusHub>> focusNodes;
789         GetChildrenFocusHub(focusNodes);
790         return focusNodes;
791     }
792 
IsChild()793     bool IsChild() const
794     {
795         return focusType_ == FocusType::NODE;
796     }
797 
SetRect(const RectF & rect)798     void SetRect(const RectF& rect)
799     {
800         rectFromOrigin_ = rect;
801     }
GetRect()802     const RectF& GetRect() const
803     {
804         return rectFromOrigin_;
805     }
806 
807     void DumpFocusTree(int32_t depth);
808     void DumpFocusNodeTree(int32_t depth);
809     void DumpFocusScopeTree(int32_t depth);
810 
811     bool OnClick(const KeyEvent& event);
812 
SetFocusType(FocusType type)813     void SetFocusType(FocusType type)
814     {
815         if (focusType_ != type && type == FocusType::DISABLE) {
816             RemoveSelf(BlurReason::FOCUS_SWITCH);
817         }
818         focusType_ = type;
819 
820         if (IsImplicitFocusableScope() && focusDepend_ == FocusDependence::CHILD) {
821             focusDepend_ = FocusDependence::AUTO;
822         }
823     }
GetFocusType()824     FocusType GetFocusType() const
825     {
826         return focusType_;
827     }
828 
GetTabIndex()829     int32_t GetTabIndex() const
830     {
831         return focusCallbackEvents_ ? focusCallbackEvents_->tabIndex_ : 0;
832     }
SetTabIndex(int32_t tabIndex)833     void SetTabIndex(int32_t tabIndex)
834     {
835         if (!focusCallbackEvents_) {
836             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
837         }
838         focusCallbackEvents_->tabIndex_ = tabIndex;
839     }
840 
IsDefaultFocus()841     bool IsDefaultFocus() const
842     {
843         return focusCallbackEvents_ ? focusCallbackEvents_->isDefaultFocus_ : false;
844     }
845 
SetIsDefaultFocus(bool isDefaultFocus)846     void SetIsDefaultFocus(bool isDefaultFocus)
847     {
848         if (!focusCallbackEvents_) {
849             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
850         }
851         focusCallbackEvents_->isDefaultFocus_ = isDefaultFocus;
852     }
853 
IsDefaultGroupFocus()854     bool IsDefaultGroupFocus() const
855     {
856         return focusCallbackEvents_ ? focusCallbackEvents_->isDefaultGroupFocus_ : false;
857     }
858 
SetIsDefaultGroupFocus(bool isDefaultGroupFocus)859     void SetIsDefaultGroupFocus(bool isDefaultGroupFocus)
860     {
861         if (!focusCallbackEvents_) {
862             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
863         }
864         focusCallbackEvents_->isDefaultGroupFocus_ = isDefaultGroupFocus;
865     }
866 
GetDefaultFocusNode()867     WeakPtr<FocusHub> GetDefaultFocusNode() const
868     {
869         return focusCallbackEvents_ ? focusCallbackEvents_->defaultFocusNode_ : nullptr;
870     }
871 
SetDefaultFocusNode(const WeakPtr<FocusHub> & node)872     void SetDefaultFocusNode(const WeakPtr<FocusHub>& node)
873     {
874         if (!focusCallbackEvents_) {
875             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
876         }
877         focusCallbackEvents_->defaultFocusNode_ = node;
878     }
879 
IsFocusOnTouch()880     std::optional<bool> IsFocusOnTouch() const
881     {
882         return focusCallbackEvents_ ? focusCallbackEvents_->isFocusOnTouch_ : std::nullopt;
883     }
884 
885     void SetIsFocusOnTouch(bool isFocusOnTouch);
886 
SetIsDefaultHasFocused(bool isDefaultHasFocused)887     void SetIsDefaultHasFocused(bool isDefaultHasFocused)
888     {
889         if (!focusCallbackEvents_) {
890             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
891         }
892         focusCallbackEvents_->isDefaultHasFocused_ = isDefaultHasFocused;
893     }
894 
IsDefaultHasFocused()895     bool IsDefaultHasFocused() const
896     {
897         return focusCallbackEvents_ ? focusCallbackEvents_->isDefaultHasFocused_ : false;
898     }
899 
SetIsDefaultGroupHasFocused(bool isDefaultGroupHasFocused)900     void SetIsDefaultGroupHasFocused(bool isDefaultGroupHasFocused)
901     {
902         if (!focusCallbackEvents_) {
903             focusCallbackEvents_ = MakeRefPtr<FocusCallbackEvents>();
904         }
905         focusCallbackEvents_->isDefaultGroupHasFocused_ = isDefaultGroupHasFocused;
906     }
907 
IsDefaultGroupHasFocused()908     bool IsDefaultGroupHasFocused() const
909     {
910         return focusCallbackEvents_ ? focusCallbackEvents_->isDefaultGroupHasFocused_ : false;
911     }
912 
IsImplicitFocusableScope()913     bool IsImplicitFocusableScope() const
914     {
915         return (focusType_ == FocusType::SCOPE) && focusable_ && implicitFocusable_;
916     }
917 
918     std::optional<std::string> GetInspectorKey() const;
919 
920     bool PaintFocusState(bool isNeedStateStyles = true);
921     bool PaintAllFocusState();
922     bool PaintInnerFocusState(const RoundRect& paintRect, bool forceUpdate = false);
923     void ClearFocusState(bool isNeedStateStyles = true);
924     void ClearAllFocusState();
925     void PrintOnKeyEventUserInfo(const KeyEvent& keyEvent, bool retCallback);
926 
SetInnerFocusPaintRectCallback(const std::function<void (RoundRect &)> & callback)927     void SetInnerFocusPaintRectCallback(const std::function<void(RoundRect&)>& callback)
928     {
929         getInnerFocusRectFunc_ = callback;
930     }
931 
SetLastWeakFocusNode(const WeakPtr<FocusHub> & focusHub)932     void SetLastWeakFocusNode(const WeakPtr<FocusHub>& focusHub)
933     {
934         lastWeakFocusNode_ = focusHub;
935     }
GetLastWeakFocusNode()936     WeakPtr<FocusHub> GetLastWeakFocusNode() const
937     {
938         return lastWeakFocusNode_;
939     }
940 
SetIsFocusUnit(bool isFocusUnit)941     void SetIsFocusUnit(bool isFocusUnit)
942     {
943         isFocusUnit_ = isFocusUnit;
944     }
945 
GetFocusDependence()946     FocusDependence GetFocusDependence() const
947     {
948         return focusDepend_;
949     }
SetFocusDependence(FocusDependence focusDepend)950     void SetFocusDependence(FocusDependence focusDepend)
951     {
952         focusDepend_ = focusDepend;
953     }
954 
GetFocusableCount()955     size_t GetFocusableCount()
956     {
957         size_t count = 0;
958         auto children = GetChildren();
959         for (const auto& child : children) {
960             if (child->IsFocusable()) {
961                 count++;
962             }
963         }
964         return count;
965     }
966 
SetIsFocusActiveWhenFocused(bool value)967     void SetIsFocusActiveWhenFocused(bool value)
968     {
969         isFocusActiveWhenFocused_ = value;
970     }
GetIsFocusActiveWhenFocused()971     bool GetIsFocusActiveWhenFocused() const
972     {
973         return isFocusActiveWhenFocused_;
974     }
975 
IsFocusStepVertical(FocusStep step)976     static inline bool IsFocusStepVertical(FocusStep step)
977     {
978         return (static_cast<uint32_t>(step) & 0x1) == 0;
979     }
980 
981     static inline bool IsFocusStepForward(FocusStep step, bool isRtl = false)
982     {
983         bool isForward = (static_cast<uint32_t>(step) & MASK_FOCUS_STEP_FORWARD) != 0;
984         if (isRtl && (step == FocusStep::RIGHT || step == FocusStep::LEFT)) {
985             isForward = !isForward;
986         }
987         return isForward;
988     }
989 
IsFocusStepTab(FocusStep step)990     static inline bool IsFocusStepTab(FocusStep step)
991     {
992         return (static_cast<uint32_t>(step) & MASK_FOCUS_STEP_TAB) == MASK_FOCUS_STEP_TAB;
993     }
994 
995     static inline FocusStep GetRealFocusStepByTab(FocusStep moveStep, bool isRtl = false)
996     {
997         if (isRtl) {
998             return moveStep == FocusStep::TAB ? FocusStep::LEFT : FocusStep::RIGHT;
999         } else {
1000             return moveStep == FocusStep::TAB ? FocusStep::RIGHT : FocusStep::LEFT;
1001         }
1002     }
1003 
1004     static double GetProjectAreaOnRect(const RectF& rect, const RectF& projectRect, FocusStep step);
1005 
1006     void SetFocusScopeId(const std::string& focusScopeId, bool isGroup);
1007     void SetFocusScopePriority(const std::string& focusScopeId, const uint32_t focusPriority);
1008     void RemoveFocusScopeIdAndPriority();
1009     bool AcceptFocusOfPriorityChild();
1010     bool SetLastWeakFocusNodeToPreviousNode();
1011     void SetLastWeakFocusToPreviousInFocusView();
GetIsFocusGroup()1012     bool GetIsFocusGroup() const
1013     {
1014         return isGroup_;
1015     }
1016 
GetIsFocusScope()1017     bool GetIsFocusScope() const
1018     {
1019         return isFocusScope_;
1020     }
1021 
GetFocusScopeId()1022     std::string GetFocusScopeId() const
1023     {
1024         return focusScopeId_;
1025     }
1026 
GetFocusBox()1027     FocusBox& GetFocusBox()
1028     {
1029         return box_;
1030     }
1031 
GetFocusPriority()1032     FocusPriority GetFocusPriority() const
1033     {
1034         return focusPriority_;
1035     }
1036 
1037     static void ToJsonValue(
1038         const RefPtr<FocusHub>& hub, std::unique_ptr<JsonValue>& json, const InspectorFilter& filter);
1039 
1040     bool FocusToHeadOrTailChild(bool isHead);
1041 
1042     WeakPtr<FocusHub> GetUnfocusableParentFocusNode();
1043 protected:
1044     bool OnKeyEvent(const KeyEvent& keyEvent);
1045     bool OnKeyEventNode(const KeyEvent& keyEvent);
1046     bool OnKeyEventScope(const KeyEvent& keyEvent);
1047     bool RequestNextFocusOfKeyTab(const KeyEvent& keyEvent);
1048     bool OnKeyPreIme(KeyEventInfo& info, const KeyEvent& keyEvent);
1049 
1050     bool AcceptFocusOfSpecifyChild(FocusStep step);
1051     bool AcceptFocusOfLastFocus();
1052     bool AcceptFocusByRectOfLastFocus(const RectF& rect);
1053     bool AcceptFocusByRectOfLastFocusNode(const RectF& rect);
1054     bool AcceptFocusByRectOfLastFocusFlex(const RectF& rect);
1055 
1056     bool CalculateRect(const RefPtr<FocusHub>& childNode, RectF& rect) const;
1057     bool RequestNextFocus(FocusStep moveStep, const RectF& rect);
1058 
1059     void OnFocus();
1060     void OnFocusNode();
1061     void OnFocusScope(bool currentHasFocused = false);
1062     void OnBlur();
1063     void OnBlurNode();
1064     void OnBlurScope();
1065 
HandleFocus()1066     void HandleFocus()
1067     {
1068         // Need update: void RenderNode::MoveWhenOutOfViewPort(bool hasEffect)
1069         OnFocus();
1070     }
1071 
1072 private:
1073     friend class FocusView;
1074 
1075     bool CalculatePosition();
1076 
1077     void SetScopeFocusAlgorithm();
1078 
1079     void SetLastFocusNodeIndex(const RefPtr<FocusHub>& focusNode);
1080 
1081     void ScrollToLastFocusIndex() const;
1082 
1083     void CheckFocusStateStyle(bool onFocus);
1084     bool HasFocusStateStyle();
1085 
1086     bool IsNeedPaintFocusState();
1087 
1088     bool ScrollByOffset();
1089     bool ScrollByOffsetToParent(const RefPtr<FrameNode>& parentFrameNode) const;
1090 
1091     RefPtr<FocusHub> GetNearestNodeByProjectArea(const std::list<RefPtr<FocusHub>>& allNodes, FocusStep step);
1092 
1093     bool UpdateFocusView();
1094 
1095     bool IsFocusAbleChildOf(const RefPtr<FocusHub>& parentFocusHub);
1096     WeakPtr<FocusHub> GetChildPriorfocusNode(const std::string& focusScopeId);
1097     bool RequestFocusByPriorityInScope();
1098     bool IsInFocusGroup();
1099     bool IsNestingFocusGroup();
1100     void SetLastWeakFocusNodeWholeScope(const std::string &focusScopeId);
1101 
1102     void RaiseZIndex(); // Recover z-index in ClearFocusState
1103 
1104     bool RequestFocusImmediatelyInner(bool isJudgeRootTree = false);
1105     bool OnKeyEventNodeInternal(const KeyEvent& keyEvent);
1106     bool OnKeyEventNodeUser(KeyEventInfo& info, const KeyEvent& keyEvent);
1107     bool RequestNextFocusByKey(const KeyEvent& keyEvent);
1108 
1109     // donot move focus before detach if has focus view child
1110     bool SkipFocusMoveBeforeRemove() const;
1111 
1112     OnFocusFunc onFocusInternal_;
1113     OnBlurFunc onBlurInternal_;
1114     OnBlurReasonFunc onBlurReasonInternal_;
1115     std::unordered_map<OnKeyEventType, OnKeyEventFunc> onKeyEventsInternal_;
1116     OnPreFocusFunc onPreFocusCallback_;
1117     OnClearFocusStateFunc onClearFocusStateCallback_;
1118     OnPaintFocusStateFunc onPaintFocusStateCallback_;
1119 
1120     RefPtr<FocusCallbackEvents> focusCallbackEvents_;
1121 
1122     RefPtr<TouchEventImpl> focusOnTouchListener_;
1123 
1124     WeakPtr<EventHub> eventHub_;
1125 
1126     WeakPtr<FocusHub> lastWeakFocusNode_ { nullptr };
1127     int32_t lastFocusNodeIndex_ { -1 };
1128     int32_t lastTabIndexNodeId_ { DEFAULT_TAB_FOCUSED_INDEX };
1129 
1130     bool focusable_ { true };
1131     bool isFocusableExplicit_ { false };
1132     bool implicitFocusable_ { false };
1133     bool parentFocusable_ { true };
1134     bool currentFocus_ { false };
1135     bool isFocusUnit_ { false };
1136     bool hasForwardMovement_ { false };
1137     bool hasBackwardMovement_ { false };
1138     bool isFocusActiveWhenFocused_ { false };
1139     bool isRaisedZIndex_ { false };
1140 
1141     FocusType focusType_ = FocusType::DISABLE;
1142     FocusStyleType focusStyleType_ = FocusStyleType::NONE;
1143     std::unique_ptr<FocusPaintParam> focusPaintParamsPtr_;
1144     std::function<void(RoundRect&)> getInnerFocusRectFunc_;
1145     FocusBox box_;
1146 
1147     RectF rectFromOrigin_;
1148     ScopeFocusAlgorithm focusAlgorithm_;
1149     BlurReason blurReason_ = BlurReason::FOCUS_SWITCH;
1150     FocusDependence focusDepend_ = FocusDependence::CHILD;
1151 
1152     std::string focusScopeId_;
1153     bool isFocusScope_ { false };
1154     bool isGroup_ { false };
1155     FocusPriority focusPriority_ = FocusPriority::AUTO;
1156 };
1157 } // namespace OHOS::Ace::NG
1158 
1159 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_FOCUS_HUB_H
1160