up-to-date submodule(rive-cpp)
[platform/core/uifw/rive-tizen.git] / submodule / include / generated / node_base.hpp
1 #ifndef _RIVE_NODE_BASE_HPP_
2 #define _RIVE_NODE_BASE_HPP_
3 #include "core/field_types/core_double_type.hpp"
4 #include "transform_component.hpp"
5 namespace rive
6 {
7         class NodeBase : public TransformComponent
8         {
9         protected:
10                 typedef TransformComponent Super;
11
12         public:
13                 static const uint16_t typeKey = 2;
14
15                 /// Helper to quickly determine if a core object extends another without
16                 /// RTTI at runtime.
17                 bool isTypeOf(uint16_t typeKey) const override
18                 {
19                         switch (typeKey)
20                         {
21                                 case NodeBase::typeKey:
22                                 case TransformComponentBase::typeKey:
23                                 case ContainerComponentBase::typeKey:
24                                 case ComponentBase::typeKey:
25                                         return true;
26                                 default:
27                                         return false;
28                         }
29                 }
30
31                 uint16_t coreType() const override { return typeKey; }
32
33                 static const uint16_t xPropertyKey = 13;
34                 static const uint16_t yPropertyKey = 14;
35
36         private:
37                 float m_X = 0.0f;
38                 float m_Y = 0.0f;
39         public:
40                 inline float x() const override { return m_X; }
41                 void x(float value)
42                 {
43                         if (m_X == value)
44                         {
45                                 return;
46                         }
47                         m_X = value;
48                         xChanged();
49                 }
50
51                 inline float y() const override { return m_Y; }
52                 void y(float value)
53                 {
54                         if (m_Y == value)
55                         {
56                                 return;
57                         }
58                         m_Y = value;
59                         yChanged();
60                 }
61
62                 Core* clone() const override;
63                 void copy(const NodeBase& object)
64                 {
65                         m_X = object.m_X;
66                         m_Y = object.m_Y;
67                         TransformComponent::copy(object);
68                 }
69
70                 bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
71                 {
72                         switch (propertyKey)
73                         {
74                                 case xPropertyKey:
75                                         m_X = CoreDoubleType::deserialize(reader);
76                                         return true;
77                                 case yPropertyKey:
78                                         m_Y = CoreDoubleType::deserialize(reader);
79                                         return true;
80                         }
81                         return TransformComponent::deserialize(propertyKey, reader);
82                 }
83
84         protected:
85                 virtual void xChanged() {}
86                 virtual void yChanged() {}
87         };
88 } // namespace rive
89
90 #endif