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
184
185
|
struct Efl.Model_Property_Event {
[[EFL model property event data structure]]
changed_properties: array<string>; [[List of changed properties]]
invalidated_properties: array<string>; [[Removed properties identified by name]]
}
struct Efl.Model_Children_Event {
[[Every time a child is added the event @[Efl.Model.child,added] is dispatched
passing along this structure.]]
index: uint; [[index is a hint and is intended to provide a way for applications
to control/know children relative positions through listings.]]
child: Efl.Object; [[If an object has been built for this index and it is currently tracked by
the parent, it will be available here.]]
}
interface @beta Efl.Model
{
[[Efl model interface]]
eo_prefix: efl_model;
methods {
@property properties {
get {
[[Get properties from model.
properties_get is due to provide callers a way the fetch the
current properties implemented/used by the model. The event
@[Efl.Model.properties,changed] will be raised to notify
listeners of any modifications in the properties.
See also @[Efl.Model.properties,changed].
@since 1.14
]]
}
values {
properties: iterator<string> @owned; [[Array of current properties]]
}
}
@property property {
set {
[[Set a property value of a given property name.
The caller must ensure to call at least efl_model_prop_list
before being able to see/set properties. This function sets
a new property value into given property name. Once the
operation is completed the concrete implementation should
raise @[Efl.Model.properties,changed] event in order to
notify listeners of the new value of the property.
If the model doesn't have the property then there are two
possibilities, either raise an error or create the new
property in model
See @.property.get, @[Efl.Model.properties,changed]
@since 1.14
]]
return: future<any_value_ptr>; [[Return an error in case the property could not be set, the value that was set otherwise.]]
}
get {
[[Retrieve the value of a given property name.
At this point the caller is free to get values from properties.
The event @[Efl.Model.properties,changed] may be raised to
notify listeners of the property/value.
See @.properties.get, @[Efl.Model.properties,changed]
@since 1.14
]]
}
keys {
property: string; [[Property name]]
}
values {
value: any_value_ptr; [[Property value]]
}
}
property_ready_get {
[[Get a future value when it changes to something that is not error:EAGAIN
@.property.get can return an error with code EAGAIN when it doesn't have any
meaningful value. To make life easier, this future will resolve when
the error:EAGAIN disapears. Either into a failed future in case the error
code changed to something else or a success with the value of the property
whenever the property finally changes.
The future can also be canceled if the model itself gets destroyed.
]]
params {
@in property: string;
}
return: future<any_value_ptr>;
}
children_slice_get {
[[Get children slice OR full range.
@.children_slice_get behaves in two different ways, it may
provide the slice if $count is non-zero
OR full range otherwise.
Since 'slice' is a range, for example if we have 20 children a
slice could be the range from 3(start) with 4(count), see:
child 0 [no]
child 1 [no]
child 2 [no]
child 3 [yes]
child 4 [yes]
child 5 [yes]
child 6 [yes]
child 7 [no]
Optionally the user can call @.children_count.get to know the
number of children so a valid range can be known in advance.
See @.children_count.get
@since 1.14
]]
params {
@in start: uint; [[Range begin - start from here.]]
@in count: uint; [[Range size. If count is 0, start is
ignored.]]
}
/* XXX: is this right? */
return: future<array<Efl.Object>>; [[Array of children]]
}
@property children_count {
get {
[[Get children count.
When efl_model_load is completed @.children_count.get
can be used to get the number of children. @.children_count.get
can also be used before calling @.children_slice_get so a valid
range is known. Event @[Efl.Model.children,count,changed] is
emitted when count is finished.
See also @.children_slice_get.
@since 1.14
]]
}
values {
count: uint; [[Current known children count]]
}
}
child_add {
[[Add a new child.
Add a new child, possibly dummy, depending on the implementation,
of a internal keeping. When the child is effectively
added the event @[Efl.Model.child,added] is then raised
and the new child is kept along with other children.
@since 1.14
]]
return: Efl.Object; [[Child object]]
}
child_del {
[[Remove a child.
Remove a child of a internal keeping. When the child is effectively
removed the event @[Efl.Model.child,removed] is then
raised to give a chance for listeners to perform any cleanup
and/or update references.
@since 1.14
]]
params {
@in child: Efl.Object; [[Child to be removed]]
}
}
}
events {
properties,changed: Efl.Model_Property_Event; [[Event dispatched when
properties list is
available.]]
child,added: Efl.Model_Children_Event; [[Event dispatched when new child is added.]]
child,removed: Efl.Model_Children_Event; [[Event dispatched when child is removed.]]
children,count,changed: void; [[Event dispatched when children count is finished.]]
}
}
|
