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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
import eina_types;
type Elm_Prefs_Data: __undefined_type;
type Elm_Prefs_Reset_Mode: __undefined_type;
class Elm.Prefs (Elm.Widget, Efl.File)
{
eo_prefix: elm_obj_prefs;
methods {
@property data {
[[Set user data for a given prefs widget
Once a prefs widget is created, after elm_prefs_file_set() is
issued on it, all of its UI elements will get default values, when
declared on that file. To fetch an user's own, personal set of
those values, one gets to pair a prefs data handle to the
prefs widget. This is what this call is intended for.
Prefs data values from $prefs_data with keys matching the ones
present on the file passed on elm_prefs_file_set() to $obj will
have their values applied to the respective UI elements of the
widget.
When $obj dies, the values of the elements declared on its
.epb file (the one set on elm_prefs_file_set()) marked as permanent
will be written back to prefs_data, if it is writable.
One is also able to make this writing event to take place
automatically after each UI element modification by using
elm_prefs_autosave_set().
Note: $obj will keep a reference of its own for $prefs_data,
but you should still unreference it by yourself, after the widget
is gone.
@since 1.8]]
set {
return: bool; [[$true, on success, $false otherwise]]
}
get {
}
values {
data: Elm_Prefs_Data * @nullable; [[A valid prefs_data handle]]
}
}
@property autosave {
[[Control whether a given prefs widget should save its values back (on
the user data file, if set) automatically on every UI element
changes.
If $autosave is $true, every call to
elm_prefs_item_value_set(), every
Elm_Prefs_Data_Event_Type.ELM_PREFS_DATA_EVENT_ITEM_CHANGED event
coming for its prefs data and every UI element direct value
changing will implicitly make the prefs values to be flushed back
to it prefs data. If a prefs data handle with no writing
permissions or no prefs data is set on $prefs, naturally nothing
will happen.
@since 1.8]]
set {
}
get {
}
values {
autosave: bool; [[$true to save automatically, $false otherwise.]]
}
}
reset {
[[Reset the values of a given prefs widget to a previous state.
As can be seen on #Elm_Prefs_Reset_Mode, there are two possible
actions to be taken by this call -- either to reset $prefs'
values to the defaults (declared on the $.epb file it is bound
to) or to reset to the state they were before the last modification
it got.
@since 1.8]]
params {
@in mode: Elm_Prefs_Reset_Mode; [[The reset mode to apply on $prefs]]
}
}
item_value_set {
[[Set the value on a given prefs widget's item.
This will change the value of item named $name programatically.
@since 1.8]]
return: bool; [[$true, on success, $false otherwise]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection)]]
@in value: const(Eina.Value)*; [[The value to set on the item. It should be typed as the item expects, preferably, or a conversion will take place]]
}
}
item_value_get @const {
[[Get the value of a given prefs widget's item.
This will retrieve the value of item named $name.
@since 1.8]]
return: bool; [[$true, on success, $false otherwise]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get value from]]
@out value: Eina.Value; [[Where to store the value of the item. It will be overwritten and setup with the type the item is bound to]]
}
}
item_object_get {
[[Get the Elementary widget bound to a given prefs widget's item.
This will retrieve a handle to the real widget implementing a given
item of $prefs, <b>for read-only</b> actions.
Warning: You should never modify the state of the returned
widget, because it's meant to be managed by $prefs, solely.
@since 1.8]]
return: const(Evas.Object)*; [[A valid widget handle, on success, or $NULL, otherwise]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get object from]]
}
}
item_disabled_set {
[[Set whether the widget bound to a given prefs widget's item is disabled or not.
@since 1.8]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to act on]]
@in disabled: bool; [[$true, to make it disabled, $false otherwise]]
}
}
item_disabled_get @const {
[[Get whether the widget bound to a given prefs widget's item is disabled or not.
@since 1.8]]
return: bool; [[$true, if it is disabled, $false otherwise]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get disabled state from]]
}
}
item_swallow {
[["Swallows" an object into a SWALLOW item of a prefs widget.
@since 1.8]]
return: bool; [[$true, on success, $false otherwise]]
params {
@in name: const(char)*; [[the name of the SWALLOW item (as declared in the prefs collection)]]
@in child: Evas.Object *; [[The object to occupy the item]]
}
}
item_editable_set {
[[Set whether the widget bound to a given prefs widget's item is editable or not.
Note: Only $TEXT or $TEXTAREA items' default widgets implement
the 'editable' property. Custom registered widgets may as well
implement them.
@since 1.8]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to act on]]
@in editable: bool; [[$true, to make it editable, $false otherwise]]
}
}
item_editable_get @const {
[[Get whether the widget bound to a given prefs widget's item is editable or not.
@since 1.8]]
return: bool; [[$true, if it is editable, $false otherwise]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get editable state from]]
}
}
item_unswallow {
[[Unswallow an object from a SWALLOW item of a prefs widget.
@since 1.8]]
return: Evas.Object *; [[The unswallowed object, or NULL on errors]]
params {
@in name: const(char)*; [[the name of the SWALLOW item (as declared in the prefs collection)]]
}
}
item_visible_set {
[[Set whether the widget bound to given prefs widget's item should be visible or not.
Each prefs item may have a default visibility state, declared on
the $.epb $prefs it was loaded with. By this call one may alter
that state, programatically.
@since 1.8]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to change visibility of]]
@in visible: bool; [[$true, to make it visible, $false otherwise]]
}
}
item_visible_get @const {
[[Get whether the widget bound to a given prefs widget's item is visible or not.
@since 1.8]]
return: bool; [[$true, if it is visible, $false otherwise]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get visibility state from]]
}
}
}
implements {
class.constructor;
Eo.Base.constructor;
Efl.File.file.set;
Efl.File.file.get;
Evas.Object.Smart.del;
Evas.Object.Smart.add;
Elm.Widget.focus_next;
}
events {
page,changed; [[s]]
page,saved; [[s]]
page,reset; [[s]]
page,loaded; [[s]]
item,changed; [[s]]
action; [[ss]]
}
}
|
