• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023-2025 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_PATTERNS_SCROLLABLE_SCROLLABLE_PATTERN_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_SCROLLABLE_SCROLLABLE_PATTERN_H
18 
19 #include <cmath>
20 #include <vector>
21 
22 #include "base/geometry/axis.h"
23 #include "core/animation/bezier_variable_velocity_motion.h"
24 #include "core/animation/select_motion.h"
25 #include "core/animation/spring_curve.h"
26 #include "core/animation/velocity_motion.h"
27 #include "core/components_ng/base/frame_scene_status.h"
28 #include "core/components_ng/event/drag_event.h"
29 #include "core/components_ng/event/scrollable_event.h"
30 #include "core/components_ng/pattern/navigation/nav_bar_pattern.h"
31 #include "core/components_ng/pattern/navrouter/navdestination_pattern.h"
32 #include "core/components_ng/pattern/overlay/sheet_presentation_pattern.h"
33 #include "core/components_ng/pattern/pattern.h"
34 #include "core/components_ng/pattern/scroll/inner/scroll_bar.h"
35 #include "core/components_ng/pattern/scroll/inner/scroll_bar_overlay_modifier.h"
36 #include "core/components_ng/pattern/scroll_bar/proxy/scroll_bar_proxy.h"
37 #include "core/components_ng/pattern/scrollable/nestable_scroll_container.h"
38 #include "core/components_ng/pattern/scrollable/refresh_coordination.h"
39 #include "core/components_ng/pattern/scrollable/scrollable_controller.h"
40 #include "core/components_ng/pattern/scrollable/scrollable_coordination_event.h"
41 #include "core/components_ng/pattern/scrollable/scrollable_paint_method.h"
42 #include "core/components_ng/pattern/scrollable/scrollable_paint_property.h"
43 #include "core/components_ng/pattern/scrollable/scrollable_properties.h"
44 #include "core/components_ng/pattern/scrollable/scrollable_theme.h"
45 #include "core/components_ng/render/animation_utils.h"
46 #include "core/event/mouse_event.h"
47 #ifdef SUPPORT_DIGITAL_CROWN
48 #include "core/event/crown_event.h"
49 #endif
50 #include "core/event/statusbar/statusbar_event_proxy.h"
51 namespace OHOS::Ace::NG {
52 class InspectorFilter;
53 #ifndef WEARABLE_PRODUCT
54 constexpr double FRICTION = 0.6;
55 constexpr double API11_FRICTION = 0.7;
56 constexpr double API12_FRICTION = 0.75;
57 constexpr double SLOW_FRICTION_THRESHOLD = 3000.0;
58 constexpr double SLOW_FRICTION = 1.0;
59 constexpr double MAX_VELOCITY = 9000.0;
60 constexpr double VELOCITY_SCALE = 1.0;
61 constexpr double SLOW_VELOCITY_SCALE = 1.2;
62 constexpr double NEW_VELOCITY_SCALE = 1.5;
63 #else
64 constexpr double FRICTION = 0.9;
65 constexpr double VELOCITY_SCALE = 0.8;
66 constexpr double MAX_VELOCITY = 5000.0;
67 #endif
68 constexpr float SPRING_ACCURACY = 0.1f;
69 enum class ModalSheetCoordinationMode : char {
70     UNKNOWN = 0,
71     SHEET_SCROLL = 1,
72     SCROLLABLE_SCROLL = 2,
73 };
74 struct ScrollOffsetAbility {
75     std::function<bool(float)> scrollFunc = nullptr;
76     Axis axis = Axis::VERTICAL;
77     float contentStartOffset = 0.0f;
78     float contentEndOffset = 0.0f;
79 };
80 class ScrollablePattern : public NestableScrollContainer, public virtual StatusBarClickListener {
81     DECLARE_ACE_TYPE(ScrollablePattern, NestableScrollContainer);
82 
83 public:
84     ScrollablePattern();
85     ScrollablePattern(EdgeEffect edgeEffect, bool alwaysEnabled);
86 
87     ~ScrollablePattern() override;
88 
IsAtomicNode()89     bool IsAtomicNode() const override
90     {
91         return false;
92     }
93 
94     RefPtr<PaintProperty> CreatePaintProperty() override;
95 
96     void CreateAnalyzerOverlay(const RefPtr<FrameNode> node);
97 
98     void UpdateFadingEdge(const RefPtr<ScrollablePaintMethod>& paint);
99 
100     void ToJsonValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const override;
101     void OnWindowHide() override;
102 
103     // scrollable
GetAxis()104     Axis GetAxis() const override
105     {
106         return axis_;
107     }
108 
IsReverse()109     virtual bool IsReverse() const
110     {
111         return GetAxis() == Axis::HORIZONTAL && IsRTL();
112     };
113 
IsRTL()114     bool IsRTL() const
115     {
116         auto host = GetHost();
117         CHECK_NULL_RETURN(host, false);
118         auto layoutProperty = host->GetLayoutProperty<LayoutProperty>();
119         CHECK_NULL_RETURN(layoutProperty, false);
120         auto layoutDirection = layoutProperty->GetNonAutoLayoutDirection();
121         return (layoutDirection == TextDirection::RTL);
122     };
123 
ShouldDelayChildPressedState()124     virtual bool ShouldDelayChildPressedState() const override
125     {
126         return true;
127     }
128 
ShouldPreventChildPressedState()129     virtual bool ShouldPreventChildPressedState() const override
130     {
131         return isHitTestBlock_;
132     }
133 
134     void RegisterScrollingListener(const RefPtr<ScrollingListener> listener) override;
135     void FireAndCleanScrollingListener() override;
136     void CleanScrollingListener() override;
137 
138     void SetAxis(Axis axis);
139     virtual bool UpdateCurrentOffset(float delta, int32_t source) = 0;
IsScrollable()140     virtual bool IsScrollable() const
141     {
142         return false;
143     }
144     virtual bool IsAtTop() const = 0;
145     virtual bool IsAtBottom(bool considerRepeat = false) const = 0;
IsAtTopWithDelta()146     virtual bool IsAtTopWithDelta() const
147     {
148         return IsAtTop();
149     }
IsAtBottomWithDelta()150     virtual bool IsAtBottomWithDelta() const
151     {
152         return IsAtBottom();
153     }
IsFadingBottom()154     virtual bool IsFadingBottom() const
155     {
156         return !IsAtBottom();
157     }
OutBoundaryCallback()158     virtual bool OutBoundaryCallback()
159     {
160         return IsOutOfBoundary();
161     }
162 
163     virtual bool IsOutOfBoundary(bool useCurrentDelta = true)
164     {
165         return false;
166     }
167 
168     virtual void OnTouchDown(const TouchEventInfo& info);
169 
170     void AddScrollEvent();
GetScrollableEvent()171     RefPtr<ScrollableEvent> GetScrollableEvent()
172     {
173         return scrollableEvent_;
174     }
175 
GetScrollable()176     RefPtr<Scrollable> GetScrollable()
177     {
178         CHECK_NULL_RETURN(scrollableEvent_, nullptr);
179         return scrollableEvent_->GetScrollable();
180     }
181 
182     virtual bool OnScrollCallback(float offset, int32_t source);
183     virtual void OnScrollStartCallback();
184     virtual void FireOnScrollStart(bool withPerfMonitor = true);
FireOnReachStart(const OnReachEvent & onReachStart,const OnReachEvent & onJSFrameNodeReachStart)185     virtual void FireOnReachStart(const OnReachEvent& onReachStart, const OnReachEvent& onJSFrameNodeReachStart) {}
FireOnReachEnd(const OnReachEvent & onReachEnd,const OnReachEvent & onJSFrameNodeReachEnd)186     virtual void FireOnReachEnd(const OnReachEvent& onReachEnd, const OnReachEvent& onJSFrameNodeReachEnd) {}
ScrollableIdle()187     bool ScrollableIdle()
188     {
189         return !scrollableEvent_ || scrollableEvent_->Idle();
190     }
SetScrollEnabled(bool enabled)191     void SetScrollEnabled(bool enabled)
192     {
193         CHECK_NULL_VOID(scrollableEvent_);
194         bool bNest = false;
195         if (scrollBarProxy_) {
196             bNest = scrollBarProxy_->IsNestScroller();
197         }
198 
199         if (enabled || bNest) {
200             enabled = true;
201             scrollableEvent_->SetAxis(axis_);
202         } else {
203             scrollableEvent_->SetAxis(Axis::NONE);
204         }
205         scrollableEvent_->SetEnabled(enabled);
206 
207         if (scrollBarProxy_) {
208             scrollBarProxy_->SetScrollEnabled(enabled, AceType::WeakClaim(this));
209         }
210     }
211 
GetScrollEnabled()212     bool GetScrollEnabled() const
213     {
214         CHECK_NULL_RETURN(scrollableEvent_, false);
215         return scrollableEvent_->GetEnabled();
216     }
217 
218     RefPtr<GestureEventHub> GetGestureHub();
219     RefPtr<InputEventHub> GetInputHub();
220 
221     // edgeEffect
222     const RefPtr<ScrollEdgeEffect>& GetScrollEdgeEffect() const;
223     bool CanFadeEffect(float offset, bool isAtTop, bool isAtBottom) const;
224     bool HandleEdgeEffect(float offset, int32_t source, const SizeF& size);
225     void HandleFadeEffect(float offset, int32_t source, const SizeF& size,
226         bool isNotPositiveScrollableDistance);
SetEdgeEffectCallback(const RefPtr<ScrollEdgeEffect> & scrollEffect)227     virtual void SetEdgeEffectCallback(const RefPtr<ScrollEdgeEffect>& scrollEffect) {}
228     bool IsRestrictBoundary();
229     // scrollBar
230     virtual void UpdateScrollBarOffset() = 0;
231     void SetScrollBar(const std::unique_ptr<ScrollBarProperty>& property);
232     virtual RefPtr<ScrollBar> CreateScrollBar();
233     void SetScrollBar(DisplayMode displayMode);
234     void SetScrollBarProxy(const RefPtr<ScrollBarProxy>& scrollBarProxy);
235     virtual RefPtr<ScrollBarOverlayModifier> CreateOverlayModifier();
236     void CreateScrollBarOverlayModifier();
237 
GetScrollableDistance()238     float GetScrollableDistance() const
239     {
240         return estimatedHeight_;
241     }
242 
GetBarOffset()243     float GetBarOffset() const
244     {
245         return barOffset_;
246     }
247 
GetScrollBarOutBoundaryExtent()248     float GetScrollBarOutBoundaryExtent() const
249     {
250         return scrollBarOutBoundaryExtent_;
251     }
252 
SetScrollBarOutBoundaryExtent(float scrollBarOutBoundaryExtent)253     void SetScrollBarOutBoundaryExtent(float scrollBarOutBoundaryExtent)
254     {
255         scrollBarOutBoundaryExtent_ = scrollBarOutBoundaryExtent;
256     }
257 
258     void HandleScrollBarOutBoundary(float scrollBarOutBoundaryExtent);
259 
GetMainSize(const SizeF & size)260     double GetMainSize(const SizeF& size) const
261     {
262         return axis_ == Axis::HORIZONTAL ? size.Width() : size.Height();
263     }
264 
IsScrollableStopped()265     bool IsScrollableStopped() const
266     {
267         CHECK_NULL_RETURN(scrollableEvent_, true);
268         auto scrollable = scrollableEvent_->GetScrollable();
269         CHECK_NULL_RETURN(scrollable, true);
270         return scrollable->IsStopped();
271     }
272 
GetIsDragging()273     bool GetIsDragging() const
274     {
275         CHECK_NULL_RETURN(scrollableEvent_, false);
276         auto scrollable = scrollableEvent_->GetScrollable();
277         CHECK_NULL_RETURN(scrollable, false);
278         return scrollable->GetIsDragging();
279     }
280 
StopScrollable()281     void StopScrollable()
282     {
283         CHECK_NULL_VOID(scrollableEvent_);
284         auto scrollable = scrollableEvent_->GetScrollable();
285         CHECK_NULL_VOID(scrollable);
286         scrollable->StopScrollable();
287     }
288 
StartSnapAnimation(SnapAnimationOptions snapAnimationOptions)289     virtual bool StartSnapAnimation(SnapAnimationOptions snapAnimationOptions)
290     {
291         return false;
292     }
293 
294     bool IsScrollableSpringEffect() const;
295 
SetCoordEventNeedSpringEffect(bool IsCoordEventNeedSpring)296     void SetCoordEventNeedSpringEffect(bool IsCoordEventNeedSpring)
297     {
298         isCoordEventNeedSpring_ = IsCoordEventNeedSpring;
299     }
300 
301     void GetParentNavigation();
302     void GetParentModalSheet();
303 
304     /**
305      * @brief Return the portion of delta that's in overScroll range.
306      *
307      * @param delta incoming offset change.
308      * @return the portion of delta in overScroll range. Both top overScroll and bottom overScroll.
309      */
GetOverScrollOffset(double delta)310     virtual OverScrollOffset GetOverScrollOffset(double delta) const
311     {
312         return { 0, 0 };
313     }
314 
StartScrollBarAnimatorByProxy()315     void StartScrollBarAnimatorByProxy()
316     {
317         if (scrollBarProxy_) {
318             scrollBarProxy_->StartScrollBarAnimator();
319         }
320 
321         for (auto proxy : nestScrollBarProxy_) {
322             auto scrollBarProxy = proxy.Upgrade();
323             CHECK_NULL_CONTINUE(scrollBarProxy);
324             scrollBarProxy->StartScrollBarAnimator();
325         }
326     }
327 
StopScrollBarAnimatorByProxy()328     void StopScrollBarAnimatorByProxy()
329     {
330         if (scrollBarProxy_) {
331             scrollBarProxy_->StopScrollBarAnimator();
332         }
333 
334         for (auto proxy : nestScrollBarProxy_) {
335             auto scrollBarProxy = proxy.Upgrade();
336             CHECK_NULL_CONTINUE(scrollBarProxy);
337             scrollBarProxy->StopScrollBarAnimator();
338         }
339     }
340 
341     virtual void SetFriction(double friction);
342 
GetFriction()343     double GetFriction() const
344     {
345         return friction_;
346     }
347 
348     void SetVelocityScale(double scale);
349 
350     void SetMaxFlingVelocity(double max);
351 
GetMaxFlingVelocity()352     double GetMaxFlingVelocity() const
353     {
354         CHECK_NULL_RETURN(scrollableEvent_, 0.0);
355         auto scrollable = scrollableEvent_->GetScrollable();
356         CHECK_NULL_RETURN(scrollable, 0.0);
357         return scrollable->GetMaxFlingVelocity();
358     }
359 
360     virtual void StopAnimate();
AnimateRunning()361     bool AnimateRunning() const
362     {
363         return (animator_ && animator_->IsRunning()) || !isAnimationStop_;
364     }
AnimateStoped()365     bool AnimateStoped() const
366     {
367         return (!animator_ || animator_->IsStopped()) && isAnimationStop_;
368     }
369 
AbortScrollAnimator()370     void AbortScrollAnimator()
371     {
372         if (animator_ && !animator_->IsStopped()) {
373             scrollAbort_ = true;
374             animator_->Stop();
375         }
376         if (!isAnimationStop_) {
377             scrollAbort_ = true;
378             StopAnimation(springAnimation_);
379             StopAnimation(curveAnimation_);
380         }
381     }
GetScrollAbort()382     bool GetScrollAbort() const
383     {
384         return scrollAbort_;
385     }
SetScrollAbort(bool abort)386     void SetScrollAbort(bool abort)
387     {
388         scrollAbort_ = abort;
389     }
390     void PlaySpringAnimation(
391         float position, float velocity, float mass, float stiffness, float damping, bool useTotalOffset = true);
392     void PlayCurveAnimation(float position, float duration, const RefPtr<Curve>& curve, bool canOverScroll);
GetTotalOffset()393     virtual double GetTotalOffset() const
394     {
395         return 0.0f;
396     }
397 
398     /* ============================= Free Scroll Enhancements ============================= */
GetFreeScrollOffset()399     virtual Offset GetFreeScrollOffset() const
400     {
401         return {};
402     }
FreeScrollBy(const OffsetF & delta)403     virtual bool FreeScrollBy(const OffsetF& delta)
404     {
405         return false;
406     }
FreeScrollPage(bool reverse,bool smooth)407     virtual bool FreeScrollPage(bool reverse, bool smooth)
408     {
409         return false;
410     }
FreeScrollToEdge(ScrollEdgeType type,bool smooth,std::optional<float> velocity)411     virtual bool FreeScrollToEdge(ScrollEdgeType type, bool smooth, std::optional<float> velocity)
412     {
413         return false;
414     }
FreeScrollTo(const ScrollControllerBase::ScrollToParam & param)415     virtual void FreeScrollTo(const ScrollControllerBase::ScrollToParam& param) {}
416     /* ============================================================================== */
417 
GetContentStartOffset()418     virtual float GetContentStartOffset() const
419     {
420         return 0.0f;
421     }
422     // main size of all children
GetTotalHeight()423     virtual float GetTotalHeight() const
424     {
425         return 0.0f;
426     }
OnAnimateStop()427     virtual void OnAnimateStop() {}
428     virtual void ScrollTo(float position);
429     virtual void AnimateTo(
430         float position, float duration, const RefPtr<Curve> &curve, bool smooth, bool canOverScroll = false,
431         bool useTotalOffset = true);
CanOverScroll(int32_t source)432     virtual bool CanOverScroll(int32_t source)
433     {
434         auto canOverScroll =
435             (IsScrollableSpringEffect() && source != SCROLL_FROM_AXIS && source != SCROLL_FROM_BAR && IsScrollable() &&
436                 (!ScrollableIdle() || animateOverScroll_ || animateCanOverScroll_));
437         if (canOverScroll != lastCanOverScroll_) {
438             lastCanOverScroll_ = canOverScroll;
439             AddScrollableFrameInfo(source);
440         }
441         return canOverScroll;
442     }
CanOverScrollStart(int32_t source)443     bool CanOverScrollStart(int32_t source)
444     {
445         return CanOverScroll(source) && GetEffectEdge() != EffectEdge::END;
446     }
CanOverScrollEnd(int32_t source)447     bool CanOverScrollEnd(int32_t source)
448     {
449         return CanOverScroll(source) && GetEffectEdge() != EffectEdge::START;
450     }
SetCanStayOverScroll(bool canStayOverScroll)451     void SetCanStayOverScroll(bool canStayOverScroll)
452     {
453         canStayOverScroll_ = canStayOverScroll;
454     }
GetCanStayOverScroll()455     bool GetCanStayOverScroll() const
456     {
457         return canStayOverScroll_;
458     }
ChangeAnimateOverScroll()459     void ChangeAnimateOverScroll()
460     {
461         if (GetScrollSource() == SCROLL_FROM_JUMP && GetCanStayOverScroll()) {
462             SetAnimateCanOverScroll(false);
463         }
464     }
ChangeCanStayOverScroll()465     void ChangeCanStayOverScroll()
466     {
467         if (GetIsOverScroll()) {
468             if (!IsOutOfBoundary()) {
469                 SetIsOverScroll(false);
470             }
471         }
472     }
473     void MarkSelectedItems();
474     bool ShouldSelectScrollBeStopped();
475     void UpdateMouseStart(float offset);
476 
477     // scrollSnap
CalcPredictSnapOffset(float delta,float dragDistance,float velocity,SnapDirection snapDirection)478     virtual std::optional<float> CalcPredictSnapOffset(
479         float delta, float dragDistance, float velocity, SnapDirection snapDirection)
480     {
481         std::optional<float> predictSnapPosition;
482         return predictSnapPosition;
483     }
484 
SetLastSnapTargetIndex(int32_t lastSnapTargetIndex)485     virtual void SetLastSnapTargetIndex(int32_t lastSnapTargetIndex) {}
486 
GetLastSnapTargetIndex()487     virtual std::optional<int32_t> GetLastSnapTargetIndex()
488     {
489         return std::nullopt;
490     }
491 
ResetLastSnapTargetIndex()492     virtual void ResetLastSnapTargetIndex() {}
493 
ResetScrollableSnapDirection()494     void ResetScrollableSnapDirection()
495     {
496         auto scrollable = GetScrollable();
497         CHECK_NULL_VOID(scrollable);
498         scrollable->ResetSnapDirection();
499     }
500 
SetScrollableCurrentPos(float currentPos)501     void SetScrollableCurrentPos(float currentPos)
502     {
503         auto scrollable = GetScrollable();
504         CHECK_NULL_VOID(scrollable);
505         return scrollable->SetCurrentPos(currentPos);
506     }
507 
NeedScrollSnapToSide(float delta)508     virtual bool NeedScrollSnapToSide(float delta)
509     {
510         return false;
511     }
512 
SetScrollSource(int32_t scrollSource)513     void SetScrollSource(int32_t scrollSource)
514     {
515         if (scrollSource == SCROLL_FROM_NONE) {
516             if (lastScrollSource_ != scrollSource_) {
517                 AddScrollableFrameInfo(scrollSource_);
518             }
519             lastScrollSource_ = scrollSource_;
520         }
521         scrollSource_ = scrollSource;
522     }
523 
GetScrollSource()524     int32_t GetScrollSource() const
525     {
526         return scrollSource_;
527     }
528 
GetCurrentVelocity()529     float GetCurrentVelocity() const
530     {
531         return currentVelocity_;
532     }
533 
GetScrollableCurrentVelocity()534     double GetScrollableCurrentVelocity() const
535     {
536         CHECK_NULL_RETURN(scrollableEvent_, 0.0);
537         auto scrollable = scrollableEvent_->GetScrollable();
538         CHECK_NULL_RETURN(scrollable, 0.0);
539         return scrollable->GetCurrentVelocity();
540     }
541 
542     ScrollState GetScrollState() const;
543 
544     static ScrollState GetScrollState(int32_t scrollSource);
545 
546     static ScrollSource ConvertScrollSource(int32_t source);
547 
548     static int32_t ScrollToTarget(
549         RefPtr<FrameNode>& scrollable, RefPtr<FrameNode>& target, float targetOffset, ScrollAlign targetAlign);
550 
CalculateFriction(float gamma)551     float CalculateFriction(float gamma)
552     {
553         gamma = std::clamp(gamma, 0.0f, 1.0f);
554         return exp(-ratio_.value_or(1.848f) * gamma);
555     }
556     virtual float GetMainContentSize() const;
557 
SupportScrollToIndex()558     virtual bool SupportScrollToIndex() const
559     {
560         return true;
561     }
562 
GetDefaultScrollAlign()563     virtual ScrollAlign GetDefaultScrollAlign() const
564     {
565         return ScrollAlign::START;
566     }
567 
568     virtual void ScrollToIndex(int32_t index, bool smooth = false, ScrollAlign align = ScrollAlign::START,
569         std::optional<float> extraOffset = std::nullopt)
570     {}
571 
SetExtraOffset(std::optional<float> extraOffset)572     void SetExtraOffset(std::optional<float> extraOffset)
573     {
574         extraOffset_ = extraOffset;
575     }
576 
GetExtraOffset()577     const std::optional<float>& GetExtraOffset() const
578     {
579         return extraOffset_;
580     }
581 
ResetExtraOffset()582     void ResetExtraOffset()
583     {
584         extraOffset_.reset();
585     }
586 
587     virtual void ScrollToEdge(ScrollEdgeType scrollEdgeType, bool smooth);
588 
GetScrollEdgeType()589     virtual ScrollEdgeType GetScrollEdgeType() const
590     {
591         return ScrollEdgeType::SCROLL_NONE;
592     }
593 
SetScrollEdgeType(ScrollEdgeType scrollEdgeType)594     virtual void SetScrollEdgeType(ScrollEdgeType scrollEdgeType) {}
595 
596     virtual void Fling(double flingVelocity);
597 
SetPositionController(RefPtr<ScrollableController> control)598     void SetPositionController(RefPtr<ScrollableController> control)
599     {
600         positionController_ = control;
601         if (control) {
602             control->SetScrollPattern(AceType::WeakClaim(this));
603         }
604     }
605 
GetOrCreatePositionController()606     RefPtr<ScrollableController> GetOrCreatePositionController()
607     {
608         if (!positionController_) {
609             auto controller = AceType::MakeRefPtr<NG::ScrollableController>();
610             SetPositionController(controller);
611         }
612         return positionController_;
613     }
614 
GetItemRect(int32_t index)615     virtual Rect GetItemRect(int32_t index) const
616     {
617         return Rect();
618     };
619 
GetItemIndex(double x,double y)620     virtual int32_t GetItemIndex(double x, double y) const
621     {
622         return -1;
623     }
624 
625     void SetEdgeEffect(EdgeEffect edgeEffect, bool alwaysEnabled, EffectEdge effectEdge = EffectEdge::ALL)
626     {
627         edgeEffect_ = edgeEffect;
628         edgeEffectAlwaysEnabled_ = alwaysEnabled;
629         effectEdge_ = effectEdge;
630     }
631 
GetEdgeEffect()632     EdgeEffect GetEdgeEffect()
633     {
634         return edgeEffect_;
635     }
636 
GetAlwaysEnabled()637     bool GetAlwaysEnabled() const
638     {
639         return edgeEffectAlwaysEnabled_;
640     }
641 
GetEffectEdge()642     EffectEdge GetEffectEdge() const
643     {
644         return effectEdge_;
645     }
646 
SetAlwaysEnabled(bool alwaysEnabled)647     void SetAlwaysEnabled(bool alwaysEnabled)
648     {
649         edgeEffectAlwaysEnabled_ = alwaysEnabled;
650     }
651 
IsScrollableAnimationNotRunning()652     bool IsScrollableAnimationNotRunning()
653     {
654         if (scrollableEvent_) {
655             auto scrollable = scrollableEvent_->GetScrollable();
656             if (scrollable) {
657                 return scrollable->IsAnimationNotRunning();
658             }
659             return false;
660         }
661         return false;
662     }
663 
GetFinalPosition()664     float GetFinalPosition() const
665     {
666         return finalPosition_;
667     }
668     void HandleOnDragStatusCallback(
669         const DragEventType& dragEventType, const RefPtr<NotifyDragEvent>& notifyDragEvent) override;
670 
IsScrollableSpringMotionRunning()671     bool IsScrollableSpringMotionRunning()
672     {
673         CHECK_NULL_RETURN(scrollableEvent_, false);
674         auto scrollable = scrollableEvent_->GetScrollable();
675         CHECK_NULL_RETURN(scrollable, false);
676         return scrollable->IsSpringMotionRunning();
677     }
678 
GetSnapType()679     virtual SnapType GetSnapType()
680     {
681         return SnapType::NONE_SNAP;
682     }
683 
IsScrollSnap()684     virtual bool IsScrollSnap()
685     {
686         // When setting snap or enablePaging in scroll, the PARENT_FIRST in nestedScroll_ is invalid
687         return false;
688     }
689 
IsEnablePagingValid()690     virtual bool IsEnablePagingValid()
691     {
692         return false;
693     }
694 
SetAnimateCanOverScroll(bool animateCanOverScroll)695     void SetAnimateCanOverScroll(bool animateCanOverScroll)
696     {
697         bool isScrollable = !(IsAtBottom() && IsAtTop() && !GetAlwaysEnabled());
698         animateCanOverScroll_ = isScrollable && animateCanOverScroll;
699     }
700 
GetVisibleSelectedItems()701     virtual std::vector<RefPtr<FrameNode>> GetVisibleSelectedItems()
702     {
703         std::vector<RefPtr<FrameNode>> children;
704         return children;
705     }
706     void InitScrollBarGestureEvent();
707     virtual void InitScrollBarClickEvent();
708     void HandleClickEvent();
709     void InitScrollBarMouseEvent();
710     virtual void ScrollPage(
711         bool reverse, bool smooth = false, AccessibilityScrollType scrollType = AccessibilityScrollType::SCROLL_FULL);
712     void ScrollPageMultiThread(
713         bool reverse, bool smooth = false, AccessibilityScrollType scrollType = AccessibilityScrollType::SCROLL_FULL);
714     void PrintOffsetLog(AceLogTag tag, int32_t id, double finalOffset);
715 
716     void CheckRestartSpring(bool sizeDiminished, bool needNestedScrolling = true);
717 
GetScrollablePanDirection()718     Axis GetScrollablePanDirection()
719     {
720         CHECK_NULL_RETURN(scrollableEvent_, Axis::NONE);
721         auto scrollable = scrollableEvent_->GetScrollable();
722         CHECK_NULL_RETURN(scrollable, Axis::NONE);
723         return scrollable->GetPanDirection();
724     }
725 
726     void AddEventsFiredInfo(ScrollableEventType eventType);
727 
728     void AddScrollableFrameInfo(int32_t scrollSource);
729 
730     void GetEdgeEffectDumpInfo();
731     void GetEdgeEffectDumpInfo(std::unique_ptr<JsonValue>& json);
732 
733     void GetAxisDumpInfo();
734     void GetAxisDumpInfo(std::unique_ptr<JsonValue>& json);
735 
736     void GetPanDirectionDumpInfo();
737     void GetPanDirectionDumpInfo(std::unique_ptr<JsonValue>& json);
738 
739     void GetPaintPropertyDumpInfo();
740     void GetPaintPropertyDumpInfo(std::unique_ptr<JsonValue>& json);
741 
742     virtual void GetEventDumpInfo();
743     virtual void GetEventDumpInfo(std::unique_ptr<JsonValue>& json);
744 
745     void DumpAdvanceInfo() override;
746     void DumpAdvanceInfo(std::unique_ptr<JsonValue>& json) override;
747 
SetScrollToSafeAreaHelper(bool isScrollToSafeAreaHelper)748     void SetScrollToSafeAreaHelper(bool isScrollToSafeAreaHelper)
749     {
750         isScrollToSafeAreaHelper_ = isScrollToSafeAreaHelper;
751     }
752 
IsScrollToSafeAreaHelper()753     bool IsScrollToSafeAreaHelper() const
754     {
755         return isScrollToSafeAreaHelper_;
756     }
757 
GetScrollOffsetAbility()758     virtual ScrollOffsetAbility GetScrollOffsetAbility()
759     {
760         return { nullptr, Axis::NONE };
761     }
762 
GetScrollIndexAbility()763     virtual std::function<bool(int32_t)> GetScrollIndexAbility()
764     {
765         return nullptr;
766     }
767 
768     void ScrollAtFixedVelocity(float velocity);
769 
770     PositionMode GetPositionMode();
771 
772     void HandleMoveEventInComp(const PointF& point);
773     void HandleLeaveHotzoneEvent();
SetHotZoneScrollCallback(std::function<void (void)> && func)774     void SetHotZoneScrollCallback(std::function<void(void)>&& func)
775     {
776         hotZoneScrollCallback_ = func;
777     }
778 
779     void SetIsOverScroll(bool val);
780     bool GetIsOverScroll() const;
781 
SetScrollBarShape(const ScrollBarShape & shape)782     void SetScrollBarShape(const ScrollBarShape &shape)
783     {
784         if (shape == ScrollBarShape::ARC) {
785             isRoundScroll_ = true;
786         } else {
787             isRoundScroll_ = false;
788         }
789     }
790 
791 #ifdef SUPPORT_DIGITAL_CROWN
GetCrownEventDragging()792     bool GetCrownEventDragging() const
793     {
794         CHECK_NULL_RETURN(scrollableEvent_, false);
795         auto scrollable = scrollableEvent_->GetScrollable();
796         CHECK_NULL_RETURN(scrollable, false);
797         return scrollable->GetCrownEventDragging();
798     }
799 #endif
800 
801     void OnCollectClickTarget(const OffsetF& coordinateOffset, const GetEventTargetImpl& getEventTargetImpl,
802         TouchTestResult& result, const RefPtr<FrameNode>& frameNode, const RefPtr<TargetComponent>& targetComponent,
803         ResponseLinkResult& responseLinkResult);
804 
805     virtual void SetAccessibilityAction();
GetScrollBarProxy()806     RefPtr<NG::ScrollBarProxy> GetScrollBarProxy() const
807     {
808         return scrollBarProxy_;
809     }
810 
811     virtual void OnAttachToMainTree() override;
812 
813     void AddNestScrollBarProxy(const WeakPtr<ScrollBarProxy>& scrollBarProxy);
814 
815     void SetParentNestedScroll(RefPtr<ScrollablePattern>& parentPattern);
816 
817     void SearchAndSetParentNestedScroll(const RefPtr<FrameNode>& node);
818 
819     void UnsetParentNestedScroll(RefPtr<ScrollablePattern>& parentPattern);
820 
821     void SearchAndUnsetParentNestedScroll(const RefPtr<FrameNode>& node);
822 
823     void DeleteNestScrollBarProxy(const WeakPtr<ScrollBarProxy>& scrollBarProxy);
824 
SetUseTotalOffset(bool useTotalOffset)825     void SetUseTotalOffset(bool useTotalOffset)
826     {
827         useTotalOffset_ = useTotalOffset;
828     }
829 
GetNestedScrolling()830     bool GetNestedScrolling() const
831     {
832         CHECK_NULL_RETURN(scrollableEvent_, false);
833         auto scrollable = scrollableEvent_->GetScrollable();
834         CHECK_NULL_RETURN(scrollable, false);
835         return scrollable->GetNestedScrolling();
836     }
837 
IsScrolling()838     bool IsScrolling() const
839     {
840         return isScrolling_;
841     }
842 
843     void OnColorConfigurationUpdate() override;
844 
GetChildrenExpandedSize()845     virtual SizeF GetChildrenExpandedSize()
846     {
847         return SizeF();
848     }
849 
850     SizeF GetViewSizeMinusPadding() const;
851 
852     void ScrollEndCallback(bool nestedScroll, float velocity);
853 
854     void StopScrollableAndAnimate();
855 
856     void SetBackToTop(bool backToTop);
857 
858     void ResetBackToTop();
859 
GetBackToTop()860     bool GetBackToTop() const
861     {
862         return backToTop_;
863     }
864 
UseDefaultBackToTop(bool useDefaultBackToTop)865     void UseDefaultBackToTop(bool useDefaultBackToTop)
866     {
867         useDefaultBackToTop_ = useDefaultBackToTop;
868     }
869 
870     void OnStatusBarClick() override;
871 
872     void GetRepeatCountInfo(
873         RefPtr<UINode> node, int32_t& repeatDifference, int32_t& firstRepeatCount, int32_t& totalChildCount);
874 
875 #ifdef SUPPORT_DIGITAL_CROWN
876     void SetDigitalCrownSensitivity(CrownSensitivity sensitivity);
GetDigitalCrownSensitivity()877     CrownSensitivity GetDigitalCrownSensitivity() const
878     {
879         return crownSensitivity_;
880     }
881 #endif
GetDefaultScrollBarDisplayMode()882     virtual DisplayMode GetDefaultScrollBarDisplayMode() const
883     {
884         return DisplayMode::AUTO;
885     }
886 
887     void MarkScrollBarProxyDirty();
888 
ChildPreMeasureHelperEnabled()889     bool ChildPreMeasureHelperEnabled() override
890     {
891         return true;
892     }
PostponedTaskForIgnoreEnabled()893     bool PostponedTaskForIgnoreEnabled() override
894     {
895         return true;
896     }
897 
NeedCustomizeSafeAreaPadding()898     bool NeedCustomizeSafeAreaPadding() override
899     {
900         return true;
901     }
902 
903     PaddingPropertyF CustomizeSafeAreaPadding(PaddingPropertyF safeAreaPadding, bool needRotate) override;
904 
ChildTentativelyLayouted()905     bool ChildTentativelyLayouted() override
906     {
907         return true;
908     }
909 
910     bool AccumulatingTerminateHelper(RectF& adjustingRect, ExpandEdges& totalExpand, bool fromSelf = false,
911         LayoutSafeAreaType ignoreType = NG::LAYOUT_SAFE_AREA_TYPE_SYSTEM) override;
912 
SetNeedFullSafeArea(bool needFullSafeArea)913     void SetNeedFullSafeArea(bool needFullSafeArea)
914     {
915         needFullSafeArea_ = needFullSafeArea;
916     }
917 
GetScrollBar()918     RefPtr<ScrollBar> GetScrollBar() const
919     {
920         return scrollBar_;
921     }
922 protected:
923     void SuggestOpIncGroup(bool flag);
924     void OnDetachFromFrameNode(FrameNode* frameNode) override;
925     void OnDetachFromFrameNodeMultiThread(FrameNode* frameNode);
926     void OnDetachFromMainTree() override;
927     void OnDetachFromMainTreeMultiThread();
928     void UpdateScrollBarRegion(float offset, float estimatedHeight, Size viewPort, Offset viewOffset);
929 
930     EdgeEffect GetEdgeEffect() const;
SetEdgeEffect()931     void SetEdgeEffect()
932     {
933         SetEdgeEffect(edgeEffect_);
934     }
935 
936     virtual void FireOnScroll(float finalOffset, OnScrollEvent& onScroll) const;
937 
938     void FireObserverOnTouch(const TouchEventInfo& info);
939     void FireObserverOnReachStart();
940     void FireObserverOnReachEnd();
941     void FireObserverOnScrollStart();
942     void FireObserverOnScrollStop();
943     void FireObserverOnDidScroll(float finalOffset);
944     void FireObserverOnScrollerAreaChange(float finalOffset);
945     float FireObserverOnWillScroll(float offset);
946 
947     virtual void OnScrollStop(const OnScrollStopEvent& onScrollStop, const OnScrollStopEvent& onJSFrameNodeScrollStop);
948     void FireOnScrollStop(const OnScrollStopEvent& onScrollStop, const OnScrollStopEvent& onJSFrameNodeScrollStop);
949 
950     float FireOnWillScroll(float offset) const;
951 
952     // select with mouse
953     struct ItemSelectedStatus {
954         std::function<void(bool)> onSelected;
955         std::function<void(bool)> selectChangeEvent;
956         RectF rect;
957         bool selected = false;
FireSelectChangeEventItemSelectedStatus958         void FireSelectChangeEvent(bool isSelected)
959         {
960             if (selected == isSelected) {
961                 return;
962             }
963             selected = isSelected;
964             if (onSelected) {
965                 onSelected(isSelected);
966             }
967             if (selectChangeEvent) {
968                 selectChangeEvent(isSelected);
969             }
970         }
971     };
972     void InitMouseEvent();
973     void UninitMouseEvent();
974     void DrawSelectedZone(const RectF& selectedZone);
975     void ClearSelectedZone();
976     bool multiSelectable_ = false;
977     bool isMouseEventInit_ = false;
978     OffsetF mouseStartOffset_;
979     float selectScrollOffset_ = 0.0f;
980     float totalOffsetOfMousePressed_ = 0.0f;
981     std::unordered_map<int32_t, ItemSelectedStatus> itemToBeSelected_;
982     bool animateOverScroll_ = false;
983     bool animateCanOverScroll_ = false;
984     bool lastCanOverScroll_ = false;
985 
GetScrollBarOverlayModifier()986     RefPtr<ScrollBarOverlayModifier> GetScrollBarOverlayModifier() const
987     {
988         return scrollBarOverlayModifier_;
989     }
990 
SetScrollBarOverlayModifier(RefPtr<ScrollBarOverlayModifier> scrollBarOverlayModifier)991     void SetScrollBarOverlayModifier(RefPtr<ScrollBarOverlayModifier> scrollBarOverlayModifier)
992     {
993         scrollBarOverlayModifier_ = scrollBarOverlayModifier;
994     }
995     // just for hold ScrollableController
996     RefPtr<ScrollableController> positionController_;
997 
998     bool scrollStop_ = false;
999 
1000     // for onReachStart of the first layout
1001     bool isInitialized_ = false;
1002 
1003     void Register2DragDropManager();
1004 
SetScrollOriginChild(const WeakPtr<NestableScrollContainer> & scrollOriginChild)1005     void SetScrollOriginChild(const WeakPtr<NestableScrollContainer>& scrollOriginChild)
1006     {
1007         scrollOriginChild_ = scrollOriginChild;
1008     }
1009 
GetScrollOriginChild()1010     RefPtr<NestableScrollContainer> GetScrollOriginChild()
1011     {
1012         return scrollOriginChild_.Upgrade();
1013     }
1014 
1015     void SetCanOverScroll(bool val);
1016     bool GetCanOverScroll() const;
1017 
1018     void CheckScrollBarOff();
1019 
1020     void RecordScrollEvent(Recorder::EventType eventType);
1021 
IsBackToTopRunning()1022     bool IsBackToTopRunning() const
1023     {
1024         return isBackToTopRunning_;
1025     }
1026 
1027     std::string ParseCommand(const std::string& command);
1028 
1029 #ifdef SUPPORT_DIGITAL_CROWN
1030     void SetDigitalCrownEvent();
1031     CrownSensitivity crownSensitivity_ = CrownSensitivity::MEDIUM;
1032 #endif
1033 private:
OnScrollEndCallback()1034     virtual void OnScrollEndCallback() {};
1035 
1036     void RegisterScrollBarEventTask();
1037     bool OnScrollPosition(double& offset, int32_t source);
1038     void ProcessNavBarReactOnStart();
1039     float ProcessNavBarReactOnUpdate(float offset);
1040     void ProcessNavBarReactOnEnd();
1041     void InitSpringOffsetProperty();
1042     void InitCurveOffsetProperty();
1043     bool HandleCurveOffsetAnimateOverScroll();
1044     void OnAnimateFinish();
1045     void StopAnimation(std::shared_ptr<AnimationUtils::Animation> animation);
1046     void PauseAnimation(std::shared_ptr<AnimationUtils::Animation> animation);
1047     void InitOption(AnimationOption &option, float duration, const RefPtr<Curve>& curve);
1048     float GetScrollDelta(float offset, bool& stopAnimation);
1049 
1050     void OnAttachToFrameNode() override;
1051     void OnAttachToFrameNodeMultiThread();
1052     void OnAttachToMainTreeMultiThread();
1053     void InitTouchEvent(const RefPtr<GestureEventHub>& gestureHub);
1054     void RegisterWindowStateChangedCallback();
1055     void OnTouchTestDone(const std::shared_ptr<BaseGestureEvent>& baseGestureEvent,
1056         const std::list<RefPtr<NGGestureRecognizer>>& activeRecognizers);
1057 
1058     // select with mouse
MultiSelectWithoutKeyboard(const RectF & selectedZone)1059     virtual void MultiSelectWithoutKeyboard(const RectF& selectedZone) {};
ClearMultiSelect()1060     virtual void ClearMultiSelect() {};
IsItemSelected(float offsetX,float offsetY)1061     virtual bool IsItemSelected(float offsetX, float offsetY)
1062     {
1063         return false;
1064     }
1065     void ClearInvisibleItemsSelectedStatus();
1066     void HandleInvisibleItemsSelectedStatus(const RectF& selectedZone);
1067     void HandleDragStart(const GestureEvent& info);
1068     void HandleDragUpdate(const GestureEvent& info);
1069     void HandleDragEnd();
1070     void SelectWithScroll();
1071     RectF ComputeSelectedZone(const OffsetF& startOffset, const OffsetF& endOffset);
1072     float GetOutOfScrollableOffset() const;
1073     virtual float GetOffsetWithLimit(float offset) const;
1074     void LimitMouseEndOffset();
1075     void UpdateMouseStartOffset();
1076 
1077     void UpdateBorderRadius();
1078 
1079     /******************************************************************************
1080      * NestableScrollContainer implementations
1081      */
1082     void HandleExtScroll(float velocity = 0.f);
1083     ScrollResult HandleScroll(
1084         float offset, int32_t source, NestedState state = NestedState::GESTURE, float velocity = 0.f) override;
1085     bool HandleScrollVelocity(float velocity, const RefPtr<NestableScrollContainer>& child = nullptr) override;
1086 
1087     void RemainVelocityToChild(float remainVelocity) override;
NestedScrollOutOfBoundary()1088     bool NestedScrollOutOfBoundary() override
1089     {
1090         return OutBoundaryCallback();
1091     }
1092     void UpdateNestedScrollVelocity(float offset, NestedState state);
1093     float GetNestedScrollVelocity();
1094 
1095     void OnScrollEndRecursive(const std::optional<float>& velocity) override;
1096     void OnScrollEndRecursiveInner(const std::optional<float>& velocity);
1097     void OnScrollStartRecursive(WeakPtr<NestableScrollContainer> child, float position, float velocity = 0.f) override;
1098     void OnScrollStartRecursiveInner(WeakPtr<NestableScrollContainer> child, float position, float velocity = 0.f);
1099     void OnScrollDragEndRecursive() override;
1100     void StopScrollAnimation() override;
1101 
1102     ScrollResult HandleScrollParentFirst(float& offset, int32_t source, NestedState state);
1103     ScrollResult HandleScrollSelfFirst(float& offset, int32_t source, NestedState state);
1104     ScrollResult HandleScrollSelfOnly(float& offset, int32_t source, NestedState state);
1105     ScrollResult HandleScrollParallel(float& offset, int32_t source, NestedState state);
1106     /*
1107      *  End of NestableScrollContainer implementations
1108      *******************************************************************************/
1109 
1110     bool HandleOutBoundary(float& offset, int32_t source, NestedState state, ScrollResult& result);
1111     bool HasEdgeEffect(float offset, bool isWithRefresh = false) const;
1112     bool CanSpringOverScroll() const;
1113     bool HandleOverScroll(float velocity);
1114     bool HandleScrollableOverScroll(float velocity);
1115 
1116     void ExecuteScrollFrameBegin(float& mainDelta, ScrollState state);
1117 
1118     void OnScrollEnd();
1119     void ProcessSpringEffect(float velocity, bool needRestart = false);
1120     void SetEdgeEffect(EdgeEffect edgeEffect);
1121     void SetHandleScrollCallback(const RefPtr<Scrollable>& scrollable);
1122     void SetHandleExtScrollCallback(const RefPtr<Scrollable>& scrollable);
1123     void SetOverScrollCallback(const RefPtr<Scrollable>& scrollable);
1124     void SetIsReverseCallback(const RefPtr<Scrollable>& scrollable);
1125     void SetOnScrollStartRec(const RefPtr<Scrollable>& scrollable);
1126     void SetOnScrollEndRec(const RefPtr<Scrollable>& scrollable);
1127     void SetScrollEndCallback(const RefPtr<Scrollable>& scrollable);
1128     void SetRemainVelocityCallback(const RefPtr<Scrollable>& scrollable);
1129     void SetDragEndCallback(const RefPtr<Scrollable>& scrollable);
1130     void SetStartSnapAnimationCallback(const RefPtr<Scrollable>& scrollable);
1131     void SetNeedScrollSnapToSideCallback(const RefPtr<Scrollable>& scrollable);
1132     void SetDragFRCSceneCallback(const RefPtr<Scrollable>& scrollable);
1133     void SetOnContinuousSliding(const RefPtr<Scrollable>& scrollable);
1134     void SetGetSnapTypeCallback(const RefPtr<Scrollable>& scrollable);
1135     void SetOnWillStopDraggingCallback(const RefPtr<Scrollable>& scrollable);
1136     RefPtr<Scrollable> CreateScrollable();
1137 
1138     // Scrollable::UpdateScrollPosition
1139     bool HandleScrollImpl(float offset, int32_t source);
1140     void NotifyMoved(bool value);
CreateRefreshCoordination()1141     void CreateRefreshCoordination()
1142     {
1143         if (!refreshCoordination_) {
1144             auto host = GetHost();
1145             CHECK_NULL_VOID(host);
1146             refreshCoordination_ = AceType::MakeRefPtr<RefreshCoordination>(host);
1147         }
1148     }
1149     float GetVelocity() const;
1150     bool NeedSplitScroll(OverScrollOffset& overOffsets, int32_t source);
1151     RefreshCoordinationMode CoordinateWithRefresh(double& offset, int32_t source, bool isAtTop);
1152     bool CoordinateWithNavigation(double& offset, int32_t source, bool isAtTop);
1153     void NotifyFRCSceneInfo(const std::string& scene, double velocity, SceneStatus sceneStatus);
1154     ModalSheetCoordinationMode CoordinateWithSheet(double& offset, int32_t source, bool isAtTop);
1155     bool NeedCoordinateScrollWithNavigation(double offset, int32_t source, const OverScrollOffset& overOffsets);
1156     void SetUiDvsyncSwitch(bool on);
1157     void SetUiDVSyncCommandTime(uint64_t time);
1158     void SetNestedScrolling(bool nestedScrolling);
1159     void InitRatio();
1160     void SetOnHiddenChangeForParent();
1161     void ReportOnItemStopEvent();
ResetForExtScroll()1162     virtual void ResetForExtScroll() {};
1163 
1164     Axis axis_ = Axis::VERTICAL;
1165     RefPtr<ScrollableEvent> scrollableEvent_;
1166     RefPtr<TouchEventImpl> touchEvent_;
1167     RefPtr<ScrollEdgeEffect> scrollEffect_;
1168     RefPtr<RefreshCoordination> refreshCoordination_;
1169     int32_t scrollSource_ = SCROLL_FROM_NONE;
1170     int32_t lastScrollSource_ = SCROLL_FROM_NONE;
1171     // scrollBar
1172     RefPtr<ScrollBar> scrollBar_;
1173     RefPtr<NG::ScrollBarProxy> scrollBarProxy_;
1174     std::list<WeakPtr<NG::ScrollBarProxy>> nestScrollBarProxy_;
1175     RefPtr<ScrollBarOverlayModifier> scrollBarOverlayModifier_;
1176     float barOffset_ = 0.0f;
1177     float estimatedHeight_ = 0.0f;
1178     bool isReactInParentMovement_ = false;
1179     bool isRefreshInReactive_ = false; // true if Refresh component is ready to receive scroll offset.
1180     bool isSheetInReactive_ = false;
1181     bool isCoordEventNeedSpring_ = true;
1182     bool isScrolling_ = false;
1183     float scrollBarOutBoundaryExtent_ = 0.f;
1184     std::optional<float> ratio_;
1185     double friction_ = -1.0;
1186     double velocityScale_ = 0.0;
1187     double maxFlingVelocity_ = MAX_VELOCITY;
1188     // scroller
1189     RefPtr<Animator> animator_;
1190     bool scrollAbort_ = false;
1191     bool isAnimateOverScroll_ = false;
1192     bool isScrollToOverAnimation_ = false;
1193     bool isScrollToSafeAreaHelper_ = true;
1194     bool inScrollingStatus_ = false;
1195     bool switchOnStatus_ = false;
1196     bool canStayOverScroll_ = false;
1197 
1198     float startPercent_ = 0.0f;
1199     float endPercent_ = 1.0f;
1200     void UpdateFadeInfo(
1201         bool isFadingTop, bool isFadingBottom, float fadeFrameSize, const RefPtr<ScrollablePaintMethod>& paint);
1202 
1203     // select with mouse
1204     enum SelectDirection { SELECT_DOWN, SELECT_UP, SELECT_NONE };
1205     SelectDirection selectDirection_ = SELECT_NONE;
1206     bool mousePressed_ = false;
1207     bool canMultiSelect_ = false;
1208     OffsetF mouseEndOffset_;
1209     OffsetF mousePressOffset_;
1210     OffsetF lastMouseStart_;
1211     GestureEvent lastMouseMove_;
1212     RefPtr<SelectMotion> selectMotion_;
1213     RefPtr<PanEvent> boxSelectPanEvent_;
1214 
1215     RefPtr<NavDestinationPatternBase> navBarPattern_;
1216     RefPtr<SheetPresentationPattern> sheetPattern_;
1217     std::vector<RefPtr<ScrollingListener>> scrollingListener_;
1218 
1219     EdgeEffect edgeEffect_ = EdgeEffect::NONE;
1220     bool edgeEffectAlwaysEnabled_ = false;
1221     EffectEdge effectEdge_ = EffectEdge::ALL;
1222 
1223     RefPtr<NodeAnimatablePropertyFloat> springOffsetProperty_;
1224     RefPtr<NodeAnimatablePropertyFloat> curveOffsetProperty_;
1225     std::shared_ptr<AnimationUtils::Animation> springAnimation_;
1226     std::shared_ptr<AnimationUtils::Animation> curveAnimation_;
1227     uint64_t lastVsyncTime_ = 0;
1228     bool isAnimationStop_ = true; // graphic animation flag
1229     bool isBackToTopRunning_ = false;
1230     float currentVelocity_ = 0.0f;
1231     float lastPosition_ = 0.0f;
1232     float finalPosition_ = 0.0f;
1233     bool useTotalOffset_ = true;
1234     bool animateToTraceFlag_ = false;
1235     std::optional<float> extraOffset_;
1236 
1237     RefPtr<Animator> hotzoneAnimator_;
1238     float lastHonezoneOffsetPct_ = 0.0f;
1239     RefPtr<BezierVariableVelocityMotion> velocityMotion_;
1240     RefPtr<VelocityMotion> fixedVelocityMotion_;
1241     std::function<void(void)> hotZoneScrollCallback_;
1242     void UnRegister2DragDropManager(FrameNode* frameNode);
1243     float IsInHotZone(const PointF& point);
1244     void HotZoneScroll(const float offset);
1245     void StopHotzoneScroll();
1246     void HandleHotZone(const DragEventType& dragEventType, const RefPtr<NotifyDragEvent>& notifyDragEvent);
1247     bool isVertical() const;
1248     void AddHotZoneSenceInterface(SceneStatus scene);
1249     float GetDVSyncOffset();
1250     RefPtr<InputEvent> mouseEvent_;
1251     bool isMousePressed_ = false;
1252     RefPtr<ClickRecognizer> clickRecognizer_;
1253     Offset locationInfo_;
1254     WeakPtr<NestableScrollContainer> scrollOriginChild_;
1255     float nestedScrollVelocity_ = 0.0f;
1256     uint64_t nestedScrollTimestamp_ = 0;
1257     bool preHasFadingEdge_ = false;
1258     float scrollStartOffset_ = 0.0f;
1259 
1260     bool isRoundScroll_ = false;
1261 
1262     // dump info
1263     std::list<ScrollableEventsFiredInfo> eventsFiredInfos_;
1264     std::list<ScrollableFrameInfo> scrollableFrameInfos_;
1265 
1266     bool backToTop_ = false;
1267     bool useDefaultBackToTop_ = true;
1268     bool isHitTestBlock_ = false;
1269     std::queue<std::pair<uint64_t, float>> offsets_;
1270     bool isExtScroll_ = false;
1271     bool isNeedCollectOffset_ = false;
1272     bool needFullSafeArea_ = false;
1273 };
1274 } // namespace OHOS::Ace::NG
1275 
1276 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_SCROLL_SCROLL_PATTERN_H
1277