1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_PROPERTIES_MOTION_PATH_EVALUATOR_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_PROPERTIES_MOTION_PATH_EVALUATOR_H
18 
19 #include "base/geometry/dimension_offset.h"
20 #include "base/geometry/offset.h"
21 #include "base/geometry/transform_util.h"
22 #include "base/memory/ace_type.h"
23 #include "core/animation/evaluator.h"
24 #include "core/components/common/layout/constants.h"
25 #include "core/components/common/properties/motion_path_option.h"
26 
27 namespace OHOS::Ace {
28 
29 class DoubleEvaluator;
30 class DimensionOffsetEvaluator;
31 class RotateEvaluator;
32 class TransformOperationsEvaluator;
33 
34 struct MotionPathPosition {
35     Offset offset;
36     float rotate = 0.0f;
37 };
38 
39 class MotionPathEvaluator final : public AceType {
40     DECLARE_ACE_TYPE(MotionPathEvaluator, AceType);
41 
42 public:
43     explicit MotionPathEvaluator(const MotionPathOption& option = MotionPathOption(),
44         const Offset& start = Offset(0.0, 0.0), const Offset& end = Offset(0.0, 0.0),
45         PositionType type = PositionType::PTRELATIVE);
46     ~MotionPathEvaluator() override = default;
47 
48     MotionPathPosition Evaluate(float fraction);
49 
CreateXEvaluator()50     RefPtr<Evaluator<double>> CreateXEvaluator()
51     {
52         return AceType::MakeRefPtr<DoubleEvaluator>(AceType::Claim(this), true);
53     }
54 
CreateYEvaluator()55     RefPtr<Evaluator<double>> CreateYEvaluator()
56     {
57         return AceType::MakeRefPtr<DoubleEvaluator>(AceType::Claim(this), false);
58     }
59 
CreateDimensionOffsetEvaluator()60     RefPtr<Evaluator<DimensionOffset>> CreateDimensionOffsetEvaluator()
61     {
62         return AceType::MakeRefPtr<DimensionOffsetEvaluator>(AceType::Claim(this));
63     }
64 
CreateRotateEvaluator()65     RefPtr<Evaluator<float>> CreateRotateEvaluator()
66     {
67         return AceType::MakeRefPtr<RotateEvaluator>(AceType::Claim(this));
68     }
69 
CreateTransformOperationsEvaluator()70     RefPtr<Evaluator<TransformOperations>> CreateTransformOperationsEvaluator()
71     {
72         return AceType::MakeRefPtr<TransformOperationsEvaluator>(AceType::Claim(this));
73     }
74 
SetStart(const Offset & point)75     void SetStart(const Offset& point)
76     {
77         startPoint_ = point;
78     }
79 
GetStart()80     const Offset& GetStart() const
81     {
82         return startPoint_;
83     }
84 
SetEnd(const Offset & point)85     void SetEnd(const Offset& point)
86     {
87         endPoint_ = point;
88     }
89 
GetEnd()90     const Offset& GetEnd() const
91     {
92         return endPoint_;
93     }
94 
95 private:
96     MotionPathOption motionPathOption_;
97     Offset startPoint_ { 0.0, 0.0 };
98     Offset endPoint_ { 0.0, 0.0 };
99     PositionType positionType_ = PositionType::PTRELATIVE;
100 };
101 
102 // MotionPathEvaluator adapter for dimension
103 class DoubleEvaluator final : public Evaluator<double> {
104 public:
DoubleEvaluator(const RefPtr<MotionPathEvaluator> & evaluator,bool isXAxis)105     DoubleEvaluator(const RefPtr<MotionPathEvaluator>& evaluator, bool isXAxis)
106         : motionPathEvaluator_(evaluator), isXAxis_(isXAxis) {}
107     ~DoubleEvaluator() override = default;
108 
109     double Evaluate(const double& start, const double& end, float fraction) override;
110 
111 private:
112     RefPtr<MotionPathEvaluator> motionPathEvaluator_;
113     bool isXAxis_ = true;
114 };
115 
116 // MotionPathEvaluator adapter for DimensionOffset
117 class DimensionOffsetEvaluator final : public Evaluator<DimensionOffset> {
118 public:
DimensionOffsetEvaluator(const RefPtr<MotionPathEvaluator> & evaluator)119     DimensionOffsetEvaluator(const RefPtr<MotionPathEvaluator>& evaluator) : motionPathEvaluator_(evaluator) {}
120     ~DimensionOffsetEvaluator() override = default;
121 
122     DimensionOffset Evaluate(const DimensionOffset& start, const DimensionOffset& end, float fraction) override;
123 
124 private:
125     RefPtr<MotionPathEvaluator> motionPathEvaluator_;
126 };
127 
128 // MotionPathEvaluator adapter for rotate
129 class RotateEvaluator final : public Evaluator<float> {
130 public:
RotateEvaluator(const RefPtr<MotionPathEvaluator> & evaluator)131     explicit RotateEvaluator(const RefPtr<MotionPathEvaluator>& evaluator) : motionPathEvaluator_(evaluator) {}
132     ~RotateEvaluator() override = default;
133 
134     float Evaluate(const float& start, const float& end, float fraction) override;
135 
136 private:
137     RefPtr<MotionPathEvaluator> motionPathEvaluator_;
138 };
139 
140 class TransformOperationsEvaluator final : public Evaluator<TransformOperations> {
141 public:
TransformOperationsEvaluator(const RefPtr<MotionPathEvaluator> & evaluator)142     explicit TransformOperationsEvaluator(const RefPtr<MotionPathEvaluator>& evaluator)
143         : motionPathEvaluator_(evaluator) {}
144     ~TransformOperationsEvaluator() override = default;
145 
146     TransformOperations Evaluate(
147         const TransformOperations& start, const TransformOperations& end, float fraction) override;
148 
149 private:
150     RefPtr<MotionPathEvaluator> motionPathEvaluator_;
151 };
152 
153 } // namespace OHOS::Ace
154 
155 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_PROPERTIES_MOTION_PATH_EVALUATOR_H
156