/
rive.py
183 lines (159 loc) · 5.2 KB
/
rive.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
from typing import Any, Optional, Union
from flet_core.alignment import Alignment
from flet_core.constrained_control import ConstrainedControl
from flet_core.control import OptionalNumber, Control
from flet_core.ref import Ref
from flet_core.types import (
AnimationValue,
OffsetValue,
ResponsiveNumber,
RotateValue,
ScaleValue,
ImageFit,
)
class Rive(ConstrainedControl):
"""
Displays rive animations.
-----
Online docs: https://flet.dev/docs/controls/rive
"""
def __init__(
self,
src: str = None,
placeholder: Optional[Control] = None,
artboard: Optional[str] = None,
alignment: Optional[Alignment] = None,
enable_antialiasing: Optional[bool] = None,
use_artboard_size: Optional[bool] = None,
fit: Optional[ImageFit] = None,
#
# ConstrainedControl
#
ref: Optional[Ref] = None,
key: Optional[str] = None,
width: OptionalNumber = None,
height: OptionalNumber = None,
left: OptionalNumber = None,
top: OptionalNumber = None,
right: OptionalNumber = None,
bottom: OptionalNumber = None,
expand: Union[None, bool, int] = None,
expand_loose: Optional[bool] = None,
col: Optional[ResponsiveNumber] = None,
opacity: OptionalNumber = None,
rotate: RotateValue = None,
scale: ScaleValue = None,
offset: OffsetValue = None,
aspect_ratio: OptionalNumber = None,
animate_opacity: AnimationValue = None,
animate_size: AnimationValue = None,
animate_position: AnimationValue = None,
animate_rotation: AnimationValue = None,
animate_scale: AnimationValue = None,
animate_offset: AnimationValue = None,
on_animation_end=None,
tooltip: Optional[str] = None,
visible: Optional[bool] = None,
disabled: Optional[bool] = None,
data: Any = None,
rtl: Optional[bool] = None,
):
ConstrainedControl.__init__(
self,
ref=ref,
key=key,
width=width,
height=height,
left=left,
top=top,
right=right,
bottom=bottom,
expand=expand,
expand_loose=expand_loose,
col=col,
opacity=opacity,
rotate=rotate,
scale=scale,
offset=offset,
aspect_ratio=aspect_ratio,
animate_opacity=animate_opacity,
animate_size=animate_size,
animate_position=animate_position,
animate_rotation=animate_rotation,
animate_scale=animate_scale,
animate_offset=animate_offset,
on_animation_end=on_animation_end,
tooltip=tooltip,
visible=visible,
disabled=disabled,
data=data,
rtl=rtl,
)
self.src = src
self.placeholder = placeholder
self.artboard = artboard
self.enable_antialiasing = enable_antialiasing
self.use_artboard_size = use_artboard_size
self.alignment = alignment
self.fit = fit
def _get_control_name(self):
return "rive"
def before_update(self):
super().before_update()
self._set_attr_json("alignment", self.__alignment)
def _get_children(self):
if self.__placeholder:
return [self.__placeholder]
return []
# src
@property
def src(self) -> Optional[str]:
return self._get_attr("src")
@src.setter
def src(self, value: Optional[str]):
if not value:
raise ValueError("Rive.src must be specified")
self._set_attr("src", value)
# alignment
@property
def alignment(self) -> Optional[Alignment]:
return self.__alignment
@alignment.setter
def alignment(self, value: Optional[Alignment]):
self.__alignment = value
# artboard
@property
def artboard(self):
return self._get_attr("artBoard")
@artboard.setter
def artboard(self, value):
self._set_attr("artBoard", value)
# enable_antialiasing
@property
def enable_antialiasing(self) -> Optional[bool]:
return self._get_attr("enableAntiAliasing", def_value=True, data_type="bool")
@enable_antialiasing.setter
def enable_antialiasing(self, value: Optional[bool]):
self._set_attr("enableAntiAliasing", value)
# placeholder
@property
def placeholder(self) -> Optional[Control]:
return self.__placeholder
@placeholder.setter
def placeholder(self, value: Optional[Control]):
self.__placeholder = value
# use_artboard_size
@property
def use_artboard_size(self) -> Optional[bool]:
return self._get_attr("useArtBoardSize", def_value=False, data_type="bool")
@use_artboard_size.setter
def use_artboard_size(self, value: Optional[bool]):
self._set_attr("useArtBoardSize", value)
# fit
@property
def fit(self) -> Optional[ImageFit]:
return self.__fit
@fit.setter
def fit(self, value: Optional[ImageFit]):
self.__fit = value
self._set_attr("fit", value.value if isinstance(value, ImageFit) else value)