summaryrefslogtreecommitdiff
path: root/legacy/elementary/src/lib/elm_entry.eo
blob: 518309c69e88dc5a520c9f9f87f7865532dd2d2a (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
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
import elm_general;

enum Elm.Text_Format
{
   [[Text Format types.

     See also @Elm.Entry.file_text_format.
   ]]
   plain_utf8, [[ Plain UTF8 type ]]
   markup_utf8 [[ Markup UTF8 type ]]
}

enum Elm.Input.Panel.Layout
{
   [[Input panel (virtual keyboard) layout types.
     Type of input panel (virtual keyboard) to use - this is a hint and may not provide exactly what is desired.
     See also @Elm.Entry.input_panel_layout.set.
   ]]
   normal,      [[Default layout.]]
   number,      [[Number layout.]]
   email,       [[Email layout.]]
   url,         [[URL layout.]]
   phonenumber, [[Phone Number layout.]]
   ip,          [[IP layout.]]
   month,       [[Month layout.]]
   numberonly,  [[Number Only layout.]]
   invalid,     [[Never use this.]]
   hex,         [[Hexadecimal layout.]]
   terminal,    [[Command-line terminal layout including esc, alt, ctrl key, so on (no auto-correct, no auto-capitalization).]]
   password,    [[Like normal, but no auto-correct, no auto-capitalization etc.]]
   datetime,    [[Date and time layout

                  @since 1.8]]
   emoticon     [[Emoticon layout

                  @since 1.10]]
}

enum Elm.Input.Panel.Lang
{
   [[Input panel (virtual keyboard) language modes.

      See also @Elm.Entry.input_panel_language.set.
   ]]
   automatic,    [[Automatic]]
   alphabet      [[Alphabet]]
}

enum Elm.Autocapital.Type
{
   [[Autocapitalization Types.
     Choose method of auto-capitalization.

     See also @Elm.Entry.autocapital_type.set.
   ]]
   none,         [[No auto-capitalization when typing.]]
   word,         [[Autocapitalize each word typed.]]
   sentence,     [[Autocapitalize the start of each sentence.]]
   allcharacter  [[Autocapitalize all letters.]]
}

enum Elm.Input.Panel.Return_Key.Type
{
   [["Return" Key types on the input panel (virtual keyboard).
     See also @Elm.Entry.input_panel_return_key_type.set.

   ]]
   default, [[Default.]]
   done,    [[Done.]]
   go,      [[Go.]]
   join,    [[Join.]]
   login,   [[Login.]]
   next,    [[Next.]]
   search,  [[Search string or magnifier icon.]]
   send,    [[Send.]]
   signin   [[Sign-in

              @since 1.8]]
}

enum Elm.Input.Hints
{
   [[Enumeration that defines the types of Input Hints.

     @since 1.12
   ]]
   legacy: elm_input_hint;
   none                = 0,        [[No active hints

                                     @since 1.12]]
   auto_complete       = 1 << 0,   [[Suggest word auto completion

                                     @since 1.12]]
   sensitive_data      = 1 << 1,   [[Typed text should not be stored.

                                     @since 1.12]]
}

class Elm.Entry (Elm.Layout, Elm_Interface_Scrollable, Evas.Clickable_Interface,
                 Elm_Interface_Atspi_Text, Elm_Interface_Atspi_Editable_Text, Efl.File,
                 Evas.Selectable_Interface, Evas.Scrollable_Interface)
{
   eo_prefix: elm_obj_entry;
   methods {
      @property scrollable {
         set {
            /*@
            Enable or disable scrolling in entry

            Normally the entry is not scrollable unless you enable it with this call.

            @ingroup Entry */
         }
         get {
            /*@
            Get the scrollable state of the entry

            Normally the entry is not scrollable. This gets the scrollable state
            of the entry. See elm_entry_scrollable_set() for more information.

            @return The scrollable state

            @ingroup Entry */
         }
         values {
            scroll: bool; /*@ EINA_TRUE if it is to be scrollable, EINA_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.

            @ingroup Entry */
         }
         get {
            /*@
            Get the attribute to show the input panel in case of only an user's explicit Mouse Up event.

            @return @c EINA_TRUE if the input panel will be shown in case of only Mouse up event.
            @since 1.9

            @ingroup Entry */
         }
         values {
            ondemand: bool; /*@ If true, the input panel will be shown in case of only Mouse up event.
            (Focus event will be ignored.)
            @since 1.9 */
         }
      }
      @property context_menu_disabled {
         set {
            /*@
            This disables the entry's contextual (longpress) menu.

            @ingroup Entry */
         }
         get {
            /*@
            This returns whether the entry's contextual (longpress) menu is
            disabled.

            @return If true, the menu is disabled

            @ingroup Entry */
         }
         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.

            @ingroup Entry */
         }
         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.

            @return mode One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.

            @ingroup 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 file_text_format {
         [[Text format used to load and save the file, which could be plain text or markup text.

           Default is $ELM_TEXT_FORMAT_PLAIN_UTF8, if you want to use
           $ELM_TEXT_FORMAT_MARKUP_UTF8 then you need to set the text format
           before calling @Efl.File.file.set.

           You could also set it before a call to @.file_save
           in order to save with the given format.
         ]]

         set {
            [[Use it before calling @Efl.File.file.set or @.file_save.]]
         }
         values {
            format: Elm.Text_Format(Elm.Text_Format.plain_utf8); [[ The file format ]]
         }
      }
      @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.

            @ingroup Entry */
         }
         get {
            /*@
            Get the language mode of the input panel.

            See @ref elm_entry_input_panel_language_set for more details.

            @return input panel language type

            @ingroup Entry */
         }
         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.

            @ingroup Entry */
         }
         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

            @ingroup Entry
            @since 1.8 */
         }
         get {
            /*@
            Get the input panel layout variation of the entry

            @return layout variation type

            @see elm_entry_input_panel_layout_variation_set

            @ingroup Entry
            @since 1.8 */
         }
         values {
            variation: int; /*@ layout variation type */
         }
      }
      @property autocapital_type {
         set {
            /*@
            Set the autocapitalization type on the immodule.

            @ingroup Entry */
         }
         get {
            /*@
            Get the autocapitalization type on the immodule.

            @return autocapitalization type

            @ingroup Entry */
         }
         values {
            autocapital_type: Elm.Autocapital.Type; /*@ The type of autocapitalization */
         }
      }
      @property editable {
         set {
            /*@
            Sets if the entry is to be editable or not.

            By default, entries are editable and when focused, any text input by the
            user will be inserted at the current cursor position. But calling this
            function with @p editable as EINA_FALSE will prevent the user from
            inputting text into the entry.

            The only way to change the text of a non-editable entry is to use
            elm_object_text_set(), elm_entry_entry_insert() and other related
            functions.

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the entry is editable or not.

            @return If true, the entry is editable by the user.
            If false, it is not editable by the user

            @see elm_entry_editable_set()

            @ingroup Entry */
         }
         values {
            editable: bool; /*@ If EINA_TRUE, user input will be inserted in the entry,
            if not, the entry is read-only and no user input is allowed. */
         }
      }
      @property anchor_hover_style {
         set {
            /*@
            Set the style that the hover should use

            When creating the popup hover, entry will request that it's
            themed according to @p style.

            Setting style no @c NULL means disabling automatic hover.

            @see elm_object_style_set()

            @ingroup Entry */
         }
         get {
            /*@
            Get the style that the hover should use

            Get the style, the hover created by entry will use.

            @return The style to use by the hover. @c NULL means the default is used.

            @see elm_object_style_set()

            @ingroup Entry */
         }
         values {
            style: const(char)* @nullable; /*@ The style to use for the underlying hover */
         }
      }
      @property single_line {
         set {
            /*@
            Sets the entry to single line mode.

            In single line mode, entries don't ever wrap when the text reaches the
            edge, and instead they keep growing horizontally. Pressing the @c Enter
            key will generate an @c "activate" event instead of adding a new line.

            When @p single_line is @c EINA_FALSE, line wrapping takes effect again
            and pressing enter will break the text into a different line
            without generating any events.

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the entry is set to be single line.

            @return single_line If true, the text in the entry is set to display
            on a single line.

            @see elm_entry_single_line_set()

            @ingroup Entry */
         }
         values {
            single_line: bool; /*@ If true, the text in the entry
            will be on a single line. */
         }
      }
      @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 (*).

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the entry is set to password mode.

            @return If true, the entry is set to display all characters
            as asterisks (*).

            @see elm_entry_password_set()

            @ingroup Entry */
         }
         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.

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the return key on the input panel should be disabled or not.

            @return EINA_TRUE if it should be disabled

            @ingroup Entry */
         }
         values {
            disabled: bool; /*@ The state to put in in: @c EINA_TRUE for
            disabled, @c EINA_FALSE for enabled */
         }
      }
      @property autosave {
         set {
            /*@
            This sets the entry object to 'autosave' the loaded text file or not.

            @see elm_entry_file_set()

            @ingroup Entry */
         }
         get {
            /*@
            This gets the entry object's 'autosave' status.

            @return Autosave the loaded file or not

            @see elm_entry_file_set()

            @ingroup Entry */
         }
         values {
            auto_save: bool; /*@ Autosave the loaded file or not */
         }
      }
      @property anchor_hover_parent {
         set {
            /*@
            Set the parent of the hover popup

            Sets the parent object to use by the hover created by the entry
            when an anchor is clicked. See @ref Hover for more details on this.

            @ingroup Entry */
         }
         get {
            /*@
            Get the parent of the hover popup

            Get the object used as parent for the hover created by the entry
            widget. See @ref Hover for more details on this.
            If no parent is set, the same entry object will be used.

            @return The object used as parent for the hover, NULL if none is set.

            @ingroup Entry */
         }
         values {
            parent: Evas.Object * @nullable; /*@ The object to use as parent for the hover */
         }
      }
      @property prediction_allow {
         set {
            /*@
            Set whether the entry should allow to use the text prediction.

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the entry should allow to use the text prediction.

            @return EINA_TRUE if it allows to use the text prediction, otherwise EINA_FALSE.

            @ingroup Entry */
         }
         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.

            @ingroup Entry */
         }
         get {
            /*@
            Gets the value of input hint.

            @return the value of input hint.

            @see elm_entry_input_hint_set

            @ingroup Entry */
         }
         values {
            hints: Elm.Input.Hints; /*@ input hint. */
         }
      }
      @property input_panel_layout {
         set {
            /*@
            Set the input panel layout of the entry

            @ingroup Entry */
         }
         get {
            /*@
            Get the input panel layout of the entry

            @return layout type. It returns ELM_INPUT_PANEL_LAYOUT_INVALID(8) when it fails.

            @see elm_entry_input_panel_layout_set

            @ingroup 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

            @ingroup Entry */
         }
         get {
            /*@
            Get the "return" key type.

            @see elm_entry_input_panel_return_key_type_set() for more details

            @return The type of "return" key on the input panel

            @ingroup Entry */
         }
         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.

            @ingroup Entry */
         }
         get {
            /*@
            Get the attribute to show the input panel automatically.

            @return EINA_TRUE if input panel will be appeared when the entry is clicked or has a focus, EINA_FALSE otherwise

            @ingroup Entry */
         }
         values {
            enabled: bool; /*@ If true, the input panel is appeared when entry is clicked or has a focus */
         }
      }
      @property line_wrap {
         set {
            /*@
            Set the line wrap type to use on multi-line entries.

            Sets the wrap type used by the entry to any of the specified in
            Elm_Wrap_Type. This tells how the text will be implicitly cut into a new
            line (without inserting a line break or paragraph separator) when it
            reaches the far edge of the widget.

            Note that this only makes sense for multi-line entries. A widget set
            to be single line will never wrap.

            @ingroup Entry */
         }
         get {
            /*@
            Get the wrap mode the entry was set to use.

            @return Wrap type

            @see also elm_entry_line_wrap_set()

            @ingroup Entry */
         }
         values {
            wrap: Elm.Wrap.Type; /*@ The wrap mode to use. See Elm_Wrap_Type for details on them */
         }
      }
      @property cursor_pos {
         set {
            /*@
            Sets the cursor position in the entry to the given value

            The value in @p pos is the index of the character position within the
            contents of the string as returned by elm_entry_cursor_pos_get().

            @ingroup Entry */
         }
         get {
            /*@
            Get the current position of the cursor in the entry

            @return The cursor position

            @ingroup Entry */
         }
         values {
            pos: int; /*@ The position of the cursor */
         }
      }
      @property icon_visible {
         set {
            /*@
            Sets the visibility of the left-side widget of the entry,
            set by elm_object_part_content_set().

            @ingroup Entry */
         }
         values {
            setting: bool; /*@ EINA_TRUE if the object should be displayed,
            EINA_FALSE if not. */
         }
      }
      @property cursor_line_end {
         set {
            /*@
            This moves the cursor to the end of the current line.

            @ingroup Entry */
         }
      }
      @property select_region {
         set {
            /*@
            This selects a region of text within the entry.

            @ingroup Entry
            @since 1.9 */
         }
         values {
            start: int; /*@ The starting position */
            end: int; /*@ The end position */
         }
      }
      @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 @p enabled is EINA_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 EINA_FALSE.

            @ingroup Entry */
         }
         values {
            enabled: bool; /*@ If @p enabled is EINA_TRUE, the return key is automatically disabled when the entry has no text. */
         }
      }
      @property end_visible {
         set {
            /*@
            Sets the visibility of the end widget of the entry, set by
            elm_object_part_content_set(ent, "end", content).

            @ingroup Entry */
         }
         values {
            setting: bool; /*@ EINA_TRUE if the object should be displayed,
            EINA_FALSE if not. */
         }
      }
      @property cursor_begin {
         set {
            /*@
            This moves the cursor to the beginning of the entry.

            @ingroup Entry */
         }
      }
      @property cursor_line_begin {
         set {
            /*@
            This moves the cursor to the beginning of the current line.

            @ingroup Entry */
         }
      }
      @property cursor_end {
         set {
            /*@
            This moves the cursor to the end of the entry.

            @ingroup Entry */
         }
      }
      @property textblock {
         get {
            /*@
            Returns the actual textblock object of the entry.

            This function exposes the internal textblock object that actually
            contains and draws the text. This should be used for low-level
            manipulations that are otherwise not possible.

            Changing the textblock directly from here will not notify edje/elm to
            recalculate the textblock size automatically, so any modifications
            done to the textblock returned by this function should be followed by
            a call to elm_entry_calc_force().

            The return value is marked as const as an additional warning.
            One should not use the returned object with any of the generic evas
            functions (geometry_get/resize/move and etc), but only with the textblock
            functions; The former will either not work at all, or break the correct
            functionality.

            IMPORTANT: Many functions may change (i.e delete and create a new one)
            the internal textblock object. Do NOT cache the returned object, and try
            not to mix calls on this object with regular elm_entry calls (which may
            change the internal textblock object). This applies to all cursors
            returned from textblock calls, and all the other derivative values.

            @return The textblock object.

            @ingroup Entry */
            return: Evas.Object *;
         }
      }
      @property cursor_geometry {
         get {
            /*@
            This function returns the geometry of the cursor.

            It's useful if you want to draw something on the cursor (or where it is),
            or for example in the case of scrolled entry where you want to show the
            cursor.

            @return EINA_TRUE upon success, EINA_FALSE upon failure

            @ingroup Entry */
            return: bool;
         }
         values {
            x: Evas.Coord; /*@ returned geometry */
            y: Evas.Coord; /*@ returned geometry */
            w: Evas.Coord; /*@ returned geometry */
            h: Evas.Coord; /*@ returned geometry */
         }
      }
      @property imf_context {
         get {
            /*@
            Returns the input method context of the entry.

            This function exposes the internal input method context.

            IMPORTANT: Many functions may change (i.e delete and create a new one)
            the internal input method context. Do NOT cache the returned object.

            @return The input method context (Ecore_IMF_Context *) in entry.

            @ingroup Entry */
            return: void *;
         }
      }
      @property cursor_is_format {
         get {
            /*@
            Get whether a format node exists at the current cursor position.

            A format node is anything that defines how the text is rendered. It can
            be a visible format node, such as a line break or a paragraph separator,
            or an invisible one, such as bold begin or end tag.
            This function returns whether any format node exists at the current
            cursor position.

            @return EINA_TRUE if the current cursor position contains a format node,
            EINA_FALSE otherwise.

            @see elm_entry_cursor_is_visible_format_get()

            @ingroup Entry */
            return: bool;
         }
      }
      @property cursor_content {
         get {
            /*@
            Get the character pointed by the cursor at its current position.

            This function returns a string with the utf8 character stored at the
            current cursor position.
            Only the text is returned, any format that may exist will not be part
            of the return value. You must free the string when done with free().

            @return The text pointed by the cursors.

            @ingroup Entry */
            return: own(char *) @warn_unused;
         }
      }
      @property selection {
         get {
            /*@
            Get any selected text within the entry.

            If there's any selected text in the entry, this function returns it as
            a string in markup format. NULL is returned if no selection exists or
            if an error occurred.

            The returned value points to an internal string and should not be freed
            or modified in any way. If the @p entry object is deleted or its
            contents are changed, the returned pointer should be considered invalid.

            @return The selected text within the entry or NULL on failure

            @ingroup Entry */
            return: const(char)*;
         }
      }
      @property cursor_is_visible_format {
         get {
            /*@
            Get if the current cursor position holds a visible format node.

            @return EINA_TRUE if the current cursor is a visible format, EINA_FALSE
            if it's an invisible one or no format exists.

            @see elm_entry_cursor_is_format_get()

            @ingroup Entry */
            return: bool;
         }
      }
      cursor_prev {
         /*@
         This moves the cursor one place to the left within the entry.

         @return EINA_TRUE upon success, EINA_FALSE upon failure

         @ingroup Entry */

         return: bool;
      }
      text_style_user_pop {
         /*@
         Remove the style in the top of user style stack.

         @see elm_entry_text_style_user_push()

         @ingroup Entry
         @since 1.7 */

      }
      item_provider_prepend {
         /*@
         This prepends a custom item provider to the list for that entry

         This prepends the given callback. See elm_entry_item_provider_append() for
         more information

         @ingroup Entry */

         params {
            @in func: Elm_Entry_Item_Provider_Cb; /*@ The function called to provide the item object */
            @in data: void * @optional; /*@ The data passed to @p 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 elm_entry_input_panel_enabled_set(en, EINA_FALSE).

         @ingroup Entry */

      }
      imf_context_reset {
         /*@
         Reset the input method context of the entry if needed.

         This can be necessary in the case where modifying the buffer would confuse on-going input method behavior.
         This will typically cause the Input Method Context to clear the preedit state.
         @ingroup Entry */

      }
      calc_force {
         /*@
         Forces calculation of the entry size and text layouting.

         This should be used after modifying the textblock object directly. See
         elm_entry_textblock_get() for more information.

         @see elm_entry_textblock_get()

         @ingroup Entry */

      }
      anchor_hover_end {
         /*@
         Ends the hover popup in the entry

         When an anchor is clicked, the entry widget will create a hover
         object to use as a popup with user provided content. This function
         terminates this popup, returning the entry to its normal state.

         @ingroup Entry */

      }
      cursor_selection_begin {
         /*@
         This begins a selection within the entry as though
         the user were holding down the mouse button to make a selection.

         @ingroup Entry */

      }
      cursor_down {
         /*@
         This moves the cursor one line down within the entry.

         @return EINA_TRUE upon success, EINA_FALSE upon failure

         @ingroup Entry */

         return: bool;
      }
      file_save {
         /*@
         This function writes any changes made to the file set with
         elm_entry_file_set()

         @ingroup Entry */

      }
      selection_copy {
         /*@
         This executes a "copy" action on the selected text in the entry.

         @ingroup Entry */

      }
      text_style_user_push {
         /*@
         Push the style to the top of user style stack.
         If there is styles in the user style stack, the properties in the top style
         of user style stack will replace the properties in current theme.
         The input style is specified in format tag='property=value' (i.e. DEFAULT='font=Sans font_size=60'hilight=' + font_weight=Bold').

         @ingroup Entry
         @since 1.7 */

         params {
            @in style: const(char)*; /*@ The style user to push */
         }
      }
      item_provider_remove {
         /*@
         This removes a custom item provider to the list for that entry

         This removes the given callback. See elm_entry_item_provider_append() for
         more information

         @ingroup Entry */

         params {
            @in func: Elm_Entry_Item_Provider_Cb; /*@ The function called to provide the item object */
            @in data: void * @optional; /*@ The data passed to @p func */
         }
      }
      text_style_user_peek @const {
         /*@
         Get the style on the top of user style stack.

         @return style on the top of user style stack if exist, otherwise NULL.

         @see elm_entry_text_style_user_push()

         @ingroup Entry
         @since 1.7 */
         return: const(char)*;
      }
      context_menu_clear {
         /*@
         This clears and frees the items in a entry's contextual (longpress)
         menu.

         @see elm_entry_context_menu_item_add()

         @ingroup Entry */

      }
      cursor_up {
         /*@
         This moves the cursor one line up within the entry.

         @return EINA_TRUE upon success, EINA_FALSE upon failure

         @ingroup Entry */

         return: bool;
      }
      entry_insert {
         /*@
         Inserts the given text into the entry at the current cursor position.

         This inserts text at the cursor position as if it was typed
         by the user (note that this also allows markup which a user
         can't just "type" as it would be converted to escaped text, so this
         call can be used to insert things like emoticon items or bold push/pop
         tags, other font and color change tags etc.)

         If any selection exists, it will be replaced by the inserted text.

         The inserted text is subject to any filters set for the widget.

         @see elm_entry_markup_filter_append()

         @ingroup Entry */

         params {
            @in entry: const(char)*; /*@ The text to insert */
         }
      }
      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.

         @ingroup Entry */

         params {
            @in data: const(void)*; /*@ 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.

         See @ref elm_entry_input_panel_imdata_set for more details.

         @ingroup Entry */
         params {
            @out 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.

         @ingroup Entry */

      }
      cursor_next {
         /*@
         This moves the cursor one place to the right within the entry.

         @return EINA_TRUE upon success, EINA_FALSE upon failure

         @ingroup Entry */

         return: bool;
      }
      select_none {
         /*@
         This drops any existing text selection within the entry.

         @ingroup 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 elm_entry_input_panel_enabled_set(en, EINA_FALSE)

         @ingroup Entry */

      }
      select_all {
         /*@
         This selects all text within the entry.

         @ingroup Entry */

      }
      cursor_selection_end {
         /*@
         This ends a selection within the entry as though
         the user had just released the mouse button while making a selection.

         @ingroup Entry */

      }
      selection_cut {
         /*@
         This executes a "cut" action on the selected text in the entry.

         @ingroup Entry */

      }
      is_empty @const {
         /*@
         Get whether the entry is empty.

         Empty means no text at all. If there are any markup tags, like an item
         tag for which no provider finds anything, and no text is displayed, this
         function still returns EINA_FALSE.

         @return @c EINA_TRUE if the entry text is empty or @p entry is NULL, @c EINA_FALSE otherwise.

         @ingroup Entry */
         return: bool(true);
      }
      markup_filter_remove {
         /*@
         Remove a markup filter from the list

         Removes the given callback from the filter list. See
         elm_entry_markup_filter_append() for more information.

         @ingroup Entry */

         params {
            @in func: Elm_Entry_Filter_Cb; /*@ The filter function to remove */
            @in data: void * @optional; /*@ The user data passed when adding the function */
         }
      }
      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 @ref entry-items

         @ingroup Entry */

         params {
            @in func: Elm_Entry_Item_Provider_Cb; /*@ The function called to provide the item object */
            @in data: void * @optional; /*@ The data passed to @p func */
         }
      }
      markup_filter_append {
         /*@
         Append a markup filter function for text inserted in the entry

         Append the given callback to the list. This functions will be called
         whenever any text is inserted into the entry, with the text to be inserted
         as a parameter. The type of given text is always markup.
         The callback function is free to alter the text in any way it wants, but
         it must remember to free the given pointer and update it.
         If the new text is to be discarded, the function can free it and set its
         text parameter to NULL. This will also prevent any following filters from
         being called.

         @ingroup Entry */

         params {
            @in func: Elm_Entry_Filter_Cb; /*@ The function to use as text filter */
            @in data: void * @optional; /*@ User data to pass to @p func */
         }
      }
      entry_append {
         /*@
         Appends @p str to the text of the entry.

         Adds the text in @p str to the end of any text already present in the
         widget.

         The appended text is subject to any filters set for the widget.

         @see elm_entry_markup_filter_append()

         @ingroup Entry */

         params {
            @in str: const(char)*; /*@ The text to be appended */
         }
      }
      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 elm_entry_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.

         @ingroup Entry */

         params {
            @in label: const(char)* @optional; /*@ The item's text label */
            @in icon_file: const(char)* @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)* @optional; /*@ The data to associate with the item for related functions */
         }
      }
      markup_filter_prepend {
         /*@
         Prepend a markup filter function for text inserted in the entry

         Prepend the given callback to the list. See elm_entry_markup_filter_append()
         for more information

         @ingroup Entry */

         params {
            @in func: Elm_Entry_Filter_Cb; /*@ The function to use as text filter */
            @in data: void * @optional; /*@ User data to pass to @p func */
         }
      }
   }
   implements {
      class.constructor;
      Eo.Base.constructor;
      Evas.Object_Smart.move;
      Evas.Object_Smart.member_add;
      Evas.Object_Smart.add;
      Evas.Object_Smart.resize;
      Evas.Object_Smart.del;
      Evas.Object_Smart.show;
      Evas.Object_Smart.hide;
      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.Container.content_unset;
      Elm.Container.content_set;
      Elm.Layout.theme_enable;
      Elm.Layout.sizing_eval;
      Elm.Layout.text_get;
      Elm.Layout.signal_callback_add;
      Elm.Layout.signal_callback_del;
      Elm.Layout.signal_emit;
      Elm.Layout.text_set;
      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;
      Elm_Interface_Atspi_Text.caret_offset.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;
      Elm_Interface_Atspi_Text.selections_count.get;
      Elm_Interface_Atspi_Text.selection_add;
      Elm_Interface_Atspi_Text.selection_remove;
      Elm_Interface_Atspi_Text.selection.set;
      Elm_Interface_Atspi_Editable_Text.content.set;
      Elm_Interface_Atspi_Editable_Text.insert;
      Elm_Interface_Atspi_Editable_Text.copy;
      Elm_Interface_Atspi_Editable_Text.cut;
      Elm_Interface_Atspi_Editable_Text.delete;
      Elm_Interface_Atspi_Editable_Text.paste;
      Efl.File.file.set;
      Efl.File.file.get;
   }
   events {
      language,changed;
      access,changed;
      activated;
      changed;
      changed,user;
      validate;
      context,open;
      anchor,clicked;
      rejected;
      maxlength,reached;
      preedit,changed;
      press;
      redo,request;
      undo,request;
      text,set,done;
      aborted;
      anchor,down;
      anchor,hover,opened;
      anchor,in;
      anchor,out;
      anchor,up;
      cursor,changed;
      cursor,changed,manual;
   }

}