Elementary migration revision 69832
[framework/uifw/elementary.git] / doc / examples.dox
1 /**
2  * @page Examples Examples
3  *
4  * Here is a page with Elementary examples.
5  *
6  * @ref bg_01_example_page
7  *
8  * @ref bg_02_example_page
9  *
10  * @ref bg_03_example_page
11  *
12  * @ref actionslider_example_page
13  *
14  * @ref transit_example_01_explained
15  *
16  * @ref transit_example_02_explained
17  *
18  * @ref general_functions_example_page
19  *
20  * @ref calendar_example_01
21  *
22  * @ref calendar_example_02
23  *
24  * @ref calendar_example_03
25  *
26  * @ref calendar_example_04
27  *
28  * @ref calendar_example_05
29  *
30  * @ref calendar_example_06
31  *
32  * @ref spinner_example
33  *
34  * @ref slider_example
35  *
36  * @ref panes_example
37  *
38  * @ref clock_example
39  *
40  * @ref datetime_example
41  *
42  * @ref dayselector_example
43  *
44  * @ref mapbuf_example
45
46  * @ref map_example_01
47  *
48  * @ref map_example_02
49  *
50  * @ref map_example_03
51  *
52  * @ref diskselector_example_01
53  *
54  * @ref diskselector_example_02
55  *
56  * @ref entry_example
57  *
58  * @ref list_example_01
59  *
60  * @ref list_example_02
61  *
62  * @ref list_example_03
63  *
64  * @ref toolbar_example_01
65  *
66  * @ref toolbar_example_02
67  *
68  * @ref toolbar_example_03
69  *
70  * @ref segment_control_example
71  *
72  * @ref flipselector_example
73  *
74  * @ref fileselector_example
75  *
76  * @ref fileselector_button_example
77  *
78  * @ref fileselector_entry_example
79  *
80  * @ref index_example_01
81  *
82  * @ref index_example_02
83  *
84  * @ref gengrid_example
85  *
86  * @ref genlist_example_01
87  *
88  * @ref genlist_example_02
89  *
90  * @ref genlist_example_03
91  *
92  * @ref genlist_example_04
93  *
94  * @ref genlist_example_05
95  *
96  * @ref glview_example_01_page
97  *
98  * @ref thumb_example_01
99  *
100  * @ref progressbar_example
101  *
102  * @ref slideshow_example
103  * 
104  * @ref efl_thread_1
105  * 
106  * @ref efl_thread_2
107  * 
108  * @ref efl_thread_3
109  * 
110  * @ref efl_thread_4
111  * 
112  * @ref efl_thread_5
113  * 
114  * @ref efl_thread_6
115  */
116
117 /**
118  * @page bg_01_example_page elm_bg - Plain color background.
119  * @dontinclude bg_example_01.c
120  *
121  * The full code for this example can be found at @ref bg_example_01_c,
122  * in the function @c test_bg_plain. It's part of the @c elementar_test
123  * suite, and thus has the code for the three examples referenced by this
124  * documentation.
125  *
126  * This first example just sets a default background with a plain color. The
127  * first part consists of creating an Elementary window. It's the common
128  * piece of code that you'll see everywhere in Elementary: @skip elm_main
129  * @until autodel_set
130  *
131  * Now we really create our background object, using the window object as
132  * its parent:
133  *
134  * @skipline bg_add
135  *
136  * Then we set the size hints of the background object so that it will use
137  * all space available for it, and then add it as a resize object to the
138  * window, making it visible in the end:
139  *
140  * @skip size_hint_weight_set
141  * @until resize_object_add
142  *
143  * See @ref evas_object_size_hint_weight_set and elm_win_resize_object_add()
144  * for more detailed info about these functions.
145  *
146  * The end of the example is quite simple, just setting the minimum and
147  * maximum size of the background, so the Elementary window knows that it
148  * has to have at least the minimum size. The background also won't scale to
149  * a size above its maximum. Then we resize the window and show it in the
150  * end:
151  *
152  * @skip set size hints
153  * @until }
154  *
155  * And here we finish our very simple background object usage example.
156  */
157
158 /**
159  * @page bg_02_example_page elm_bg - Image background.
160  * @dontinclude bg_example_02.c
161  *
162  * The full code for this example can be found at @ref bg_example_02_c,
163  * in the function @c test_bg_image. It's part of the @c elementar_test
164  * suite, and thus has the code for the three examples referenced by this
165  * documentation.
166  *
167  * This is the second example, and shows how to use the Elementary
168  * background object to set an image as background of your application.
169  *
170  * We start this example exactly in the same way as the previous one, even
171  * when creating the background object:
172  *
173  * @skip elm_main
174  * @until bg_add
175  *
176  * Now it's the different part.
177  *
178  * Our background will have an image, that will be displayed over the
179  * background color. Before loading the image, we set the load size of the
180  * image. The load size is a hint about the size that we want the image
181  * displayed in the screen. It's not the exact size that the image will have,
182  * but usually a bit bigger. The background object can still be scaled to a
183  * size bigger than the one set here. Setting the image load size to
184  * something smaller than its real size will reduce the memory used to keep
185  * the pixmap representation of the image, and the time to load it. Here we
186  * set the load size to 20x20 pixels, but the image is loaded with a size
187  * bigger than that (since it's just a hint):
188  *
189  * @skipline load_size_set
190  *
191  * And set our background image to be centered, instead of stretched or
192  * scaled, so the effect of the elm_bg_load_size_set() can be easily
193  * understood:
194  *
195  * @skipline option_set
196  *
197  * We need a filename to set, so we get one from the previous installed
198  * images in the @c PACKAGE_DATA_DIR, and write its full path to a buffer.
199  * Then we use this buffer to set the filename in the background object:
200  *
201  * @skip snprintf
202  * @until bg_file_set
203  *
204  * Notice that the third argument of the elm_bg_file_set() function is @c
205  * NULL, since we are setting an image to this background. This function
206  * also supports setting an edje group as background, in which case the @c
207  * group parameter wouldn't be @c NULL, but be the name of the group
208  * instead.
209  *
210  * Finally, we can set the size hints, add the background as a resize
211  * object, and resize the window, exactly the same thing we do in the @ref
212  * bg_01_example_page example:
213  *
214  * @skip size_hint
215  * @until }
216  *
217  * And this is the end of this example.
218  *
219  * This example will look like this:
220  *
221  * @image html screenshots/bg_01.png
222  * @image latex screenshots/bg_01.eps width=\textwidth
223  */
224
225 /**
226  * @page bg_03_example_page elm_bg - Background properties.
227  * @dontinclude bg_example_03.c
228  *
229  * The full code for this example can be found at @ref bg_example_03_c, in the
230  * function @c test_bg_options, with the callbacks @c _cb_overlay_changed, @c
231  * _cb_color_changed and @c _cb_radio_changed defined in the beginning of the
232  * file. It's part of the @c elementar_test suite, and thus has the code for
233  * the three examples referenced by this documentation.
234  *
235  * This example will show the properties available for the background object,
236  * and will use of some more widgets to set them.
237  *
238  * In order to do this, we will set some callbacks for these widgets. The
239  * first is for the radio buttons that will be used to choose the option
240  * passed as argument to elm_bg_option_set():
241  *
242  * @skip _cb_radio_changed
243  * @until }
244  *
245  * The next callback will be used when setting the overlay (using
246  * elm_object_content_set()):
247  *
248  * @skip _cb_overlay_changed
249  * @until }
250  * @until }
251  *
252  * And the last one, used to set the color (with elm_bg_color_set()):
253  *
254  * @skip _cb_color_changed
255  * @until }
256  *
257  * We will get back to what these functions do soon. If you want to know more
258  * about how to set these callbacks and what these widgets are, look for:
259  * @li elm_radio_add()
260  * @li elm_check_add()
261  * @li elm_spinner_add()
262  *
263  * Now going to the main function, @c test_bg_options, we have the common
264  * code with the other examples:
265  *
266  * @skip bg-options
267  * @until autodel_set
268  *
269  * We add a plain background to this window, so it will have the default
270  * background color behind everything:
271  *
272  * @skip bg = elm_bg_add
273  * @until evas_object_show(bg)
274  *
275  * Then we add a vertical box (elm_box_add()) that will hold the background
276  * object that we are going to play with, as well as a horizontal box that
277  * will hold widgets:
278  *
279  * @skip elm_box_add
280  * @until evas_object_show
281  *
282  * Now we add the background object that is going to be of use for our
283  * example. It is an image background, as used in @ref bg_02_example_page ,
284  * so the code should be familiar:
285  *
286  * @skip elm_bg_add
287  * @until evas_object_show
288  *
289  * Notice the call to elm_box_pack_end(): it will pack the background object
290  * in the end of the Elementary box declared above. Just refer to that
291  * documentation for more info.
292  *
293  * Since this Elementary background is already an image background, we are
294  * going to play with its other properties. We will change its option
295  * (CENTER, SCALE, STRETCH, TILE), its color (RGB), and add an overlay to it.
296  * For all of these properties, we are going to add widgets that will
297  * configure them.
298  *
299  * First, lets add the horizontal box that will hold these widgets:
300  * @skip hbox
301  * @until align_set
302  *
303  * For now, just consider this @c hbox as a rectangle that will contain the
304  * widgets, and will distribute them horizontally inside its content. Then we
305  * add radio buttons that will allow us to choose the property to use with
306  * this background:
307  *
308  * @skip radio_add
309  * @until evas_object_show
310  *
311  * Again, I won't give details about the use of these widgets, just look for
312  * their documentation if necessary. It's enough to know for now that we are
313  * packing them in the @c hbox, setting a label for them, and the most
314  * important parts: setting its value to @c ELM_BG_OPTION_CENTER and its
315  * callback to @c _cb_radio_changed (the function defined in the beginning of
316  * this example). We do this for the next 3 radio buttons added after this
317  * one, each of them with a different value.
318  *
319  * Now taking a look at the code of the callback @c _cb_radio_changed again,
320  * it will call elm_bg_option_set() with the value set from the checked radio
321  * button, thus setting the option for this background. The background is
322  * passed as argument to the @p data parameter of this callback, and is
323  * referenced here as @c o_bg.
324  *
325  * Later we set the default value for this radio button:
326  *
327  * @skipline elm_radio_value_set
328  *
329  * Then we add a checkbox for the elm_object_content_set() function for the bg:
330  *
331  * @skip check_add
332  * @until evas_object_show
333  *
334  * Now look at the code of the @c _cb_overlay_changed again. If the checkbox
335  * state is checked, an overlay will be added to the background. It's done by
336  * creating an Edje object, and setting it with elm_object_content_set() to the
337  * background object. For information about what are and how to set Edje
338  * object, look at the Edje documentation.
339  *
340  * Finally we add a spinner object (elm_spinner_add()) to be used to select
341  * the color of our background. In its callback it's possible to see the call
342  * to elm_bg_color_set(), which will change the color of this background.
343  * This color is used by the background to fill areas where the image doesn't
344  * cover (in this case, where we have an image background). The spinner is
345  * also packed into the @c hbox :
346  *
347  * @skip elm_spinner_add
348  * @until evas_object_show
349  *
350  * Then we just have to pack the @c hbox inside the @c box, set some size
351  * hints, and show our window:
352  *
353  * @skip pack_end
354  * @until }
355  *
356  * Now to see this code in action, open elementary_test, and go to the "Bg
357  * Options" test. It should demonstrate what was implemented here.
358  */
359
360 /**
361  * @page actionslider_example_page Actionslider usage
362  * @dontinclude actionslider_example_01.c
363  *
364  * For this example we are going to assume knowledge of evas smart callbacks
365  * and some basic evas object functions. Elementary is not meant to be used
366  * without evas, if you're not yet familiar with evas it probably is worth
367  * checking that out.
368  *
369  * And now to the example, when using Elementary we start by including
370  * Elementary.h:
371  * @skipline #include
372  *
373  * Next we define some callbacks, they all share the same signature because
374  * they are all to be used with evas_object_smart_callback_add().
375  * The first one just prints the selected label(in two different ways):
376  * @until }
377  *
378  * This next callback is a little more interesting, it makes the selected
379  * label magnetic(except if it's the center label):
380  * @until }
381  *
382  * This callback enables or disables the magnetic propertty of the center
383  * label:
384  * @until }
385  *
386  * And finally a callback to stop the main loop when the window is closed:
387  * @until }
388  *
389  * To be able to create our actionsliders we need to do some setup, but this
390  * isn't really relevant here, so if you want to know about that go @ref
391  * Win "here".
392  *
393  * With all that boring stuff out of the way we can proceed to creating some
394  * actionsliders.@n
395  * All actionsliders are created the same way:
396  * @skipline actionslider_add
397  * Next we must choose where the indicator starts, and for this one we choose
398  * the right, and set the right as magnetic:
399  * @skipline indicator_pos_set
400  * @until magnet_pos_set
401  *
402  * We then set the labels for the left and right, passing NULL as an argument
403  * to any of the labels makes that position have no label.
404  * @until Stop
405  *
406  * Furthermore we mark both left and right as enabled positions, if we didn't
407  * do this all three positions would be enabled:
408  * @until RIGHT
409  *
410  * Having the the enabled positions we now add a smart callback to change
411  * which position is magnetic, so that only the last selected position is
412  * magnetic:
413  * @until NULL
414  *
415  * And finally we set our printing callback and show the actionslider:
416  * @until object_show
417  * @skip pack_end
418  *
419  * For our next actionslider we are going to do much as we did for the
420  * previous except we are going to have the center as the magnet(and not
421  * change it):
422  * @skipline actionslider_add
423  * @skipline indicator_pos_set
424  * @until object_show
425  *
426  * And another actionslider, in this one the indicator starts on the left.
427  * It has labels only in the center and right, and both bositions are
428  * magnetic. Because the left doesn't have a label and is not magnetic once
429  * the indicator leaves it can't return:
430  * @skipline actionslider_add
431  * @skipline indicator_pos_set
432  * @until object_show
433  * @note The greyed out area is a @ref Styles "style".
434  *
435  * And now an actionslider with a label in the indicator, and whose magnet
436  * properties change based on what was last selected:
437  * @skipline actionslider_add
438  * @skipline indicator_pos_set
439  * @until object_show
440  * @note The greyed out area is a @ref Styles "style".
441  *
442  * We are almost done, this next one is just an actionslider with all
443  * positions magnetized and having every possible label:
444  * @skipline actionslider_add
445  * @skipline indicator_pos_set
446  * @until object_show
447  *
448  * And for our last actionslider we have one that turns the magnetic property
449  * on and off:
450  * @skipline actionslider_add
451  * @skipline indicator_pos_set
452  * @until object_show
453  *
454  * The example will look like this:
455  *
456  * @image html screenshots/actionslider_01.png
457  * @image latex screenshots/actionslider_01.eps width=\textwidth
458  *
459  * See the full source code @ref actionslider_example_01 "here"
460  */
461
462 /**
463  * @page transit_example_03_c elm_transit - Combined effects and options.
464  *
465  * This example shows how to apply the following transition effects:
466  * @li translation
467  * @li color
468  * @li rotation
469  * @li wipe
470  * @li zoom
471  * @li resizing
472  *
473  * It allows you to apply more than one effect at once, and also allows to
474  * set properties like event_enabled, auto_reverse, repeat_times and
475  * tween_mode.
476  *
477  * @include transit_example_03.c
478  */
479
480 /**
481  * @page transit_example_04_c elm_transit - Combined effects over two objects.
482  *
483  * This example shows how to apply the transition effects:
484  * @li flip
485  * @li resizable_flip
486  * @li fade
487  * @li blend
488  * over two objects. This kind of transition effect is used to make one
489  * object disappear and another one appear on its place.
490  *
491  * You can mix more than one effect of this type on the same objects, and the
492  * transition will apply both.
493  *
494  * @include transit_example_04.c
495  */
496
497 /**
498  * @page transit_example_01_explained elm_transit - Basic transit usage.
499  * @dontinclude transit_example_01.c
500  *
501  * The full code for this example can be found at @ref transit_example_01_c.
502  *
503  * This example shows the simplest way of creating a transition and applying
504  * it to an object. Similarly to every other elementary example, we create a
505  * window, set its title, size, autodel property, and setup a callback to
506  * exit the program when finished:
507  *
508  * @skip on_done
509  * @until evas_object_resize
510  *
511  * We also add a resizable white background to use behind our animation:
512  *
513  * @skip bg_add
514  * @until evas_object_show
515  *
516  * And then we add a button that we will use to demonstrate the effects of
517  * our animation:
518  *
519  * @skip button_add
520  * @until evas_object_show(win)
521  *
522  * Notice that we are not adding the button with elm_win_resize_object_add()
523  * because we don't want the window to control the size of the button. We
524  * will use the transition to change the button size, so it could conflict
525  * with something else trying to control that size.
526  *
527  * Now, the simplest code possible to create the resize animation:
528  *
529  * @skip transit_add
530  * @until transit_go
531  *
532  * As you can see, this code is very easy to understand. First, we create the
533  * transition itself with elm_transit_add(). Then we add the button to this
534  * transition with elm_transit_object_add(), which means that the transition
535  * will operate over this button. The effect that we want now is changing the
536  * object size from 100x50 to 300x150, and can be achieved by adding the
537  * resize effect with elm_transit_effect_resizing_add().
538  *
539  * Finally, we set the transition time to 5 seconds and start the transition
540  * with elm_transit_go(). If we wanted more effects applied to this
541  * button, we could add them to the same transition. See the
542  * @ref transit_example_03_c to watch many transitions being applied to an
543  * object.
544  */
545
546 /**
547  * @page transit_example_02_explained elm_transit - Chained transitions.
548  * @dontinclude transit_example_02.c
549  *
550  * The full code for this example can be found at @ref transit_example_02_c.
551  *
552  * This example shows how to implement a chain of transitions. This chain is
553  * used to start a transition just after another transition ended. Similarly
554  * to every other elementary example, we create a window, set its title,
555  * size, autodel property, and setup a callback to exit the program when
556  * finished:
557  *
558  * @skip on_done
559  * @until evas_object_resize
560  *
561  * We also add a resizable white background to use behind our animation:
562  *
563  * @skip bg_add
564  * @until evas_object_show
565  *
566  * This example will have a chain of 4 transitions, each of them applied to
567  * one button. Thus we create 4 different buttons:
568  *
569  * @skip button_add
570  * @until evas_object_show(bt4)
571  *
572  * Now we create a simple translation transition that will be started as soon
573  * as the program loads. It will be our first transition, and the other
574  * transitions will be started just after this transition ends:
575  *
576  * @skip transit_add
577  * @until transit_go
578  *
579  * The code displayed until now has nothing different from what you have
580  * already seen in @ref transit_example_01_explained, but now comes the new
581  * part: instead of creating a second transition that will start later using
582  * a timer, we create the it normally, and use
583  * elm_transit_chain_transit_add() instead of elm_transit_go. Since we are
584  * adding it in a chain after the first transition, it will start as soon as
585  * the first transition ends:
586  *
587  * @skip transit_add
588  * @until transit_chain_transit_add
589  *
590  * Finally we add the 2 other transitions to the chain, and run our program.
591  * It will make one transition start after the other finish, and there is the
592  * transition chain.
593  */
594
595 /**
596  * @page general_functions_example_page General (top-level) functions example
597  * @dontinclude general_funcs_example.c
598  *
599  * As told in their documentation blocks, the
600  * elm_app_compile_*_dir_set() family of functions have to be called
601  * before elm_app_info_set():
602  * @skip tell elm about
603  * @until elm_app_info_set
604  *
605  * We are here setting the fallback paths to the compiling time target
606  * paths, naturally. If you're building the example out of the
607  * project's build system, we're assuming they are the canonical ones.
608  *
609  * After the program starts, elm_app_info_set() will actually run and
610  * then you'll see an intrincasy: Elementary does the prefix lookup @b
611  * twice. This is so because of the quicklaunch infrastructure in
612  * Elementary (@ref Start), which will register a predefined prefix
613  * for possible users of the launch schema. We're not hooking into a
614  * quick launch, so this first call can't be avoided.
615  *
616  * If you ran this example from your "bindir" installation
617  * directiory, no output will emerge from these both attempts -- it
618  * will find the "magic" file there registered and set the prefixes
619  * silently. Otherwise, you could get something like:
620  @verbatim
621  WARNING: Could not determine its installed prefix for 'ELM'
622        so am falling back on the compiled in default:
623          usr
624        implied by the following:
625          bindir    = usr/lib
626          libdir    = usr/lib
627          datadir   = usr/share/elementary
628          localedir = usr/share/locale
629        Try setting the following environment variables:
630          ELM_PREFIX     - points to the base prefix of install
631        or the next 4 variables
632          ELM_BIN_DIR    - provide a specific binary directory
633          ELM_LIB_DIR    - provide a specific library directory
634          ELM_DATA_DIR   - provide a specific data directory
635          ELM_LOCALE_DIR - provide a specific locale directory
636  @endverbatim
637  * if you also didn't change those environment variables (remember
638  * they are also a valid way of communicating your prefix to the
639  * binary) - this is the scenario where it fallbacks to the paths set
640  * for compile time.
641  *
642  * Then, you can check the prefixes set on the standard output:
643  * @skip prefix was set to
644  * @until locale directory is
645  *
646  * In the fragment
647  * @skip by using this policy
648  * @until elm_win_autodel_set
649  * we demonstrate the use of Elementary policies. The policy defining
650  * under which circunstances our application should quit automatically
651  * is set to when its last window is closed (this one has just one
652  * window, though). This will save us from having to set a callback
653  * ourselves on the window, like done in @ref bg_example_01_c "this"
654  * example. Note that we need to tell the window to delete itself's
655  * object on a request to destroy the canvas coming, with
656  * elm_win_autodel_set().
657  *
658  * What follows is some boilerplate code, creating a frame with a @b
659  * button, our object of interest, and, below, widgets to change the
660  * button's behavior and exemplify the group of functions in question.
661  *
662  * @dontinclude general_funcs_example.c
663  * We enabled the focus highlight object for this window, so that you
664  * can keep track of the current focused object better:
665  * @skip elm_win_focus_highlight_enabled_set
666  * @until evas_object_show
667  * Use the tab key to navigate through the focus chain.
668  *
669  * @dontinclude general_funcs_example.c
670  * While creating the button, we exemplify how to use Elementary's
671  * finger size information to scale our UI:
672  * @skip fprintf(stdout, "Elementary
673  * @until evas_object_show
674  *
675  * @dontinclude general_funcs_example.c
676  * The first checkbox's callback is:
677  * @skip static void
678  * @until }
679  * When unsetting the checkbox, we disable the button, which will get a new
680  * decoration (greyed out) and stop receiving events. The focus chain
681  * will also ignore it.
682  *
683  * Following, there are 2 more buttons whose actions are focus/unfocus
684  * the top button, respectively:
685  * @skip focus callback
686  * @until }
687  * and
688  * @skip unfocus callback
689  * @until }
690  * Note the situations in which they won't take effect:
691  * - the button is not allowed to get focus or
692  * - the button is disabled
693  *
694  * The first restriction above you'll get by a second checkbox, whose
695  * callback is:
696  * @skip focus allow callback
697  * @until }
698  * Note that the button will still get mouse events, though.
699  *
700  * Next, there's a slider controlling the button's scale:
701  * @skip scaling callback
702  * @until }
703  *
704  * Experiment with it, so you understand the effect better. If you
705  * change its value, it will mess with the button's original size,
706  * naturally.
707  *
708  * The full code for this example can be found
709  * @ref general_functions_example_c "here".
710  */
711
712 /**
713  * @page theme_example_01 Theme - Using extensions
714  *
715  * @dontinclude theme_example_01.c
716  *
717  * Using extensions is extremely easy, discarding the part where you have to
718  * write the theme for them.
719  *
720  * In the following example we'll be creating two buttons, one to load or
721  * unload our extension theme and one to cycle around three possible styles,
722  * one of which we created.
723  *
724  * After including our one and only header we'll jump to the callback for
725  * the buttons. First one takes care of loading or unloading our extension
726  * file, relative to the default theme set (thus the @c NULL in the
727  * functions first parameter).
728  * @skipline Elementary.h
729  * @skip static void
730  * @until }
731  * @until }
732  * @until }
733  *
734  * The second button, as we said before, will just switch around different
735  * styles. In this case we have three of them. The first one is our custom
736  * style, named after something very unlikely to find in the default theme.
737  * The other two styles are the standard and one more, anchor, which exists
738  * in the default and is similar to the default, except the button vanishes
739  * when the mouse is not over it.
740  * @skip static void
741  * @until }
742  * @until }
743  *
744  * So what happens if the style switches to our custom one when the
745  * extension is loaded? Elementary falls back to the default for the
746  * widget.
747  *
748  * And the main function, simply enough, will create the window, set the
749  * buttons and their callbacks, and just to begin with our button styled
750  * we're also loading our extension at the beginning.
751  * @skip int
752  * @until ELM_MAIN
753  *
754  * In this case we wanted to easily remove extensions, but all adding an
755  * extension does is tell Elementary where else it should look for themes
756  * when it can't find them in the default theme. Another way to do this
757  * is to set the theme search order using elm_theme_set(), but this requires
758  * that the developer is careful not to override any user configuration.
759  * That can be helped by adding our theme to the end of whatver is already
760  * set, like in the following snippet.
761  * @code
762  * char buf[4096];
763  * snprintf(buf, sizeof(buf), "%s:./theme_example.edj", elme_theme_get(NULL);
764  * elm_theme_set(NULL, buf);
765  * @endcode
766  *
767  * If we were using overlays instead of extensions, the same thing applies,
768  * but the custom theme must be added to the front of the search path.
769  *
770  * In the end, we should be looking at something like this:
771  *
772  * @image html screenshots/theme_example_01.png
773  * @image latex screenshots/theme_example_01.eps width=\textwidth
774  *
775  * That's all. Boringly simple, and the full code in one piece can be found
776  * @ref theme_example_01.c "here".
777  *
778  * And the code for our extension is @ref theme_example.edc "here".
779  *
780  * @example theme_example_01.c
781  * @example theme_example.edc
782  */
783
784 /**
785  * @page theme_example_02 Theme - Using overlays
786  *
787  * @dontinclude theme_example_02.c
788  *
789  * Overlays are like extensions in that you tell Elementary that some other
790  * theme contains the styles you need for your program. The difference is that
791  * they will be look in first, so they can override the default style of any
792  * widget.
793  *
794  * There's not much to say about them that hasn't been said in our previous
795  * example about @ref theme_example_01 "extensions", so going quickly through
796  * the code we have a function to load or unload the theme, which will be
797  * called when we click any button.
798  * @skipline Elementary.h
799  * @skip static void
800  * @until }
801  *
802  * And the main function, creating the window and adding some buttons to it.
803  * We load our theme as an overlay and nothing else. Notice there's no style
804  * set for any button there, which means they should be using the default
805  * that we override.
806  * @skip int
807  * @until ELM_MAIN
808  *
809  * That's pretty much it. The full code is @ref theme_example_02.c "here" and
810  * the definition of the theme is the same as before, and can be found in
811  * @ref theme_example.edc "here".
812  *
813  * @example theme_example_02.c
814  */
815
816  /**
817   * @page button_example_00 Button - Hello, Button!
818   *
819   * @dontinclude button_example_00.c
820   *
821   * Keeping the tradition, this is a simple "Hello, World" button example. We
822   * will show how to create a button and associate and action to be performed
823   * when you click on it.
824   *
825   * In the end, we'll be presented with something that looks like this:
826   *
827   * @image html screenshots/button_00.png
828   * @image latex screenshots/button_00.eps width=\textwidth
829   *
830   * The full code of the example is @ref button_example_00.c "here" and we
831   * will follow here with a rundown of it.
832   *
833   *
834   * There is only one button on the interface which performs a basic action:
835   * close the application. This behavior is described by on_click() function,
836   * that interrupt the program invoking elm_exit().
837   * @skip static void
838   * @until }
839   *
840   *
841   * On the main() function, we set the basic characteristics of the user
842   * interface. First we use the Elementary library to create a window and
843   * set its policies (such as close when the user click on the window close
844   * icon).
845   *
846   * @skip elm_win_add
847   * @until elm_policy_set
848   *
849   * In order to turn it visible on the WM (Window Manager), we also have to
850   * associate it to a canvas through Evas library, and set its dimensions.
851   *
852   * @skip evas_object_resize
853   * @until evas_object_show(win)
854   *
855   * Then we create a background associated to the window, define its dimensions,
856   * and turn it visible on the canvas.
857   * @skip  elm_bg_add
858   * @until evas_object_show(bg)
859   *
860   *
861   * Finally we use Elementary to create a button and Evas to set its
862   * proprieties. Here we have not only to give the button dimensions, but also
863   * its coordinates and the action to be performed on the click event.
864   * @skip elm_button_add
865   * @until evas_object_show(btn)
866   *
867   *
868   * And we are done.
869   *
870   * @example button_example_00.c
871   */
872
873 /**
874   * @page button_example_01 Button - Complete example
875   *
876   * @dontinclude button_example_01.c
877   *
878   * A button is simple, you click on it and something happens. That said,
879   * we'll go through an example to show in detail the button API less
880   * commonly used.
881   *
882   * In the end, we'll be presented with something that looks like this:
883   *
884   * @image html screenshots/button_01.png
885   * @image latex screenshots/button_01.eps width=\textwidth
886   *
887   * The full code of the example is @ref button_example_01.c "here" and we
888   * will follow here with a rundown of it.
889   *
890   * @skip Elementary.h
891   * @until Elementary.h
892   * @skip struct
893   * @until App_Data
894   *
895   * We have several buttons to set different times for the autorepeat timeouts
896   * of the buttons that use it and a few more that we keep track of in our
897   * data struct. The mid button doesn't do much, just moves around according
898   * to what other buttons the user presses. Then four more buttons to move the
899   * central one, and we're also keeping track of the icon set in the middle
900   * button, since when this one moves, we change the icon, and when movement
901   * is finished (by releasing one of the four arrow buttons), we set back the
902   * normal icon.
903   * @skip static void
904   * @until }
905   *
906   * Keeping any of those four buttons pressed will trigger their autorepeat
907   * callback, where we move the button doing some size hint magic. To
908   * understand how that works better, refer to the @ref Box documentation.
909   * Also, the first time the function is called, we change the icon in the
910   * middle button, using elm_object_content_unset() first to keep the reference
911   * to the previous one, so we don't need to recreate it when we are done
912   * moving it.
913   * @skip static void
914   * @until }
915   * @until size_hint_align_set
916   * @until }
917   *
918   * One more callback for the option buttons, that just sets the timeouts for
919   * the different autorepeat options.
920   *
921   * @skip static void
922   * @until }
923   * @until }
924   * @until }
925   *
926   * And the main function, which does some setting up of the buttons in boxes
927   * to make things work. Here we'll go through some snippets only.
928   *
929   * For the option buttons, it's just the button with its label and callback.
930   * @skip elm_button_add
931   * @until smart_callback_add
932   *
933   * For the ones that move the central button, we have no labels. There are
934   * icons instead, and the autorepeat option is toggled.
935   * @skip Gap: 1.0
936   * @skip elm_button_add
937   * @until data.cursors.up
938   *
939   * And just to show the mid button, which doesn't have anything special.
940   * @skip data.cursors.left
941   * @skip elm_button_add
942   * @until data.mid
943   *
944   * And we are done.
945   *
946   * @example button_example_01.c
947   */
948
949 /**
950  * @page bubble_01_example_page elm_bubble - Simple use.
951  * @dontinclude bubble_example_01.c
952  *
953  * This example shows a bubble with all fields set(label, info, content and
954  * icon) and the selected corner changing when the bubble is clicked. To be
955  * able use a bubble we need to do some setup and create a window, for this
956  * example we are going to ignore that part of the code since it isn't
957  * relevant to the bubble.
958  *
959  * To have the selected corner change in a clockwise motion we are going to
960  * use the following callback:
961  * @skip static
962  * @until }
963  * @until }
964  *
965  * Here we are creating an elm_label that is going to be used as the content
966  * for our bubble:
967  * @skipline elm_label
968  * @until show
969  * @note You could use any evas_object for this, we are using an elm_label
970  * for simplicity.
971  *
972  * Despite it's name the bubble's icon doesn't have to be an icon, it can be
973  * any evas_object. For this example we are going to make the icon a simple
974  * blue rectangle:
975  * @until show
976  *
977  * And finally we have the actual bubble creation and the setting of it's
978  * label, info and content:
979  * @until content
980  * @skipline show
981  * @note Because we didn't set a corner, the default("top_left") will be
982  * used.
983  *
984  * Now that we have our bubble all that is left is connecting the "clicked"
985  * signals to our callback:
986  * @line smart_callback
987  *
988  * This last bubble we created was very complete, so it's pertinent to show
989  * that most of that stuff is optional a bubble can be created with nothing
990  * but content:
991  * @until content
992  * @skipline show
993  *
994  * Our example will look like this:
995  *
996  * @image html screenshots/bubble_example_01.png
997  * @image latex screenshots/bubble_example_01.eps width=\textwidth
998  *
999  * See the full source code @ref bubble_example_01.c here.
1000  * @example bubble_example_01.c
1001  */
1002
1003 /**
1004  * @page box_example_01 Box - Basic API
1005  *
1006  * @dontinclude button_example_01.c
1007  *
1008  * As a special guest tonight, we have the @ref button_example_01 "simple
1009  * button example". There are plenty of boxes in it, and to make the cursor
1010  * buttons that moved a central one around when pressed, we had to use a
1011  * variety of values for their hints.
1012  *
1013  * To start, let's take a look at the handling of the central button when
1014  * we were moving it around. To achieve this effect without falling back to
1015  * a complete manual positioning of the @c Evas_Object in our canvas, we just
1016  * put it in a box and played with its alignment within it, as seen in the
1017  * following snippet of the callback for the pressed buttons.
1018  * @skip evas_object_size_hint_align_get
1019  * @until evas_object_size_hint_align_set
1020  *
1021  * Not much to it. We get the current alignment of the object and change it
1022  * by just a little, depending on which button was pressed, then set it
1023  * again, making sure we stay within the 0.0-1.0 range so the button moves
1024  * inside the space it has, instead of disappearing under the other objects.
1025  *
1026  * But as useful as an example as that may have been, the usual case with boxes
1027  * is to set everything at the moment they are created, like we did for
1028  * everything else in our main function.
1029  *
1030  * The entire layout of our program is made with boxes. We have one set as the
1031  * resize object for the window, which means it will always be resized with
1032  * the window. The weight hints set to @c EVAS_HINT_EXPAND will tell the
1033  * window that the box can grow past it's minimum size, which allows resizing
1034  * of it.
1035  * @skip elm_main
1036  * @skip elm_box_add
1037  * @until evas_object_show
1038  *
1039  * Two more boxes, set to horizontal, hold the buttons to change the autorepeat
1040  * configuration used by the buttons. We create each to take over all the
1041  * available space horizontally, but we don't want them to grow vertically,
1042  * so we keep that axis of the weight with 0.0. Then it gets packed in the
1043  * main box.
1044  * @skip box2
1045  * @until evas_object_show
1046  *
1047  * The buttons in each of those boxes have nothing special, they are just packed
1048  * in with their default values and the box will use their minimum size, as set
1049  * by Elementary itself based on the label, icon, finger size and theme.
1050  *
1051  * But the buttons used to move the central one have a special disposition.
1052  * The top one first, is placed right into the main box like our other smaller
1053  * boxes. Set to expand horizontally and not vertically, and in this case we
1054  * also tell it to fill that space, so it gets resized to take the entire
1055  * width of the window.
1056  * @skip Gap: 1.0
1057  * @skip elm_button_add
1058  * @until evas_object_show
1059  *
1060  * The bottom one will be the same, but for the other two we need to use a
1061  * second box set to take as much space as we have, so we can place our side
1062  * buttons in place and have the big empty space where the central button will
1063  * move.
1064  * @skip elm_box_add
1065  * @until evas_object_show
1066  *
1067  * Then the buttons will have their hints inverted to the other top and bottom
1068  * ones, to expand and fill vertically and keep their minimum size horizontally.
1069  * @skip elm_button_add
1070  * @until evas_object_show
1071  *
1072  * The central button takes every thing else. It will ask to be expanded in
1073  * both directions, but without filling its cell. Changing its alignment by
1074  * pressing the buttons will make it move around.
1075  * @skip elm_button_add
1076  * @until evas_object_show
1077  *
1078  * To end, the rightmost button is packed in the smaller box after the central
1079  * one, and back to the main box we have the bottom button at the end.
1080  */
1081
1082 /**
1083  * @page box_example_02 Box - Layout transitions
1084  *
1085  * @dontinclude box_example_02.c
1086  *
1087  * Setting a customized layout for a box is simple once you have the layout
1088  * function, which is just like the layout function for @c Evas_Box. The new
1089  * and fancier thing we can do with Elementary is animate the transition from
1090  * one layout to the next. We'll see now how to do that through a simple
1091  * example, while also taking a look at some of the API that was left
1092  * untouched in our @ref box_example_01 "previous example".
1093  *
1094  * @image html screenshots/box_example_02.png
1095  * @image latex screenshots/box_example_02.eps width=\textwidth
1096  *
1097  * @skipline Elementary.h
1098  *
1099  * Our application data consists of a list of layout functions, given by
1100  * @c transitions. We'll be animating through them throughout the entire run.
1101  * The box with the stuff to move around and the last layout that was set to
1102  * make things easier in the code.
1103  * @skip typedef
1104  * @until Transitions_Data
1105  *
1106  * The box starts with three buttons, clicking on any of them will take it
1107  * out of the box without deleting the object. There are also two more buttons
1108  * outside, one to add an object to the box and the other to clear it.
1109  * This is all to show how you can interact with the items in the box, add
1110  * things and even remove them, while the transitions occur.
1111  *
1112  * One of the callback we'll be using creates a new button, asks the box for
1113  * the list of its children and if it's not empty, we add the new object after
1114  * the first one, otherwise just place at the end as it will not make any
1115  * difference.
1116  * @skip static void
1117  * @until }
1118  * @until }
1119  *
1120  * The clear button is even simpler. Everything in the box will be deleted,
1121  * leaving it empty and ready to fill it up with more stuff.
1122  * @skip static void
1123  * @until }
1124  *
1125  * And a little function to remove buttons from the box without deleting them.
1126  * This one is set for the @c clicked callback of the original buttons,
1127  * unpacking them when clicked and placing it somewhere in the screen where
1128  * they will not disturb. Once we do this, the box no longer has any control
1129  * of it, so it will be left untouched until the program ends.
1130  * @skip static void
1131  * @until }
1132  *
1133  * If we wanted, we could just call @c evas_object_del() on the object to
1134  * destroy it. In this case, no unpack is really necessary, as the box would
1135  * be notified of a child being deleted and adjust its calculations accordingly.
1136  *
1137  * The core of the program is the following function. It takes whatever
1138  * function is first on our list of layouts and together with the
1139  * @c last_layout, it creates an ::Elm_Box_Transition to use with
1140  * elm_box_layout_transition(). In here, we tell it to start from whatever
1141  * layout we last set, end with the one that was at the top of the list and
1142  * when everything is finished, call us back so we can create another
1143  * transition. Finally, move the new layout to the end of the list so we
1144  * can continue running through them until the program ends.
1145  * @skip static void
1146  * @until }
1147  *
1148  * The main function doesn't have antyhing special. Creation of box, initial
1149  * buttons and some callback setting. The only part worth mentioning is the
1150  * initialization of our application data.
1151  * @skip tdata.box
1152  * @until evas_object_box_layout_stack
1153  *
1154  * We have a simple static variable, set the box, the first layout we are
1155  * using as last and create the list with the different functions to go
1156  * through.
1157  *
1158  * And in the end, we set the first layout and call the same function we went
1159  * through before to start the run of transitions.
1160  * @until _test_box_transition_change
1161  *
1162  * For the full code, follow @ref box_example_02.c "here".
1163  *
1164  * @example box_example_02.c
1165  */
1166
1167 /**
1168  * @page calendar_example_01 Calendar - Simple creation.
1169  * @dontinclude calendar_example_01.c
1170  *
1171  * As a first example, let's just display a calendar in our window,
1172  * explaining all steps required to do so.
1173  *
1174  * First you should declare objects we intend to use:
1175  * @skipline Evas_Object
1176  *
1177  * Then a window is created, a title is set and its set to be autodeleted.
1178  * More details can be found on windows examples:
1179  * @until elm_win_autodel
1180  *
1181  * Next a simple background is placed on our windows. More details on
1182  * @ref bg_01_example_page :
1183  * @until evas_object_show(bg)
1184  *
1185  * Now, the exciting part, let's add the calendar with elm_calendar_add(),
1186  * passing our window object as parent.
1187  * @until evas_object_show(cal);
1188  *
1189  * To conclude our example, we should show the window and run elm mainloop:
1190  * @until ELM_MAIN
1191  *
1192  * Our example will look like this:
1193  *
1194  * @image html screenshots/calendar_example_01.png
1195  * @image latex screenshots/calendar_example_01.eps width=\textwidth
1196  *
1197  * See the full source code @ref calendar_example_01.c here.
1198  * @example calendar_example_01.c
1199  */
1200
1201 /**
1202  * @page calendar_example_02 Calendar - Layout strings formatting.
1203  * @dontinclude calendar_example_02.c
1204  *
1205  * In this simple example, we'll explain how to format the label displaying
1206  * month and year, and also set weekday names.
1207  *
1208  * To format month and year label, we need to create a callback function
1209  * to create a string given the selected time, declared under a
1210  * <tt> struct tm </tt>.
1211  *
1212  * <tt> struct tm </tt>, declared on @c time.h, is a structure composed by
1213  * nine integers:
1214  * @li tm_sec   seconds [0,59]
1215  * @li tm_min   minutes [0,59]
1216  * @li tm_hour  hour [0,23]
1217  * @li tm_mday  day of month [1,31]
1218  * @li tm_mon   month of year [0,11]
1219  * @li tm_year  years since 1900
1220  * @li tm_wday  day of week [0,6] (Sunday = 0)
1221  * @li tm_yday  day of year [0,365]
1222  * @li tm_isdst daylight savings flag
1223  * @note glib version has 2 additional fields.
1224  *
1225  * For our function, only stuff that matters are tm_mon and tm_year.
1226  * But we don't need to access it directly, since there are nice functions
1227  * to format date and time, as @c strftime.
1228  * We will get abbreviated month (%b) and year (%y) (check strftime manpage
1229  * for more) in our example:
1230  * @skipline static char
1231  * @until }
1232  *
1233  * We need to alloc the string to be returned, and calendar widget will
1234  * free it when it's not needed, what is done by @c strdup.
1235  * So let's register our callback to calendar object:
1236  * @skipline elm_calendar_format_function_set
1237  *
1238  * To set weekday names, we should declare them as an array of strings:
1239  * @dontinclude calendar_example_02.c
1240  * @skipline weekdays[]
1241  * @until }
1242  *
1243  * And finally set them to calendar:
1244  * @skipline weekdays_names_set
1245  *
1246  * Our example will look like this:
1247  *
1248  * @image html screenshots/calendar_example_02.png
1249  * @image latex screenshots/calendar_example_02.eps width=\textwidth
1250  *
1251  * See the full source code @ref calendar_example_02.c here.
1252  * @example calendar_example_02.c
1253  */
1254
1255 /**
1256  * @page calendar_example_03 Calendar - Years restrictions.
1257  * @dontinclude calendar_example_03.c
1258  *
1259  * This example explains how to set max and min year to be displayed
1260  * by a calendar object. This means that user won't be able to
1261  * see or select a date before and after selected years.
1262  * By default, limits are 1902 and maximun value will depends
1263  * on platform architecture (year 2037 for 32 bits); You can
1264  * read more about time functions on @c ctime manpage.
1265  *
1266  * Straigh to the point, to set it is enough to call
1267  * elm_calendar_min_max_year_set(). First value is minimun year, second
1268  * is maximum. If first value is negative, it won't apply limit for min
1269  * year, if the second one is negative, won't apply for max year.
1270  * Setting both to negative value will clear limits (default state):
1271  * @skipline elm_calendar_min_max_year_set
1272  *
1273  * Our example will look like this:
1274  *
1275  * @image html screenshots/calendar_example_03.png
1276  * @image latex screenshots/calendar_example_03.eps width=\textwidth
1277  *
1278  * See the full source code @ref calendar_example_03.c here.
1279  * @example calendar_example_03.c
1280  */
1281
1282 /**
1283  * @page calendar_example_04 Calendar - Days selection.
1284  * @dontinclude calendar_example_04.c
1285  *
1286  * It's possible to disable date selection and to select a date
1287  * from your program, and that's what we'll see on this example.
1288  *
1289  * If isn't required that users could select a day on calendar,
1290  * only interacting going through months, disabling days selection
1291  * could be a good idea to avoid confusion. For that:
1292  * @skipline elm_calendar_day_selection_disabled_set
1293  *
1294  * Also, regarding days selection, you could be interested to set a
1295  * date to be highlighted on calendar from your code, maybe when
1296  * a specific event happens, or after calendar creation. As @c time output is
1297  * in seconds, we define the number of seconds contained within a day as a
1298  * constant:
1299  * @dontinclude calendar_example_04.c
1300  * @skipline SECS_DAY
1301  *
1302  * Now let's select two days from current day:
1303  * @skipline time(NULL)
1304  * @until elm_calendar_selected_time_set
1305  *
1306  * Our example will look like this:
1307  *
1308  * @image html screenshots/calendar_example_04.png
1309  * @image latex screenshots/calendar_example_04.eps width=\textwidth
1310  *
1311  * See the full source code @ref calendar_example_04.c here.
1312  * @example calendar_example_04.c
1313  */
1314
1315 /**
1316  * @page calendar_example_05 Calendar - Signal callback and getters.
1317  * @dontinclude calendar_example_05.c
1318  *
1319  * Most of setters explained on previous examples have associated getters.
1320  * That's the subject of this example. We'll add a callback to display
1321  * all calendar information every time user interacts with the calendar.
1322  *
1323  * Let's check our callback function:
1324  * @skipline static void
1325  * @until double interval;
1326  *
1327  * To get selected day, we need to call elm_calendar_selected_time_get(),
1328  * but to assure nothing wrong happened, we must check for function return.
1329  * It'll return @c EINA_FALSE if fail. Otherwise we can use time set to
1330  * our structure @p stime.
1331  * @skipline elm_calendar_selected_time_get
1332  * @until return
1333  *
1334  * Next we'll get information from calendar and place on declared vars:
1335  * @skipline interval
1336  * @until elm_calendar_weekdays_names_get
1337  *
1338  * The only tricky part is that last line gets an array of strings
1339  * (char arrays), one for each weekday.
1340  *
1341  * Then we can simple print that to stdin:
1342  * @skipline printf
1343  * @until }
1344  *
1345  * <tt> struct tm </tt> is declared on @c time.h. You can check @c ctime
1346  * manpage to read about it.
1347  *
1348  * To register this callback, that will be called every time user selects
1349  * a day or goes to next or previous month, just add a callback for signal
1350  * @b changed.
1351  * @skipline evas_object_smart_callback_add
1352  *
1353  * Our example will look like this:
1354  *
1355  * @image html screenshots/calendar_example_05.png
1356  * @image latex screenshots/calendar_example_05.eps width=\textwidth
1357  *
1358  * See the full source code @ref calendar_example_05.c here.
1359  * @example calendar_example_05.c
1360  */
1361
1362 /**
1363  * @page calendar_example_06 Calendar - Calendar marks.
1364  * @dontinclude calendar_example_06.c
1365  *
1366  * On this example marks management will be explained. Functions
1367  * elm_calendar_mark_add(), elm_calendar_mark_del() and
1368  * elm_calendar_marks_clear() will be covered.
1369  *
1370  * To add a mark, will be required to choose three things:
1371  * @li mark style
1372  * @li mark date, or start date if it will be repeated
1373  * @li mark periodicity
1374  *
1375  * Style defines the kind of mark will be displayed over marked day,
1376  * on caledar. Default theme supports @b holiday and @b checked.
1377  * If more is required, is possible to set a new theme to calendar
1378  * widget using elm_object_style_set(), and use
1379  * the signal that will be used by such marks.
1380  *
1381  * Date is a <tt> struct tm </tt>, as defined by @c time.h. More can
1382  * be read on @c ctime manpage.
1383  * If a date relative from current is required, this struct can be set
1384  * as:
1385  * @skipline time(NULL)
1386  * @until localtime_r
1387  *
1388  * Or if it's an absolute date, you can just declare the struct like:
1389  * @dontinclude calendar_example_06.c
1390  * @skipline sunday
1391  * @until christmas.tm_mon
1392  *
1393  * Periodicity is how frequently the mark will be displayed over the
1394  * calendar.  Can be a unique mark (that don't repeat), or it can repeat
1395  * daily, weekly, monthly or annually. It's enumerated by
1396  * @c Elm_Calendar_Mark_Repeat_Type.
1397  *
1398  * So let's add some marks to our calendar. We will add christmas holiday,
1399  * set Sundays as holidays, and check current day and day after that.
1400  * @dontinclude calendar_example_06.c
1401  * @skipline sunday
1402  * @until christmas.tm_mon
1403  * @skipline current_time
1404  * @until ELM_CALENDAR_WEEKLY
1405  *
1406  * We kept the return of first mark add, because we don't really won't it
1407  * to be checked, so let's remove it:
1408  * @skipline elm_calendar_mark_del
1409  *
1410  * After all marks are added and removed, is required to draw them:
1411  * @skipline elm_calendar_marks_draw
1412  *
1413  * Finally, to clear all marks, let's set a callback for our button:
1414  * @skipline elm_button_add
1415  * @until evas_object_show(bt);
1416  *
1417  * This callback will receive our calendar object, and should clear it:
1418  * @dontinclude calendar_example_06.c
1419  * @skipline static
1420  * @until }
1421  * @note Remember to draw marks after clear the calendar.
1422  *
1423  * Our example will look like this:
1424  *
1425  * @image html screenshots/calendar_example_06.png
1426  * @image latex screenshots/calendar_example_06.eps width=\textwidth
1427  *
1428  * See the full source code @ref calendar_example_06.c here.
1429  * @example calendar_example_06.c
1430  */
1431
1432 /**
1433  * @page spinner_example Spinner widget example
1434  *
1435  * This code places seven Elementary spinner widgets on a window, each of
1436  * them exemplifying a part of the widget's API.
1437  *
1438  * The first of them is the default spinner:
1439  * @dontinclude spinner_example.c
1440  * @skipline elm_spinner_add
1441  * @until evas_object_show
1442  * As you see, the defaults for a spinner are:
1443  * @li no wrap
1444  * @li min value set to 0
1445  * @li max value set to 100
1446  * @li step value set to 1
1447  * @li label format set to "%0.f"
1448  *
1449  * If another format is required, see the second spinner. It will put a text
1450  * before and after the value, and also format value to display two decimals:
1451  * @skipline format_set
1452  *
1453  * The third one will use a customized step, define new minimum and maximum
1454  * values and enable wrap, so when value reaches minimum it jumps to maximum,
1455  * or jumps to minimum after maximum value is reached. Format is set to display
1456  * a decimal:
1457  * @skipline elm_spinner_add
1458  * @until evas_object_show
1459  *
1460  * The fourth uses @c vertical style, so instead of left and right arrows,
1461  * top and bottom are displayed. Also the change interval is reduced, so
1462  * user can change value faster.
1463  * @skipline style
1464  * @skipline interval
1465  *
1466  * In the fifth the user won't be allowed to set value directly, i.e., will
1467  * be obligate change value only using arrows:
1468  * @skipline editable
1469  *
1470  * The sixth widget will receive a lot of special values, so
1471  * instead of reading numeric values, user will see labels for each one.
1472  * Also direct edition is disabled, otherwise users would see the numeric
1473  * value on edition mode. User will be able to select a month in this widget:
1474  * @skipline elm_spinner_add
1475  * @until evas_object_show
1476  *
1477  * Finally the last widget will exemplify how to listen to widget's signals,
1478  * <tt> changed </tt> and <tt> delay,changed </tt>. First we need to
1479  * implement callback functions that will simply print spinner's value:
1480  * @dontinclude spinner_example.c
1481  * @skip static
1482  * @skip }
1483  * @skipline static
1484  * @until }
1485  * @until }
1486  *
1487  * The first callback function should be called everytime value changes,
1488  * the second one only after user stops to increment or decrement. Try
1489  * to keep arrows pressed and check the difference.
1490  * @skip smart_callback
1491  * @skipline smart_callback
1492  * @skipline smart_callback
1493  *
1494  * See the full @ref spinner_example.c "example", whose window should
1495  * look like this picture:
1496  *
1497  * @image html screenshots/spinner_example.png
1498  * @image latex screenshots/spinner_example.eps width=\textwidth
1499  *
1500  * See the full @ref spinner_example.c "source code" for this example.
1501  *
1502  * @example spinner_example.c
1503  */
1504
1505 /**
1506  * @page slider_example Slider widget example
1507  *
1508  * This code places seven Elementary slider widgets on a window, each of
1509  * them exemplifying a part of the widget's API.
1510  *
1511  * The first of them is the default slider:
1512  * @dontinclude slider_example.c
1513  * @skipline elm_slider_add
1514  * @until evas_object_show
1515  *
1516  * As you see, the defaults for a slider are:
1517  * @li horizontal
1518  * @li no label
1519  * @li no values (on indicator or unit labels)
1520  *
1521  * Actually it's pretty useless this way. So let's learn how to improve it.
1522  *
1523  * If some decoration is required, a label can be set, and icon before and
1524  * after the bar as well. On the second slider will add a @c home icon
1525  * and a @c folder icon at @c end.
1526  * @skip elm_object_text_set
1527  * @until elm_object_part_content_set(sl, "end", ic)
1528  *
1529  * If the bar size need to be changed, it can be done with span set function,
1530  * that doesn't accounts other widget's parts size. Also the bar can starts
1531  * with a not default value (0.0), as we done on third slider:
1532  * @skipline value_set
1533  * @skipline span_size_set
1534  *
1535  * So far, users won't be able to see the slider value. If it's required,
1536  * it can be displayed in two different areas, units label or above
1537  * the indicator.
1538  *
1539  * Let's place a units label on our widget, and also let's set minimum and
1540  * maximum value (uses 0.0 and 1.0 by default):
1541  * @skipline unit_format_set
1542  * @skipline min_max_set
1543  *
1544  * If above the indicator is the place to display the value, just set it.
1545  * Also, is possible to invert a bar, as you can see:
1546  * @skipline indicator_format_set
1547  * @skipline inverted_set
1548  *
1549  * But if you require to use a function a bit more customized to show the value,
1550  * is possible to registry a callback function that will be called
1551  * to display unit or indicator label. Only the value will be passed to this
1552  * function, that should return a string.
1553  * In this case, a function to free this string will be required.
1554  *
1555  * Let's exemplify with indicator label on our sixth slider:
1556  * @dontinclude slider_example.c
1557  * @skip static
1558  * @skip }
1559  * @skip static
1560  * @skip }
1561  * @skip static
1562  * @skip }
1563  * @skipline static
1564  * @until }
1565  * @until }
1566  *
1567  * Setting callback functions:
1568  * @skipline indicator_format_function_set
1569  * @skipline _indicator_free
1570  *
1571  * Also, a slider can be displayed vertically:
1572  * @dontinclude slider_example.c
1573  * @skipline elm_slider_horizontal_set
1574  *
1575  * Finally the last widget will exemplify how to listen to widget's signals,
1576  * <tt> changed </tt> and <tt> delay,changed </tt>. First we need to
1577  * implement callback functions that will simply print slider's value:
1578  * @dontinclude slider_example.c
1579  * @skip static
1580  * @skip }
1581  * @skipline static
1582  * @until }
1583  * @until }
1584  *
1585  * The first callback function should be called everytime value changes,
1586  * the second one only after user stops to increment or decrement. Try
1587  * to keep arrows pressed and check the difference.
1588  * @skip smart_callback
1589  * @skipline smart_callback
1590  * @skipline smart_callback
1591  *
1592  * See the full @ref slider_example.c "example", whose window should
1593  * look like this picture:
1594  *
1595  * @image html screenshots/slider_example.png
1596  * @image latex screenshots/slider_example.eps width=\textwidth
1597  *
1598  * See the full @ref slider_example.c "source code" for this example.
1599  *
1600  * @example slider_example.c
1601  */
1602
1603 /**
1604  * @page panes_example Panes widget example
1605  *
1606  * This code places two Elementary panes widgets on a window, one of them
1607  * displayed vertically and the other horizontally, to exemplify
1608  * a part of the widget's API. Also, all the signals emitted by this
1609  * widget will be covered.
1610  *
1611  * Let's start adding a panes to our window:
1612  * @dontinclude panes_example.c
1613  * @skipline elm_panes_add
1614  * @until evas_object_show
1615  *
1616  * Now we will set a content (a simple button) to the left side of our
1617  * panes widget:
1618  * @skipline elm_button_add
1619  * @until content_left_set
1620  *
1621  * The content of the right side will be something a bit more elaborated, we'll
1622  * place another panes, displayed vertically (it's displayed horizontally
1623  * by default):
1624  * @skipline elm_panes_add
1625  * @until content_right_set
1626  *
1627  * When populating a panes displayed vertically, remember that left content
1628  * will be placed at top, and right content will place at bottom. Next
1629  * we will add two buttons to exemplify that:
1630  * @skipline elm_button_add
1631  * @until content_right_set
1632  *
1633  * Panes widgets emits 4 different signals, depending on users interaction
1634  * with the draggable bar. We'll add a callback function for each of them.
1635  *
1636  * <tt> "clicked" signal </tt>:
1637  *
1638  * Callback function that just print "Clicked" to stdin:
1639  * @dontinclude panes_example.c
1640  * @skip static void
1641  * @skip }
1642  * @skip static void
1643  * @skip }
1644  * @skip static void
1645  * @skip }
1646  * @skipline static void
1647  * @until }
1648  *
1649  * Also, add callback function to the panes:
1650  * @skipline "clicked"
1651  *
1652  * <tt> "press" signal </tt>:
1653  *
1654  * Callback function that just print "Pressed" to stdin:
1655  * @dontinclude panes_example.c
1656  * @skip static void
1657  * @skip }
1658  * @skipline static void
1659  * @until }
1660  *
1661  * Also, add callback function to the panes:
1662  * @skipline "press"
1663  *
1664  * Now, let's try to make our callback functions a bit more useful:
1665  *
1666  * <tt> "unpress" signal </tt>:
1667  *
1668  * Suppose we want to know the size proportion of left content after
1669  * user drags the bar. We need to listen for @c unpress signal, and
1670  * get this size from our panes widget. It's done on the following
1671  * function:
1672  * @dontinclude panes_example.c
1673  * @skip static void
1674  * @skip }
1675  * @skip static void
1676  * @skip }
1677  * @skipline static void
1678  * @until }
1679  *
1680  * Adding the callback function to the panes:
1681  * @skipline "unpress"
1682
1683  * <tt> "clicked,double" signal </tt>:
1684  *
1685  * Now, a interesting feature that could be addded to panes widget.
1686  * Hide a content when user double click the draggable bar. It's done
1687  * using a variable to store size and content left size getter and setter
1688  * on the following function:
1689  * @dontinclude panes_example.c
1690  * @skipline static double
1691  * @skip static void
1692  * @skip }
1693  * @skip static void
1694  * @skip }
1695  * @skip static void
1696  * @skip }
1697  * @skipline static void
1698  * @until }
1699  * @until }
1700  * @until }
1701  *
1702  * Adding the callback function to the panes:
1703  * @skipline "clicked,double"
1704  * @until panes);
1705  *
1706  * See the full @ref panes_example.c "example", whose window should
1707  * look like this picture:
1708  *
1709  * @image html screenshots/panes_example.png
1710  * @image latex screenshots/panes_example.eps width=\textwidth
1711  *
1712  * @example panes_example.c
1713  */
1714
1715 /**
1716  * @page clock_example Clock widget example
1717  *
1718  * This code places five Elementary clock widgets on a window, each of
1719  * them exemplifying a part of the widget's API.
1720  *
1721  * The first of them is the pristine clock:
1722  * @dontinclude clock_example.c
1723  * @skip pristine
1724  * @until evas_object_show
1725  * As you see, the defaults for a clock are:
1726  * - military time
1727  * - no seconds shown
1728  *
1729  * For am/pm time, see the second clock:
1730  * @dontinclude clock_example.c
1731  * @skip am/pm
1732  * @until evas_object_show
1733  *
1734  * The third one will show the seconds digits, which will flip in
1735  * synchrony with system time. Note, besides, that the time itself is
1736  * @b different from the system's -- it was customly set with
1737  * elm_clock_time_set():
1738  * @dontinclude clock_example.c
1739  * @skip with seconds
1740  * @until evas_object_show
1741  *
1742  * In both fourth and fifth ones, we turn on the <b>edition
1743  * mode</b>. See how you can change each of the sheets on it, and be
1744  * sure to try holding the mouse pressed over one of the sheet
1745  * arrows. The forth one also starts with a custom time set:
1746  * @dontinclude clock_example.c
1747  * @skip in edition
1748  * @until evas_object_show
1749  *
1750  * The fifth, besides editable, has only the time @b units editable,
1751  * for hours, minutes and seconds. This exemplifies
1752  * elm_clock_edit_mode_set():
1753  * @dontinclude clock_example.c
1754  * @skip but only
1755  * @until evas_object_show
1756  *
1757  * See the full @ref clock_example.c "example", whose window should
1758  * look like this picture:
1759  *
1760  * @image html screenshots/clock_example.png
1761  * @image latex screenshots/clock_example.eps width=\textwidth
1762  *
1763  * See the full @ref clock_example_c "source code" for this example.
1764  *
1765  * @example clock_example.c
1766  */
1767
1768 /**
1769  * @page datetime_example Datetime widget example
1770  *
1771  * This code places three Elementary Datetime widgets on a window, each of
1772  * them exemplifying the widget's different usage.
1773  *
1774  * The first of them is <b>"only Date display"</b>:
1775  * @dontinclude datetime_example.c
1776  * @skip only DATE
1777  * @until evas_object_show
1778  *
1779  * For <b>"only Time display"</b>, see the second datetime:
1780  * @dontinclude datetime_example.c
1781  * @skip only TIME
1782  * @until evas_object_show
1783  *
1784  * The third one will display datetime shows both <b>Date and Time</b>, corresponding format will be
1785  * taken from system @b locale. Note, besides, that the strings are different
1786  *  for different language settings.
1787  *
1788  * <b>Datetime format</b> can be programmatically set by using 
1789  * elm_datetime_format_set():
1790  * @dontinclude datetime_example.c
1791  * @skip DATE and TIME
1792  * @until evas_object_show
1793  * The default format of any locale consists:
1794  * - Year Field
1795  * - Month Field
1796  * - Date Field
1797  * - Hour Field(12hr/24hr format)
1798  * - Minute Field
1799  * - AM/PM (if exists).
1800  *
1801  * This is how the example program's window looks like with the datetime widget
1802  * showing only date, only time and both date & time:
1803  *
1804  * @image html screenshots/datetime_example.png
1805  * @image latex screenshots/datetime_example.eps width=\textwidth
1806  *
1807  * See the full @ref datetime_example_c "source code" for
1808  * this example.
1809  *
1810  * @example datetime_example.c
1811  */
1812
1813 /**
1814  * @page dayselector_example Dayselector widget example
1815  *
1816  * This code places two Elementary dayselector widgets on a window, each of
1817  * them exemplifying the different widget styles.
1818  *
1819  * The first of them is the dayselector in default style:
1820  * @dontinclude dayselector_example.c
1821  * @skip weekdays starting from Sunday
1822  * @until evas_object_show
1823  *
1824  * As you see, the default style displays the weekdays starting from Sunday.
1825  *
1826  * One can select/unselect a day just by clicking on the day object.
1827  * The selection toggles once it is being pressed.
1828  *
1829  *
1830  * For showing weekdays starting from Monday, see the second dayselector:
1831  * @dontinclude dayselector_example.c
1832  * @skip weekdays starting from Monday
1833  * @until evas_object_show
1834  *
1835  *
1836  * The following code exemplifies the selection APIs of Dayselector:
1837  * @dontinclude dayselector_example.c
1838  * @skip Callback function
1839  * @until End of clicked callback
1840  *
1841  *
1842  * See the full @ref dayselector_example.c "example", whose window should
1843  * look like this picture:
1844  *
1845  * @image html screenshots/dayselector_example.png
1846  * @image latex screenshots/dayselector_example.eps width=\textwidth
1847  *
1848  * See the full @ref dayselector_example_c "source code" for this example.
1849  *
1850  * @example dayselector_example.c
1851  */
1852
1853 /**
1854  * @page mapbuf_example Mapbuf Widget Example
1855  *
1856  * This code places a Elementary mapbuf widget on a window,
1857  * to exemplify part of the widget's API.
1858  *
1859  * First we'll add an window with a background and a vertical box to
1860  * pack our interface elements:
1861  * @dontinclude mapbuf_example.c
1862  * @skipline win_add
1863  * @until show(bx)
1864  *
1865  * Next we'll simply add the mapbuf widget to the box:
1866  * @skipline mapbuf_add
1867  * @until pack_end
1868  *
1869  * But mapbuf is a container widget, it won't do anything alone. So let's
1870  * create a table full of icons. For that we'll loop to fill each line of each
1871  * column. See @ref tutorial_table_01 "tutorial_table_01"
1872  * if you don't know how to use tables:
1873  * @skipline table_add
1874  * @until }
1875  * @until }
1876  *
1877  * Finally, setting mapbuf content:
1878  * @skipline content_set
1879  * @skipline show
1880  *
1881  * Also, would be good a horizontal box with some controls to change mapbuf
1882  * behavior:
1883  * @skipline box_add
1884  * @until show
1885  *
1886  * By default map is disabled. So just setting content isn't enough.
1887  * Alpha and smooth settings will be applied when map is enabled.
1888  * So we'll add a check for that. Everytime the map properties
1889  * are changed, map will need to be enabled again. So if you
1890  * want to play a bit with our example, remember to always enable
1891  * map again after concluding your changes.
1892  * @skipline check_add
1893  * @until show
1894  *
1895  * We have added a callback function to this check, so it will enable
1896  * or disable map:
1897  * @dontinclude mapbuf_example.c
1898  * @skip static
1899  * @skip }
1900  * @skipline static
1901  * @until }
1902  *
1903  * Let's add check boxes for alpha blending and smooth rendering:
1904  * @skipline check_add
1905  * @until show
1906  * @until show
1907  *
1908  * By default, mapbuf would enable alpha blending and smooth rendering,
1909  * so we need to check boxes to be consistent with its behavior.
1910  *
1911  * Callback functions look like the one added to the check. This way we
1912  * could enable or disable the both properties:
1913  * @dontinclude mapbuf_example.c
1914  * @skip static
1915  * @skip }
1916  * @skip static
1917  * @skip }
1918  * @skipline static
1919  * @until }
1920  * @until }
1921  *
1922  * You'll see that disabling alpha blending will set a black rectangle below
1923  * the icons. That's the reason you only should enable that when you're sure
1924  * the mapbuf content is 100% solid.
1925  *
1926  * See @ref mapbuf_example.c "mapbuf_example.c", whose window should
1927  * look like this picture:
1928  *
1929  * @image html screenshots/mapbuf_example.png
1930  * @image latex screenshots/mapbuf_example.eps width=\textwidth
1931  *
1932  * @example mapbuf_example.c
1933  */
1934
1935 /**
1936  * @page map_example_01 Map Example - Creation and Zoom
1937  *
1938  * This code places a Elementary map widget on a window,
1939  * to exemplify part of the widget's API.
1940  *
1941  * Let's start adding a map to our window:
1942  * @dontinclude map_example_01.c
1943  * @skipline elm_map_add
1944  * @until evas_object_show
1945  *
1946  * It's enough to display a world map inside our window. But usually you'll
1947  * need to let user interact with the map. We need to place some buttons,
1948  * so the user could control the map. It's done on the followin code.
1949  * If you don't know about boxes, or buttons, check their examples,
1950  * @ref box_example_01 "Box Example 1" and
1951  * @ref button_example_01 "Button Example 1".
1952  * @skipline elm_box_add
1953  * @until _bt_zoom_fill
1954  *
1955  * We are adding callback functions that will be called when the user clicks
1956  * over these buttons. Let's study such functions, starting from the function
1957  * that will zoom in the map:
1958  * @dontinclude map_example_01.c
1959  * @skipline static void
1960  * @until }
1961  *
1962  * First thing done is assure zoom mode is set to manual. It's the default
1963  * mode, but the other buttons will change this, so before setting a new
1964  * zoom value, we need to change the zoom mode.
1965  *
1966  * Then, we get the current zoom value, increment that, and set the new
1967  * value to the map. If it's bigger than max zoom value allowed, it will
1968  * remain on the maximum allowed, nothing bad will happen. This way we
1969  * don't need to check first if it won't be bigger than max.
1970  *
1971  * Zoom out function is basically the same thing, but zoom will be decremented
1972  * instead of incremented:
1973  * @skipline static void
1974  * @until }
1975  *
1976  * The "X" button, when pressed, will call a function that will
1977  * zoom the map until it fits
1978  * inside the scroll frame with no pixels outside this area:
1979  * @skipline static void
1980  * @until }
1981  *
1982  * And the "#" button, will call a function that will zoom until map fills
1983  * scroll, ensuring no pixels are left unfilled:
1984  * @skipline static void
1985  * @until }
1986  *
1987  * But we can also set map to show something different from default
1988  * world map, changing the zoom level and region shown. Let's pick a
1989  * wonderful city coordinates, one placed at <tt> 43 20 S, 22 90 W </tt>.
1990  * Since map uses double variables to represent latitude and longitude,
1991  * to represent north or east, we should represent it as positive values,
1992  * and south or west as negative. Also, the value will be represented as
1993  * degree.min. So, for example, our longitude <tt> 43 20 S </tt> will
1994  * be represented
1995  * by the value <tt> -43.20 </tt>. A zoom set to @c 12 should be enough
1996  * to show a city.
1997  * @skipline region_show
1998  * @until zoom_set
1999  *
2000  * See @ref map_example_01.c "map_example_01.c" for full source,
2001  * whose window should
2002  * look like this picture:
2003  *
2004  * @image html screenshots/map_example_01.png
2005  * @image latex screenshots/map_example_01.eps width=\textwidth
2006  *
2007  * @example map_example_01.c
2008  */
2009
2010 /**
2011  * @page map_example_02 Map Example - Overlay Usage
2012  *
2013  * This code places a Elementary map widget on a window,
2014  * to exemplify part of the widget's API, related to overlays.
2015  *
2016  * We'll start this example in the same way
2017  * @ref map_example_01 "Map Example 1". Adding a map with buttons to control
2018  * zoom, so if you didn't read it yet, just do it now.
2019  * @dontinclude map_example_02.c
2020  * @skipline elm_map_add
2021  * @until zoom_fill
2022  *
2023  * Overlays can be placed over the map to represent anything we want. Let's
2024  * say we want to represent some countries and cities with overlays. 
2025  * 
2026  * Before we create city or country overlays, let's create class overlays. 
2027  *
2028  * @skipline elm_map_overlay_class_add
2029  * @until elm_map_overlay_icon_set
2030  * These lines create a class overlay which represents cities.
2031  * This class overlay will be used for grouping city overlays. 
2032  * Later city overlays in the same class are appended to this class overlay. 
2033  * if city overlays are near each other, they will be grouped.
2034  *
2035  * We can set the icon for the class so that the icon will be displayed 
2036  * when city overlays are grouped.
2037  * We can set the zoom required to display the overlays that belongs
2038  * to this class, so if the zoom is less than this value, nothing
2039  * will be shown. 
2040  * 
2041  * Country class can be created in the same way.
2042  * @skipline elm_map_overlay_class_add
2043  * @until elm_map_overlay_icon_set
2044  *
2045  * Next we'll create some overlays representing cities and coutries.
2046  * We set the data for the overlay so that can be used later when 
2047  * clicked callback is called.
2048  * We'll append them into city class to be grouped.
2049  * We'll append them in a list, to close up them later. 
2050  * To create a default overlay, we need to pass the coordinates.
2051  * @skipline elm_map_overlay_add
2052  * @until eina_list_append
2053  *
2054  * We subscribe a smart callback "overlay,clicked" to create bubble on 
2055  * the clicked overlay.
2056  * @dontinclude map_example_02.c
2057  * @skipline "overlay,clicked"
2058  *
2059  * Finally, on our @c main function, we ask the map to show all the overlays
2060  * with the biggest zoom possible, passing the list of overlays added.
2061  * @skipline elm_map_overlays_show
2062  *
2063  * We have created a specific structure for this example to store the name
2064  * of the place and a path to a image file to represent it.
2065  * @dontinclude map_example_02.c
2066  * @skipline typedef
2067  * @until Overlay_Data;
2068  *
2069  * We'll create instances for each place:
2070  * @skipline argentina
2071  * @until sky_03
2072  *
2073   * To return an icon, all we need to do is to add a elm_icon and return it:
2074  * @dontinclude map_example_02.c
2075  * @skipline _icon_get(
2076  * @until }
2077  *
2078  * For the content, let's return something more elaborate. We will return
2079  * a box with an image representing the place, and the name of this place:
2080  * @skipline _box_get(
2081  * @until }
2082  *
2083  * See @ref map_example_02.c "map_example_02.c" for full source,
2084  * whose window should
2085  * look like this picture:
2086  *
2087  * @image html screenshots/map_example_02.png
2088  * @image latex screenshots/map_example_02.eps width=\textwidth
2089  *
2090  * @example map_example_02.c
2091  */
2092
2093 /**
2094  * @page map_example_03 Map Example - Route and Name Usage
2095  *
2096  * This code places a Elementary map widget on a window,
2097  * to exemplify part of the widget's API, related routes and names.
2098  *
2099  * In this example, we will suppose we need to set a route for the user
2100  * from his current point (a gps could provide us this information)
2101  * to somewhere else. So we would have coordinates of this
2102  * start point, and would like that he enters the address of his
2103  * destination in a entry, and we'll trace a route on the map.
2104  *
2105  * We'll start this example in the same way
2106  * @ref map_example_01 "Map Example 1". Adding a map with buttons to control
2107  * zoom, so if you didn't read it yet, just do it now. Actually there is
2108  * a change, that we're aligning buttons to the top, since we wan't a
2109  * vertical control box this time.
2110  * @dontinclude map_example_03.c
2111  * @skipline elm_map_add
2112  * @until zoom_fill
2113  * @until align_set
2114  *
2115  * Next we set the box to be vertical and change it's size, weight
2116  * and alignment, so it will occupy the top of the window, from left
2117  * to right:
2118  * @skipline horizontal_set
2119  * @until align_set
2120  *
2121  * We'll add an entry with a preliminar address, that I know will
2122  * find a coordinate, to examplify names work. But you can try
2123  * lots of addresses. From city or country names to pubs, or whatever
2124  * you want. To try is enough to run the example, type the address and
2125  * press "Route" button. This button will call a function that will
2126  * get the typed address and find the route.
2127  * @skipline entry_add
2128  * @until align_set
2129  * @until align_set
2130  *
2131  * The button pass an structure
2132  * instance we make for this example, with all the fields we'll need.
2133  * @dontinclude map_example_03.c
2134  * @skipline _Example_Data
2135  * @until example_data;
2136  *
2137  * Let's initialize it's fields:
2138  * @skipline example_data.map
2139  * @until example_data.start_lat
2140  *
2141  * @c map and @c entry are our elementary objects, @c route is set to @c NULL,
2142  * since we don't have one yet, and the coordinates of the start point is set
2143  * (longitude and latitude).
2144  *
2145  * Also, let's show this start point at the center of the map, and set a zoom
2146  * nice enough to close it:
2147  * @skipline region_show
2148  * @until zoom_set
2149  *
2150  * These lines were already explained on @ref map_example_02 "Map Example 2".
2151  *
2152  * Now we'll see the "Route" button callback function:
2153  * @dontinclude map_example_03.c
2154  * @skip static void
2155  * @skip }
2156  * @skipline static void
2157  * @until }
2158  *
2159  * First we get the address string from our entry. Then we use @c name
2160  * conversion
2161  * util functions, so we could get coordinates for this address. These
2162  * functions return an #Elm_Map_Name handle for us.
2163  * Function elm_map_name_geo_request() will do this job for us,
2164  * but it's an assyncronous function, since it requires this
2165  * information from the server.
2166  *
2167  * That's the reason we need to wait for
2168  * <tt> "name,loaded" </tt> signal. We add a callback function for this:
2169  * @dontinclude map_example_03.c
2170  * @skipline static void
2171  * @until }
2172  *
2173  * This function will check if a previous route was traced, and if it was,
2174  * it will remove it. Next we'll get destination coordinates from our
2175  * @c name, and use them to add a new route.
2176  *
2177  * To trace a route we need to know how the user will go through the path.
2178  * Let's suppose he'll be walking, but doesn't like to walk, so we
2179  * need to choose the shortest path intead of the route that would
2180  * made him spend less time. Coordinates of the point from where he will
2181  * start and of the destination point need to be passed as well.
2182  *
2183  * Finally we'll set a color different from solid red (default), to show
2184  * our route. We set it green.
2185  *
2186  * See @ref map_example_03.c "map_example_03.c" for full source,
2187  * whose window should
2188  * look like this picture:
2189  *
2190  * @image html screenshots/map_example_03.png
2191  * @image latex screenshots/map_example_03.eps width=\textwidth
2192  *
2193  * @example map_example_03.c
2194  */
2195
2196 /**
2197  * @page diskselector_example_01 Diskselector widget example
2198  *
2199  * This code places 4 Elementary diskselector widgets on a window, each of
2200  * them exemplifying a part of the widget's API.
2201  *
2202  * All of them will have weekdays as items, since we won't focus
2203  * on items management on this example. For an example about this subject,
2204  * check @ref diskselector_example_02.
2205  *
2206  * The first of them is a default diskselector.
2207  * @dontinclude diskselector_example_01.c
2208  * @skipline lbl
2209  * @until }
2210  * @skipline elm_diskselector_add
2211  * @until evas_object_show
2212  *
2213  * We are just adding the diskselector, so as you can see, defaults for it are:
2214  * @li Only 3 items visible each time.
2215  * @li Only 3 characters are displayed for labels on side positions.
2216  * @li The first added item remains centeres, i.e., it's the selected item.
2217  *
2218  * To add items, we are just appending it on a loop, using function
2219  * elm_diskselector_item_append(), that will be better exaplained on
2220  * items management example.
2221  *
2222  * For a circular diskselector, check the second widget. A circular
2223  * diskselector will display first item after last, and last previous to
2224  * the first one. So, as you can see, @b Sa will appears on left side
2225  * of selected @b Sunday. This property is set with
2226  * elm_diskselector_round_enabled_set().
2227  *
2228  * Also, we decide to display only 2 character for side labels, instead of 3.
2229  * For this we call elm_diskselector_side_text_max_length_set(). As result,
2230  * we'll see @b Mo displayed instead of @b Mon, when @b Monday is on a
2231  * side position.
2232  *
2233  * @skipline elm_diskselector_add
2234  * @until evas_object_show
2235  *
2236  * But so far, we are only displaying 3 items at once. If more are wanted,
2237  * is enough to call elm_diskselector_display_item_num_set(), as you can
2238  * see here:
2239  * @skipline elm_diskselector_add
2240  * @until elm_diskselector_display_item_num_set
2241  *
2242  * @note You can't set less than 3 items to be displayed.
2243  *
2244  * You can get the number of items in the diskselector by calling
2245  * elm_diskselector_display_item_num_get(), as you can see here:
2246  * @skipline elm_diskselector_display_item_num_get
2247  *
2248  * Finally, if a bounce effect is required, or you would like to see
2249  * scrollbars, it is possible. But, for default theme, diskselector
2250  * scrollbars will be invisible anyway.
2251  * @skipline elm_diskselector_add
2252  * @until evas_object_show
2253  *
2254  * See the full @ref diskselector_example_01.c "diskselector_example_01.c"
2255  * code, whose window should look like this picture:
2256  *
2257  * @image html screenshots/diskselector_example_01.png
2258  * @image latex screenshots/diskselector_example_01.eps width=\textwidth
2259  *
2260  * @example diskselector_example_01.c
2261  */
2262
2263 /**
2264  * @page diskselector_example_02 Diskselector - Items management
2265  *
2266  * This code places a Elementary diskselector widgets on a window,
2267  * along with some buttons trigerring actions on it (though its API).
2268  * It covers most of diskselector item functions.
2269  *
2270  * On our @c main function, we are adding a default diskselector with
2271  * 3 items. We are only setting their labels (second parameter of function
2272  * elm_diskselector_item_append):
2273  * @dontinclude diskselector_example_02.c
2274  * @skipline elm_diskselector_add
2275  * @until Item 2
2276  *
2277  * Next we are adding lots of buttons, each one for a callback function
2278  * that will realize a task covering part of diskselector items API.
2279  * Lets check the first one:
2280  * @skipline elm_button_add
2281  * @until evas_object_show
2282  *
2283  * We are labeling the button with a task description with
2284  * elm_object_text_set() and setting a callback
2285  * function evas_object_smart_callback_add().
2286  * Each callback function will have the signature:
2287  * <tt> static void _task_cb(void *data, Evas_Object *obj,
2288  * void *event_info)</tt> with the function name varying for each task.
2289  *
2290  * Now let's cover all of them.
2291  *
2292  * <b> Appending an item: </b>
2293  * @dontinclude diskselector_example_02.c
2294  * @skipline _add_cb
2295  * @until }
2296  *
2297  * All items are included on diskselector after last one. You @b can't
2298  * preprend items.
2299  *
2300  * The first parameter of elm_diskselector_item_append() is the diskselector
2301  * object, that we are receiving as data on our callback function.
2302  * The second one is a label, the string that will be placed in the center
2303  * of our item. As we don't wan't icons or callback functions, we can
2304  * send NULL as third, fourth and fifth parameters.
2305  *
2306  * <b> Appending an item with icon: </b>
2307  * @dontinclude diskselector_example_02.c
2308  * @skipline _add_ic_cb
2309  * @until }
2310  *
2311  * If an icon is required, you can pass it as third paramenter on our
2312  * elm_diskselector_item_append() function. It will be place on the
2313  * left side of item's label, that will be shifted to right a bit.
2314  *
2315  * For more details about how to create icons, look for elm_icon examples.
2316  *
2317  * <b> Appending an item with callback function for selected: </b>
2318  * @dontinclude diskselector_example_02.c
2319  * @skipline _sel_cb
2320  * @until }
2321  * @until }
2322  *
2323  * To set a callback function that will be called every time an item is
2324  * selected, i.e., everytime the diskselector stops with this item in
2325  * center position, just pass the function as fourth paramenter.
2326  *
2327  * <b> Appending an item with callback function for selected with data: </b>
2328  * @dontinclude diskselector_example_02.c
2329  * @skipline _sel_data_cb
2330  * @until }
2331  * @until }
2332  * @until }
2333  * @until }
2334  *
2335  * If the callback function request an extra data, it can be attached to our
2336  * item passing a pointer for data as fifth parameter.
2337  * Our function _sel_data_cb will receive it as <tt> void *data </tt>.
2338  *
2339  * If you want to free this data, or handle that the way you need when the
2340  * item is deleted, set a callback function for that, with
2341  * elm_object_item_del_cb_set().
2342  *
2343  * As you can see we check if @c it is not @c NULL after appending it.
2344  * If an error happens, we won't try to set a function for it.
2345  *
2346  * <b> Deleting an item: </b>
2347  * @dontinclude diskselector_example_02.c
2348  * @skipline _del_cb(void
2349  * @until }
2350  *
2351  * To delete an item we simple need to call elm_object_item_del() with
2352  * a pointer for such item.
2353  *
2354  * If you need, you can get selected item with
2355  * elm_diskselector_selected_item_get(), that will return a pointer for it.
2356  *
2357  * <b> Unselecting an item: </b>
2358  * @dontinclude diskselector_example_02.c
2359  * @skipline _unselect_cb
2360  * @until }
2361  *
2362  * To select an item, you should call elm_diskselector_item_selected_set()
2363  * passing @c EINA_TRUE, and to unselect it, @c EINA_FALSE.
2364  *
2365  * If you unselect the selected item, diskselector will automatically select
2366  * the first item.
2367  *
2368  * <b> Printing all items: </b>
2369  * @dontinclude diskselector_example_02.c
2370  * @skipline _print_cb
2371  * @until }
2372  *
2373  * <b> Clearing the diskselector: </b>
2374  * @dontinclude diskselector_example_02.c
2375  * @skipline _clear_cb
2376  * @until }
2377  *
2378  * <b> Selecting the first item: </b>
2379  * @dontinclude diskselector_example_02.c
2380  * @skipline _select_first_cb
2381  * @until }
2382  *
2383  * <b> Selecting the last item: </b>
2384  * @dontinclude diskselector_example_02.c
2385  * @skipline _select_last_cb
2386  * @until }
2387  *
2388  * <b> Selecting the next item: </b>
2389  * @dontinclude diskselector_example_02.c
2390  * @skipline _select_next_cb
2391  * @until }
2392  *
2393  * <b> Selecting the previous item: </b>
2394  * @dontinclude diskselector_example_02.c
2395  * @skipline _select_prev_cb
2396  * @until }
2397  *
2398  * See the full @ref diskselector_example_02.c "diskselector_example_02.c"
2399  * code, whose window should look like this picture:
2400  *
2401  * @image html screenshots/diskselector_example_02.png
2402  * @image latex screenshots/diskselector_example_02.eps width=\textwidth
2403  *
2404  * @example diskselector_example_02.c
2405  */
2406
2407 /**
2408  * @page list_example_01 List widget example
2409  *
2410  * This code places a single Elementary list widgets on a window, just
2411  * to exemplify the more simple and common use case: a list will be created
2412  * and populated with a few items.
2413  *
2414  * To keep it simple, we won't show how to customize the list, for this check
2415  * @ref list_example_02. Also, we won't focus
2416  * on items management on this example. For an example about this subject,
2417  * check @ref list_example_03.
2418  *
2419  * To add a list widget.
2420  * @dontinclude list_example_01.c
2421  * @skipline elm_list_add
2422  *
2423  * We are just adding the list, so as you can see, defaults for it are:
2424  * @li Items are displayed vertically.
2425  * @li Only one item can be selected.
2426  * @li The list doesn't bouce.
2427  *
2428  * To add items, we are just appending it on a loop, using function
2429  * elm_list_item_append(), that will be better exaplained on
2430  * items management example.
2431  * @dontinclude list_example_01.c
2432  * @skipline lbl[]
2433  * @until };
2434  * @skipline for
2435  * @skipline elm_list_item_append
2436  *
2437  * After we just want to show the list. But first we need to start the widget.
2438  * It was done this way to improve widget's performance. So, always remember
2439  * that:
2440  * @warning Call elm_list_go before showing the object
2441  * @skipline elm_list_go
2442  * @skipline show
2443  *
2444  * See the full @ref list_example_01.c "list_example_01.c"
2445  * code, whose window should look like this picture:
2446  *
2447  * @image html screenshots/list_example_01.png
2448  * @image latex screenshots/list_example_01.eps width=\textwidth
2449  *
2450  * @example list_example_01.c
2451  */
2452
2453 /**
2454  * @page list_example_02 List widget example
2455  *
2456  * This code places a single Elementary list widgets on a window,
2457  * exemplifying a part of the widget's API.
2458  *
2459  * First, we will just create a simple list, as done on @ref list_example_01 :
2460  * @dontinclude list_example_02.c
2461  * @skipline lbl
2462  * @until }
2463  * @skipline elm_list_add
2464  * @until elm_list_item_append
2465  *
2466  * Now, let's customize this list a bit. First we will display items
2467  * horizontally:
2468  * @skipline horizontal_set
2469  *
2470  * Then we will choose another list mode. There are four of them, and
2471  * the default #Elm_List_Mode is #ELM_LIST_SCROLL. Let's set compress mode:
2472  * @skipline mode_set
2473  *
2474  * To enable multiple items selection, we need to enable it, since only one
2475  * selected item is allowed by default:
2476  * @skipline elm_list_multi_select_set
2477  *
2478  * We are not adding items with callback functions here,
2479  * since we'll explain it better on  @ref list_example_03. But if the callback
2480  * need to be called everytime user clicks an item, even if already selected,
2481  * it's required to enable this behavior:
2482  * @skipline elm_list_select_mode_set
2483  *
2484  * Finally, if a bounce effect is required, or you would like to see
2485  * scrollbars, it is possible. But, for default theme, list
2486  * scrollbars will be invisible anyway.
2487  * @skipline bounce_set
2488  * @until SCROLLER_POLICY_ON
2489  *
2490  * See the full @ref list_example_02.c "list_example_02.c"
2491  * code, whose window should look like this picture:
2492  *
2493  * @image html screenshots/list_example_02.png
2494  * @image latex screenshots/list_example_02.eps width=\textwidth
2495  *
2496  * @example list_example_02.c
2497  */
2498
2499 /**
2500  * @page list_example_03 List - Items management
2501  *
2502  * This code places a Elementary list widgets on a window,
2503  * along with some buttons trigerring actions on it (though its API).
2504  * It covers most of elm_list_item functions.
2505  *
2506  * On our @c main function, we are adding a default list with
2507  * 3 items. We are only setting their labels (second parameter of function
2508  * elm_list_item_append):
2509  * @dontinclude list_example_03.c
2510  * @skipline elm_list_add
2511  * @until Item 2
2512  *
2513  * Next we are adding lots of buttons, each one for a callback function
2514  * that will realize a task covering part of list items API.
2515  * Lets check the first one:
2516  * @skipline elm_button_add
2517  * @until evas_object_show
2518  *
2519  * We are labeling the button with a task description with
2520  * elm_object_text_set() and setting a callback
2521  * function evas_object_smart_callback_add().
2522  * Each callback function will have the signature:
2523  * <tt> static void _task_cb(void *data, Evas_Object *obj,
2524  * void *event_info)</tt> with the function name varying for each task.
2525  *
2526  * Now let's cover all of them.
2527  *
2528  * <b> Prepending an item: </b>
2529  * @dontinclude list_example_03.c
2530  * @skipline _prepend_cb
2531  * @until }
2532  *
2533  * The item will be placed on the begining of the list,
2534  * i.e. it will be the first one.
2535  *
2536  * The first parameter of elm_list_item_prepend() is the list
2537  * object, that we are receiving as data on our callback function.
2538  * The second one is a label, the string that will be placed in the center
2539  * of our item. As we don't wan't icons or callback functions, we can
2540  * send NULL as third, fourth, fifth and sixth parameters.
2541  *
2542  * <b> Appending an item: </b>
2543  * @dontinclude list_example_03.c
2544  * @skipline _add_cb
2545  * @until }
2546  *
2547  * Items included with append will be inserted inserted after the last one.
2548  *
2549  * <b> Appending an item with icon: </b>
2550  * @dontinclude list_example_03.c
2551  * @skipline _add_ic_cb
2552  * @until }
2553  *
2554  * If an icon is required, you can pass it as third paramenter on our
2555  * elm_list_item_append() function. It will be place on the
2556  * left side of item's label. If an icon is wanted on the right side,
2557  * it should be passed as fourth parameter.
2558  *
2559  * For more details about how to create icons, look for elm_icon examples
2560  * @ref tutorial_icon.
2561  *
2562  * <b> Appending an item with callback function for selected: </b>
2563  * @dontinclude list_example_03.c
2564  * @skipline _sel_cb
2565  * @until }
2566  * @until }
2567  *
2568  * To set a callback function that will be called every time an item is
2569  * selected, i.e., everytime the list stops with this item in
2570  * center position, just pass the function as fifth paramenter.
2571  *
2572  * <b> Appending an item with callback function for selected with data: </b>
2573  * @dontinclude list_example_03.c
2574  * @skipline _sel_data_cb
2575  * @until }
2576  * @until }
2577  * @until }
2578  * @until }
2579  *
2580  * If the callback function request an extra data, it can be attached to our
2581  * item passing a pointer for data as sixth parameter.
2582  * Our function _sel_data_cb will receive it as <tt> void *data </tt>.
2583  *
2584  * If you want to free this data, or handle that the way you need when the
2585  * item is deleted, set a callback function for that, with
2586  * elm_object_item_del_cb_set().
2587  *
2588  * As you can see we check if @c it is not @c NULL after appending it.
2589  * If an error happens, we won't try to set a function for it.
2590  *
2591  * <b> Deleting an item: </b>
2592  * @dontinclude list_example_03.c
2593  * @skipline _del_cb(
2594  * @until }
2595  *
2596  * To delete an item we simple need to call elm_object_item_del() with
2597  * a pointer for such item.
2598  *
2599  * If you need, you can get selected item with
2600  * elm_list_selected_item_get(), that will return a pointer for it.
2601  *
2602  * <b> Unselecting an item: </b>
2603  * @dontinclude list_example_03.c
2604  * @skipline _unselect_cb
2605  * @until }
2606  *
2607  * To select an item, you should call elm_list_item_selected_set()
2608  * passing @c EINA_TRUE, and to unselect it, @c EINA_FALSE.
2609  *
2610  * <b> Printing all items: </b>
2611  * @dontinclude list_example_03.c
2612  * @skipline _print_cb
2613  * @until }
2614  *
2615  * <b> Clearing the list: </b>
2616  * @dontinclude list_example_03.c
2617  * @skipline _clear_cb
2618  * @until }
2619  *
2620  * <b> Selecting the next item: </b>
2621  * @dontinclude list_example_03.c
2622  * @skipline _select_next_cb
2623  * @until }
2624  *
2625  * <b> Inserting after an item: </b>
2626  * @dontinclude list_example_03.c
2627  * @skipline _insert_after_cb
2628  * @until }
2629  *
2630  * <b> Selecting the previous item: </b>
2631  * @dontinclude list_example_03.c
2632  * @skipline _select_prev_cb
2633  * @until }
2634  *
2635  * <b> Inserting before an item: </b>
2636  * @dontinclude list_example_03.c
2637  * @skipline _insert_before_cb
2638  * @until }
2639  *
2640  * If a separator is required, just set an item as such:
2641  * @dontinclude list_example_03.c
2642  * @skipline _set_separator_cb
2643  * @until }
2644  *
2645  * Also an item can be disabled, and the user won't be allowed to (un)select it:
2646  * @dontinclude list_example_03.c
2647  * @skipline _disable_cb
2648  * @until }
2649  *
2650  * See the full @ref list_example_03.c "list_example_03.c"
2651  * code, whose window should look like this picture:
2652  *
2653  * @image html screenshots/list_example_03.png
2654  * @image latex screenshots/list_example_03.eps width=\textwidth
2655  *
2656  * @example list_example_03.c
2657  */
2658
2659 /**
2660  * @page toolbar_example_01 Toolbar Example - Simple Items
2661  *
2662  * This code places a Elementary toolbar widget on a window,
2663  * to exemplify part of the widget's API.
2664  *
2665  * Let's start adding a button to our window, that will have its text
2666  * modified depending on which item is selected. It's used just to exemplify
2667  * how to change a window content from the toolbar.
2668  * @dontinclude toolbar_example_01.c
2669  * @skipline elm_button_add
2670  * @until evas_object_show
2671  *
2672  * Also, we'll need a toolbar widget, obviously:
2673  * @skipline elm_toolbar_add
2674  * @until evas_object_show
2675  *
2676  * When appending an item is possible to set an icon, label, and a callback
2677  * function that will receive passed data.
2678  * @skipline _item_append
2679  * @until Folder
2680  *
2681  * It's possible to disable items, so the user can't select then. We will
2682  * disable the third item:
2683  * @skipline _item_append
2684  * @until disable
2685  *
2686  * Our callbacks will just set button's label:
2687  * @dontinclude toolbar_example_01.c
2688  * @skip static
2689  * @skip }
2690  * @skipline static
2691  * @until }
2692  * @until }
2693  * @until }
2694  *
2695  * By default, toolbars would display items homogeneously, so item with
2696  * long labels, like the third, will make all of them occupy a lot of space.
2697  * To avoid that, we can disable it:
2698  * @dontinclude toolbar_example_01.c
2699  * @skipline homogeneous
2700  *
2701  * Another default behavior, is to add an menu item if we have more items
2702  * that would fit on toolbar size. To simply enable scroll, without menus,
2703  * it's required to change toolbar's shrink mode:
2704  * @dontinclude toolbar_example_01.c
2705  * @skipline shrink
2706  *
2707  * See @ref toolbar_example_01.c "toolbar_example_01.c", whose window should
2708  * look like this picture:
2709  *
2710  * @image html screenshots/toolbar_example_01.png
2711  * @image latex screenshots/toolbar_example_01.eps width=\textwidth
2712  *
2713  * @example toolbar_example_01.c
2714  */
2715
2716 /**
2717  * @page toolbar_example_02 Toolbar Example - Items with States
2718  *
2719  * This code places a Elementary toolbar widget on a window,
2720  * to exemplify part of the widget's API.
2721  *
2722  * Toolbar widgets has support to items with states. Each state
2723  * can have it's own label, icon, and callback function.
2724  *
2725  * Let's start populating a toolbar with some regular items.
2726  * If you don't know how to do that, see
2727  * @ref toolbar_example_01 "Toolbar Example 1".
2728  * @dontinclude toolbar_example_02.c
2729  * @skipline elm_toolbar_add
2730  * @until Update
2731  *
2732  * The only difference here is that we set shrink mode to #ELM_TOOLBAR_SHRINK_HIDE,
2733  * that won't display items that doesn't fit to the window.
2734  *
2735  * Now, let's add an item with states. First, add the item just as any other.
2736  * @skipline elm_toolbar_item_append
2737  * @until _item_pressed
2738  *
2739  * After that states can be added to this item:
2740  * @skipline state_add
2741  * @until Full
2742  * @until _item_pressed
2743  *
2744  * The both states and the item are using the same callback function,
2745  * that will cycle between states and unselect the item. Unseleting
2746  * is required because it won't call the callback if an user clicks
2747  * over an item already selected:
2748  * @dontinclude toolbar_example_02.c
2749  * @skip static
2750  * @skip }
2751  * @skipline static
2752  * @until }
2753  *
2754  * On our example, some items are hidden
2755  * because we set the window to be small. But if an item should be displayed
2756  * anyway, is needed to set its priority to be higher than others.
2757  * Any positive value will be enough in our case. Let's force the item
2758  * with multiple states to be displayed.
2759  * @skipline priority
2760  *
2761  * See @ref toolbar_example_02.c "toolbar_example_02.c", whose window should
2762  * look like this picture:
2763  *
2764  * @image html screenshots/toolbar_example_02.png
2765  * @image latex screenshots/toolbar_example_02.eps width=\textwidth
2766  *
2767  * @example toolbar_example_02.c
2768  */
2769
2770 /**
2771  * @page toolbar_example_03 Toolbar Example - Items with Menus
2772  *
2773  * Toolbar widgets have support to items with menus. This kind
2774  * of item will display a menu when selected by the user.
2775  *
2776  * Let's start populating a toolbar with some regular items, the same
2777  * way we started @ref toolbar_example_02 "Toolbar Example 2".
2778  * @dontinclude toolbar_example_03.c
2779  * @skipline elm_toolbar_add
2780  * @until Update
2781  *
2782  * The only difference is that we'll keep the default shrink mode, that
2783  * adds an item with a menu of hidden items.
2784  *
2785  * So, a important thing to do is to set a parent for toolbar menus, or they
2786  * will use the toolbar as parent, and its size will be restricted to that.
2787  * @skipline parent_set
2788  *
2789  * Not only items' menus will respect this parent, but also the own toolbar
2790  * menu, used to show hidden items.
2791  *
2792  * Next, let's add an item set to display a menu:
2793  * @skipline elm_toolbar_item_append
2794  * @until _menu_set
2795  *
2796  * Now, to add two options to this item, we can get the menu object and use
2797  * it as a regular elm_menu. See @ref tutorial_menu "Menu example" for more
2798  * about menu widget.
2799  * @skipline _menu_get
2800  * @until Full
2801  *
2802  * See @ref toolbar_example_03.c "toolbar_example_03.c", whose window should
2803  * look like this picture:
2804  *
2805  * @image html screenshots/toolbar_example_03.png
2806  * @image latex screenshots/toolbar_example_03.eps width=\textwidth
2807  *
2808  * @example toolbar_example_03.c
2809  */
2810
2811 /**
2812  * @page segment_control_example Segment Control Example
2813  *
2814  * This code places a Elementary segment control widgets on a window,
2815  * to exemplify part of the widget's API.
2816  *
2817  * Let's start adding a segment control to our window:
2818  * @dontinclude segment_control_example.c
2819  * @skipline elm_segment_control_add
2820  * @until evas_object_show
2821  *
2822  * Now will add an item only with label:
2823  * @skipline item_add
2824  *
2825  * Really simple. To add an item with only an icon, the icon needs to be created
2826  * first, them added with this same function:
2827  * @skipline icon_add
2828  * @until item_add
2829  *
2830  * If an item with label and icon is required, it can be done as well. In this
2831  * case, instead of a label (or icon) centered, the item will display an icon
2832  * at left and the label at right:
2833  * @skipline icon_add
2834  * @until item_add
2835  *
2836  * But, if you need to add some items that can have or not a label, but
2837  * want that all of them looks the same way, with icon at left, just add
2838  * an empty string label. It's done on our example to ilustrate that:
2839  * @skipline icon_add
2840  * @until item_add
2841  *
2842  * So far, all the item were added to the last position of the widget,
2843  * but if something different is required, it can be done using another
2844  * insertion function. Let's suppose we want to put an item just before
2845  * the last item:
2846  * @skipline count
2847  * @until insert_at
2848  *
2849  * There are two ways to delete items. Using the item handle, like:
2850  * @skipline insert_at
2851  * @until del
2852  *
2853  * Or using item's index:
2854  * @skipline insert_at
2855  * @until del_at
2856  *
2857  * To set properties of an item already added to the widget, you just need
2858  * to get the item and set icon or label, as the following code shows:
2859  * @skipline item_get
2860  * @until label_set
2861  *
2862  * Finally, it's possible to select an item from the code, and also get
2863  * the selected item. We will select the item at the center of the widget
2864  * and print its position.
2865  * @skipline count_get
2866  * @until printf
2867  *
2868  * See the full @ref segment_control_example.c "example", whose window should
2869  * look like this picture:
2870  *
2871  * @image html screenshots/segment_control_example.png
2872  * @image latex screenshots/segment_control_example.eps width=\textwidth
2873  *
2874  * @example segment_control_example.c
2875  */
2876
2877 /**
2878  * @page flipselector_example Flip selector widget example
2879  *
2880  * This code places an Elementary flip selector widget on a window,
2881  * along with two buttons trigerring actions on it (though its API).
2882  *
2883  * The selector is being populated with the following items:
2884  * @dontinclude flipselector_example.c
2885  * @skip lbl[]
2886  * @until ;
2887  *
2888  * Next, we create it, populating it with those items and registering
2889  * two (smart) callbacks on it:
2890  * @dontinclude flipselector_example.c
2891  * @skip fp = elm_flipselector_add
2892  * @until object_show
2893  *
2894  * Those two callbacks will take place whenever one of those smart
2895  * events occur, and they will just print something to @c stdout:
2896  * @dontinclude flipselector_example.c
2897  * @skip underflow callback
2898  * @until }
2899  * @until }
2900  * Flip the sheets on the widget while looking at the items list, in
2901  * the source code, and you'll get the idea of those events.
2902  *
2903  * The two buttons below the flip selector will take the actions
2904  * described in their labels:
2905  * @dontinclude flipselector_example.c
2906  * @skip bt = elm_button_add
2907  * @until callback_add(win
2908  *
2909  * @dontinclude flipselector_example.c
2910  * @skip unselect the item
2911  * @until }
2912  * @until }
2913  *
2914  * Click on them to exercise those flip selector API calls. To
2915  * interact with the other parts of this API, there's a command line
2916  * interface, whose help string can be asked for with the 'h' key:
2917  * @dontinclude flipselector_example.c
2918  * @skip commands
2919  * @until ;
2920  *
2921  * The 'n' and 'p' keys will exemplify elm_flipselector_flip_next()
2922  * and elm_flipselector_flip_prev(), respectively. 'f' and 'l' account
2923  * for elm_flipselector_first_item_get() and
2924  * elm_flipselector_last_item_get(), respectively. Finally, 's' will
2925  * issue elm_flipselector_selected_item_get() on our example flip
2926  * selector widget.
2927  *
2928  * See the full @ref flipselector_example.c "example", whose window should
2929  * look like this picture:
2930  *
2931  * @image html screenshots/flipselector_example.png
2932  * @image latex screenshots/flipselector_example.eps width=\textwidth
2933  *
2934  * See the full @ref flipselector_example_c "source code" for this example.
2935  *
2936  * @example flipselector_example.c
2937  */
2938
2939 /**
2940  * @page fileselector_example File selector widget example
2941  *
2942  * This code places two Elementary file selector widgets on a window.
2943  * The one on the left is layouting file system items in a @b list,
2944  * while the the other is layouting them in a @b grid.
2945  *
2946  * The one having the majority of hooks of interest is on the left,
2947  * which we create as follows:
2948  * @dontinclude fileselector_example.c
2949  * @skip first file selector
2950  * @until object_show
2951  *
2952  * Note that we enable custom edition of file/directory selection, via
2953  * the text entry it has on its bottom, via
2954  * elm_fileselector_is_save_set(). It starts with the list view, which
2955  * is the default, and we make it not expandable in place
2956  * (elm_fileselector_expandable_set()), so that it replaces its view's
2957  * contents with the current directory's entries each time one
2958  * navigates to a different folder.  For both of file selectors we are
2959  * starting to list the contents found in the @c "/tmp" directory
2960  * (elm_fileselector_path_set()).
2961  *
2962  * Note the code setting it to "grid mode" and observe the differences
2963  * in the file selector's views, in the example. We also hide the
2964  * second file selector's Ok/Cancel buttons -- since it's there just
2965  * to show the grid view (and navigation) -- via
2966  * elm_fileselector_buttons_ok_cancel_set().
2967  *
2968  * The @c "done" event, which triggers the callback below
2969  * @dontinclude fileselector_example.c
2970  * @skip 'done' cb
2971  * @until }
2972  * will be called at the time one clicks the "Ok"/"Cancel" buttons of
2973  * the file selector (on the left). Note that it will print the path
2974  * to the current selection, if any.
2975  *
2976  * The @c "selected" event, which triggers the callback below
2977  * @dontinclude fileselector_example.c
2978  * @skip bt = 'selected' cb
2979  * @until }
2980  * takes place when one selects a file (if the file selector is @b not
2981  * under folders-only mode) or when one selects a folder (when in
2982  * folders-only mode). Experiment it by selecting different file
2983  * system entries.
2984  *
2985  * What comes next is the code creating the three check boxes and two
2986  * buttons below the file selector in the right. They will exercise a
2987  * bunch of functions on the file selector's API, for the instance on
2988  * the left. Experiment with them, specially the buttons, to get the
2989  * difference between elm_fileselector_path_get() and
2990  * elm_fileselector_selected_get().
2991  *
2992  * Finally, there's the code adding the second file selector, on the
2993  * right:
2994  * @dontinclude fileselector_example.c
2995  * @skip second file selector
2996  * @until object_show
2997  *
2998  * Pay attention to the code setting it to "grid mode" and observe the
2999  * differences in the file selector's views, in the example. We also
3000  * hide the second file selector's Ok/Cancel buttons -- since it's
3001  * there just to show the grid view (and navigation) -- via
3002  * elm_fileselector_buttons_ok_cancel_set().
3003  *
3004  * See the full @ref fileselector_example.c "example", whose window
3005  * should look like this picture:
3006  *
3007  * @image html screenshots/fileselector_example.png
3008  * @image latex screenshots/fileselector_example.eps width=\textwidth
3009  *
3010  * See the full @ref fileselector_example_c "source code" for this example.
3011  *
3012  * @example fileselector_example.c
3013  */
3014
3015 /**
3016  * @page fileselector_button_example File selector button widget example
3017  *
3018  * This code places an Elementary file selector button widget on a
3019  * window, along with some other checkboxes and a text entry. Those
3020  * are there just as knobs on the file selector button's state and to
3021  * display information from it.
3022  *
3023  * Here's how we instantiate it:
3024  * @dontinclude fileselector_button_example.c
3025  * @skip ic = elm_icon_add
3026  * @until evas_object_show
3027  *
3028  * Note that we set on it both icon and label decorations. It's set to
3029  * list the contents of the @c "/tmp" directory, too, with
3030  * elm_fileselector_button_path_set(). What follows are checkboxes to
3031  * exercise some of its API funtions:
3032  * @dontinclude fileselector_button_example.c
3033  * @skip ck = elm_check_add
3034  * @until evas_object_show(en)
3035  *
3036  * The checkboxes will toggle whether the file selector button's
3037  * internal file selector:
3038  * - must have an editable text entry for file names (thus, be in
3039  *   "save dialog mode")
3040  * - is to be raised as an "inner window" (note it's the default
3041  *   behavior) or as a dedicated window
3042  * - is to populate its view with folders only
3043  * - is to expand its folders, in its view, <b>in place</b>, and not
3044  *   repainting it entirely just with the contents of a sole
3045  *   directory.
3046  *
3047  * The entry labeled @c "Last selection" will exercise the @c
3048  * "file,chosen" smart event coming from the file selector button:
3049  * @dontinclude fileselector_button_example.c
3050  * @skip hook on the
3051  * @until toggle inwin
3052  *
3053  * Whenever you dismiss or acknowledges the file selector, after it's
3054  * raised, the @c event_info string will contain the last selection on
3055  * it (if any was made).
3056  *
3057  * This is how the example, just after called, should look like:
3058  *
3059  * @image html screenshots/fileselector_button_example_00.png
3060  * @image latex screenshots/fileselector_button_example_00.eps width=\textwidth
3061  *
3062  * Click on the file selector button to raise its internal file
3063  * selector, which will be contained on an <b>"inner window"</b>:
3064  *
3065  * @image html screenshots/fileselector_button_example_01.png
3066  * @image latex screenshots/fileselector_button_example_01.eps width=\textwidth
3067  *
3068  * Toggle the "inwin mode" switch off and, if you click on the file
3069  * selector button again, you'll get @b two windows, the original one
3070  * (note the last selection there!)
3071  *
3072  * @image html screenshots/fileselector_button_example_02.png
3073  * @image latex screenshots/fileselector_button_example_02.eps width=\textwidth
3074  *
3075  * and the file selector's new one
3076  *
3077  * @image html screenshots/fileselector_button_example_03.png
3078  * @image latex screenshots/fileselector_button_example_03.eps width=\textwidth
3079  *
3080  * Play with the checkboxes to get the behavior changes on the file
3081  * selector button. The respective API calls on the widget coming from
3082  * those knobs where shown in the code already.
3083  *
3084  * See the full @ref fileselector_button_example_c "source code" for
3085  * this example.
3086  *
3087  * @example fileselector_button_example.c
3088  */
3089
3090 /**
3091  * @page fileselector_entry_example File selector entry widget example
3092  *
3093  * This code places an Elementary file selector entry widget on a
3094  * window, along with some other checkboxes. Those are there just as
3095  * knobs on the file selector entry's state.
3096  *
3097  * Here's how we instantiate it:
3098  * @dontinclude fileselector_entry_example.c
3099  * @skip ic = elm_icon_add
3100  * @until evas_object_show
3101  *
3102  * Note that we set on it's button both icon and label
3103  * decorations. It's set to exhibit the path of (and list the contents
3104  * of, when internal file selector is launched) the @c "/tmp"
3105  * directory, also, with elm_fileselector_entry_path_set(). What
3106  * follows are checkboxes to exercise some of its API funtions:
3107  * @dontinclude fileselector_entry_example.c
3108  * @skip ck = elm_check_add
3109  * @until callback_add(fs_entry
3110  *
3111  * The checkboxes will toggle whether the file selector entry's
3112  * internal file selector:
3113  * - must have an editable text entry for file names (thus, be in
3114  *   "save dialog mode")
3115  * - is to be raised as an "inner window" (note it's the default
3116  *   behavior) or as a dedicated window
3117  * - is to populate its view with folders only
3118  * - is to expand its folders, in its view, <b>in place</b>, and not
3119  *   repainting it entirely just with the contents of a sole
3120  *   directory.
3121  *
3122  * Observe how the entry's text will match the string coming from the
3123  * @c "file,chosen" smart event:
3124  * @dontinclude fileselector_entry_example.c
3125  * @skip hook on the
3126  * @until }
3127  * Whenever you dismiss or acknowledges the file selector, after it's
3128  * raised, the @c event_info string will contain the last selection on
3129  * it (if any was made).
3130  *
3131  * Try, also, to type in a valid system path and, then, open the file
3132  * selector's window: it will start the file browsing there, for you.
3133  *
3134  * This is how the example, just after called, should look like:
3135  *
3136  * @image html screenshots/fileselector_entry_example_00.png
3137  * @image latex screenshots/fileselector_entry_example_00.eps width=\textwidth
3138  *
3139  * Click on the file selector entry to raise its internal file
3140  * selector, which will be contained on an <b>"inner window"</b>:
3141  *
3142  * @image html screenshots/fileselector_entry_example_01.png
3143  * @image latex screenshots/fileselector_entry_example_01.eps width=\textwidth
3144  *
3145  * Toggle the "inwin mode" switch off and, if you click on the file
3146  * selector entry again, you'll get @b two windows, the original one
3147  * (note the last selection there!)
3148  *
3149  * @image html screenshots/fileselector_entry_example_02.png
3150  * @image latex screenshots/fileselector_entry_example_02.eps width=\textwidth
3151  *
3152  * and the file selector's new one
3153  *
3154  * @image html screenshots/fileselector_entry_example_03.png
3155  * @image latex screenshots/fileselector_entry_example_03.eps width=\textwidth
3156  *
3157  * Play with the checkboxes to get the behavior changes on the file
3158  * selector entry. The respective API calls on the widget coming from
3159  * those knobs where shown in the code already.
3160  *
3161  * See the full @ref fileselector_entry_example_c "source code" for
3162  * this example.
3163  *
3164  * @example fileselector_entry_example.c
3165  */
3166
3167 /**
3168  * @page layout_example_01 Layout - Content, Table and Box
3169  *
3170  * This example shows how one can use the @ref Layout widget to create a
3171  * customized distribution of widgets on the screen, controled by an Edje theme.
3172  * The full source code for this example can be found at @ref
3173  * layout_example_01_c.
3174  *
3175  * Our custom layout is defined by a file, @ref layout_example_edc, which is an
3176  * Edje theme file. Look for the Edje documentation to understand it. For now,
3177  * it's enough to know that we describe some specific parts on this layout
3178  * theme:
3179  * @li a title text field;
3180  * @li a box container;
3181  * @li a table container;
3182  * @li and a content container.
3183  *
3184  * Going straight to the code, the following snippet instantiates the layout
3185  * widget:
3186  *
3187  * @dontinclude layout_example_01.c
3188  * @skip elm_layout_add
3189  * @until evas_object_show(layout)
3190  *
3191  * As any other widget, we set some properties for the size calculation. But
3192  * notice on this piece of code the call to the function elm_layout_file_set().
3193  * Here is where the theme file is loaded, and particularly the specific group
3194  * from this theme file. Also notice that the theme file here is referenced as
3195  * an .edj, which is a .edc theme file compiled to its binary form. Again, look
3196  * for the Edje documentation for more information about theme files.
3197  *
3198  * Next, we fetch from our theme a data string referenced by the key "title".
3199  * This data was defined in the theme, and can be used as parameters which the
3200  * program get from the specific theme that it is using. In this case, we store
3201  * the title of this window and program in the theme, as a "data" entry, just
3202  * for demonstration purposes:
3203  *
3204  * @until }
3205  *
3206  * This call elm_layout_data_get() is used to fetch the string based on the key,
3207  * and elm_object_part_text_set() will set the part defined in the theme as
3208  * "example/title" to contain this string. This key "example/title" has nothing
3209  * special. It's just an arbitrary convention that we are using in this example.
3210  * Every string in this example referencing a part of this theme will be of the
3211  * form "example/<something>".
3212  *
3213  * Now let's start using our layout to distribute things on the window space.
3214  * Since the layout was added as a resize object to the elementary window, it
3215  * will always occupy the entire space available for this window.
3216  *
3217  * The theme already has a title, and it also defines a table element which is
3218  * positioned approximately between 50% and 70% of the height of this window,
3219  * and has 100% of the width. We create some widgets (two icons, a clock and a
3220  * button) and pack them inside the table, in a distribution similar to a HTML
3221  * table:
3222  *
3223  * @until evas_object_show(bt)
3224  *
3225  * Notice that we just set size hints for every object, and call the function
3226  * elm_layout_table_pack(), which does all the work. It will place the elements
3227  * in the specified row/column, with row and column span if required, and then
3228  * the object's size and position will be controled by the layout widget. It
3229  * will also respect size hints, alignments and weight properties set to these
3230  * widgets. The resulting distribution on the screen depends on the table
3231  * properties (described in the theme), the size hints set on each widget, and
3232  * on the cells of the table that are being used.
3233  *
3234  * For instance, we add the two icons and the clock on the first, second and
3235  * third cells of the first row, and add the button the second row, making it
3236  * span for 3 columns (thus having the size of the entire table width). This
3237  * will result in a table that has 2 rows and 3 columns.
3238  *
3239  * Now let's add some widgets to the box area of our layout. This box is around
3240  * 20% and 50% of the vertical size of the layout, and 100% of its width. The
3241  * theme defines that it will use an "horizontal flow" distribution to its
3242  * elements. Unlike the table, a box will distribute elements without knowing
3243  * about rows and columns, and the distribution function selected will take care
3244  * of putting them in row, column, both, or any other available layout. This is
3245  * also described in the Edje documentation.
3246  *
3247  * This box area is similar to the @ref Box widget of elementary, with the
3248  * difference that its position and properties are controled by the theme of the
3249  * layout. It also contains more than one API to add items to it, since the
3250  * items position now is defined in terms of a list of items, not a matrix.
3251  * There's the first position (can have items added to it with
3252  * elm_layout_box_prepend()), the last position (elm_layout_box_append()), the
3253  * nth position (elm_layout_box_insert_at()) and the position right before an
3254  * element (elm_layout_box_insert_before()). We use insert_at and prepend
3255  * functions to add the first two buttons to this box, and insert_before on the
3256  * callback of each button. The callback code will be shown later, but it
3257  * basically adds a button just before the clicked button using the
3258  * elm_layout_box_insert_before() function. Here's the code for adding the first
3259  * 2 buttons:
3260  *
3261  * @until evas_object_show(item)
3262  * @until evas_object_show(item)
3263  *
3264  * Finally, we have an area in this layout theme, in the bottom part of it,
3265  * reserved for adding an specific widget. Differently from the 2 parts
3266  * described until now, this one can only receive one widget with the call
3267  * elm_object_part_content_set() for the layout. If there was already an item on this specific part,
3268  * it will be deleted (one can use elm_object_part_content_unset() in order to remove
3269  * it without deleting). An example of removing it without deleting, but
3270  * manually deleting this widget just after that, can be seen on the callback
3271  * for this button. Actually, the callback defined for this button will clean
3272  * the two other parts (deleting all of their elements) and then remove and
3273  * delete this button.
3274  *
3275  * @until _swallow_btn_cb
3276  *
3277  * Also notice that, for this last added button, we don't have to call
3278  * evas_object_show() on it. This is a particularity of the theme for layouts,
3279  * that will have total control over the properties like size, position,
3280  * visibility and clipping of a widget added with elm_object_part_content_set().
3281  * Again, read the Edje documentation to understand this better.
3282  *
3283  * Now we just put the code for the different callbacks specified for each kind
3284  * of button and make simple comments about them:
3285  *
3286  * @dontinclude layout_example_01.c
3287  * @skip static void
3288  * @until evas_object_del(item)
3289  * @until }
3290  *
3291  * The first callback is used for the button in the table, and will just remove
3292  * itself from the table with elm_layout_table_unpack(), which remove items
3293  * without deleting them, and then calling evas_object_del() on itself.
3294  *
3295  * The second callback is for buttons added to the box. When clicked, these
3296  * buttons will create a new button, and add them to the same box, in the
3297  * position just before the clicked button.
3298  *
3299  * And the last callback is for the button added to the "content" area. It will
3300  * clear both the table and the box, passing @c EINA_TRUE to their respective @c
3301  * clear parameters, which will imply on the items of these containers being
3302  * deleted.
3303  *
3304  * A screenshot of this example can be seen on:
3305  *
3306  * @image html screenshots/layout_example_01.png
3307  * @image latex screenshots/layout_example_01.eps width=\textwidth
3308  *
3309  */
3310
3311 /**
3312  * @page layout_example_02 Layout - Predefined Layout
3313  *
3314  * This example shows how one can use the @ref Layout with a predefined theme
3315  * layout to add a back and next button to a simple window. The full source code
3316  * for this example can be found at @ref layout_example_02_c.
3317  *
3318  * After setting up the window and background, we add the layout widget to the
3319  * window. But instead of using elm_layout_file_set() to load its theme from a
3320  * custom theme file, we can use elm_layout_theme_set() to load one of the
3321  * predefined layouts that come with elementary. Particularly on this example,
3322  * we load the them of class "layout", group "application" and style
3323  * "content-back-next" (since we want the back and next buttons).
3324  *
3325  * @dontinclude layout_example_02.c
3326  * @skip elm_layout_add
3327  * @until evas_object_show(layout)
3328  *
3329  * This default theme contains only a "content" area named
3330  * "elm.swallow.content", where we can add any widget (it can be even a
3331  * container widget, like a box, frame, list, or even another layout). Since we
3332  * just want to show the resulting layout, we add a simple icon to it:
3333  *
3334  * @until layout_content_set
3335  *
3336  * This default layout also provides some signals when the next and prev buttons
3337  * are clicked. We can register callbacks to them with the
3338  * elm_object_signal_callback_add() function:
3339  *
3340  * @until elm,action,next
3341  *
3342  * In the @ref layout_example_03 you can see how to send signals to the layout with
3343  * elm_object_signal_emit().
3344  *
3345  * Now our callback just changes the picture being displayed when one of the
3346  * buttons are clicked:
3347  *
3348  * @dontinclude layout_example_02.c
3349  * @skip images
3350  * @until standard_set
3351  * @until }
3352  *
3353  * It's possible to see that it gets the name of the image being shown from the
3354  * array of image names, going forward on this array when "next" is clicked and
3355  * backward when "back" is clicked.
3356  *
3357  * A screenshot of this example can be seen on:
3358  *
3359  * @image html screenshots/layout_example_02.png
3360  * @image latex screenshots/layout_example_02.eps width=\textwidth
3361  */
3362
3363 /**
3364  * @page layout_example_03 Layout - Signals and Size Changed
3365  *
3366  * This example shows how one can send and receive signals to/from the layout,
3367  * and what to do when the layout theme has its size changed. The full source
3368  * code for this example can be found at @ref layout_example_03_c.
3369  *
3370  * In this exmaple we will use another group from the same layout theme file
3371  * used in @ref layout_example_01. Its instanciation and loading happens in the
3372  * following lines:
3373  *
3374  * @dontinclude layout_example_03.c
3375  * @skip elm_layout_add
3376  * @until evas_object_show
3377  *
3378  * This time we register a callback to be called whenever we receive a signal
3379  * after the end of the animation that happens in this layout:
3380  *
3381  * @until signal_callback_add
3382  *
3383  * We also add a button that will send signals to the layout:
3384  *
3385  * @until callback_add
3386  *
3387  * The callback for this button will check what type of signal it should send,
3388  * and then emit it. The code for this callback follows:
3389  *
3390  * @dontinclude layout_example_03.c
3391  * @skip static Eina_Bool
3392  * @until Enlarge
3393  * @until }
3394  * @until }
3395  *
3396  * As we said before, we are receiving a signal whenever the animation started
3397  * by the button click ends. This is the callback for that signal:
3398  *
3399  * @until }
3400  *
3401  * Notice from this callback that the elm_layout_sizing_eval() function must be
3402  * called if we want our widget to update its size after the layout theme having
3403  * changed its minimum size. This happens because the animation specified in the
3404  * theme increases the size of the content area to a value higher than the
3405  * widget size, thus requiring more space. But the elementary layout widget
3406  * has no way to know this, thus needing the elm_layout_sizing_eval() to
3407  * be called on the layout, informing that this size has changed.
3408  *
3409  * A screenshot of this example can be seen on:
3410  *
3411  * @image html screenshots/layout_example_03.png
3412  * @image latex screenshots/layout_example_03.eps width=\textwidth
3413  */
3414
3415 /**
3416  * @page tutorial_hover Hover example
3417  * @dontinclude hover_example_01.c
3418  *
3419  * On this example we are going to have a button that when clicked will show our
3420  * hover widget, this hover will have content set on it's left, top, right and
3421  * middle positions. In the middle position we are placing a button that when
3422  * clicked will hide the hover. We are also going to use a non-default theme
3423  * for our hover. We won't explain the functioning of button for that see @ref
3424  * Button.
3425  *
3426  * We start our example with a couple of callbacks that show and hide the data
3427  * they're given(which we'll see later on is the hover widget):
3428  * @skip static
3429  * @until }
3430  * @until }
3431  *
3432  * In our main function we'll do some initialization and then create 3
3433  * rectangles, one red, one green and one blue to use in our hover. We'll also
3434  * create the 2 buttons that will show and hide the hover:
3435  * @until show(bt2)
3436  *
3437  * With all of that squared away we can now get to the heart of the matter,
3438  * creating our hover widget, which is easy as pie:
3439  * @until hover
3440  *
3441  * Having created our hover we now need to set the parent and target. Which if
3442  * you recall from the function documentations are going to tell the hover which
3443  * area it should cover and where it should be centered:
3444  * @until bt
3445  *
3446  * Now we set the theme for our hover. We're using the popout theme which gives
3447  * our contents a white background and causes their appearance to be animated:
3448  * @until popout
3449  *
3450  * And finally we set the content for our positions:
3451  * @until bt2
3452  *
3453  * So far so good? Great 'cause that's all there is too it, what is left now is
3454  * just connecting our buttons to the callbacks we defined at the beginning of
3455  * the example and run the main loop:
3456  * @until ELM_MAIN
3457  *
3458  * Our example will initially look like this:
3459  *
3460  * @image html screenshots/hover_example_01.png
3461  * @image latex screenshots/hover_example_01.eps width=\textwidth
3462  *
3463  * And after you click the "Show hover" button it will look like this:
3464  *
3465  * @image html screenshots/hover_example_01_a.png
3466  * @image latex screenshots/hover_example_01_a.eps width=\textwidth
3467  *
3468  * @example hover_example_01.c
3469  */
3470
3471 /**
3472   * @page glview_01_example_page - GLView Example
3473   * @include glview_example_01.c
3474   */
3475
3476 /**
3477   * @page tutorial_flip Flip example
3478   * @dontinclude flip_example_01.c
3479   *
3480   * This example will show a flip with two rectangles on it(one blue, one
3481   * green). Our example will allow the user to choose the animation the flip
3482   * uses and to interact with it. To allow the user to choose the interaction
3483   * mode we use radio buttons, we will however not explain them, if you would
3484   * like to know more about radio buttons see @ref Radio.
3485   *
3486   * We start our example with the usual setup and then create the 2 rectangles
3487   * we will use in our flip:
3488   * @until show(rect2)
3489   *
3490   * The next thing to do is to create our flip and set it's front and back
3491   * content:
3492   * @until show
3493   *
3494   * The next thing we do is set the interaction mode(which the user can later
3495   * change) to the page animation:
3496   * @until PAGE
3497   *
3498   * Setting a interaction mode however is not sufficient, we also need to
3499   * choose which directions we allow interaction from, for this example we
3500   * will use all of them:
3501   * @until RIGHT
3502   *
3503   * We are also going to set the hitsize to the entire flip(in all directions)
3504   * to make our flip very easy to interact with:
3505   * @until RIGHT
3506   *
3507   * After that we create our radio buttons and start the main loop:
3508   * @until ELM_MAIN()
3509   *
3510   * When the user clicks a radio button a function that changes the
3511   * interaction mode and animates the flip is called:
3512   * @until }
3513   * @note The elm_flip_go() call here serves no purpose other than to
3514   * ilustrate that it's possible to animate the flip programmatically.
3515   *
3516   * Our example will look like this:
3517   *
3518   * @image html screenshots/flip_example_01.png
3519   * @image latex screenshots/flip_example_01.eps width=\textwidth
3520   *
3521   * @note Since this is an animated example the screenshot doesn't do it
3522   * justice, it is a good idea to compile it and see the animations.
3523   *
3524   * @example flip_example_01.c
3525   */
3526
3527  /**
3528   * @page tutorial_label Label example
3529   * @dontinclude label_example_01.c
3530   *
3531   * In this example we are going to create 6 labels, set some properties on
3532   * them and see what changes in appearance those properties cause.
3533   *
3534   * We start with the setup code that by now you should be familiar with:
3535   * @until show(bg)
3536   *
3537   * For our first label we have a moderately long text(that doesn't fit in the
3538   * label's width) so we will make it a sliding label. Since the text isn't
3539   * too long we don't need the animation to be very long, 3 seconds should
3540   * give us a nice speed:
3541   * @until show(label
3542   *
3543   * For our second label we have the same text, but this time we aren't going
3544   * to have it slide, we're going to ellipsize it. Because we ask our label
3545   * widget to ellipsize the text it will first diminsh the fontsize so that it
3546   * can show as much of the text as possible:
3547   * @until show(label
3548   *
3549   * For the third label we are going to ellipsize the text again, however this
3550   * time to make sure the fontsize isn't diminshed we will set a line wrap.
3551   * The wrap won't actually cause a line break because we set the label to
3552   * ellipsize:
3553   * @until show(label
3554   *
3555   * For our fourth label we will set line wrapping but won't set ellipsis, so
3556   * that our text will indeed be wrapped instead of ellipsized. For this label
3557   * we choose character wrap:
3558   * @until show(label
3559   *
3560   * Just two more, for our fifth label we do the same as for the fourth
3561   * except we set the wrap to word:
3562   * @until show(label
3563   *
3564   * And last but not least for our sixth label we set the style to "marker" and
3565   * the color to red(the default color is white which would be hard to see on
3566   * our white background):
3567   * @until show(label
3568   *
3569   * Our example will look like this:
3570   *
3571   * @image html screenshots/label_example_01.png
3572   * @image latex screenshots/label_example_01.eps width=\textwidth
3573   *
3574   * @example label_example_01.c
3575   */
3576
3577  /**
3578   * @page tutorial_image Image example
3579   * @dontinclude image_example_01.c
3580   *
3581   * This example is as simple as possible. An image object will be added to the
3582   * window over a white background, and set to be resizable together with the
3583   * window. All the options set through the example will affect the behavior of
3584   * this image.
3585   *
3586   * We start with the code for creating a window and its background, and also
3587   * add the code to write the path to the image that will be loaded:
3588   *
3589   * @skip int
3590   * @until snprintf
3591   *
3592   * Now we create the image object, and set that file to be loaded:
3593   *
3594   * @until }
3595   *
3596   * We can now go setting our options.
3597   *
3598   * elm_image_no_scale_set() is used just to set this value to true (we
3599   * don't want to scale our image anyway, just resize it).
3600   *
3601   * elm_image_resizable_set() is used to allow the image to be resized to a size
3602   * smaller than the original one, but not to a size bigger than it.
3603   *
3604   * elm_elm_image_smooth_set() will disable the smooth scaling, so the scale
3605   * algorithm used to scale the image to the new object size is going to be
3606   * faster, but with a lower quality.
3607   *
3608   * elm_image_orient_set() is used to flip the image around the (1, 0) (0, 1)
3609   * diagonal.
3610   *
3611   * elm_image_aspect_fixed_set() is used to keep the original aspect
3612   * ratio of the image, even when the window is resized to another aspect ratio.
3613   *
3614   * elm_image_fill_outside_set() is used to ensure that the image will fill the
3615   * entire area available to it, even if keeping the aspect ratio. The image
3616   * will overflow its width or height (any of them that is necessary) to the
3617   * object area, instead of resizing the image down until it can fit entirely in
3618   * this area.
3619   *
3620   * elm_image_editable_set() is used just to cover the API, but won't affect
3621   * this example since we are not using any copy & paste property.
3622   *
3623   * This is the code for setting these options:
3624   *
3625   * @until editable
3626   *
3627   * Now some last touches in our object size hints, window and background, to
3628   * display this image properly:
3629   *
3630   * @until ELM_MAIN
3631   *
3632   * This example will look like this:
3633   *
3634   * @image html screenshots/image_example_01.png
3635   * @image latex screenshots/image_example_01.eps width=\textwidth
3636   *
3637   * @example image_example_01.c
3638   */
3639
3640  /**
3641   * @page tutorial_icon Icon example
3642   * @dontinclude icon_example_01.c
3643   *
3644   * This example is as simple as possible. An icon object will be added to the
3645   * window over a white background, and set to be resizable together with the
3646   * window. All the options set through the example will affect the behavior of
3647   * this icon.
3648   *
3649   * We start with the code for creating a window and its background:
3650   *
3651   * @skip int
3652   * @until show(bg)
3653   *
3654   * Now we create the icon object, and set lookup order of the icon, and choose
3655   * the "home" icon:
3656   *
3657   * @until home
3658   *
3659   * An intersting thing is that after setting this, it's possible to check where
3660   * in the filesystem is the theme used by this icon, and the name of the group
3661   * used:
3662   *
3663   * @until printf
3664   *
3665   * We can now go setting our options.
3666   *
3667   * elm_icon_no_scale_set() is used just to set this value to true (we
3668   * don't want to scale our icon anyway, just resize it).
3669   *
3670   * elm_icon_resizable_set() is used to allow the icon to be resized to a size
3671   * smaller than the original one, but not to a size bigger than it.
3672   *
3673   * elm_elm_icon_smooth_set() will disable the smooth scaling, so the scale
3674   * algorithm used to scale the icon to the new object size is going to be
3675   * faster, but with a lower quality.
3676   *
3677   * elm_icon_fill_outside_set() is used to ensure that the icon will fill the
3678   * entire area available to it, even if keeping the aspect ratio. The icon
3679   * will overflow its width or height (any of them that is necessary) to the
3680   * object area, instead of resizing the icon down until it can fit entirely in
3681   * this area.
3682   *
3683   * This is the code for setting these options:
3684   *
3685   * @until fill_outside
3686   *
3687   * However, if you try this example you may notice that this image is not being
3688   * affected by all of these options. This happens because the used icon will be
3689   * from elementary theme, and thus it has its own set of options like smooth
3690   * scaling and fill_outside options. You can change the "home" icon to use some
3691   * image (from your system) and see that then those options will be respected.
3692   *
3693   * Now some last touches in our object size hints, window and background, to
3694   * display this icon properly:
3695   *
3696   * @until ELM_MAIN
3697   *
3698   * This example will look like this:
3699   *
3700   * @image html screenshots/icon_example_01.png
3701   * @image latex screenshots/icon_example_01.eps width=\textwidth
3702   *
3703   * @example icon_example_01.c
3704   */
3705
3706 /**
3707  * @page tutorial_hoversel Hoversel example
3708  * @dontinclude hoversel_example_01.c
3709  *
3710  * In this example we will create a hoversel with 3 items, one with a label but
3711  * no icon and two with both a label and an icon. Every item that is clicked
3712  * will be deleted, but everytime the hoversel is activated we will also add an
3713  * item. In addition our first item will print all items when clicked and our
3714  * third item will clear all items in the hoversel.
3715  *
3716  * We will start with the normal creation of window stuff:
3717  * @until show(bg)
3718  *
3719  * Next we will create a red rectangle to use as the icon of our hoversel:
3720  * @until show
3721  *
3722  * And now we create our hoversel and set some of it's properties. We set @p win
3723  * as its parent, ask it to not be horizontal(be vertical) and give it a label
3724  * and icon:
3725  * @until "icon", rect)
3726  *
3727  * Next we will add our three items, setting a callback to be called for the
3728  * first and third:
3729  * @until _rm_items
3730  *
3731  * We also set a pair of callbacks to be called whenever any item is selected or
3732  * when the hoversel is activated:
3733  * @until clicked
3734  *
3735  * And then ask that our hoversel be shown and run the main loop:
3736  * @until ELM_MAIN
3737  *
3738  * We now have the callback for our first item which prints all items in the
3739  * hoversel:
3740  * @until }
3741  *
3742  * Next we have the callback for our third item which removes all items from the
3743  * hoversel:
3744  * @until }
3745  *
3746  * Next we have the callback that is called whenever an item is clicked and
3747  * deletes that item:
3748  * @until }
3749  *
3750  * And the callback that is called when the hoversel is activated and adds an
3751  * item to the hoversel. Note that since we allocate memory for the item we need
3752  * to know when the item dies so we can free that memory:
3753  * @until }
3754  *
3755  * And finally the callback that frees the memory we allocated for items created
3756  * in the @p _add_item callback:
3757  * @until }
3758  *
3759  * Our example will initially look like this:
3760  *
3761  * @image html screenshots/hoversel_example_01.png
3762  * @image latex screenshots/hoversel_example_01.eps width=\textwidth
3763  *
3764  * And when the hoversel is clicked it will look like this:
3765  *
3766  * @image html screenshots/hoversel_example_01_a.png
3767  * @image latex screenshots/hoversel_example_01_a.eps width=\textwidth
3768  *
3769  * @example hoversel_example_01.c
3770  */
3771
3772 /**
3773  * @page conformant_example Conformant Example.
3774  *
3775  * In this example we'll explain how to create applications to work
3776  * with illume, considering space required for virtual keyboards, indicator
3777  * and softkeys.
3778  *
3779  * Illume is a module for Enlightenment that modifies the user interface
3780  * to work cleanly and nicely on a mobile device. It has support for
3781  * virtual keyboard, among other nice features.
3782  *
3783  * Let's start creating a very simple window with a vertical box
3784  * with multi-line entry between two buttons.
3785  * This entry will expand filling all space on window not used by buttons.
3786  *
3787  * @dontinclude conformant_example_01.c
3788  * @skipline elm_main
3789  * @until }
3790  *
3791  * For information about how to create windows, boxes, buttons or entries,
3792  * look for documentation for these widgets.
3793  *
3794  * It will looks fine when you don't need a virtual keyboard, as you
3795  * can see on the following image:
3796  *
3797  * @image html screenshots/conformant_example_01.png
3798  * @image latex screenshots/conformant_example_01.eps width=\textwidth
3799  *
3800  * But if you call a virtual keyboard, the window will resize, changing
3801  * widgets size and position. All the content will shrink.
3802  *
3803  * If you don't want such behaviour, you
3804  * will need a conformant to account for space taken up by the indicator,
3805  * virtual keyboard and softkey.
3806  *
3807  * In this case, using the conformant in a proper way, you will have
3808  * a window like the following:
3809  *
3810  * @image html screenshots/conformant_example_02.png
3811  * @image latex screenshots/conformant_example_02.eps width=\textwidth
3812  *
3813  * As you can see, it guess the space that will be required by the keyboard,
3814  * indicator and softkey bars.
3815  *
3816  * So, let's study each step required to transform our initial example on
3817  * the second one.
3818  *
3819  * First of all, we need to set the window as an illume conformant window:
3820  * @dontinclude conformant_example_02.c
3821  * @skipline elm_win_conformant_set
3822  *
3823  * Next, we'll add a conformant widget, and set it to resize with the window,
3824  * instead of the box.
3825  * @skipline conform
3826  * @until evas_object_show
3827  *
3828  * Finally, we'll set the box as conformant's content, just like this:
3829  * @skipline elm_object_content_set
3830  *
3831  * Compare both examples code:
3832  * @ref conformant_example_01.c "conformant_example_01.c"
3833  * @ref conformant_example_02.c "conformant_example_02.c"
3834  *
3835  * @example conformant_example_01.c
3836  * @example conformant_example_02.c
3837  */
3838
3839 /**
3840  * @page index_example_01 Index widget example 1
3841  *
3842  * This code places an Elementary index widget on a window, which also
3843  * has a very long list of arbitrary strings on it.  The list is
3844  * sorted alphabetically and the index will be used to index the first
3845  * items of each set of strings beginning with an alphabet letter.
3846  *
3847  * Below the list are some buttons, which are there just to exercise
3848  * some index widget's API.
3849  *
3850  * Here's how we instantiate it:
3851  * @dontinclude index_example_01.c
3852  * @skip elm_list_add
3853  * @until evas_object_show(d.index)
3854  * where we're showing also the list being created. Note that we issue
3855  * elm_win_resize_object_add() on the index, so that it's set to have
3856  * the whole window as its container. Then, we have to populate both
3857  * list and index widgets:
3858  * @dontinclude index_example_01.c
3859  * @skip for (i = 0; i < (sizeof(dict) / sizeof(dict[0])); i++)
3860  * @until }
3861  * @until }
3862  *
3863  * The strings populating the list come from a file
3864  * @dontinclude index_example_01.c
3865  * @skip static const char *dict
3866  * @until }
3867  *
3868  * We use the @c curr char variable to hold the last initial letter
3869  * seen on that ordered list of strings, so that we're able to have an
3870  * index item pointing to each list item starting a new letter
3871  * "section". Note that our index item data pointers will be the list
3872  * item handles. We are also setting a callback function to index
3873  * items deletion events:
3874  * @dontinclude index_example_01.c
3875  * @skip static void
3876  * @until }
3877  *
3878  * There, we show you that the @c event_info pointer will contain the
3879  * item in question's data, i.e., a given list item's pointer. Because
3880  * item data is also returned in the @c data argument on
3881  * @c Evas_Smart_Cb functions, those two pointers must have the same
3882  * values. On this deletion callback, we're deleting the referred list
3883  * item too, just to exemplify that anything could be done there.
3884  *
3885  * Next, we hook to two smart events of the index object:
3886  * @dontinclude index_example_01.c
3887  * @skip smart_callback_add(d.index
3888  * @until _index_selected
3889  * @dontinclude index_example_01.c
3890  * @skip "delay,changed" hook
3891  * @until }
3892  * @until }
3893  *
3894  * Check that, whenever one holds the mouse pressed over a given index
3895  * letter for some time, the list beneath it will roll down to the
3896  * item pointed to by that index item. When one releases the mouse
3897  * button, the second callback takes place. There, we check that the
3898  * reported item data, on @c event_info, is the same reported by
3899  * elm_index_selected_item_get(), which gives the last selection's
3900  * data on the index widget.
3901  *
3902  * The first of the three buttons that follow will call
3903  * elm_index_autohide_disabled_set(), thus showing the index automatically for
3904  * you, if it's not already visible, what is checked with
3905  * elm_index_autohide_disabled_get(). The second button will exercise @b deletion
3906  * of index item objects, by the following code:
3907  * @dontinclude index_example_01.c
3908  * @skip delete an index item
3909  * @until }
3910  *
3911  * It will get the last index item selected's data and find the
3912  * respective index item handle(#Elm_Object_Item) with elm_index_item_find().
3913  * We need the latter to query the indexing letter string from, with
3914  * elm_index_item_letter_get(). Next, comes the delition, itself,
3915  * which will also trigger the @c _index_item_del callback function,
3916  * as said above.
3917  *
3918  * The third button, finally, will exercise elm_index_item_clear(),
3919  * which will delete @b all of the index's items.
3920  *
3921  * This is how the example program's window looks like with the index
3922  * widget hidden:
3923  * @image html screenshots/index_example_00.png
3924  * @image latex screenshots/index_example_00.eps
3925  *
3926  * When it's shown, it's like the following figure:
3927  * @image html screenshots/index_example_01.png
3928  * @image latex screenshots/index_example_01.eps
3929  *
3930  * See the full @ref index_example_01_c "source code" for
3931  * this example.
3932  *
3933  * @example index_example_01.c
3934  */
3935
3936 /**
3937  * @page index_example_02 Index widget example 2
3938  *
3939  * This code places an Elementary index widget on a window, indexing
3940  * grid items. The items are placed so that their labels @b don't
3941  * follow any order, but the index itself is ordered (through
3942  * elm_index_item_sorted_insert()). This is a complement to to @ref
3943  * index_example_01 "the first example on indexes".
3944  *
3945  * Here's the list of item labels to be used on the grid (in that
3946  * order):
3947  * @dontinclude index_example_02.c
3948  * @skip static const char *items
3949  * @until };
3950  *
3951  * In the interesting part of the code, here, we first instantiate the
3952  * grid (more on grids on their examples) and, after creating our
3953  * index, for each grid item we also create an index one to reference
3954  * it:
3955  * @dontinclude index_example_02.c
3956  * @skip grid = elm_gengrid_add
3957  * @until }
3958  * @until smart_callback_add
3959  *
3960  * The order in which they'll appear in the index, though, is @b
3961  * alphabetical, becase of elm_index_item_sorted_insert() usage
3962  * together with the comparing function, where we take the letters of
3963  * each index item to base our ordering on. The parameters on
3964  * @c _index_cmp have to be declared as void pointers because of the
3965  * @c Eina_Compare_Cb prototype requisition, but in this case we know
3966  * they'll be index item(#Elm_Object_Item)'s:
3967  * @dontinclude index_example_02.c
3968  * @skip ordering alphabetically
3969  * @until }
3970  *
3971  * The last interesting bit is the callback in the @c "delay,changed"
3972  * smart event, which will bring the given grid item to the grid's
3973  * visible area:
3974  * @dontinclude index_example_02.c
3975  * @skip static void
3976  * @until }
3977  *
3978  * Note how the grid will move kind of randomly while you move your
3979  * mouse pointer held over the index from top to bottom -- that's
3980  * because of the the random order the items have in the grid itself.
3981  *
3982  * This is how the example program's window looks like:
3983  * @image html screenshots/index_example_03.png
3984  * @image latex screenshots/index_example_03.eps
3985  *
3986  * See the full @ref index_example.c "source code" for
3987  * this example.
3988  *
3989  * @example index_example_02.c
3990  */
3991
3992 /**
3993  * @page tutorial_ctxpopup Ctxpopup example
3994  * @dontinclude ctxpopup_example_01.c
3995  *
3996  * In this example we have a list with two items, when either item is clicked
3997  * a ctxpopup for it will be shown. Our two ctxpopups are quite different, the
3998  * one for the first item is a vertical and it's items contain both labels and
3999  * icons, the one for the second item is horizontal and it's items have icons
4000  * but not labels.
4001  *
4002  * We will begin examining our example code by looking at the callback we'll use
4003  * when items in the ctxpopup are clicked. It's very simple, all it does is
4004  * print the label present in the ctxpopup item:
4005  * @until }
4006  *
4007  * Next we examine a function that creates ctxpopup items, it was created to
4008  * avoid repeating the same code whenever we needed to add an item to our
4009  * ctxpopup. Our function creates an icon from the standard set of icons, and
4010  * then creates the item, with the label received as an argument. We also set
4011  * the callback to be called when the item is clicked:
4012  * @until }
4013  *
4014  * Finally we have the function that will create the ctxpopup for the first item
4015  * in our list. This one is somewhat more complex though, so let's go through it
4016  * in parts. First we declare our variable and add the ctxpopup:
4017  * @until ctxpopup_add
4018  *
4019  * Next we create a bunch of items for our ctxpopup, marking two of them as
4020  * disabled just so we can see what that will look like:
4021  * @until disabled_set
4022  * @until disabled_set
4023  *
4024  * Then we ask evas where the mouse pointer was so that we can have our ctxpopup
4025  * appear in the right place, set a maximum size for the ctxpopup, move it and
4026  * show it:
4027  * @until show
4028  *
4029  * And last we mark the list item as not selected:
4030  * @until }
4031  *
4032  * Our next function is the callback that will create the ctxpopup for the
4033  * second list item, it is very similar to the previous function. A couple of
4034  * interesting things to note is that we ask our ctxpopup to be horizontal, and
4035  * that we pass NULL as the label for every item:
4036  * @until }
4037  *
4038  * And with all of that in place we can now get to our main function where we
4039  * create the window, the list, the list items and run the main loop:
4040  * @until ELM_MAIN()
4041  *
4042  * The example will initially look like this:
4043  *
4044  * @image html screenshots/ctxpopup_example_01.png
4045  * @image latex screenshots/ctxpopup_example_01.eps width=\textwidth
4046  *
4047  * @note This doesn't show the ctxpopup tough, since it will only appear when
4048  * we click one of the list items.
4049  *
4050  * Here is what our first ctxpopup will look like:
4051  *
4052  * @image html screenshots/ctxpopup_example_01_a.png
4053  * @image latex screenshots/ctxpopup_example_01_a.eps width=\textwidth
4054  *
4055  * And here the second ctxpopup:
4056  *
4057  * @image html screenshots/ctxpopup_example_01_b.png
4058  * @image latex screenshots/ctxpopup_example_01_b.eps width=\textwidth
4059  *
4060  * @example ctxpopup_example_01.c
4061  */
4062
4063 /**
4064  * @page tutorial_separator Separator example
4065  * @dontinclude separator_example_01.c
4066  *
4067  * In this example we are going to pack two rectangles in a box, and have a
4068  * separator in the middle.
4069  *
4070  * So we start we the window, background, box and rectangle creation, all pretty
4071  * normal stuff:
4072  * @until pack_end
4073  *
4074  * Once we have our first rectangle in the box we create and add our separator:
4075  * @until pack_end
4076  * @note Since our box is in horizontal mode it's a good idea to set the
4077  * separator to be horizontal too.
4078  *
4079  * And now we add our second rectangle and run the main loop:
4080  * @until ELM_MAIN
4081  *
4082  * This example will look like this:
4083  *
4084  * @image html screenshots/separator_example_01.png
4085  * @image latex screenshots/separator_example_01.eps width=\textwidth
4086  *
4087  * @example separator_example_01.c
4088  */
4089
4090 /**
4091  * @page tutorial_radio Radio example
4092  * @dontinclude radio_example_01.c
4093  *
4094  * In this example we will create 4 radio buttons, three of them in a group and
4095  * another one not in the group. We will also have the radios in the group
4096  * change the value of a variable directly and have then print it when the value
4097  * changes. The fourth button is in the example just to make clear that radios
4098  * outside the group don't affect the group.
4099  *
4100  * We'll start with the usual includes:
4101  * @until #endif
4102  *
4103  * And move right to declaring a static variable(the one whose value the radios
4104  * will change):
4105  * @until static
4106  *
4107  * We now need to have a window and all that good stuff to be able to place our
4108  * radios in:
4109  * @until show(bx)
4110  *
4111  * And now we create a radio button, since this is the first button in our group
4112  * we set the group to be the radio(so we can set the other radios in the same
4113  * group). We also set the state value of this radio to 1 and the value pointer
4114  * to @p val, since val is @p 1 this has the additional effect of setting the
4115  * radio value to @p 1. For this radio we choose the default home icon:
4116  * @until show
4117  *
4118  * To check that our radio buttons are working we'll add a callback to the
4119  * "changed" signal of the radio:
4120  * @until smart_callback
4121  *
4122  * The creation of our second radio button is almost identical, the 2
4123  * differences worth noting are, the value of this radio 2 and that we add this
4124  * radio to the group of the first radio:
4125  * @until smart_callback
4126  *
4127  * For our third callback we'll omit the icon and set the value to 3, we'll also
4128  * add it to the group of the first radio:
4129  * @until smart_callback
4130  *
4131  * Our fourth callback has a value of 4, no icon and most relevantly is not a
4132  * member of the same group as the other radios:
4133  * @until show
4134  *
4135  * We finally run the main loop:
4136  * @until ELM_MAIN
4137  *
4138  * And the last detail in our example is the callback that prints @p val so that
4139  * we can see that the radios are indeed changing its value:
4140  * @until }
4141  *
4142  * The example will look like this:
4143  *
4144  * @image html screenshots/radio_example_01.png
4145  * @image latex screenshots/radio_example_01.eps width=\textwidth
4146  *
4147  * @example radio_example_01.c
4148  */
4149
4150 /**
4151  * @page tutorial_panel Panel example
4152  * @dontinclude panel_example_01.c
4153  *
4154  * In this example will have 3 panels, one for each possible orientation. Two of
4155  * our panels will start out hidden, the third will start out expanded. For each
4156  * of the panels we will use a label as the content, it's however possible to
4157  * have any widget(including containers) as the content of panels.
4158  *
4159  * We start by doing some setup, code you should be familiar with from other
4160  * examples:
4161  * @until show(bx)
4162  *
4163  * And move right to creating our first panel, for this panel we are going to
4164  * choose the orientation as TOP and toggle it(tell it to hide itself):
4165  * @until pack_end
4166  *
4167  * For the second panel we choose the RIGHT orientation and explicitly set the
4168  * state as hidden:
4169  * @until pack_end
4170  *
4171  * For our third and last panel we won't set the orientation(which means it will
4172  * use the default: LEFT):
4173  * @until pack_end
4174  *
4175  * All that is left is running the main loop:
4176  * @until ELM_MAIN
4177  *
4178  * This example will look like this;
4179  *
4180  * @image html screenshots/panel_example_01.png
4181  * @image latex screenshots/panel_example_01.eps width=\textwidth
4182  * @note The buttons with arrow allow the user to hide/show the panels.
4183  *
4184  * @example panel_example_01.c
4185  */
4186
4187 /**
4188  * @page gengrid_example Gengrid widget example
4189  *
4190  * This application is a thorough exercise on the gengrid widget's
4191  * API. We place an Elementary gengrid widget on a window, with
4192  * various knobs below its viewport, each one acting on it somehow.
4193  *
4194  * The code's relevant part begins at the grid's creation. After
4195  * instantiating it, we set its items sizes, so that we don't end with
4196  * items one finger size wide, only. We're setting them to fat, 150
4197  * pixel wide ones, for this example. We give it some size hints, not
4198  * to be discussed in this context and, than, we register a callback
4199  * on one of its smart events -- the one coming each time an item gets
4200  * doubly clicked. There, we just print the item handle's value.
4201  * @dontinclude gengrid_example.c
4202  * @skip grid = elm_gengrid_add
4203  * @until evas_object_sho
4204  * @dontinclude gengrid_example.c
4205  * @skip item double click callback
4206  * @until }
4207  *
4208  * Before we actually start to deal with the items API, let's show
4209  * some things items will be using throughout all the code. The first
4210  * of them is a struct to be used as item data, for all of them:
4211  * @dontinclude gengrid_example.c
4212  * @skip typedef struct
4213  * @until Item;
4214  *
4215  * That path will be used to index an image, to be swallowed into one
4216  * of the item's icon spots. The imagens themselves are distributed
4217  * with Elementary:
4218  * @dontinclude gengrid_example.c
4219  * @skip static const char *imgs
4220  * @until ;
4221  *
4222  * We also have an (unique) gengrid item class we'll be using for
4223  * items in the example:
4224  * @dontinclude gengrid_example.c
4225  * @skip static Elm_Gengrid_Item_Class
4226  * @until static Elm_Gengrid_Item_Class
4227  * @dontinclude gengrid_example.c
4228  * @skip item_style =
4229  * @until _grid_del
4230  *
4231  * As you see, our items will follow the default theme on gengrid
4232  * items. For the label fetching code, we return a string composed of
4233  * the item's image path:
4234  * @dontinclude gengrid_example.c
4235  * @skip label fetching callback
4236  * @until }
4237  *
4238  * For item icons, we'll be populating the item default theme's two
4239  * icon spots, @c "elm.swallow.icon" and @c "elm.swallow.end". The
4240  * former will receive one of the images in our list (in the form of
4241  * a @ref bg_02_example_page "background"), while the latter will be
4242  * a check widget. Note that we prevent the check to propagate click
4243  * events, so that the user can toggle its state without messing with
4244  * the respective item's selection in the grid:
4245  * @dontinclude gengrid_example.c
4246  * @skip icon fetching callback
4247  * @until return NULL
4248  * @until }
4249  *
4250  * As the default gengrid item's theme does not have parts
4251  * implementing item states, we'll be just returning false for every
4252  * item state:
4253  * @dontinclude gengrid_example.c
4254  * @skip state fetching callback
4255  * @until }
4256  *
4257  * Finally, the deletion callback on gengrid items takes care of
4258  * freeing the item's label string and its data struct:
4259  * @dontinclude gengrid_example.c
4260  * @skip deletion callback
4261  * @until }
4262  *
4263  * Let's move to item insertion/deletion knobs, them. They are four
4264  * buttons, above the grid's viewport, namely
4265  * - "Append" (to append an item to the grid),
4266  * - "Prepend" (to prepend an item to the grid),
4267  * - "Insert before" (to insert an item before the selection, on the
4268  *   grid),
4269  * - "Insert after" (to insert an item after the selection, on the
4270  *   grid),
4271  * - "Clear" (to delete all items in the grid),
4272  * - "Bring in 1st" (to make the 1st item visible, by scrolling),
4273  * - "Show last" (to directly show the last item),
4274  * .
4275  * which are displaced and declared in that order. We're not dealing
4276  * with the buttons' creation code (see @ref button_example_01
4277  * "a button example", for more details on it), but with their @c
4278  * "clicked" registered callbacks.  For all of them, the grid's handle
4279  * is passed as @c data. The ones creating new items use a common
4280  * code, which just gives a new @c Example_Item struct, with @c path
4281  * filled with a random image in our images list:
4282  * @dontinclude gengrid_example.c
4283  * @skip new item with random path
4284  * @until }
4285  *
4286  * Moreover, that ones will set a common function to be issued on the
4287  * selection of the items. There, we print the item handle's value,
4288  * along with the callback function data. The latter will be @c NULL,
4289  * always, because it's what we pass when adding all icons. By using
4290  * elm_object_item_data_get(), we can have the item data back and,
4291  * with that, we're priting the item's path string. Finally, we
4292  * exemplify elm_gengrid_item_pos_get(), printing the item's position
4293  * in the grid:
4294  * @dontinclude gengrid_example.c
4295  * @skip item selection callback
4296  * @until }
4297  *
4298  * The appending button will exercise elm_gengrid_item_append(), simply:
4299  * @dontinclude gengrid_example.c
4300  * @skip append an item
4301  * @until }
4302  *
4303  * The prepending, naturally, is analogous, but exercising
4304  * elm_gengrid_item_prepend(), on its turn. The "Insert before" one
4305  * will expect an item to be selected in the grid, so that it will
4306  * insert a new item just before it:
4307  * @dontinclude gengrid_example.c
4308  * @skip "insert before" callback
4309  * @until }
4310  *
4311  * The "Insert after" is analogous, just using
4312  * elm_gengrid_item_insert_after(), instead. The "Clear" button will,
4313  * as expected, just issue elm_gengrid_clear():
4314  * @dontinclude gengrid_example.c
4315  * @skip delete items
4316  * @until }
4317  *
4318  * The "Bring in 1st" button is there exercise two gengrid functions
4319  * -- elm_gengrid_first_item_get() and elm_gengrid_item_bring_in().
4320  * With the former, we get a handle to the first item and, with the
4321  * latter, you'll see that the widget animatedly scrolls its view
4322  * until we can see that item:
4323  * @dontinclude gengrid_example.c
4324  * @skip bring in 1st item
4325  * @until }
4326  *
4327  * The "Show last", in its turn, will use elm_gengrid_last_item_get()
4328  * and elm_gengrid_item_show(). The latter differs from
4329  * elm_gengrid_item_bring_in() in that it immediately replaces the
4330  * contents of the grid's viewport with the region containing the item
4331  * in question:
4332  * @dontinclude gengrid_example.c
4333  * @skip show last item
4334  * @until }
4335  *
4336  * To change the grid's cell (items) size, we've placed a spinner,
4337  * which has the following @c "changed" smart callback:
4338  * @dontinclude gengrid_example.c
4339  * @skip change items' size
4340  * @until }
4341  *
4342  * Experiment with it and see how the items are affected. The "Disable
4343  * item" button will, as the name says, disable the currently selected
4344  * item:
4345  * @dontinclude gengrid_example.c
4346  * @skip disable selected item
4347  * @until }
4348  * Note that we also make use of elm_gengrid_item_selected_set(),
4349  * there, thus making the item unselected before we actually disable
4350  * it.
4351  *
4352  * To toggle between horizontal and vertical layouting modes on the
4353  * grid, use the "Horizontal mode" check, which will call the
4354  * respective API function on the grid:
4355  * @dontinclude gengrid_example.c
4356  * @skip change layouting mode
4357  * @until }
4358  *
4359  * If you toggle the check right after that one, "Always select",
4360  * you'll notice all subsequent clicks on the @b same grid item will
4361  * still issue the selection callback on it, what is different from
4362  * when it's not checked. This is the
4363  * elm_gengrid_select_mode_set() behavior:
4364  * @dontinclude gengrid_example.c
4365  * @skip "always select" callback
4366  * @until }
4367  *
4368  * One more check follows, "Bouncing", which will turn on/off the
4369  * bouncing animations on the grid, when one scrolls past its
4370  * borders. Experiment with scrolling the grid to get the idea, having
4371  * it turned on and off:
4372  * @dontinclude gengrid_example.c
4373  * @skip "bouncing mode" callback
4374  * @until }
4375  *
4376  * The next two checks will affect items selection on the grid. The
4377  * first, "Multi-selection", will make it possible to select more the
4378  * one item on the grid. Because it wouldn't make sense to fetch for
4379  * an unique selected item on this case, we also disable two of the
4380  * buttons, which insert items relatively, if multi-selection is on:
4381  * @dontinclude gengrid_example.c
4382  * @skip multi-selection callback
4383  * @until }
4384  *
4385  * Note that we also @b unselect all items in the grid, when returning
4386  * from multi-selection mode, making use of
4387  * elm_gengrid_item_selected_set().
4388  *
4389  * The second check acting on selection, "No selection", is just what
4390  * its name depicts -- no selection will be allowed anymore, on the
4391  * grid, while it's on. Check it out for yourself, interacting with
4392  * the program:
4393  * @dontinclude gengrid_example.c
4394  * @skip no selection callback
4395  * @until }
4396  *
4397  * We have, finally, one more line of knobs, now sliders, to change
4398  * the grids behavior. The two first will change the horizontal @b
4399  * alignment of the whole actual grid of items within the gengrid's
4400  * viewport:
4401  * @dontinclude gengrid_example.c
4402  * @skip items grid horizontal alignment change
4403  * @until }
4404  *
4405  * Naturally, the vertical counterpart just issues
4406  * elm_gengrid_align_set() changing the second alignment component,
4407  * instead.
4408  *
4409  * The last slider will change the grid's <b>page size</b>, relative
4410  * to its own one. Try to change those values and, one manner of
4411  * observing the paging behavior, is to scroll softly and release the
4412  * mouse button, with different page sizes, at different grid
4413  * positions, while having lots of items in it -- you'll see it
4414  * snapping to page boundaries differenty, for each configuration:
4415  * @dontinclude gengrid_example.c
4416  * @skip page relative size change
4417  * @until }
4418  *
4419  * This is how the example program's window looks like:
4420  * @image html screenshots/gengrid_example.png
4421  * @image latex screenshots/gengrid_example.eps width=\textwidth
4422  *
4423  * Note that it starts with three items which we included at will:
4424  * @dontinclude gengrid_example.c
4425  * @skip _clicked(grid,
4426  * @until _clicked(grid,
4427  * @until _clicked(grid,
4428  * @until _clicked(grid,
4429  *
4430  * See the full @ref gengrid_example_c "source code" for
4431  * this example.
4432  *
4433  * @example gengrid_example.c
4434  */
4435 /**
4436  * @page entry_example Entry - Example of simple editing
4437  *
4438  * As a general overview of @ref Entry we are going to write an, albeit simple,
4439  * functional editor. Although intended to show how elm_entry works, this
4440  * example also makes extensive use of several other widgets. The full code
4441  * can be found in @ref entry_example.c "entry_example.c" and in the following
4442  * lines we'll go through the parts especific to the @ref Entry widget.
4443  *
4444  * The program itself is a simple editor, with a file already set to it, that
4445  * can be set to autosave or not and allows insertion of emoticons and some
4446  * formatted text. As of this writing, the capabilities of format edition in
4447  * the entry are very limited, so a lot of manual work is required to change
4448  * the current text.
4449  *
4450  * In any case, the program allows some changes by using the buttons on the
4451  * top of the window and returning focus back to the main entry afterwards.
4452  *
4453  * @image html screenshots/entry_example.png
4454  * @image latex screenshots/entry_example.eps width=\textwidth
4455  *
4456  * We'll begin by showing a few structures used throught the program. First,
4457  * the application owns data that holds the main window and the main entry
4458  * where the editting happens. Then, an auxiliar structure we'll use later
4459  * when inserting icons in our text.
4460  * @dontinclude entry_example.c
4461  * @skip typedef
4462  * @until App_Inwin_Data
4463  *
4464  * A little convenience function will insert whatever text we need in the
4465  * buffer at the current cursor's position and set focus back to this entry.
4466  * This is done mostly because clicking on any button will make them steal
4467  * focus, which makes writing text more cumbersome.
4468  * @skip static void
4469  * @until }
4470  *
4471  * One of the buttons on the top will trigger an @ref Inwin to open and show
4472  * us several icons we can insert into the text. We'll jump over most of these
4473  * functions, but when all the options are chosen, we insert the special
4474  * markup text that will show the chosen icon in place.
4475  * @skip edje_file_collection_list_free(emos)
4476  * @skip static void
4477  * @until evas_object_del
4478  * @until }
4479  *
4480  * As can be seen in that function, the program lets us add icons to our entry
4481  * using all the possible configurations for them. That should help to
4482  * clarify how the different combinations work out by actually seeing them
4483  * in action.
4484  *
4485  * The same popup window has a page to set the settings of the chosen icon,
4486  * that is, the size and how the item will be placed within the line.
4487  *
4488  * The size is done with two entries, limitted to accept numbers and a fixed
4489  * size of characters. Changing the value in this entries will update the icon
4490  * size in our struct as seen in the next two callbacks.
4491  * @skip static void
4492  * @until }
4493  * @until }
4494  *
4495  * The rest of the options are handled with radio buttons, since only one type
4496  * of size can be used (@c size, @c absize or @c relsize) and for the vertical
4497  * sizing it needs to choose between @c ascent and @c full. Depending on which
4498  * is chosen, the @c item tag is formed accordingly as seen before.
4499  * @skip static Evas_Object
4500  * @until evas_object_show(rvascent)
4501  *
4502  * The first of our entries is here. There's something worth mentioning about
4503  * the way we'll create this one. Normally, any entry regardless of whether is
4504  * single line or not, will be set to scrollable, but in this case, since we
4505  * are limitting how many characters can fit in them and we know we don't need
4506  * scrolling, we are not setting this flag. This makes the entry have virtually
4507  * no appearance on screen, other than its text. This is because an entry is
4508  * just that, a box that holds text, and in order to have some frame around it
4509  * or a background color, another widget needs to provide this. When an entry
4510  * is scrollable, the same scroller used internally does this.
4511  * We are using @ref Frame "frames" here to provide some decoration around,
4512  * then creating our entries, set them to single line, add our two filters and
4513  * the callback for when their value change.
4514  * @until _height_changed_cb
4515  *
4516  * This function ends with the button that will finally call the item
4517  * into our editting string.
4518  * @until }
4519  *
4520  * Then we get to the format edition. Here we can add the @c bold and
4521  * @c emphasis tags to parts of our text. There's a lot of manual work to
4522  * know what to do here, since we are not implementing an entire state manager
4523  * and the entry itself doesn't, yet, support all the needed capabilities to
4524  * make this simpler. We begin by getting the format we are using in our
4525  * function from the button pressed.
4526  * @skip  _format_change_cb(void *data, Evas_Object *obj, void *event __UNUSED__)
4527  * @until sizeof(fmt_close)
4528  *
4529  * Next we need to find out if we need to insert an opening or a closing tag.
4530  * For this, we store the current cursor position and create a selection
4531  * from this point until the beginning of our text, and then get the selected
4532  * text to look for any existing format tags in it. This is currently the only
4533  * way in which we can find out what formats is being used in the entry.
4534  * @until }
4535  * @until }
4536  *
4537  * Once we know what tag to insert, we need a second check in the case it was
4538  * a closing tag. This is because any other closing tag that comes after would
4539  * be left dangling alone, so we need to remove it to keep the text consistent.
4540  * @until }
4541  * @until }
4542  * Finally, we clear our fake selections and return the cursor back to the
4543  * position it had at first, since there is where we want to insert our format.
4544  * @until cursor_pos_set
4545  *
4546  * And finish by calling our convenience function from before, to insert the
4547  * text at the current cursor and give focus back to the entry.
4548  * @until }
4549  *
4550  * A checkbox on the top of our program tells us if the text we are editing
4551  * will autosave or not. In it's @c "changed" callback we get the value from
4552  * the checkbox and call the elm_entry_autosave_set() function with it. If
4553  * autosave is set, we also call elm_entry_file_save(). This is so the internal
4554  * timer used to periodically store to disk our changes is started.
4555  * @skip static void
4556  * @until }
4557  *
4558  * Two more functions to show some cursor playing. Whenever we double click
4559  * anywhere on our entry, we'll find what word is the cursor placed at and
4560  * select it. Likewise, for triple clicking, we select the entire line.
4561  * @skip static void
4562  * @until _edit_tplclick_cb
4563  * @until }
4564  *
4565  * And finally, the main window of the program contains the entry where we
4566  * do all the edition and some helping widgets to change format, add icons
4567  * or change the autosave flag.
4568  * @skip elm_exit
4569  * @skip int
4570  * @until _image_insert_cb
4571  *
4572  * And the main entry of the program. Set to scroll, by default we disable
4573  * autosave and we'll begin with a file set to it because no file selector
4574  * is being used here. The file is loaded with #ELM_TEXT_FORMAT_MARKUP_UTF8
4575  * so that any format contained in it is interpreted, otherwise the entry
4576  * would load it as just text, escaping any tags found and no format or icons
4577  * would be shown. Then we connect to the double and triple click signals
4578  * and set focus on the entry so we can start typing right away.
4579  * @until ELM_MAIN
4580  *
4581  * @example entry_example.c
4582  */
4583
4584 /**
4585  * @page genlist_example_01 Genlist - basic usage
4586  *
4587  * This example creates a simple genlist with a small number of items and
4588  * a callback that is called whenever an item is selected. All the properties of
4589  * this genlist are the default ones. The full code for this example can be seen
4590  * at @ref genlist_example_01_c.
4591  *
4592  * For the simplest list that you plan to create, it's necessary to define some
4593  * of the basic functions that are used for creating each list item, and
4594  * associating them with the "item class" for that list. The item class is just
4595  * an struct that contains pointers to the specific list item functions that are
4596  * common to all the items of the list.
4597  *
4598  * Let's show it by example. Our item class is declared globally and static as
4599  * it will be the only item class that we need (we are just creating one list):
4600  *
4601  * @dontinclude genlist_example_01.c
4602  * @skip static Elm_Genlist
4603  * @until static Elm_Genlist
4604  *
4605  * This item class will be used for every item that we create. The only
4606  * functions that we are going to set are @c label_get and @c icon_get. As the
4607  * name suggests, they are used by the genlist to generate the label for the
4608  * respective item, and to generate icon(s) to it too. Both the label and icon
4609  * get functions can be called more than once for each item, with different @c
4610  * part parameters, which represent where in the theme of the item that label or
4611  * icon is going to be set.
4612  *
4613  * The default theme for the genlist contains only one area for label, and two
4614  * areas for icon ("elm.swallow.icon" and "elm.swallow.end"). Since we just want
4615  * to set the first icon (that will be at the left side of the label), we
4616  * compare the part name given with "elm.swallow.icon". Notice that the
4617  * @c label_get function must return a strduped string, that will be freed later
4618  * automatically by the list. Here's the code for @c label_get and @c icon_get:
4619  *
4620  * @until static void
4621  *
4622  * We will also provide a function that will be called whenever an item is
4623  * selected in the genlist. However, this function is not part of the item
4624  * class, it will be passed for each item being added to the genlist explicitly.
4625  * Notice the similarity of the function signature with those used by @c
4626  * evas_object_smart_callback_add:
4627  *
4628  * @until }
4629  *
4630  * Now let's show the code used for really creating the list. Skipping
4631  * boilerplate code used for creating a window and background, the first piece
4632  * of code specific to our genlist example is setting the pointer functions of
4633  * the item class to our above defined functions:
4634  *
4635  * @skip _itc
4636  * @until func.del
4637  *
4638  * Notice that we also choose to use the "default" style for our genlist items.
4639  * Another interesting point is that @c state_get and @c del are set to @c NULL,
4640  * since we don't need these functions now. @c del doesn't need to be used
4641  * because we don't add any data that must be freed to our items, and @c
4642  * state_get is also not used since all of our items are the same and don't need
4643  * to have different states to be used for each item. Finally we create our
4644  * list:
4645  *
4646  * @until genlist_add
4647  *
4648  * Now we append several items to the list, and for all of them we need to give
4649  * the list pointer, a pointer to the item class, the data that will be used
4650  * with that item, a pointer to the parent of this item if it is in a group type
4651  * list (this is not the case so we pass @c NULL), possible flags for this item,
4652  * the callback for when the item is selected, and the data pointer that will be
4653  * given to the selected callback.
4654  *
4655  * @until }
4656  *
4657  * The rest of the code is also common to all the other examples, so it will be
4658  * omitted here (look at the full source code link above if you need it).
4659  *
4660  * You can try to play with this example, and see the selected callback being
4661  * called whenever an item is clicked. It also already has some features enabled
4662  * by default, like vertical bounce animation when reaching the end of the list,
4663  * automatically visible/invisible scrollbar, etc. Look at the @ref
4664  * genlist_example_02 to see an example of setting these properties to the list.
4665  *
4666  * The current example will look like this when running:
4667  *
4668  * @image html screenshots/genlist_example_01.png
4669  * @image latex screenshots/genlist_example_01.eps width=\textwidth
4670  */
4671
4672 /**
4673  * @page genlist_example_02 Genlist - list setup functions
4674  *
4675  * This example is very similar to the @ref genlist_example_01, but it fetch
4676  * most of the properties of the genlist and displays them on startup (thus
4677  * getting the default value for them) and then set them to some other values,
4678  * to show how to use that API. The full source code is at @ref
4679  * genlist_example_02_c.
4680  *
4681  * Considering that the base code for instantiating a genlist was already
4682  * described in the previous example, we are going to focus on the new code.
4683  *
4684  * Just a small difference for the @c _item_label_get function, we are going to
4685  * store the time that this function was called. This is the "realized" time,
4686  * the time when the visual representation of this item was created. This is the
4687  * code for the @c label_get function:
4688  *
4689  * @dontinclude genlist_example_02.c
4690  * @skip static char
4691  * @until return strdup
4692  *
4693  * Now let's go to the list creation and setup. First, just after creating the
4694  * list, we get most of the default properties from it, and print them on the
4695  * console:
4696  *
4697  * @skip genlist_add
4698  * @until printf("\n")
4699  *
4700  * We are going to change some of the properties of our list.
4701  *
4702  * There's no need to call the selected callback at every click, just when the
4703  * selected item changes, thus we call elm_genlist_select_mode_set() with
4704  * ELM_OBJECT_SELECT_MODE_ALWAYS.
4705  *
4706  * For this list we don't want bounce animations at all, so we set both the
4707  * horizontal bounce and the vertical bounce to false with
4708  * elm_genlist_bounce_set().
4709  *
4710  * We also want our list to compress items if they are wider than the list
4711  * width (thus we call elm_genlist_mode_set(obj, ELM_LIST_COMPRESS).
4712  *
4713  * The items have different width, so they are not homogeneous:
4714  * elm_genlist_homogeneous_set() is set to false.
4715  *
4716  * Since the compress mode is active, the call to
4717  * elm_genlist_mode_set() doesn't make difference, but the current
4718  * option would make the list to have at least the width of the largest item.
4719  *
4720  * This list will support multiple selection, so we call
4721  * elm_genlist_multi_select_set() on it.
4722  *
4723  * The option elm_genlist_mode_set() would allow text block to
4724  * wrap lines if the Edje part is configured with "text.min: 0 1", for example.
4725  * But since we are compressing the elements to the width of the list, this
4726  * option wouldn't take any effect.
4727  *
4728  * We want the vertical scrollbar to be always displayed, and the orizontal one
4729  * to never be displayed, and set this with elm_genlist_scroller_policy_set().
4730  *
4731  * The timeout to consider a longpress is set to half of a second with
4732  * elm_genlist_longpress_timeout_set().
4733  *
4734  * We also change the block count to a smaller value, but that should have not
4735  * impact on performance since the number of visible items is too small. We just
4736  * increase the granularity of the block count (setting it to have at most 4
4737  * items).
4738  *
4739  * @until block_count_set
4740  *
4741  * Now let's add elements to the list:
4742  *
4743  * @until item_append
4744  * @until }
4745  *
4746  * It's exactly the same as the previous example. The difference is on the
4747  * behavior of the list, if you try to scroll, select items and so.
4748  *
4749  * In this example we also need two buttons. One of them, when clicked, will
4750  * display several status info about the current selection, the "realized"
4751  * items, the item in the middle of the screen, and the current mode and active
4752  * item of that mode for the genlist.
4753  *
4754  * The other button will ask the genlist to "realize" again the items already
4755  * "realized", so their respective label_get and icon_get functions will be
4756  * called again.
4757  *
4758  * These are the callbacks for both of these buttons:
4759  *
4760  * @dontinclude genlist_example_02.c
4761  * @skip item_sel_cb
4762  * @skip static
4763  * @until }
4764  * @until }
4765  *
4766  * Try to scroll, select some items and click on the "Show status" button.
4767  * You'll notice that not all items of the list are "realized", thus consuming
4768  * just a small amount of memory. The selected items are listed in the order
4769  * that they were selected, and the current selected item printed using
4770  * elm_genlist_selected_item_get() is the first selected item of the multiple
4771  * selection.
4772  *
4773  * Now resize the window so that you can see the "realized time" of some items.
4774  * This is the time of when the label_get function was called. If you click on
4775  * the "Realize" button, all the already realized items will be rebuilt, so the
4776  * time will be updated for all of them.
4777  *
4778  * The current example will look like this when running:
4779  *
4780  * @image html screenshots/genlist_example_02.png
4781  * @image latex screenshots/genlist_example_02.eps width=\textwidth
4782  */
4783
4784 /**
4785  * @page genlist_example_03 Genlist - different width options
4786  *
4787  * This example doesn't present any other feature that is not already present in
4788  * the other examples, but visually shows the difference between using the
4789  * default list options (first list of the example), setting the horizontal mode
4790  * to #ELM_LIST_LIMIT (second list), enabling compress mode (third list) and
4791  * using height_for_width option (fourth list).
4792  *
4793  * The full code for this example is listed below:
4794  *
4795  * @include genlist_example_03.c
4796  *
4797  * And the screenshot of the running example:
4798  *
4799  * @image html screenshots/genlist_example_03.png
4800  * @image latex screenshots/genlist_example_03.eps width=\textwidth
4801  *
4802  * @example genlist_example_03.c
4803  */
4804
4805 /**
4806  * @page genlist_example_04 Genlist - items manipulation
4807  *
4808  * This example is also similar ot the @ref genlist_example_01, but it
4809  * demonstrates most of the item manipulation functions. See the full source
4810  * code at @ref genlist_example_04_c.
4811  *
4812  * In this example, we also will use the concept of creating groups of items in
4813  * the genlist. Each group of items is composed by a parent item (which will be
4814  * the index of the group) and several children of this item. Thus, for the
4815  * children, we declare a normal item class. But we also are going to declare a
4816  * different item class for the group index (which in practice is another type
4817  * of item in the genlist):
4818  *
4819  * @dontinclude genlist_example_04.c
4820  * @skip _item_sel_cb
4821  * @skip static
4822  * @until }
4823  * @until }
4824  *
4825  * We will add buttons to the window, where each button provides one
4826  * functionality of the genlist item API. Each button will have a callback
4827  * attached, that will really execute this functionality. An example of these
4828  * callbacks is the next one, for the elm_genlist_item_insert_after() function:
4829  *
4830  * @skip insert_before_cb
4831  * @skip static
4832  * @until }
4833  *
4834  * If you want ot see the other button functions, look at the full source code
4835  * link above.
4836  *
4837  * Each button will be created with a function that already creates the button,
4838  * add it to an elementary box, and attach the specified callback. This is the
4839  * function that does it:
4840  *
4841  * @skip genlist_item_update
4842  * @skip static
4843  * @until }
4844  *
4845  * In our @c elm_main function, besides the code for setting up the window, box
4846  * and background, we also initialize our two item classes:
4847  *
4848  * @skip _itc.item_style
4849  * @until _itc_group.func.del
4850  *
4851  * This example uses a different style for the items, the @a double_label, which
4852  * provides a text field for the item text, and another text field for a subtext.
4853  *
4854  * For the group index we use the @a group_index style, which provides a
4855  * different appearance, helping to identify the end of a group and beginning of
4856  * another one.
4857  *
4858  * Now, after the code for creating the list, setting up the box and other
4859  * stuff, let's add the buttons with their respective callbacks:
4860  *
4861  * @skip _button_add
4862  * @until bt_top_show
4863  *
4864  * The main code for adding items to the list is a bit more complex than the one
4865  * from the previous examples. We check if each item is multiple of 7, and if
4866  * so, they are group indexes (thus each group has 6 elements by default, in
4867  * this example):
4868  *
4869  * @skip for
4870  * @until }
4871  * @until }
4872  *
4873  * Then we also check for specific items, and add callbacks to them on the
4874  * respective buttons, so we can show, bring in, etc.:
4875  *
4876  * @until }
4877  * @until }
4878  *
4879  * Once you understand the code from the @ref genlist_example_01, it should be
4880  * easy to understand this one too. Look at the full code, and also try to play
4881  * a bit with the buttons, adding items, bringing them to the viewport, and so.
4882  *
4883  * The example will look like this when running:
4884  *
4885  * @image html screenshots/genlist_example_04.png
4886  * @image latex screenshots/genlist_example_04.eps width=\textwidth
4887  */
4888
4889 /**
4890  * @page genlist_example_05 Genlist - working with subitems
4891  *
4892  * This is probably the most complex example of elementary @ref Genlist. We
4893  * create a tree of items, using the subitems properties of the items, and keep
4894  * it in memory to be able to expand/hide subitems of an item. The full source
4895  * code can be found at @ref genlist_example_05_c
4896  *
4897  * The main point is the way that Genlist manages subitems. Clicking on an
4898  * item's button to expand it won't really show its children. It will only
4899  * generate the "expand,request" signal, and the expansion must be done
4900  * manually.
4901  *
4902  * In this example we want to be able to add items as subitems of another item.
4903  * If an item has any child, it must be displayed using a parent class,
4904  * otherwise it will use the normal item class.
4905  *
4906  * It will be possible to delete items too. Once a tree is constructed (with
4907  * subitems of subitems), and the user clicks on the first parent (root of the
4908  * tree), the entire subtree must be hidden. However, just calling
4909  * elm_genlist_item_expanded_set(item, EINA_FALSE) won't hide them. The only
4910  * thing that happens is that the parent item will change its appearance to
4911  * represent that it's contracted. And the signal "contracted" will be emitted
4912  * from the genlist. Thus, we must call elm_genlist_item_subitems_clear() to
4913  * delete all its subitems, but still keep a way to recreate them when expanding
4914  * the parent again. That's why we are going to keep a node struct for each
4915  * item, that will be the data of the item, with the following information:
4916  *
4917  * @dontinclude genlist_example_05.c
4918  * @skip typedef
4919  * @until }
4920  *
4921  * This @c Node_Data contains the value for the item, a number indicating its
4922  * level under the tree, a list of children (to be able to expand it later) and
4923  * a boolean indicating if it's a favorite item or not.
4924  *
4925  * We use 3 different item classes in this example:
4926  *
4927  * One for items that don't have children:
4928  *
4929  * @skip nitems
4930  * @skip static
4931  * @until }
4932  * @until }
4933  *
4934  * One for items that have children:
4935  *
4936  * @skip item_sel
4937  * @skip static
4938  * @until }
4939  * @until }
4940  *
4941  * And one for items that were favorited:
4942  *
4943  * @skip static
4944  * @until }
4945  * @until }
4946  *
4947  * The favorite item class is there just to demonstrate the
4948  * elm_genlist_item_item_class_update() function in action. It would be much
4949  * simpler to implement the favorite behavior by just changing the icon inside
4950  * the icon_get functions when the @c favorite boolean is activated.
4951  *
4952  * Now we are going to declare the callbacks for the buttons that add, delete
4953  * and change items.
4954  *
4955  * First, a button for appending items to the list:
4956  *
4957  * @until item_append
4958  * @until }
4959  *
4960  * If an item is selected, a new item will be appended to the same level of that
4961  * item, but using the selected item's parent as its parent too. If no item is
4962  * selected, the new item will be appended to the root of the tree.
4963  *
4964  * Then the callback for marking an item as favorite:
4965  *
4966  * @until elm_genlist_item_update
4967  * @until }
4968  *
4969  * This callback is very simple, it just changes the item class of the selected
4970  * item for the "favorite" one, or go back to the "item" or "parent" class
4971  * depending on that item having children or not.
4972  *
4973  * Now, the most complex operation (adding a child to an item):
4974  *
4975  * @until elm_genlist_item_update
4976  * @until }
4977  *
4978  * This function gets the data of the selected item, create a new data (for the
4979  * item being added), and appends it to the children list of the selected item.
4980  *
4981  * Then we must check if the selected item (let's call it @c item1 now) to which
4982  * the new item (called @c item2 from now on) was already a parent item too
4983  * (using the parent item class) or just a normal item (using the default item
4984  * class). In the first case, we just have to append the item to the end of the
4985  * @c item1 children list.
4986  *
4987  * However, if the @c item1 didn't have any child previously, we have to change
4988  * it to a parent item now. It would be easy to just change its item class to
4989  * the parent type, but there's no way to change the item flags and make it be
4990  * of the type #ELM_GENLIST_ITEM_TREE. Thus, we have to delete it and create
4991  * a new item, and add this new item to the same position that the deleted one
4992  * was. That's the reason of the checks inside the bigger @c if.
4993  *
4994  * After adding the item to the newly converted parent, we set it to not
4995  * expanded (since we don't want to show the added item immediately) and select
4996  * it again, since the original item was deleted and no item is selected at the
4997  * moment.
4998  *
4999  * Finally, let's show the callback for deleting items:
5000  *
5001  * @until elm_genlist_item_update
5002  * @until }
5003  *
5004  * Since we have an iternal list representing each element of our tree, once we
5005  * delete an item we have to go deleting each child of that item, in our
5006  * internal list. That's why we have the function @c _clear_list, which
5007  * recursively goes freeing all the item data.
5008  *
5009  * This is necessary because only when we really want to delete the item is when
5010  * we need to delete the item data. When we are just contracting the item, we
5011  * need to hide the children by deleting them, but keeping the item data.
5012  *
5013  * Now there are two callbacks that will be called whenever the user clicks on
5014  * the expand/contract icon of the item. They will just request to items to be
5015  * contracted or expanded:
5016  *
5017  * @until elm_genlist_item_expanded_set(
5018  * @until elm_genlist_item_expanded_set(
5019  * @until }
5020  *
5021  * When the elm_genlist_item_expanded_set() function is called with @c
5022  * EINA_TRUE, the @c _expanded_cb will be called. And when this happens, the
5023  * subtree of that item must be recreated again. This is done using the internal
5024  * list stored as item data for each item. The function code follows:
5025  *
5026  * @until }
5027  *
5028  * Each appended item is set to contracted, so we don't have to deal with
5029  * checking if the item was contracted or expanded before its parent being
5030  * contracted. It could be easily implemented, though, by adding a flag expanded
5031  * inside the item data.
5032  *
5033  * Now, the @c _contracted_cb, which is much simpler:
5034  *
5035  * @until }
5036  *
5037  * We just have to call elm_genlist_item_subitems_clear(), that will take care
5038  * of deleting every item, and keep the item data still stored (since we don't
5039  * have any del function set on any of our item classes).
5040  *
5041  * Finally, the code inside @c elm_main is very similar to the other examples:
5042  *
5043  * @skip elm_main
5044  * @until ELM_MAIN
5045  *
5046  * The example will look like this when running:
5047  *
5048  * @image html screenshots/genlist_example_05.png
5049  * @image latex screenshots/genlist_example_05.eps width=\textwidth
5050  */
5051
5052 /**
5053  * @page thumb_example_01 Thumb - generating thumbnails.
5054  *
5055  * This example shows how to create a simple thumbnail object with Elementary.
5056  * The full source code can be found at @ref thumb_example_01_c
5057  *
5058  * Everything is very simple. First we need to tell elementary that we need
5059  * Ethumb to generate the thumbnails:
5060  *
5061  * @dontinclude thumb_example_01.c
5062  * @skipline elm_need_ethumb
5063  *
5064  * Then, after creating the window and background, we setup our client to
5065  * generate images of 160x160:
5066  *
5067  * @skip client_get
5068  * @until size_set
5069  *
5070  * After that, we can start creating thumbnail objects. They are very similar to
5071  * image or icon objects:
5072  *
5073  * @until thumb_reload
5074  *
5075  * As you can see, the main different function here is elm_thumb_reload(), which
5076  * will check if the options of the Ethumb client have changed. If so, it will
5077  * re-generate the thumbnail, and show the new one.
5078  *
5079  * Notice in this example that the thumbnail object is displayed on the size of
5080  * the window (320x320 pixels), but the thumbnail generated and stored has size
5081  * 160x160 pixels. That's why the picture seems upscaled.
5082  *
5083  * Ideally, you will be generating thumbnails with the size that you will be
5084  * using them.
5085  *
5086  * The example will look like this when running:
5087  *
5088  * @image html screenshots/thumb_example_01.png
5089  * @image latex screenshots/thumb_example_01.eps width=\textwidth
5090  */
5091
5092 /**
5093  * @page progressbar_example Progress bar widget example
5094  *
5095  * This application is a thorough example of the progress bar widget,
5096  * consisting of a window with varios progress bars, each with a given
5097  * look/style one can give to those widgets. With two auxiliary
5098  * buttons, one can start or stop a timer which will fill in the bars
5099  * in synchrony, simulating an underlying task being completed.
5100  *
5101  * We create @b seven progress bars, being three of them horizontal,
5102  * three vertical and a final one under the "wheel" alternate style.
5103  *
5104  * For the first one, we add a progress bar on total pristine state,
5105  * with no other call than the elm_progressbar_add() one:
5106  * @dontinclude progressbar_example.c
5107  * @skip pb with no label
5108  * @until pb1
5109  * See, than, that the defaults of a progress bar are:
5110  * - no primary label shown,
5111  * - unit label set to @c "%.0f %%",
5112  * - no icon set
5113  *
5114  * The second progress bar is given a primary label, <c>"Infinite
5115  * bounce"</c>, and, besides, it's set to @b pulse. See how, after one
5116  * starts the progress timer, with the "Start" button, it animates
5117  * differently than the previous one. It won't account for the
5118  * progress, itself, and just dumbly animate a small bar within its
5119  * bar region.
5120  * @dontinclude progressbar_example.c
5121  * @skip pb with label
5122  * @until pb2
5123  *
5124  * Next, comes a progress bar with an @b icon, a primary label and a
5125  * @b custom unit label set. It's also made to grow its bar in an
5126  * @b inverted manner, so check that out during the timer's progression:
5127  * @dontinclude progressbar_example.c
5128  * @skip ic1 =
5129  * @until pb3
5130  * Another important thing in this one is the call to
5131  * elm_progressbar_span_size_set() -- this is how we forcefully set a
5132  * minimum horizontal size to our whole window! We're not resizing it
5133  * manually, as you can see in the @ref progressbar_example_c
5134  * "complete code".
5135  *
5136  * The next three progress bars are just variants on the ones already
5137  * shown, but now all being @b vertical. Another time we use one of
5138  * than to give the window a minimum vertical size, with
5139  * elm_progressbar_span_size_set().  To demonstrate this trick once
5140  * more, the fifth one, which is also set to pulse, has a smaller
5141  * hardcoded span size:
5142  * @dontinclude progressbar_example.c
5143  * @skip vertical pb, with pulse
5144  * @until pb5
5145  *
5146  * We end the widget demonstration by showing a progress bar with the
5147  * special @b "wheel" progress bar style. One does @b not need to set
5148  * it to pulse, with elm_progressbar_pulse_set(), explicitly, because
5149  * its theme does not take it in account:
5150  * @dontinclude progressbar_example.c
5151  * @skip "wheel"
5152  * @until pb7
5153  *
5154  * The two buttons exercising the bars, the facto, follow:
5155  * @dontinclude progressbar_example.c
5156  * @skip elm_button_add
5157  * @until evas_object_show(bt)
5158  * @until evas_object_show(bt)
5159  *
5160  * The first of the callbacks will, for the progress bars set to
5161  * pulse, start the pulsing animation at that time. For the others, a
5162  * timer callback will take care of updating the values:
5163  * @dontinclude progressbar_example.c
5164  * @skip static Eina_Bool
5165  * @until }
5166  * @until }
5167  * @until }
5168  *
5169  * Finally, the callback to stop the progress timer will stop the
5170  * pulsing on the pulsing progress bars and, for the others, to delete
5171  * the timer which was acting on their values:
5172  * @dontinclude progressbar_example.c
5173  * @skip end of show
5174  * @until }
5175  * @until }
5176  *
5177  * This is how the example program's window looks like:
5178  * @image html screenshots/progressbar_example.png
5179  * @image latex screenshots/progressbar_example.eps width=\textwidth
5180  *
5181  * See the full @ref progressbar_example_c "source code" for
5182  * this example.
5183  *
5184  * @example progressbar_example.c
5185  */
5186
5187 /**
5188  * @page tutorial_notify Notify example
5189  * @dontinclude notify_example_01.c
5190  *
5191  * In this example we will have 3 notifys in 3 different positions. The first of
5192  * which will dissapear after 5 seconds or when a click outside it occurs, the
5193  * second and third will not dissapear and differ from each other only in
5194  * position.
5195  *
5196  * We start our example with the usual stuff you've seen in other examples:
5197  * @until show(bx)
5198  *
5199  * We now create a label to use as the content of our first notify:
5200  * @until show
5201  *
5202  * Having the label we move to creating our notify, telling it to block events,
5203  * setting its timeout(to autohide it):
5204  * @until pack_end
5205  *
5206  * To have the notify dissapear when a click outside its area occur we have to
5207  * listen to its "block,clicked" signal:
5208  * @until smart_callback
5209  *
5210  * Our callback will look like this:
5211  * @skip static
5212  * @until }
5213  * @dontinclude notify_example_01.c
5214  *
5215  * Next we create another label and another notify. Note, however, that this
5216  * time we don't set a timeout and don't have it block events. What we do is set
5217  * the orient so that this notify will appear in the bottom of its parent:
5218  * @skip smart_callback
5219  * @skip content
5220  * @until pack_end
5221  *
5222  * For our third notify the only change is the orient which is now center:
5223  * @until pack_end
5224  *
5225  * Now we tell the main loop to run:
5226  * @until ELM_MAIN
5227  *
5228  * Our example will initially look like this:
5229  *
5230  * @image html screenshots/notify_example_01.png
5231  * @image latex screenshots/notify_example_01.eps width=\textwidth
5232  *
5233  * Once the first notify is hidden:
5234  *
5235  * @image html screenshots/notify_example_01_a.png
5236  * @image latex screenshots/notify_example_01_a.eps width=\textwidth
5237  *
5238  * @example notify_example_01.c
5239  */
5240
5241 /**
5242  * @page popup_example_01_c popup_example_01.c
5243  * @include popup_example_01.c
5244  *
5245  * This example will initially look like this:
5246  *
5247  * @image html screenshots/popup_example_01.png
5248  * @image latex screenshots/popup_example_01.eps width=\textwidth
5249  *
5250  * Once the popup is hidden after timeout:
5251  *
5252  * @image html screenshots/popup_example_01_a.png
5253  * @image latex screenshots/popup_example_01_a.eps width=\textwidth
5254  *
5255  * @example popup_example_01.c
5256  */
5257
5258  /** @page popup_example_02_c popup_example_02.c
5259  * @include popup_example_02.c
5260  *
5261  * This example will look like this:
5262  *
5263  * @image html screenshots/popup_example_02.png
5264  * @image latex screenshots/popup_example_02.eps width=\textwidth
5265  *
5266  * @example popup_example_02.c
5267  */
5268
5269 /**
5270  * @page popup_example_03_c popup_example_03.c
5271  * @include popup_example_03.c
5272  *
5273  * This example will look like this:
5274  *
5275  * @image html screenshots/popup_example_03.png
5276  * @image latex screenshots/popup_example_03.eps width=\textwidth
5277  *
5278  * @example popup_example_03.c
5279  */
5280
5281 /**
5282  * @page tutorial_frame Frame example
5283  * @dontinclude frame_example_01.c
5284  *
5285  * In this example we are going to create 4 Frames with different styles and
5286  * add a rectangle of different color in each.
5287  *
5288  * We start we the usual setup code:
5289  * @until show(bg)
5290  *
5291  * And then create one rectangle:
5292  * @until show
5293  *
5294  * To add it in our first frame, which since it doesn't have it's style
5295  * specifically set uses the default style:
5296  * @until show
5297  *
5298  * And then create another rectangle:
5299  * @until show
5300  *
5301  * To add it in our second frame, which uses the "pad_small" style, note that
5302  * even tough we are setting a text for this frame it won't be show, only the
5303  * default style shows the Frame's title:
5304  * @until show
5305  * @note The "pad_small", "pad_medium", "pad_large" and "pad_huge" styles are
5306  * very similar, their only difference is the size of the empty area around
5307  * the content of the frame.
5308  *
5309  * And then create yet another rectangle:
5310  * @until show
5311  *
5312  * To add it in our third frame, which uses the "outdent_top" style, note
5313  * that even tough we are setting a text for this frame it won't be show,
5314  * only the default style shows the Frame's title:
5315  * @until show
5316  *
5317  * And then create one last rectangle:
5318  * @until show
5319  *
5320  * To add it in our fourth and final frame, which uses the "outdent_bottom"
5321  * style, note that even tough we are setting a text for this frame it won't
5322  * be show, only the default style shows the Frame's title:
5323  * @until show
5324  *
5325  * And now we are left with just some more setup code:
5326  * @until ELM_MAIN()
5327  *
5328  * Our example will look like this:
5329  *
5330  * @image html screenshots/frame_example_01.png
5331  * @image latex screenshots/frame_example_01.eps width=\textwidth
5332  *
5333  * @example frame_example_01.c
5334  */
5335
5336 /**
5337  * @page tutorial_anchorblock_example Anchorblock/Anchorview example
5338  * This example will show both Anchorblock and @ref Anchorview,
5339  * since both are very similar and it's easier to show them once and side
5340  * by side, so the difference is more clear.
5341  *
5342  * We'll show the relevant snippets of the code here, but the full example
5343  * can be found here... sorry, @ref anchorblock_example_01.c "here".
5344  *
5345  * As for the actual example, it's just a simple window with an anchorblock
5346  * and an anchorview, both containing the same text. After including
5347  * Elementary.h and declaring some functions we'll need, we jump to our
5348  * elm_main (see ELM_MAIN) and create our window.
5349  * @dontinclude anchorblock_example_01.c
5350  * @skip int
5351  * @until const char
5352  * @until ;
5353  *
5354  * With the needed variables declared, we'll create the window and a box to
5355  * hold our widgets, but we don't need to go through that here.
5356  *
5357  * In order to make clear where the anchorblock ends and the anchorview
5358  * begins, they'll be each inside a @ref Frame. After creating the frame,
5359  * the anchorblock follows.
5360  * @skip elm_frame_add
5361  * @until elm_frame_content_set
5362  *
5363  * Nothing out of the ordinary there. What's worth mentioning is the call
5364  * to elm_anchorblock_hover_parent_set(). We are telling our widget that
5365  * when an anchor is clicked, the hover for the popup will cover the entire
5366  * window. This affects the area that will be obscured by the hover and
5367  * where clicking will dismiss it, as well as the calculations it does to
5368  * inform the best locations where to insert the popups content.
5369  * Other than that, the code is pretty standard. We also need to set our
5370  * callback for when an anchor is clicked, since it's our task to populate
5371  * the popup. There's no default for it.
5372  *
5373  * The anchorview is no different, we only change a few things so it looks
5374  * different.
5375  * @until elm_frame_content_set
5376  *
5377  * Then we run, so stuff works and close our main function in the usual way.
5378  * @until ELM_MAIN
5379  *
5380  * Now, a little note. Normally you would use either one of anchorblock or
5381  * anchorview, set your one callback to clicks and do your stuff in there.
5382  * In this example, however, there are a few tricks to make it easier to
5383  * show both widgets in one go (and to save me some typing). So we have
5384  * two callbacks, one per widget, that will call a common function to do
5385  * the rest. The trick is using ::Elm_Entry_Anchorblock_Info for the
5386  * anchorview too, since both are equal, and passing a callback to use
5387  * for our buttons to end the hover, because each widget has a different
5388  * function for it.
5389  * @until _anchorview_clicked_cb
5390  * @until }
5391  *
5392  * The meat of our popup is in the following function. We check what kind
5393  * of menu we need to show, based on the name set to the anchor in the
5394  * markup text. If there's no type (something went wrong, no valid contact
5395  * in the address list) we are just putting a button that does nothing, but
5396  * it's perfectly reasonable to just end the hover and call it quits.
5397  *
5398  * Our popup will consist of one main button in the middle of our hover,
5399  * and possibly a secondary button and a list of other options. We'll create
5400  * first our main button and check what kind of popup we need afterwards.
5401  * @skip static void
5402  * @skip static void
5403  * @until eina_stringshare_add
5404  * @until }
5405  *
5406  * Each button has two callbacks, one is our hack to close the hover
5407  * properly based on which widget it belongs to, the other a simple
5408  * printf that will show the action with the anchors own data. This is
5409  * not how you would usually do it. Instead, the common case is to have
5410  * one callback for the button that will know which function to call to end
5411  * things, but since we are doing it this way it's worth noting that
5412  * smart callbacks will be called in reverse in respect to the order they
5413  * were added, and since our @c btn_end_cb will close the hover, and thus
5414  * delete our buttons, the other callback wouldn't be called if we had
5415  * added it before.
5416  *
5417  * After our telephone popup, there are a few others that are practically
5418  * the same, so they won't be shown here.
5419  *
5420  * Once we are done with that, it's time to place our actions into our
5421  * hover. Main button goes in the middle without much questioning, and then
5422  * we see if we have a secondary button and a box of extra options.
5423  * Because I said so, secondary button goes on either side and box of
5424  * options either on top or below the main one, but to choose which
5425  * exactly, we use the hints our callback info has, which saves us from
5426  * having to do the math and see which side has more space available, with
5427  * a little special case where we delete our extra stuff if there's nowhere
5428  * to place it.
5429  * @skip url:
5430  * @skip }
5431  * @skip evas_object_smart
5432  * @until evas_object_del(box)
5433  * @until }
5434  * @until }
5435  *
5436  * The example will look like this:
5437  *
5438  * @image html screenshots/anchorblock_01.png
5439  * @image latex screenshots/anchorblock_01.eps width=\textwidth
5440  *
5441  * @example anchorblock_example_01.c
5442  */
5443
5444 /**
5445  * @page tutorial_check Check example
5446  * @dontinclude check_example_01.c
5447  *
5448  * This example will show 2 checkboxes, one with just a label and the second
5449  * one with both a label and an icon. This example also ilustrates how to
5450  * have the checkbox change the value of a variable and how to react to those
5451  * changes.
5452  *
5453  * We will start with the usual setup code:
5454  * @until show(bg)
5455  *
5456  * And now we create our first checkbox, set its label, tell it to change
5457  * the value of @p value when the checkbox stats is changed and ask to be
5458  * notified of state changes:
5459  * @until show
5460  *
5461  * For our second checkbox we are going to set an icon so we need to create
5462  * and icon:
5463  * @until show
5464  * @note For simplicity we are using a rectangle as icon, but any evas object
5465  * can be used.
5466  *
5467  * And for our second checkbox we set the label, icon and state to true:
5468  * @until show
5469  *
5470  * We now do some more setup:
5471  * @until ELM_MAIN
5472  *
5473  * And finally implement the callback that will be called when the first
5474  * checkbox's state changes. This callback will use @p data to print a
5475  * message:
5476  * @until }
5477  * @note This work because @p data is @p value(from the main function) and @p
5478  * value is changed when the checkbox is changed.
5479  *
5480  * Our example will look like this:
5481  *
5482  * @image html screenshots/check_example_01.png
5483  * @image latex screenshots/check_example_01.eps width=\textwidth
5484  *
5485  * @example check_example_01.c
5486  */
5487
5488 /**
5489  * @page tutorial_colorselector Color selector example
5490  * @dontinclude colorselector_example_01.c
5491  *
5492  * This example shows how to change the color of a rectangle using a color
5493  * selector. We aren't going to explain a lot of the code since it's the
5494  * usual setup code:
5495  * @until show(rect)
5496  *
5497  * Now that we have a window with background and a rectangle we can create
5498  * our color_selector
5499  * @until elm_colorselector_add
5500  *
5501  * Now colors can be loaded to color selector's palette by setting the palette name
5502  * @until show(cs)
5503  *
5504  * Next we ask to be notified whenever the color changes on selector:
5505  * @until changed
5506  *
5507  * Next we ask to be notified whenever the color item is selected and longpressed:
5508  * @until color,item,longpressed
5509  *
5510  * We add some more code to the usual setup code:
5511  * @until ELM_MAIN()
5512  *
5513  * now get to the "changed" callback that sets the color of the rectangle:
5514  * @until }
5515  *
5516  * And now get to the "color,item,selected" callback that sets the color of the rectangle:
5517  * @until }
5518  *
5519  * And now get to the "color,item,longpressed" callback that gets and displays 
5520  * the color of the rectangle:
5521  * @until }
5522  *
5523  * This example will look like this:
5524  *
5525  * @image html screenshots/colorselector_example_01.png
5526  * @image latex screenshots/colorselector_example_01.eps width=\textwidth
5527  *
5528  * @example colorselector_example_01.c
5529  */
5530
5531 /**
5532  * @page slideshow_example Slideshow widget example
5533  *
5534  * This application is aimed to exemplify the slideshow widget. It
5535  * consists of a window with a slideshow widget set as "resize
5536  * object", along with a control bar, in the form of a notify. Those
5537  * controls will exercise most of the slideshow's API functions.
5538  *
5539  * We create the slideshow, itself, first, making it @b loop on its
5540  * image itens, when in slideshow mode:
5541  * @dontinclude slideshow_example.c
5542  * @skip slideshow = elm_slideshow_add
5543  * @until evas_object_show
5544  *
5545  * Next, we define the <b>item class</b> for our slideshow
5546  * items. Slideshow images are going to be Elementary @ref Photo "photo"
5547  * widgets, here, as pointed by our @c get class
5548  * function. We'll let the Elementary infrastructure to delete those
5549  * objects for us, and, as there's no additional data attached to our
5550  * slideshow items, the @c del class function can be left undefined:
5551  * @dontinclude slideshow_example.c
5552  * @skip itc
5553  * @until ;
5554  * @dontinclude slideshow_example.c
5555  * @skip itc.func
5556  * @until = NULL
5557  * @dontinclude slideshow_example.c
5558  * @skip get our images to make slideshow items
5559  * @until }
5560  *
5561  * We now get to populate the slideshow widget with items. Our images
5562  * are going to be some randomly chosen from the Elementary package,
5563  * nine of them. For the first eight, we insert them ordered in the
5564  * widget, by using elm_slideshow_item_sorted_insert(). The comparing
5565  * function will use the image names to sort items. The last item is
5566  * inserted at the end of the slideshow's items list, with
5567  * elm_slideshow_item_add(). We check out how that list ends with
5568  * elm_slideshow_items_get(), than:
5569  * @dontinclude slideshow_example.c
5570  * @skip static const char *img
5571  * @until _2
5572  * @dontinclude slideshow_example.c
5573  * @skip first =
5574  * @until data_get
5575  *
5576  * Note that we save the pointers to the first and last items in the
5577  * slideshow, for future use.
5578  *
5579  * What follows is the code creating a notify, to be shown over the
5580  * slideshow's viewport, with knobs to act on it. We're not showing
5581  * that boilerplate code, but only the callbacks attached to the
5582  * interesting smart events of those knobs. The first four are
5583  * buttons, which will:
5584  * - Select the @b next item in the slideshow
5585  * - Select the @b previous item in the slideshow
5586  * - Select the @b first item in the slideshow
5587  * - Select the @b last item in the slideshow
5588  *
5589  * Check out the code for those four actions, being the two last @c
5590  * data pointers the same @c first and @c last pointers we save
5591  * before, respectively:
5592  * @dontinclude slideshow_example.c
5593  * @skip jump to next
5594  * @until }
5595  * @until }
5596  * @until }
5597  * @until }
5598  *
5599  * What follow are two hoversels, meant for one to change the
5600  * slideshow's @b transition and @b layout styles, respectively. We
5601  * fetch all the available transition and layout names to populate
5602  * those widgets and, when one selects any of them, we apply the
5603  * corresponding setters on the slideshow:
5604  * @dontinclude slideshow_example.c
5605  * @skip hv = elm_hoversel_add
5606  * @until show(hv)
5607  * @until show(hv)
5608  * @dontinclude slideshow_example.c
5609  * @skip transition changed
5610  * @until }
5611  * @until }
5612  *
5613  * For one to change the transition @b time on the slideshow widget,
5614  * we use a spinner widget. We set it to the initial value of 3
5615  * (seconds), which will be probed by the next knob -- a button
5616  * starting the slideshow, de facto. Note that changing the transition
5617  * time while a slideshow is already happening will ajust its
5618  * transition time:
5619  * @dontinclude slideshow_example.c
5620  * @skip spin = elm_spinner_add
5621  * @until evas_object_show
5622  * @dontinclude slideshow_example.c
5623  * @skip slideshow transition time has
5624  * @until }
5625  *
5626  * Finally, we have two buttons which will, respectively, start and
5627  * stop the slideshow on our widget. Here are their "clicked"
5628  * callbacks:
5629  * @dontinclude slideshow_example.c
5630  * @skip start the show
5631  * @until }
5632  * @until }
5633  *
5634  * This is how the example program's window looks like:
5635  * @image html screenshots/slideshow_example.png
5636  * @image latex screenshots/slideshow_example.eps width=\textwidth
5637  *
5638  * See the full @ref slideshow_example_c "source code" for
5639  * this example.
5640  *
5641  * @example slideshow_example.c
5642  */
5643
5644 /**
5645  * @page tutorial_photocam Photocam example
5646  * @dontinclude photocam_example_01.c
5647  *
5648  * In this example we will have a photocam and a couple of buttons and slider to
5649  * control the photocam. To avoid cluttering we'll only show the parts of the
5650  * example that relate to the photocam, the full source code can be seen @ref
5651  * photocam_example_01.c "here".
5652  *
5653  * Creating a photocam is as easy as creating any other widget:
5654  * @skipline elm_photocam_add
5655  *
5656  * A photocam is only useful if we have a image on it, so lets set a file for it
5657  * to work with:
5658  * @until file_set
5659  *
5660  * We now set the photocam to not bounce horizontally:
5661  * @until bounce_set
5662  *
5663  * And we want to know when the photocam has finished loading the image so:
5664  * @until smart_callback
5665  *
5666  * The reason to know when the image is loaded is so that we can bring the
5667  * center of the image into view:
5668  * @skip static
5669  * @until }
5670  *
5671  * As mentioned we have 2 buttons in this example, the "Fit" one will cause
5672  * the photocam to go in to a zoom mode that makes the image fit inside the
5673  * photocam. Tough this has no effect on the image we also print what region was
5674  * being viewed before setting the zoom mode:
5675  * @skip static
5676  * @until }
5677  * @note When in fit mode our slider(explained below) won't work.
5678  *
5679  * The second button("Unfit") will bring the photocam back into manual zoom
5680  * mode:
5681  * @skip static
5682  * @until }
5683  *
5684  * Our slider controls the level of zoom of the photocam:
5685  * @skip static
5686  * @until }
5687  * @note It is important to note that this only works when in manual zoom mode.
5688  *
5689  * Our example will initially look like this:
5690  *
5691  * @image html screenshots/photocam_example_01.png
5692  * @image latex screenshots/photocam_example_01.eps width=\textwidth
5693  *
5694  * @example photocam_example_01.c
5695  */
5696
5697 /**
5698  * @page inwin_example_01 Inwin - General overview
5699  *
5700  * Inwin is a very simple widget to show, so this example will be a very simple
5701  * one, just using all of the available API.
5702  *
5703  * The program is nothing but a window with a lonely button, as shown here.
5704  *
5705  * @image html screenshots/inwin_example.png
5706  * @image latex screenshots/inwin_example.eps width=\textwidth
5707  *
5708  * And pressing the button makes an inwin appear.
5709  *
5710  * @image html screenshots/inwin_example_a.png
5711  * @image latex screenshots/inwin_example_a.eps width=\textwidth
5712  *
5713  * And the code is just as simple. We being with some global variables to keep
5714  * track of our Inwin.
5715  * @dontinclude inwin_example.c
5716  * @skip static
5717  * @until current_style
5718  *
5719  * And two callbacks used by the buttons the above screenshot showed. In these,
5720  * we check if @c inwin exists and execute the proper action on it. If it's not
5721  * there anymore, then we were abandoned to our luck, so we disabled ourselves.
5722  * @until _inwin_destroy
5723  * @until }
5724  * @until }
5725  *
5726  * The lonely button from the beginning, when clicked, will call the following
5727  * function, which begins by checking if an inwin exists, and if it's there,
5728  * we bring it back to the front and exit from our function without any further
5729  * ado.
5730  * @until }
5731  *
5732  * But if no inwin is there to show, we need to create one. First we need the
5733  * top-most window for the program, as no inwin can be created using other
5734  * objects as parents. Then we create our popup, set the next style in the list
5735  * and show it.
5736  * @until current_style =
5737  *
5738  * As for the content of our inwin, it's just a box with a label and some
5739  * buttons inside.
5740  * @until _inwin_destroy
5741  * @until }
5742  *
5743  * Now, all the code above shows how every object must always be set as content
5744  * for some other object, be it by setting the full content, packing it in a
5745  * box or table or working as icon for some other widget. But we didn't do
5746  * anything like that for the inwin, this one is just created and shown and
5747  * everything works. Other widgets can be used this way, but they would need
5748  * to be placed and resized manually or nothing would be shown correctly. The
5749  * inwin, however, sets itself as a children of the top-level window and will
5750  * be resized as the parent window changes too.
5751  *
5752  * Another characteristic of Inwin is that when it's shown above everyone else,
5753  * it will work kind of like a modal window, blocking any other widget from
5754  * receiving events until the window is manually dismissed by pressing some
5755  * button to close it or having blocking task signalling its completion so
5756  * normal operations can be resumed. This is unlike the @ref Hover widget,
5757  * that would show its content on top of the designated target, but clicking
5758  * anywhere else would dismiss it automatically.
5759  *
5760  * To illustrate that last point, when we close the main window and an inwin
5761  * is still there, we'll take out the content from the inwin and place it in
5762  * a hover.
5763  * @until }
5764  * @until }
5765  *
5766  * And the rest of the program doesn't have anything else related to inwin,
5767  * so it won't be shown here, but you can find it in
5768  * @ref inwin_example.c "inwin_example.c".
5769  *
5770  * @example inwin_example.c
5771  */
5772
5773 /**
5774  * @page tutorial_scroller Scroller example
5775  * @dontinclude scroller_example_01.c
5776  *
5777  * This example is very short and will illustrate one way to use a scroller.
5778  * We'll omit the declaration of the @p text variable because it's a very long
5779  * @htmlonly<a href="http://lipsum.com/">@endhtmlonly ipsum lorem
5780  * @htmlonly</a>@endhtmlonly. If you really want to see the full code, it's @ref
5781  * scroller_example_01.c "scroller_example_01.c".
5782  *
5783  * We start our example by creating our window and background:
5784  * @skip EAPI
5785  * @until show(bg)
5786  *
5787  * Next we create a label and set it's text to @p text(very long ipsum lorem):
5788  * @until show(label)
5789  *
5790  * We then create our scroller, ask that it have the same size as the window and
5791  * set its content:
5792  * @until content_set
5793  *
5794  * We are now going to set a number of properties in our scroller:
5795  * @li We make it bounce horizontally but not vertically.
5796  * @li We make both scrollbars always be visible.
5797  * @li We have the events be propagated from the content to the scroller.
5798  * @li We enforce a page policy vertically(having a page be the size of the
5799  * viewport) and leave horizontal scrolling free.
5800  * @li And finally we ask the scroller to show us a region starting at 50,50 and
5801  * having a width and height of 200px.
5802  * @until region_show
5803  * @note Observant reader will note that the elm_scroller_region_show() didn't
5804  * scroll the view vertically, this is because we told the scroller to only
5805  * accept vertical scrolling in pages.
5806  *
5807  * And now we're done:
5808  * @until ELM_MAIN
5809  *
5810  * Our example will look like this:
5811  *
5812  * @image html screenshots/scroller_example_01.png
5813  * @image latex screenshots/scroller_example_01.eps width=\textwidth
5814  *
5815  * @example scroller_example_01.c
5816  */
5817
5818 /**
5819  * @page tutorial_table_01
5820  *
5821  * In this example we add four labels to a homogeneous table that has a padding
5822  * of 5px between cells.
5823  *
5824  * The interesting bits from this example are:
5825  * @li Where we set the table as homogeneous and the padding:
5826  * @dontinclude table_example_01.c
5827  * @skip padding_set
5828  * @until homogeneous_set
5829  * @li Where we add each label to the table:
5830  * @skipline elm_table_pack
5831  * @skipline elm_table_pack
5832  * @skipline elm_table_pack
5833  * @skipline elm_table_pack
5834  *
5835  * Here you can see the full source:
5836  * @include table_example_01.c
5837  *
5838  * Our example will look like this:
5839  *
5840  * @image html screenshots/table_example_01.png
5841  * @image latex screenshots/table_example_01.eps width=\textwidth
5842  *
5843  * @example table_example_01.c
5844  */
5845
5846 /**
5847  * @page tutorial_table_02
5848  *
5849  * For our second example we'll create a table with 4 rectangles in it. Since
5850  * our rectangles are of different sizes our table won't be homogeneous.
5851  *
5852  * The interesting bits from this example are:
5853  * @li Where we set the table as not homogeneous:
5854  * @dontinclude table_example_02.c
5855  * @skipline homogeneous_set
5856  * @li Where we add each rectangle to the table:
5857  * @skipline elm_table_pack
5858  * @skipline elm_table_pack
5859  * @skipline elm_table_pack
5860  * @skipline elm_table_pack
5861  *
5862  * Here you can see the full source:
5863  * @include table_example_02.c
5864  *
5865  * Our example will look like this:
5866  *
5867  * @image html screenshots/table_example_02.png
5868  * @image latex screenshots/table_example_02.eps width=\textwidth
5869  *
5870  * @example table_example_02.c
5871  */
5872
5873 /**
5874  * @page tutorial_menu Menu Example
5875  * @dontinclude menu_example_01.c
5876  *
5877  * This example shows how to create a menu with regular items, object items,
5878  * submenus and how to delete items from a menu. The full source for this
5879  * example is @ref menu_example_01.c "menu_example_01.c".
5880  *
5881  * We'll start looking at the menu creation and how to create a very simple
5882  * item:
5883  * @skip menu_add
5884  * @until item_add
5885  *
5886  * For our next item we are going to add an icon:
5887  * @until item_add
5888  *
5889  * Now we are going to add more items, but these icons are going to have a
5890  * parent, which will put them in a sub-menu. First just another item with an
5891  * icon:
5892  * @until item_add
5893  *
5894  * Next we are going to add a button to our menu(any elm widget can be added to
5895  * a menu):
5896  * @until item_add
5897  *
5898  * We are also going to have the button delete the first item of our
5899  * sub-menu when clicked:
5900  * @until smart_callback
5901  * @dontinclude menu_example_01.c
5902  * @skip static
5903  * @until }
5904  *
5905  * We now add a separator and three more regular items:
5906  * @until item_add
5907  * @until item_add
5908  * @until item_add
5909  *
5910  * We now add another item, however this time it won't go the sub-menu and it'll
5911  * be disabled:
5912  * @until disabled_set
5913  *
5914  * To make sure that our menu is shown whenever the window is clicked(and where
5915  * clicked) we use the following callback:
5916  * @dontinclude menu_example_01.c
5917  * @skip static
5918  * @skipline static
5919  * @until }
5920  *
5921  * Our example will look like this:
5922  *
5923  * @image html screenshots/menu_example_01.png
5924  * @image latex screenshots/menu_example_01.eps width=\textwidth
5925  *
5926  * @example menu_example_01.c
5927  */
5928
5929 /**
5930  * @page win_example_01 Win - General API overview
5931  *
5932  * For most users of the Elementary API, the @ref Win widget has a lot more
5933  * functions than what they need.
5934  *
5935  * In general, a developer will create a window, set some content on it and
5936  * forget about it for the rest of its program's life, letting whatever
5937  * Window Manager is there to handle the window. Here, however, we are going
5938  * to show how to generally manage a window.
5939  *
5940  * We'll have a bit more than the usual includes here, since part of the
5941  * example requires some low level fiddling.
5942  * @dontinclude win_example.c
5943  * @skip Elementary.h
5944  * @until Ecore_X.h
5945  *
5946  * The program then, consists of one window with two lists of buttons, each
5947  * of which operates on another two windows. One of them is a normal window,
5948  * the other has the @c override flag set so the Window Manager ignores it.
5949  *
5950  * Pressing each button will call the corresponding function to act on the
5951  * corresponding window. These are pretty self explanatory, so we'll show
5952  * them in one batch.
5953  * @skip static void
5954  * @until elm_win_sticky_set
5955  * @until }
5956  *
5957  * Next, we handle the main window closing. We have a @c "delete,request"
5958  * callback set to ask if really want to quit. If so, we end the main loop,
5959  * otherwise just delete the popup message and continue running normally.
5960  * @until _no_quit_cb
5961  * @until _no_quit_cb
5962  * @until }
5963  *
5964  * The non-managed window, being completely ignored by the Window Manager,
5965  * is likely to never receive keyboard focus, even if we click on its entry
5966  * to write something. So we have a button on it that will forcefully focus
5967  * it by using some lower level functions to act directly on the X window.
5968  * Then, each time one of the window is focused, we print some message on a
5969  * console to show this more clearly.
5970  * @until _win_focused_cb
5971  * @until }
5972  *
5973  * And to finalize, the main function creates a window to hold all the action
5974  * buttons and another two to show how (and what) works on each of them.
5975  *
5976  * First, the main window will be a normal window, we'll enable the focus
5977  * highlight regardless of how it is configured so it's easier to navigate
5978  * the window with the keyboard. Then we hook our focus and delete callbacks
5979  * and set up the rest of the window's content.
5980  * @until evas_object_show(box)
5981  *
5982  * The first of our sub-windows is the managed one. We'll create it as a
5983  * dialog, which should make the Window Manager treat it as a non-resizable
5984  * window. We are also setting the window to be auto-deleted when the close
5985  * button in the titlebar is pressed.
5986  * @until evas_object_show(o)
5987  *
5988  * Now, we added an icon to the window as a resize object. We also set this
5989  * icon to not scale, and no weight size hints have been set for it. This way,
5990  * even if we hadn't created the window as a dialog, it would still not be
5991  * resizable. The window size is defined by its content, so it would never be
5992  * smaller than the smallest of its resize objects, and for it to be resizable,
5993  * all of those objects have to allow it.
5994  *
5995  * Next, we add the buttons with the actions to perform on this window. Using
5996  * a macro saves us typing and makes the world a happier place.
5997  * @until WIN_ACTION(sticky)
5998  *
5999  * The maximize one is likely to not work, because the Window Manager will
6000  * probably not enforce it upon a window that states its maximum size, much
6001  * less a dialog. But that can be changed by editting the example to use
6002  * #ELM_WIN_BASIC when creating the window and adding the following line to
6003  * the icon set as content
6004  * @code
6005  * evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
6006  * @endcode
6007  *
6008  * Lastly, the second sub-window will have it's override flag set. In it we
6009  * have a label with some text, and entry and a button. The entry can be
6010  * clicked normally to set focus on it, but whether it actually gets keyboard
6011  * input will also depend on the window getting focus, and since the window
6012  * is an override one, it will probably not gain it by normal means. The
6013  * button is there to force the focus at the X level to go to our window.
6014  * And to finish, another list of buttons with actions to perform on this
6015  * last window. Remember that most of them are requests or hints for the
6016  * Window Manager, so they are likely to do nothing on this window.
6017  * Similarly, there won't be any way to move it or resize it, because we
6018  * haven't implemented that kind of control on this example and that's
6019  * something controlled by Window Managers on windows they are tracking, which
6020  * is not the case with this one.
6021  * @until ELM_MAIN
6022  *
6023  * The full code listing of this example can be found at
6024  * @ref win_example.c "win_example.c".
6025  *
6026  * @example win_example.c
6027  */
6028
6029 /**
6030  * @page web_example_01 Web - Simple example
6031  *
6032  * WebKit-EFL is independent of any particular toolkit, such as Elementary,
6033  * so using it on applications requires that the programmer writes a lot of
6034  * boiler plate code to manage to manage the web object.
6035  *
6036  * For a full featured browser this may make sense, as the programmer will
6037  * want to have full control of every aspect of the web object, since it's the
6038  * main component of the application. But other programs with simpler
6039  * requirements, having to write so much code is undesired.
6040  *
6041  * This is where elm_web comes in. Its purpose is to provide a simple way
6042  * for developers to embed a simple web object in their programs, simplifying
6043  * the common use cases.
6044  *
6045  * This is not to say that a browser can't be made out of it, as this example
6046  * shows.
6047  *
6048  * We'll be making a simple browser, consisting of one window with an URL bar,
6049  * a toolbar to be used for the tabs and a pager to show one page at a time.
6050  *
6051  * When all tabs are closed, we'll be showing a default view with some custom
6052  * content, for which we need to get the internal @c ewk_view object and use
6053  * some WebKit functions on it, thus we need to include the necessary headers
6054  * first.
6055  *
6056  * @dontinclude web_example.c
6057  * @skip include
6058  * @until EWebKit
6059  *
6060  * A struct to keep track of the different widgets in use and the currently
6061  * shown tab. There's also an @c exiting flag, used to work around the overly
6062  * simplistic way in which this example is written, just to avoid some
6063  * warnings when closing the program.
6064  *
6065  * @skip typedef
6066  * @skip typedef
6067  * @until App_Data
6068  *
6069  * Each tab has its own struct too, but there's not much to it.
6070  * @until };
6071  *
6072  * Whenever the currently selected tab changes, we need to update some state
6073  * on the application. The back and forward buttons need to be disabled
6074  * accordingly and the URL bar needs to show the right address.
6075  *
6076  * @skip static void
6077  * @until naviframe_item_simple_promote
6078  * @until }
6079  *
6080  * Other updates happen based on events from the web object, like title change
6081  * to update the name shown in the tab, and URL change which will update the
6082  * URL bar if the event came from the currently selected tab.
6083  *
6084  * @skip tab_current_set
6085  * @skip static void
6086  * @until }
6087  * @until }
6088  *
6089  * Adding a new tab is just a matter of creating a new web widget, its data
6090  * and pushing it into the pager. A lot of the things that we should handle
6091  * here, such as how to react to popups and JavaScript dialogs, are done
6092  * already in the @c elm_web widget, so we can rely on their default
6093  * implementations. For the JavaScript dialogs we are going to avoid having
6094  * them open in a new window by setting the @c Inwin mode.
6095  *
6096  * There is no default implementation, however, for the requests to create a
6097  * new window, so we have to handle them by setting a callback function that
6098  * will ultimately call this very same function to add a new tab.
6099  *
6100  * @skip td->tab = NULL
6101  * @skip Tab_Data
6102  * @until }
6103  *
6104  * Entering an address in the URL bar will check if a tab exists, and if not,
6105  * create one and set the URL for it. The address needs to conform to the URI
6106  * format, so we check that it does and add the protocol if it's missing.
6107  *
6108  * @skip static char
6109  * @until eina_stringshare_del
6110  * @until }
6111  *
6112  * The navigation buttons are simple enough. As for the refresh, it normally
6113  * reloads the page using anything that may exist in the caches if applicable,
6114  * but we can press it while holding the @c Shift key to avoid the cache.
6115  *
6116  * @skip static void
6117  * @until web_forward
6118  * @until }
6119  *
6120  * The callback set for the new window request creates a new tab and returns
6121  * the web widget associated with it. This is important, this function must
6122  * return a valid web widget returned by elm_web_add().
6123  *
6124  * @skip static Evas_Object
6125  * @until }
6126  *
6127  * Pressing @c Ctrl-F will bring up the search box. Nothing about the box
6128  * itself is worth mentioning here, but it works as you would expect from any
6129  * other browser. While typing on it, it will highlight all occurrences of the
6130  * searched word. Pressing @c Enter will go to the next instance and the two
6131  * buttons next to the entry will move forward and backwards through the found
6132  * keywords.
6133  *
6134  * @skip win_del_request
6135  * @skip static void
6136  * @until win_search_trigger
6137  * @until }
6138  *
6139  * Last, create the main window and put all of the things used above in it. It
6140  * contains a default web widget that will be shown when no tabs exist. This
6141  * web object is not browsable per se, so history is disabled in it, and we
6142  * set the same callback to create new windows, on top of setting some custom
6143  * content of our own on it, with some links that will open new tabs to start
6144  * browsing quickly.
6145  *
6146  * @skip static void
6147  * @until ELM_MAIN
6148  *
6149  * Some parts of the code were left out, as they are not relevant to the
6150  * example, but the full listing can be found at @ref web_example.c
6151  * "web_example.c".
6152  *
6153  * @example web_example.c
6154  */
6155
6156 /**
6157  * @page efl_thread_1 EFL Threading example 1
6158  *
6159  * You can use threads with Elementary (and EFL) but you need to be careful
6160  * to only use eina or eet calls inside a thread. Other libraries are not
6161  * totally threadsafe except for some specific ecore calls designed for
6162  * working from threads like the ecore_pipe_write() and ecore_thread calls.
6163  * 
6164  * Below is an example of how to use EFL calls from a native thread you have
6165  * already created. You have to put the EFL calls inside the critical block
6166  * between ecore_thread_main_loop_begin() and ecore_thread_main_loop_end()
6167  * which ensure you gain a lock on the mainloop. Beware that this requires
6168  * that the thread WAIT to synchronize with the mainloop at the beginning of
6169  * the critical section. It is highly suggested you use as few of these
6170  * in your thread as possible and probably put just a single 
6171  * ecore_thread_main_loop_begin() / ecore_thread_main_loop_end() section
6172  * at the end of the threads calculation or work when it is done and
6173  * would otherwise exit to sit idle.
6174  * 
6175  * For a progression of examples that become more complex and show other
6176  * ways to use threading with EFL, please see:
6177  * 
6178  * @ref efl_thread_2
6179  * 
6180  * @ref efl_thread_3
6181  * 
6182  * @ref efl_thread_4
6183  * 
6184  * @ref efl_thread_5
6185  * 
6186  * @ref efl_thread_6
6187  *
6188  * @include efl_thread_1.c
6189  */
6190
6191 /**
6192  * @page efl_thread_2 EFL Threading example 2
6193  *
6194  * You can also use ecore_main_loop_thread_safe_call_sync() to call a
6195  * specific function that needs to do EFL main loop operations. This call
6196  * will block and wait to synchronise to the mainloop just like
6197  * ecore_thread_main_loop_begin() / ecore_thread_main_loop_end() will,
6198  * but instead you simply provide it the function callback to call instead
6199  * of inlining your code.
6200  *
6201  * @ref efl_thread_3
6202  * 
6203  * @ref efl_thread_4
6204  * 
6205  * @ref efl_thread_5
6206  * 
6207  * @ref efl_thread_6
6208  *
6209  * @include efl_thread_2.c
6210  */
6211
6212 /**
6213  * @page efl_thread_3 EFL Threading example 3
6214  *
6215  * Like with ecore_main_loop_thread_safe_call_sync() you can provide a
6216  * callback to call inline in the mainloop, but this time with
6217  * ecore_main_loop_thread_safe_call_async() the callback is queued and
6218  * called asynchronously, without the thread blocking. The mainloop will
6219  * call this function when it comes around to its synchronisation point. This
6220  * acts as a "fire and forget" way of having the mainloop do some work
6221  * for a thread that has finished processing some data and is read to hand it
6222  * off to the mainloop and the thread wants to march on and do some more work
6223  * while the main loop deals with "displaying" the results of the previous
6224  * calculation.
6225  *
6226  * @ref efl_thread_4
6227  * 
6228  * @ref efl_thread_5
6229  * 
6230  * @ref efl_thread_6
6231  *
6232  * @include efl_thread_3.c
6233  */
6234
6235 /**
6236  * @page efl_thread_4 EFL Threading example 4
6237  *
6238  * Now when you want to have a thread do some work, send back results to
6239  * the mainloop and continue running but the mainloop controls when the
6240  * thread should stop working, you need some extra flags. This is an example
6241  * of how you might use ecore_main_loop_thread_safe_call_async() and pthreads
6242  * to do this.
6243  *
6244  * @ref efl_thread_5
6245  * 
6246  * @ref efl_thread_6
6247  *
6248  * @include efl_thread_4.c
6249  */
6250
6251 /**
6252  * @page efl_thread_5 EFL Threading example 5
6253  *
6254  * This is the same as @ref efl_thread_4 but now uses the ecore_thread
6255  * infrastructure to have a running worker thread that feeds results back
6256  * to the mainloop and can easily be cancelled. This saves some code in the
6257  * application and makes for fewer problem spots if you forget a mutex.
6258  *
6259  * @ref efl_thread_6
6260  *
6261  * @include efl_thread_5.c
6262  */
6263
6264 /**
6265  * @page efl_thread_6 EFL Threading example 6
6266  *
6267  * You can also use the ecore_thread infrastructure for compute tasks that
6268  * don't send feedback as they go - they are one-shot compute jobs and when
6269  * done they will trigger the end callback in the mainloop which is intended
6270  * to pick up the results and "display them".
6271  *
6272  * @include efl_thread_6.c
6273  */
6274
6275 /**
6276  * @page bg_example_01_c bg_example_01.c
6277  * @include bg_example_01.c
6278  * @example bg_example_01.c
6279  */
6280
6281 /**
6282  * @page bg_example_02_c bg_example_02.c
6283  * @include bg_example_02.c
6284  * @example bg_example_02.c
6285  */
6286
6287 /**
6288  * @page bg_example_03_c bg_example_03.c
6289  * @include bg_example_03.c
6290  * @example bg_example_03.c
6291  */
6292
6293 /**
6294  * @page actionslider_example_01 Actionslider example
6295  * @include actionslider_example_01.c
6296  * @example actionslider_example_01.c
6297  */
6298
6299 /**
6300  * @page transit_example_01_c Transit example 1
6301  * @include transit_example_01.c
6302  * @example transit_example_01.c
6303  */
6304
6305 /**
6306  * @page transit_example_02_c Transit example 2
6307  * @include transit_example_02.c
6308  * @example transit_example_02.c
6309  */
6310
6311 /**
6312  * @page general_functions_example_c General (top-level) functions example
6313  * @include general_funcs_example.c
6314  * @example general_funcs_example.c
6315  */
6316
6317 /**
6318  * @page clock_example_c Clock example
6319  * @include clock_example.c
6320  * @example clock_example.c
6321  */
6322
6323  /**
6324  * @page datetime_example_c Datetime example
6325  * @include datetime_example.c
6326  * @example datetime_example.c
6327  */
6328
6329 /**
6330  * @page dayselector_example_c Dayselector example
6331  * @include dayselector_example.c
6332  * @example dayselector_example.c
6333  */
6334
6335 /**
6336  * @page flipselector_example_c Flipselector example
6337  * @include flipselector_example.c
6338  * @example flipselector_example.c
6339  */
6340
6341 /**
6342  * @page fileselector_example_c Fileselector example
6343  * @include fileselector_example.c
6344  * @example fileselector_example.c
6345  */
6346
6347 /**
6348  * @page fileselector_button_example_c Fileselector button example
6349  * @include fileselector_button_example.c
6350  * @example fileselector_button_example.c
6351  */
6352
6353 /**
6354  * @page fileselector_entry_example_c Fileselector entry example
6355  * @include fileselector_entry_example.c
6356  * @example fileselector_entry_example.c
6357  */
6358
6359 /**
6360  * @page index_example_01_c Index example
6361  * @include index_example_01.c
6362  * @example index_example_01.c
6363  */
6364
6365 /**
6366  * @page index_example_02_c Index example
6367  * @include index_example_02.c
6368  * @example index_example_02.c
6369  */
6370
6371 /**
6372  * @page layout_example_01_c layout_example_01.c
6373  * @include layout_example_01.c
6374  * @example layout_example_01.c
6375  */
6376
6377 /**
6378  * @page layout_example_02_c layout_example_02.c
6379  * @include layout_example_02.c
6380  * @example layout_example_02.c
6381  */
6382
6383 /**
6384  * @page layout_example_03_c layout_example_03.c
6385  * @include layout_example_03.c
6386  * @example layout_example_03.c
6387  */
6388
6389 /**
6390  * @page layout_example_edc An example of layout theme file
6391  *
6392  * This theme file contains two groups. Each of them is a different theme, and
6393  * can be used by an Elementary Layout widget. A theme can be used more than
6394  * once by many different Elementary Layout widgets too.
6395  *
6396  * @include layout_example.edc
6397  * @example layout_example.edc
6398  */
6399
6400 /**
6401  * @page gengrid_example_c Gengrid example
6402  * @include gengrid_example.c
6403  * @example gengrid_example.c
6404  */
6405
6406 /**
6407  * @page genlist_example_01_c genlist_example_01.c
6408  * @include genlist_example_01.c
6409  * @example genlist_example_01.c
6410  */
6411
6412 /**
6413  * @page genlist_example_02_c genlist_example_02.c
6414  * @include genlist_example_02.c
6415  * @example genlist_example_02.c
6416  */
6417
6418 /**
6419  * @page genlist_example_04_c genlist_example_04.c
6420  * @include genlist_example_04.c
6421  * @example genlist_example_04.c
6422  */
6423
6424 /**
6425  * @page genlist_example_05_c genlist_example_05.c
6426  * @include genlist_example_05.c
6427  * @example genlist_example_05.c
6428  */
6429
6430 /**
6431  * @page thumb_example_01_c thumb_example_01.c
6432  * @include thumb_example_01.c
6433  * @example thumb_example_01.c
6434  */
6435
6436 /**
6437  * @page progressbar_example_c Progress bar example
6438  * @include progressbar_example.c
6439  * @example progressbar_example.c
6440  */
6441
6442 /**
6443  * @page slideshow_example_c Slideshow example
6444  * @include slideshow_example.c
6445  * @example slideshow_example.c
6446  */
6447
6448 /**
6449  * @page efl_thread_1_c EFL Threading example 1
6450  * @include efl_thread_1.c
6451  * @example efl_thread_1.c
6452  */
6453
6454 /**
6455  * @page efl_thread_2_c EFL Threading example 2
6456  * @include efl_thread_2.c
6457  * @example efl_thread_2.c
6458  */
6459
6460 /**
6461  * @page efl_thread_3_c EFL Threading example 3
6462  * @include efl_thread_3.c
6463  * @example efl_thread_3.c
6464  */
6465
6466 /**
6467  * @page efl_thread_4_c EFL Threading example 4
6468  * @include efl_thread_4.c
6469  * @example efl_thread_4.c
6470  */
6471
6472 /**
6473  * @page efl_thread_5_c EFL Threading example 5
6474  * @include efl_thread_5.c
6475  * @example efl_thread_5.c
6476  */
6477
6478 /**
6479  * @page efl_thread_6_c EFL Threading example 6
6480  * @include efl_thread_6.c
6481  * @example efl_thread_6.c
6482  */