• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023-2024 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/select_motion.h"
24 #include "core/animation/spring_curve.h"
25 #include "core/animation/bezier_variable_velocity_motion.h"
26 #include "core/components_ng/base/frame_scene_status.h"
27 #include "core/components_ng/event/drag_event.h"
28 #include "core/components_ng/pattern/navigation/nav_bar_pattern.h"
29 #include "core/components_ng/pattern/overlay/sheet_presentation_pattern.h"
30 #include "core/components_ng/pattern/pattern.h"
31 #include "core/components_ng/pattern/scroll/inner/scroll_bar.h"
32 #include "core/components_ng/pattern/scroll/inner/scroll_bar_overlay_modifier.h"
33 #include "core/components_ng/pattern/scroll_bar/proxy/scroll_bar_proxy.h"
34 #include "core/components_ng/pattern/scrollable/nestable_scroll_container.h"
35 #include "core/components_ng/pattern/scrollable/refresh_coordination.h"
36 #include "core/components_ng/pattern/scrollable/scrollable_controller.h"
37 #include "core/components_ng/pattern/scrollable/scrollable_coordination_event.h"
38 #include "core/components_ng/pattern/scrollable/scrollable_paint_property.h"
39 #include "core/components_ng/pattern/scrollable/scrollable_properties.h"
40 #include "core/components_ng/render/animation_utils.h"
41 #include "core/event/mouse_event.h"
42 #include "core/components_ng/event/scrollable_event.h"
43 namespace OHOS::Ace::NG {
44 #ifndef WEARABLE_PRODUCT
45 constexpr double FRICTION = 0.6;
46 constexpr double NEW_FRICTION = 0.7;
47 constexpr double MAX_VELOCITY = 800000.0;
48 #else
49 constexpr double FRICTION = 0.9;
50 constexpr double MAX_VELOCITY = 5000.0;
51 #endif
52 enum class ModalSheetCoordinationMode : char {
53     UNKNOWN = 0,
54     SHEET_SCROLL = 1,
55     SCROLLABLE_SCROLL = 2,
56 };
57 class ScrollablePattern : public NestableScrollContainer {
58     DECLARE_ACE_TYPE(ScrollablePattern, NestableScrollContainer);
59 
60 public:
61     ScrollablePattern();
62     ScrollablePattern(EdgeEffect edgeEffect, bool alwaysEnabled);
63 
~ScrollablePattern()64     ~ScrollablePattern()
65     {
66         UnRegister2DragDropManager();
67         if (scrollBarProxy_) {
68             scrollBarProxy_->UnRegisterScrollableNode(AceType::WeakClaim(this));
69         }
70     }
71 
IsAtomicNode()72     bool IsAtomicNode() const override
73     {
74         return false;
75     }
76 
77     RefPtr<PaintProperty> CreatePaintProperty() override;
78 
79     void ToJsonValue(std::unique_ptr<JsonValue>& json) const override;
80     void OnWindowHide() override;
81 
82     // scrollable
GetAxis()83     Axis GetAxis() const override
84     {
85         return axis_;
86     }
87 
IsReverse()88     virtual bool IsReverse() const
89     {
90         return false;
91     };
92 
ShouldDelayChildPressedState()93     virtual bool ShouldDelayChildPressedState() const override
94     {
95         return true;
96     }
97 
98     void RegisterScrollingListener(const RefPtr<ScrollingListener> listener) override;
99     void FireAndCleanScrollingListener() override;
100     void CleanScrollingListener() override;
101 
102     void SetAxis(Axis axis);
103     virtual bool UpdateCurrentOffset(float delta, int32_t source) = 0;
IsScrollable()104     virtual bool IsScrollable() const
105     {
106         return false;
107     }
108     virtual bool IsAtTop() const = 0;
109     virtual bool IsAtBottom() const = 0;
OutBoundaryCallback()110     virtual bool OutBoundaryCallback()
111     {
112         return IsAtTop() || IsAtBottom();
113     }
114 
115     virtual bool IsOutOfBoundary(bool useCurrentDelta = true)
116     {
117         return false;
118     }
119 
120     void AddScrollEvent();
GetScrollableEvent()121     RefPtr<ScrollableEvent> GetScrollableEvent()
122     {
123         return scrollableEvent_;
124     }
125     virtual bool OnScrollCallback(float offset, int32_t source);
126     virtual void OnScrollStartCallback();
127     virtual void FireOnScrollStart();
ScrollableIdle()128     bool ScrollableIdle()
129     {
130         return !scrollableEvent_ || scrollableEvent_->Idle();
131     }
SetScrollEnable(bool enable)132     void SetScrollEnable(bool enable)
133     {
134         CHECK_NULL_VOID(scrollableEvent_);
135         scrollableEvent_->SetEnabled(enable);
136         if (!enable) {
137             scrollableEvent_->SetAxis(Axis::NONE);
138         } else {
139             scrollableEvent_->SetAxis(axis_);
140         }
141     }
142 
143     RefPtr<GestureEventHub> GetGestureHub();
144     RefPtr<InputEventHub> GetInputHub();
145 
146     // edgeEffect
GetScrollEdgeEffect()147     const RefPtr<ScrollEdgeEffect>& GetScrollEdgeEffect() const
148     {
149         return scrollEffect_;
150     }
151     bool HandleEdgeEffect(float offset, int32_t source, const SizeF& size, bool reverse = false);
SetEdgeEffectCallback(const RefPtr<ScrollEdgeEffect> & scrollEffect)152     virtual void SetEdgeEffectCallback(const RefPtr<ScrollEdgeEffect>& scrollEffect) {}
IsRestrictBoundary()153     bool IsRestrictBoundary()
154     {
155         return !scrollEffect_ || scrollEffect_->IsRestrictBoundary();
156     }
157 
158     // scrollBar
159     virtual void UpdateScrollBarOffset() = 0;
160     void SetScrollBar(const std::unique_ptr<ScrollBarProperty>& property);
161     void SetScrollBar(DisplayMode displayMode);
162     void SetScrollBarProxy(const RefPtr<ScrollBarProxy>& scrollBarProxy);
163     void CreateScrollBarOverlayModifier();
164 
GetScrollableDistance()165     float GetScrollableDistance() const
166     {
167         return estimatedHeight_;
168     }
169 
GetBarOffset()170     float GetBarOffset() const
171     {
172         return barOffset_;
173     }
174 
GetScrollBarOutBoundaryExtent()175     double GetScrollBarOutBoundaryExtent() const
176     {
177         return scrollBarOutBoundaryExtent_;
178     }
179 
SetScrollBarOutBoundaryExtent(float scrollBarOutBoundaryExtent)180     void SetScrollBarOutBoundaryExtent(float scrollBarOutBoundaryExtent)
181     {
182         scrollBarOutBoundaryExtent_ = scrollBarOutBoundaryExtent;
183     }
184 
185     void HandleScrollBarOutBoundary(float scrollBarOutBoundaryExtent);
186 
GetMainSize(const SizeF & size)187     double GetMainSize(const SizeF& size) const
188     {
189         return axis_ == Axis::HORIZONTAL ? size.Width() : size.Height();
190     }
191 
IsScrollableStopped()192     bool IsScrollableStopped() const
193     {
194         CHECK_NULL_RETURN(scrollableEvent_, true);
195         auto scrollable = scrollableEvent_->GetScrollable();
196         CHECK_NULL_RETURN(scrollable, true);
197         return scrollable->IsStopped();
198     }
199 
StopScrollable()200     void StopScrollable()
201     {
202         CHECK_NULL_VOID(scrollableEvent_);
203         auto scrollable = scrollableEvent_->GetScrollable();
204         CHECK_NULL_VOID(scrollable);
205         scrollable->StopScrollable();
206     }
207 
StartScrollSnapMotion(float scrollSnapDelta,float scrollSnapVelocity)208     void StartScrollSnapMotion(float scrollSnapDelta, float scrollSnapVelocity)
209     {
210         CHECK_NULL_VOID(scrollableEvent_);
211         auto scrollable = scrollableEvent_->GetScrollable();
212         CHECK_NULL_VOID(scrollable);
213         scrollable->ProcessScrollSnapSpringMotion(scrollSnapDelta, scrollSnapVelocity);
214     }
215 
SetScrollFrameBeginCallback(const ScrollFrameBeginCallback & scrollFrameBeginCallback)216     void SetScrollFrameBeginCallback(const ScrollFrameBeginCallback& scrollFrameBeginCallback)
217     {
218         // Previous: Set to Scrollable and called in HandleScroll
219         // Now: HandleScroll moved to base class, directly store and call scrollFrameBeginCallback_ here
220         scrollFrameBeginCallback_ = scrollFrameBeginCallback;
221     }
222 
IsScrollableSpringEffect()223     bool IsScrollableSpringEffect() const
224     {
225         CHECK_NULL_RETURN(scrollEffect_, false);
226         return scrollEffect_->IsSpringEffect();
227     }
228 
SetCoordEventNeedSpringEffect(bool IsCoordEventNeedSpring)229     void SetCoordEventNeedSpringEffect(bool IsCoordEventNeedSpring)
230     {
231         isCoordEventNeedSpring_ = IsCoordEventNeedSpring;
232     }
233 
234     void SetNestedScroll(const NestedScrollOptions& nestedOpt);
235     void GetParentNavigation();
236     void GetParentModalSheet();
237 
GetOverScrollOffset(double delta)238     virtual OverScrollOffset GetOverScrollOffset(double delta) const
239     {
240         return { 0, 0 };
241     }
242 
OnScrollSnapCallback(double targetOffset,double velocity)243     virtual bool OnScrollSnapCallback(double targetOffset, double velocity)
244     {
245         return false;
246     }
247 
StartScrollBarAnimatorByProxy()248     void StartScrollBarAnimatorByProxy()
249     {
250         if (scrollBarProxy_) {
251             scrollBarProxy_->StartScrollBarAnimator();
252         }
253     }
254 
StopScrollBarAnimatorByProxy()255     void StopScrollBarAnimatorByProxy()
256     {
257         if (scrollBarProxy_) {
258             scrollBarProxy_->StopScrollBarAnimator();
259         }
260     }
261 
262     void SetFriction(double friction);
263 
GetFriction()264     double GetFriction() const
265     {
266         return friction_;
267     }
268 
269     void SetMaxFlingVelocity(double max);
270 
271     void StopAnimate();
AnimateRunning()272     bool AnimateRunning() const
273     {
274         return (animator_ && animator_->IsRunning()) || !isAnimationStop_;
275     }
AnimateStoped()276     bool AnimateStoped() const
277     {
278         return (!animator_ || animator_->IsStopped()) && isAnimationStop_;
279     }
280 
AbortScrollAnimator()281     void AbortScrollAnimator()
282     {
283         if (animator_ && !animator_->IsStopped()) {
284             scrollAbort_ = true;
285             animator_->Stop();
286         }
287         if (!isAnimationStop_) {
288             scrollAbort_ = true;
289             StopAnimation(springAnimation_);
290             StopAnimation(curveAnimation_);
291         }
292     }
GetScrollAbort()293     bool GetScrollAbort() const
294     {
295         return scrollAbort_;
296     }
SetScrollAbort(bool abort)297     void SetScrollAbort(bool abort)
298     {
299         scrollAbort_ = abort;
300     }
301     void PlaySpringAnimation(float position, float velocity, float mass, float stiffness, float damping);
302     void PlayCurveAnimation(float position, float duration, const RefPtr<Curve>& curve, bool canOverScroll);
GetTotalOffset()303     virtual float GetTotalOffset() const
304     {
305         return 0.0f;
306     }
307     // main size of all children
GetTotalHeight()308     virtual float GetTotalHeight() const
309     {
310         return 0.0f;
311     }
OnAnimateStop()312     virtual void OnAnimateStop() {}
313     virtual void ScrollTo(float position);
314     virtual void AnimateTo(
315         float position, float duration, const RefPtr<Curve>& curve, bool smooth, bool canOverScroll = false);
CanOverScroll(int32_t source)316     bool CanOverScroll(int32_t source)
317     {
318         return (IsScrollableSpringEffect() && source != SCROLL_FROM_AXIS && source != SCROLL_FROM_BAR &&
319                 IsScrollable() && (!ScrollableIdle() || animateOverScroll_ || animateCanOverScroll_));
320     }
321     void MarkSelectedItems();
322     bool ShouldSelectScrollBeStopped();
323     void UpdateMouseStart(float offset);
324 
325     // scrollSnap
CalePredictSnapOffset(float delta,float dragDistance,float velocity)326     virtual std::optional<float> CalePredictSnapOffset(float delta, float dragDistance, float velocity)
327     {
328         std::optional<float> predictSnapPosition;
329         return predictSnapPosition;
330     }
331 
NeedScrollSnapToSide(float delta)332     virtual bool NeedScrollSnapToSide(float delta)
333     {
334         return false;
335     }
336 
SetScrollSource(int32_t scrollSource)337     void SetScrollSource(int32_t scrollSource)
338     {
339         if (scrollSource == SCROLL_FROM_JUMP || scrollSource == SCROLL_FROM_FOCUS_JUMP) {
340             if (scrollBar_ && scrollBar_->IsScrollable() && scrollBarOverlayModifier_) {
341                 scrollBarOverlayModifier_->SetOpacity(UINT8_MAX);
342                 scrollBar_->ScheduleDisappearDelayTask();
343             }
344             StopScrollBarAnimatorByProxy();
345             StartScrollBarAnimatorByProxy();
346         }
347         scrollSource_ = scrollSource;
348     }
349 
GetScrollSource()350     int32_t GetScrollSource() const
351     {
352         return scrollSource_;
353     }
354 
GetCurrentVelocity()355     float GetCurrentVelocity() const
356     {
357         return currentVelocity_;
358     }
359 
360     ScrollState GetScrollState() const;
361 
362     static ScrollState GetScrollState(int32_t scrollSource);
363 
CalculateFriction(float gamma)364     static float CalculateFriction(float gamma)
365     {
366         constexpr float RATIO = 1.848f;
367         if (GreatOrEqual(gamma, 1.0)) {
368             gamma = 1.0f;
369         }
370         return exp(-RATIO * gamma);
371     }
372     virtual float GetMainContentSize() const;
373 
SupportScrollToIndex()374     virtual bool SupportScrollToIndex() const
375     {
376         return true;
377     }
378 
GetDefaultScrollAlign()379     virtual ScrollAlign GetDefaultScrollAlign() const
380     {
381         return ScrollAlign::START;
382     }
383 
384     virtual void ScrollToIndex(int32_t index, bool smooth = false, ScrollAlign align = ScrollAlign::START) {}
385 
386     virtual void ScrollToEdge(ScrollEdgeType scrollEdgeType, bool smooth);
387 
SetPositionController(RefPtr<ScrollableController> control)388     void SetPositionController(RefPtr<ScrollableController> control)
389     {
390         positionController_ = control;
391         if (control) {
392             control->SetScrollPattern(AceType::WeakClaim(this));
393         }
394     }
395 
GetItemRect(int32_t index)396     virtual Rect GetItemRect(int32_t index) const
397     {
398         return Rect();
399     };
400 
SetEdgeEffect(EdgeEffect edgeEffect,bool alwaysEnabled)401     void SetEdgeEffect(EdgeEffect edgeEffect, bool alwaysEnabled)
402     {
403         edgeEffect_ = edgeEffect;
404         edgeEffectAlwaysEnabled_ = alwaysEnabled;
405     }
406 
GetAlwaysEnabled()407     bool GetAlwaysEnabled() const
408     {
409         return edgeEffectAlwaysEnabled_;
410     }
411 
SetAlwaysEnabled(bool alwaysEnabled)412     void SetAlwaysEnabled(bool alwaysEnabled)
413     {
414         edgeEffectAlwaysEnabled_ = alwaysEnabled;
415     }
416 
IsScrollableAnimationNotRunning()417     bool IsScrollableAnimationNotRunning()
418     {
419         if (scrollableEvent_) {
420             auto scrollable = scrollableEvent_->GetScrollable();
421             if (scrollable) {
422                 return scrollable->IsAnimationNotRunning();
423             }
424             return false;
425         }
426         return false;
427     }
428 
GetFinalPosition()429     float GetFinalPosition() const
430     {
431         return finalPosition_;
432     }
433     void HandleOnDragStatusCallback(
434         const DragEventType& dragEventType, const RefPtr<NotifyDragEvent>& notifyDragEvent) override;
435 
IsScrollableSpringMotionRunning()436     bool IsScrollableSpringMotionRunning()
437     {
438         CHECK_NULL_RETURN(scrollableEvent_, false);
439         auto scrollable = scrollableEvent_->GetScrollable();
440         CHECK_NULL_RETURN(scrollable, false);
441         return scrollable->IsSpringMotionRunning();
442     }
443 
IsScrollSnap()444     virtual bool IsScrollSnap()
445     {
446         // When setting snap or enablePaging in scroll, the PARENT_FIRST in nestedScroll_ is invalid
447         return false;
448     }
449 
SetNeedLinked(bool needLinked)450     void SetNeedLinked(bool needLinked)
451     {
452         needLinked_ = needLinked;
453     }
454 
SetAnimateCanOverScroll(bool animateCanOverScroll)455     void SetAnimateCanOverScroll(bool animateCanOverScroll)
456     {
457         animateCanOverScroll_ = animateCanOverScroll;
458     }
459 
460 protected:
461     void OnDetachFromFrameNode(FrameNode* frameNode) override;
GetDefaultScrollBarDisplayMode()462     virtual DisplayMode GetDefaultScrollBarDisplayMode() const
463     {
464         return DisplayMode::AUTO;
465     }
GetScrollBar()466     RefPtr<ScrollBar> GetScrollBar() const
467     {
468         return scrollBar_;
469     }
GetScrollBarProxy()470     RefPtr<NG::ScrollBarProxy> GetScrollBarProxy() const
471     {
472         return scrollBarProxy_;
473     }
474     void UpdateScrollBarRegion(float offset, float estimatedHeight, Size viewPort, Offset viewOffset);
475 
476     EdgeEffect GetEdgeEffect() const;
SetEdgeEffect()477     void SetEdgeEffect()
478     {
479         SetEdgeEffect(edgeEffect_);
480     }
481 
482     virtual void FireOnScroll(float finalOffset, OnScrollEvent& onScroll) const;
483 
484     virtual void OnScrollStop(const OnScrollStopEvent& onScrollStop);
485 
486     // select with mouse
487     struct ItemSelectedStatus {
488         std::function<void(bool)> onSelected;
489         std::function<void(bool)> selectChangeEvent;
490         RectF rect;
491         bool selected = false;
FireSelectChangeEventItemSelectedStatus492         void FireSelectChangeEvent(bool isSelected)
493         {
494             if (selected == isSelected) {
495                 return;
496             }
497             selected = isSelected;
498             if (onSelected) {
499                 onSelected(isSelected);
500             }
501             if (selectChangeEvent) {
502                 selectChangeEvent(isSelected);
503             }
504         }
505     };
506     void InitMouseEvent();
507     void UninitMouseEvent();
508     void DrawSelectedZone(const RectF& selectedZone);
509     void ClearSelectedZone();
510     bool multiSelectable_ = false;
511     bool isMouseEventInit_ = false;
512     OffsetF mouseStartOffset_;
513     float totalOffsetOfMousePressed_ = 0.0f;
514     std::unordered_map<int32_t, ItemSelectedStatus> itemToBeSelected_;
515 
GetScrollBarOverlayModifier()516     RefPtr<ScrollBarOverlayModifier> GetScrollBarOverlayModifier() const
517     {
518         return scrollBarOverlayModifier_;
519     }
520 
SetScrollBarOverlayModifier(RefPtr<ScrollBarOverlayModifier> scrollBarOverlayModifier)521     void SetScrollBarOverlayModifier(RefPtr<ScrollBarOverlayModifier> scrollBarOverlayModifier)
522     {
523         scrollBarOverlayModifier_ = scrollBarOverlayModifier;
524     }
525     // just for hold ScrollableController
526     RefPtr<ScrollableController> positionController_;
527 
528     bool scrollStop_ = false;
529 
530     // for onReachStart of the first layout
531     bool isInitialized_ = false;
532 
533     void Register2DragDropManager();
534 
535 private:
OnScrollEndCallback()536     virtual void OnScrollEndCallback() {};
537 
538     void RegisterScrollBarEventTask();
539     bool OnScrollPosition(double& offset, int32_t source);
540     void SetParentScrollable();
541     void ProcessNavBarReactOnStart();
542     float ProcessNavBarReactOnUpdate(float offset);
543     void ProcessNavBarReactOnEnd();
544     void InitSpringOffsetProperty();
545     void InitCurveOffsetProperty(float position);
546     void StopAnimation(std::shared_ptr<AnimationUtils::Animation> animation);
547     void PauseAnimation(std::shared_ptr<AnimationUtils::Animation> animation);
548     void InitOption(AnimationOption &option, float duration, const RefPtr<Curve>& curve);
549 
550     void OnAttachToFrameNode() override;
551     void AttachAnimatableProperty(RefPtr<Scrollable> scrollable);
552     void InitTouchEvent(const RefPtr<GestureEventHub>& gestureHub);
553     void RegisterWindowStateChangedCallback();
554 
555     // select with mouse
MultiSelectWithoutKeyboard(const RectF & selectedZone)556     virtual void MultiSelectWithoutKeyboard(const RectF& selectedZone) {};
ClearMultiSelect()557     virtual void ClearMultiSelect() {};
IsItemSelected(const GestureEvent & info)558     virtual bool IsItemSelected(const GestureEvent& info)
559     {
560         return false;
561     }
562     void ClearInvisibleItemsSelectedStatus();
563     void HandleInvisibleItemsSelectedStatus(const RectF& selectedZone);
564     void HandleDragStart(const GestureEvent& info);
565     void HandleDragUpdate(const GestureEvent& info);
566     void HandleDragEnd(const GestureEvent& info);
567     void SelectWithScroll();
568     RectF ComputeSelectedZone(const OffsetF& startOffset, const OffsetF& endOffset);
569     float GetOutOfScrollableOffset() const;
570     virtual float GetOffsetWithLimit(float offset) const;
571     void LimitMouseEndOffset();
572     void UpdateBorderRadius();
573 
574     /******************************************************************************
575      * NestableScrollContainer implementations
576      */
577     ScrollResult HandleScroll(float offset, int32_t source, NestedState state = NestedState::GESTURE) override;
578     bool HandleScrollVelocity(float velocity) override;
579 
580     void OnScrollEndRecursive(const std::optional<float>& velocity) override;
581     void OnScrollStartRecursive(float position) override;
582 
583     ScrollResult HandleScrollParentFirst(float& offset, int32_t source, NestedState state);
584     ScrollResult HandleScrollSelfFirst(float& offset, int32_t source, NestedState state);
585     ScrollResult HandleScrollSelfOnly(float& offset, int32_t source, NestedState state);
586     ScrollResult HandleScrollParallel(float& offset, int32_t source, NestedState state);
587 
588     void ExecuteScrollFrameBegin(float& mainDelta, ScrollState state);
589 
590     void SetCanOverScroll(bool val);
591     bool GetCanOverScroll() const;
592 
593     void OnScrollEnd();
594     void ProcessSpringEffect(float velocity);
595     void SetEdgeEffect(EdgeEffect edgeEffect);
596 
597     // Scrollable::UpdateScrollPosition
598     bool HandleScrollImpl(float offset, int32_t source);
599     void NotifyMoved(bool value);
600 
601     WeakPtr<NestableScrollContainer> parent_;
602     ScrollFrameBeginCallback scrollFrameBeginCallback_;
603     /*
604      *  End of NestableScrollContainer implementations
605      *******************************************************************************/
606 
607     bool HandleOverScroll(float velocity);
608 
CreateRefreshCoordination()609     void CreateRefreshCoordination()
610     {
611         if (!refreshCoordination_) {
612             auto host = GetHost();
613             CHECK_NULL_VOID(host);
614             refreshCoordination_ = AceType::MakeRefPtr<RefreshCoordination>(host);
615         }
616     }
617     float GetVelocity() const;
618     bool NeedSplitScroll(OverScrollOffset& overOffsets, int32_t source);
619     RefreshCoordinationMode CoordinateWithRefresh(double& offset, int32_t source, bool isAtTop);
620     bool CoordinateWithNavigation(double& offset, int32_t source, bool isAtTop);
621     void NotifyFRCSceneInfo(const std::string& scene, double velocity, SceneStatus sceneStatus);
622     ModalSheetCoordinationMode CoordinateWithSheet(double& offset, int32_t source, bool isAtTop);
623     bool NeedCoordinateScrollWithNavigation(double offset, int32_t source, const OverScrollOffset& overOffsets);
624 
625     Axis axis_ = Axis::VERTICAL;
626     RefPtr<ScrollableEvent> scrollableEvent_;
627     RefPtr<TouchEventImpl> touchEvent_;
628     RefPtr<ScrollEdgeEffect> scrollEffect_;
629     RefPtr<RefreshCoordination> refreshCoordination_;
630     int32_t scrollSource_ = SCROLL_FROM_NONE;
631     // scrollBar
632     RefPtr<ScrollBar> scrollBar_;
633     RefPtr<NG::ScrollBarProxy> scrollBarProxy_;
634     RefPtr<ScrollBarOverlayModifier> scrollBarOverlayModifier_;
635     float barOffset_ = 0.0f;
636     float estimatedHeight_ = 0.0f;
637     bool isReactInParentMovement_ = false;
638     bool isRefreshInReactive_ = false;
639     bool isSheetInReactive_ = false;
640     bool isCoordEventNeedSpring_ = true;
641     double scrollBarOutBoundaryExtent_ = 0.0;
642     double friction_ = 0.0;
643     double maxFlingVelocity_ = MAX_VELOCITY;
644     // scroller
645     RefPtr<Animator> animator_;
646     bool scrollAbort_ = false;
647     bool animateOverScroll_ = false;
648     bool isAnimateOverScroll_ = false;
649     bool animateCanOverScroll_ = false;
650 
651     NestedScrollOptions nestedScroll_ = {
652         .forward = NestedScrollMode::SELF_ONLY,
653         .backward = NestedScrollMode::SELF_ONLY,
654     };
655 
656     // select with mouse
657     enum SelectDirection { SELECT_DOWN, SELECT_UP, SELECT_NONE };
658     SelectDirection selectDirection_ = SELECT_NONE;
659     bool mousePressed_ = false;
660     bool canMultiSelect_ = false;
661     OffsetF mouseEndOffset_;
662     OffsetF mousePressOffset_;
663     OffsetF lastMouseStart_;
664     GestureEvent lastMouseMove_;
665     RefPtr<SelectMotion> selectMotion_;
666     RefPtr<PanEvent> boxSelectPanEvent_;
667 
668     RefPtr<NavBarPattern> navBarPattern_;
669     RefPtr<SheetPresentationPattern> sheetPattern_;
670     std::vector<RefPtr<ScrollingListener>> scrollingListener_;
671 
672     EdgeEffect edgeEffect_ = EdgeEffect::NONE;
673     bool edgeEffectAlwaysEnabled_ = false;
674     bool needLinked_ = true;
675 
676     RefPtr<NodeAnimatablePropertyFloat> springOffsetProperty_;
677     RefPtr<NodeAnimatablePropertyFloat> curveOffsetProperty_;
678     std::shared_ptr<AnimationUtils::Animation> springAnimation_;
679     std::shared_ptr<AnimationUtils::Animation> curveAnimation_;
680     uint64_t lastVsyncTime_ = 0;
681     bool isAnimationStop_ = true; // graphic animation flag
682     float currentVelocity_ = 0.0f;
683     float lastPosition_ = 0.0f;
684     float finalPosition_ = 0.0f;
685 
686     RefPtr<Animator> hotzoneAnimator_;
687     float lastHonezoneOffsetPct_ = 0.0f;
688     RefPtr<BezierVariableVelocityMotion> velocityMotion_;
689     void UnRegister2DragDropManager();
690     float IsInHotZone(const PointF& point);
691     void HotZoneScroll(const float offset);
692     void StopHotzoneScroll();
693     void HandleHotZone(const DragEventType& dragEventType, const RefPtr<NotifyDragEvent>& notifyDragEvent);
694     void HandleMoveEventInComp(const PointF& point);
695     void HandleLeaveHotzoneEvent();
696     bool isVertical() const;
697     void AddHotZoneSenceInterface(SceneStatus scene);
698 };
699 } // namespace OHOS::Ace::NG
700 
701 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_SCROLL_SCROLL_PATTERN_H
702