aboutsummaryrefslogtreecommitdiffstats
path: root/src/lib/elementary/efl_ui_text.eo
blob: 9a305da92005585a7c6871b73aee7acb387cfb64 (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
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
import elm_general;
import elm_entry;

struct Efl.Ui.Text.Anchor_Info
{
   [[EFL UI text anchor information]]
   name: string; [[The name of the anchor, as stated in its href.]]
   button: int; [[The mouse button used to click on it.]]
   x: int; [[Anchor geometry, relative to canvas.]]
   y: int; [[Anchor geometry, relative to canvas.]]
   w: int; [[Anchor geometry, relative to canvas.]]
   h: int; [[Anchor geometry, relative to canvas.]]
}

struct Efl.Ui.Text.Hover_Parent
{
   [[EFL text hover parent]]
   x: int; [[Hover parent X coordinate]]
   y: int; [[Hover parent Y coordinate]]
   w: int; [[Hover parent width]]
   h: int; [[Hover parent height]]
}

struct Efl.Ui.Text.Anchor_Hover_Info
{
   [[EFL text anchor hover information]]
   anchor_info: ptr(const(Efl.Ui.Text.Anchor_Info)); [[The actual anchor info.]]
   hover: Elm.Hover; [[The hover object to use for the popup.]]
   hover_parent: Efl.Ui.Text.Hover_Parent; [[Hover parent widget]]
   hover_left : bool; [[Hint indicating if there's space
                     for content on the left side of
                     the hover. Before calling the
                     callback, the widget will make the
                     necessary calculations to check
                     which sides are fit to be set with
                     content, based on the position the
                     hover is activated and its distance
                     to the edges of its parent object
                   ]]
   hover_right : bool; [[Hint indicating content fits on
                      the right side of the hover.
                      See @.hover_left.
                    ]]
   hover_top : bool; [[Hint indicating content fits on top
                    of the hover. @.hover_left.
                  ]]
   hover_bottom : bool; [[Hint indicating content fits
                                   below the hover. See
                                   @.hover_left.
                                  ]]
}

class Efl.Ui.Text (Elm.Layout, Elm.Interface_Scrollable, Efl.Ui.Clickable,
                 Elm.Interface.Atspi.Text, Elm.Interface.Atspi.Text.Editable, 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 an 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 {
         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 copy or past.
              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 {
            cnp_mode: Elm.Cnp_Mode; [[One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.]]
         }
      }
      @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 disabled 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 {
         set {
            [[Sets the entry to password mode.

              In password mode, entries are implicitly single line and the display of
              any text in 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 to use the text prediction.]]
         }
         get {
            [[Get whether the entry should allow to use the text prediction.]]
         }
         values {
            prediction: bool; [[Whether the entry should allow to use the text prediction.]]
         }
      }
      @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.]]
         }
      }
      item_provider_prepend {
         [[This prepends a custom item provider to the list for that entry

           This prepends the given callback.]]
         params {
            @in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]]
            @in data: void_ptr @optional; [[The data passed to $func.]]
         }
      }
      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.]]
      }
      item_provider_remove {
         [[This removes a custom item provider to the list for that entry

           This removes the given callback. See @.item_provider_append for
           more information
         ]]
         params {
            @in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]]
            @in data: void_ptr @optional; [[The data passed to $func.]]
         }
      }
      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 got 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.]]
      }
      item_provider_append {
         [[This appends a custom item provider to the list for that entry

           This appends the given callback. The list is walked from beginning to end
           with each function called given the item href string in the text. If the
           function returns an object handle other than $null (it should create an
           object to do this), then this object is used to replace that item. If
           not the next provider is called until one provides an item object, or the
           default provider in entry does.

           See also \@ref entry-items.
         ]]
         params {
            @in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]]
            @in data: void_ptr @optional; [[The data passed to $func.]]
         }
      }
      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, if this
           hasn't 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,
           and 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: Efl.Canvas.Text.Cursor; [[Text cursor]]
      }
   }
   implements {
      class.constructor;
      Efl.Object.constructor;
      Efl.Object.destructor;
      Efl.Gfx.visible { set; }
      Efl.Gfx.position { set; }
      Efl.Gfx.size { set; }
      Efl.Canvas.Group.group_member_add;
      Elm.Widget.activate;
      Elm.Widget.focus_direction_manager_is;
      Elm.Widget.theme_apply;
      Elm.Widget.on_focus;
      Elm.Widget.on_focus_region;
      Elm.Widget.disable;
      Elm.Widget.sub_object_del;
      Elm.Widget.focus_next_manager_is;
      Elm.Layout.theme_enable;
      Elm.Layout.sizing_eval;
      Elm.Layout.text { get; set; }
      Elm.Layout.signal_callback_add;
      Elm.Layout.signal_callback_del;
      Elm.Layout.signal_emit;
      Elm.Layout.content_aliases { get; }
      Elm.Interface_Scrollable.policy { set; }
      Elm.Interface_Scrollable.bounce_allow { set; }
      Elm.Interface.Atspi_Accessible.state_set { get; }
      Elm.Interface.Atspi_Accessible.name { get; }
      Elm.Interface.Atspi.Text.text { get; }
      Elm.Interface.Atspi.Text.string { get; }
      Elm.Interface.Atspi.Text.attribute { get; }
      Elm.Interface.Atspi.Text.attributes { get; }
      Elm.Interface.Atspi.Text.default_attributes { get; }
      Elm.Interface.Atspi.Text.caret_offset { get; set; }
      Elm.Interface.Atspi.Text.character { get; }
      Elm.Interface.Atspi.Text.character_extents { get; }
      Elm.Interface.Atspi.Text.character_count { get; }
      Elm.Interface.Atspi.Text.offset_at_point { get; }
      Elm.Interface.Atspi.Text.bounded_ranges { get; }
      Elm.Interface.Atspi.Text.range_extents { get; }
      Elm.Interface.Atspi.Text.selection { get; set; }
      Elm.Interface.Atspi.Text.selections_count { get; }
      Elm.Interface.Atspi.Text.selection_add;
      Elm.Interface.Atspi.Text.selection_remove;
      Elm.Interface.Atspi.Text.Editable.content { set; }
      Elm.Interface.Atspi.Text.Editable.insert;
      Elm.Interface.Atspi.Text.Editable.copy;
      Elm.Interface.Atspi.Text.Editable.cut;
      Elm.Interface.Atspi.Text.Editable.delete;
      Elm.Interface.Atspi.Text.Editable.paste;
      Efl.File.file { get; set; }
      Efl.Ui.Text.Interactive.editable { set; }
   }
   events {
      activated; [[Called when entry got activated]]
      changed; [[Called when entry changed]]
      changed,user; [[Called when object changed due to user interaction]]
      validate; [[Called when validating]]
      context,open; [[Called when context menu was opened]]
      anchor,clicked; [[Called when anchor was clicked]]
      rejected; [[Called when entry was 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 was requested]]
      undo,request; [[Called when undo was requested]]
      text,set,done; [[Called when text set finished]]
      aborted; [[Called when entry was 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]]
   }
}