• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_SLIDER_SLIDER_PATTERN_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_SLIDER_SLIDER_PATTERN_H
18 
19 #include <cstddef>
20 #include <optional>
21 
22 #include "core/components_ng/pattern/pattern.h"
23 #include "core/components_ng/pattern/slider/slider_content_modifier.h"
24 #include "core/components_ng/pattern/slider/slider_event_hub.h"
25 #include "core/components_ng/pattern/slider/slider_layout_algorithm.h"
26 #include "core/components_ng/pattern/slider/slider_layout_property.h"
27 #include "core/components_ng/pattern/slider/slider_model_ng.h"
28 #include "core/components_ng/pattern/slider/slider_paint_method.h"
29 #include "core/components_ng/pattern/slider/slider_paint_property.h"
30 #include "core/components_ng/pattern/slider/slider_custom_content_options.h"
31 
32 namespace OHOS::Ace::NG {
33 class SliderPattern : public Pattern {
34     DECLARE_ACE_TYPE(SliderPattern, Pattern);
35 
36 public:
37     SliderPattern() = default;
38     ~SliderPattern() override = default;
39 
CreateNodePaintMethod()40     RefPtr<NodePaintMethod> CreateNodePaintMethod() override
41     {
42         if (!IsSliderVisible()) {
43             return nullptr;
44         }
45         auto paintParameters = UpdateContentParameters();
46         if (!sliderContentModifier_) {
47             sliderContentModifier_ = AceType::MakeRefPtr<SliderContentModifier>(
48                 paintParameters,
49                 [weak = WeakClaim(this)](float x) {
50                     auto pattern = weak.Upgrade();
51                     CHECK_NULL_VOID(pattern);
52                     pattern->UpdateImagePositionX(x);
53                 },
54                 [weak = WeakClaim(this)](float y) {
55                     auto pattern = weak.Upgrade();
56                     CHECK_NULL_VOID(pattern);
57                     pattern->UpdateImagePositionY(y);
58                 });
59             sliderContentModifier_->SetHost(GetHost());
60         }
61         InitAccessibilityVirtualNodeTask();
62         sliderContentModifier_->SetUseContentModifier(UseContentModifier());
63         auto overlayGlobalOffset = CalculateGlobalSafeOffset();
64         std::pair<OffsetF, float> BubbleVertex = GetBubbleVertexPosition(circleCenter_, trackThickness_, blockSize_);
65         SliderPaintMethod::TipParameters tipParameters { bubbleFlag_, BubbleVertex.first, overlayGlobalOffset };
66         if (!sliderTipModifier_ && bubbleFlag_) {
67             sliderTipModifier_ = AceType::MakeRefPtr<SliderTipModifier>([weak = WeakClaim(this)]() {
68                 auto pattern = weak.Upgrade();
69                 if (!pattern) {
70                     return std::pair<OffsetF, float>();
71                 }
72                 auto blockCenter = pattern->GetBlockCenter();
73                 auto trackThickness = pattern->sliderContentModifier_->GetTrackThickness();
74                 auto blockSize = pattern->sliderContentModifier_->GetBlockSize();
75                 return pattern->GetBubbleVertexPosition(blockCenter, trackThickness, blockSize);
76             });
77         }
78         auto textDirection = TextDirection::AUTO;
79         auto layoutProperty = GetLayoutProperty<SliderLayoutProperty>();
80         if (layoutProperty) {
81             textDirection = layoutProperty->GetLayoutDirection();
82         }
83         if ((HasPrefix() || HasSuffix()) && !contentModifierNode_ && !endsInitFlag_) {
84             endsInitFlag_ = true;
85             InitSliderEndsState();
86         }
87         return MakeRefPtr<SliderPaintMethod>(sliderContentModifier_, paintParameters, sliderLength_, borderBlank_,
88             sliderTipModifier_, tipParameters, textDirection);
89     }
90 
InitSliderEndsState()91     void InitSliderEndsState()
92     {
93         CHECK_NULL_VOID(sliderContentModifier_);
94         if (HasPrefix()) {
95             CHECK_NULL_VOID(prefixNodeStack_);
96             prefixSize_ = prefixNodeStack_->GetGeometryNode()->GetFrameSize();
97             sliderContentModifier_->SetHasPrefix(true);
98         }
99         if (HasSuffix()) {
100             CHECK_NULL_VOID(suffixNodeStack_);
101             suffixSize_ = suffixNodeStack_->GetGeometryNode()->GetFrameSize();
102             sliderContentModifier_->SetHasSuffix(true);
103         }
104         InitSliderEnds();
105     }
106 
CreateLayoutProperty()107     RefPtr<LayoutProperty> CreateLayoutProperty() override
108     {
109         return MakeRefPtr<SliderLayoutProperty>();
110     }
111 
CreatePaintProperty()112     RefPtr<PaintProperty> CreatePaintProperty() override
113     {
114         return MakeRefPtr<SliderPaintProperty>();
115     }
116 
CreateLayoutAlgorithm()117     RefPtr<LayoutAlgorithm> CreateLayoutAlgorithm() override
118     {
119         return MakeRefPtr<SliderLayoutAlgorithm>();
120     }
121 
122     RefPtr<AccessibilityProperty> CreateAccessibilityProperty() override;
123 
CreateEventHub()124     RefPtr<EventHub> CreateEventHub() override
125     {
126         return MakeRefPtr<SliderEventHub>();
127     }
128 
GetFocusPattern()129     FocusPattern GetFocusPattern() const override
130     {
131         return { FocusType::NODE, true, FocusStyleType::CUSTOM_REGION };
132     }
133 
GetBlockCenter()134     const OffsetF& GetBlockCenter() const
135     {
136         return circleCenter_;
137     }
138 
GetAnimatableBlockCenter()139     std::optional<OffsetF> GetAnimatableBlockCenter() const
140     {
141         if (sliderContentModifier_ != nullptr) {
142             auto blockCenter = sliderContentModifier_->GetBlockCenter();
143             return OffsetF(blockCenter.GetX(), blockCenter.GetY());
144         }
145         return std::nullopt;
146     }
147 
GetValueRatio()148     float GetValueRatio() const
149     {
150         return valueRatio_;
151     }
152 
IsEnableMatchParent()153     bool IsEnableMatchParent() override
154     {
155         return true;
156     }
157 
158     std::string ProvideRestoreInfo() override;
159     void OnRestoreInfo(const std::string& restoreInfo) override;
160     OffsetF CalculateGlobalSafeOffset();
161     void UpdateValue(float value);
162     void UpdateValueMultiThread(const RefPtr<FrameNode>& frameNode);
163     void OnWindowSizeChanged(int32_t width, int32_t height, WindowSizeChangeReason type) override;
164 
SetBuilderFunc(SliderMakeCallback && makeFunc)165     void SetBuilderFunc(SliderMakeCallback&& makeFunc)
166     {
167         if (makeFunc == nullptr) {
168             makeFunc_ = std::nullopt;
169             OnModifyDone();
170             return;
171         }
172         makeFunc_ = std::move(makeFunc);
173         if (sliderContentModifier_) {
174             sliderContentModifier_->SetUseContentModifier(true);
175         }
176     }
177 
UseContentModifier()178     bool UseContentModifier()
179     {
180         return contentModifierNode_ != nullptr;
181     }
182 
SetEnableHapticFeedback(bool value)183     void SetEnableHapticFeedback(bool value)
184     {
185         isEnableHaptic_ = value;
186     }
187 
GetEnableHapticFeedback()188     bool GetEnableHapticFeedback() const
189     {
190         return isEnableHaptic_;
191     }
192 
HasPrefix()193     bool HasPrefix() const
194     {
195         if (contentModifierNode_) {
196             return false;
197         }
198         return prefix_.Upgrade() != nullptr;
199     };
200 
HasSuffix()201     bool HasSuffix() const
202     {
203         if (contentModifierNode_) {
204             return false;
205         }
206         return suffix_.Upgrade() != nullptr;
207     };
208 
209     void SetSliderValue(double value, int32_t mode);
210     void InitSliderEnds();
211     void InitAccessibilityVirtualNodeTask();
SetIsAccessibilityOn(bool value)212     void SetIsAccessibilityOn(bool value)
213     {
214         isAccessibilityOn_ = value;
215     }
216     void PlayHapticFeedback(bool isShowSteps);
217     bool OnThemeScopeUpdate(int32_t themeScopeId) override;
218     void DumpInfo() override;
219 
220     void InitPrefixSuffixRow();
221     void SetPrefix(const RefPtr<NG::UINode>& prefix, const NG::SliderPrefixOptions& options);
222     void SetSuffix(const RefPtr<NG::UINode>& suffix, const NG::SliderSuffixOptions& options);
223     void ResetPrefix();
224     void ResetSuffix();
225     void UpdatePrefixPosition();
226     void UpdateSuffixPosition();
227     void UpdateEndsIsShowStepsPosition(
228         PointF& EndsPosition, PointF& block, SizeF& endsSize, float outsetoffset, bool side);
229     void UpdateEndsNotShowStepsPosition(
230         PointF& EndsPosition, PointF& block, SizeF& endsSize, float noneOffset, float outsetOffset);
231 
232 #ifdef SUPPORT_DIGITAL_CROWN
SetDigitalCrownSensitivity(CrownSensitivity sensitivity)233     void SetDigitalCrownSensitivity(CrownSensitivity sensitivity)
234     {
235         crownSensitivity_ = sensitivity;
236     }
237 
GetDigitalCrownSensitivity()238     CrownSensitivity GetDigitalCrownSensitivity()
239     {
240         return crownSensitivity_;
241     }
242 #endif
SetBubbleFlag(bool flag)243     void SetBubbleFlag(bool flag)
244     {
245         bubbleFlag_ = flag;
246     }
247 
UpdateSliderParams(float trackThickness,SizeF blockSize,SizeF blockHotSize)248     void UpdateSliderParams(float trackThickness, SizeF blockSize, SizeF blockHotSize)
249     {
250         trackThickness_ = trackThickness;
251         blockSize_ = blockSize;
252         blockHotSize_ = blockHotSize;
253     }
254 
GetSliderContentModifier()255     RefPtr<SliderContentModifier> GetSliderContentModifier() const
256     {
257         return sliderContentModifier_;
258     }
259 
260     void UpdateSliderComponentColor(const Color& color, const SliderColorType sliderColorType, const Gradient& value);
261     void UpdateSliderComponentMedia();
262     void UpdateSliderComponentString(const bool isShowTips, const std::string& value);
263     Axis GetDirection() const;
264 
265 private:
266     void OnAttachToFrameNode() override;
267     void OnAttachToFrameNodeMultiThread();
268     void OnAttachToMainTree() override;
269     void OnAttachToMainTreeMultiThread();
270     void OnDetachFromFrameNode(FrameNode* frameNode) override;
271     void OnDetachFromFrameNodeMultiThread();
272     void OnDetachFromMainTree() override;
273     void OnDetachFromMainTreeMultiThread(const RefPtr<FrameNode>& frameNode);
274     void OnModifyDone() override;
275     void OnColorConfigurationUpdate() override;
276     void CalcSliderValue();
277     void CancelExceptionValue(float& min, float& max, float& step);
278     bool OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& dirty, bool skipMeasure, bool skipLayout) override;
279     bool UpdateParameters();
280     void CreateParagraphFunc();
281     void CreateParagraphAndLayout(
282         const TextStyle& textStyle, const std::string& content, const LayoutConstraintF& contentConstraint);
283     bool CreateParagraph(const TextStyle& textStyle, std::string content);
284     void UpdateCircleCenterOffset();
285     void UpdateTipsValue();
286     void UpdateBubbleSizeAndLayout();
287     void UpdateBubble();
288     void InitializeBubble();
289     void UpdatePaintRect(RefPtr<SliderTheme> theme, SliderModel::SliderMode& sliderMode, RoundRect& paintRect,
290         const RectF& rect, float rectRadius);
291 
292     bool AtMousePanArea(const Offset& offsetInFrame);
293     bool AtTouchPanArea(const Offset& offsetInFrame);
294     bool AtPanArea(const Offset& offset, const SourceType& sourceType);
295 
296     void UpdateMarkDirtyNode(const PropertyChangeFlag& Flag);
297 
298     void InitEvent();
299     void InitClickEvent(const RefPtr<GestureEventHub>& gestureHub);
300     void InitTouchEvent(const RefPtr<GestureEventHub>& gestureHub);
301     void HandleTouchEvent(const TouchEventInfo& info);
302     void HandleTouchDown(const Offset& location, SourceType sourceType);
303     void HandleTouchUp(const Offset& location, SourceType sourceType);
304     void InitMouseEvent(const RefPtr<InputEventHub>& inputEventHub);
305     void HandleMouseEvent(const MouseInfo& info);
306     void HandleHoverEvent(bool isHover);
307     void HandleEnabled();
308     void InitPanEvent(const RefPtr<GestureEventHub>& gestureHub);
309     void HandlingGestureStart(const GestureEvent& info);
310     void HandlingGestureEvent(const GestureEvent& info);
311     void HandledGestureEvent();
312 
313     void UpdateValueByLocalLocation(const std::optional<Offset>& localLocation);
314     void FireChangeEvent(int32_t mode);
315 
316     void InitOnKeyEvent(const RefPtr<FocusHub>& focusHub);
317     void GetInnerFocusPaintRect(RoundRect& paintRect);
318     void GetOutsetInnerFocusPaintRect(RoundRect& paintRect);
319     void GetInsetAndNoneInnerFocusPaintRect(RoundRect& paintRect);
320     bool OnKeyEvent(const KeyEvent& event);
321     void PaintFocusState();
322     bool MoveStep(int32_t stepCount);
323 #ifdef SUPPORT_DIGITAL_CROWN
InitDigitalCrownEvent(const RefPtr<FocusHub> & focusHub)324     void InitDigitalCrownEvent(const RefPtr<FocusHub>& focusHub)
325     {
326         auto pipeline = GetContext();
327         CHECK_NULL_VOID(pipeline);
328         auto sliderTheme = pipeline->GetTheme<SliderTheme>();
329         CHECK_NULL_VOID(sliderTheme);
330         crownDisplayControlRatio_ = sliderTheme->GetCrownDisplayControlRatio();
331 
332         auto onCrownEvent = [weak = WeakClaim(this)](const CrownEvent& event) -> bool {
333             auto pattern = weak.Upgrade();
334             CHECK_NULL_RETURN(pattern, false);
335             pattern->HandleCrownEvent(event);
336             return true;
337         };
338         focusHub->SetOnCrownEventInternal(std::move(onCrownEvent));
339     }
HandleCrownEvent(const CrownEvent & event)340     void HandleCrownEvent(const CrownEvent& event)
341     {
342         TAG_LOGD(AceLogTag::ACE_SELECT_COMPONENT,
343             "slider HandleCrownEvent event.action %{public}d event.degree %{public}f",
344             event.action, event.degree);
345         double mainDelta = GetCrownRotatePx(event);
346         switch (event.action) {
347             case CrownAction::UPDATE:
348                 if (!isHandleCrownActionBegin_) {
349                     isHandleCrownActionBegin_ = true;
350                     crownMovingLength_ = valueRatio_ * sliderLength_;
351                     crownEventNum_ = 0;
352                     reachBoundary_ = false;
353                     HandleCrownAction(mainDelta);
354                     timeStampPre_ = GetCurrentTimestamp();
355                     UpdateMarkDirtyNode(PROPERTY_UPDATE_RENDER);
356                     FireChangeEvent(SliderChangeMode::Begin);
357                     OpenTranslateAnimation(SliderStatus::MOVE);
358                 } else {
359                     HandleCrownAction(mainDelta);
360                     StartVibrateFeedback();
361                     UpdateMarkDirtyNode(PROPERTY_UPDATE_RENDER);
362                     FireChangeEvent(SliderChangeMode::Moving);
363                     OpenTranslateAnimation(SliderStatus::MOVE);
364                 }
365                 break;
366             case CrownAction::END:
367                 isHandleCrownActionBegin_ = false;
368                 bubbleFlag_ = false;
369                 UpdateMarkDirtyNode(PROPERTY_UPDATE_RENDER);
370                 FireChangeEvent(SliderChangeMode::End);
371                 CloseTranslateAnimation();
372                 break;
373             case CrownAction::BEGIN:
374             default:
375                 break;
376         }
377     }
378     double GetCrownRotatePx(const CrownEvent& event) const;
379     void HandleCrownAction(double mainDelta);
380     void StartVibrateFeedback();
381 #endif
382     bool IsSliderVisible();
383     void RegisterVisibleAreaChange();
384     void OnWindowHide() override;
385     void OnWindowShow() override;
386     void StartAnimation();
387     void StopAnimation();
388 
389     void OpenTranslateAnimation(SliderStatus status);
390     void CloseTranslateAnimation();
391     SliderContentModifier::Parameters UpdateContentParameters();
392     void GetSelectPosition(SliderContentModifier::Parameters& parameters, float centerWidth, const OffsetF& offset);
393     void GetBackgroundPosition(SliderContentModifier::Parameters& parameters, float centerWidth, const OffsetF& offset);
394     void GetCirclePosition(SliderContentModifier::Parameters& parameters, float centerWidth, const OffsetF& offset);
395     void UpdateBlock();
396     void LayoutImageNode();
397     void UpdateImagePositionX(float centerX);
398     void UpdateImagePositionY(float centerY);
399     std::pair<OffsetF, float> GetBubbleVertexPosition(
400         const OffsetF& blockCenter, float trackThickness, const SizeF& blockSize);
401     void SetAccessibilityAction();
402     void UpdateTipState();
403     void OnIsFocusActiveUpdate(bool isFocusActive);
404     void AddIsFocusActiveUpdateEvent();
405     void RemoveIsFocusActiveUpdateEvent();
406     bool isMinResponseExceed(const std::optional<Offset>& localLocation);
407     void FireBuilder();
408     RefPtr<FrameNode> BuildContentModifierNode();
409     float GetValueInValidRange(const RefPtr<SliderPaintProperty>& paintProperty, float value, float min, float max);
410     void UpdateToValidValue();
411     void InitSliderAccessibilityEnabledRegister();
412     void AccessibilityVirtualNodeRenderTask();
413     bool CheckCreateAccessibilityVirtualNode();
414     void InitAccessibilityHoverEvent();
415     bool InitAccessibilityVirtualNode();
416     void ModifyAccessibilityVirtualNode();
417     void AddStepPointsAccessibilityVirtualNode();
418     void UpdateStepAccessibilityVirtualNode();
419     void UpdateParentNodeSize();
420     std::string GetPointAccessibilityTxt(uint32_t pointIndex, float stepRatio, float min, float max);
421     uint32_t GetCurrentStepIndex();
422     int32_t GetOffsetStepIndex(uint32_t index);
423     SizeF GetStepPointAccessibilityVirtualNodeSize();
424     void UpdateStepPointsAccessibilityVirtualNodeSelected();
425     void SetStepPointsAccessibilityVirtualNodeEvent(
426         const RefPtr<FrameNode>& pointNode, uint32_t index, bool isClickAbled, bool reverse, bool isDisabledDesc);
427     void SetStepPointAccessibilityVirtualNode(const RefPtr<FrameNode>& pointNode, const SizeF& size,
428         const PointF& point, const std::string& txt, uint32_t index);
429     void SendAccessibilityValueEvent(int32_t mode);
430     void ClearSliderVirtualNode();
431     void InitOrRefreshSlipFactor();
432     RefPtr<PanEvent> CreatePanEvent();
433 
434     std::optional<SliderMakeCallback> makeFunc_;
435     RefPtr<FrameNode> contentModifierNode_;
SetSkipGestureEvents()436     void SetSkipGestureEvents()
437     {
438         skipGestureEvents_ = true;
439     }
ResetSkipGestureEvents()440     void ResetSkipGestureEvents()
441     {
442         skipGestureEvents_ = false;
443     }
IsSkipGestureEvents()444     bool IsSkipGestureEvents()
445     {
446         return skipGestureEvents_;
447     }
448     void DumpSubInfo(RefPtr<SliderPaintProperty> paintProperty);
449     void UpdateStepPointsAccessibilityText(
450         RefPtr<FrameNode>& node, uint32_t nodeIndex, SliderModel::SliderShowStepOptions& options);
451 
452     void RemoveCallbackOnDetach(FrameNode* frameNode);
453 
454     Axis direction_ = Axis::HORIZONTAL;
455     enum SliderChangeMode { Begin = 0, Moving = 1, End = 2, Click = 3 };
456     float value_ = 0.0f;
457     float minResponse_ = 0.0f;
458     bool skipGestureEvents_ = false;
459     float minResponseStartValue_ = value_;
460     bool isMinResponseExceedFlag_ = false;
461     SourceType eventSourceDevice_ = SourceType::NONE;
462     Offset eventLocalLocation_ {};
463     bool showTips_ = false;
464     bool hotFlag_ = false; // whether the mouse is hovering over the slider
465     bool valueChangeFlag_ = false;
466     bool mouseHoverFlag_ = false;
467     bool mousePressedFlag_ = false;
468     bool axisFlag_ = false; // Wheel operation flag
469     bool focusFlag_ = false;
470     bool panMoveFlag_ = false;
471     bool hasVisibleChangeRegistered_ = false;
472     bool isVisibleArea_ = true;
473     bool isShow_ = true;
474     SliderModelNG::SliderInteraction sliderInteractionMode_ = SliderModelNG::SliderInteraction::SLIDE_AND_CLICK;
475     bool allowDragEvents_ = true;
476     int32_t fingerId_ = -1;
477     std::optional<Offset> lastTouchLocation_ = std::nullopt;
478 
479     float valueRatio_ = 0.0f;
480     float sliderLength_ = 0.0f;
481     float borderBlank_ = 0.0f;
482     float hotBlockShadowWidth_ = 0.0f;
483     double axisOffset_ = 0.0;
484     OffsetF circleCenter_ = { 0.0f, 0.0f }; // Relative to the content area
485 
486     float trackThickness_ = 0.0f;
487     SizeF blockHotSize_;
488     SizeF blockSize_;
489 #ifdef SUPPORT_DIGITAL_CROWN
490     CrownSensitivity crownSensitivity_ = CrownSensitivity::MEDIUM;
491     double crownDisplayControlRatio_ = 1.0;
492     double crownMovingLength_ = 0.0;
493     int32_t crownEventNum_ = 0;
494     bool reachBoundary_ = false;
495     int64_t timeStampCur_ = 0;
496     int64_t timeStampPre_ = 0;
497     bool isHandleCrownActionBegin_ = false;
498 #endif
499 
500     RefPtr<TouchEventImpl> touchEvent_;
501     RefPtr<ClickEvent> clickListener_;
502     RefPtr<PanEvent> panEvent_;
503     RefPtr<InputEvent> mouseEvent_;
504     RefPtr<InputEvent> hoverEvent_;
505     RefPtr<FrameNode> parentPrefixSuffixNode_;
506     std::vector<PointF> stepPoints_;
507     PointF blockStart_ = { 0.0f, 0.0f };
508     PointF blockEnd_ = { 0.0f, 0.0f };
509     PointF prefixPosition_ = { 0.0f, 0.0f };
510     PointF suffixPosition_ = { 0.0f, 0.0f };
511     SizeF prefixSize_ = { 0.0f, 0.0f };
512     SizeF suffixSize_ = { 0.0f, 0.0f };
513     RSRect trackRect_;
514     bool isShowSteps_ = false;
515     bool side_ = true;
516     bool endsInitFlag_ = false;
517     float outsetOffset_ = 0.0f;
518 
519     NG::SliderPrefixOptions prefixAccessibilityoptions_;
520     NG::SliderSuffixOptions suffixAccessibilityoptions_;
521     WeakPtr<UINode> prefix_;
522     WeakPtr<UINode> suffix_;
523     RefPtr<FrameNode> prefixNodeStack_;
524     RefPtr<FrameNode> suffixNodeStack_;
525 
526     RefPtr<SliderContentModifier> sliderContentModifier_;
527     bool isTouchUpFlag_ = false;
528 
529     // tip Parameters
530     bool bubbleFlag_ = false;
531     RefPtr<SliderTipModifier> sliderTipModifier_;
532 
533     RefPtr<FrameNode> imageFrameNode_;
534     std::function<void(bool)> isFocusActiveUpdateEvent_;
535     bool isFocusActive_ = false;
536     SliderModel::SliderMode sliderMode_ = SliderModel::SliderMode::OUTSET;
537     bool isAccessibilityOn_ = AceApplicationInfo::GetInstance().IsAccessibilityEnabled();
538 
539     std::shared_ptr<AccessibilitySAObserverCallback> accessibilitySAObserverCallback_;
540     RefPtr<FrameNode> parentAccessibilityNode_;
541     std::vector<RefPtr<FrameNode>> pointAccessibilityNodeVec_;
542     std::vector<GestureEventFunc> pointAccessibilityNodeEventVec_;
543     bool isInitAccessibilityVirtualNode_ = false;
544     uint64_t lastSendPostValueTime_ = 0;
545     float accessibilityValue_ = 0.0f;
546     bool isEnableHaptic_ = true;
547     double slipfactor_ = 0;
548     ACE_DISALLOW_COPY_AND_MOVE(SliderPattern);
549 };
550 } // namespace OHOS::Ace::NG
551 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_SLIDER_SLIDER_PATTERN_H
552