aboutsummaryrefslogtreecommitdiffstats
path: root/legacy/elementary/src/lib/Elementary.h.in
blob: 2410c8631d4d938f283f119ae36e2bab954af453 (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
/*
 * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
 */
#ifndef ELEMENTARY_H
#define ELEMENTARY_H

/**
 * @file Elementary.h
 * @brief Elementary's API
 *
 * Elementary API.
 */

@ELM_UNIX_DEF@ ELM_UNIX
@ELM_WIN32_DEF@ ELM_WIN32
@ELM_WINCE_DEF@ ELM_WINCE
@ELM_EDBUS_DEF@ ELM_EDBUS
@ELM_EFREET_DEF@ ELM_EFREET
@ELM_ALLOCA_H_DEF@ ELM_ALLOCA_H
@ELM_LIBINTL_H_DEF@ ELM_LIBINTL_H

/* Standard headers for standard system calls etc. */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/param.h>
#include <dlfcn.h>
#include <math.h>
#include <fnmatch.h>
#include <limits.h>
#include <ctype.h>
#include <time.h>
#include <dirent.h>
#include <pwd.h>
#include <errno.h>

#ifdef ELM_UNIX
# include <locale.h>
#ifdef ELM_LIBINTL_H
# include <libintl.h>
#endif
# include <signal.h>
# include <grp.h>
# include <glob.h>
#endif

#ifdef ELM_ALLOCA_H
# include <alloca.h>
#endif

#if defined (ELM_WIN32) || defined (ELM_WINCE)
# include <malloc.h>
# ifndef alloca
#  define alloca _alloca
# endif
#endif


/* EFL headers */
#include <Eina.h>
#include <Eet.h>
#include <Evas.h>
#include <Ecore.h>
#include <Ecore_Evas.h>
#include <Ecore_Job.h>
#include <Ecore_Txt.h>
#include <Ecore_File.h>
#include <Edje.h>

#ifdef ELM_EDBUS
# include <E_DBus.h>
# include <E_Hal.h>
#endif

#ifdef ELM_EFREET
# include <Efreet.h>
# include <Efreet_Mime.h>
# include <Efreet_Trash.h>
#endif

#ifdef EAPI
# undef EAPI
#endif

#ifdef _WIN32
# ifdef ELEMENTARY_BUILD
#  ifdef DLL_EXPORT
#   define EAPI __declspec(dllexport)
#  else
#   define EAPI
#  endif /* ! DLL_EXPORT */
# else
#  define EAPI __declspec(dllimport)
# endif /* ! EFL_EVAS_BUILD */
#else
# ifdef __GNUC__
#  if __GNUC__ >= 4
#   define EAPI __attribute__ ((visibility("default")))
#  else
#   define EAPI
#  endif
# else
#  define EAPI
# endif
#endif /* ! _WIN32 */


/* allow usage from c++ */
#ifdef __cplusplus
extern "C" {
#endif

/* handy macros */
#define ELM_RECTS_INTERSECT(x, y, w, h, xx, yy, ww, hh) (((x) < ((xx) + (ww))) && ((y) < ((yy) + (hh))) && (((x) + (w)) > (xx)) && (((y) + (h)) > (yy)))

/**************************************************************************/
   /* Objects */
   typedef enum _Elm_Win_Type
     {
	ELM_WIN_BASIC,
	ELM_WIN_DIALOG_BASIC,
	ELM_WIN_DESKTOP,
	ELM_WIN_DOCK,
	ELM_WIN_TOOLBAR,
	ELM_WIN_MENU,
	ELM_WIN_UTILITY,
	ELM_WIN_SPLASH
     } Elm_Win_Type;

   typedef enum _Elm_Win_Keyboard_Mode
     {
	ELM_WIN_KEYBOARD_UNKNOWN,
	  ELM_WIN_KEYBOARD_OFF,
	  ELM_WIN_KEYBOARD_ON,
	  ELM_WIN_KEYBOARD_ALPHA,
	  ELM_WIN_KEYBOARD_NUMERIC,
	  ELM_WIN_KEYBOARD_PIN,
	  ELM_WIN_KEYBOARD_PHONE_NUMBER,
	  ELM_WIN_KEYBOARD_HEX,
	  ELM_WIN_KEYBOARD_TERMINAL,
	  ELM_WIN_KEYBOARD_PASSWORD
     } Elm_Win_Keyboard_Mode;

#ifndef ELM_LIB_QUICKLAUNCH
#define ELM_MAIN() int main(int argc, char **argv) {elm_init(argc, argv); return elm_main(argc, argv);}
#else
#define ELM_MAIN() int main(int argc, char **argv) {return elm_quicklaunch_fallback(argc, argv);}
#endif

/**************************************************************************/
   /* General calls */
   EAPI void         elm_init(int argc, char **argv);
   EAPI void         elm_shutdown(void);
   EAPI void         elm_run(void);
   EAPI void         elm_exit(void);

   EAPI void         elm_quicklaunch_init(int argc, char **argv);
   EAPI void         elm_quicklaunch_sub_init(int argc, char **argv);
   EAPI void         elm_quicklaunch_sub_shutdown(void);
   EAPI void         elm_quicklaunch_shutdown(void);
   EAPI void         elm_quicklaunch_seed(void);
   EAPI Eina_Bool    elm_quicklaunch_prepare(int argc, char **argv);
   EAPI Eina_Bool    elm_quicklaunch_fork(int argc, char **argv, char *cwd, void (postfork_func) (void *data), void *postfork_data);
   EAPI void         elm_quicklaunch_cleanup(void);
   EAPI int          elm_quicklaunch_fallback(int argc, char **argv);
   EAPI char        *elm_quicklaunch_exe_path_get(const char *exe);

   EAPI void         elm_need_efreet(void);
   EAPI void         elm_need_e_dbus(void);

   EAPI void         elm_object_scale_set(Evas_Object *obj, double scale);
   EAPI double       elm_object_scale_get(const Evas_Object *obj);
   EAPI void         elm_object_style_set(Evas_Object *obj, const char *style);
   EAPI const char  *elm_object_style_get(const Evas_Object *obj);
   EAPI void         elm_object_disabled_set(Evas_Object *obj, Eina_Bool disabled);
   EAPI Eina_Bool    elm_object_disabled_get(const Evas_Object *obj);

   EAPI double       elm_scale_get(void);
   EAPI void         elm_scale_set(double scale);
   EAPI Evas_Coord   elm_finger_size_get(void);
   EAPI void         elm_finger_size_set(Evas_Coord size);

   EAPI void         elm_object_focus(Evas_Object *obj);

   EAPI void         elm_object_scroll_hold_push(Evas_Object *obj);
   EAPI void         elm_object_scroll_hold_pop(Evas_Object *obj);
   EAPI void         elm_object_scroll_freeze_push(Evas_Object *obj);
   EAPI void         elm_object_scroll_freeze_pop(Evas_Object *obj);

   EAPI void         elm_coords_finger_size_adjust(int times_w, Evas_Coord *w, int times_h, Evas_Coord *h);

   EAPI void         elm_theme_overlay_add(const char *item);
   EAPI void         elm_theme_extension_add(const char *item);

   EAPI Evas_Object *elm_win_add(Evas_Object *parent, const char *name, Elm_Win_Type type);
   EAPI void         elm_win_resize_object_add(Evas_Object *obj, Evas_Object *subobj);
   EAPI void         elm_win_resize_object_del(Evas_Object *obj, Evas_Object *subobj);
   EAPI void         elm_win_title_set(Evas_Object *obj, const char *title);
   EAPI void         elm_win_autodel_set(Evas_Object *obj, Eina_Bool autodel);
   EAPI void         elm_win_activate(Evas_Object *obj);
   EAPI void         elm_win_lower(Evas_Object *obj);
   EAPI void         elm_win_raise(Evas_Object *obj);
   EAPI void         elm_win_borderless_set(Evas_Object *obj, Eina_Bool borderless);
   EAPI void         elm_win_shaped_set(Evas_Object *obj, Eina_Bool shaped);
   EAPI void         elm_win_alpha_set(Evas_Object *obj, Eina_Bool alpha);
   EAPI void         elm_win_override_set(Evas_Object *obj, Eina_Bool override);
   EAPI void         elm_win_fullscreen_set(Evas_Object *obj, Eina_Bool fullscreen);
   EAPI void         elm_win_maximized_set(Evas_Object *obj, Eina_Bool maximized);
   EAPI void         elm_win_iconified_set(Evas_Object *obj, Eina_Bool iconified);
   EAPI void         elm_win_layer_set(Evas_Object *obj, int layer);
   EAPI void         elm_win_rotation_set(Evas_Object *obj, int rotation);
   EAPI void         elm_win_sticky_set(Evas_Object *obj, Eina_Bool sticky);

   /*...
    * ecore_x_icccm_hints_set -> accepts_focus (add to ecore_evas)
    * ecore_x_icccm_hints_set -> window_group (add to ecore_evas)
    * ecore_x_icccm_size_pos_hints_set -> request_pos (add to ecore_evas)
    * ecore_x_icccm_client_leader_set -> l (add to ecore_evas)
    * ecore_x_icccm_window_role_set -> role (add to ecore_evas)
    * ecore_x_icccm_transient_for_set -> forwin (add to ecore_evas)
    * ecore_x_netwm_window_type_set -> type (add to ecore_evas)
    *
    * (add to ecore_x) set netwm argb icon! (add to ecore_evas)
    * (blank mouse, private mouse obj, defaultmouse)
    *
    */
   EAPI void         elm_win_keyboard_mode_set(Evas_Object *obj, Elm_Win_Keyboard_Mode mode);
   EAPI void         elm_win_keyboard_win_set(Evas_Object *obj, Eina_Bool is_keyboard);

   EAPI Evas_Object *elm_win_inwin_add(Evas_Object *obj);
   EAPI void         elm_win_inwin_activate(Evas_Object *obj);
   EAPI void         elm_win_inwin_style_set(Evas_Object *obj, const char *style);
   EAPI void         elm_win_inwin_content_set(Evas_Object *obj, Evas_Object *content);
   /* available styles:
    * default
    * minimal
    * minimal_vertical
    */

   /* X specific calls - won't work on non-x engines (return 0) */
   EAPI Ecore_X_Window elm_win_xwindow_get(const Evas_Object *obj);
   /* smart callbacks called:
    * "delete-request" - the user requested to delete the window
    * "focus-in" - window got focus
    * "focus-out" - window lost focus
    */

   EAPI Evas_Object *elm_bg_add(Evas_Object *parent);
   EAPI void         elm_bg_file_set(Evas_Object *obj, const char *file, const char *group);
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_icon_add(Evas_Object *parent);
   EAPI Eina_Bool    elm_icon_file_set(Evas_Object *obj, const char *file, const char *group);
   EAPI void         elm_icon_standard_set(Evas_Object *obj, const char *name);
   EAPI void         elm_icon_smooth_set(Evas_Object *obj, Eina_Bool smooth);
   EAPI void         elm_icon_no_scale_set(Evas_Object *obj, Eina_Bool no_scale);
   EAPI void         elm_icon_scale_set(Evas_Object *obj, Eina_Bool scale_up, Eina_Bool scale_down);
   EAPI void         elm_icon_fill_outside_set(Evas_Object *obj, Eina_Bool fill_outside);
   EAPI void         elm_icon_prescale_set(Evas_Object *obj, int size);
   /* smart callbacks called:
    * "clicked" - the user clicked the icon
    */

   typedef enum _Elm_Image_Orient
     {
	ELM_IMAGE_ORIENT_NONE,
	ELM_IMAGE_ROTATE_90_CW,
	ELM_IMAGE_ROTATE_180_CW,
	ELM_IMAGE_ROTATE_90_CCW,
	ELM_IMAGE_FLIP_HORIZONTAL,
	ELM_IMAGE_FLIP_VERTICAL,
	ELM_IMAGE_FLIP_TRANSPOSE,
	ELM_IMAGE_FLIP_TRANSVERSE
     } Elm_Image_Orient;

   EAPI Evas_Object *elm_image_add(Evas_Object *parent);
   EAPI Eina_Bool    elm_image_file_set(Evas_Object *obj, const char *file, const char *group);
   EAPI void         elm_image_smooth_set(Evas_Object *obj, Eina_Bool smooth);
   EAPI void         elm_image_no_scale_set(Evas_Object *obj, Eina_Bool no_scale);
   EAPI void         elm_image_object_size_get(const Evas_Object *obj, int *w, int *h);
   EAPI void         elm_image_scale_set(Evas_Object *obj, Eina_Bool scale_up, Eina_Bool scale_down);
   EAPI void         elm_image_fill_outside_set(Evas_Object *obj, Eina_Bool fill_outside);
   EAPI void         elm_image_prescale_set(Evas_Object *obj, int size);
   EAPI void         elm_image_orient_set(Evas_Object *obj, Elm_Image_Orient orient);
   /* smart callbacks called:
    * "clicked" - the user clicked the image
    */

   EAPI Evas_Object *elm_box_add(Evas_Object *parent);
   EAPI void         elm_box_horizontal_set(Evas_Object *obj, Eina_Bool horizontal);
   EAPI void         elm_box_homogenous_set(Evas_Object *obj, Eina_Bool homogenous);
   EAPI void         elm_box_pack_start(Evas_Object *obj, Evas_Object *subobj);
   EAPI void         elm_box_pack_end(Evas_Object *obj, Evas_Object *subobj);
   EAPI void         elm_box_pack_before(Evas_Object *obj, Evas_Object *subobj, Evas_Object *before);
   EAPI void         elm_box_pack_after(Evas_Object *obj, Evas_Object *subobj, Evas_Object *after);
   EAPI void         elm_box_clear(Evas_Object *obj);
   EAPI void         elm_box_unpack(Evas_Object *obj, Evas_Object *subobj);
   EAPI void         elm_box_unpack_all(Evas_Object *obj);
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_button_add(Evas_Object *parent);
   EAPI void         elm_button_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_button_label_get(Evas_Object *obj);
   EAPI void         elm_button_icon_set(Evas_Object *obj, Evas_Object *icon);
   EAPI Evas_Object *elm_button_icon_get(Evas_Object *obj);
   EAPI void         elm_button_style_set(Evas_Object *obj, const char *style);
   /* available styles:
    * default
    * hoversel_vertical
    * hoversel_vertical_entry
    */
   /* smart callbacks called:
    * "clicked" - the user clicked the button
    */

   typedef enum _Elm_Scroller_Policy
     {
	ELM_SCROLLER_POLICY_AUTO,
	  ELM_SCROLLER_POLICY_ON,
	  ELM_SCROLLER_POLICY_OFF
     }
   Elm_Scroller_Policy;

   EAPI Evas_Object *elm_scroller_add(Evas_Object *parent);
   EAPI void         elm_scroller_content_set(Evas_Object *obj, Evas_Object *child);
   EAPI void         elm_scroller_content_min_limit(Evas_Object *obj, Eina_Bool w, Eina_Bool h);
   EAPI void         elm_scroller_region_show(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h);
   EAPI void         elm_scroller_policy_set(Evas_Object *obj, Elm_Scroller_Policy policy_h, Elm_Scroller_Policy policy_v);
   EAPI void         elm_scroller_region_get(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h);
   EAPI void         elm_scroller_child_size_get(Evas_Object *obj, Evas_Coord *w, Evas_Coord *h);
   EAPI void         elm_scroller_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce);
   EAPI void         elm_scroller_page_relative_set(Evas_Object *obj, double h_pagerel, double v_pagerel);
   EAPI void         elm_scroller_page_size_set(Evas_Object *obj, Evas_Coord h_pagesize, Evas_Coord v_pagesize);
   EAPI void         elm_scroller_region_bring_in(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h);
   /* smart callbacks called:
    * "edge_left"
    * "edge_right"
    * "edge_top"
    * "edge_bottom"
    * "scroll"
    * "scroll_anim_start"
    * "scroll_anim_stop"
    * "scroll_drag_start"
    * "scroll_drag_stop"
    */

   EAPI Evas_Object *elm_label_add(Evas_Object *parent);
   EAPI void         elm_label_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_label_label_get(Evas_Object *obj);
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_toggle_add(Evas_Object *parent);
   EAPI void         elm_toggle_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_toggle_label_get(Evas_Object *obj);
   EAPI void         elm_toggle_icon_set(Evas_Object *obj, Evas_Object *icon);
   EAPI Evas_Object *elm_toggle_icon_get(Evas_Object *obj);
   EAPI void         elm_toggle_states_labels_set(Evas_Object *obj, const char *onlabel, const char *offlabel);
   EAPI void         elm_toggle_state_set(Evas_Object *obj, Eina_Bool state);
   EAPI Eina_Bool    elm_toggle_state_get(const Evas_Object *obj);
   EAPI void         elm_toggle_state_pointer_set(Evas_Object *obj, Eina_Bool *statep);
   /* smart callbacks called:
    * "changed" - the user toggled the state
    */

   EAPI Evas_Object *elm_frame_add(Evas_Object *parent);
   EAPI void         elm_frame_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_frame_label_get(Evas_Object *obj);
   EAPI void         elm_frame_content_set(Evas_Object *obj, Evas_Object *content);
   EAPI void         elm_frame_style_set(Evas_Object *obj, const char *style);
   /* available styles:
    * default
    * pad_small
    * pad_medium
    * pad_large
    * pad_huge
    * outdent_top
    * outdent_bottom
    */
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_table_add(Evas_Object *parent);
   EAPI void         elm_table_homogenous_set(Evas_Object *obj, Eina_Bool homogenous);
   EAPI void         elm_table_pack(Evas_Object *obj, Evas_Object *subobj, int x, int y, int w, int h);
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_clock_add(Evas_Object *parent);
   EAPI void         elm_clock_time_set(Evas_Object *obj, int hrs, int min, int sec);
   EAPI void         elm_clock_time_get(const Evas_Object *obj, int *hrs, int *min, int *sec);
   EAPI void         elm_clock_edit_set(Evas_Object *obj, Eina_Bool edit);
   EAPI void         elm_clock_show_am_pm_set(Evas_Object *obj, Eina_Bool am_pm);
   EAPI void         elm_clock_show_seconds_set(Evas_Object *obj, Eina_Bool seconds);
   /* smart callbacks called:
    * "changed" - the user changed the time
    */

   EAPI Evas_Object *elm_layout_add(Evas_Object *parent);
   EAPI Eina_Bool    elm_layout_file_set(Evas_Object *obj, const char *file, const char *group);
   EAPI void         elm_layout_content_set(Evas_Object *obj, const char *swallow, Evas_Object *content);
   EAPI Evas_Object *elm_layout_edje_get(const Evas_Object *obj);
   /* smart callbacks called:
    */

   typedef enum _Elm_Notify_Orient
     {
	 ELM_NOTIFY_ORIENT_TOP,
	 ELM_NOTIFY_ORIENT_BOTTOM,
	 ELM_NOTIFY_ORIENT_LEFT,
	 ELM_NOTIFY_ORIENT_RIGHT,
	 ELM_NOTIFY_ORIENT_TOP_LEFT,
	 ELM_NOTIFY_ORIENT_TOP_RIGHT,
	 ELM_NOTIFY_ORIENT_BOTTOM_LEFT,
	 ELM_NOTIFY_ORIENT_BOTTOM_RIGHT
     } Elm_Notify_Orient;
   EAPI Evas_Object *elm_notify_add(Evas_Object *parent);
   EAPI void         elm_notify_content_set(Evas_Object *obj, Evas_Object *content);
   EAPI void	     elm_notify_orient_set(Evas_Object *obj, Elm_Notify_Orient orient);
   EAPI void         elm_notify_timeout_set(Evas_Object *obj, int timeout);
   EAPI void	     elm_notify_timer_init(Evas_Object *obj);
   /* smart callbacks called:
    */


   typedef enum _Elm_Hover_Axis
     {
	ELM_HOVER_AXIS_NONE,
	  ELM_HOVER_AXIS_HORIZONTAL,
	  ELM_HOVER_AXIS_VERTICAL,
	  ELM_HOVER_AXIS_BOTH
     } Elm_Hover_Axis;
   EAPI Evas_Object *elm_hover_add(Evas_Object *parent);
   EAPI void         elm_hover_target_set(Evas_Object *obj, Evas_Object *target);
   EAPI void         elm_hover_parent_set(Evas_Object *obj, Evas_Object *parent);
   EAPI void         elm_hover_content_set(Evas_Object *obj, const char *swallow, Evas_Object *content);
   EAPI void         elm_hover_style_set(Evas_Object *obj, const char *style);
   EAPI const char  *elm_hover_best_content_location_get(const Evas_Object *obj, Elm_Hover_Axis pref_axis);
   /* available styles:
    * default
    * popout
    * hoversel_vertical
    */
   /* smart callbacks called:
    * "clicked" - the user clicked the empty space in the hover to dismiss
    */

   typedef struct _Elm_Entry_Anchor_Info Elm_Entry_Anchor_Info;
   struct _Elm_Entry_Anchor_Info
     {
	const char *name;
	int button;
	Evas_Coord x, y, w, h;
     };
   typedef enum _Elm_Icon_Type
     {
	ELM_ICON_NONE,
	  ELM_ICON_FILE,
	  ELM_ICON_STANDARD
     } Elm_Icon_Type;
   typedef struct _Elm_Hoversel_Item Elm_Hoversel_Item;
   EAPI Evas_Object *elm_entry_add(Evas_Object *parent);
   EAPI void         elm_entry_single_line_set(Evas_Object *obj, Eina_Bool single_line);
   EAPI void         elm_entry_password_set(Evas_Object *obj, Eina_Bool password);
   EAPI void         elm_entry_entry_set(Evas_Object *obj, const char *entry);
   EAPI const char  *elm_entry_entry_get(const Evas_Object *obj);
   EAPI const char  *elm_entry_selection_get(const Evas_Object *obj);
   EAPI void         elm_entry_entry_insert(Evas_Object *obj, const char *entry);
   EAPI void         elm_entry_line_wrap_set(Evas_Object *obj, Eina_Bool wrap);
   EAPI void         elm_entry_editable_set(Evas_Object *obj, Eina_Bool editable);
   EAPI void         elm_entry_select_none(Evas_Object *obj);
   EAPI void         elm_entry_select_all(Evas_Object *obj);
   EAPI void         elm_entry_context_menu_clear(Evas_Object *obj);
   EAPI void         elm_entry_context_menu_item_add(Evas_Object *obj, const char *label, const char *icon_file, Elm_Icon_Type icon_type, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
   EAPI char        *elm_entry_markup_to_utf8(const char *s);
   EAPI char        *elm_entry_utf8_to_markup(const char *s);

   /* smart callbacks called:
    * "changed" - the text content changed
    * "selection,start" - the user started selecting text
    * "selection,changed" - the user modified the selection size/location
    * "selection,cleared" - the user cleared the selection
    * "selection,paste" - the user rrequested a paste of text
    * "selection,copy" - the user copied the text
    * "selection,cut" - the user cut the text
    * "cursor,changed" - the cursor changed position
    * "anchor,clicked" - achor called was clicked | event_info = Elm_Entry_Anchor_Info
    * "activated" - when the enter key is pressed (useful for single line)
    */

   /* composite widgets - these basically put together basic widgets above
    * in convenient packages that do more than basic stuff */

   typedef enum _Elm_Text_Format
     {
	ELM_TEXT_FORMAT_PLAIN_UTF8,
	ELM_TEXT_FORMAT_MARKUP_UTF8
     } Elm_Text_Format;
   EAPI Evas_Object *elm_notepad_add(Evas_Object *parent);
   EAPI void         elm_notepad_file_set(Evas_Object *obj, const char *file, Elm_Text_Format format);
   /* smart callbacks called:
    */

   typedef struct _Elm_Entry_Anchorview_Info Elm_Entry_Anchorview_Info;
   struct _Elm_Entry_Anchorview_Info
     {
	const char *name;
	int button;
	Evas_Object *hover;
	struct {
	   Evas_Coord x, y, w, h;
	} anchor, hover_parent;
	Eina_Bool hover_left : 1;
	Eina_Bool hover_right : 1;
	Eina_Bool hover_top : 1;
	Eina_Bool hover_bottom : 1;
     };
   EAPI Evas_Object *elm_anchorview_add(Evas_Object *parent);
   EAPI void         elm_anchorview_text_set(Evas_Object *obj, const char *text);
   EAPI void         elm_anchorview_hover_parent_set(Evas_Object *obj, Evas_Object *parent);
   EAPI void         elm_anchorview_hover_style_set(Evas_Object *obj, const char *style);
   EAPI void         elm_anchorview_hover_end(Evas_Object *obj);
   /* smart callbacks called:
    * "anchor,clicked" - achor called was clicked | event_info = Elm_Entry_Anchorview_Info
    */

   typedef struct _Elm_Entry_Anchorblock_Info Elm_Entry_Anchorblock_Info;
   struct _Elm_Entry_Anchorblock_Info
     {
	const char *name;
	int button;
	Evas_Object *hover;
	struct {
	   Evas_Coord x, y, w, h;
	} anchor, hover_parent;
	Eina_Bool hover_left : 1;
	Eina_Bool hover_right : 1;
	Eina_Bool hover_top : 1;
	Eina_Bool hover_bottom : 1;
     };
   EAPI Evas_Object *elm_anchorblock_add(Evas_Object *parent);
   EAPI void         elm_anchorblock_text_set(Evas_Object *obj, const char *text);
   EAPI void         elm_anchorblock_hover_parent_set(Evas_Object *obj, Evas_Object *parent);
   EAPI void         elm_anchorblock_hover_style_set(Evas_Object *obj, const char *style);
   EAPI void         elm_anchorblock_hover_end(Evas_Object *obj);
   /* smart callbacks called:
    * "anchor,clicked" - achor called was clicked | event_info = Elm_Entry_Anchorblock_Info
    */

   EAPI Evas_Object *elm_bubble_add(Evas_Object *parent);
   EAPI void         elm_bubble_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_bubble_label_get(Evas_Object *obj);
   EAPI void         elm_bubble_info_set(Evas_Object *obj, const char *info);
   EAPI void         elm_bubble_content_set(Evas_Object *obj, Evas_Object *content);
   EAPI void         elm_bubble_icon_set(Evas_Object *obj, Evas_Object *icon);
   EAPI Evas_Object *elm_bubble_icon_get(Evas_Object *obj);
   EAPI void         elm_bubble_corner_set(Evas_Object *obj, const char *corner);
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_photo_add(Evas_Object *parent);
   EAPI Eina_Bool    elm_photo_file_set(Evas_Object *obj, const char *file);
   EAPI void         elm_photo_size_set(Evas_Object *obj, int size);
   /* smart callbacks called:
    * "clicked" - the user clicked the icon
    */

   EAPI Evas_Object *elm_hoversel_add(Evas_Object *parent);
   EAPI void         elm_hoversel_hover_parent_set(Evas_Object *obj, Evas_Object *parent);
   EAPI void         elm_hoversel_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_hoversel_label_get(Evas_Object *obj);
   EAPI void         elm_hoversel_icon_set(Evas_Object *obj, Evas_Object *icon);
   EAPI Evas_Object *elm_hoversel_icon_get(Evas_Object *obj);
   EAPI void         elm_hoversel_hover_begin(Evas_Object *obj);
   EAPI void         elm_hoversel_hover_end(Evas_Object *obj);
   EAPI void         elm_hoversel_clear(Evas_Object *obj);
   EAPI Elm_Hoversel_Item *elm_hoversel_item_add(Evas_Object *obj, const char *label, const char *icon_file, Elm_Icon_Type icon_type, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
   EAPI void         elm_hoversel_item_del(Elm_Hoversel_Item *item);
   EAPI void        *elm_hoversel_item_data_get(Elm_Hoversel_Item *it);
   EAPI const char  *elm_hoversel_item_label_get(Elm_Hoversel_Item *it);
   EAPI void         elm_hoversel_item_icon_set(Elm_Hoversel_Item *it, const char *icon_file, const char *icon_group, Elm_Icon_Type icon_type);
   EAPI void         elm_hoversel_item_icon_get(Elm_Hoversel_Item *it, const char **icon_file, const char **icon_group, Elm_Icon_Type *icon_type);
   /* smart callbacks called:
    * "clicked" - the user clicked the hoversel button and popped up the sel
    * "selected" - an item in the hoversel list is selected
    * "dismissed" - the hover is dismissed
    */

   typedef struct _Elm_Toolbar_Item Elm_Toolbar_Item;
   EAPI Evas_Object *elm_toolbar_add(Evas_Object *parent);
   EAPI void        elm_toolbar_icon_size_set(Evas_Object *obj, int icon_size);
   EAPI int         elm_toolbar_icon_size_get(Evas_Object *obj);
   EAPI Elm_Toolbar_Item *elm_toolbar_item_add(Evas_Object *obj, Evas_Object *icon, const char *label, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
   EAPI Evas_Object *elm_toolbar_item_icon_get(Elm_Toolbar_Item *item);
   EAPI const char  *elm_toolbar_item_label_get(Elm_Toolbar_Item *item);
   EAPI void         elm_toolbar_item_label_set(Elm_Toolbar_Item *item, const char *label);
   EAPI void         elm_toolbar_item_del(Elm_Toolbar_Item *item);
   EAPI void         elm_toolbar_item_select(Elm_Toolbar_Item *item);
   EAPI Eina_Bool    elm_toolbar_item_disabled_get(Elm_Toolbar_Item *item);
   EAPI void         elm_toolbar_item_disabled_set(Elm_Toolbar_Item *item, Eina_Bool disabled);
   EAPI void         elm_toolbar_item_separator_set(Elm_Toolbar_Item *item, Eina_Bool separator);
   EAPI Eina_Bool    elm_toolbar_item_separator_get(Elm_Toolbar_Item *item);
   EAPI void         elm_toolbar_scrollable_set(Evas_Object *obj, Eina_Bool scrollable);
   /* smart callbacks called:
    * "clicked" - when the user clicks on a toolbar item and becomes selected
    */

   typedef enum _Elm_List_Mode
     {
	ELM_LIST_COMPRESS,
	ELM_LIST_SCROLL,
	ELM_LIST_LIMIT
     } Elm_List_Mode;
   typedef struct _Elm_List_Item Elm_List_Item;
   EAPI Evas_Object *elm_list_add(Evas_Object *parent);
   EAPI Elm_List_Item *elm_list_item_append(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Object *end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
   EAPI Elm_List_Item *elm_list_item_prepend(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Object *end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
   EAPI Elm_List_Item *elm_list_item_insert_before(Evas_Object *obj, Elm_List_Item *before, const char *label, Evas_Object *icon, Evas_Object *end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
   EAPI Elm_List_Item *elm_list_item_insert_after(Evas_Object *obj, Elm_List_Item *after, const char *label, Evas_Object *icon, Evas_Object *end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
   EAPI void         elm_list_clear(Evas_Object *obj);
   EAPI void         elm_list_go(Evas_Object *obj);
   EAPI void         elm_list_multi_select_set(Evas_Object *obj, Eina_Bool multi);
   EAPI void         elm_list_horizontal_mode_set(Evas_Object *obj, Elm_List_Mode mode);
   EAPI void         elm_list_always_select_mode_set(Evas_Object *obj, Eina_Bool always_select);
   EAPI const Eina_List     *elm_list_items_get(const Evas_Object *obj);
   EAPI Elm_List_Item       *elm_list_selected_item_get(const Evas_Object *obj);
   EAPI const Eina_List     *elm_list_selected_items_get(const Evas_Object *obj);
   EAPI void         elm_list_item_selected_set(Elm_List_Item *item, Eina_Bool selected);
   EAPI void         elm_list_item_show(Elm_List_Item *item);
   EAPI void         elm_list_item_del(Elm_List_Item *item);
   EAPI void         elm_list_item_del_cb_set(Elm_List_Item *item, void (*func)(void *data, Evas_Object *obj, void *event_info));
   EAPI void        *elm_list_item_data_get(const Elm_List_Item *item);
   EAPI Evas_Object *elm_list_item_icon_get(const Elm_List_Item *item);
   EAPI void         elm_list_item_icon_set(Elm_List_Item *item, Evas_Object *icon);
   EAPI Evas_Object *elm_list_item_end_get(const Elm_List_Item *item);
   EAPI void         elm_list_item_end_set(Elm_List_Item *item, Evas_Object *end);
   EAPI Evas_Object *elm_list_item_base_get(const Elm_List_Item *item);
   EAPI const char  *elm_list_item_label_get(const Elm_List_Item *item);
   EAPI void         elm_list_item_label_set(Elm_List_Item *item, const char *text);
   EAPI Elm_List_Item *elm_list_item_prev(const Elm_List_Item *it);
   EAPI Elm_List_Item *elm_list_item_next(const Elm_List_Item *it);

   /* smart callbacks called:
    * "clicked" - when the user double-clicked an item
    * "selected" - when the user selected an item
    * "unselected" - when the user selected an item
    * "longpressed" - an item in the hoversel list is long-pressed
    */

   // FIXME: incomplete - carousel
   typedef struct _Elm_Carousel_Item Elm_Carousel_Item;
   EAPI Evas_Object *elm_carousel_add(Evas_Object *parent);
   EAPI Elm_Carousel_Item *elm_carousel_item_add(Evas_Object *obj, Evas_Object *icon, const char *label, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
   EAPI void         elm_carousel_item_del(Elm_Carousel_Item *item);
   EAPI void         elm_carousel_item_select(Elm_Carousel_Item *item);
   /* smart callbacks called:
    * "clicked" - when the user clicks on a carousel item and becomes selected
    */

   EAPI Evas_Object *elm_slider_add(Evas_Object *parent);
   EAPI void         elm_slider_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_slider_label_get(Evas_Object *obj);
   EAPI void         elm_slider_icon_set(Evas_Object *obj, Evas_Object *icon);
   EAPI Evas_Object *elm_slider_icon_get(Evas_Object *obj);
   EAPI void         elm_slider_span_size_set(Evas_Object *obj, Evas_Coord size);
   EAPI void         elm_slider_unit_format_set(Evas_Object *obj, const char *format);
   EAPI void         elm_slider_indicator_format_set(Evas_Object *obj, const char *indicator);
   EAPI void         elm_slider_horizontal_set(Evas_Object *obj, Eina_Bool horizontal);
   EAPI void         elm_slider_min_max_set(Evas_Object *obj, double min, double max);
   EAPI void         elm_slider_value_set(Evas_Object *obj, double val);
   EAPI double       elm_slider_value_get(const Evas_Object *obj);
   EAPI void         elm_slider_inverted_set(Evas_Object *obj, Eina_Bool inverted);
   /* smart callbacks called:
    * "changed" - when the slider value changes
    * "delay,changed" - when the slider value changed, but a small time after a change (use this if you only want to respond to a change once the slider is held still for a short while).
    */

   typedef enum _Elm_Genlist_Item_Flags
     {
	ELM_GENLIST_ITEM_NONE = 0,
	ELM_GENLIST_ITEM_SUBITEMS = (1 << 0)
     } Elm_Genlist_Item_Flags;
   typedef struct _Elm_Genlist_Item_Class Elm_Genlist_Item_Class;
   typedef struct _Elm_Genlist_Item       Elm_Genlist_Item;
   typedef struct _Elm_Genlist_Item_Class_Func Elm_Genlist_Item_Class_Func;
   typedef char        *(*GenlistItemLabelGetFunc) (const void *data, Evas_Object *obj, const char *part);
   typedef Evas_Object *(*GenlistItemIconGetFunc)  (const void *data, Evas_Object *obj, const char *part);
   typedef Eina_Bool    (*GenlistItemStateGetFunc) (const void *data, Evas_Object *obj, const char *part);
   typedef void         (*GenlistItemDelFunc)      (const void *data, Evas_Object *obj);

   struct _Elm_Genlist_Item_Class
     {
	const char *item_style;
	struct _Elm_Genlist_Item_Class_Func {
	   GenlistItemLabelGetFunc label_get;
	   GenlistItemIconGetFunc icon_get;
	   GenlistItemStateGetFunc state_get;
	   GenlistItemDelFunc del;
	} func;
     };

   EAPI Evas_Object      *elm_genlist_add(Evas_Object *parent);
   EAPI Elm_Genlist_Item *elm_genlist_item_append(Evas_Object *obj, const Elm_Genlist_Item_Class *itc, const void *data, Elm_Genlist_Item *parent, Elm_Genlist_Item_Flags flags, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *func_data);
   EAPI Elm_Genlist_Item *elm_genlist_item_prepend(Evas_Object *obj, const Elm_Genlist_Item_Class *itc, const void *data, Elm_Genlist_Item *parent, Elm_Genlist_Item_Flags flags, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *func_data);
   EAPI Elm_Genlist_Item *elm_genlist_item_insert_before(Evas_Object *obj, const Elm_Genlist_Item_Class *itc, const void *data, Elm_Genlist_Item *before, Elm_Genlist_Item_Flags flags, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *func_data);
   EAPI Elm_Genlist_Item *elm_genlist_item_insert_after(Evas_Object *obj, const Elm_Genlist_Item_Class *itc, const void *data, Elm_Genlist_Item *after, Elm_Genlist_Item_Flags flags, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *func_data);
   EAPI void              elm_genlist_clear(Evas_Object *obj);
   EAPI void              elm_genlist_multi_select_set(Evas_Object *obj, Eina_Bool multi);
   EAPI Elm_Genlist_Item *elm_genlist_selected_item_get(const Evas_Object *obj);
   EAPI const Eina_List  *elm_genlist_selected_items_get(const Evas_Object *obj);
   EAPI Elm_Genlist_Item *elm_genlist_at_xy_item_get(const Evas_Object *obj, Evas_Coord x, Evas_Coord y, int *posret);
   EAPI Elm_Genlist_Item *elm_genlist_first_item_get(const Evas_Object *obj);
   EAPI Elm_Genlist_Item *elm_genlist_last_item_get(const Evas_Object *obj);
   EAPI Elm_Genlist_Item *elm_genlist_item_next_get(const Elm_Genlist_Item *item);
   EAPI Elm_Genlist_Item *elm_genlist_item_prev_get(const Elm_Genlist_Item *item);
   EAPI Evas_Object      *elm_genlist_item_genlist_get(const Elm_Genlist_Item *item);
   EAPI Elm_Genlist_Item *elm_genlist_item_parent_get(const Elm_Genlist_Item *it);
   EAPI void              elm_genlist_item_subitems_clear(Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_selected_set(Elm_Genlist_Item *item, Eina_Bool selected);
   EAPI Eina_Bool         elm_genlist_item_selected_get(const Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_expanded_set(Elm_Genlist_Item *item, Eina_Bool expanded);
   EAPI Eina_Bool         elm_genlist_item_expanded_get(const Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_disabled_set(Elm_Genlist_Item *item, Eina_Bool disabled);
   EAPI Eina_Bool         elm_genlist_item_disabled_get(const Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_show(Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_bring_in(Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_top_show(Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_top_bring_in(Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_del(Elm_Genlist_Item *item);
   EAPI const void       *elm_genlist_item_data_get(const Elm_Genlist_Item *item);
   EAPI void              elm_genlist_item_data_set(Elm_Genlist_Item *it, const void *data);
   EAPI const Evas_Object *elm_genlist_item_object_get(const Elm_Genlist_Item *it);
   EAPI void              elm_genlist_item_update(Elm_Genlist_Item *item);
   EAPI void              elm_genlist_horizontal_mode_set(Evas_Object *obj, Elm_List_Mode mode);
   EAPI void              elm_genlist_always_select_mode_set(Evas_Object *obj, Eina_Bool always_select);
   EAPI void              elm_genlist_no_select_mode_set(Evas_Object *obj, Eina_Bool no_select);
   /* available item styles:
    * default
    * double_label
    * icon_top_text_bottom
    */
   /* smart callbacks called:
    * "clicked" - when the user double-clicked an item
    * "selected" - when the user selected an item
    * "unselected" - when the user selected an item
    * "longpressed" - an item in the hoversel list is long-pressed
    * "expanded" - when the user expanded an item
    * "contracted" - when the user contracted an item
    * "expand,request" - when the user requested to expand an item
    * "contract,request" - when the user requested to expand an item
    */

   EAPI Evas_Object *elm_check_add(Evas_Object *parent);
   EAPI void         elm_check_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_check_label_get(Evas_Object *obj);
   EAPI void         elm_check_icon_set(Evas_Object *obj, Evas_Object *icon);
   EAPI Evas_Object *elm_check_icon_get(Evas_Object *obj);
   EAPI void         elm_check_state_set(Evas_Object *obj, Eina_Bool state);
   EAPI Eina_Bool    elm_check_state_get(const Evas_Object *obj);
   EAPI void         elm_check_state_pointer_set(Evas_Object *obj, Eina_Bool *statep);
   /* smart callbacks called:
    * "changed" - the user toggled the state
    */

   EAPI Evas_Object *elm_radio_add(Evas_Object *parent);
   EAPI void         elm_radio_label_set(Evas_Object *obj, const char *label);
   EAPI const char  *elm_radio_label_get(Evas_Object *obj);
   EAPI void         elm_radio_icon_set(Evas_Object *obj, Evas_Object *icon);
   EAPI Evas_Object *elm_radio_icon_get(Evas_Object *obj);
   EAPI void         elm_radio_group_add(Evas_Object *obj, Evas_Object *group);
   EAPI void         elm_radio_state_value_set(Evas_Object *obj, int value);
   EAPI void         elm_radio_value_set(Evas_Object *obj, int value);
   EAPI int          elm_radio_value_get(const Evas_Object *obj);
   EAPI void         elm_radio_value_pointer_set(Evas_Object *obj, int *valuep);
   /* smart callbacks called:
    * "changed" - the user toggled the state
    */

   EAPI Evas_Object *elm_pager_add(Evas_Object *parent);
   EAPI void         elm_pager_content_push(Evas_Object *obj, Evas_Object *content);
   EAPI void         elm_pager_content_pop(Evas_Object *obj);
   EAPI void         elm_pager_content_promote(Evas_Object *obj, Evas_Object *content);
   EAPI Evas_Object *elm_pager_content_bottom_get(Evas_Object *obj);
   EAPI Evas_Object *elm_pager_content_top_get(Evas_Object *obj);
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_slideshow_add(Evas_Object *parent);
   EAPI void         elm_slideshow_image_add(Evas_Object *obj, const char *file, const char *group);
   EAPI void	     elm_slideshow_goto(Evas_Object *obj, int pos);
   EAPI void	     elm_slideshow_next(Evas_Object *obj);
   EAPI void	     elm_slideshow_previous(Evas_Object *obj);
   EAPI const Eina_List *elm_slideshow_transitions_get(Evas_Object *obj);
   EAPI void	     elm_slideshow_transition_set(Evas_Object *obj, const char *);
   EAPI void         elm_slideshow_timeout_set(Evas_Object *obj ,int timeout);
   EAPI int          elm_slideshow_timeout_get(Evas_Object *obj);
   EAPI void	     elm_slideshow_loop_set(Evas_Object *obj, int loop);
   EAPI void         elm_slideshow_clear(Evas_Object *obj);
   /* smart callbacks called:
    * "clicked" - the use click on the widget
    * "move" - the mouse move on the widget)
    */


   EAPI Evas_Object *elm_fileselector_add(Evas_Object *parent);
   EAPI void         elm_fileselector_is_save_set(Evas_Object *obj, Eina_Bool is_save);
   EAPI Eina_Bool    elm_fileselector_is_save_get(Evas_Object *obj);
   EAPI void         elm_fileselector_expandable_set(Evas_Object *obj, Eina_Bool expand);
   EAPI void         elm_fileselector_path_set(Evas_Object *obj, const char *path);
   EAPI const char  *elm_fileselector_path_get(Evas_Object *obj);
   EAPI const char  *elm_fileselector_selected_get(Evas_Object *obj);
   /* smart callbacks called:
    * "selected" - the user click on a file
    * "done" - the user click on the ok or cancel buttons
    */

   EAPI Evas_Object *elm_progressbar_add(Evas_Object *parent);
   EAPI void         elm_progressbar_label_set(Evas_Object *obj, const char *label);
   EAPI void         elm_progressbar_icon_set(Evas_Object *obj, Evas_Object *icon);
   EAPI void         elm_progressbar_span_size_set(Evas_Object *obj, Evas_Coord size);
   EAPI void         elm_progressbar_horizontal_set(Evas_Object *obj, Eina_Bool horizontal);
   EAPI void         elm_progressbar_inverted_set(Evas_Object *obj, Eina_Bool inverted);
   EAPI void         elm_progressbar_pulse_set(Evas_Object *obj, Eina_Bool pulse);
   EAPI void         elm_progressbar_pulse(Evas_Object *obj, Eina_Bool state);
   EAPI void         elm_progressbar_unit_format_set(Evas_Object *obj, const char *format);
   EAPI void         elm_progressbar_value_set(Evas_Object *obj, double val);
   EAPI double       elm_progressbar_value_get(const Evas_Object *obj);
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_separator_add(Evas_Object *parent);
   EAPI void         elm_separator_horizontal_set(Evas_Object *obj, Eina_Bool horizontal);
   EAPI Eina_Bool    elm_separator_horizontal_get(Evas_Object *obj);
   /* smart callbacks called:
    */

   EAPI Evas_Object *elm_spinner_add(Evas_Object *parent);
   EAPI void	     elm_spinner_label_format_set(Evas_Object *obj, const char *fmt);
   EAPI const char  *elm_spinner_label_format_get(Evas_Object *obj);
   EAPI void         elm_spinner_min_max_set(Evas_Object *obj, double min, double max);
   EAPI void	     elm_spinner_step_set(Evas_Object *obj, double step);
   EAPI void	     elm_spinner_value_set(Evas_Object *obj, double val);
   EAPI double	     elm_spinner_value_get(const Evas_Object *obj);
   EAPI void         elm_spinner_wrap_set(Evas_Object *obj, Eina_Bool wrap);
   /* smart callbacks called:
    * "changed" - when the spinner value changes
    * "delay,changed" - when the spinner value changed, but a small time after a change (use this if you only want to respond to a change once the spinner is held still for a short while).
    */

   EAPI Evas_Object *elm_index_add(Evas_Object *parent);
   EAPI void         elm_index_active_set(Evas_Object *obj, Eina_Bool active);
   EAPI void         elm_index_item_level_set(Evas_Object *obj, int level);
   EAPI int          elm_index_item_level_get(Evas_Object *obj);
   EAPI const void  *elm_index_item_selected_get(Evas_Object *obj, int level);
   EAPI void         elm_index_item_append(Evas_Object *obj, const char *letter, const void *item);
   EAPI void         elm_index_item_prepend(Evas_Object *obj, const char *letter, const void *item);
   EAPI void         elm_index_item_append_relative(Evas_Object *obj, const char *letter, const void *item, const void *relative);
   EAPI void         elm_index_item_prepend_relative(Evas_Object *obj, const char *letter, const void *item, const void *relative);
   EAPI void         elm_index_item_del(Evas_Object *obj, const void *item);
   EAPI void         elm_index_item_clear(Evas_Object *obj);
   EAPI void         elm_index_item_go(Evas_Object *obj, int level);
   /* smart callbacks called:
    * "changed" - when the selected index item changes
    * "delay,changed" - when the selected index item changes, but after some small idle period
    * "selected" - when the user releases heir finger and selects an item
    */

   typedef enum _Elm_Photocam_Zoom_Mode
     {
	ELM_PHOTOCAM_ZOOM_MODE_MANUAL,
	ELM_PHOTOCAM_ZOOM_MODE_AUTO_FIT,
	ELM_PHOTOCAM_ZOOM_MODE_AUTO_FILL
     } Elm_Photocam_Zoom_Mode;
   EAPI Evas_Object *elm_photocam_add(Evas_Object *parent);
   EAPI int          elm_photocam_file_set(Evas_Object *obj, const char *file);
   EAPI void         elm_photocam_zoom_set(Evas_Object *obj, int zoom);
   EAPI int          elm_photocam_zoom_get(Evas_Object *obj);
   EAPI void         elm_photocam_zoom_mode_set(Evas_Object *obj, Elm_Photocam_Zoom_Mode mode);
   EAPI Elm_Photocam_Zoom_Mode elm_photocam_zoom_mode_get(Evas_Object *obj);
   EAPI void         elm_photocam_image_size_get(Evas_Object *obj, int *w, int *h);

#ifdef __cplusplus
}
#endif

  ////////////////////////////////////////////////////////////////////////////
 /// FIXME: TODO LIST ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//
//// (bugs - high priority)
// * scale change for hover doesnt seem to do new size alloc nicely
// * left/right arrow broken with password mode for entry + utf8 chars...
// * bubble doesnt handle child size changes right
// * table doesnt do homogenous properly
//
//// (incomplete - medium priority)
// * need to add support for disabled in all widgets. Button, toolbar, hoversel, radio, check, toggle, spinner and entry are currently done.
// * on the fly theme changes - test (should work)
// * hoversel only vertical right now - make horizontal
// * when entries are in a scroller and change size, the scroller shows scrollbars. fix. same for selecting. for 1 line entries in a scroller should only have scroll arrow indicators.
//
//// (more widgets/features - medium priority)
// * multiple genlist item styles (multi-label, 1 icon + 2 line label, header etc.)
// * carousel selector widget
// * auto-size label/text that adapts text size to its allocated region
// * [ scrollable dropdown combo box ]
// * [ notepad widget ]
// * [ toggle with 2x labelled button for 2 states ]
// * [ poker spinner with numbers + labels ]
// * [ wrapping text button bar ]
// * slide-open "panel" that can hold stuff and optionally scroll
// * calendar widget (select date)
// * range selector (select range of values from X to Y over an interval)
// * "dialogbutton" widget (bigger button for bottom of wins)
// * dialog window widget
// * phone-number widget (hilight country dial prefixes, add flags, photos of contacts that match etc.)
// * imageview widget (for large not iconic images)
// * tiled image + zoom widget (tiled map viewer)
// * dialpad widget - need one with a phone dialpad
// * file selector widget - needs look and functionality improvement :)
// * generic "tacho" widget (set min/max labels - and up to 3 intermediate labels etc.)
// * status widget (busy, stalled, running, etc.)
// * full window in window widget (so move/resize of window object does as you'd expect a child window to do within the canvas)
// * window frame widget for borderless windows that want the app to do its own frame (move, resize as well etc.)
//
//// (improvements - low priority)
// * test for all bubble styles
// * test for all frame styles
// * test for all genlist item styles
// * test for all button styles
// * test for all hoversel styles
// * test for all inwin styles
// * test for all anchorblock styles
// * test for all anchorview styles
// * test more layout in layout
// * test normal evas (and edje) objects used as children in elm widgets
// * need a way to attach a "dnd detector" to any object
// * need a dnd handler (able to hook to dnd detector)
// * need another sample theme
// * need a way to set a preferred size of a widget (but not min or max).
// * merge with gurana
// * use evas's new box instead of a box smart
// * use evas's table instead of a table smart
// * use stack for win widget
// * determine prefix of app dynamically and export calls to get prefix info
// * load config from file - currently being done
// * load config from x property
// * handle finger size property and on-the-fly changes like scaling does
// * somehow a pdf(ps) viewer widget that doesnt make it gpl (lgpl)
// * emotion widget
// * ewebkit widget
// * flash (gnash) widget
// * menu bar + menu widget
// * need url and path entry modes for vkbd
// * return list of toplevel window objects
// * focus should have an object that is layered above all others (definable layer) that moves + resizes (slides about - animated) from one focused widget to the next for focus. also emit focus/unfocus signals too
// * scroller could do with page up/down/left/right buttons and and idea of a page size
// * current sizing tree inefficient
// * need a way to filter entry data for entry (eg for phone numbers)
// * win should emit signals based on vkbd type - if it gets a message and is a vkbd win
// * win needs a way of setting aspect too
// * use the wrong call on the wrong widget and *BOOM* ... crashland
//
//////////////////////////////////////////////////////////////////////////////
#endif