aboutsummaryrefslogtreecommitdiffstats
path: root/src/lib/elementary/efl_ui_text.eo
blob: e873d9649ce4581e5f62cf88132f4aac666c166e (plain) (blame)
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
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
/* FIXME - Text object must stop using elm_general! */
import elm_general;

class Efl.Ui.Text (Efl.Ui.Layout, Elm.Interface_Scrollable, Efl.Ui.Clickable,
                 Efl.Access.Text, Efl.Access.Editable.Text, Efl.File,
                 Efl.Ui.Selectable, Efl.Ui.Scrollable, Efl.Ui.Text.Interactive)
{
   [[Efl UI text class]]
   methods {
      @property scrollable {
         set {
            [[Enable or disable scrolling in entry

              Normally the entry is not scrollable unless you enable it with this call.
            ]]
         }
         get {
            [[Get the scrollable state of the entry

              Normally the entry is not scrollable. This gets the scrollable state
              of the entry.
            ]]
         }
         values {
            scroll: bool; [[$true if it is to be scrollable, $false otherwise.]]
         }
      }
      @property input_panel_show_on_demand {
         set {
            [[Set 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.

              @since 1.9
            ]]
         }
         get {
            [[Get the attribute to show the input panel in case of only an user's explicit Mouse Up event.

              @since 1.9
            ]]
         }
         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 {
         set {
            [[This disables the entry's contextual (longpress) menu.]]
         }
         get {
            [[This returns whether the entry's contextual (longpress) menu is
              disabled.
            ]]
         }
         values {
            disabled: bool; [[If $true, the menu is disabled.]]
         }
      }
      @property cnp_mode {
         /* FIXME: Efl.Selection.Format does not allow markup without images! */
         set {
            [[Control pasting of text and images for the widget.

              Normally the entry allows both text and images to be pasted.
              By setting cnp_mode to be #ELM_CNP_MODE_NO_IMAGE this prevents images from being copied or pasted.
              By setting cnp_mode to be #ELM_CNP_MODE_PLAINTEXT this remove all tags in text .

              Note: This only changes the behaviour of text.
            ]]
         }
         get {
            [[Getting elm_entry text paste/drop mode.

              Normally the entry allows both text and images to be pasted.
              This gets the copy & paste mode of the entry.
            ]]
         }
         values {
            format: Efl.Selection.Format; [[Format for copy & paste.]]
         }
      }
      @property input_panel_language {
         set {
            [[Set the language mode of the input panel.

              This API can be used if you want to show the alphabet keyboard mode.
            ]]
         }
         get {
            [[Get the language mode of the input panel.]]
         }
         values {
            lang: Elm.Input.Panel.Lang; [[Language to be set to the input panel.]]
         }
      }
      @property selection_handler_disabled {
         set {
            [[This disables the entry's selection handlers.]]
         }
         get {
            [[This returns whether the entry's selection handlers are disabled.]]
            legacy: null;
         }
         values {
            disabled: bool; [[If $true, the selection handlers are disabled.]]
         }
      }
      @property input_panel_layout_variation {
         set {
            [[Set the input panel layout variation of the entry

              @since 1.8
            ]]
         }
         get {
            [[Get the input panel layout variation of the entry

              @since 1.8
            ]]
         }
         values {
            variation: int; [[Layout variation type.]]
         }
      }
      @property autocapital_type {
         set {
            [[Set the autocapitalization type on the immodule.]]
         }
         get {
            [[Get the autocapitalization type on the immodule.]]
         }
         values {
            autocapital_type: Elm.Autocapital.Type; [[The type of autocapitalization.]]
         }
      }
      @property password_mode {
         set {
            [[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 (*).
            ]]
         }
         get {
            [[Get whether the entry is set to password mode.]]
         }
         values {
            password: bool; [[If true, password mode is enabled.]]
         }
      }
      @property input_panel_return_key_disabled {
         set {
            [[Set the return key on the input panel to be disabled.]]
         }
         get {
            [[Get whether the return key on the input panel should be disabled or not.]]
         }
         values {
            disabled: bool; [[The state to put in in: $true for
            disabled, $false for enabled.]]
         }
      }
      @property prediction_allow {
         set {
            [[Set whether the entry should allow predictive text.]]
         }
         get {
            [[Get whether the entry allows predictive text.]]
         }
         values {
            prediction: bool; [[Whether the entry should allow predictive text.]]
         }
      }
      @property input_hint {
         set {
            [[Sets the input hint which allows input methods to fine-tune their behavior.]]
         }
         get {
            [[Gets the value of input hint.]]
         }
         values {
            hints: Elm.Input.Hints; [[Input hint.]]
         }
      }
      @property input_panel_layout {
         set {
            [[Set the input panel layout of the entry.]]
         }
         get {
            [[Get the input panel layout of the entry.]]
         }
         values {
            layout: Elm.Input.Panel.Layout(Elm.Input.Panel.Layout.invalid); [[Layout type.]]
         }
      }
      @property input_panel_return_key_type {
         set {
            [[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.
            ]]
         }
         get {
            [[Get the "return" key type.]]
         }
         values {
            return_key_type: Elm.Input.Panel.Return_Key.Type; [[The type of "return" key on the input panel.]]
         }
      }
      @property input_panel_enabled {
         set {
            [[Sets the attribute to show the input panel automatically.]]
         }
         get {
            [[Get the attribute to show the input panel automatically.]]
         }
         values {
            enabled: bool; [[If $true, the input panel is appeared when entry is clicked or has a focus.]]
         }
      }
      @property input_panel_return_key_autoenabled {
         set {
            [[Set 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.
              The default value is $false.
            ]]
         }
         values {
            enabled: bool; [[If $enabled is $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.destructor;
      Efl.Gfx.visible { set; }
      Efl.Gfx.position { set; }
      Efl.Gfx.size { set; }
      Efl.Canvas.Group.group_member_add;
      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.on_disabled_update;
      Efl.Ui.Widget.widget_sub_object_del;
      Elm.Interface_Scrollable.policy { set; }
      Elm.Interface_Scrollable.bounce_allow { set; }
      Efl.Access.state_set { get; }
      Efl.Access.i18n_name { get; }
      Efl.Access.Text.text { get; }
      Efl.Access.Text.string { get; }
      Efl.Access.Text.attribute { get; }
      Efl.Access.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.selection { get; set; }
      Efl.Access.Text.selections_count { get; }
      Efl.Access.Text.selection_add;
      Efl.Access.Text.selection_remove;
      Efl.Access.Editable.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 { get; set; }
      Efl.Ui.Text.Interactive.editable { set; }
   }
   events {
      activated; [[Called when entry is activated]]
      changed; [[Called when entry changes]]
      changed,user: Efl.Ui.Text.Change_Info;
         [[The text object has changed due to user interaction]]
      validate; [[Called when validating]]
      context,open; [[Called when context menu was opened]]
      anchor,clicked; [[Called when anchor is clicked]]
      rejected; [[Called when entry is rejected]]
      maxlength,reached; [[Called when maximum entry length has been reached]]
      preedit,changed; [[Called when entry preedit changed]]
      press; [[Called when entry pressed]]
      redo,request; [[Called when redo is requested]]
      undo,request; [[Called when undo is requested]]
      text,set,done; [[Called when text set finished]]
      aborted; [[Called when entry is aborted]]
      anchor,down; [[Called on anchor down]]
      anchor,hover,opened; [[Called when hover opened]]
      anchor,in; [[Called on anchor in]]
      anchor,out; [[Called on anchor out]]
      anchor,up; [[called on anchor up]]
      cursor,changed; [[Called on cursor changed]]
      cursor,changed,manual; [[Called on manual cursor change]]
   }
}