summaryrefslogtreecommitdiff
path: root/src/lib/elementary/elm_prefs.eo
blob: 0f91b45f4eef24ca6a279046256acc2f82da4bfb (plain)
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
import eina_types;

type Elm_Prefs_Data: __undefined_type; [[Elementary preferences data type]]
type Elm_Prefs_Reset_Mode: __undefined_type; [[Elementary preferences reset mode type]]

class Elm.Prefs (Efl.Ui.Widget, Efl.File, Efl.Ui.Legacy)
{
   [[Elementary preferences class]]
   legacy_prefix: elm_prefs;
   eo_prefix: elm_obj_prefs;
   event_prefix: elm_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: ptr(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: string; [[The name of the item (as declared in the prefs collection)]]
            @in value: const(any_value_ptr); [[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: string; [[The name of the item (as declared in the prefs collection) to get value from]]
            @out value: any_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(Efl.Canvas.Object); [[A valid widget handle, on success, or $NULL, otherwise]]
         params {
            @in name: string; [[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: string; [[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: string; [[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: string; [[The name of the SWALLOW item (as declared in the prefs collection)]]
            @in child: Efl.Canvas.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: string; [[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: string; [[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: Efl.Canvas.Object; [[The unswallowed object, or NULL on errors]]
         params {
            @in name: string; [[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: string; [[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: string; [[The name of the item (as declared in the prefs collection) to get visibility state from]]
         }
      }
   }
   implements {
      class.constructor;
      Efl.Object.constructor;
      Efl.File.file { get; set; }
   }
   events {
      page,changed; [[Called when page changed]]
      page,saved; [[Called when page was saved]]
      page,reset; [[Called when page was reset]]
      page,loaded; [[Called when page got loaded]]
      item,changed; [[Called when item changed]]
      action; [[Called when action was done]]
   }
}