summaryrefslogtreecommitdiff
path: root/src/lib/edje/edje_object.eo
blob: 2653d72f651c6c4a0bbe78c3ea0f2623ae290f1f (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
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
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
class Edje.Object (Evas.Smart_Clipped, Efl.File)
{
   legacy_prefix: edje_object;
   eo_prefix: edje_obj;
   data: Edje;
   properties {
      update_hints {
         set {
            /*@
            @brief Edje will automatically update the size hints on itself.

            By default edje doesn't set size hints on itself. With this function
            call, it will do so if update is true. Be carefully, it cost a lot to
            trigger this feature as it will recalc the object every time it make
            sense to be sure that's its minimal size hint is always accurate. */
         }
         get {
            /*@
            @brief Whether or not Edje will update size hints on itself.

            @return @c true if does, @c false if it doesn't. */
         }
         values {
            bool update; /*@ Whether or not update the size hints. */
         }
      }
      mirrored {
         set {
            /*@
            @brief Set the RTL orientation for this object.

            @since 1.1.0 */
         }
         get {
            /*@
            @brief Get the RTL orientation for this object.

            You can RTL orientation explicitly with edje_object_mirrored_set.

            @return @c EINA_TRUE if the flag is set or @c EINA_FALSE if not.
            @since 1.1.0 */
         }
         values {
            bool rtl; /*@ new value of flag EINA_TRUE/EINA_FALSE */
         }
      }
      animation {
         set {
            /*@
            @brief Set the object's animation state.

            This function starts or stops an Edje object's animation. The
            information if it's stopped can be retrieved by
            edje_object_animation_get().

            @see edje_object_animation_get() */
         }
         get {
            /*@
            @brief Get the Edje object's animation state.

            @return @c EINA_FALSE on error or if object is not animated;
            @c EINA_TRUE if animated.

            This function returns if the animation is stopped or not. The
            animation state is set by edje_object_animation_set().

            @see edje_object_animation_set(). */
         }
         values {
            bool on; /*@ The animation state. @c EINA_TRUE to starts or
            @c EINA_FALSE to stops. */
         }
      }
      play {
         set {
            /*@
            @brief Set the Edje object to playing or paused states.

            This function sets the Edje object @a obj to playing or paused
            states, depending on the parameter @a play. This has no effect if
            the object was already at that state.

            @see edje_object_play_get(). */
         }
         get {
            /*@
            @brief Get the Edje object's state.

            @return @c EINA_FALSE if the object is not connected, its @c delete_me flag
            is set, or it is at paused state; @c EINA_TRUE if the object is at playing
            state.

            This function tells if an Edje object is playing or not. This state
            is set by edje_object_play_set().

            @see edje_object_play_set(). */
         }
         values {
            bool play; /*@ Object state (@c EINA_TRUE to playing,
            @c EINA_FALSE to paused). */
         }
      }
      perspective {
         set {
            /*@
            Set the given perspective object on this Edje object.

            Make the given perspective object be the default perspective for this Edje
            object.

            There can be only one perspective object per Edje object, and if a
            previous one was set, it will be removed and the new perspective object
            will be used.

            An Edje perspective will only affect a part if it doesn't point to another
            part to be used as perspective.

            @see edje_object_perspective_new()
            @see edje_object_perspective_get()
            @see edje_perspective_set() */
         }
         get {
            /*@
            Get the current perspective used on this Edje object.

            @return The perspective object being used on this Edje object. Or @c NULL
            if there was none, and on errors.

            @see edje_object_perspective_set() */
         }
         values {
            Edje_Perspective *ps @const_get; /*@ The perspective object that will be used. */
         }
      }
      scale {
         set {
            /*@
            @brief Set the scaling factor for a given Edje object.

            This function sets an @b individual scaling factor on the @a obj
            Edje object. This property (or Edje's global scaling factor, when
            applicable), will affect this object's part sizes. If @p scale is
            not zero, than the individual scaling will @b override any global
            scaling set, for the object @p obj's parts. Put it back to zero to
            get the effects of the global scaling again.

            @warning Only parts which, at EDC level, had the @c "scale"
            property set to @c 1, will be affected by this function. Check the
            complete @ref edcref "syntax reference" for EDC files.

            @see edje_object_scale_get()
            @see edje_scale_get() for more details */
            return: bool;
         }
         get {
            /*@
            @brief Get a given Edje object's scaling factor.

            This function returns the @c individual scaling factor set on the
            @a obj Edje object.

            @see edje_object_scale_set() for more details */
         }
         values {
            double scale; /*@ The scaling factor (the default value is @c 0.0,
            meaning individual scaling @b not set) */
         }
      }
      base_scale {
         get {
            /*@
            @brief Get a given Edje object's base_scale factor.

            This function returns the base_scale factor set on the
            @a obj Edje object.
            The base_scale can be set in the collection of edc.
            If it isn't set, the default value is 1.0 */
         }
         values {
            double base_scale; /* The base_scale factor (the default value is @ 1.0,
            that means the edc file is made based on scale 1.0. */
         }
      }
      text_change_cb {
         set {
            /*@
            @brief Set the object text callback.

            This function sets the callback to be called when the text changes. */
         }
         values {
            Edje_Text_Change_Cb func; /*@ The callback function to handle the text change */
            void *data; /*@ The data associated to the callback function. */
         }
      }
      part_text_cursor_begin {
         set {
            /*@
            @brief Moves the cursor to the beginning of the text part
            @see evas_textblock_cursor_paragraph_first */
         }
         values {
            const(char)* part; /*@ The part name */
            Edje_Cursor cur; /*@ the edje cursor to work on */
         }
      }
      part_text_cursor_line_end {
         set {
            /*@
            @brief Move the cursor to the end of the line.
            @see evas_textblock_cursor_line_char_last */
         }
         values {
            const(char)* part; /*@ The part name */
            Edje_Cursor cur; /*@ the edje cursor to work on */
         }
      }
      text_class {
         set {
            /*@
            @brief Sets Edje text class.

            @return @c EINA_TRUE, on success or @c EINA_FALSE, on error

            This function sets the text class for the Edje. */
            return: bool;
         }
         values {
            const(char)* text_class; /*@ The text class name */
            const(char)* font; /*@ Font name */
            Evas_Font_Size size; /*@ Font Size */
         }
      }
      part_text_cursor_coord {
         set {
            /*@
            Position the given cursor to a X,Y position.

            This is frequently used with the user cursor.

            @return True on success, false on error. */
            return: bool;
         }
         values {
            const(char)* part; /*@ The part containing the object. */
            Edje_Cursor cur; /*@ The cursor to adjust. */
            Evas_Coord x; /*@ X Coordinate. */
            Evas_Coord y; /*@ Y Coordinate. */
         }
      }
      part_text_cursor_end {
         set {
            /*@
            @brief Moves the cursor to the end of the text part.
            @see evas_textblock_cursor_paragraph_last */
         }
         values {
            const(char)* part; /*@ The part name */
            Edje_Cursor cur; /*@ the edje cursor to work on */
         }
      }
      part_text_escaped {
         set {
            /*@
            @brief Sets the text for an object part, but converts HTML escapes to UTF8

            This converts the given string @p text to UTF8 assuming it contains HTML
            style escapes like "&" and "©" etc. IF the part is of type TEXT,
            as opposed to TEXTBLOCK.

            @return @c EINA_TRUE on success, @c EINA_FALSE otherwise

            @since 1.2 */
            return: bool;
         }
         values {
            const(char)* part; /*@ The part name */
            const(char)* text; /*@ The text string */
         }
      }
      item_provider {
         set {
            /*@
            @brief Set the function that provides item objects for named items in an edje entry text

            Item objects may be deleted any time by Edje, and will be deleted when the
            Edje object is deleted (or file is set to a new file). */
         }
         values {
            Edje_Item_Provider_Cb func; /*@ The function to call (or NULL to disable) to get item objects */
            void *data; /*@ The data pointer to pass to the @p func callback */
         }
      }
      part_text_cursor_line_begin {
         set {
            /*@
            @brief Move the cursor to the beginning of the line.
            @see evas_textblock_cursor_line_char_first */
         }
         values {
            const(char)* part; /*@ The part name */
            Edje_Cursor cur; /*@ the edje cursor to work on */
         }
      }
      message_handler {
         set {
            /*@
            @brief Set an Edje message handler function for a given Edje object.

            For scriptable programs on an Edje object's defining EDC file which
            send messages with the @c send_message() primitive, one can attach
            <b>handler functions</b>, to be called in the code which creates
            that object (see @ref edcref "the syntax" for EDC files).

            This function associates a message handler function and the
            attached data pointer to the object @p obj.

            @see edje_object_message_send() */
         }
         values {
            Edje_Message_Handler_Cb func; /*@ The function to handle messages @b coming from @p obj */
            void *data; /*@ Auxiliary data to be passed to @p func */
         }
      }
      size_min {
         get {
            /*@
            @brief Get the minimum size specified -- as an EDC property -- for a
            given Edje object

            This function retrieves the @p obj object's minimum size values,
            <b>as declared in its EDC group definition</b>. Minimum size of
            groups have the following syntax
            @code
            collections {
            group {
            name: "a_group";
            min: 100 100;
            }
            }
            @endcode

            where one declares a minimum size of 100 pixels both for width and
            height. Those are (hint) values which should be respected when the
            given object/group is to be controlled by a given container object
            (e.g. an Edje object being "swallowed" into a given @c SWALLOW
            typed part, as in edje_object_part_swallow()). Check the complete
            @ref edcref "syntax reference" for EDC files.

            @note If the @c min EDC property was not declared for @p obj, this
            call will return the value 0, for each axis.

            @note On failure, this function will make all non-@c NULL size
            pointers' pointed variables be set to zero.

            @see edje_object_size_max_get() */
         }
         values {
            Evas_Coord minw; /*@ Pointer to a variable where to store the minimum width */
            Evas_Coord minh; /*@ Pointer to a variable where to store the minimum height */
         }
      }
      access_part_list {
         get {
            /*@
            @brief Retrieve a list all accessibility part names

            @return A list all accessibility part names on @p obj
            @since 1.7.0 */
            return: list<const(char)*> *;
         }
      }
      load_error {
         get {
            /*@
            @brief Gets the (last) file loading error for a given Edje object

            @return The Edje loading error, one of:
            - #EDJE_LOAD_ERROR_NONE
            - #EDJE_LOAD_ERROR_GENERIC
            - #EDJE_LOAD_ERROR_DOES_NOT_EXIST
            - #EDJE_LOAD_ERROR_PERMISSION_DENIED
            - #EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED
            - #EDJE_LOAD_ERROR_CORRUPT_FILE
            - #EDJE_LOAD_ERROR_UNKNOWN_FORMAT
            - #EDJE_LOAD_ERROR_INCOMPATIBLE_FILE
            - #EDJE_LOAD_ERROR_UNKNOWN_COLLECTION
            - #EDJE_LOAD_ERROR_RECURSIVE_REFERENCE

            This function is meant to be used after an Edje EDJ <b>file
            loading</b>, what takes place with the edje_object_file_set()
            function. If that function does not return @c EINA_TRUE, one should
            check for the reason of failure with this one.

            @see edje_load_error_str() */
            return: Edje_Load_Error;
         }
      }
      size_max {
         get {
            /*@
            @brief Get the maximum size specified -- as an EDC property -- for a
            given Edje object

            This function retrieves the @p obj object's maximum size values,
            <b>as declared in its EDC group definition</b>. Maximum size of
            groups have the following syntax
            @code
            collections {
            group {
            name: "a_group";
            max: 100 100;
            }
            }
            @endcode

            where one declares a maximum size of 100 pixels both for width and
            height. Those are (hint) values which should be respected when the
            given object/group is to be controlled by a given container object
            (e.g. an Edje object being "swallowed" into a given @c SWALLOW
            typed part, as in edje_object_part_swallow()). Check the complete
            @ref edcref "syntax reference" for EDC files.

            @note If the @c max EDC property was not declared for @p obj, this
            call will return the maximum size a given Edje object may have, for
            each axis.

            @note On failure, this function will make all non-@c NULL size
            pointers' pointed variables be set to zero.

            @see edje_object_size_min_get() */
         }
         values {
            Evas_Coord maxw; /*@ Pointer to a variable where to store the maximum width */
            Evas_Coord maxh; /*@ Pointer to a variable where to store the maximum height */
         }
      }
   }
   methods {
      part_table_clear {
         /*@
         @brief Removes all object from the table.

         @return @c EINA_TRUE clear the table, @c EINA_FALSE on failure

         Removes all object from the table indicated by part, except the
         internal ones set from the theme. */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in bool clear; /*@ If set, will delete subobjs on remove */
         }
      }
      part_external_param_type_get @const {
         /*@
         Facility to query the type of the given parameter of the given part.

         @return @c EDJE_EXTERNAL_PARAM_TYPE_MAX on errors, or another value
         from #Edje_External_Param_Type on success. */
         return: Edje_External_Param_Type;
         params {
            @in const(char)* part; /*@ The part name */
            @out const(char) param; /*@ the parameter name to use. */
         }
      }
      part_text_select_allow_set @const {
         /*@
         @brief Enables selection if the entry is an EXPLICIT selection mode
         type.

         The default is to @b not allow selection. This function only affects user
         selection, functions such as edje_object_part_text_select_all() and
         edje_object_part_text_select_none() are not affected. */
         params {
            @in const(char)* part; /*@ The part name */
            @in bool allow; /*@ EINA_TRUE to enable, EINA_FALSE otherwise */
         }
      }
      part_state_get @const {
         /*@
         @brief Returns the state of the Edje part.

         @return The part state:\n
         "default" for the default state\n
         "" for other states */
         return: const(char)*;
         params {
            @in const(char)* part; /*@ The part name */
            @out double val_ret;
         }
      }
      text_markup_filter_callback_del_full {
         /*@
         Delete a function and matching user data from the markup filter list.

         Delete the given @p func filter and @p data user data from the list
         in @p part.
         Returns the user data pointer given when added.

         @see edje_object_text_markup_filter_callback_add
         @see edje_object_text_markup_filter_callback_del

         @return The same data pointer if successful, or NULL otherwise
         @since 1.2.0 */

         return: void *;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Markup_Filter_Cb func; /*@ The function callback to remove */
            @in void *data; /*@ The data passed to the callback function */
         }
      }
      part_drag_step_set {
         /*@
         @brief Sets the drag step increment.

         Sets the x,y step increments for a dragable object.

         Values for @p dx and @p dy are real numbers that range from 0 to 1,
         representing the relative size of the dragable area on that axis by which the
         part will be moved.

         @see edje_object_part_drag_step_get() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in double dx; /*@ The x step amount */
            @in double dy; /*@ The y step amount */
         }
      }
      part_drag_step_get @const {
         /*@
         @brief Gets the drag step increment values.

         Gets the x and y step increments for the dragable object.


         @see edje_object_part_drag_step_set() */
         return: bool;
         params {
            @in const(char)* part; /*@ The part */
            @out double dx; /*@ The x step increment pointer */
            @out double dy; /*@ The y step increment pointer */
         }
      }
      part_text_imf_context_get @const {
         /*@
         @brief Get the input method context in entry.

         If ecore_imf was not available when edje was compiled, this function returns NULL
         otherwise, the returned pointer is an Ecore_IMF

         @return The input method context (Ecore_IMF_Context *) in entry
         @since 1.2.0 */
         return: void *;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_select_begin @const {
         /*@
         @brief Starts selecting at current cursor position */
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_style_user_peek @const {
         /*@
         @brief Return the text of the object part.

         @return The text string

         This function returns the style associated with the textblock part.

         @since 1.2.0 */
         return: const(char)*;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      signal_callback_del {
         /*@
         @brief Remove a signal-triggered callback from an object.

         @return The data pointer

         This function removes a callback, previously attached to the
         emittion of a signal, from the object @a obj. The parameters @a
         emission, @a source and @a func must match exactly those passed to
         a previous call to edje_object_signal_callback_add(). The data
         pointer that was passed to this call will be returned.

         @see edje_object_signal_callback_add().
         @see edje_object_signal_callback_del_full(). */

         legacy: null;
         return: void *;
         params {
            @in const(char)* emission; /*@ The emission string. */
            @in const(char)* source; /*@ The source string. */
            @in Edje_Signal_Cb func; /*@ The callback function. */
            @in void *data; /*@ The callback function. */
         }
      }
      part_text_cursor_next {
         /*@
         @brief Advances the cursor to the next cursor position.
         @see evas_textblock_cursor_char_next */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ The edje cursor to advance */
         }
      }
      part_text_style_user_push {
         /*@
         @brief Set the style of the

         This function sets the style associated with the textblock part.

         @since 1.2.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in const(char)* style; /*@ The style to set (textblock conventions). */
         }
      }
      part_text_append {
         /*@
         @brief Insert text for an object part.

         This function inserts the text for an object part at the end; It does not
         move the cursor.

         @since 1.1 */

         params {
            @in const(char)* part; /*@ The part name */
            @in const(char)* text; /*@ The text string */
         }
      }
      part_geometry_get @const {
         /*@
         @brief Retrieve the geometry of a given Edje part, in a given Edje
         object's group definition, <b>relative to the object's area</b>

         This function gets the geometry of an Edje part within its
         group. The @p x and @p y coordinates are relative to the top left
         corner of the whole @p obj object's area.

         @note Use @c NULL pointers on the geometry components you're not
         interested in: they'll be ignored by the function.

         @note On failure, this function will make all non-@c NULL geometry
         pointers' pointed variables be set to zero. */
         return: bool;
         params {
            @in const(char)* part; /*@ The Edje part's name */
            @out Evas_Coord x; /*@ A pointer to a variable where to store the part's x
            coordinate */
            @out Evas_Coord y; /*@ A pointer to a variable where to store the part's y
            coordinate */
            @out Evas_Coord w; /*@ A pointer to a variable where to store the part's width */
            @out Evas_Coord h; /*@ A pointer to a variable where to store the part's height */
         }
      }
      part_text_input_panel_hide @const {
         /*@
         @brief Hide the input panel (virtual keyboard).
         @see edje_object_part_text_input_panel_show

         Note that input panel is shown or hidden automatically according to the focus state.
         This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set.

         @since 1.2.0 */
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_item_geometry_get @const {
         /*@
         @brief Return item geometry.

         @return 1 if item exists, 0 if not

         This function return a list of Evas_Textblock_Rectangle item
         rectangles. */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in const(char)* item; /*@ The item name */
            @out Evas_Coord cx; /*@ Item x return (relative to entry part) */
            @out Evas_Coord cy; /*@ Item y return (relative to entry part) */
            @out Evas_Coord cw; /*@ Item width return */
            @out Evas_Coord ch; /*@ Item height return */
         }
      }
      part_table_unpack {
         /*@
         @brief Removes an object from the table.

         @return @c EINA_TRUE object removed, @c EINA_FALSE on failure

         Removes an object from the table indicated by part. */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Evas_Object *child_obj; /*@ The object to pack in */
         }
      }
      part_text_select_abort @const {
         /*@
         @brief Aborts any selection action on a part. */
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      text_insert_filter_callback_del_full {
         /*@
         Delete a function and matching user data from the filter list.

         Delete the given @p func filter and @p data user data from the list
         in @p part.
         Returns the user data pointer given when added.

         @see edje_object_text_insert_filter_callback_add
         @see edje_object_text_insert_filter_callback_del

         @return The same data pointer if successful, or NULL otherwise */

         return: void *;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Text_Filter_Cb func; /*@ The function callback to remove */
            @in void *data; /*@ The data passed to the callback function */
         }
      }
      part_text_style_user_pop {
         /*@
         @brief Delete the top style form the user style stack.

         @since 1.2.0 */

         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_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.

         @since 1.2.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in const(void)* data; /*@ The specific data to be set to the input panel. */
            @in int len; /*@ the length of data, in bytes, to send to the input panel */
         }
      }
      part_text_input_panel_imdata_get @const {
         /*@
         Get the specific data of the current active input panel.

         @since 1.2.0 */
         params {
            @in const(char)* part; /*@ The part name */
            @in void *data; /*@ The specific data to be got from the input panel */
            @in int *len; /*@ The length of data */
         }
      }
      part_text_insert {
         /*@
         @brief Insert text for an object part.

         This function inserts the text for an object part just before the
         cursor position. */

         params {
            @in const(char)* part; /*@ The part name */
            @in const(char)* text; /*@ The text string */
         }
      }
      part_box_remove_at {
         /*@
         @brief Removes an object from the box.

         @return Pointer to the object removed, or @c NULL.

         Removes from the box indicated by part, the object in the position
         pos.

         @see edje_object_part_box_remove()
         @see edje_object_part_box_remove_all() */

         return: Evas_Object *;
         params {
            @in const(char)* part; /*@ The part name */
            @in uint pos; /*@ The position index of the object (starts counting from 0) */
         }
      }
      part_text_cursor_copy {
         /*@
         @brief Copy the cursor to another cursor. */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor src; /*@ the cursor to copy from */
            @in Edje_Cursor dst; /*@ the cursor to copy to */
         }
      }
      parts_extends_calc {
         /*@
         Calculate the geometry of the region, relative to a given Edje
         object's area, <b>occupied by all parts in the object</b>

         This function gets the geometry of the rectangle equal to the area
         required to group all parts in @p obj's group/collection. The @p x
         and @p y coordinates are relative to the top left corner of the
         whole @p obj object's area. Parts placed out of the group's
         boundaries will also be taken in account, so that @p x and @p y
         <b>may be negative</b>.

         @note Use @c NULL pointers on the geometry components you're not
         interested in: they'll be ignored by the function.

         @note On failure, this function will make all non-@c NULL geometry
         pointers' pointed variables be set to zero. */

         return: bool;
         params {
            @out Evas_Coord x; /*@ A pointer to a variable where to store the parts region's
            x coordinate */
            @out Evas_Coord y; /*@ A pointer to a variable where to store the parts region's
            y coordinate */
            @out Evas_Coord w; /*@ A pointer to a variable where to store the parts region's
            width */
            @out Evas_Coord h; /*@ A pointer to a variable where to store the parts region's
            height */
         }
      }
      part_drag_value_set {
         /*@
         @brief Set the dragable object location.

         Places the dragable object at the given location.

         Values for @p dx and @p dy are real numbers that range from 0 to 1,
         representing the relative position to the dragable area on that axis.

         This value means, for the vertical axis, that 0.0 will be at the top if the
         first parameter of @c y in the dragable part theme is 1, and at bottom if it
         is -1.

         For the horizontal axis, 0.0 means left if the first parameter of @c x in the
         dragable part theme is 1, and right if it is -1.

         @see edje_object_part_drag_value_get() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in double dx; /*@ The x value */
            @in double dy; /*@ The y value */
         }
      }
      part_drag_value_get @const {
         /*@
         @brief Get the dragable object location.

         Values for @p dx and @p dy are real numbers that range from 0 to 1,
         representing the relative position to the dragable area on that axis.

         @see edje_object_part_drag_value_set()

         Gets the drag location values. */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @out double dx; /*@ The X value pointer */
            @out double dy; /*@ The Y value pointer */
         }
      }
      calc_force {
         /*@
         @brief Force a Size/Geometry calculation.

         Forces the object @p obj to recalculation layout regardless of
         freeze/thaw. */

      }
      part_text_cursor_pos_set {
         /*@
         @brief Sets the cursor position to the given value

         @since 1.1.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ The cursor to move */
            @in int pos; /*@ the position of the cursor */
         }
      }
      part_text_cursor_pos_get @const {
         /*@
         @brief Retrieves the current position of the cursor

         @return The cursor position
         @since 1.1.0 */
         return: int;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ The cursor to get the position */
         }
      }
      freeze {
         /*@
         @brief Freezes the Edje object.

         @return The frozen state or 0 on Error

         This function puts all changes on hold. Successive freezes will
         nest, requiring an equal number of thaws.

         @see edje_object_thaw() */

         return: int;
      }
      part_text_cursor_content_get @const {
         /*@
         @brief Returns the content (char) at the cursor position.
         @see evas_textblock_cursor_content_get

         You must free the return (if not NULL) after you are done with it.

         @return The character string pointed to (may be a multi-byte utf8 sequence) terminated by a nul byte. */
         return: char *;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ The cursor to use */
         }
      }
      part_text_input_panel_layout_set {
         /*@
         @brief Set the layout of the input panel.

         The layout of the input panel or virtual keyboard can make it easier or
         harder to enter content. This allows you to hint what kind of input you
         are expecting to enter and thus have the input panel automatically
         come up with the right mode.

         @since 1.1 */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Input_Panel_Layout layout; /*@ layout type */
         }
      }
      part_text_input_panel_layout_get @const {
         /*@
         @brief Get the layout of the input panel.

         @return Layout type of the input panel

         @see edje_object_part_text_input_panel_layout_set
         @since 1.1 */
         return: Edje_Input_Panel_Layout;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_table_pack {
         /*@
         @brief Packs an object into the table.

         @return @c EINA_TRUE object was added, @c EINA_FALSE on failure

         Packs an object into the table indicated by part. */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Evas_Object *child_obj; /*@ The object to pack in */
            @in ushort col; /*@ The column to place it in */
            @in ushort row; /*@ The row to place it in */
            @in ushort colspan; /*@ Columns the child will take */
            @in ushort rowspan; /*@ Rows the child will take */
         }
      }
      part_text_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.

         @since 1.2.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Input_Panel_Lang lang; /*@ the language to be set to the input panel. */
         }
      }
      part_text_input_panel_language_get @const {
         /*@
         Get the language mode of the input panel.

         See @ref edje_object_part_text_input_panel_language_set for more details.

         @return input panel language type
         @since 1.2.0 */
         return: Edje_Input_Panel_Lang;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_table_col_row_size_get @const {
         /*@
         @brief Gets the number of columns and rows the table has.

         @return @c EINA_TRUE get some data, @c EINA_FALSE on failure

         Retrieves the size of the table in number of columns and rows. */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @out int cols; /*@ Pointer where to store number of columns (can be NULL) */
            @out int rows; /*@ Pointer where to store number of rows (can be NULL) */
         }
      }
      part_external_object_get @const {
         /*@
         @brief Get the object created by this external part.

         Parts of type external creates the part object using information
         provided by external plugins. It's somehow like "swallow"
         (edje_object_part_swallow()), but it's all set automatically.

         This function returns the part created by such external plugins and
         being currently managed by this Edje.

         @note Almost all swallow rules apply: you should not move, resize,
         hide, show, set the color or clipper of such part. It's a bit
         more restrictive as one must @b never delete this object!

         @return The externally created object, or NULL if there is none or
         part is not an external. */
         return: Evas_Object *;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_external_content_get @const {
         /*@
         @brief Get an object contained in an part of type EXTERNAL

         The @p content string must not be NULL. Its actual value depends on the
         code providing the EXTERNAL. */
         return: Evas_Object *;
         params {
            @in const(char)* part; /*@ The name of the part holding the EXTERNAL */
            @out const(char) content; /*@ A string identifying which content from the EXTERNAL to get */
         }
      }
      preload {
         /*@
         @brief Preload the images on the Edje Object in the background.

         @return @c EINA_FASLE if obj was not a valid Edje object
         otherwise @c EINA_TRUE

         This function requests the preload of all data images (on the given
         object) in the background. The work is queued before being processed
         (because there might be other pending requests of this type).
         It emits a signal "preload,done" when finished.

         @note Use @c EINA_TRUE on scenarios where you don't need
         the image data preloaded anymore. */

         return: bool;
         params {
            @in bool cancel; /*@ @c EINA_FALSE will add it the preloading work queue,
            @c EINA_TRUE will remove it (if it was issued before). */
         }
      }
      part_text_input_panel_enabled_set {
         /*@
         @brief Sets the attribute to show the input panel automatically.

         @since 1.1.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in bool enabled; /*@ If true, the input panel is appeared when entry is clicked or has a focus */
         }
      }
      part_text_input_panel_enabled_get @const {
         /*@
         @brief Retrieve the attribute to show the input panel automatically.
         @see edje_object_part_text_input_panel_enabled_set

         @return EINA_TRUE if it supports or EINA_FALSE otherwise
         @since 1.1.0 */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_select_extend @const {
         /*@
         @brief Extends the current selection to the current cursor position */
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_box_insert_at {
         /*@
         @brief Inserts an object to the box.

         @return @c EINA_TRUE: Successfully added.\n
         @c EINA_FALSE: An error occurred.

         Adds child to the box indicated by part, in the position given by
         pos.

         @see edje_object_part_box_append()
         @see edje_object_part_box_prepend()
         @see edje_object_part_box_insert_before() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Evas_Object *child; /*@ The object to insert */
            @in uint pos; /*@ The position where to insert child */
         }
      }
      part_text_anchor_geometry_get @const {
         /*@
         @brief Return a list of Evas_Textblock_Rectangle anchor rectangles.

         @return The list of anchor rects (const Evas_Textblock_Rectangle
         *), do not modify! Geometry is relative to entry part.

         This function return a list of Evas_Textblock_Rectangle anchor
         rectangles. */
         return: const(list<const(Evas.Textblock_Rectangle)*>)*;
         params {
            @in const(char)* part; /*@ The part name */
            @in const(char)* anchor; /*@ The anchor name */
         }
      }
      part_text_cursor_down {
         /*@
         @brief Moves the cursor to the char below the current cursor position. */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ the edje cursor to work on */
         }
      }
      part_drag_page_set {
         /*@
         @brief Sets the page step increments.

         Sets the x,y page step increment values.

         Values for @p dx and @p dy are real numbers that range from 0 to 1,
         representing the relative size of the dragable area on that axis by which the
         part will be moved.

         @see edje_object_part_drag_page_get() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in double dx; /*@ The x page step increment */
            @in double dy; /*@ The y page step increment */
         }
      }
      part_drag_page_get @const {
         /*@
         @brief Gets the page step increments.

         Gets the x,y page step increments for the dragable object.

         @see edje_object_part_drag_page_set() */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @out double dx; /*@ The dx page increment pointer */
            @out double dy; /*@ The dy page increment pointer */
         }
      }
      part_box_prepend {
         /*@
         @brief Prepends an object to the box.

         @return @c EINA_TRUE: Successfully added.\n
         @c EINA_FALSE: An error occurred.

         Prepends child to the box indicated by part.

         @see edje_object_part_box_append()
         @see edje_object_part_box_insert_before()
         @see edje_object_part_box_insert_at() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Evas_Object *child; /*@ The object to prepend */
         }
      }
      signal_emit {
         /*@
         @brief Send/emit an Edje signal to a given Edje object

         This function sends a signal to the object @a obj. An Edje program,
         at @p obj's EDC specification level, can respond to a signal by
         having declared matching @c 'signal' and @c 'source' fields on its
         block (see @ref edcref "the syntax" for EDC files).

         As an example,
         @code
         edje_object_signal_emit(obj, "a_signal", "");
         @endcode
         would trigger a program which had an EDC declaration block like
         @code
         program {
         name: "a_program";
         signal: "a_signal";
         source: "";
         action: ...
         }
         @endcode

         @see edje_object_signal_callback_add() for more on Edje signals. */

         params {
            @in const(char)* emission; /*@ The signal's "emission" string */
            @in const(char)* source; /*@ The signal's "source" string */
         }
      }
      part_text_input_panel_layout_variation_set {
         /*@
         @brief Set the layout variation of the input panel.

         The layout variation of the input panel or virtual keyboard can make it easier or
         harder to enter content. This allows you to hint what kind of input you
         are expecting to enter and thus have the input panel automatically
         come up with the right mode.

         @since 1.8 */

         params {
            @in const(char)* part; /*@ The part name */
            @in int variation; /*@ layout variation type */
         }
      }
      part_text_input_panel_layout_variation_get @const {
         /*@
         @brief Get the layout variation of the input panel.

         @return Layout variation type of the input panel

         @see edje_object_part_text_input_panel_layout_variation_set
         @since 1.8 */
         return: int;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      message_send {
         /*@
         @brief Send an (Edje) message to a given Edje object

         This function sends an Edje message to @p obj and to all of its
         child objects, if it has any (swallowed objects are one kind of
         child object). @p type and @p msg @b must be matched accordingly,
         as documented in #Edje_Message_Type.

         The @p id argument as a form of code and theme defining a common
         interface on message communication. One should define the same IDs
         on both code and EDC declaration (see @ref edcref "the syntax" for
         EDC files), to individualize messages (binding them to a given
         context).

         The function to handle messages arriving @b from @b obj is set with
         edje_object_message_handler_set(). */

         params {
            @in Edje_Message_Type type; /*@ The type of message to send to @p obj */
            @in int id; /*@ A identification number for the message to be sent */
            @in void *msg; /*@ The message's body, a struct depending on @p type */
         }
      }
      part_text_select_none @const {
         /*@
         @brief Set the selection to be none.

         This function sets the selection text to be none. */
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_object_get @const {
         /*@
         @brief Get a handle to the Evas object implementing a given Edje
         part, in an Edje object.

         @return A pointer to the Evas object implementing the given part,
         or @c NULL on failure (e.g. the given part doesn't exist)

         This function gets a pointer of the Evas object corresponding to a
         given part in the @p obj object's group.

         You should @b never modify the state of the returned object (with
         @c evas_object_move() or @c evas_object_hide() for example),
         because it's meant to be managed by Edje, solely. You are safe to
         query information about its current state (with @c
         evas_object_visible_get() or @c evas_object_color_get() for
         example), though. */
         return: const(Evas_Object)*;
         params {
            @in const(char)* part; /*@ The Edje part's name */
         }
      }
      part_drag_size_set {
         /*@
         @brief Set the dragable object size.

         Values for @p dw and @p dh are real numbers that range from 0 to 1,
         representing the relative size of the dragable area on that axis.

         Sets the size of the dragable object.

         @see edje_object_part_drag_size_get() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in double dw; /*@ The drag width */
            @in double dh; /*@ The drag height */
         }
      }
      part_drag_size_get @const {
         /*@
         @brief Get the dragable object size.

         Gets the dragable object size.

         @see edje_object_part_drag_size_set() */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @out double dw; /*@ The drag width pointer */
            @out double dh; /*@ The drag height pointer */
         }
      }
      text_insert_filter_callback_del {
         /*@
         Delete a function from the filter list.

         Delete the given @p func filter from the list in @p part. Returns
         the user data pointer given when added.

         @see edje_object_text_insert_filter_callback_add
         @see edje_object_text_insert_filter_callback_del_full

         @return The user data pointer if successful, or NULL otherwise */

         return: void *;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Text_Filter_Cb func; /*@ The function callback to remove */
         }
      }
      part_drag_dir_get @const {
         /*@
         @brief Determine dragable directions.

         The dragable directions are defined in the EDC file, inside the @c dragable
         section, by the attributes @c x and @c y. See the @ref edcref for more
         information.

         @return #EDJE_DRAG_DIR_NONE: Not dragable\n
         #EDJE_DRAG_DIR_X: Dragable in X direction\n
         #EDJE_DRAG_DIR_Y: Dragable in Y direction\n
         #EDJE_DRAG_DIR_XY: Dragable in X & Y directions */
         return: Edje_Drag_Dir;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_unescaped_set {
         /*@
         @brief Sets the raw (non escaped) text for an object part.

         This funciton will not do escape for you if it is a TEXTBLOCK part, that is,
         if text contain tags, these tags will not be interpreted/parsed by TEXTBLOCK.

         @see edje_object_part_text_unescaped_get(). */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in const(char)* text_to_escape; /*@ The text string */
         }
      }
      part_text_unescaped_get @const {
         /*@
         @brief Returns the text of the object part, without escaping.

         @return The @b allocated text string without escaping, or NULL on
         problems.

         This function is the counterpart of
         edje_object_part_text_unescaped_set(). Please notice that the
         result is newly allocated memory and should be released with free()
         when done.

         @see edje_object_part_text_unescaped_set(). */
         return: char *;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      signal_callback_add {
         /*@
         @brief Add a callback for an arriving Edje signal, emitted by
         a given Edje object.

         Edje signals are one of the communication interfaces between
         @b code and a given Edje object's @b theme. With signals, one can
         communicate two string values at a time, which are:
         - "emission" value: the name of the signal, in general
         - "source" value: a name for the signal's context, in general

         Though there are those common uses for the two strings, one is free
         to use them however they like.

         This function adds a callback function to a signal emitted by @a obj, to
         be issued every time an EDC program like the following
         @code
         program {
         name: "emit_example";
         action: SIGNAL_EMIT "a_signal" "a_source";
         }
         @endcode
         is run, if @p emission and @p source are given those same values,
         here.

         Signal callback registration is powerful, in the way that @b blobs
         may be used to match <b>multiple signals at once</b>. All the @c
         "*?[\" set of @c fnmatch() operators can be used, both for @p
         emission and @p source.

         Edje has @b internal signals it will emit, automatically, on
         various actions taking place on group parts. For example, the mouse
         cursor being moved, pressed, released, etc., over a given part's
         area, all generate individual signals.

         By using something like
         @code
         edje_object_signal_callback_add(obj, "mouse,down,*", "button.*",
         signal_cb, NULL);
         @endcode
         being @c "button.*" the pattern for the names of parts implementing
         buttons on an interface, you'd be registering for notifications on
         events of mouse buttons being pressed down on either of those parts
         (those events all have the @c "mouse,down," common prefix on their
         names, with a suffix giving the button number). The actual emission
         and source strings of an event will be passed in as the @a emission
         and @a source parameters of the callback function (e.g. @c
         "mouse,down,2" and @c "button.close"), for each of those events.

         @note See @ref edcref "the syntax" for EDC files
         @see edje_object_signal_emit() on how to emits Edje signals from
         code to a an object
         @see edje_object_signal_callback_del_full() */

         params {
            @in const(char)* emission; /*@ The signal's "emission" string */
            @in const(char)* source; /*@ The signal's "source" string */
            @in Edje_Signal_Cb func; /*@ The callback function to be executed when the signal is
            emitted. */
            @in void *data; /*@ A pointer to data to pass in to @p func. */
         }
      }
      part_text_select_all @const {
         /*@
         @brief Set the selection to be everything.

         This function selects all text of the object of the part. */
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_input_panel_return_key_disabled_set {
         /*@
         Set the return key on the input panel to be disabled.

         @since 1.2.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in bool disabled; /*@ The state */
         }
      }
      part_text_input_panel_return_key_disabled_get @const {
         /*@
         Get whether the return key on the input panel should be disabled or not.

         @return EINA_TRUE if it should be disabled
         @since 1.2.0 */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_autocapital_type_set {
         /*@
         @brief Set the autocapitalization type on the immodule.

         @since 1.1.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Text_Autocapital_Type autocapital_type; /*@ The type of autocapitalization */
         }
      }
      part_text_autocapital_type_get @const {
         /*@
         @brief Retrieves the autocapitalization type

         @return The autocapitalization type
         @since 1.1.0 */
         return: Edje_Text_Autocapital_Type;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_unswallow {
         /*@
         @brief Unswallow an object.

         Causes the edje to regurgitate a previously swallowed object. :)

         @note @p obj_swallow will @b not be deleted or hidden.
         @note @p obj_swallow may appear shown on the evas depending on its state when
         it got unswallowed. Make sure you delete it or hide it if you do not want it to. */

         params {
            @in Evas_Object *obj_swallow; /*@ The swallowed object */
         }
      }
      part_text_prediction_allow_set {
         /*@
         @brief Set whether the prediction is allowed or not.

         @since 1.2.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in bool prediction; /*@ If true, the prediction feature is allowed. */
         }
      }
      part_text_prediction_allow_get @const {
         /*@
         @brief Get whether the prediction is allowed or not.

         @return EINA_TRUE if prediction feature is allowed.
         @since 1.2.0 */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      data_get @const {
         /*@
         @brief Retrive an <b>EDC data field's value</b> from a given Edje
         object's group.

         @return The data's value string. Must not be freed.

         This function fetches an EDC data field's value, which is declared
         on the objects building EDC file, <b>under its group</b>. EDC data
         blocks are most commonly used to pass arbitrary parameters from an
         application's theme to its code.

         They look like the following:

         @code
         collections {
         group {
         name: "a_group";
         data {
         item: "key1" "value1";
         item: "key2" "value2";
         }
         }
         }
         @endcode

         EDC data fields always hold @b strings as values, hence the return
         type of this function. Check the complete @ref edcref "syntax reference"
         for EDC files.

         @warning Do not confuse this call with edje_file_data_get(), which
         queries for a @b global EDC data field on an EDC declaration file.

         @see edje_object_file_set() */
         return: const(char)*;
         params {
            @in const(char)* key; /*@ The data field's key string */
         }
      }
      text_markup_filter_callback_add {
         /*@
         Add a markup filter function for newly inserted text.

         Whenever text is inserted (not the same as set) into the given @p part,
         the list of markup filter functions will be called to decide if and how
         the new text will be accepted.
         The text parameter in the @p func filter is always markup. It can be
         modified by the user and it's up to him to free the one passed if he's to
         change the pointer. If doing so, the newly set text should be malloc'ed,
         as once all the filters are called Edje will free it.
         If the text is to be rejected, freeing it and setting the pointer to NULL
         will make Edje break out of the filter cycle and reject the inserted
         text.
         This function is different from edje_object_text_insert_filter_callback_add()
         in that the text parameter in the @p fucn filter is always markup.

         @warning If you use this function with
         edje_object_text_insert_filter_callback_add() togehter, all
         Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions
         will be executed, and then filtered text will be inserted.

         @see edje_object_text_markup_filter_callback_del
         @see edje_object_text_markup_filter_callback_del_full
         @see edje_object_text_insert_filter_callback_add

         @since 1.2.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Markup_Filter_Cb func; /*@ The callback function that will act as markup filter */
            @in void *data; /*@ User provided data to pass to the filter function */
         }
      }
      message_signal_process {
         /*@
         @brief Process an object's message queue.

         This function goes through the object message queue processing the
         pending messages for @b this specific Edje object. Normally they'd
         be processed only at idle time. */

      }
      part_box_remove {
         /*@
         @brief Removes an object from the box.

         @return Pointer to the object removed, or @c NULL.

         Removes child from the box indicated by part.

         @see edje_object_part_box_remove_at()
         @see edje_object_part_box_remove_all() */

         return: Evas_Object *;
         params {
            @in const(char)* part; /*@ The part name */
            @in Evas_Object *child; /*@ The object to remove */
         }
      }
      thaw {
         /*@
         @brief Thaws the Edje object.

         @return The frozen state or 0 if the object is not frozen or on error.

         This function thaws the given Edje object.

         @note: If sucessives freezes were done, an equal number of
         thaws will be required.

         @see edje_object_freeze() */

         return: int;
      }
      part_swallow_get @const {
         /*@
         @brief Get the object currently swallowed by a part.

         @return The swallowed object, or NULL if there is none. */
         return: Evas_Object *;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_imf_context_reset @const {
         /*@
         @brief Reset the input method context if needed.

         This can be necessary in the case where modifying the buffer would confuse on-going input method behavior

         @since 1.2.0 */
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_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

         @since 1.2.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Input_Panel_Return_Key_Type return_key_type; /*@ The type of "return" key on the input panel */
         }
      }
      part_text_input_panel_return_key_type_get @const {
         /*@
         Get the "return" key type.

         @see edje_object_part_text_input_panel_return_key_type_set() for more details

         @return The type of "return" key on the input panel
         @since 1.2.0 */
         return: Edje_Input_Panel_Return_Key_Type;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_table_child_get @const {
         /*@
         @brief Retrieve a child from a table

         @return The child Evas_Object */
         return: Evas_Object *;
         params {
            @in const(char)* part; /*@ The part name */
            @in uint col; /*@ The column of the child to get */
            @in uint row; /*@ The row of the child to get */
         }
      }
      part_box_insert_before {
         /*@
         @brief Adds an object to the box.

         @return @c EINA_TRUE: Successfully added.\n
         @c EINA_FALSE: An error occurred.

         Inserts child in the box given by part, in the position marked by
         reference.

         @see edje_object_part_box_append()
         @see edje_object_part_box_prepend()
         @see edje_object_part_box_insert_at() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Evas_Object *child; /*@ The object to insert */
            @in const(Evas_Object)* reference; /*@ The object to be used as reference */
         }
      }
      part_external_param_set {
         /*@
         @brief Set the parameter for the external part.

         Parts of type external may carry extra properties that have
         meanings defined by the external plugin. For instance, it may be a
         string that defines a button label and setting this property will
         change that label on the fly.

         @note external parts have parameters set when they change
         states. Those parameters will never be changed by this
         function. The interpretation of how state_set parameters and
         param_set will interact is up to the external plugin.

         @note this function will not check if parameter value is valid
         using #Edje_External_Param_Info minimum, maximum, valid
         choices and others. However these should be checked by the
         underlying implementation provided by the external
         plugin. This is done for performance reasons.

         @return @c EINA_TRUE if everything went fine, @c EINA_FALSE on errors. */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in const(Edje_External_Param)* param; /*@ the parameter details, including its name, type and
            actual value. This pointer should be valid, and the
            parameter must exist in
            #Edje_External_Type.parameters_info, with the exact type,
            otherwise the operation will fail and @c EINA_FALSE will be
            returned. */
         }
      }
      part_external_param_get @const {
         /*@
         @brief Get the parameter for the external part.

         Parts of type external may carry extra properties that have
         meanings defined by the external plugin. For instance, it may be a
         string that defines a button label. This property can be modified by
         state parameters, by explicit calls to
         edje_object_part_external_param_set() or getting the actual object
         with edje_object_part_external_object_get() and calling native
         functions.

         This function asks the external plugin what is the current value,
         independent on how it was set.

         @return @c EINA_TRUE if everything went fine and @p param members
         are filled with information, @c EINA_FALSE on errors and @p
         param member values are not set or valid. */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @out Edje_External_Param param; /*@ the parameter details. It is used as both input and
            output variable. This pointer should be valid, and the
            parameter must exist in
            #Edje_External_Type.parameters_info, with the exact type,
            otherwise the operation will fail and @c EINA_FALSE will be
            returned. */
         }
      }
      size_min_calc {
         /*@
         @brief Calculate the minimum required size for a given Edje object.

         This call works exactly as edje_object_size_min_restricted_calc(),
         with the last two arguments set to 0. Please refer to its
         documentation, then. */

         params {
            @out Evas_Coord minw; /*@ Pointer to a variable where to store the minimum
            required width */
            @out Evas_Coord minh; /*@ Pointer to a variable where to store the minimum
            required height */
         }
      }
      part_box_append {
         /*@
         @brief Appends an object to the box.

         @return @c EINA_TRUE: Successfully added.\n
         @c EINA_FALSE: An error occurred.

         Appends child to the box indicated by part.

         @see edje_object_part_box_prepend()
         @see edje_object_part_box_insert_before()
         @see edje_object_part_box_insert_at() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Evas_Object *child; /*@ The object to append */
         }
      }
      size_min_restricted_calc {
         /*@
         @brief Calculate the minimum required size for a given Edje object.

         This call will trigger an internal recalculation of all parts of
         the @p obj object, in order to return its minimum required
         dimensions for width and height. The user might choose to @b impose
         those minimum sizes, making the resulting calculation to get to values
         equal or bigger than @p restrictedw and @p restrictedh, for width and
         height, respectively.

         @note At the end of this call, @p obj @b won't be automatically
         resized to new dimensions, but just return the calculated
         sizes. The caller is the one up to change its geometry or not.

         @warning Be advised that invisible parts in @p obj @b will be taken
         into account in this calculation. */

         params {
            @out Evas_Coord minw; /*@ Pointer to a variable where to store the minimum
            required width */
            @out Evas_Coord minh; /*@ Pointer to a variable where to store the minimum
            required height */
            @in Evas_Coord restrictedw; /*@ Do not allow object's calculated (minimum) width
            to be less than this value */
            @in Evas_Coord restrictedh; /*@ Do not allow object's calculated (minimum)
            height to be less than this value */
         }
      }
      part_box_remove_all {
         /*@
         @brief Removes all elements from the box.

         @return 1: Successfully cleared.\n
         0: An error occurred.

         Removes all the external objects from the box indicated by part.
         Elements created from the theme will not be removed.

         @see edje_object_part_box_remove()
         @see edje_object_part_box_remove_at() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in bool clear; /*@ Delete objects on removal */
         }
      }
      part_drag_page {
         /*@
         @brief Pages x,y steps.

         Pages x,y where the increment is defined by
         edje_object_part_drag_page_set.

         Values for @p dx and @p dy are real numbers that range from 0 to 1.

         @warning Paging is bugged!

         @see edje_object_part_drag_step() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in double dx; /*@ The x step */
            @in double dy; /*@ The y step */
         }
      }
      part_text_set {
         /*@
         @brief Sets the text for an object part

         @return @c EINA_TRUE on success, @c EINA_FALSE otherwise */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in const(char)* text; /*@ The text string */
         }
      }
      part_text_get @const {
         /*@
         @brief Return the text of the object part.

         @return The text string

         This function returns the text associated to the object part.

         @see edje_object_part_text_set(). */
         return: const(char)*;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_input_panel_show_on_demand_set {
         /*@
         Set the attribute to show the input panel in case of only an user's explicit Mouse Up event.
         It doesn't request to show the input panel even though it has focus.

         @since 1.9.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in bool ondemand; /*@ If true, the input panel will be shown in case of only Mouse up event. (Focus event will be ignored.) */
         }
      }
      part_text_input_panel_show_on_demand_get @const {
         /*@
         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.0 */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_input_hint_set {
         /*@
         Sets the input hint which allows input methods to fine-tune their behavior.

         @since 1.12.0 */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Input_Hints input_hints; /*@ input hints */
         }
      }
      part_text_input_hint_get @const {
         /*@
         Gets the value of input hint

         @return The value of input hint
         @since 1.12.0 */
         return: Edje_Input_Hints;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_selection_get @const {
         /*@
         @brief Return the selection text of the object part.

         @return The text string

         This function returns selection text of the object part.

         @see edje_object_part_text_select_all()
         @see edje_object_part_text_select_none() */
         return: const(char)*;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_text_cursor_is_format_get @const {
         /*@
         @brief Returns whether the cursor points to a format.
         @see evas_textblock_cursor_is_format

         @return EINA_TRUE if it's true, EINA_FALSE otherwise. */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ The cursor to adjust. */
         }
      }
      text_class_get @const {
         /*@
         @brief Gets font and font size from edje text class.

         @return @c EINA_TRUE, on success or @c EINA_FALSE, on error

         This function gets the font and the font size from the object
         text class. The font string will only be valid until the text
         class is changed or the edje object is deleted. */
         return: bool;
         params {
            @in const(char)* text_class; /*@ The text class name */
            @out const(char)* font; /*@ Font name */
            @out Evas_Font_Size size; /*@ Font Size */
         }
      }
      color_class_set {
         /*@
         @brief Sets the object color class.

         This function sets the color values for an object level color
         class. This will cause all edje parts in the specified object that
         have the specified color class to have their colors multiplied by
         these values.

         The first color is the object, the second is the text outline, and
         the third is the text shadow. (Note that the second two only apply
         to text parts).

         Setting color emits a signal "color_class,set" with source being
         the given color.

         @note unlike Evas, Edje colors are @b not pre-multiplied. That is,
         half-transparent white is 255 255 255 128. */

         return: bool;
         params {
            @in const(char)* color_class;
            @in int r; /*@ Object Red value */
            @in int g; /*@ Object Green value */
            @in int b; /*@ Object Blue value */
            @in int a; /*@ Object Alpha value */
            @in int r2; /*@ Outline Red value */
            @in int g2; /*@ Outline Green value */
            @in int b2; /*@ Outline Blue value */
            @in int a2; /*@ Outline Alpha value */
            @in int r3; /*@ Shadow Red value */
            @in int g3; /*@ Shadow Green value */
            @in int b3; /*@ Shadow Blue value */
            @in int a3; /*@ Shadow Alpha value */
         }
      }
      color_class_get @const {
         /*@
         @brief Gets the object color class.

         @return EINA_TRUE if found or EINA_FALSE if not found and all
         values are zeroed.

         This function gets the color values for an object level color
         class. If no explicit object color is set, then global values will
         be used.

         The first color is the object, the second is the text outline, and
         the third is the text shadow. (Note that the second two only apply
         to text parts).

         @note unlike Evas, Edje colors are @b not pre-multiplied. That is,
         half-transparent white is 255 255 255 128. */
         return: bool;
         params {
            @in const(char)* color_class;
            @out int r; /*@ Object Red value */
            @out int g; /*@ Object Green value */
            @out int b; /*@ Object Blue value */
            @out int a; /*@ Object Alpha value */
            @out int r2; /*@ Outline Red value */
            @out int g2; /*@ Outline Green value */
            @out int b2; /*@ Outline Blue value */
            @out int a2; /*@ Outline Alpha value */
            @out int r3; /*@ Shadow Red value */
            @out int g3; /*@ Shadow Green value */
            @out int b3; /*@ Shadow Blue value */
            @out int a3; /*@ Shadow Alpha value */
         }
      }
      color_class_description_get @const {
         /*@
         @brief Gets the description of an object color class.

         @return The description of the target color class or @c NULL if not found

         This function gets the description of a color class in use by an object. */
         return: const(char)*;
         params {
            @in const(char)* color_class;
         }
      }
      part_drag_step {
         /*@
         @brief Steps the dragable x,y steps.

         Steps x,y where the step increment is the amount set by
         edje_object_part_drag_step_set.

         Values for @p dx and @p dy are real numbers that range from 0 to 1.

         @see edje_object_part_drag_page() */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in double dx; /*@ The x step */
            @in double dy; /*@ The y step */
         }
      }
      part_text_cursor_up {
         /*@
         @brief Move the cursor to the char above the current cursor position. */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ the edje cursor to work on */
         }
      }
      part_text_cursor_geometry_get @const {
         /*@
         @brief Returns the cursor geometry of the part relative to the edje
         object. */
         params {
            @in const(char)* part; /*@ The part name */
            @out Evas_Coord x; /*@ Cursor X position */
            @out Evas_Coord y; /*@ Cursor Y position */
            @out Evas_Coord w; /*@ Cursor width */
            @out Evas_Coord h; /*@ Cursor height */
         }
      }
      part_text_anchor_list_get @const {
         /*@
         @brief Return a list of char anchor names.

         @return The list of anchors (const char *), do not modify!

         This function returns a list of char anchor names. */
         return: const(list<const(char)*>)*;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      text_insert_filter_callback_add {
         /*@
         Add a filter function for newly inserted text.

         Whenever text is inserted (not the same as set) into the given @p part,
         the list of filter functions will be called to decide if and how the new
         text will be accepted.
         There are three types of filters, EDJE_TEXT_FILTER_TEXT,
         EDJE_TEXT_FILTER_FORMAT and EDJE_TEXT_FILTER_MARKUP.
         The text parameter in the @p func filter can be modified by the user and
         it's up to him to free the one passed if he's to change the pointer. If
         doing so, the newly set text should be malloc'ed, as once all the filters
         are called Edje will free it.
         If the text is to be rejected, freeing it and setting the pointer to NULL
         will make Edje break out of the filter cycle and reject the inserted
         text.

         @warning This function will be deprecated because of difficulty in use.
         The type(format, text, or markup) of text should be always
         checked in the filter function for correct filtering.
         Please use edje_object_text_markup_filter_callback_add() instead. There
         is no need to check the type of text in the filter function
         because the text is always markup.
         @warning If you use this function with
         edje_object_text_markup_filter_callback_add() together, all
         Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions
         will be executed, and then filtered text will be inserted.

         @see edje_object_text_insert_filter_callback_del
         @see edje_object_text_insert_filter_callback_del_full
         @see edje_object_text_markup_filter_callback_add */

         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Text_Filter_Cb func; /*@ The callback function that will act as filter */
            @in void *data; /*@ User provided data to pass to the filter function */
         }
      }
      part_text_input_panel_show @const {
         /*@
         @brief Show the input panel (virtual keyboard) based on the input panel property such as layout, autocapital types, and so on.

         Note that input panel is shown or hidden automatically according to the focus state.
         This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set.

         @since 1.2.0 */
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_exists @const {
         /*@
         @brief Check if an Edje part exists in a given Edje object's group
         definition.

         @return @c EINA_TRUE, if the Edje part exists in @p obj's group or
         @c EINA_FALSE, otherwise (and on errors)

         This function returns if a given part exists in the Edje group
         bound to object @p obj (with edje_object_file_set()).

         This call is useful, for example, when one could expect or not a
         given GUI element, depending on the @b theme applied to @p obj. */
         return: bool;
         params {
            @in const(char)* part; /*@ The part's name to check for existence in @p obj's
            group */
         }
      }
      text_markup_filter_callback_del {
         /*@
         Delete a function from the markup filter list.

         Delete the given @p func filter from the list in @p part. Returns
         the user data pointer given when added.

         @see edje_object_text_markup_filter_callback_add
         @see edje_object_text_markup_filter_callback_del_full

         @return The user data pointer if successful, or NULL otherwise
         @since 1.2.0 */

         return: void *;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Markup_Filter_Cb func; /*@ The function callback to remove */
         }
      }
      part_text_cursor_is_visible_format_get @const {
         /*@
         @brief Return true if the cursor points to a visible format
         For example \\t, \\n, item and etc.
         @see  evas_textblock_cursor_format_is_visible_get */
         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ The cursor to adjust. */
         }
      }
      part_text_user_insert @const {
         /*@
         @brief This function inserts text as if the user has inserted it.

         This means it actually registers as a change and emits signals, triggers
         callbacks as appropriate.

         @since 1.2.0 */
         params {
            @in const(char)* part; /*@ The part name */
            @in const(char)* text; /*@ The text string */
         }
      }
      part_text_cursor_prev {
         /*@
         @brief Moves the cursor to the previous char
         @see evas_textblock_cursor_char_prev */

         return: bool;
         params {
            @in const(char)* part; /*@ The part name */
            @in Edje_Cursor cur; /*@ the edje cursor to work on */
         }
      }
      part_text_item_list_get @const {
         /*@
         @brief Return a list of char item names.

         @return The list of items (const char *), do not modify!

         This function returns a list of char item names. */
         return: const(list<const(char)*>)*;
         params {
            @in const(char)* part; /*@ The part name */
         }
      }
      part_swallow {
         /*@
         @brief "Swallows" an object into one of the Edje object @c SWALLOW
         parts.

         Swallowing an object into an Edje object is, for a given part of
         type @c SWALLOW in the EDC group which gave life to @a obj, to set
         an external object to be controlled by @a obj, being displayed
         exactly over that part's region inside the whole Edje object's
         viewport.

         From this point on, @a obj will have total control over @a
         obj_swallow's geometry and visibility. For instance, if @a obj is
         visible, as in @c evas_object_show(), the swallowed object will be
         visible too -- if the given @c SWALLOW part it's in is also
         visible. Other actions on @a obj will also reflect on the swallowed
         object as well (e.g. resizing, moving, raising/lowering, etc.).

         Finally, all internal changes to @a part, specifically, will
         reflect on the displaying of @a obj_swallow, for example state
         changes leading to different visibility states, geometries,
         positions, etc.

         If an object has already been swallowed into this part, then it
         will first be unswallowed (as in edje_object_part_unswallow())
         before the new object is swallowed.

         @note @a obj @b won't delete the swallowed object once it is
         deleted -- @a obj_swallow will get to an unparented state again.

         For more details on EDC @c SWALLOW parts, see @ref edcref "syntax
         reference". */

         return: bool;
         params {
            @in const(char)* part; /*@ The swallow part's name */
            @in Evas_Object *obj_swallow; /*@ The object to occupy that part */
         }
      }
   }
   implements {
      Eo.Base.constructor;
      Eo.Base.destructor;
      Eo.Base.dbg_info_get;
      Evas.Object_Smart.hide;
      Evas.Object_Smart.calculate;
      Evas.Object_Smart.show;
      Evas.Object_Smart.move;
      Evas.Object_Smart.add;
      Evas.Object_Smart.del;
      Evas.Object_Smart.resize;
      Efl.File.file.set;
      Efl.File.file.get;
      Efl.File.mmap.set;
      Efl.File.mmap.get;
   }
}