summaryrefslogtreecommitdiff
path: root/src/lib/elementary/efl_ui_text.eo
blob: 2118babe50530022dc75ded16944f20fa9add3ad (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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
/* FIXME - Text object must stop using elm_general! */
import elm_general;

class @beta Efl.Ui.Text extends Efl.Ui.Layout_Base implements Efl.Input.Clickable,
                 Efl.Access.Text, Efl.Access.Editable.Text, Efl.File,
                 Efl.Ui.Text_Selectable
   composites
                 Efl.Text_Interactive, Efl.Text_Markup
{
   [[A flexible text widget which can be static (as a label) or editable by
     the user (as a text entry). It provides all sorts of editing facilities
     like automatic scrollbars, virtual keyboard, clipboard, configurable
     context menus, password mode or autocapitalization, for example.]]
   methods {
      @property scrollable {
         [[Enable or disable scrolling in the widget.

           When scrolling is enabled scrollbars will appear if the text does
           not fit the widget size.]]
         set {}
         get {}
         values {
            scroll: bool; [[$true to enable scrolling. Default is $false.]]
         }
      }
      @property input_panel_show_on_demand {
         [[The attribute to show the input panel in case of only a user's explicit Mouse Up event.
           It doesn't request to show the input panel even though it has focus.
         ]]
         set {
         }
         get {
         }
         values {
            ondemand: bool; [[If $true, the input panel will be shown in case of only Mouse up event.
            (Focus event will be ignored.)
            ]]
         }
      }
      @property context_menu_disabled {
         [[This disables the entry's contextual (longpress) menu.]]
         set {
         }
         get {
         }
         values {
            disabled: bool; [[If $true, the menu is disabled.]]
         }
      }
      @property cnp_mode {
         /* FIXME: Efl.Ui.Selection_Format does not allow markup without images! */
         [[Control pasting of text and images for the widget.

           Normally the entry allows both text and images to be pasted.

           Note: This only changes the behaviour of text.
         ]]
         set {
         }
         get {
         }
         values {
            format: Efl.Ui.Selection_Format; [[Format for copy & paste.]]
         }
      }
      @property input_panel_language {
         [[The language mode of the input panel.

           This API can be used if you want to show the alphabet keyboard mode.
         ]]
         set {
         }
         get {
         }
         values {
            lang: Elm.Input.Panel.Lang; [[Language to be set to the input panel.]]
         }
      }
      @property selection_handler_disabled {
         [[This disables the entry's selection handlers.]]
         set {
         }
         get {
         }
         values {
            disabled: bool; [[If $true, the selection handlers are disabled.]]
         }
      }
      @property input_panel_layout_variation {
         [[Set the input panel layout variation of the entry
         ]]
         set {
         }
         get {
         }
         values {
            variation: int; [[Layout variation type.]]
         }
      }
      @property autocapital_type {
         [[Set the autocapitalization type on the immodule.]]
         set {
         }
         get {
         }
         values {
            autocapital_type: Elm.Autocapital.Type; [[The type of autocapitalization.]]
         }
      }
      @property password_mode {
         [[Sets the entry to password mode.

           In password mode entries are implicitly single line and the display of
           any text inside them is replaced with asterisks (*).
         ]]
         set {
         }
         get {
         }
         values {
            password: bool; [[If true, password mode is enabled.]]
         }
      }
      @property input_panel_return_key_disabled {
         [[Set the return key on the input panel to be disabled.]]
         set {
         }
         get {
         }
         values {
            disabled: bool; [[The state to put in in: $true for
            disabled, $false for enabled.]]
         }
      }
      @property prediction_allow {
         [[Whether the entry should allow predictive text.]]
         set {
         }
         get {
         }
         values {
            prediction: bool; [[Whether the entry should allow predictive text.]]
         }
      }
      @property input_hint {
         [[Sets the input hint which allows input methods to fine-tune their behavior.]]
         set {
         }
         get {
         }
         values {
            hints: Elm.Input.Hints; [[Input hint.]]
         }
      }
      @property input_panel_layout {
         [[Set the input panel layout of the entry.]]
         set {
         }
         get {
         }
         values {
            layout: Elm.Input.Panel.Layout(Elm.Input.Panel.Layout.invalid); [[Layout type.]]
         }
      }
      @property input_panel_return_key_type {
         [[Set the "return" key type. This type is used to set string or icon on the "return" key of the input panel.

           An input panel displays the string or icon associated with this type.
         ]]
         set {
         }
         get {
         }
         values {
            return_key_type: Elm.Input.Panel.Return_Key.Type; [[The type of "return" key on the input panel.]]
         }
      }
      @property input_panel_enabled {
         [[Sets the attribute to show the input panel automatically.]]
         set {
         }
         get {
         }
         values {
            enabled: bool; [[If $true, the input panel is appeared when entry is clicked or has a focus.]]
         }
      }
      @property input_panel_return_key_autoenabled {
         [[Whether the return key on the input panel is disabled automatically when entry has no text.

           If $enabled is $true, the return key on input panel is disabled when the entry has no text.
           The return key on the input panel is automatically enabled when the entry has text.
         ]]
         set {
         }
         values {
            enabled: bool(false); [[If $true, the return key is automatically disabled when the entry has no text.]]
         }
      }
      @property item_factory {
         [[The factory that provides item in the text e.g.
           "emoticon/happy" or "href=file://image.jpg" etc.
         ]]
         values {
            item_factory: Efl.Canvas.Text_Factory; [[Factory to create items]]
         }
      }
      input_panel_show {
         [[Show the input panel (virtual keyboard) based on the input panel property of entry such as layout,
           autocapital types and so on.

           Note that input panel is shown or hidden automatically according to the focus state of entry widget.
           This API can be used in the case of manually controlling by using @.input_panel_enabled.set(en, $false).
         ]]
      }
      selection_copy {
         [[This executes a "copy" action on the selected text in the entry.]]
      }
      context_menu_clear {
         [[This clears and frees the items in a entry's contextual (longpress)
           menu.

           See also @.context_menu_item_add.
         ]]
      }
      input_panel_imdata_set {
         [[Set the input panel-specific data to deliver to the input panel.

           This API is used by applications to deliver specific data to the input panel.
           The data format MUST be negotiated by both application and the input panel.
           The size and format of data are defined by the input panel.
         ]]
         params {
            @in data: const(void_ptr); [[The specific data to be set to the input panel.]]
            @in len: int; [[The length of data, in bytes, to send to the input panel.]]
         }
      }
      input_panel_imdata_get @const {
         [[Get the specific data of the current input panel.]]
         params {
            @inout data: void; [[The specific data to be obtained from the input panel.]]
            @out len: int; [[The length of data.]]
         }
      }
      selection_paste {
         [[This executes a "paste" action in the entry.]]
      }
      input_panel_hide {
         [[Hide the input panel (virtual keyboard).

           Note that input panel is shown or hidden automatically according to the focus state of entry widget.
           This API can be used in the case of manually controlling by using @.input_panel_enabled.set(en, $false)
         ]]
      }
      cursor_selection_end {
         [[This ends a selection within the entry as though
           the user had just released the mouse button while making a selection.]]
      }
      selection_cut {
         [[This executes a "cut" action on the selected text in the entry.]]
      }
      context_menu_item_add {
         [[This adds an item to the entry's contextual menu.

           A longpress on an entry will make the contextual menu show up unless this
           has been disabled with @.context_menu_disabled.set.
           By default this menu provides a few options like enabling selection mode,
           which is useful on embedded devices that need to be explicit about it.
           When a selection exists it also shows the copy and cut actions.

           With this function, developers can add other options to this menu to
           perform any action they deem necessary.
         ]]
         params {
            @in label: string @optional; [[The item's text label.]]
            @in icon_file: string @optional; [[The item's icon file.]]
            @in icon_type: Elm.Icon.Type; [[The item's icon type.]]
            @in func: Evas_Smart_Cb @optional; [[The callback to execute when the item is clicked.]]
            @in data: const(void_ptr) @optional; [[The data to associate with the item for related functions.]]
         }
      }
      cursor_new {
         [[Creates and returns a new cursor for the text.]]
         return: ptr(Efl.Text_Cursor_Cursor); [[Text cursor]]
      }
   }
   implements {
      Efl.Object.constructor;
      Efl.Object.finalize;
      Efl.Object.destructor;
      Efl.Gfx.Entity.visible { set; }
      Efl.Gfx.Entity.position { set; }
      Efl.Gfx.Entity.size { set; }
      Efl.Canvas.Group.group_member_add;
      Efl.Canvas.Group.group_calculate;
      Efl.Layout.Signal.signal_callback_add;
      Efl.Layout.Signal.signal_callback_del;
      Efl.Layout.Signal.signal_emit;
      Efl.Ui.Widget.on_access_activate;
      Efl.Ui.Widget.theme_apply;
      Efl.Ui.Focus.Object.on_focus_update;
      Efl.Ui.Widget.interest_region { get; }
      Efl.Ui.Widget.disabled {set;}
      //Efl.Ui.Widget.widget_sub_object_del;
      //Elm.Interface_Scrollable.policy { set; }
      //Elm.Interface_Scrollable.bounce_allow { set; }
      Efl.Access.Object.state_set { get; }
      Efl.Access.Object.i18n_name { get; }
      Efl.Access.Text.access_text { get; }
      Efl.Access.Text.string { get; }
      Efl.Access.Text.attribute { get; }
      Efl.Access.Text.text_attributes { get; }
      Efl.Access.Text.default_attributes { get; }
      Efl.Access.Text.caret_offset { get; set; }
      Efl.Access.Text.character { get; }
      Efl.Access.Text.character_extents { get; }
      Efl.Access.Text.character_count { get; }
      Efl.Access.Text.offset_at_point { get; }
      Efl.Access.Text.bounded_ranges { get; }
      Efl.Access.Text.range_extents { get; }
      Efl.Access.Text.access_selection { get; set; }
      Efl.Access.Text.selections_count { get; }
      Efl.Access.Text.selection_add;
      Efl.Access.Text.selection_remove;
      Efl.Access.Editable.Text.text_content { set; }
      Efl.Access.Editable.Text.insert;
      Efl.Access.Editable.Text.copy;
      Efl.Access.Editable.Text.cut;
      Efl.Access.Editable.Text.delete;
      Efl.Access.Editable.Text.paste;
      Efl.File.file { set; }
      Efl.File.load;
      Efl.File.unload;
      Efl.Text_Interactive.editable { set; }
      Efl.Part.part_get;
   }
   events {
      changed: void; [[Called when entry changes]]
      /* can be $NULL, tag nullable once Eolian supports it */
      changed,user: Efl.Ui.Text_Change_Info;
         [[The text object has changed due to user interaction]]
      validate: Elm.Validate_Content; [[Called when validating]]
      context,open: void; [[Called when context menu was opened]]
      preedit,changed: void; [[Called when entry preedit changed]]
      press: void; [[Called when entry pressed]]
      redo,request: void; [[Called when redo is requested]]
      undo,request: void; [[Called when undo is requested]]
      aborted: void; [[Called when entry is aborted]]
      anchor,down: Elm.Entry_Anchor_Info; [[Called on anchor down]]
      anchor,hover,opened: Elm.Entry_Anchor_Hover_Info; [[Called when hover opened]]
      anchor,in: Elm.Entry_Anchor_Info; [[Called on anchor in]]
      anchor,out: Elm.Entry_Anchor_Info; [[Called on anchor out]]
      anchor,up: Elm.Entry_Anchor_Info; [[called on anchor up]]
      cursor,changed,manual: void; [[Called on manual cursor change]]
   }
}