[Adaptation Layer] Added rive-tizen adaptation layer class.
[platform/core/uifw/rive-tizen.git] / submodule / include / generated / draw_target_base.hpp
1 #ifndef _RIVE_DRAW_TARGET_BASE_HPP_
2 #define _RIVE_DRAW_TARGET_BASE_HPP_
3 #include "component.hpp"
4 #include "core/field_types/core_uint_type.hpp"
5 namespace rive
6 {
7         class DrawTargetBase : public Component
8         {
9         protected:
10                 typedef Component Super;
11
12         public:
13                 static const uint16_t typeKey = 48;
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 DrawTargetBase::typeKey:
22                                 case ComponentBase::typeKey:
23                                         return true;
24                                 default:
25                                         return false;
26                         }
27                 }
28
29                 uint16_t coreType() const override { return typeKey; }
30
31                 static const uint16_t drawableIdPropertyKey = 119;
32                 static const uint16_t placementValuePropertyKey = 120;
33
34         private:
35                 int m_DrawableId = -1;
36                 int m_PlacementValue = 0;
37         public:
38                 inline int drawableId() const { return m_DrawableId; }
39                 void drawableId(int value)
40                 {
41                         if (m_DrawableId == value)
42                         {
43                                 return;
44                         }
45                         m_DrawableId = value;
46                         drawableIdChanged();
47                 }
48
49                 inline int placementValue() const { return m_PlacementValue; }
50                 void placementValue(int value)
51                 {
52                         if (m_PlacementValue == value)
53                         {
54                                 return;
55                         }
56                         m_PlacementValue = value;
57                         placementValueChanged();
58                 }
59
60                 Core* clone() const override;
61                 void copy(const DrawTargetBase& object)
62                 {
63                         m_DrawableId = object.m_DrawableId;
64                         m_PlacementValue = object.m_PlacementValue;
65                         Component::copy(object);
66                 }
67
68                 bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
69                 {
70                         switch (propertyKey)
71                         {
72                                 case drawableIdPropertyKey:
73                                         m_DrawableId = CoreUintType::deserialize(reader);
74                                         return true;
75                                 case placementValuePropertyKey:
76                                         m_PlacementValue = CoreUintType::deserialize(reader);
77                                         return true;
78                         }
79                         return Component::deserialize(propertyKey, reader);
80                 }
81
82         protected:
83                 virtual void drawableIdChanged() {}
84                 virtual void placementValueChanged() {}
85         };
86 } // namespace rive
87
88 #endif