summaryrefslogtreecommitdiff
path: root/elementary/elementary.c_elementary_entry.pxi
blob: 74f37a53f6372c4aa6d89f1e20d7946512eb2da6 (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
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
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
# Copyright (c) 2008-2009 Simon Busch
#
# This file is part of python-elementary.
#
# python-elementary is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# python-elementary is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with python-elementary.  If not, see <http://www.gnu.org/licenses/>.
#

def Entry_markup_to_utf8(str):
    cdef const_char_ptr string
    string = elm_entry_markup_to_utf8(str)
    if string == NULL:
        return None
    return string

def Entry_utf8_to_markup(str):
    cdef const_char_ptr string
    string = elm_entry_utf8_to_markup(str)
    if string == NULL:
        return None
    return string

class EntryAnchorInfo:
    def __init__(self):
        self.name = None
        self.button = 0
        self.x = 0
        self.y = 0
        self.w = 0
        self.h = 0

class EntryAnchorHoverInfo:
    def __init__(self):
        self.anchor_info = None
        self.hover = None
        self.hover_parent = (0, 0, 0, 0)
        self.hover_left = False
        self.hover_right = False
        self.hover_top = False
        self.hover_bottom = False

def _entryanchor_conv(long addr):
    cdef Elm_Entry_Anchor_Info *ei = <Elm_Entry_Anchor_Info *>addr
    eai = EntryAnchorInfo()
    eai.name = ei.name
    eai.button = ei.button
    eai.x = ei.x
    eai.y = ei.y
    eai.w = ei.w
    eai.h = ei.h
    return eai

def _entryanchorhover_conv(long addr):
    cdef Elm_Entry_Anchor_Hover_Info *ehi = <Elm_Entry_Anchor_Hover_Info *>addr
    eahi = EntryAnchorHoverInfo()
    eahi.anchor_info = <object>ehi.anchor_info
    eahi.hover = Hover(None, <object>ehi.hover)
    eahi.hover_parent = (ehi.hover_parent.x, ehi.hover_parent.y,
                       ehi.hover_parent.w, ehi.hover_parent.h)
    eahi.hover_left = ehi.hover_left
    eahi.hover_right = ehi.hover_right
    eahi.hover_top = ehi.hover_top
    eahi.hover_bottom = ehi.hover_bottom
    return eahi

cdef public class Entry(Object) [object PyElementaryEntry, type PyElementaryEntry_Type]:

    """An entry is a convenience widget which shows a box that the user can
    enter text into.

    Entries by default don't scroll, so they grow to
    accommodate the entire text, resizing the parent window as needed. This
    can be changed with the L{scrollable_set()} function.

    They can also be single line or multi line (the default) and when set
    to multi line mode they support text wrapping in any of the modes
    indicated by C{Elm_Wrap_Type}.

    Other features include password mode, filtering of inserted text with
    L{markup_filter_append()} and related functions, inline "items" and
    formatted markup text.

    Formatted text
    ==============

    The markup tags supported by the Entry are defined by the theme, but
    even when writing new themes or extensions it's a good idea to stick to
    a sane default, to maintain coherency and avoid application breakages.
    Currently defined by the default theme are the following tags:
        - <br>: Inserts a line break.
        - <ps>: Inserts a paragraph separator. This is preferred over line
          breaks.
        - <tab>: Inserts a tab.
        - <em>...</em>: Emphasis. Sets the @em oblique style for the
          enclosed text.
        - <b>...</b>: Sets the @b bold style for the enclosed text.
        - <link>...</link>: Underlines the enclosed text.
        - <hilight>...</hilight>: Highlights the enclosed text.

    Special markups
    ===============

    Besides those used to format text, entries support two special markup
    tags used to insert click-able portions of text or items inlined within
    the text.

    Anchors
    -------

    Anchors are similar to HTML anchors. Text can be surrounded by <a> and
    </a> tags and an event will be generated when this text is clicked,
    like this:

    C{This text is outside <a href=anc-01>but this one is an anchor</a>}

    The C{href} attribute in the opening tag gives the name that will be
    used to identify the anchor and it can be any valid utf8 string.

    When an anchor is clicked, an C{"anchor,clicked"} signal is emitted with
    an C{Elm_Entry_Anchor_Info} in the C{event_info} parameter for the
    callback function. The same applies for "anchor,in" (mouse in), "anchor,out"
    (mouse out), "anchor,down" (mouse down), and "anchor,up" (mouse up) events on
    an anchor.

    Items
    -----

    Inlined in the text, any other L{Object} can be inserted by using
    <item> tags this way:

    C{<item size=16x16 vsize=full href=emoticon/haha></item>}

    Just like with anchors, the C{href} identifies each item, but these need,
    in addition, to indicate their size, which is done using any one of
    C{size}, C{absize} or C{relsize} attributes. These attributes take their
    value in the WxH format, where W is the width and H the height of the
    item.

        - absize: Absolute pixel size for the item. Whatever value is set will
          be the item's size regardless of any scale value the object may have
          been set to. The final line height will be adjusted to fit larger items.
        - size: Similar to C{absize}, but it's adjusted to the scale value set
          for the object.
        - relsize: Size is adjusted for the item to fit within the current
          line height.

    Besides their size, items are specified a C{vsize} value that affects
    how their final size and position are calculated. The possible values
    are:
        - ascent: Item will be placed within the line's baseline and its
          ascent. That is, the height between the line where all characters are
          positioned and the highest point in the line. For C{size} and C{absize}
          items, the descent value will be added to the total line height to make
          them fit. C{relsize} items will be adjusted to fit within this space.
        - full: Items will be placed between the descent and ascent, or the
          lowest point in the line and its highest.

    After the size for an item is calculated, the entry will request an
    object to place in its space. For this, the functions set with
    L{item_provider_append()} and related functions will be called
    in order until one of them returns a non-C{None} value. If no providers
    are available, or all of them return C{None}, then the entry falls back
    to one of the internal defaults, provided the name matches with one of
    them.

    All of the following are currently supported:
        - emoticon/angry
        - emoticon/angry-shout
        - emoticon/crazy-laugh
        - emoticon/evil-laugh
        - emoticon/evil
        - emoticon/goggle-smile
        - emoticon/grumpy
        - emoticon/grumpy-smile
        - emoticon/guilty
        - emoticon/guilty-smile
        - emoticon/haha
        - emoticon/half-smile
        - emoticon/happy-panting
        - emoticon/happy
        - emoticon/indifferent
        - emoticon/kiss
        - emoticon/knowing-grin
        - emoticon/laugh
        - emoticon/little-bit-sorry
        - emoticon/love-lots
        - emoticon/love
        - emoticon/minimal-smile
        - emoticon/not-happy
        - emoticon/not-impressed
        - emoticon/omg
        - emoticon/opensmile
        - emoticon/smile
        - emoticon/sorry
        - emoticon/squint-laugh
        - emoticon/surprised
        - emoticon/suspicious
        - emoticon/tongue-dangling
        - emoticon/tongue-poke
        - emoticon/uh
        - emoticon/unhappy
        - emoticon/very-sorry
        - emoticon/what
        - emoticon/wink
        - emoticon/worried
        - emoticon/wtf

    Alternatively, an item may reference an image by its path, using
    the URI form C{file:///path/to/an/image.png} and the entry will then
    use that image for the item.

    Setting entry's style
    =====================

    There are 2 major ways to change the entry's style:
        - Theme - set the "base" field to the desired style.
        - User style - Pushing overrides to the theme style to the textblock object
          by using evas_object_textblock_style_user_push().

    You should modify the theme when you would like to change the style for
    aesthetic reasons. While the user style should be changed when you would
    like to change the style to something specific defined at run-time, e.g,
    setting font or font size in a text editor.

    Loading and saving files
    ========================

    Entries have convenience functions to load text from a file and save
    changes back to it after a short delay. The automatic saving is enabled
    by default, but can be disabled with L{autosave_set()} and files
    can be loaded directly as plain text or have any markup in them
    recognized. See L{file_set()} for more details.

    Emitted signals
    ===============

    This widget emits the following signals:
        - "changed": The text within the entry was changed.
        - "changed,user": The text within the entry was changed because of user interaction.
        - "activated": The enter key was pressed on a single line entry.
        - "press": A mouse button has been pressed on the entry.
        - "longpressed": A mouse button has been pressed and held for a couple
          seconds.
        - "clicked": The entry has been clicked (mouse press and release).
        - "clicked,double": The entry has been double clicked.
        - "clicked,triple": The entry has been triple clicked.
        - "focused": The entry has received focus.
        - "unfocused": The entry has lost focus.
        - "selection,paste": A paste of the clipboard contents was requested.
        - "selection,copy": A copy of the selected text into the clipboard was
          requested.
        - "selection,cut": A cut of the selected text into the clipboard was
          requested.
        - "selection,start": A selection has begun and no previous selection
          existed.
        - "selection,changed": The current selection has changed.
        - "selection,cleared": The current selection has been cleared.
        - "cursor,changed": The cursor has changed position.
        - "anchor,clicked": An anchor has been clicked. The event_info
          parameter for the callback will be an C{Elm_Entry_Anchor_Info}.
        - "anchor,in": Mouse cursor has moved into an anchor. The event_info
          parameter for the callback will be an C{Elm_Entry_Anchor_Info}.
        - "anchor,out": Mouse cursor has moved out of an anchor. The event_info
          parameter for the callback will be an C{Elm_Entry_Anchor_Info}.
        - "anchor,up": Mouse button has been unpressed on an anchor. The event_info
          parameter for the callback will be an C{Elm_Entry_Anchor_Info}.
        - "anchor,down": Mouse button has been pressed on an anchor. The event_info
          parameter for the callback will be an C{Elm_Entry_Anchor_Info}.
        - "preedit,changed": The preedit string has changed.
        - "language,changed": Program language changed.

    Default content parts of the entry items that you can use for are:
        - "icon" - An icon in the entry
        - "end" - A content in the end of the entry

    Default text parts of the entry that you can use for are:
        - "default" - text of the entry

    """

    def __init__(self, evasObject parent):
        """This adds an entry to @p parent object.

        By default, entries are:
            - not scrolled
            - multi-line
            - word wrapped
            - autosave is enabled

        @param parent: The parent object
        @type parent: L{Object}
        @return: The new object or None if it cannot be created
        @rtype: L{Object}

        """
        Object.__init__(self, parent.evas)
        self._set_obj(elm_entry_add(parent.obj))

    def single_line_set(self, single_line):
        """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 C{single_line} is C{False}, line wrapping takes effect again
        and pressing enter will break the text into a different line
        without generating any events.

        @param single_line: If true, the text in the entry will be on a single
            line.
        @type single_line: bool

        """
        elm_entry_single_line_set(self.obj, single_line)

    def single_line_get(self):
        """Gets whether the entry is set to be single line.

        @see: L{single_line_set()}

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

        """
        return bool(elm_entry_single_line_get(self.obj))

    property single_line:
        """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 C{single_line} is C{False}, line wrapping takes effect again
        and pressing enter will break the text into a different line
        without generating any events.

        @type: bool

        """
        def __get__(self):
            return bool(elm_entry_single_line_get(self.obj))

        def __set__(self, single_line):
            elm_entry_single_line_set(self.obj, single_line)

    def password_set(self, password):
        """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 (*).

        @param password: If true, password mode is enabled.
        @type password: bool

        """
        elm_entry_password_set(self.obj, password)

    def password_get(self):
        """Gets whether the entry is set to password mode.

        @see: L{password_set()}

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

        """
        return bool(elm_entry_password_get(self.obj))

    property password:
        """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 (*).

        @type: bool

        """
        def __get__(self):
            return bool(elm_entry_password_get(self.obj))

        def __set__(self, password):
            elm_entry_password_set(self.obj, password)

    def entry_set(self, entry):
        """This sets the text displayed within the entry to C{entry}.

        @note: Using this function bypasses text filters

        @param entry: The text to be displayed
        @type entry: string

        """
        elm_entry_entry_set(self.obj, _cfruni(entry))

    def entry_get(self):
        """This returns the text currently shown in object C{entry}.

        @see: L{entry_set()}.

        @return: The currently displayed text or None on failure
        @rtype: string

        """
        return _ctouni(elm_entry_entry_get(self.obj))

    property entry:
        """The text displayed within the entry to C{entry}.

        @note: Setting this bypasses text filters

        @type: string

        """
        def __get__(self):
            return _ctouni(elm_entry_entry_get(self.obj))

        def __set__(self, entry):
            elm_entry_entry_set(self.obj, _cfruni(entry))

    def entry_append(self, text):
        """Appends C{entry} to the text of the entry.

        Adds the text in C{entry} to the end of any text already present in the
        widget.

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

        @see: L{markup_filter_append()}

        @param entry: The text to be displayed
        @type entry: string

        """
        elm_entry_entry_append(self.obj, _cfruni(text))

    def is_empty(self):
        """Gets 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 False.

        @return: True if the entry is empty, False otherwise.
        @rtype: bool

        """
        return elm_entry_is_empty(self.obj)

    def selection_get(self):
        """Gets 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. None 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 C{entry} object is deleted or its
        contents are changed, the returned pointer should be considered invalid.

        @return: The selected text within the entry or None on failure
        @rtype: string

        """
        return _ctouni(elm_entry_selection_get(self.obj))

    property selection:
        """Gets 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. None 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 C{entry} object is deleted or its
        contents are changed, the returned pointer should be considered invalid.

        @type: string

        """
        def __get__(self):
            return _ctouni(elm_entry_selection_get(self.obj))

    def textblock_get(self):
        """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 L{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.
        @rtype: Evas_Object

        """
        cdef Evas_Object *o
        o = elm_entry_textblock_get(self.obj)
        return Object_from_instance(o)

    property textblock:
        """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 L{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.

        @type: Evas_Object

        """
        def __get__(self):
            cdef Evas_Object *o
            o = elm_entry_textblock_get(self.obj)
            return Object_from_instance(o)

    def calc_force(self):
        """Forces calculation of the entry size and text layouting.

        This should be used after modifying the textblock object directly.

        @see: L{textblock_get()}

        """
        elm_entry_calc_force(self.obj)

    def entry_insert(self, entry):
        """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: L{markup_filter_append()}

        @param entry: The text to insert
        @type entry: string

        """
        elm_entry_entry_insert(self.obj, _cfruni(entry))

    def line_wrap_set(self, wrap):
        """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.

        @param wrap: The wrap mode to use. See Elm_Wrap_Type for details on them
        @type wrap: Elm_Wrap_Type

        """
        elm_entry_line_wrap_set(self.obj, wrap)

    def line_wrap_get(self):
        """Gets the wrap mode the entry was set to use.

        @see: L{line_wrap_set()}

        @return: Wrap type
        @rtype: Elm_Wrap_Type

        """
        return elm_entry_line_wrap_get(self.obj)

    property line_wrap:
        """The line wrap type to use on multi-line entries.

        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.

        @type: Elm_Wrap_Type

        """
        def __get__(self):
            return elm_entry_line_wrap_get(self.obj)

        def __set__(self, wrap):
            elm_entry_line_wrap_set(self.obj, wrap)

    def editable_set(self, editable):
        """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 C{editable} as 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
        L{Object.text_set()}, L{entry_insert()} and other related
        functions.

        @param editable: If True, user input will be inserted in the entry,
            if not, the entry is read-only and no user input is allowed.
        @type editable: bool

        """
        elm_entry_editable_set(self.obj, editable)

    def editable_get(self):
        """Gets whether the entry is editable or not.

        @see: L{editable_set()}

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

        """
        return bool(elm_entry_editable_get(self.obj))

    property editable:
        """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. Setting this as
        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
        L{Object.text_set()}, L{entry_insert()} and other related
        functions and properties.

        @type: bool

        """
        def __get__(self):
            return bool(elm_entry_editable_get(self.obj))

        def __set__(self, editable):
            elm_entry_editable_set(self.obj, editable)

    def select_none(self):
        """This drops any existing text selection within the entry."""
        elm_entry_select_none(self.obj)

    def select_all(self):
        """This selects all text within the entry."""
        elm_entry_select_all(self.obj)

    def cursor_next(self):
        """This moves the cursor one place to the right within the entry.

        @return: True upon success, False upon failure
        @rtype: bool

        """
        return bool(elm_entry_cursor_next(self.obj))

    def cursor_prev(self):
        """This moves the cursor one place to the left within the entry.

        @return: True upon success, False upon failure
        @rtype: bool

        """
        return bool(elm_entry_cursor_prev(self.obj))

    def cursor_up(self):
        """This moves the cursor one line up within the entry.

        @return: True upon success, False upon failure
        @rtype: bool

        """
        return bool(elm_entry_cursor_up(self.obj))

    def cursor_down(self):
        """This moves the cursor one line down within the entry.

        @return: True upon success, False upon failure
        @rtype: bool

        """
        return bool(elm_entry_cursor_down(self.obj))

    def cursor_begin_set(self):
        """This moves the cursor to the beginning of the entry."""
        elm_entry_cursor_begin_set(self.obj)

    def cursor_end_set(self):
        """This moves the cursor to the end of the entry."""
        elm_entry_cursor_end_set(self.obj)

    def cursor_line_begin_set(self):
        """This moves the cursor to the beginning of the current line."""
        elm_entry_cursor_line_begin_set(self.obj)

    def cursor_line_end_set(self):
        """This moves the cursor to the end of the current line."""
        elm_entry_cursor_line_end_set(self.obj)

    def cursor_selection_begin(self):
        """This begins a selection within the entry as though the user were
        holding down the mouse button to make a selection."""
        elm_entry_cursor_selection_begin(self.obj)

    def cursor_selection_end(self):
        """This ends a selection within the entry as though the user had
        just released the mouse button while making a selection."""
        elm_entry_cursor_selection_end(self.obj)

    def cursor_is_format_get(self):
        """Gets 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.

        @see: L{cursor_is_visible_format_get()}

        @return: True if the current cursor position contains a format node,
            False otherwise.
        @rtype: bool

        """
        return bool(elm_entry_cursor_is_format_get(self.obj))

    def cursor_is_visible_format_get(self):
        """Gets if the current cursor position holds a visible format node.

        @see: L{cursor_is_format_get()}

        @return: True if the current cursor is a visible format, False
            if it's an invisible one or no format exists.
        @rtype: bool

        """
        return bool(elm_entry_cursor_is_visible_format_get(self.obj))

    def cursor_content_get(self):
        """Gets 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.
        @rtype: string

        """
        return elm_entry_cursor_content_get(self.obj)

    def cursor_geometry_get(self):
        """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: Geometry (x, y, w, h)
        @rtype: tuple of Evas_Coords (int)

        """
        cdef Evas_Coord x, y, w, h
        #TODO: Check return status for success
        elm_entry_cursor_geometry_get(self.obj, &x, &y, &w, &h)
        return (x, y, w, h)

    def cursor_pos_set(self, pos):
        """Sets the cursor position in the entry to the given value

        The value in C{pos} is the index of the character position within the
        contents of the string as returned by L{cursor_pos_get()}.

        @param pos: The position of the cursor
        @type pos: int

        """
        elm_entry_cursor_pos_set(self.obj, pos)

    def cursor_pos_get(self):
        """Retrieves the current position of the cursor in the entry

        @return: The cursor position
        @rtype: int

        """
        return elm_entry_cursor_pos_get(self.obj)

    property cursor_pos:
        """The cursor position in the entry

        The value is the index of the character position within the
        contents of the string.

        @type: int

        """
        def __get__(self):
            return elm_entry_cursor_pos_get(self.obj)

        def __set__(self, pos):
            elm_entry_cursor_pos_set(self.obj, pos)

    def selection_cut(self):
        """This executes a "cut" action on the selected text in the entry."""
        elm_entry_selection_cut(self.obj)

    def selection_copy(self):
        """This executes a "copy" action on the selected text in the entry."""
        elm_entry_selection_copy(self.obj)

    def selection_paste(self):
        """This executes a "paste" action in the entry."""
        elm_entry_selection_paste(self.obj)

    def context_menu_clear(self):
        """This clears and frees the items in a entry's contextual (longpress) menu.

        @see: L{context_menu_item_add()}

        """
        elm_entry_context_menu_clear(self.obj)

    # TODO XXX
    # def context_menu_item_add(self, label, icon_file, icon_type, cb, data):
        """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 L{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.

        @param label: The item's text label
        @type label: string
        @param icon_file: The item's icon file
        @type icon_file: string
        @param icon_type: The item's icon type
        @type icon_type: string
        @param func: The callback to execute when the item is clicked
        @type func: function

        """
        #elm_entry_context_menu_item_add(self.obj, label, icon_file, icon_type, func, data);

    def context_menu_disabled_set(self, disabled):
        """This disables the entry's contextual (longpress) menu.

        @param disabled: If true, the menu is disabled
        @type disabled: bool

        """
        elm_entry_context_menu_disabled_set(self.obj, disabled)

    def context_menu_disabled_get(self):
        """This returns whether the entry's contextual (longpress) menu is
        disabled.

        @return: If true, the menu is disabled
        @rtype: bool

        """
        return elm_entry_context_menu_disabled_get(self.obj)

    property context_menu_disabled:
        """This disables the entry's contextual (longpress) menu.

        @type: bool

        """
        def __get__(self):
            return elm_entry_context_menu_disabled_get(self.obj)

        def __set__(self, disabled):
            elm_entry_context_menu_disabled_set(self.obj, disabled)


    # elm_entry_item_provider_append() # TODO XXX

    # elm_entry_item_provider_prepend() # TODO XXX

    # elm_entry_item_provider_remove() # TODO XXX

    # elm_entry_markup_filter_append() # TODO XXX

    # elm_entry_markup_filter_prepend() # TODO XXX

    # elm_entry_markup_filter_remove() # TODO XXX

    markup_to_utf8 = staticmethod(Entry_markup_to_utf8)

    utf8_to_markup = staticmethod(Entry_utf8_to_markup)

    def file_set(self, file, format):
        """This sets the file (and implicitly loads it) for the text to display and
        then edit.

        All changes are written back to the file after a short delay if
        the entry object is set to autosave (which is the default).

        If the entry had any other file set previously, any changes made to it
        will be saved if the autosave feature is enabled, otherwise, the file
        will be silently discarded and any non-saved changes will be lost.

        @param file: The path to the file to load and save
        @type file: string
        @param format: The file format
        @type format: Elm_Text_Format
        @return: C{True} on success, C{False} otherwise

        """
        return bool(elm_entry_file_set(self.obj, _cfruni(file), format))

    def file_get(self):
        """Gets the file being edited by the entry.

        This function can be used to retrieve any file set on the entry for
        edition, along with the format used to load and save it.

        @return: Tuple of file and format
        @rtype: tuple of strings

        """
        cdef const_char_ptr file
        cdef Elm_Text_Format format

        elm_entry_file_get(self.obj, &file, &format)
        return (_ctouni(file), format)

    property file:
        """The file for the text to display and then edit.

        All changes are written back to the file after a short delay if
        the entry object is set to autosave (which is the default).

        If the entry had any other file set previously, any changes made to it
        will be saved if the autosave feature is enabled, otherwise, the file
        will be silently discarded and any non-saved changes will be lost.

        @type: tuple of strings (file, format)

        """
        def __get__(self):
            cdef const_char_ptr file
            cdef Elm_Text_Format format
            elm_entry_file_get(self.obj, &file, &format)
            return (_ctouni(file), format)

        def __set__(self, value):
            file, format = value
            elm_entry_file_set(self.obj, _cfruni(file), format)

    def file_save(self):
        """This function writes any changes made to the file set with
        L{file_set()}.

        """
        elm_entry_file_save(self.obj)

    def autosave_set(self, autosave):
        """This sets the entry object to 'autosave' the loaded text file or not.

        @see: L{file_set()}

        @param autosave: Autosave the loaded file or not
        @type autosave: bool

        """
        elm_entry_autosave_set(self.obj, autosave)

    def autosave_get(self):
        """This gets the entry object's 'autosave' status.

        @see: L{file_set()}

        @return: Autosave the loaded file or not
        @rtype: bool

        """
        return elm_entry_autosave_get(self.obj)

    property autosave:
        """Whether the entry object 'autosaves' the loaded text file or not.

        @type: bool

        """
        def __get__(self):
            return elm_entry_autosave_get(self.obj)

        def __set__(self, autosave):
            elm_entry_autosave_set(self.obj, autosave)

    def scrollable_set(self, scrollable):
        """Enable or disable scrolling in entry

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

        @param scroll: True if it is to be scrollable, False otherwise
        @type scroll: bool

        """
        elm_entry_scrollable_set(self.obj, scrollable)

    def scrollable_get(self):
        """Get the scrollable state of the entry

        Normally the entry is not scrollable. This gets the scrollable state
        of the entry.

        @see: L{scrollable_set()} for more information.

        @return: The scrollable state
        @rtype: bool

        """
        return bool(elm_entry_scrollable_get(self.obj))

    property scrollable:
        """Enable or disable scrolling in entry

        Normally the entry is not scrollable.

        @type: bool

        """
        def __get__(self):
            return bool(elm_entry_scrollable_get(self.obj))

        def __set__(self, scrollable):
            elm_entry_scrollable_set(self.obj, scrollable)

    def icon_visible_set(self, visible):
        """Sets the visibility of the end widget of the entry, set by
        C{Object.part_content_set("end", content)}.

        @param setting: True if the object should be displayed, False if not.
        @type setting: bool

        """
        elm_entry_icon_visible_set(self.obj, visible)

    property icon_visible:
        """Sets the visibility of the end widget of the entry, set by
        C{Object.part_content_set("end", content)}.

        @type: bool

        """
        def __set__(self, visible):
            elm_entry_icon_visible_set(self.obj, visible)

    def scrollbar_policy_set(self, Elm_Scroller_Policy h, Elm_Scroller_Policy v):
        """This sets the entry's scrollbar policy (i.e. enabling/disabling
        them).

        Setting an entry to single-line mode with L{single_line_set()}
        will automatically disable the display of scrollbars when the entry
        moves inside its scroller.

        @param h: The horizontal scrollbar policy to apply
        @type h: Elm_Scroller_Policy
        @param v: The vertical scrollbar policy to apply
        @type v: Elm_Scroller_Policy

        """
        elm_scroller_policy_set(self.obj, h, v)

    property scrollbar_policy:
        """This sets the entry's scrollbar policy (i.e. enabling/disabling
        them).

        Setting an entry to single-line mode with L{single_line_set()}
        will automatically disable the display of scrollbars when the entry
        moves inside its scroller.

        @type: tuple of Elm_Scroller_Policy (h, v)

        """
        def __set__(self, value):
            cdef Elm_Scroller_Policy h, v
            h, v = value
            elm_scroller_policy_set(self.obj, h, v)

    def bounce_set(self, h_bounce, v_bounce):
        """This enables/disables bouncing within the entry.

        This function sets whether the entry will bounce when scrolling reaches
        the end of the contained entry.

        @param h_bounce: The horizontal bounce state
        @type h_bounce: bool
        @param v_bounce: The vertical bounce state
        @type v_bounce: bool

        """
        elm_scroller_bounce_set(self.obj, h_bounce, v_bounce)

    def bounce_get(self):
        """Get the bounce mode

        @return: Tuple with bounce modes for horizontal and vertical
        @rtype: tuple of bools

        """
        cdef Eina_Bool h_bounce, v_bounce

        elm_scroller_bounce_get(self.obj, &h_bounce, &v_bounce)
        return (h_bounce, v_bounce)

    property bounce:
        """Whether the entry will bounce when scrolling reaches
        the end of the contained entry.

        @type: tuple of bools (h_bounce, v_bounce)

        """
        def __get__(self):
            cdef Eina_Bool h_bounce, v_bounce
            elm_scroller_bounce_get(self.obj, &h_bounce, &v_bounce)
            return (h_bounce, v_bounce)

        def __set__(self, value):
            cdef Eina_Bool h_bounce, v_bounce
            h_bounce, v_bounce = value
            elm_scroller_bounce_set(self.obj, h_bounce, v_bounce)

    def input_panel_layout_set(self, layout):
        """Set the input panel layout of the entry

        @param layout: layout type
        @type layout: Elm_Input_Panel_Layout

        """
        elm_entry_input_panel_layout_set(self.obj, layout)

    def input_panel_layout_get(self):
        """Get the input panel layout of the entry

        @see: L{input_panel_layout_set()}

        @return: layout type
        @rtype: Elm_Input_Panel_Layout

        """
        return elm_entry_input_panel_layout_get(self.obj)

    property input_panel_layout:
        """The input panel layout of the entry

        @type: Elm_Input_Panel_Layout

        """
        def __get__(self):
            return elm_entry_input_panel_layout_get(self.obj)

        def __set__(self, layout):
            elm_entry_input_panel_layout_set(self.obj, layout)

    def input_panel_enabled_set(self, enabled):
        """Sets the attribute to show the input panel automatically.

        @param enabled: If true, the input panel is appeared when entry is
            clicked or has a focus
        @type enabled: bool

        """
        elm_entry_input_panel_enabled_set(self.obj, enabled)

    def input_panel_enabled_get(self):
        """Retrieve the attribute to show the input panel automatically.

        @return: True if input panel will be appeared when the entry is clicked
            or has a focus, False otherwise
        @rtype: bool

        """
        return bool(elm_entry_input_panel_enabled_get(self.obj))

    property input_panel_enabled:
        """Whether to show the input panel automatically or not.

        @type: bool

        """
        def __get__(self):
            return bool(elm_entry_input_panel_enabled_get(self.obj))

        def __set__(self, enabled):
            elm_entry_input_panel_enabled_set(self.obj, enabled)

    def input_panel_show(self):
        """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
        C{Entry.input_panel_enabled = False}.

        """
        elm_entry_input_panel_show(self.obj)

    def input_panel_hide(self):
        """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
        C{Entry.input_panel_enabled_set = False}.

        """
        elm_entry_input_panel_hide(self.obj)

    def input_panel_language_set(self, lang):
        """Set the language mode of the input panel.

        This API can be used if you want to show the alphabet keyboard mode.

        @param lang: language to be set to the input panel.
        @type lang: Elm_Input_Panel_Lang

        """
        elm_entry_input_panel_language_set(self.obj, lang)

    def input_panel_language_get(self):
        """Get the language mode of the input panel.

        @see: L{input_panel_language_set()} for more details.

        @return: input panel language type
        @rtype: Elm_Input_Panel_Lang

        """
        return elm_entry_input_panel_language_get(self.obj)

    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.

        @type: Elm_Input_Panel_Lang

        """
        def __get__(self):
            return elm_entry_input_panel_language_get(self.obj)

        def __set__(self, lang):
            elm_entry_input_panel_language_set(self.obj, lang)

    # TODO XXX elm_entry_input_panel_imdata_set() ??

    # TODO XXX elm_entry_input_panel_imdata_get() ??

    def input_panel_return_key_type_set(self, 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

        @param return_key_type: The type of "return" key on the input panel
        @type return_key_type: Elm_Input_Panel_Return_Key_Type

        """
        elm_entry_input_panel_return_key_type_set(self.obj, return_key_type)

    def input_panel_return_key_type_get(self):
        """Get the "return" key type.

        @see: L{input_panel_return_key_type_set()} for more details

        @return: The type of "return" key on the input panel
        @rtype: Elm_Input_Panel_Return_Key_Type

        """
        return elm_entry_input_panel_return_key_type_get(self.obj)

    property input_panel_return_key_type:
        """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

        @type: Elm_Input_Panel_Return_Key_Type

        """
        def __get__(self):
            return elm_entry_input_panel_return_key_type_get(self.obj)

        def __set__(self, return_key_type):
            elm_entry_input_panel_return_key_type_set(self.obj, return_key_type)

    def input_panel_return_key_disabled_set(self, disabled):
        """Set the return key on the input panel to be disabled.

        @param disabled: The state to put in in: C{True} for
            disabled, C{False} for enabled
        @type disabled: bool

        """
        elm_entry_input_panel_return_key_disabled_set(self.obj, disabled)

    def input_panel_return_key_disabled_get(self):
        """Get whether the return key on the input panel should be disabled or not.

        @return: True if it should be disabled
        @rtype: bool

        """
        return elm_entry_input_panel_return_key_disabled_get(self.obj)

    property input_panel_return_key_disabled:
        """Whether the return key on the input panel is disabled or not.

        @type: bool

        """
        def __get__(self):
            return elm_entry_input_panel_return_key_disabled_get(self.obj)

        def __set__(self, disabled):
            elm_entry_input_panel_return_key_disabled_set(self.obj, disabled)

    def input_panel_return_key_autoenabled_set(self, enabled):
        """Set whether the return key on the input panel is disabled automatically when entry has no text.

        If C{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.

        @param enabled: If True, the return key is automatically disabled when
            the entry has no text.
        @type enabled: bool

        """
        elm_entry_input_panel_return_key_autoenabled_set(self.obj, enabled)

    property input_panel_return_key_autoenabled:
        """Set whether the return key on the input panel is disabled automatically when entry has no text.

        If C{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.

        @type: bool

        """
        def __set__(self, enabled):
            elm_entry_input_panel_return_key_autoenabled_set(self.obj, enabled)

    def imf_context_reset(self):
        """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.

        """
        elm_entry_imf_context_reset(self.obj)

    def prediction_allow_set(self, allow):
        """Set whether the entry should allow to use the text prediction.

        @param prediction: Whether the entry should allow to use the text prediction.
        @type prediction: bool

        """
        elm_entry_prediction_allow_set(self.obj, allow)

    def prediction_allow_get(self):
        """Get whether the entry should allow to use the text prediction.

        @return: True if it allows to use the text prediction, otherwise False.
        @rtype: bool

        """
        return elm_entry_prediction_allow_get(self.obj)

    property prediction_allow:
        """Whether the entry should allow to use the text prediction.

        @type: bool

        """
        def __get__(self):
            return elm_entry_prediction_allow_get(self.obj)

        def __set__(self, allow):
            elm_entry_prediction_allow_set(self.obj, allow)

    # TODO XXX elm_entry_filter_accept_set()
    # TODO XXX elm_entry_imf_context_get() ??

    def cnp_mode_set(self, mode):
        """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 C{ELM_CNP_MODE_NO_IMAGE}, this prevents images from being copy or past.
        By setting cnp_mode to be C{ELM_CNP_MODE_PLAINTEXT}, this remove all tags in text .

        @note: this only changes the behaviour of text.

        @param cnp_mode: One of: ELM_CNP_MODE_MARKUP, ELM_CNP_MODE_NO_IMAGE, ELM_CNP_MODE_PLAINTEXT.
        @type cnp_mode: Elm_Cnp_Mode

        """
        elm_entry_cnp_mode_set(self.obj, mode)

    def cnp_mode_get(self):
        """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: One of: ELM_CNP_MODE_MARKUP, ELM_CNP_MODE_NO_IMAGE, ELM_CNP_MODE_PLAINTEXT.
        @rtype: Elm_Cnp_Mode

        """
        return elm_entry_cnp_mode_get(self.obj)

    property cnp_mode:
        """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 C{ELM_CNP_MODE_NO_IMAGE}, this prevents images from being copy or past.
        By setting cnp_mode to be C{ELM_CNP_MODE_PLAINTEXT}, this remove all tags in text .

        @note: this only changes the behaviour of text.

        @type: Elm_Cnp_Mode

        """
        def __get__(self):
            return elm_entry_cnp_mode_get(self.obj)

        def __set__(self, mode):
            elm_entry_cnp_mode_set(self.obj, mode)

    def anchor_hover_parent_set(self, evasObject anchor_hover_parent):
        """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 L{Hover} for more details on this.

        @param parent: The object to use as parent for the hover
        @type parent: L{Object}

        """
        elm_entry_anchor_hover_parent_set(self.obj, anchor_hover_parent.obj)

    def anchor_hover_parent_get(self):
        """Get the parent of the hover popup

        Get the object used as parent for the hover created by the entry
        widget. See L{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, None if none is set.
        @rtype: L{Object}

        """
        cdef Evas_Object *anchor_hover_parent
        anchor_hover_parent = elm_entry_anchor_hover_parent_get(self.obj)
        return Object_from_instance(anchor_hover_parent)

    property anchor_hover_parent:
        """Parent of the hover popup

        The parent object to use by the hover created by the entry
        when an anchor is clicked. See L{Hover} for more details on this.

        @type: L{Object}

        """
        def __get__(self):
            cdef Evas_Object *anchor_hover_parent
            anchor_hover_parent = elm_entry_anchor_hover_parent_get(self.obj)
            return Object_from_instance(anchor_hover_parent)

        def __set__(self, evasObject anchor_hover_parent):
            elm_entry_anchor_hover_parent_set(self.obj, anchor_hover_parent.obj)

    def anchor_hover_style_set(self, style):
        """Set the style that the hover should use

        When creating the popup hover, entry will request that it's
        themed according to C{style}.

        Setting style to C{None} means disabling automatic hover.

        @see: L{Object.style_set()}

        @param style: The style to use for the underlying hover
        @type style: string

        """
        elm_entry_anchor_hover_style_set(self.obj, _cfruni(style))

    def anchor_hover_style_get(self):
        """Get the style that the hover created by entry will use.

        @return: The style to use by the hover. C{None} means the default is used.

        @see: L{Object.style_set()}

        """
        return _ctouni(elm_entry_anchor_hover_style_get(self.obj))

    property anchor_hover_style:
        """The style that the hover should use

        When creating the popup hover, entry will request that it's
        themed according to C{style}.

        Setting style to C{None} means disabling automatic hover.

        @see: L{Object.style_set()}

        @type: string

        """
        def __get__(self):
            return _ctouni(elm_entry_anchor_hover_style_get(self.obj))

        def __set__(self, style):
            elm_entry_anchor_hover_style_set(self.obj, _cfruni(style))

    def anchor_hover_end(self):
        """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.

        """
        elm_entry_anchor_hover_end(self.obj)

    def callback_changed_add(self, func, *args, **kwargs):
        """The text within the entry was changed."""
        self._callback_add("changed", func, *args, **kwargs)

    def callback_changed_del(self, func):
        self._callback_del("changed", func)

    def callback_changed_user_add(self, func, *args, **kwargs):
        """The text within the entry was changed because of user interaction."""
        self._callback_add("changed,user", func, *args, **kwargs)

    def callback_changed_user_del(self, func):
        self._callback_del("changed,user", func)

    def callback_activated_add(self, func, *args, **kwargs):
        """The enter key was pressed on a single line entry."""
        self._callback_add("activated", func, *args, **kwargs)

    def callback_activated_del(self, func):
        self._callback_del("activated", func)

    def callback_press_add(self, func, *args, **kwargs):
        """A mouse button has been pressed on the entry."""
        self._callback_add("press", func, *args, **kwargs)

    def callback_press_del(self, func):
        self._callback_del("press", func)

    def callback_longpressed_add(self, func, *args, **kwargs):
        """A mouse button has been pressed and held for a couple seconds."""
        self._callback_add("longpressed", func, *args, **kwargs)

    def callback_longpressed_del(self, func):
        self._callback_del("longpressed", func)

    def callback_clicked_add(self, func, *args, **kwargs):
        """The entry has been clicked (mouse press and release)."""
        self._callback_add("clicked", func, *args, **kwargs)

    def callback_clicked_del(self, func):
        self._callback_del("clicked", func)

    def callback_double_clicked_add(self, func, *args, **kwargs):
        """The entry has been double clicked."""
        self._callback_add("clicked,double", func, *args, **kwargs)

    def callback_double_clicked_del(self, func):
        self._callback_del("clicked,double", func)

    def callback_triple_clicked_add(self, func, *args, **kwargs):
        """The entry has been triple clicked."""
        self._callback_add("clicked,triple", func, *args, **kwargs)

    def callback_triple_clicked_del(self, func):
        self._callback_del("clicked,triple", func)

    def callback_focused_add(self, func, *args, **kwargs):
        """The entry has received focus."""
        self._callback_add("focused", func, *args, **kwargs)

    def callback_focused_del(self, func):
        self._callback_del("focused", func)

    def callback_unfocused_add(self, func, *args, **kwargs):
        """The entry has lost focus."""
        self._callback_add("unfocused", func, *args, **kwargs)

    def callback_unfocused_del(self, func):
        self._callback_del("unfocused", func)

    def callback_selection_paste_add(self, func, *args, **kwargs):
        """A paste of the clipboard contents was requested."""
        self._callback_add("selection,paste", func, *args, **kwargs)

    def callback_selection_paste_del(self, func):
        self._callback_del("selection,paste", func)

    def callback_selection_copy_add(self, func, *args, **kwargs):
        """A copy of the selected text into the clipboard was requested."""
        self._callback_add("selection,copy", func, *args, **kwargs)

    def callback_selection_copy_del(self, func):
        self._callback_del("selection,copy", func)

    def callback_selection_cut_add(self, func, *args, **kwargs):
        """A cut of the selected text into the clipboard was requested."""
        self._callback_add("selection,cut", func, *args, **kwargs)

    def callback_selection_cut_del(self, func):
        self._callback_del("selection,cut", func)

    def callback_selection_start_add(self, func, *args, **kwargs):
        """A selection has begun and no previous selection existed."""
        self._callback_add("selection,start", func, *args, **kwargs)

    def callback_selection_start_del(self, func):
        self._callback_del("selection,start", func)

    def callback_selection_changed_add(self, func, *args, **kwargs):
        """The current selection has changed."""
        self._callback_add("selection,changed", func, *args, **kwargs)

    def callback_selection_changed_del(self, func):
        self._callback_del("selection,changed", func)

    def callback_selection_cleared_add(self, func, *args, **kwargs):
        """The current selection has been cleared."""
        self._callback_add("selection,cleared", func, *args, **kwargs)

    def callback_selection_cleared_del(self, func):
        self._callback_del("selection,cleared", func)

    def callback_cursor_changed_add(self, func, *args, **kwargs):
        """The cursor has changed position."""
        self._callback_add("cursor,changed", func, *args, **kwargs)

    def callback_cursor_changed_del(self, func):
        self._callback_del("cursor,changed", func)

    def callback_anchor_clicked_add(self, func, *args, **kwargs):
        """An anchor has been clicked. The event_info
        parameter for the callback will be an C{Elm_Entry_Anchor_Info}.

        """
        self._callback_add_full("anchor,clicked", _entryanchor_conv,
                                func, *args, **kwargs)

    def callback_anchor_clicked_del(self, func):
        self._callback_del_full("anchor,clicked", _entryanchor_conv,
                                func)

    def callback_anchor_in_add(self, func, *args, **kwargs):
        """Mouse cursor has moved into an anchor. The event_info
        parameter for the callback will be an C{Elm_Entry_Anchor_Info}.

        """
        self._callback_add_full("anchor,in", _entryanchor_conv,
                                func, *args, **kwargs)

    def callback_anchor_in_del(self, func):
        self._callback_del_full("anchor,in", _entryanchor_conv,
                                func)

    def callback_anchor_out_add(self, func, *args, **kwargs):
        """Mouse cursor has moved out of an anchor. The event_info
        parameter for the callback will be an C{Elm_Entry_Anchor_Info}.

        """
        self._callback_add_full("anchor,out", _entryanchor_conv,
                                func, *args, **kwargs)

    def callback_anchor_out_del(self, func):
        self._callback_del_full("anchor,out", _entryanchor_conv,
                                func)

    def callback_anchor_up_add(self, func, *args, **kwargs):
        """Mouse button has been unpressed on an anchor. The event_info
        parameter for the callback will be an C{Elm_Entry_Anchor_Info}.

        """
        self._callback_add_full("anchor,up", _entryanchor_conv,
                                func, *args, **kwargs)

    def callback_anchor_up_del(self, func):
        self._callback_del_full("anchor,up", _entryanchor_conv,
                                func)

    def callback_anchor_down_add(self, func, *args, **kwargs):
        """Mouse button has been pressed on an anchor. The event_info
        parameter for the callback will be an C{Elm_Entry_Anchor_Info}.

        """
        self._callback_add_full("anchor,down", _entryanchor_conv,
                                func, *args, **kwargs)

    def callback_anchor_down_del(self, func):
        self._callback_del_full("anchor,down", _entryanchor_conv,
                                func)

    def callback_anchor_hover_opened_add(self, func, *args, **kwargs):
        self._callback_add_full("anchor,hover,opened", _entryanchorhover_conv,
                                func, *args, **kwargs)

    def callback_anchor_hover_opened_del(self, func):
        self._callback_del_full("anchor,hover,opened", _entryanchorhover_conv,
                                func)

    def callback_preedit_changed_add(self, func, *args, **kwargs):
        """The preedit string has changed."""
        self._callback_add("preedit,changed", func, *args, **kwargs)

    def callback_preedit_changed_del(self, func):
        self._callback_del("preedit,changed", func)

    def callback_language_changed_add(self, func, *args, **kwargs):
        """Program language changed."""
        self._callback_add("language,changed", func, *args, **kwargs)

    def callback_language_changed_del(self, func):
        self._callback_del("language,changed", func)

_elm_widget_type_register("entry", Entry)

cdef extern from "Elementary.h": # hack to force type to be known
    cdef PyTypeObject PyElementaryEntry_Type # hack to install metaclass
_install_metaclass(&PyElementaryEntry_Type, ElementaryObjectMeta)