[elementary] Put dangling examples on the proper file.
[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 elm_animator_example_page_01
15  *
16  * @ref transit_example_01_explained
17  *
18  * @ref transit_example_02_explained
19  *
20  * @ref general_functions_example_page
21  *
22  * @ref calendar_example_01
23  *
24  * @ref calendar_example_02
25  *
26  * @ref calendar_example_03
27  *
28  * @ref calendar_example_04
29  *
30  * @ref calendar_example_05
31  *
32  * @ref calendar_example_06
33  *
34  * @ref spinner_example
35  *
36  * @ref slider_example
37  *
38  * @ref panes_example
39  *
40  * @ref clock_example
41  *
42  * @ref diskselector_example_01
43  *
44  * @ref diskselector_example_02
45  *
46  * @ref list_example_01
47  *
48  * @ref list_example_02
49  *
50  * @ref list_example_03
51  *
52  * @ref flipselector_example
53  *
54  * @ref fileselector_example
55  *
56  * @ref fileselector_button_example
57  *
58  * @ref fileselector_entry_example
59  *
60  * @ref index_example_01
61  *
62  * @ref index_example_02
63  *
64  * @ref gengrid_example
65  *
66  * @ref genlist_example_01
67  *
68  * @ref genlist_example_02
69  *
70  * @ref progressbar_example
71  *
72  * @ref slideshow_example
73  */
74
75 /**
76  * @page bg_01_example_page elm_bg - Plain color background.
77  * @dontinclude bg_example_01.c
78  *
79  * The full code for this example can be found at @ref bg_example_01_c,
80  * in the function @c test_bg_plain. It's part of the @c elementar_test
81  * suite, and thus has the code for the three examples referenced by this
82  * documentation.
83  *
84  * This first example just sets a default background with a plain color. The
85  * first part consists of creating an Elementary window. It's the common
86  * piece of code that you'll see everywhere in Elementary: @skip elm_main
87  * @until autodel_set
88  *
89  * Now we really create our background object, using the window object as
90  * its parent:
91  *
92  * @skipline bg_add
93  *
94  * Then we set the size hints of the background object so that it will use
95  * all space available for it, and then add it as a resize object to the
96  * window, making it visible in the end:
97  *
98  * @skip size_hint_weight_set
99  * @until resize_object_add
100  *
101  * See @ref evas_object_size_hint_weight_set and elm_win_resize_object_add()
102  * for more detailed info about these functions.
103  *
104  * The end of the example is quite simple, just setting the minimum and
105  * maximum size of the background, so the Elementary window knows that it
106  * has to have at least the minimum size. The background also won't scale to
107  * a size above its maximum. Then we resize the window and show it in the
108  * end:
109  *
110  * @skip set size hints
111  * @until }
112  *
113  * And here we finish our very simple background object usage example.
114  */
115
116 /**
117  * @page bg_02_example_page elm_bg - Image background.
118  * @dontinclude bg_example_02.c
119  *
120  * The full code for this example can be found at @ref bg_example_02_c,
121  * in the function @c test_bg_image. It's part of the @c elementar_test
122  * suite, and thus has the code for the three examples referenced by this
123  * documentation.
124  *
125  * This is the second example, and shows how to use the Elementary
126  * background object to set an image as background of your application.
127  *
128  * We start this example exactly in the same way as the previous one, even
129  * when creating the background object:
130  *
131  * @skip elm_main
132  * @until bg_add
133  *
134  * Now it's the different part.
135  *
136  * Our background will have an image, that will be displayed over the
137  * background color. Before loading the image, we set the load size of the
138  * image. The load size is a hint about the size that we want the image
139  * displayed in the screen. It's not the exact size that the image will have,
140  * but usually a bit bigger. The background object can still be scaled to a
141  * size bigger than the one set here. Setting the image load size to
142  * something smaller than its real size will reduce the memory used to keep
143  * the pixmap representation of the image, and the time to load it. Here we
144  * set the load size to 20x20 pixels, but the image is loaded with a size
145  * bigger than that (since it's just a hint):
146  *
147  * @skipline load_size_set
148  *
149  * And set our background image to be centered, instead of stretched or
150  * scaled, so the effect of the elm_bg_load_size_set() can be easily
151  * understood:
152  *
153  * @skipline option_set
154  *
155  * We need a filename to set, so we get one from the previous installed
156  * images in the @c PACKAGE_DATA_DIR, and write its full path to a buffer.
157  * Then we use this buffer to set the filename in the background object:
158  *
159  * @skip snprintf
160  * @until bg_file_set
161  *
162  * Notice that the third argument of the elm_bg_file_set() function is @c
163  * NULL, since we are setting an image to this background. This function
164  * also supports setting an edje group as background, in which case the @c
165  * group parameter wouldn't be @c NULL, but be the name of the group
166  * instead.
167  *
168  * Finally, we can set the size hints, add the background as a resize
169  * object, and resize the window, exactly the same thing we do in the @ref
170  * bg_01_example_page example:
171  *
172  * @skip size_hint
173  * @until }
174  *
175  * And this is the end of this example.
176  *
177  * This example will look like this:
178  *
179  * @image html screenshots/bg_01.png
180  * @image latex screenshots/bg_01.eps width=\textwidth
181  */
182
183 /**
184  * @page bg_03_example_page elm_bg - Background properties.
185  * @dontinclude bg_example_03.c
186  *
187  * The full code for this example can be found at @ref bg_example_03_c, in the
188  * function @c test_bg_options, with the callbacks @c _cb_overlay_changed, @c
189  * _cb_color_changed and @c _cb_radio_changed defined in the beginning of the
190  * file. It's part of the @c elementar_test suite, and thus has the code for
191  * the three examples referenced by this documentation.
192  *
193  * This example will show the properties available for the background object,
194  * and will use of some more widgets to set them.
195  *
196  * In order to do this, we will set some callbacks for these widgets. The
197  * first is for the radio buttons that will be used to choose the option
198  * passed as argument to elm_bg_option_set():
199  *
200  * @skip _cb_radio_changed
201  * @until }
202  *
203  * The next callback will be used when setting the overlay (using
204  * elm_bg_overlay_set()):
205  *
206  * @skip _cb_overlay_changed
207  * @until }
208  * @until }
209  *
210  * And the last one, used to set the color (with elm_bg_color_set()):
211  *
212  * @skip _cb_color_changed
213  * @until }
214  *
215  * We will get back to what these functions do soon. If you want to know more
216  * about how to set these callbacks and what these widgets are, look for:
217  * @li elm_radio_add()
218  * @li elm_check_add()
219  * @li elm_spinner_add()
220  *
221  * Now going to the main function, @c test_bg_options, we have the common
222  * code with the other examples:
223  *
224  * @skip bg-options
225  * @until autodel_set
226  *
227  * We add a plain background to this window, so it will have the default
228  * background color behind everything:
229  *
230  * @skip bg = elm_bg_add
231  * @until evas_object_show(bg)
232  *
233  * Then we add a vertical box (elm_box_add()) that will hold the background
234  * object that we are going to play with, as well as a horizontal box that
235  * will hold widgets:
236  *
237  * @skip elm_box_add
238  * @until evas_object_show
239  *
240  * Now we add the background object that is going to be of use for our
241  * example. It is an image background, as used in @ref bg_02_example_page ,
242  * so the code should be familiar:
243  *
244  * @skip elm_bg_add
245  * @until evas_object_show
246  *
247  * Notice the call to elm_box_pack_end(): it will pack the background object
248  * in the end of the Elementary box declared above. Just refer to that
249  * documentation for more info.
250  *
251  * Since this Elementary background is already an image background, we are
252  * going to play with its other properties. We will change its option
253  * (CENTER, SCALE, STRETCH, TILE), its color (RGB), and add an overlay to it.
254  * For all of these properties, we are going to add widgets that will
255  * configure them.
256  *
257  * First, lets add the horizontal box that will hold these widgets:
258  * @skip hbox
259  * @until align_set
260  *
261  * For now, just consider this @c hbox as a rectangle that will contain the
262  * widgets, and will distribute them horizontally inside its content. Then we
263  * add radio buttons that will allow us to choose the property to use with
264  * this background:
265  *
266  * @skip radio_add
267  * @until evas_object_show
268  *
269  * Again, I won't give details about the use of these widgets, just look for
270  * their documentation if necessary. It's enough to know for now that we are
271  * packing them in the @c hbox, setting a label for them, and the most
272  * important parts: setting its value to @c ELM_BG_OPTION_CENTER and its
273  * callback to @c _cb_radio_changed (the function defined in the beginning of
274  * this example). We do this for the next 3 radio buttons added after this
275  * one, each of them with a different value.
276  *
277  * Now taking a look at the code of the callback @c _cb_radio_changed again,
278  * it will call elm_bg_option_set() with the value set from the checked radio
279  * button, thus setting the option for this background. The background is
280  * passed as argument to the @p data parameter of this callback, and is
281  * referenced here as @c o_bg.
282  *
283  * Later we set the default value for this radio button:
284  *
285  * @skipline elm_radio_value_set
286  *
287  * Then we add a checkbox for the elm_bg_overlay_set() function:
288  *
289  * @skip check_add
290  * @until evas_object_show
291  *
292  * Now look at the code of the @c _cb_overlay_changed again. If the checkbox
293  * state is checked, an overlay will be added to the background. It's done by
294  * creating an Edje object, and setting it with elm_bg_overlay_set() to the
295  * background object. For information about what are and how to set Edje
296  * object, look at the Edje documentation.
297  *
298  * Finally we add a spinner object (elm_spinner_add()) to be used to select
299  * the color of our background. In its callback it's possible to see the call
300  * to elm_bg_color_set(), which will change the color of this background.
301  * This color is used by the background to fill areas where the image doesn't
302  * cover (in this case, where we have an image background). The spinner is
303  * also packed into the @c hbox :
304  *
305  * @skip elm_spinner_add
306  * @until evas_object_show
307  *
308  * Then we just have to pack the @c hbox inside the @c box, set some size
309  * hints, and show our window:
310  *
311  * @skip pack_end
312  * @until }
313  *
314  * Now to see this code in action, open elementary_test, and go to the "Bg
315  * Options" test. It should demonstrate what was implemented here.
316  */
317
318 /**
319  * @page actionslider_example_page Actionslider usage
320  * @dontinclude actionslider_example_01.c
321  *
322  * For this example we are going to assume knowledge of evas smart callbacks
323  * and some basic evas object functions. Elementary is not meant to be used
324  * without evas, if you're not yet familiar with evas it probably is worth
325  * checking that out.
326  *
327  * And now to the example, when using Elementary we start by including
328  * Elementary.h:
329  * @skipline #include
330  *
331  * Next we define some callbacks, they all share the same signature because
332  * they are all to be used with evas_object_smart_callback_add().
333  * The first one just prints the selected label(in two different ways):
334  * @until }
335  *
336  * This next callback is a little more interesting, it makes the selected
337  * label magnetic(except if it's the center label):
338  * @until }
339  *
340  * This callback enables or disables the magnetic propertty of the center
341  * label:
342  * @until }
343  *
344  * And finally a callback to stop the main loop when the window is closed:
345  * @until }
346  *
347  * To be able to create our actionsliders we need to do some setup, but this
348  * isn't really relevant here, so if you want to know about that go @ref
349  * Win "here".
350  *
351  * With all that boring stuff out of the way we can proceed to creating some
352  * actionsliders.@n
353  * All actionsliders are created the same way:
354  * @skipline actionslider_add
355  * Next we must choose where the indicator starts, and for this one we choose
356  * the right, and set the right as magnetic:
357  * @skipline indicator_pos_set
358  * @until magnet_pos_set
359  *
360  * We then set the labels for the left and right, passing NULL as an argument
361  * to any of the labels makes that position have no label.
362  * @until Stop
363  *
364  * Furthermore we mark both left and right as enabled positions, if we didn't
365  * do this all three positions would be enabled:
366  * @until RIGHT
367  *
368  * Having the the enabled positions we now add a smart callback to change
369  * which position is magnetic, so that only the last selected position is
370  * magnetic:
371  * @until NULL
372  *
373  * And finally we set our printing callback and show the actionslider:
374  * @until object_show
375  * @skip pack_end
376  *
377  * For our next actionslider we are going to do much as we did for the
378  * previous except we are going to have the center as the magnet(and not
379  * change it):
380  * @skipline actionslider_add
381  * @skipline indicator_pos_set
382  * @until object_show
383  *
384  * And another actionslider, in this one the indicator starts on the left.
385  * It has labels only in the center and right, and both bositions are
386  * magnetic. Because the left doesn't have a label and is not magnetic once
387  * the indicator leaves it can't return:
388  * @skipline actionslider_add
389  * @skipline indicator_pos_set
390  * @until object_show
391  * @note The greyed out area is a @ref Styles "style".
392  *
393  * And now an actionslider with a label in the indicator, and whose magnet
394  * properties change based on what was last selected:
395  * @skipline actionslider_add
396  * @skipline indicator_pos_set
397  * @until object_show
398  * @note The greyed out area is a @ref Styles "style".
399  *
400  * We are almost done, this next one is just an actionslider with all
401  * positions magnetized and having every possible label:
402  * @skipline actionslider_add
403  * @skipline indicator_pos_set
404  * @until object_show
405  *
406  * And for our last actionslider we have one that turns the magnetic property
407  * on and off:
408  * @skipline actionslider_add
409  * @skipline indicator_pos_set
410  * @until object_show
411  *
412  * The example will look like this:
413  *
414  * @image html screenshots/actionslider_01.png
415  * @image latex screenshots/actionslider_01.eps width=\textwidth
416  *
417  * See the full source code @ref actionslider_example_01 "here"
418  */
419
420 /**
421  * @page elm_animator_example_page_01 Animator usage
422  * @dontinclude animator_example_01.c
423  *
424  * For this example we will be using a bit of evas, you could animate a
425  * elementary widget in much the same way, but to keep things simple we use
426  * an evas_object_rectangle.
427  *
428  * As every other example we start with our include and a simple callback to
429  * exit the app when the window is closed:
430  * @skipline #include
431  * @until }
432  *
433  * This next callback is the one that actually creates our animation, it
434  * changes the size, position and color of a rectangle given to it in @a
435  * data:
436  * @until }
437  *
438  * Next we have a callback that prints a string, nothing special:
439  * @until }
440  *
441  * This next callback is a little more interesting, it has a state variable
442  * to know if the animation is currently paused or running, and it toogles
443  * the state of the animation accordingly:
444  * @until }
445  * @until }
446  * @until }
447  *
448  * Finally we have a callback to stop the animation:
449  * @until }
450  *
451  * As with every example we need to do a bit of setup before we can actually
452  * use an animation, but for the purposes of this example that's not relevant
453  * so let's just skip to the good stuff, creating an animator:
454  * @skipline animator_add
455  * @note Since elm_animator is not a widget we can give it a NULL parent.
456  *
457  * Now that we have an elm_animator we set it's duration to 1 second:
458  * @line duration_set
459  *
460  * We would also like our animation to be reversible, so:
461  * @line reverse_set
462  *
463  * We also set our animation to repeat as many times as possible, which will
464  * mean that _end_cb will only be called after UINT_MAX * 2 seconds(UINT_MAX
465  * for the animation running forward and UNIT_MAX for the animation running
466  * backwards):
467  * @line repeat_set
468  *
469  * To add some fun to our animation we will use the IN_OUT curve style:
470  * @line curve_style
471  *
472  * To actually animate anything we need an operation callback:
473  * @line operation_callback
474  *
475  * Even though we set our animation to repeat for a very long time we are
476  * going to set a end callback to it:
477  * @line completion_callback
478  * @note Notice that stoping the animation with the stop button will not make
479  * _end_cb be called.
480  *
481  * Now that we have fully set up our animator we can tell it to start
482  * animating:
483  * @line animate
484  *
485  * There's a bit more of code that doesn't really matter to use so we skip
486  * right down to our last interesting point:
487  * @skipline animator_del
488  * @note Because we created our animator with no parent we need to delete it
489  * ourselves.
490  *
491  * The example should look like this:
492  *
493  * @image html screenshots/animator_example_01.png
494  * @image latex screenshots/animator_example_01.eps width=\textwidth
495  * @n
496  * @image html screenshots/animator_example_02.png
497  * @image latex screenshots/animator_example_02.eps width=\textwidth
498  * @n
499  * @image html screenshots/animator_example_03.png
500  * @image latex screenshots/animator_example_03.eps width=\textwidth
501  *
502  * The full source code for this example can be found @ref
503  * animator_example_01_c "here"
504  */
505
506 /**
507  * @page transit_example_03_c elm_transit - Combined effects and options.
508  *
509  * This example shows how to apply the following transition effects:
510  * @li translation
511  * @li color
512  * @li rotation
513  * @li wipe
514  * @li zoom
515  * @li resizing
516  *
517  * It allows you to apply more than one effect at once, and also allows to
518  * set properties like event_enabled, auto_reverse, repeat_times and
519  * tween_mode.
520  *
521  * @include transit_example_03.c
522  */
523
524 /**
525  * @page transit_example_04_c elm_transit - Combined effects over two objects.
526  *
527  * This example shows how to apply the transition effects:
528  * @li flip
529  * @li resizable_flip
530  * @li fade
531  * @li blend
532  * over two objects. This kind of transition effect is used to make one
533  * object disappear and another one appear on its place.
534  *
535  * You can mix more than one effect of this type on the same objects, and the
536  * transition will apply both.
537  *
538  * @include transit_example_04.c
539  */
540
541 /**
542  * @page transit_example_01_explained elm_transit - Basic transit usage.
543  * @dontinclude transit_example_01.c
544  *
545  * The full code for this example can be found at @ref transit_example_01_c.
546  *
547  * This example shows the simplest way of creating a transition and applying
548  * it to an object. Similarly to every other elementary example, we create a
549  * window, set its title, size, autodel property, and setup a callback to
550  * exit the program when finished:
551  *
552  * @skip on_done
553  * @until evas_object_resize
554  *
555  * We also add a resizeable white background to use behind our animation:
556  *
557  * @skip bg_add
558  * @until evas_object_show
559  *
560  * And then we add a button that we will use to demonstrate the effects of
561  * our animation:
562  *
563  * @skip button_add
564  * @until evas_object_show(win)
565  *
566  * Notice that we are not adding the button with elm_win_resize_object_add()
567  * because we don't want the window to control the size of the button. We
568  * will use the transition to change the button size, so it could conflict
569  * with something else trying to control that size.
570  *
571  * Now, the simplest code possible to create the resize animation:
572  *
573  * @skip transit_add
574  * @until transit_go
575  *
576  * As you can see, this code is very easy to understand. First, we create the
577  * transition itself with elm_transit_add(). Then we add the button to this
578  * transition with elm_transit_object_add(), which means that the transition
579  * will operate over this button. The effect that we want now is changing the
580  * object size from 100x50 to 300x150, and can be achieved by adding the
581  * resize effect with elm_transit_effect_resizing_add().
582  *
583  * Finally, we set the transition time to 5 seconds and start the transition
584  * with elm_transit_go(). If we wanted more effects applied to this
585  * button, we could add them to the same transition. See the
586  * @ref transit_example_03_c to watch many transitions being applied to an
587  * object.
588  */
589
590 /**
591  * @page transit_example_02_explained elm_transit - Chained transitions.
592  * @dontinclude transit_example_02.c
593  *
594  * The full code for this example can be found at @ref transit_example_02_c.
595  *
596  * This example shows how to implement a chain of transitions. This chain is
597  * used to start a transition just after another transition ended. Similarly
598  * to every other elementary example, we create a window, set its title,
599  * size, autodel property, and setup a callback to exit the program when
600  * finished:
601  *
602  * @skip on_done
603  * @until evas_object_resize
604  *
605  * We also add a resizeable white background to use behind our animation:
606  *
607  * @skip bg_add
608  * @until evas_object_show
609  *
610  * This example will have a chain of 4 transitions, each of them applied to
611  * one button. Thus we create 4 different buttons:
612  *
613  * @skip button_add
614  * @until evas_object_show(bt4)
615  *
616  * Now we create a simple translation transition that will be started as soon
617  * as the program loads. It will be our first transition, and the other
618  * transitions will be started just after this transition ends:
619  *
620  * @skip transit_add
621  * @until transit_go
622  *
623  * The code displayed until now has nothing different from what you have
624  * already seen in @ref transit_example_01_explained, but now comes the new
625  * part: instead of creating a second transition that will start later using
626  * a timer, we create the it normally, and use
627  * elm_transit_chain_transit_add() instead of elm_transit_go. Since we are
628  * adding it in a chain after the first transition, it will start as soon as
629  * the first transition ends:
630  *
631  * @skip transit_add
632  * @until transit_chain_transit_add
633  *
634  * Finally we add the 2 other transitions to the chain, and run our program.
635  * It will make one transition start after the other finish, and there is the
636  * transition chain.
637  */
638
639 /**
640  * @page general_functions_example_page General (top-level) functions example
641  * @dontinclude general_funcs_example.c
642  *
643  * As told in their documentation blocks, the
644  * elm_app_compile_*_dir_set() family of functions have to be called
645  * before elm_app_info_set():
646  * @skip tell elm about
647  * @until elm_app_info_set
648  *
649  * We are here setting the fallback paths to the compiling time target
650  * paths, naturally. If you're building the example out of the
651  * project's build system, we're assuming they are the canonical ones.
652  *
653  * After the program starts, elm_app_info_set() will actually run and
654  * then you'll see an intrincasy: Elementary does the prefix lookup @b
655  * twice. This is so because of the quicklaunch infrastructure in
656  * Elementary (@ref Start), which will register a predefined prefix
657  * for possible users of the launch schema. We're not hooking into a
658  * quick launch, so this first call can't be avoided.
659  *
660  * If you ran this example from your "bindir" installation
661  * directiory, no output will emerge from these both attempts -- it
662  * will find the "magic" file there registered and set the prefixes
663  * silently. Otherwise, you could get something like:
664  @verbatim
665  WARNING: Could not determine its installed prefix for 'ELM'
666        so am falling back on the compiled in default:
667          usr
668        implied by the following:
669          bindir    = usr/lib
670          libdir    = usr/lib
671          datadir   = usr/share/elementary
672          localedir = usr/share/locale
673        Try setting the following environment variables:
674          ELM_PREFIX     - points to the base prefix of install
675        or the next 4 variables
676          ELM_BIN_DIR    - provide a specific binary directory
677          ELM_LIB_DIR    - provide a specific library directory
678          ELM_DATA_DIR   - provide a specific data directory
679          ELM_LOCALE_DIR - provide a specific locale directory
680  @endverbatim
681  * if you also didn't change those environment variables (remember
682  * they are also a valid way of communicating your prefix to the
683  * binary) - this is the scenario where it fallbacks to the paths set
684  * for compile time.
685  *
686  * Then, you can check the prefixes set on the standard output:
687  * @skip prefix was set to
688  * @until locale directory is
689  *
690  * In the fragment
691  * @skip by using this policy
692  * @until elm_win_autodel_set
693  * we demonstrate the use of Elementary policies. The policy defining
694  * under which circunstances our application should quit automatically
695  * is set to when its last window is closed (this one has just one
696  * window, though). This will save us from having to set a callback
697  * ourselves on the window, like done in @ref bg_example_01_c "this"
698  * example. Note that we need to tell the window to delete itself's
699  * object on a request to destroy the canvas coming, with
700  * elm_win_autodel_set().
701  *
702  * What follows is some boilerplate code, creating a frame with a @b
703  * button, our object of interest, and, below, widgets to change the
704  * button's behavior and exemplify the group of functions in question.
705  *
706  * @dontinclude general_funcs_example.c
707  * We enabled the focus highlight object for this window, so that you
708  * can keep track of the current focused object better:
709  * @skip elm_win_focus_highlight_enabled_set
710  * @until evas_object_show
711  * Use the tab key to navigate through the focus chain.
712  *
713  * @dontinclude general_funcs_example.c
714  * While creating the button, we exemplify how to use Elementary's
715  * finger size information to scale our UI:
716  * @skip fprintf(stdout, "Elementary
717  * @until evas_object_show
718  *
719  * @dontinclude general_funcs_example.c
720  * The first checkbox's callback is:
721  * @skip static void
722  * @until }
723  * When unsetting the checkbox, we disable the button, which will get a new
724  * decoration (greyed out) and stop receiving events. The focus chain
725  * will also ignore it.
726  *
727  * Following, there are 2 more buttons whose actions are focus/unfocus
728  * the top button, respectively:
729  * @skip focus callback
730  * @until }
731  * and
732  * @skip unfocus callback
733  * @until }
734  * Note the situations in which they won't take effect:
735  * - the button is not allowed to get focus or
736  * - the button is disabled
737  *
738  * The first restriction above you'll get by a second checkbox, whose
739  * callback is:
740  * @skip focus allow callback
741  * @until }
742  * Note that the button will still get mouse events, though.
743  *
744  * Next, there's a slider controlling the button's scale:
745  * @skip scaling callback
746  * @until }
747  *
748  * Experiment with it, so you understand the effect better. If you
749  * change its value, it will mess with the button's original size,
750  * naturally.
751  *
752  * The full code for this example can be found
753  * @ref general_functions_example_c "here".
754  */
755
756 /**
757  * @page theme_example_01 Theme - Using extensions
758  *
759  * @dontinclude theme_example_01.c
760  *
761  * Using extensions is extremely easy, discarding the part where you have to
762  * write the theme for them.
763  *
764  * In the following example we'll be creating two buttons, one to load or
765  * unload our extension theme and one to cycle around three possible styles,
766  * one of which we created.
767  *
768  * After including our one and only header we'll jump to the callback for
769  * the buttons. First one takes care of loading or unloading our extension
770  * file, relative to the default theme set (thus the @c NULL in the
771  * functions first parameter).
772  * @skipline Elementary.h
773  * @skip static void
774  * @until }
775  * @until }
776  * @until }
777  *
778  * The second button, as we said before, will just switch around different
779  * styles. In this case we have three of them. The first one is our custom
780  * style, named after something very unlikely to find in the default theme.
781  * The other two styles are the standard and one more, anchor, which exists
782  * in the default and is similar to the default, except the button vanishes
783  * when the mouse is not over it.
784  * @skip static void
785  * @until }
786  * @until }
787  *
788  * So what happens if the style switches to our custom one when the
789  * extension is loaded? Elementary falls back to the default for the
790  * widget.
791  *
792  * And the main function, simply enough, will create the window, set the
793  * buttons and their callbacks, and just to begin with our button styled
794  * we're also loading our extension at the beginning.
795  * @skip int
796  * @until ELM_MAIN
797  *
798  * In this case we wanted to easily remove extensions, but all adding an
799  * extension does is tell Elementary where else it should look for themes
800  * when it can't find them in the default theme. Another way to do this
801  * is to set the theme search order using elm_theme_set(), but this requires
802  * that the developer is careful not to override any user configuration.
803  * That can be helped by adding our theme to the end of whatver is already
804  * set, like in the following snippet.
805  * @code
806  * char buf[4096];
807  * snprintf(buf, sizeof(buf), "%s:./theme_example.edj", elme_theme_get(NULL);
808  * elm_theme_set(NULL, buf);
809  * @endcode
810  *
811  * If we were using overlays instead of extensions, the same thing applies,
812  * but the custom theme must be added to the front of the search path.
813  *
814  * In the end, we should be looking at something like this:
815  *
816  * @image html screenshots/theme_example_01.png
817  * @image latex screenshots/theme_example_01.eps width=\textwidth
818  *
819  * That's all. Boringly simple, and the full code in one piece can be found
820  * @ref theme_example_01.c "here".
821  *
822  * And the code for our extension is @ref theme_example.edc "here".
823  *
824  * @example theme_example_01.c
825  * @example theme_example.edc
826  */
827
828 /**
829  * @page theme_example_02 Theme - Using overlays
830  *
831  * @dontinclude theme_example_02.c
832  *
833  * Overlays are like extensions in that you tell Elementary that some other
834  * theme contains the styles you need for your program. The difference is that
835  * they will be look in first, so they can override the default style of any
836  * widget.
837  *
838  * There's not much to say about them that hasn't been said in our previous
839  * example about @ref theme_example_01 "extensions", so going quickly through
840  * the code we have a function to load or unload the theme, which will be
841  * called when we click any button.
842  * @skipline Elementary.h
843  * @skip static void
844  * @until }
845  *
846  * And the main function, creating the window and adding some buttons to it.
847  * We load our theme as an overlay and nothing else. Notice there's no style
848  * set for any button there, which means they should be using the default
849  * that we override.
850  * @skip int
851  * @until ELM_MAIN
852  *
853  * That's pretty much it. The full code is @ref theme_example_02.c "here" and
854  * the definition of the theme is the same as before, and can be found in
855  * @ref theme_example.edc "here".
856  *
857  * @example theme_example_02.c
858  */
859
860  /**
861   * @page button_example_01 Button - Complete example
862   *
863   * @dontinclude button_example_01.c
864   *
865   * A button is simple, you click on it and something happens. That said,
866   * we'll go through an example to show in detail the button API less
867   * commonly used.
868   *
869   * In the end, we'll be presented with something that looks like this:
870   *
871   * @image html screenshots/button_01.png
872   * @image latex screenshots/button_01.eps width=\textwidth
873   *
874   * The full code of the example is @ref button_example_01.c "here" and we
875   * will follow here with a rundown of it.
876   *
877   * @skip Elementary.h
878   * @until Elementary.h
879   * @skip struct
880   * @until App_Data
881   *
882   * We have several buttons to set different times for the autorepeat timeouts
883   * of the buttons that use it and a few more that we keep track of in our
884   * data struct. The mid button doesn't do much, just moves around according
885   * to what other buttons the user presses. Then four more buttons to move the
886   * central one, and we're also keeping track of the icon set in the middle
887   * button, since when this one moves, we change the icon, and when movement
888   * is finished (by releasing one of the four arrow buttons), we set back the
889   * normal icon.
890   * @skip static void
891   * @until }
892   *
893   * Keeping any of those four buttons pressed will trigger their autorepeat
894   * callback, where we move the button doing some size hint magic. To
895   * understand how that works better, refer to the @ref Box documentation.
896   * Also, the first time the function is called, we change the icon in the
897   * middle button, using elm_button_icon_unset() first to keep the reference
898   * to the previous one, so we don't need to recreate it when we are done
899   * moving it.
900   * @skip static void
901   * @until }
902   * @until size_hint_align_set
903   * @until }
904   *
905   * One more callback for the option buttons, that just sets the timeouts for
906   * the different autorepeat options.
907   *
908   * @skip static void
909   * @until }
910   * @until }
911   * @until }
912   *
913   * And the main function, which does some setting up of the buttons in boxes
914   * to make things work. Here we'll go through some snippets only.
915   *
916   * For the option buttons, it's just the button with its label and callback.
917   * @skip elm_button_add
918   * @until smart_callback_add
919   *
920   * For the ones that move the central button, we have no labels. There are
921   * icons instead, and the autorepeat option is toggled.
922   * @skip Gap: 1.0
923   * @skip elm_button_add
924   * @until data.cursors.up
925   *
926   * And just to show the mid button, which doesn't have anything special.
927   * @skip data.cursors.left
928   * @skip elm_button_add
929   * @until data.mid
930   *
931   * And we are done.
932   *
933   * @example button_example_01.c
934   */
935
936 /**
937  * @page bubble_01_example_page elm_bubble - Simple use.
938  * @dontinclude bubble_example_01.c
939  *
940  * This example shows a bubble with all fields set(label, info, content and
941  * icon) and the selected corner changing when the bubble is clicked. To be
942  * able use a bubble we need to do some setup and create a window, for this
943  * example we are going to ignore that part of the code since it isn't
944  * relevant to the bubble.
945  *
946  * To have the selected corner change in a clockwise motion we are going to
947  * use the following callback:
948  * @skip static
949  * @until }
950  * @until }
951  *
952  * Here we are creating an elm_label that is going to be used as the content
953  * for our bubble:
954  * @skipline elm_label
955  * @until show
956  * @note You could use any evas_object for this, we are using an elm_label
957  * for simplicity.
958  *
959  * Despite it's name the bubble's icon doesn't have to be an icon, it can be
960  * any evas_object. For this example we are going to make the icon a simple
961  * blue rectangle:
962  * @until show
963  *
964  * And finally we have the actual bubble creation and the setting of it's
965  * label, info and content:
966  * @until content
967  * @skipline show
968  * @note Because we didn't set a corner, the default("top_left") will be
969  * used.
970  *
971  * Now that we have our bubble all that is left is connecting the "clicked"
972  * signals to our callback:
973  * @line smart_callback
974  *
975  * This last bubble we created was very complete, so it's pertinent to show
976  * that most of that stuff is optional a bubble can be created with nothing
977  * but content:
978  * @until content
979  * @skipline show
980  *
981  * Our example will look like this:
982  *
983  * @image html screenshots/bubble_example_01.png
984  * @image latex screenshots/bubble_example_01.eps width=\textwidth
985  *
986  * See the full source code @ref bubble_example_01.c here.
987  * @example bubble_example_01.c
988  */
989
990 /**
991  * @page box_example_01 Box - Basic API
992  *
993  * @dontinclude button_example_01.c
994  *
995  * As a special guest tonight, we have the @ref button_example_01 "simple
996  * button example". There are plenty of boxes in it, and to make the cursor
997  * buttons that moved a central one around when pressed, we had to use a
998  * variety of values for their hints.
999  *
1000  * To start, let's take a look at the handling of the central button when
1001  * we were moving it around. To achieve this effect without falling back to
1002  * a complete manual positioning of the @c Evas_Object in our canvas, we just
1003  * put it in a box and played with its alignment within it, as seen in the
1004  * following snippet of the callback for the pressed buttons.
1005  * @skip evas_object_size_hint_align_get
1006  * @until evas_object_size_hint_align_set
1007  *
1008  * Not much to it. We get the current alignment of the object and change it
1009  * by just a little, depending on which button was pressed, then set it
1010  * again, making sure we stay within the 0.0-1.0 range so the button moves
1011  * inside the space it has, instead of disappearing under the other objects.
1012  *
1013  * But as useful as an example as that may have been, the usual case with boxes
1014  * is to set everything at the moment they are created, like we did for
1015  * everything else in our main function.
1016  *
1017  * The entire layout of our program is made with boxes. We have one set as the
1018  * resize object for the window, which means it will always be resized with
1019  * the window. The weight hints set to @c EVAS_HINT_EXPAND will tell the
1020  * window that the box can grow past it's minimum size, which allows resizing
1021  * of it.
1022  * @skip elm_main
1023  * @skip elm_box_add
1024  * @until evas_object_show
1025  *
1026  * Two more boxes, set to horizontal, hold the buttons to change the autorepeat
1027  * configuration used by the buttons. We create each to take over all the
1028  * available space horizontally, but we don't want them to grow vertically,
1029  * so we keep that axis of the weight with 0.0. Then it gets packed in the
1030  * main box.
1031  * @skip box2
1032  * @until evas_object_show
1033  *
1034  * The buttons in each of those boxes have nothing special, they are just packed
1035  * in with their default values and the box will use their minimum size, as set
1036  * by Elementary itself based on the label, icon, finger size and theme.
1037  *
1038  * But the buttons used to move the central one have a special disposition.
1039  * The top one first, is placed right into the main box like our other smaller
1040  * boxes. Set to expand horizontally and not vertically, and in this case we
1041  * also tell it to fill that space, so it gets resized to take the entire
1042  * width of the window.
1043  * @skip Gap: 1.0
1044  * @skip elm_button_add
1045  * @until evas_object_show
1046  *
1047  * The bottom one will be the same, but for the other two we need to use a
1048  * second box set to take as much space as we have, so we can place our side
1049  * buttons in place and have the big empty space where the central button will
1050  * move.
1051  * @skip elm_box_add
1052  * @until evas_object_show
1053  *
1054  * Then the buttons will have their hints inverted to the other top and bottom
1055  * ones, to expand and fill vertically and keep their minimum size horizontally.
1056  * @skip elm_button_add
1057  * @until evas_object_show
1058  *
1059  * The central button takes every thing else. It will ask to be expanded in
1060  * both directions, but without filling its cell. Changing its alignment by
1061  * pressing the buttons will make it move around.
1062  * @skip elm_button_add
1063  * @until evas_object_show
1064  *
1065  * To end, the rightmost button is packed in the smaller box after the central
1066  * one, and back to the main box we have the bottom button at the end.
1067  */
1068
1069 /**
1070  * @page box_example_02 Box - Layout transitions
1071  *
1072  * @dontinclude box_example_02.c
1073  *
1074  * Setting a customized layout for a box is simple once you have the layout
1075  * function, which is just like the layout function for @c Evas_Box. The new
1076  * and fancier thing we can do with Elementary is animate the transition from
1077  * one layout to the next. We'll see now how to do that through a simple
1078  * example, while also taking a look at some of the API that was left
1079  * untouched in our @ref box_example_01 "previous example".
1080  *
1081  * @image html screenshots/box_example_02.png
1082  * @image latex screenshots/box_example_02.eps width=\textwidth
1083  *
1084  * @skipline Elementary.h
1085  *
1086  * Our application data consists of a list of layout functions, given by
1087  * @c transitions. We'll be animating through them throughout the entire run.
1088  * The box with the stuff to move around and the last layout that was set to
1089  * make things easier in the code.
1090  * @skip typedef
1091  * @until Transitions_Data
1092  *
1093  * The box starts with three buttons, clicking on any of them will take it
1094  * out of the box without deleting the object. There are also two more buttons
1095  * outside, one to add an object to the box and the other to clear it.
1096  * This is all to show how you can interact with the items in the box, add
1097  * things and even remove them, while the transitions occur.
1098  *
1099  * One of the callback we'll be using creates a new button, asks the box for
1100  * the list of its children and if it's not empty, we add the new object after
1101  * the first one, otherwise just place at the end as it will not make any
1102  * difference.
1103  * @skip static void
1104  * @until }
1105  * @until }
1106  *
1107  * The clear button is even simpler. Everything in the box will be deleted,
1108  * leaving it empty and ready to fill it up with more stuff.
1109  * @skip static void
1110  * @until }
1111  *
1112  * And a little function to remove buttons from the box without deleting them.
1113  * This one is set for the @c clicked callback of the original buttons,
1114  * unpacking them when clicked and placing it somewhere in the screen where
1115  * they will not disturb. Once we do this, the box no longer has any control
1116  * of it, so it will be left untouched until the program ends.
1117  * @skip static void
1118  * @until }
1119  *
1120  * If we wanted, we could just call @c evas_object_del() on the object to
1121  * destroy it. In this case, no unpack is really necessary, as the box would
1122  * be notified of a child being deleted and adjust its calculations accordingly.
1123  *
1124  * The core of the program is the following function. It takes whatever
1125  * function is first on our list of layouts and together with the
1126  * @c last_layout, it creates an ::Elm_Box_Transition to use with
1127  * elm_box_layout_transition(). In here, we tell it to start from whatever
1128  * layout we last set, end with the one that was at the top of the list and
1129  * when everything is finished, call us back so we can create another
1130  * transition. Finally, move the new layout to the end of the list so we
1131  * can continue running through them until the program ends.
1132  * @skip static void
1133  * @until }
1134  *
1135  * The main function doesn't have antyhing special. Creation of box, initial
1136  * buttons and some callback setting. The only part worth mentioning is the
1137  * initialization of our application data.
1138  * @skip tdata.box
1139  * @until evas_object_box_layout_stack
1140  *
1141  * We have a simple static variable, set the box, the first layout we are
1142  * using as last and create the list with the different functions to go
1143  * through.
1144  *
1145  * And in the end, we set the first layout and call the same function we went
1146  * through before to start the run of transitions.
1147  * @until _test_box_transition_change
1148  *
1149  * For the full code, follow @ref box_example_02.c "here".
1150  *
1151  * @example box_example_02.c
1152  */
1153
1154 /**
1155  * @page calendar_example_01 Calendar - Simple creation.
1156  * @dontinclude calendar_example_01.c
1157  *
1158  * As a first example, let's just display a calendar in our window,
1159  * explaining all steps required to do so.
1160  *
1161  * First you should declare objects we intend to use:
1162  * @skipline Evas_Object
1163  *
1164  * Then a window is created, a title is set and its set to be autodeleted.
1165  * More details can be found on windows examples:
1166  * @until elm_win_autodel
1167  *
1168  * Next a simple background is placed on our windows. More details on
1169  * @ref bg_01_example_page:
1170  * @until evas_object_show(bg)
1171  *
1172  * Now, the exciting part, let's add the calendar with elm_calendar_add(),
1173  * passing our window object as parent.
1174  * @until evas_object_show(cal);
1175  *
1176  * To conclude our example, we should show the window and run elm mainloop:
1177  * @until ELM_MAIN
1178  *
1179  * Our example will look like this:
1180  *
1181  * @image html screenshots/calendar_example_01.png
1182  * @image latex screenshots/calendar_example_01.eps width=\textwidth
1183  *
1184  * See the full source code @ref calendar_example_01.c here.
1185  * @example calendar_example_01.c
1186  */
1187
1188 /**
1189  * @page calendar_example_02 Calendar - Layout strings formatting.
1190  * @dontinclude calendar_example_02.c
1191  *
1192  * In this simple example, we'll explain how to format the label displaying
1193  * month and year, and also set weekday names.
1194  *
1195  * To format month and year label, we need to create a callback function
1196  * to create a string given the selected time, declared under a
1197  * <tt> struct tm </tt>.
1198  *
1199  * <tt> struct tm </tt>, declared on @c time.h, is a structure composed by
1200  * nine integers:
1201  * @li tm_sec   seconds [0,59]
1202  * @li tm_min   minutes [0,59]
1203  * @li tm_hour  hour [0,23]
1204  * @li tm_mday  day of month [1,31]
1205  * @li tm_mon   month of year [0,11]
1206  * @li tm_year  years since 1900
1207  * @li tm_wday  day of week [0,6] (Sunday = 0)
1208  * @li tm_yday  day of year [0,365]
1209  * @li tm_isdst daylight savings flag
1210  * @note glib version has 2 additional fields.
1211  *
1212  * For our function, only stuff that matters are tm_mon and tm_year.
1213  * But we don't need to access it directly, since there are nice functions
1214  * to format date and time, as @c strftime.
1215  * We will get abbreviated month (%b) and year (%y) (check strftime manpage
1216  * for more) in our example:
1217  * @skipline static char
1218  * @until }
1219  *
1220  * We need to alloc the string to be returned, and calendar widget will
1221  * free it when it's not needed, what is done by @c strdup.
1222  * So let's register our callback to calendar object:
1223  * @skipline elm_calendar_format_function_set
1224  *
1225  * To set weekday names, we should declare them as an array of strings:
1226  * @dontinclude calendar_example_02.c
1227  * @skipline weekdays
1228  * @until }
1229  *
1230  * And finally set them to calendar:
1231  * skipline weekdays_names_set
1232  *
1233  * Our example will look like this:
1234  *
1235  * @image html screenshots/calendar_example_02.png
1236  * @image latex screenshots/calendar_example_02.eps width=\textwidth
1237  *
1238  * See the full source code @ref calendar_example_02.c here.
1239  * @example calendar_example_02.c
1240  */
1241
1242 /**
1243  * @page calendar_example_03 Calendar - Years restrictions.
1244  * @dontinclude calendar_example_03.c
1245  *
1246  * This example explains how to set max and min year to be displayed
1247  * by a calendar object. This means that user won't be able to
1248  * see or select a date before and after selected years.
1249  * By default, limits are 1902 and maximun value will depends
1250  * on platform architecture (year 2037 for 32 bits); You can
1251  * read more about time functions on @c ctime manpage.
1252  *
1253  * Straigh to the point, to set it is enough to call
1254  * elm_calendar_min_max_year_set(). First value is minimun year, second
1255  * is maximum. If first value is negative, it won't apply limit for min
1256  * year, if the second one is negative, won't apply for max year.
1257  * Setting both to negative value will clear limits (default state):
1258  * @skipline elm_calendar_min_max_year_set
1259  *
1260  * Our example will look like this:
1261  *
1262  * @image html screenshots/calendar_example_03.png
1263  * @image latex screenshots/calendar_example_03.eps width=\textwidth
1264  *
1265  * See the full source code @ref calendar_example_03.c here.
1266  * @example calendar_example_03.c
1267  */
1268
1269 /**
1270  * @page calendar_example_04 Calendar - Days selection.
1271  * @dontinclude calendar_example_04.c
1272  *
1273  * It's possible to disable date selection and to select a date
1274  * from your program, and that's what we'll see on this example.
1275  *
1276  * If isn't required that users could select a day on calendar,
1277  * only interacting going through months, disabling days selection
1278  * could be a good idea to avoid confusion. For that:
1279  * @skipline elm_calendar_day_selection_enabled_set
1280  *
1281  * Also, regarding days selection, you could be interested to set a
1282  * date to be highlighted on calendar from your code, maybe when
1283  * a specific event happens, or after calendar creation. Let's select
1284  * two days from current day:
1285  * @dontinclude calendar_example_04.c
1286  * @skipline SECS_DAY
1287  * @skipline current_time
1288  * @until elm_calendar_selected_time_set
1289  *
1290  * Our example will look like this:
1291  *
1292  * @image html screenshots/calendar_example_04.png
1293  * @image latex screenshots/calendar_example_04.eps width=\textwidth
1294  *
1295  * See the full source code @ref calendar_example_04.c here.
1296  * @example calendar_example_04.c
1297  */
1298
1299 /**
1300  * @page calendar_example_05 Calendar - Signal callback and getters.
1301  * @dontinclude calendar_example_05.c
1302  *
1303  * Most of setters explained on previous examples have associated getters.
1304  * That's the subject of this example. We'll add a callback to display
1305  * all calendar information every time user interacts with the calendar.
1306  *
1307  * Let's check our callback function:
1308  * @skipline static void
1309  * @until double interval;
1310  *
1311  * To get selected day, we need to call elm_calendar_selected_time_get(),
1312  * but to assure nothing wrong happened, we must check for function return.
1313  * It'll return @c EINA_FALSE if fail. Otherwise we can use time set to
1314  * our structure @p stime.
1315  * @skipline elm_calendar_selected_time_get
1316  * @until return
1317  *
1318  * Next we'll get information from calendar and place on declared vars:
1319  * @skipline interval
1320  * @until elm_calendar_weekdays_names_get
1321  *
1322  * The only tricky part is that last line gets an array of strings
1323  * (char arrays), one for each weekday.
1324  *
1325  * Then we can simple print that to stdin:
1326  * @skipline printf
1327  * @until }
1328  *
1329  * <tt> struct tm </tt> is declared on @c time.h. You can check @c ctime
1330  * manpage to read about it.
1331  *
1332  * To register this callback, that will be called every time user selects
1333  * a day or goes to next or previous month, just add a callback for signal
1334  * @b changed.
1335  * @skipline evas_object_smart_callback_add
1336  *
1337  * Our example will look like this:
1338  *
1339  * @image html screenshots/calendar_example_05.png
1340  * @image latex screenshots/calendar_example_05.eps width=\textwidth
1341  *
1342  * See the full source code @ref calendar_example_05.c here.
1343  * @example calendar_example_05.c
1344  */
1345
1346 /**
1347  * @page calendar_example_06 Calendar - Calendar marks.
1348  * @dontinclude calendar_example_06.c
1349  *
1350  * On this example marks management will be explained. Functions
1351  * elm_calendar_mark_add(), elm_calendar_mark_del() and
1352  * elm_calendar_marks_clear() will be covered.
1353  *
1354  * To add a mark, will be required to choose three things:
1355  * @li mark style
1356  * @li mark date, or start date if it will be repeated
1357  * @li mark periodicity
1358  *
1359  * Style defines the kind of mark will be displayed over marked day,
1360  * on caledar. Default theme supports @b holiday and @b checked.
1361  * If more is required, is possible to set a new theme to calendar
1362  * widget using elm_object_style_set(), and use
1363  * the signal that will be used by such marks.
1364  *
1365  * Date is a <tt> struct tm </tt>, as defined by @c time.h. More can
1366  * be read on @c ctime manpage.
1367  * If a date relative from current is required, this struct can be set
1368  * as:
1369  * @skipline current_time
1370  * @until localtime_r
1371  *
1372  * Or if it's an absolute date, you can just declare the struct like:
1373  * @dontinclude calendar_example_06.c
1374  * @skipline sunday
1375  * @until christmas.tm_mon
1376  *
1377  * Periodicity is how frequently the mark will be displayed over the
1378  * calendar.  Can be a unique mark (that don't repeat), or it can repeat
1379  * daily, weekly, monthly or annually. It's enumerated by
1380  * @c Elm_Calendar_Mark_Repeat.
1381  *
1382  * So let's add some marks to our calendar. We will add christmas holiday,
1383  * set Sundays as holidays, and check current day and day after that.
1384  * @dontinclude calendar_example_06.c
1385  * @skipline sunday
1386  * @until christmas.tm_mon
1387  * @skipline current_time
1388  * @until ELM_CALENDAR_WEEKLY
1389  *
1390  * We kept the return of first mark add, because we don't really won't it
1391  * to be checked, so let's remove it:
1392  * @skipline elm_calendar_mark_del
1393  *
1394  * After all marks are added and removed, is required to draw them:
1395  * @skipline elm_calendar_marks_draw
1396  *
1397  * Finally, to clear all marks, let's set a callback for our button:
1398  * @skipline elm_button_add
1399  * @until evas_object_show(bt);
1400  *
1401  * This callback will receive our calendar object, and should clear it:
1402  * @dontinclude calendar_example_06.c
1403  * @skipline static
1404  * @until }
1405  * @note Remember to draw marks after clear the calendar.
1406  *
1407  * Our example will look like this:
1408  *
1409  * @image html screenshots/calendar_example_06.png
1410  * @image latex screenshots/calendar_example_06.eps width=\textwidth
1411  *
1412  * See the full source code @ref calendar_example_06.c here.
1413  * @example calendar_example_06.c
1414  */
1415
1416 /**
1417  * @page spinner_example Spinner widget example
1418  *
1419  * This code places seven Elementary spinner widgets on a window, each of
1420  * them exemplifying a part of the widget's API.
1421  *
1422  * The first of them is the default spinner:
1423  * @dontinclude spinner_example.c
1424  * @skipline elm_spinner_add
1425  * @until evas_object_show
1426  * As you see, the defaults for a spinner are:
1427  * @li no wrap
1428  * @li min value set to 0
1429  * @li max value set to 100
1430  * @li step value set to 1
1431  * @li label format set to "%0.f"
1432  *
1433  * If another format is required, see the second spinner. It will put a text
1434  * before and after the value, and also format value to display two decimals:
1435  * @skipline format_set
1436  *
1437  * The third one will use a customized step, define new minimum and maximum
1438  * values and enable wrap, so when value reaches minimum it jumps to maximum,
1439  * or jumps to minimum after maximum value is reached. Format is set to display
1440  * a decimal:
1441  * @skipline elm_spinner_add
1442  * @until evas_object_show
1443  *
1444  * The fourth uses @c vertical style, so instead of left and right arrows,
1445  * top and bottom are displayed. Also the change interval is reduced, so
1446  * user can change value faster.
1447  * @skipline style
1448  * @skipline interval
1449  *
1450  * In the fifth the user won't be allowed to set value directly, i.e., will
1451  * be obligate change value only using arrows:
1452  * @skipline editable
1453  *
1454  * The sixth widget will receive a lot of special values, so
1455  * instead of reading numeric values, user will see labels for each one.
1456  * Also direct edition is disabled, otherwise users would see the numeric
1457  * value on edition mode. User will be able to select a month in this widget:
1458  * @skipline elm_spinner_add
1459  * @until evas_object_show
1460  *
1461  * Finally the last widget will exemplify how to listen to widget's signals,
1462  * <tt> changed </tt> and <tt> delay,changed </tt>. First we need to
1463  * implement callback functions that will simply print spinner's value:
1464  * @dontinclude spinner_example.c
1465  * @skip static
1466  * @skip }
1467  * @skipline static
1468  * @until }
1469  * @until }
1470  *
1471  * The first callback function should be called everytime value changes,
1472  * the second one only after user stops to increment or decrement. Try
1473  * to keep arrows pressed and check the difference.
1474  * @skip smart_callback
1475  * @skipline smart_callback
1476  * @skipline smart_callback
1477  *
1478  * See the full @ref spinner_example.c "example", whose window should
1479  * look like this picture:
1480  *
1481  * @image html screenshots/spinner_example.png
1482  * @image latex screenshots/spinner_example.eps width=\textwidth
1483  *
1484  * See the full @ref spinner_example_c "source code" for this example.
1485  *
1486  * @example spinner_example.c
1487  */
1488
1489 /**
1490  * @page slider_example Slider widget example
1491  *
1492  * This code places seven Elementary slider widgets on a window, each of
1493  * them exemplifying a part of the widget's API.
1494  *
1495  * The first of them is the default slider:
1496  * @dontinclude slider_example.c
1497  * @skipline elm_slider_add
1498  * @until evas_object_show
1499  *
1500  * As you see, the defaults for a slider are:
1501  * @li horizontal
1502  * @li no label
1503  * @li no values (on indicator or unit labels)
1504  *
1505  * Actually it's pretty useless this way. So let's learn how to improve it.
1506  *
1507  * If some decoration is required, a label can be set, and icon before and
1508  * after the bar as well. On the second slider will add a @c home icon
1509  * and a @c folder icon at @c end.
1510  * @skipline text_set
1511  * @until end_set
1512  *
1513  * If the bar size need to be changed, it can be done with span set function,
1514  * that doesn't accounts other widget's parts size. Also the bar can starts
1515  * with a not default value (0.0), as we done on third slider:
1516  * @skipline value_set
1517  * @skipline span_size_set
1518  *
1519  * So far, users won't be able to see the slider value. If it's required,
1520  * it can be displayed in two different areas, units label or above
1521  * the indicator.
1522  *
1523  * Let's place a units label on our widget, and also let's set minimum and
1524  * maximum value (uses 0.0 and 1.0 by default):
1525  * @skipline unit_format_set
1526  * @skipline min_max_set
1527  *
1528  * If above the indicator is the place to display the value, just set it.
1529  * Also, is possible to invert a bar, as you can see:
1530  * @skipline indicator_format_set
1531  * @skipline inverted_set
1532  *
1533  * But if you require to use a function a bit more customized to show the value,
1534  * is possible to registry a callback function that will be called
1535  * to display unit or indicator label. Only the value will be passed to this
1536  * function, that should return a string.
1537  * In this case, a function to free this string will be required.
1538  *
1539  * Let's exemplify with indicator label on our sixth slider:
1540  * @dontinclude slider_example.c
1541  * @skip static
1542  * @skip }
1543  * @skip static
1544  * @skip }
1545  * @skip static
1546  * @skip }
1547  * @skipline static
1548  * @until }
1549  * @until }
1550  *
1551  * Setting callback functions:
1552  * @skipline indicator_format_function_set
1553  * @skipline _indicator_free
1554  *
1555  * Also, a slider can be displayed vertically:
1556  * @dontinclude slider_example.c
1557  * @skipline elm_slider_horizontal_set
1558  *
1559  * Finally the last widget will exemplify how to listen to widget's signals,
1560  * <tt> changed </tt> and <tt> delay,changed </tt>. First we need to
1561  * implement callback functions that will simply print slider's value:
1562  * @dontinclude slider_example.c
1563  * @skip static
1564  * @skip }
1565  * @skipline static
1566  * @until }
1567  * @until }
1568  *
1569  * The first callback function should be called everytime value changes,
1570  * the second one only after user stops to increment or decrement. Try
1571  * to keep arrows pressed and check the difference.
1572  * @skip smart_callback
1573  * @skipline smart_callback
1574  * @skipline smart_callback
1575  *
1576  * See the full @ref slider_example.c "example", whose window should
1577  * look like this picture:
1578  *
1579  * @image html screenshots/slider_example.png
1580  * @image latex screenshots/slider_example.eps width=\textwidth
1581  *
1582  * See the full @ref slider_example_c "source code" for this example.
1583  *
1584  * @example slider_example.c
1585  */
1586
1587 /**
1588  * @page panes_example Panes widget example
1589  *
1590  * This code places two Elementary panes widgets on a window, one of them
1591  * displayed vertically and the other horizontally, to exemplify
1592  * a part of the widget's API. Also, all the signals emitted by this
1593  * widget will be covered.
1594  *
1595  * Let's start adding a panes to our window:
1596  * @dontinclude panes_example.c
1597  * @skipline elm_panes_add
1598  * @until evas_object_show
1599  *
1600  * Now we will set a content (a simple button) to the left side of our
1601  * panes widget:
1602  * @skipline elm_button_add
1603  * @until content_left_set
1604  *
1605  * The content of the right side will be something a bit more elaborated, we'll
1606  * place another panes, displayed vertically (it's displayed horizontally
1607  * by default):
1608  * @skipline elm_panes_add
1609  * @until content_right_set
1610  *
1611  * When populating a panes displayed vertically, remember that left content
1612  * will be placed at top, and right content will place at bottom. Next
1613  * we will add two buttons to exemplify that:
1614  * @skipline elm_button_add
1615  * @until content_right_set
1616  *
1617  * Panes widgets emits 4 different signals, depending on users interaction
1618  * with the draggable bar. We'll add a callback function for each of them.
1619  *
1620  * <tt> "clicked" signal </tt>:
1621  *
1622  * Callback function that just print "Clicked" to stdin:
1623  * @dontinclude panes_example.c
1624  * @skip static void
1625  * @skip }
1626  * @skip static void
1627  * @skip }
1628  * @skip static void
1629  * @skip }
1630  * @skipline static void
1631  * @until }
1632  *
1633  * Also, add callback function to the panes:
1634  * @skipline "clicked"
1635  *
1636  * <tt> "press" signal </tt>:
1637  *
1638  * Callback function that just print "Pressed" to stdin:
1639  * @dontinclude panes_example.c
1640  * @skip static void
1641  * @skip }
1642  * @skipline static void
1643  * @until }
1644  *
1645  * Also, add callback function to the panes:
1646  * @skipline "press"
1647  *
1648  * Now, let's try to make our callback functions a bit more useful:
1649  *
1650  * <tt> "unpress" signal </tt>:
1651  *
1652  * Suppose we want to know the size proportion of left content after
1653  * user drags the bar. We need to listen for @c unpress signal, and
1654  * get this size from our panes widget. It's done on the following
1655  * function:
1656  * @dontinclude panes_example.c
1657  * @skip static void
1658  * @skip }
1659  * @skip static void
1660  * @skip }
1661  * @skipline static void
1662  * @until }
1663  *
1664  * Adding the callback function to the panes:
1665  * @skipline "unpress"
1666
1667  * <tt> "clicked,double" signal </tt>:
1668  *
1669  * Now, a interesting feature that could be addded to panes widget.
1670  * Hide a content when user double click the draggable bar. It's done
1671  * using a variable to store size and content left size getter and setter
1672  * on the following function:
1673  * @dontinclude panes_example.c
1674  * @skipline static double
1675  * @skip static void
1676  * @skip }
1677  * @skip static void
1678  * @skip }
1679  * @skip static void
1680  * @skip }
1681  * @skipline static void
1682  * @until }
1683  * @until }
1684  * @until }
1685  *
1686  * Adding the callback function to the panes:
1687  * @skipline "clicked,double"
1688  * @until panes);
1689  *
1690  * See the full @ref panes_example.c "example", whose window should
1691  * look like this picture:
1692  *
1693  * @image html screenshots/panes_example.png
1694  * @image latex screenshots/panes_example.eps width=\textwidth
1695  *
1696  * @example panes_example.c
1697  */
1698
1699 /**
1700  * @page clock_example Clock widget example
1701  *
1702  * This code places five Elementary clock widgets on a window, each of
1703  * them exemplifying a part of the widget's API.
1704  *
1705  * The first of them is the pristine clock:
1706  * @dontinclude clock_example.c
1707  * @skip pristine
1708  * @until evas_object_show
1709  * As you see, the defaults for a clock are:
1710  * - military time
1711  * - no seconds shown
1712  *
1713  * For am/pm time, see the second clock:
1714  * @dontinclude clock_example.c
1715  * @skip am/pm
1716  * @until evas_object_show
1717  *
1718  * The third one will show the seconds digits, which will flip in
1719  * synchrony with system time. Note, besides, that the time itself is
1720  * @b different from the system's -- it was customly set with
1721  * elm_clock_time_set():
1722  * @dontinclude clock_example.c
1723  * @skip with seconds
1724  * @until evas_object_show
1725  *
1726  * In both fourth and fifth ones, we turn on the <b>edition
1727  * mode</b>. See how you can change each of the sheets on it, and be
1728  * sure to try holding the mouse pressed over one of the sheet
1729  * arrows. The forth one also starts with a custom time set:
1730  * @dontinclude clock_example.c
1731  * @skip in edition
1732  * @until evas_object_show
1733  *
1734  * The fifth, besides editable, has only the time @b units editable,
1735  * for hours, minutes and seconds. This exemplifies
1736  * elm_clock_digit_edit_set():
1737  * @dontinclude clock_example.c
1738  * @skip but only
1739  * @until evas_object_show
1740  *
1741  * See the full @ref clock_example.c "example", whose window should
1742  * look like this picture:
1743  *
1744  * @image html screenshots/clock_example.png
1745  * @image latex screenshots/clock_example.eps width=\textwidth
1746  *
1747  * See the full @ref clock_example_c "source code" for this example.
1748  *
1749  * @example clock_example.c
1750  */
1751
1752 /**
1753  * @page diskselector_example_01 Diskselector widget example
1754  *
1755  * This code places 4 Elementary diskselector widgets on a window, each of
1756  * them exemplifying a part of the widget's API.
1757  *
1758  * All of them will have weekdays as items, since we won't focus
1759  * on items management on this example. For an example about this subject,
1760  * check @ref diskselector_example_02.
1761  *
1762  * The first of them is a default diskselector.
1763  * @dontinclude diskselector_example_01.c
1764  * @skipline lbl
1765  * @until }
1766  * @skipline elm_diskselector_add
1767  * @until evas_object_show
1768  *
1769  * We are just adding the diskselector, so as you can see, defaults for it are:
1770  * @li Only 3 items visible each time.
1771  * @li Only 3 characters are displayed for labels on side positions.
1772  * @li The first added item remains centeres, i.e., it's the selected item.
1773  *
1774  * To add items, we are just appending it on a loop, using function
1775  * elm_diskselector_item_append(), that will be better exaplained on
1776  * items management example.
1777  *
1778  * For a circular diskselector, check the second widget. A circular
1779  * diskselector will display first item after last, and last previous to
1780  * the first one. So, as you can see, @b Sa will appears on left side
1781  * of selected @b Sunday. This property is set with
1782  * elm_diskselector_round_set().
1783  *
1784  * Also, we decide to display only 2 character for side labels, instead of 3.
1785  * For this we call elm_diskselector_side_label_length_set(). As result,
1786  * we'll see @b Mo displayed instead of @b Mon, when @b Monday is on a
1787  * side position.
1788  *
1789  * @skipline elm_diskselector_add
1790  * @until evas_object_show
1791  *
1792  * But so far, we are only displaying 3 items at once. If more are wanted,
1793  * is enough to call elm_diskselector_display_item_num_set(), as you can
1794  * see here:
1795  * @skipline elm_diskselector_add
1796  * @until evas_object_show
1797  *
1798  * @note You can't set less than 3 items to be displayed.
1799  *
1800  * Finally, if a bounce effect is required, or you would like to see
1801  * scrollbars, it is possible. But, for default theme, diskselector
1802  * scrollbars will be invisible anyway.
1803  * @skipline elm_diskselector_add
1804  * @until evas_object_show
1805  *
1806  * See the full @ref diskselector_example_01.c "diskselector_example_01.c"
1807  * code, whose window should look like this picture:
1808  *
1809  * @image html screenshots/diskselector_example_01.png
1810  * @image latex screenshots/diskselector_example_01.eps width=\textwidth
1811  *
1812  * @example diskselector_example_01.c
1813  */
1814
1815 /**
1816  * @page diskselector_example_02 Diskselector - Items management
1817  *
1818  * This code places a Elementary diskselector widgets on a window,
1819  * along with some buttons trigerring actions on it (though its API).
1820  * It covers most of Elm_Diskselector_Item functions.
1821  *
1822  * On our @c main function, we are adding a default diskselector with
1823  * 3 items. We are only setting their labels (second parameter of function
1824  * elm_diskselector_item_append):
1825  * @dontinclude diskselector_example_02.c
1826  * @skipline elm_diskselector_add
1827  * @until Item 2
1828  *
1829  * Next we are adding lots of buttons, each one for a callback function
1830  * that will realize a task covering part of diskselector items API.
1831  * Lets check the first one:
1832  * @skipline elm_button_add
1833  * @until evas_object_show
1834  *
1835  * We are labeling the button with a task description with
1836  * elm_object_text_set() and setting a callback
1837  * function evas_object_smart_callback_add().
1838  * Each callback function will have the signature:
1839  * <tt> static void _task_cb(void *data, Evas_Object *obj,
1840  * void *event_info)</tt> with the function name varying for each task.
1841  *
1842  * Now let's cover all of them.
1843  *
1844  * <b> Appending an item: </b>
1845  * @dontinclude diskselector_example_02.c
1846  * @skipline _add_cb
1847  * @until }
1848  *
1849  * All items are included on diskselector after last one. You @b can't
1850  * preprend items.
1851  *
1852  * The first parameter of elm_diskselector_item_append() is the diskselector
1853  * object, that we are receiving as data on our callback function.
1854  * The second one is a label, the string that will be placed in the center
1855  * of our item. As we don't wan't icons or callback functions, we can
1856  * send NULL as third, fourth and fifth parameters.
1857  *
1858  * <b> Appending an item with icon: </b>
1859  * @dontinclude diskselector_example_02.c
1860  * @skipline _add_ic_cb
1861  * @until }
1862  *
1863  * If an icon is required, you can pass it as third paramenter on our
1864  * elm_diskselector_item_append() function. It will be place on the
1865  * left side of item's label, that will be shifted to right a bit.
1866  *
1867  * For more details about how to create icons, look for elm_icon examples.
1868  *
1869  * <b> Appending an item with callback function for selected: </b>
1870  * @dontinclude diskselector_example_02.c
1871  * @skipline _sel_cb
1872  * @until }
1873  * @until }
1874  *
1875  * To set a callback function that will be called every time an item is
1876  * selected, i.e., everytime the diskselector stops with this item in
1877  * center position, just pass the function as fourth paramenter.
1878  *
1879  * <b> Appending an item with callback function for selected with data: </b>
1880  * @dontinclude diskselector_example_02.c
1881  * @skipline _sel_data_cb
1882  * @until }
1883  * @until }
1884  * @until }
1885  * @until }
1886  *
1887  * If the callback function request an extra data, it can be attached to our
1888  * item passing a pointer for data as fifth parameter.
1889  * Our function _sel_data_cb will receive it as <tt> void *data </tt>.
1890  *
1891  * If you want to free this data, or handle that the way you need when the
1892  * item is deleted, set a callback function for that, with
1893  * elm_diskselector_item_del_cb_set().
1894  *
1895  * As you can see we check if @c it is not @c NULL after appending it.
1896  * If an error happens, we won't try to set a function for it.
1897  *
1898  * <b> Deleting an item: </b>
1899  * @dontinclude diskselector_example_02.c
1900  * @skip _del_cb
1901  * @skipline _del_cb
1902  * @until }
1903  *
1904  * To delete an item we simple need to call elm_diskselector_item_del() with
1905  * a pointer for such item.
1906  *
1907  * If you need, you can get selected item with
1908  * elm_diskselector_selected_item_get(), that will return a pointer for it.
1909  *
1910  * <b> Unselecting an item: </b>
1911  * @dontinclude diskselector_example_02.c
1912  * @skipline _unselect_cb
1913  * @until }
1914  *
1915  * To select an item, you should call elm_diskselector_item_selected_set()
1916  * passing @c EINA_TRUE, and to unselect it, @c EINA_FALSE.
1917  *
1918  * If you unselect the selected item, diskselector will automatically select
1919  * the first item.
1920  *
1921  * <b> Printing all items: </b>
1922  * @dontinclude diskselector_example_02.c
1923  * @skipline _print_cb
1924  * @until }
1925  *
1926  * <b> Clearing the diskselector: </b>
1927  * @dontinclude diskselector_example_02.c
1928  * @skipline _clear_cb
1929  * @until }
1930  *
1931  * <b> Selecting the first item: </b>
1932  * @dontinclude diskselector_example_02.c
1933  * @skipline _select_first_cb
1934  * @until }
1935  *
1936  * <b> Selecting the last item: </b>
1937  * @dontinclude diskselector_example_02.c
1938  * @skipline _select_last_cb
1939  * @until }
1940  *
1941  * <b> Selecting the next item: </b>
1942  * @dontinclude diskselector_example_02.c
1943  * @skipline _select_next_cb
1944  * @until }
1945  *
1946  * <b> Selecting the previous item: </b>
1947  * @dontinclude diskselector_example_02.c
1948  * @skipline _select_prev_cb
1949  * @until }
1950  *
1951  * See the full @ref diskselector_example_02.c "diskselector_example_02.c"
1952  * code, whose window should look like this picture:
1953  *
1954  * @image html screenshots/diskselector_example_02.png
1955  * @image latex screenshots/diskselector_example_02.eps width=\textwidth
1956  *
1957  * @example diskselector_example_02.c
1958  */
1959
1960 /**
1961  * @page list_example_01 List widget example
1962  *
1963  * This code places a single Elementary list widgets on a window, just
1964  * to exemplify the more simple and common use case: a list will be created
1965  * and populated with a few items.
1966  *
1967  * To keep it simple, we won't show how to customize the list, for this check
1968  * @ref list_example_02. Also, we won't focus
1969  * on items management on this example. For an example about this subject,
1970  * check @ref list_example_03.
1971  *
1972  * To add a list widget.
1973  * @dontinclude list_example_01.c
1974  * @skipline elm_list_add
1975  *
1976  * We are just adding the list, so as you can see, defaults for it are:
1977  * @li Items are displayed vertically.
1978  * @li Only one item can be selected.
1979  * @li The list doesn't bouce.
1980  *
1981  * To add items, we are just appending it on a loop, using function
1982  * elm_list_item_append(), that will be better exaplained on
1983  * items management example.
1984  * @dontinclude list_example_01.c
1985  * @skipline lbl[]
1986  * @until };
1987  * @skipline for
1988  * @skipline elm_list_item_append
1989  *
1990  * After we just want to show the list. But first we need to start the widget.
1991  * It was done this way to improve widget's performance. So, always remember
1992  * that:
1993  * @warning Call elm_list_go before showing the object
1994  * @skipline elm_list_go
1995  * @skipline show
1996  *
1997  * See the full @ref list_example_01.c "list_example_01.c"
1998  * code, whose window should look like this picture:
1999  *
2000  * @image html screenshots/list_example_01.png
2001  * @image latex screenshots/list_example_01.eps width=\textwidth
2002  *
2003  * @example list_example_01.c
2004  */
2005
2006 /**
2007  * @page list_example_02 List widget example
2008  *
2009  * This code places a single Elementary list widgets on a window,
2010  * exemplifying a part of the widget's API.
2011  *
2012  * First, we will just create a simple list, as done on @ref list_example_01 :
2013  * @dontinclude list_example_02.c
2014  * @skipline lbl
2015  * @until }
2016  * @skipline elm_list_add
2017  * @until elm_list_item_append
2018  *
2019  * Now, let's customize this list a bit. First we will display items
2020  * horizontally:
2021  * @skipline horizontal_set
2022  *
2023  * Then we will choose another list mode. There are four of them, and
2024  * the default #Elm_List_Mode is #ELM_LIST_SCROLL. Let's set compress mode:
2025  * @skipline mode_set
2026  *
2027  * To enable multiple items selection, we need to enable it, since only one
2028  * selected item is allowed by default:
2029  * @skipline elm_list_multi_select_set
2030  *
2031  * We are not adding items with callback functions here,
2032  * since we'll explain it better on  @ref list_example_03. But if the callback
2033  * need to be called everytime user clicks an item, even if already selected,
2034  * it's required to enable this behavior:
2035  * @skipline elm_list_always_select_mode_set
2036  *
2037  * Finally, if a bounce effect is required, or you would like to see
2038  * scrollbars, it is possible. But, for default theme, list
2039  * scrollbars will be invisible anyway.
2040  * @skipline bounce_set
2041  * @until SCROLLER_POLICY_ON
2042  *
2043  * See the full @ref list_example_02.c "list_example_02.c"
2044  * code, whose window should look like this picture:
2045  *
2046  * @image html screenshots/list_example_02.png
2047  * @image latex screenshots/list_example_02.eps width=\textwidth
2048  *
2049  * @example list_example_02.c
2050  */
2051
2052 /**
2053  * @page list_example_03 List - Items management
2054  *
2055  * This code places a Elementary list widgets on a window,
2056  * along with some buttons trigerring actions on it (though its API).
2057  * It covers most of Elm_List_Item functions.
2058  *
2059  * On our @c main function, we are adding a default list with
2060  * 3 items. We are only setting their labels (second parameter of function
2061  * elm_list_item_append):
2062  * @dontinclude list_example_03.c
2063  * @skipline elm_list_add
2064  * @until Item 2
2065  *
2066  * Next we are adding lots of buttons, each one for a callback function
2067  * that will realize a task covering part of list items API.
2068  * Lets check the first one:
2069  * @skipline elm_button_add
2070  * @until evas_object_show
2071  *
2072  * We are labeling the button with a task description with
2073  * elm_object_text_set() and setting a callback
2074  * function evas_object_smart_callback_add().
2075  * Each callback function will have the signature:
2076  * <tt> static void _task_cb(void *data, Evas_Object *obj,
2077  * void *event_info)</tt> with the function name varying for each task.
2078  *
2079  * Now let's cover all of them.
2080  *
2081  * <b> Prepending an item: </b>
2082  * @dontinclude list_example_03.c
2083  * @skipline _prepend_cb
2084  * @until }
2085  *
2086  * The item will be placed on the begining of the list,
2087  * i.e. it will be the first one.
2088  *
2089  * The first parameter of elm_list_item_prepend() is the list
2090  * object, that we are receiving as data on our callback function.
2091  * The second one is a label, the string that will be placed in the center
2092  * of our item. As we don't wan't icons or callback functions, we can
2093  * send NULL as third, fourth, fifth and sixth parameters.
2094  *
2095  * <b> Appending an item: </b>
2096  * @dontinclude list_example_03.c
2097  * @skipline _add_cb
2098  * @until }
2099  *
2100  * Items included with append will be inserted inserted after the last one.
2101  *
2102  * <b> Appending an item with icon: </b>
2103  * @dontinclude list_example_03.c
2104  * @skipline _add_ic_cb
2105  * @until }
2106  *
2107  * If an icon is required, you can pass it as third paramenter on our
2108  * elm_list_item_append() function. It will be place on the
2109  * left side of item's label. If an icon is wanted on the right side,
2110  * it should be passed as fourth parameter.
2111  *
2112  * For more details about how to create icons, look for elm_icon examples
2113  * @ref tutorial_icon.
2114  *
2115  * <b> Appending an item with callback function for selected: </b>
2116  * @dontinclude list_example_03.c
2117  * @skipline _sel_cb
2118  * @until }
2119  * @until }
2120  *
2121  * To set a callback function that will be called every time an item is
2122  * selected, i.e., everytime the list stops with this item in
2123  * center position, just pass the function as fifth paramenter.
2124  *
2125  * <b> Appending an item with callback function for selected with data: </b>
2126  * @dontinclude list_example_03.c
2127  * @skipline _sel_data_cb
2128  * @until }
2129  * @until }
2130  * @until }
2131  * @until }
2132  *
2133  * If the callback function request an extra data, it can be attached to our
2134  * item passing a pointer for data as sixth parameter.
2135  * Our function _sel_data_cb will receive it as <tt> void *data </tt>.
2136  *
2137  * If you want to free this data, or handle that the way you need when the
2138  * item is deleted, set a callback function for that, with
2139  * elm_list_item_del_cb_set().
2140  *
2141  * As you can see we check if @c it is not @c NULL after appending it.
2142  * If an error happens, we won't try to set a function for it.
2143  *
2144  * <b> Deleting an item: </b>
2145  * @dontinclude list_example_03.c
2146  * @skipline _del_cb(
2147  * @until }
2148  *
2149  * To delete an item we simple need to call elm_list_item_del() with
2150  * a pointer for such item.
2151  *
2152  * If you need, you can get selected item with
2153  * elm_list_selected_item_get(), that will return a pointer for it.
2154  *
2155  * <b> Unselecting an item: </b>
2156  * @dontinclude list_example_03.c
2157  * @skipline _unselect_cb
2158  * @until }
2159  *
2160  * To select an item, you should call elm_list_item_selected_set()
2161  * passing @c EINA_TRUE, and to unselect it, @c EINA_FALSE.
2162  *
2163  * <b> Printing all items: </b>
2164  * @dontinclude list_example_03.c
2165  * @skipline _print_cb
2166  * @until }
2167  *
2168  * <b> Clearing the list: </b>
2169  * @dontinclude list_example_03.c
2170  * @skipline _clear_cb
2171  * @until }
2172  *
2173  * <b> Selecting the next item: </b>
2174  * @dontinclude list_example_03.c
2175  * @skipline _select_next_cb
2176  * @until }
2177  *
2178  * <b> Inserting after an item: </b>
2179  * @dontinclude list_example_03.c
2180  * @skipline _insert_after_cb
2181  * @until }
2182  *
2183  * <b> Selecting the previous item: </b>
2184  * @dontinclude list_example_03.c
2185  * @skipline _select_prev_cb
2186  * @until }
2187  *
2188  * <b> Inserting before an item: </b>
2189  * @dontinclude list_example_03.c
2190  * @skipline _insert_before_cb
2191  * @until }
2192  *
2193  * If a separator is required, just set an item as such:
2194  * @dontinclude list_example_03.c
2195  * @skipline _set_separator_cb
2196  * @until }
2197  *
2198  * Also an item can be disabled, and the user won't be allowed to (un)select it:
2199  * @dontinclude list_example_03.c
2200  * @skipline _disable_cb
2201  * @until }
2202  *
2203  * See the full @ref list_example_03.c "list_example_03.c"
2204  * code, whose window should look like this picture:
2205  *
2206  * @image html screenshots/list_example_03.png
2207  * @image latex screenshots/list_example_03.eps width=\textwidth
2208  *
2209  * @example list_example_03.c
2210  */
2211
2212 /**
2213  * @page flipselector_example Flip selector widget example
2214  *
2215  * This code places an Elementary flip selector widget on a window,
2216  * along with two buttons trigerring actions on it (though its API).
2217  *
2218  * The selector is being populated with the following items:
2219  * @dontinclude flipselector_example.c
2220  * @skip lbl[]
2221  * @until ;
2222  *
2223  * Next, we create it, populating it with those items and registering
2224  * two (smart) callbacks on it:
2225  * @dontinclude flipselector_example.c
2226  * @skip fp = elm_flipselector_add
2227  * @until object_show
2228  *
2229  * Those two callbacks will take place whenever one of those smart
2230  * events occur, and they will just print something to @c stdout:
2231  * @dontinclude flipselector_example.c
2232  * @skip underflow callback
2233  * @until static void
2234  * Flip the sheets on the widget while looking at the items list, in
2235  * the source code, and you'll get the idea of those events.
2236  *
2237  * The two buttons below the flip selector will take the actions
2238  * described in their labels:
2239  * @dontinclude flipselector_example.c
2240  * @skip bt = elm_button_add
2241  * @until callback_add(win
2242  *
2243  * @dontinclude flipselector_example.c
2244  * @skip unselect the item
2245  * @until underflow
2246  *
2247  * Click on them to exercise those flip selector API calls. To
2248  * interact with the other parts of this API, there's a command line
2249  * interface, whose help string can be asked for with the 'h' key:
2250  * @dontinclude flipselector_example.c
2251  * @skip commands
2252  * @until ;
2253  *
2254  * The 'n' and 'p' keys will exemplify elm_flipselector_flip_next()
2255  * and elm_flipselector_flip_prev(), respectively. 'f' and 'l' account
2256  * for elm_flipselector_first_item_get() and
2257  * elm_flipselector_last_item_get(), respectively. Finally, 's' will
2258  * issue elm_flipselector_selected_item_get() on our example flip
2259  * selector widget.
2260  *
2261  * See the full @ref flipselector_example.c "example", whose window should
2262  * look like this picture:
2263  *
2264  * @image html screenshots/flipselector_example.png
2265  * @image latex screenshots/flipselector_example.eps width=\textwidth
2266  *
2267  * See the full @ref flipselector_example_c "source code" for this example.
2268  *
2269  * @example flipselector_example.c
2270  */
2271
2272 /**
2273  * @page fileselector_example File selector widget example
2274  *
2275  * This code places two Elementary file selector widgets on a window.
2276  * The one on the left is layouting file system items in a @b list,
2277  * while the the other is layouting them in a @b grid.
2278  *
2279  * The one having the majority of hooks of interest is on the left,
2280  * which we create as follows:
2281  * @dontinclude fileselector_example.c
2282  * @skip first file selector
2283  * @until object_show
2284  *
2285  * Note that we enable custom edition of file/directory selection, via
2286  * the text entry it has on its bottom, via
2287  * elm_fileselector_is_save_set(). It starts with the list view, which
2288  * is the default, and we make it not expandable in place
2289  * (elm_fileselector_expandable_set()), so that it replaces its view's
2290  * contents with the current directory's entries each time one
2291  * navigates to a different folder.  For both of file selectors we are
2292  * starting to list the contents found in the @c "/tmp" directory
2293  * (elm_fileselector_path_set()).
2294  *
2295  * Note the code setting it to "grid mode" and observe the differences
2296  * in the file selector's views, in the example. We also hide the
2297  * second file selector's Ok/Cancel buttons -- since it's there just
2298  * to show the grid view (and navigation) -- via
2299  * elm_fileselector_buttons_ok_cancel_set().
2300  *
2301  * The @c "done" event, which triggers the callback below
2302  * @dontinclude fileselector_example.c
2303  * @skip 'done' cb
2304  * @until }
2305  * will be called at the time one clicks the "Ok"/"Cancel" buttons of
2306  * the file selector (on the left). Note that it will print the path
2307  * to the current selection, if any.
2308  *
2309  * The @c "selected" event, which triggers the callback below
2310  * @dontinclude fileselector_example.c
2311  * @skip bt = 'selected' cb
2312  * @until }
2313  * takes place when one selects a file (if the file selector is @b not
2314  * under folders-only mode) or when one selects a folder (when in
2315  * folders-only mode). Experiment it by selecting different file
2316  * system entries.
2317  *
2318  * What comes next is the code creating the three check boxes and two
2319  * buttons below the file selector in the right. They will exercise a
2320  * bunch of functions on the file selector's API, for the instance on
2321  * the left. Experiment with them, specially the buttons, to get the
2322  * difference between elm_fileselector_path_get() and
2323  * elm_fileselector_selected_get().
2324  *
2325  * Finally, there's the code adding the second file selector, on the
2326  * right:
2327  * @dontinclude fileselector_example.c
2328  * @skip second file selector
2329  * @until object_show
2330  *
2331  * Pay attention to the code setting it to "grid mode" and observe the
2332  * differences in the file selector's views, in the example. We also
2333  * hide the second file selector's Ok/Cancel buttons -- since it's
2334  * there just to show the grid view (and navigation) -- via
2335  * elm_fileselector_buttons_ok_cancel_set().
2336  *
2337  * See the full @ref fileselector_example.c "example", whose window
2338  * should look like this picture:
2339  *
2340  * @image html screenshots/fileselector_example.png
2341  * @image latex screenshots/fileselector_example.eps width=\textwidth
2342  *
2343  * See the full @ref fileselector_example_c "source code" for this example.
2344  *
2345  * @example fileselector_example.c
2346  */
2347
2348 /**
2349  * @page fileselector_button_example File selector button widget example
2350  *
2351  * This code places an Elementary file selector button widget on a
2352  * window, along with some other checkboxes and a text entry. Those
2353  * are there just as knobs on the file selector button's state and to
2354  * display information from it.
2355  *
2356  * Here's how we instantiate it:
2357  * @dontinclude fileselector_button_example.c
2358  * @skip ic = elm_icon_add
2359  * @until evas_object_show
2360  *
2361  * Note that we set on it both icon and label decorations. It's set to
2362  * list the contents of the @c "/tmp" directory, too, with
2363  * elm_fileselector_button_path_set(). What follows are checkboxes to
2364  * exercise some of its API funtions:
2365  * @dontinclude fileselector_button_example.c
2366  * @skip ck = elm_check_add
2367  * @until evas_object_show(en)
2368  *
2369  * The checkboxes will toggle whether the file selector button's
2370  * internal file selector:
2371  * - must have an editable text entry for file names (thus, be in
2372  *   "save dialog mode")
2373  * - is to be raised as an "inner window" (note it's the default
2374  *   behavior) or as a dedicated window
2375  * - is to populate its view with folders only
2376  * - is to expand its folders, in its view, <b>in place</b>, and not
2377  *   repainting it entirely just with the contents of a sole
2378  *   directory.
2379  *
2380  * The entry labeled @c "Last selection" will exercise the @c
2381  * "file,chosen" smart event coming from the file selector button:
2382  * @dontinclude fileselector_button_example.c
2383  * @skip hook on the
2384  * @until toggle inwin
2385  *
2386  * Whenever you dismiss or acknowledges the file selector, after it's
2387  * raised, the @c event_info string will contain the last selection on
2388  * it (if any was made).
2389  *
2390  * This is how the example, just after called, should look like:
2391  *
2392  * @image html screenshots/fileselector_button_example_00.png
2393  * @image latex screenshots/fileselector_button_example_00.eps width=\textwidth
2394  *
2395  * Click on the file selector button to raise its internal file
2396  * selector, which will be contained on an <b>"inner window"</b>:
2397  *
2398  * @image html screenshots/fileselector_button_example_01.png
2399  * @image latex screenshots/fileselector_button_example_01.eps width=\textwidth
2400  *
2401  * Toggle the "inwin mode" switch off and, if you click on the file
2402  * selector button again, you'll get @b two windows, the original one
2403  * (note the last selection there!)
2404  *
2405  * @image html screenshots/fileselector_button_example_02.png
2406  * @image latex screenshots/fileselector_button_example_02.eps width=\textwidth
2407  *
2408  * and the file selector's new one
2409  *
2410  * @image html screenshots/fileselector_button_example_03.png
2411  * @image latex screenshots/fileselector_button_example_03.eps width=\textwidth
2412  *
2413  * Play with the checkboxes to get the behavior changes on the file
2414  * selector button. The respective API calls on the widget coming from
2415  * those knobs where shown in the code already.
2416  *
2417  * See the full @ref fileselector_button_example_c "source code" for
2418  * this example.
2419  *
2420  * @example fileselector_button_example.c
2421  */
2422
2423 /**
2424  * @page fileselector_entry_example File selector entry widget example
2425  *
2426  * This code places an Elementary file selector entry widget on a
2427  * window, along with some other checkboxes. Those are there just as
2428  * knobs on the file selector entry's state.
2429  *
2430  * Here's how we instantiate it:
2431  * @dontinclude fileselector_entry_example.c
2432  * @skip ic = elm_icon_add
2433  * @until evas_object_show
2434  *
2435  * Note that we set on it's button both icon and label
2436  * decorations. It's set to exhibit the path of (and list the contents
2437  * of, when internal file selector is launched) the @c "/tmp"
2438  * directory, also, with elm_fileselector_entry_path_set(). What
2439  * follows are checkboxes to exercise some of its API funtions:
2440  * @dontinclude fileselector_entry_example.c
2441  * @skip ck = elm_check_add
2442  * @until callback_add(fs_entry
2443  *
2444  * The checkboxes will toggle whether the file selector entry's
2445  * internal file selector:
2446  * - must have an editable text entry for file names (thus, be in
2447  *   "save dialog mode")
2448  * - is to be raised as an "inner window" (note it's the default
2449  *   behavior) or as a dedicated window
2450  * - is to populate its view with folders only
2451  * - is to expand its folders, in its view, <b>in place</b>, and not
2452  *   repainting it entirely just with the contents of a sole
2453  *   directory.
2454  *
2455  * Observe how the entry's text will match the string coming from the
2456  * @c "file,chosen" smart event:
2457  * @dontinclude fileselector_entry_example.c
2458  * @skip hook on the
2459  * @until }
2460  * Whenever you dismiss or acknowledges the file selector, after it's
2461  * raised, the @c event_info string will contain the last selection on
2462  * it (if any was made).
2463  *
2464  * Try, also, to type in a valid system path and, then, open the file
2465  * selector's window: it will start the file browsing there, for you.
2466  *
2467  * This is how the example, just after called, should look like:
2468  *
2469  * @image html screenshots/fileselector_entry_example_00.png
2470  * @image latex screenshots/fileselector_entry_example_00.eps width=\textwidth
2471  *
2472  * Click on the file selector entry to raise its internal file
2473  * selector, which will be contained on an <b>"inner window"</b>:
2474  *
2475  * @image html screenshots/fileselector_entry_example_01.png
2476  * @image latex screenshots/fileselector_entry_example_01.eps width=\textwidth
2477  *
2478  * Toggle the "inwin mode" switch off and, if you click on the file
2479  * selector entry again, you'll get @b two windows, the original one
2480  * (note the last selection there!)
2481  *
2482  * @image html screenshots/fileselector_entry_example_02.png
2483  * @image latex screenshots/fileselector_entry_example_02.eps width=\textwidth
2484  *
2485  * and the file selector's new one
2486  *
2487  * @image html screenshots/fileselector_entry_example_03.png
2488  * @image latex screenshots/fileselector_entry_example_03.eps width=\textwidth
2489  *
2490  * Play with the checkboxes to get the behavior changes on the file
2491  * selector entry. The respective API calls on the widget coming from
2492  * those knobs where shown in the code already.
2493  *
2494  * See the full @ref fileselector_entry_example_c "source code" for
2495  * this example.
2496  *
2497  * @example fileselector_entry_example.c
2498  */
2499
2500 /**
2501  * @page layout_example_01 Layout - Content, Table and Box
2502  *
2503  * This example shows how one can use the @ref Layout widget to create a
2504  * customized distribution of widgets on the screen, controled by an Edje theme.
2505  * The full source code for this example can be found at @ref
2506  * layout_example_01_c.
2507  *
2508  * Our custom layout is defined by a file, @ref layout_example_edc, which is an
2509  * Edje theme file. Look for the Edje documentation to understand it. For now,
2510  * it's enough to know that we describe some specific parts on this layout
2511  * theme:
2512  * @li a title text field;
2513  * @li a box container;
2514  * @li a table container;
2515  * @li and a content container.
2516  *
2517  * Going straight to the code, the following snippet instantiates the layout
2518  * widget:
2519  *
2520  * @dontinclude layout_example_01.c
2521  * @skip elm_layout_add
2522  * @until evas_object_show(layout)
2523  *
2524  * As any other widget, we set some properties for the size calculation. But
2525  * notice on this piece of code the call to the function elm_layout_file_set().
2526  * Here is where the theme file is loaded, and particularly the specific group
2527  * from this theme file. Also notice that the theme file here is referenced as
2528  * an .edj, which is a .edc theme file compiled to its binary form. Again, look
2529  * for the Edje documentation for more information about theme files.
2530  *
2531  * Next, we fetch from our theme a data string referenced by the key "title".
2532  * This data was defined in the theme, and can be used as parameters which the
2533  * program get from the specific theme that it is using. In this case, we store
2534  * the title of this window and program in the theme, as a "data" entry, just
2535  * for demonstration purposes:
2536  *
2537  * @until }
2538  *
2539  * This call elm_layout_data_get() is used to fetch the string based on the key,
2540  * and elm_object_text_part_set() will set the part defined in the theme as
2541  * "example/title" to contain this string. This key "example/title" has nothing
2542  * special. It's just an arbitrary convention that we are using in this example.
2543  * Every string in this example referencing a part of this theme will be of the
2544  * form "example/<something>".
2545  *
2546  * Now let's start using our layout to distribute things on the window space.
2547  * Since the layout was added as a resize object to the elementary window, it
2548  * will always occupy the entire space available for this window.
2549  *
2550  * The theme already has a title, and it also defines a table element which is
2551  * positioned approximately between 50% and 70% of the height of this window,
2552  * and has 100% of the width. We create some widgets (two icons, a clock and a
2553  * button) and pack them inside the table, in a distribution similar to a HTML
2554  * table:
2555  *
2556  * @until evas_object_show(bt)
2557  *
2558  * Notice that we just set size hints for every object, and call the function
2559  * elm_layout_table_pack(), which does all the work. It will place the elements
2560  * in the specified row/column, with row and column span if required, and then
2561  * the object's size and position will be controled by the layout widget. It
2562  * will also respect size hints, alignments and weight properties set to these
2563  * widgets. The resulting distribution on the screen depends on the table
2564  * properties (described in the theme), the size hints set on each widget, and
2565  * on the cells of the table that are being used.
2566  *
2567  * For instance, we add the two icons and the clock on the first, second and
2568  * third cells of the first row, and add the button the second row, making it
2569  * span for 3 columns (thus having the size of the entire table width). This
2570  * will result in a table that has 2 rows and 3 columns.
2571  *
2572  * Now let's add some widgets to the box area of our layout. This box is around
2573  * 20% and 50% of the vertical size of the layout, and 100% of its width. The
2574  * theme defines that it will use an "horizontal flow" distribution to its
2575  * elements. Unlike the table, a box will distribute elements without knowing
2576  * about rows and columns, and the distribution function selected will take care
2577  * of putting them in row, column, both, or any other available layout. This is
2578  * also described in the Edje documentation.
2579  *
2580  * This box area is similar to the @ref Box widget of elementary, with the
2581  * difference that its position and properties are controled by the theme of the
2582  * layout. It also contains more than one API to add items to it, since the
2583  * items position now is defined in terms of a list of items, not a matrix.
2584  * There's the first position (can have items added to it with
2585  * elm_layout_box_prepend()), the last position (elm_layout_box_append()), the
2586  * nth position (elm_layout_box_insert_at()) and the position right before an
2587  * element (elm_layout_box_insert_before()). We use insert_at and prepend
2588  * functions to add the first two buttons to this box, and insert_before on the
2589  * callback of each button. The callback code will be shown later, but it
2590  * basically adds a button just before the clicked button using the
2591  * elm_layout_box_insert_before() function. Here's the code for adding the first
2592  * 2 buttons:
2593  *
2594  * @until evas_object_show(item)
2595  * @until evas_object_show(item)
2596  *
2597  * Finally, we have an area in this layout theme, in the bottom part of it,
2598  * reserved for adding an specific widget. Differently from the 2 parts
2599  * described until now, this one can only receive one widget with the call
2600  * elm_layout_content_set(). If there was already an item on this specific part,
2601  * it will be deleted (one can use elm_layout_content_unset() in order to remove
2602  * it without deleting). An example of removing it without deleting, but
2603  * manually deleting this widget just after that, can be seen on the callback
2604  * for this button. Actually, the callback defined for this button will clean
2605  * the two other parts (deleting all of their elements) and then remove and
2606  * delete this button.
2607  *
2608  * @until _swallow_btn_cb
2609  *
2610  * Also notice that, for this last added button, we don't have to call
2611  * evas_object_show() on it. This is a particularity of the theme for layouts,
2612  * that will have total control over the properties like size, position,
2613  * visibility and clipping of a widget added with elm_layout_content_set().
2614  * Again, read the Edje documentation to understand this better.
2615  *
2616  * Now we just put the code for the different callbacks specified for each kind
2617  * of button and make simple comments about them:
2618  *
2619  * @dontinclude layout_example_01.c
2620  * @skip static void
2621  * @until evas_object_del(item)
2622  * @until }
2623  *
2624  * The first callback is used for the button in the table, and will just remove
2625  * itself from the table with elm_layout_table_unpack(), which remove items
2626  * without deleting them, and then calling evas_object_del() on itself.
2627  *
2628  * The second callback is for buttons added to the box. When clicked, these
2629  * buttons will create a new button, and add them to the same box, in the
2630  * position just before the clicked button.
2631  *
2632  * And the last callback is for the button added to the "content" area. It will
2633  * clear both the table and the box, passing @c EINA_TRUE to their respective @c
2634  * clear parameters, which will imply on the items of these containers being
2635  * deleted.
2636  *
2637  * A screenshot of this example can be seen on:
2638  *
2639  * @image html screenshots/layout_example_01.png
2640  * @image latex screenshots/layout_example_01.eps width=\textwidth
2641  *
2642  */
2643
2644 /**
2645  * @page layout_example_02 Layout - Predefined Layout
2646  *
2647  * This example shows how one can use the @ref Layout with a predefined theme
2648  * layout to add a back and next button to a simple window. The full source code
2649  * for this example can be found at @ref layout_example_02_c.
2650  *
2651  * After setting up the window and background, we add the layout widget to the
2652  * window. But instead of using elm_layout_file_set() to load its theme from a
2653  * custom theme file, we can use elm_layout_theme_set() to load one of the
2654  * predefined layouts that come with elementary. Particularly on this example,
2655  * we load the them of class "layout", group "application" and style
2656  * "content-back-next" (since we want the back and next buttons).
2657  *
2658  * @dontinclude layout_example_02.c
2659  * @skip elm_layout_add
2660  * @until evas_object_show(layout)
2661  *
2662  * This default theme contains only a "content" area named
2663  * "elm.swallow.content", where we can add any widget (it can be even a
2664  * container widget, like a box, frame, list, or even another layout). Since we
2665  * just want to show the resulting layout, we add a simple icon to it:
2666  *
2667  * @until layout_content_set
2668  *
2669  * This default layout also provides some signals when the next and prev buttons
2670  * are clicked. We can register callbacks to them with the
2671  * elm_object_signal_callback_add() function:
2672  *
2673  * @until elm,action,next
2674  *
2675  * In the @ref layout_example_03 you can see how to send signals to the layout with
2676  * elm_object_signal_emit().
2677  *
2678  * Now our callback just changes the picture being displayed when one of the
2679  * buttons are clicked:
2680  *
2681  * @dontinclude layout_example_02.c
2682  * @skip images
2683  * @until standard_set
2684  * @until }
2685  *
2686  * It's possible to see that it gets the name of the image being shown from the
2687  * array of image names, going forward on this array when "next" is clicked and
2688  * backward when "back" is clicked.
2689  *
2690  * A screenshot of this example can be seen on:
2691  *
2692  * @image html screenshots/layout_example_02.png
2693  * @image latex screenshots/layout_example_02.eps width=\textwidth
2694  */
2695
2696 /**
2697  * @page layout_example_03 Layout - Signals and Size Changed
2698  *
2699  * This example shows how one can send and receive signals to/from the layout,
2700  * and what to do when the layout theme has its size changed. The full source
2701  * code for this example can be found at @ref layout_example_03_c.
2702  *
2703  * In this exmaple we will use another group from the same layout theme file
2704  * used in @ref layout_example_01. Its instanciation and loading happens in the
2705  * following lines:
2706  *
2707  * @dontinclude layout_example_03.c
2708  * @skip elm_layout_add
2709  * @until evas_object_show
2710  *
2711  * This time we register a callback to be called whenever we receive a signal
2712  * after the end of the animation that happens in this layout:
2713  *
2714  * @until signal_callback_add
2715  *
2716  * We also add a button that will send signals to the layout:
2717  *
2718  * @until callback_add
2719  *
2720  * The callback for this button will check what type of signal it should send,
2721  * and then emit it. The code for this callback follows:
2722  *
2723  * @dontinclude layout_exmaple_03.c
2724  * @skip static Eina_Bool
2725  * @until Enlarge
2726  * @until }
2727  * @until }
2728  *
2729  * As we said before, we are receiving a signal whenever the animation started
2730  * by the button click ends. This is the callback for that signal:
2731  *
2732  * @until }
2733  *
2734  * Notice from this callback that the elm_layout_sizing_eval() function must be
2735  * called if we want our widget to update its size after the layout theme having
2736  * changed its minimum size. This happens because the animation specified in the
2737  * theme increases the size of the content area to a value higher than the
2738  * widget size, thus requiring more space. But the elementary layout widget
2739  * has no way to know this, thus needing the elm_layout_sizing_eval() to
2740  * be called on the layout, informing that this size has changed.
2741  *
2742  * A screenshot of this example can be seen on:
2743  *
2744  * @image html screenshots/layout_example_03.png
2745  * @image latex screenshots/layout_example_03.eps width=\textwidth
2746  */
2747
2748 /**
2749  * @page tutorial_hover Hover example
2750  * @dontinclude hover_example_01.c
2751  *
2752  * On this example we are going to have a button that when clicked will show our
2753  * hover widget, this hover will have content set on it's left, top, right and
2754  * middle positions. In the middle position we are placing a button that when
2755  * clicked will hide the hover. We are also going to use a non-default theme
2756  * for our hover. We won't explain the functioning of button for that see @ref
2757  * Button.
2758  *
2759  * We start our example with a couple of callbacks that show and hide the data
2760  * they're given(which we'll see later on is the hover widget):
2761  * @skip static
2762  * @until }
2763  * @until }
2764  *
2765  * In our main function we'll do some initialization and then create 3
2766  * rectangles, one red, one green and one blue to use in our hover. We'll also
2767  * create the 2 buttons that will show and hide the hover:
2768  * @until show(bt2)
2769  *
2770  * With all of that squared away we can now get to the heart of the matter,
2771  * creating our hover widget, which is easy as pie:
2772  * @until hover
2773  *
2774  * Having created our hover we now need to set the parent and target. Which if
2775  * you recall from the function documentations are going to tell the hover which
2776  * area it should cover and where it should be centered:
2777  * @until bt
2778  *
2779  * Now we set the theme for our hover. We're using the popout theme which gives
2780  * our contents a white background and causes their appearance to be animated:
2781  * @until popout
2782  *
2783  * And finally we set the content for our positions:
2784  * @until bt2
2785  *
2786  * So far so good? Great 'cause that's all there is too it, what is left now is
2787  * just connecting our buttons to the callbacks we defined at the beginning of
2788  * the example and run the main loop:
2789  * @until ELM_MAIN
2790  *
2791  * Our example will initially look like this:
2792  *
2793  * @image html screenshots/hover_example_01.png
2794  * @image latex screenshots/hover_example_01.eps width=\textwidth
2795  *
2796  * And after you click the "Show hover" button it will look like this:
2797  *
2798  * @image html screenshots/hover_example_01_a.png
2799  * @image latex screenshots/hover_example_01_a.eps width=\textwidth
2800  *
2801  * @example hover_example_01.c
2802  */
2803
2804 /**
2805   * @page tutorial_flip Flip example
2806   * @dontinclude flip_example_01.c
2807   *
2808   * This example will show a flip with two rectangles on it(one blue, one
2809   * green). Our example will allow the user to choose the animation the flip
2810   * uses and to interact with it. To allow the user to choose the interaction
2811   * mode we use radio buttons, we will however not explain them, if you would
2812   * like to know more about radio buttons see @ref radio.
2813   *
2814   * We start our example with the usual setup and then create the 2 rectangles
2815   * we will use in our flip:
2816   * @until show(rect2)
2817   *
2818   * The next thing to do is to create our flip and set it's front and back
2819   * content:
2820   * @until show
2821   *
2822   * The next thing we do is set the interaction mode(which the user can later
2823   * change) to the page animation:
2824   * @until PAGE
2825   *
2826   * Setting a interaction mode however is not sufficient, we also need to
2827   * choose which directions we allow interaction from, for this example we
2828   * will use all of them:
2829   * @until RIGHT
2830   *
2831   * We are also going to set the hitsize to the entire flip(in all directions)
2832   * to make our flip very easy to interact with:
2833   * @until RIGHT
2834   *
2835   * After that we create our radio buttons and start the main loop:
2836   * @until ELM_MAIN()
2837   *
2838   * When the user clicks a radio button a function that changes the
2839   * interaction mode and animates the flip is called:
2840   * @until }
2841   * @note The elm_flip_go() call here serves no purpose other than to
2842   * ilustrate that it's possible to animate the flip programmatically.
2843   *
2844   * Our example will look like this:
2845   *
2846   * @image html screenshots/flip_example_01.png
2847   * @image latex screenshots/flip_example_01.eps width=\textwidth
2848   *
2849   * @note Since this is an animated example the screenshot doesn't do it
2850   * justice, it is a good idea to compile it and see the animations.
2851   *
2852   * @example flip_example_01.c
2853   */
2854
2855  /**
2856   * @page tutorial_label Label example
2857   * @dontinclude label_example_01.c
2858   *
2859   * In this example we are going to create 6 labels, set some properties on
2860   * them and see what changes in appearance those properties cause.
2861   *
2862   * We start with the setup code that by now you should be familiar with:
2863   * @until show(bg)
2864   *
2865   * For our first label we have a moderately long text(that doesn't fit in the
2866   * label's width) so we will make it a sliding label. Since the text isn't
2867   * too long we don't need the animation to be very long, 3 seconds should
2868   * give us a nice speed:
2869   * @until show(label
2870   *
2871   * For our second label we have the same text, but this time we aren't going
2872   * to have it slide, we're going to ellipsize it. Because we ask our label
2873   * widget to ellipsize the text it will first diminsh the fontsize so that it
2874   * can show as much of the text as possible:
2875   * @until show(label
2876   *
2877   * For the third label we are going to ellipsize the text again, however this
2878   * time to make sure the fontsize isn't diminshed we will set a line wrap.
2879   * The wrap won't actually cause a line break because we set the label to
2880   * ellipsize:
2881   * @until show(label
2882   *
2883   * For our fourth label we will set line wrapping but won't set ellipsis, so
2884   * that our text will indeed be wrapped instead of ellipsized. For this label
2885   * we choose character wrap:
2886   * @until show(label
2887   *
2888   * Just two more, for our fifth label we do the same as for the fourth
2889   * except we set the wrap to word:
2890   * @until show(label
2891   *
2892   * And last but not least for our sixth label we set the style to "marker" and
2893   * the color to red(the default color is white which would be hard to see on
2894   * our white background):
2895   * @until show(label
2896   *
2897   * Our example will look like this:
2898   *
2899   * @image html screenshots/label_example_01.png
2900   * @image latex screenshots/label_example_01.eps width=\textwidth
2901   *
2902   * @example label_example_01.c
2903   */
2904
2905  /**
2906   * @page tutorial_image Image example
2907   * @dontinclude image_example_01.c
2908   *
2909   * This example is as simple as possible. An image object will be added to the
2910   * window over a white background, and set to be resizeable together with the
2911   * window. All the options set through the example will affect the behavior of
2912   * this image.
2913   *
2914   * We start with the code for creating a window and its background, and also
2915   * add the code to write the path to the image that will be loaded:
2916   *
2917   * @skip int
2918   * @until snprintf
2919   *
2920   * Now we create the image object, and set that file to be loaded:
2921   *
2922   * @until }
2923   *
2924   * We can now go setting our options.
2925   *
2926   * elm_image_no_scale_set() is used just to set this value to true (we
2927   * don't want to scale our image anyway, just resize it).
2928   *
2929   * elm_image_scale_set() is used to allow the image to be resized to a size
2930   * smaller than the original one, but not to a size bigger than it.
2931   *
2932   * elm_elm_image_smooth_set() will disable the smooth scaling, so the scale
2933   * algorithm used to scale the image to the new object size is going to be
2934   * faster, but with a lower quality.
2935   *
2936   * elm_image_orient_set() is used to flip the image around the (1, 0) (0, 1)
2937   * diagonal.
2938   *
2939   * elm_image_aspect_ratio_retained_set() is used to keep the original aspect
2940   * ratio of the image, even when the window is resized to another aspect ratio.
2941   *
2942   * elm_image_fill_outside_set() is used to ensure that the image will fill the
2943   * entire area available to it, even if keeping the aspect ratio. The image
2944   * will overflow its width or height (any of them that is necessary) to the
2945   * object area, instead of resizing the image down until it can fit entirely in
2946   * this area.
2947   *
2948   * elm_image_editable_set() is used just to cover the API, but won't affect
2949   * this example since we are not using any copy & paste property.
2950   *
2951   * This is the code for setting these options:
2952   *
2953   * @until editable
2954   *
2955   * Now some last touches in our object size hints, window and background, to
2956   * display this image properly:
2957   *
2958   * @until ELM_MAIN
2959   *
2960   * This example will look like this:
2961   *
2962   * @image html screenshots/image_example_01.png
2963   * @image latex screenshots/image_example_01.eps width=\textwidth
2964   *
2965   * @example image_example_01.c
2966   */
2967
2968  /**
2969   * @page tutorial_icon Icon example
2970   * @dontinclude icon_example_01.c
2971   *
2972   * This example is as simple as possible. An icon object will be added to the
2973   * window over a white background, and set to be resizeable together with the
2974   * window. All the options set through the example will affect the behavior of
2975   * this icon.
2976   *
2977   * We start with the code for creating a window and its background:
2978   *
2979   * @skip int
2980   * @until show(bg)
2981   *
2982   * Now we create the icon object, and set lookup order of the icon, and choose
2983   * the "home" icon:
2984   *
2985   * @until home
2986   *
2987   * An intersting thing is that after setting this, it's possible to check where
2988   * in the filesystem is the theme used by this icon, and the name of the group
2989   * used:
2990   *
2991   * @until printf
2992   *
2993   * We can now go setting our options.
2994   *
2995   * elm_icon_no_scale_set() is used just to set this value to true (we
2996   * don't want to scale our icon anyway, just resize it).
2997   *
2998   * elm_icon_scale_set() is used to allow the icon to be resized to a size
2999   * smaller than the original one, but not to a size bigger than it.
3000   *
3001   * elm_elm_icon_smooth_set() will disable the smooth scaling, so the scale
3002   * algorithm used to scale the icon to the new object size is going to be
3003   * faster, but with a lower quality.
3004   *
3005   * elm_icon_fill_outside_set() is used to ensure that the icon will fill the
3006   * entire area available to it, even if keeping the aspect ratio. The icon
3007   * will overflow its width or height (any of them that is necessary) to the
3008   * object area, instead of resizing the icon down until it can fit entirely in
3009   * this area.
3010   *
3011   * This is the code for setting these options:
3012   *
3013   * @until fill_outside
3014   *
3015   * However, if you try this example you may notice that this image is not being
3016   * affected by all of these options. This happens because the used icon will be
3017   * from elementary theme, and thus it has its own set of options like smooth
3018   * scaling and fill_outside options. You can change the "home" icon to use some
3019   * image (from your system) and see that then those options will be respected.
3020   *
3021   * Now some last touches in our object size hints, window and background, to
3022   * display this icon properly:
3023   *
3024   * @until ELM_MAIN
3025   *
3026   * This example will look like this:
3027   *
3028   * @image html screenshots/icon_example_01.png
3029   * @image latex screenshots/icon_example_01.eps width=\textwidth
3030   *
3031   * @example icon_example_01.c
3032   */
3033
3034 /**
3035  * @page tutorial_hoversel Hoversel example
3036  * @dontinclude hoversel_example_01.c
3037  *
3038  * In this example we will create a hoversel with 3 items, one with a label but
3039  * no icon and two with both a label and an icon. Every item that is clicked
3040  * will be deleted, but everytime the hoversel is activated we will also add an
3041  * item. In addition our first item will print all items when clicked and our
3042  * third item will clear all items in the hoversel.
3043  *
3044  * We will start with the normal creation of window stuff:
3045  * @until show(bg)
3046  *
3047  * Next we will create a red rectangle to use as the icon of our hoversel:
3048  * @until show
3049  *
3050  * And now we create our hoversel and set some of it's properties. We set @p win
3051  * as its parent, ask it to not be horizontal(be vertical) and give it a label
3052  * and icon:
3053  * @until icon_set
3054  *
3055  * Next we will add our three items, setting a callback to be called for the
3056  * first and third:
3057  * @until _rm_items
3058  *
3059  * We also set a pair of callbacks to be called whenever any item is selected or
3060  * when the hoversel is activated:
3061  * @until clicked
3062  *
3063  * And then ask that our hoversel be shown and run the main loop:
3064  * @until ELM_MAIN
3065  *
3066  * We now have the callback for our first item which prints all items in the
3067  * hoversel:
3068  * @until }
3069  *
3070  * Next we have the callback for our third item which removes all items from the
3071  * hoversel:
3072  * @until }
3073  *
3074  * Next we have the callback that is called whenever an item is clicked and
3075  * deletes that item:
3076  * @until }
3077  *
3078  * And the callback that is called when the hoversel is activated and adds an
3079  * item to the hoversel. Note that since we allocate memory for the item we need
3080  * to know when the item dies so we can free that memory:
3081  * @until }
3082  *
3083  * And finally the callback that frees the memory we allocated for items created
3084  * in the @p _add_item callback:
3085  * @until }
3086  *
3087  * Our example will initially look like this:
3088  *
3089  * @image html screenshots/hoversel_example_01.png
3090  * @image latex screenshots/hoversel_example_01.eps width=\textwidth
3091  *
3092  * And when the hoversel is clicked it will look like this:
3093  *
3094  * @image html screenshots/hoversel_example_01_a.png
3095  * @image latex screenshots/hoversel_example_01_a.eps width=\textwidth
3096  *
3097  * @example hoversel_example_01.c
3098  */
3099
3100 /**
3101  * @page conformant_example Conformant Example.
3102  *
3103  * In this example we'll explain how to create applications to work
3104  * with illume, considering space required for virtual keyboards, indicator
3105  * and softkeys.
3106  *
3107  * Illume is a module for Enlightenment that modifies the user interface
3108  * to work cleanly and nicely on a mobile device. It has support for
3109  * virtual keyboard, among other nice features.
3110  *
3111  * Let's start creating a very simple window with a vertical box
3112  * with multi-line entry between two buttons.
3113  * This entry will expand filling all space on window not used by buttons.
3114  *
3115  * @dontinclude conformant_example_01.c
3116  * @skipline elm_main
3117  * @until }
3118  *
3119  * For information about how to create windows, boxes, buttons or entries,
3120  * look for documentation for these widgets.
3121  *
3122  * It will looks fine when you don't need a virtual keyboard, as you
3123  * can see on the following image:
3124  *
3125  * @image html screenshots/conformant_example_01.png
3126  * @image latex screenshots/conformant_example_01.eps width=\textwidth
3127  *
3128  * But if you call a virtual keyboard, the window will resize, changing
3129  * widgets size and position. All the content will shrink.
3130  *
3131  * If you don't want such behaviour, you
3132  * will need a conformant to account for space taken up by the indicator,
3133  * virtual keyboard and softkey.
3134  *
3135  * In this case, using the conformant in a proper way, you will have
3136  * a window like the following:
3137  *
3138  * @image html screenshots/conformant_example_02.png
3139  * @image latex screenshots/conformant_example_02.eps width=\textwidth
3140  *
3141  * As you can see, it guess the space that will be required by the keyboard,
3142  * indicator and softkey bars.
3143  *
3144  * So, let's study each step required to transform our initial example on
3145  * the second one.
3146  *
3147  * First of all, we need to set the window as an illume conformant window:
3148  * @dontinclude conformant_example_02.c
3149  * @skipline elm_win_conformant_set
3150  *
3151  * Next, we'll add a conformant widget, and set it to resize with the window,
3152  * instead of the box.
3153  * @skipline conform
3154  * @until evas_object_show
3155  *
3156  * Finally, we'll set the box as conformant's content, just like this:
3157  * @skipline elm_conformant_content_set
3158  *
3159  * Compare both examples code:
3160  * @ref conformant_example_01.c "conformant_example_01.c"
3161  * @ref conformant_example_02.c "conformant_example_02.c"
3162  *
3163  * @example conformant_example_01.c
3164  * @example conformant_example_02.c
3165  */
3166
3167 /**
3168  * @page index_example_01 Index widget example 1
3169  *
3170  * This code places an Elementary index widget on a window, which also
3171  * has a very long list of arbitrary strings on it.  The list is
3172  * sorted alphabetically and the index will be used to index the first
3173  * items of each set of strings beginning with an alphabet letter.
3174  *
3175  * Below the list are some buttons, which are there just to exercise
3176  * some index widget's API.
3177  *
3178  * Here's how we instantiate it:
3179  * @dontinclude index_example_01.c
3180  * @skip elm_list_add
3181  * @until evas_object_show(d.index)
3182  * where we're showing also the list being created. Note that we issue
3183  * elm_win_resize_object_add() on the index, so that it's set to have
3184  * the whole window as its container. Then, we have to populate both
3185  * list and index widgets:
3186  * @dontinclude index_example_01.c
3187  * @skip for (i = 0; i < (sizeof(dict) / sizeof(dict[0])); i++)
3188  * @until }
3189  * @until }
3190  *
3191  * The strings populating the list come from a file
3192  * @dontinclude index_example_01.c
3193  * @skip static const char *dict
3194  * @until }
3195  *
3196  * We use the @c curr char variable to hold the last initial letter
3197  * seen on that ordered list of strings, so that we're able to have an
3198  * index item pointing to each list item starting a new letter
3199  * "section". Note that our index item data pointers will be the list
3200  * item handles. We are also setting a callback function to index
3201  * items deletion events:
3202  * @dontinclude index_example_01.c
3203  * @skip static void
3204  * @until }
3205  *
3206  * There, we show you that the @c event_info pointer will contain the
3207  * item in question's data, i.e., a given list item's pointer. Because
3208  * item data is also returned in the @c data argument on
3209  * @c Evas_Smart_Cb functions, those two pointers must have the same
3210  * values. On this deletion callback, we're deleting the referred list
3211  * item too, just to exemplify that anything could be done there.
3212  *
3213  * Next, we hook to two smart events of the index object:
3214  * @dontinclude index_example_01.c
3215  * @skip smart_callback_add(d.index
3216  * @until _index_selected
3217  * @dontinclude index_example_01.c
3218  * @skip "delay,changed" hook
3219  * @until }
3220  * @until }
3221  *
3222  * Check that, whenever one holds the mouse pressed over a given index
3223  * letter for some time, the list beneath it will roll down to the
3224  * item pointed to by that index item. When one releases the mouse
3225  * button, the second callback takes place. There, we check that the
3226  * reported item data, on @c event_info, is the same reported by
3227  * elm_index_item_selected_get(), which gives the last selection's
3228  * data on the index widget.
3229  *
3230  * The first of the three buttons that follow will call
3231  * elm_index_active_set(), thus showing the index automatically for
3232  * you, if it's not already visible, what is checked with
3233  * elm_index_active_get(). The second button will exercise @b deletion
3234  * of index item objects, by the following code:
3235  * @dontinclude index_example_01.c
3236  * @skip delete an index item
3237  * @until }
3238  *
3239  * It will get the last index item selected's data and find the
3240  * respective #Elm_Index_Item handle with elm_index_item_find(). We
3241  * need the latter to query the indexing letter string from, with
3242  * elm_index_item_letter_get(). Next, comes the delition, itself,
3243  * which will also trigger the @c _index_item_del callback function,
3244  * as said above.
3245  *
3246  * The third button, finally, will exercise elm_index_item_clear(),
3247  * which will delete @b all of the index's items.
3248  *
3249  * This is how the example program's window looks like with the index
3250  * widget hidden:
3251  * @image html screenshots/index_example_00.png
3252  * @image latex screenshots/index_example_00.eps
3253  *
3254  * When it's shown, it's like the following figure:
3255  * @image html screenshots/index_example_01.png
3256  * @image latex screenshots/index_example_01.eps
3257  *
3258  * See the full @ref index_example_01_c "source code" for
3259  * this example.
3260  *
3261  * @example index_example_01.c
3262  */
3263
3264 /**
3265  * @page index_example_02 Index widget example 2
3266  *
3267  * This code places an Elementary index widget on a window, indexing
3268  * grid items. The items are placed so that their labels @b don't
3269  * follow any order, but the index itself is ordered (through
3270  * elm_index_item_sorted_insert()). This is a complement to to @ref
3271  * index_example_01 "the first example on indexes".
3272  *
3273  * Here's the list of item labels to be used on the grid (in that
3274  * order):
3275  * @dontinclude index_example_02.c
3276  * @skip static const char *items
3277  * @until };
3278  *
3279  * In the interesting part of the code, here, we first instantiate the
3280  * grid (more on grids on their examples) and, after creating our
3281  * index, for each grid item we also create an index one to reference
3282  * it:
3283  * @dontinclude index_example_02.c
3284  * @skip grid = elm_gengrid_add
3285  * @until }
3286  * @until smart_callback_add
3287  *
3288  * The order in which they'll appear in the index, though, is @b
3289  * alphabetical, becase of elm_index_item_sorted_insert() usage
3290  * together with the comparing function, where we take the letters of
3291  * each index item to base our ordering on. The parameters on
3292  * @c _index_cmp have to be declared as void pointers because of the
3293  * @c Eina_Compare_Cb prototype requisition, but in this case we know
3294  * they'll be #Elm_Index_Item's:
3295  * @dontinclude index_example_02.c
3296  * @skip ordering alphabetically
3297  * @until }
3298  *
3299  * The last interesting bit is the callback in the @c "delay,changed"
3300  * smart event, which will bring the given grid item to the grid's
3301  * visible area:
3302  * @dontinclude index_example_02.c
3303  * @skip static void
3304  * @until }
3305  *
3306  * Note how the grid will move kind of randomly while you move your
3307  * mouse pointer held over the index from top to bottom -- that's
3308  * because of the the random order the items have in the grid itself.
3309  *
3310  * This is how the example program's window looks like:
3311  * @image html screenshots/index_example_03.png
3312  * @image latex screenshots/index_example_03.eps
3313  *
3314  * See the full @ref index_example_c "source code" for
3315  * this example.
3316  *
3317  * @example index_example_02.c
3318  */
3319
3320 /**
3321  * @page tutorial_ctxpopup Ctxpopup example
3322  * @dontinclude ctxpopup_example_01.c
3323  *
3324  * In this example we have a list with two items, when either item is clicked
3325  * a ctxpopup for it will be shown. Our two ctxpopups are quite different, the
3326  * one for the first item is a vertical and it's items contain both labels and
3327  * icons, the one for the second item is horizontal and it's items have icons
3328  * but not labels.
3329  *
3330  * We will begin examining our example code by looking at the callback we'll use
3331  * when items in the ctxpopup are clicked. It's very simple, all it does is
3332  * print the label present in the ctxpopup item:
3333  * @until }
3334  *
3335  * Next we examine a function that creates ctxpopup items, it was created to
3336  * avoid repeating the same code whenever we needed to add an item to our
3337  * ctxpopup. Our function creates an icon from the standard set of icons, and
3338  * then creates the item, with the label received as an argument. We also set
3339  * the callback to be called when the item is clicked:
3340  * @until }
3341  *
3342  * Finally we have the function that will create the ctxpopup for the first item
3343  * in our list. This one is somewhat more complex though, so let's go through it
3344  * in parts. First we declare our variable and add the ctxpopup:
3345  * @until ctxpopup_add
3346  *
3347  * Next we create a bunch of items for our ctxpopup, marking two of them as
3348  * disabled just so we can see what that will look like:
3349  * @until disabled_set
3350  * @until disabled_set
3351  *
3352  * Then we ask evas where the mouse pointer was so that we can have our ctxpopup
3353  * appear in the right place, set a maximum size for the ctxpopup, move it and
3354  * show it:
3355  * @until show
3356  *
3357  * And last we mark the list item as not selected:
3358  * @until }
3359  *
3360  * Our next function is the callback that will create the ctxpopup for the
3361  * second list item, it is very similar to the previous function. A couple of
3362  * interesting things to note is that we ask our ctxpopup to be horizontal, and
3363  * that we pass NULL as the label for every item:
3364  * @until }
3365  *
3366  * And with all of that in place we can now get to our main function where we
3367  * create the window, the list, the list items and run the main loop:
3368  * @until ELM_MAIN()
3369  *
3370  * The example will initially look like this:
3371  *
3372  * @image html screenshots/ctxpopup_example_01.png
3373  * @image latex screenshots/ctxpopup_example_01.eps width=\textwidth
3374  *
3375  * @note This doesn't show the ctxpopup tough, since it will only appear when
3376  * we click one of the list items.
3377  *
3378  * Here is what our first ctxpopup will look like:
3379  *
3380  * @image html screenshots/ctxpopup_example_01_a.png
3381  * @image latex screenshots/ctxpopup_example_01_a.eps width=\textwidth
3382  *
3383  * And here the second ctxpopup:
3384  *
3385  * @image html screenshots/ctxpopup_example_01_b.png
3386  * @image latex screenshots/ctxpopup_example_01_b.eps width=\textwidth
3387  *
3388  * @example ctxpopup_example_01.c
3389  */
3390
3391 /**
3392  * @page tutorial_pager
3393  * @dontinclude pager_example_01.c
3394  *
3395  * In this example we'll have a pager with 3 rectangles on it, one blue, one
3396  * green and one blue, we'll also have 1 button for each rectangle. Pressing a
3397  * button will bring the associated rectangle to the front of the pager(promote
3398  * it).
3399  *
3400  * We start our example with some run of the mill code that you've seen in other
3401  * examples:
3402  * @until show
3403  *
3404  * And then we get right to creating our pager, setting a style and some basic
3405  * properties to it:
3406  * @until show
3407  *
3408  * Well a pager without any content is not of much use, so let's create the
3409  * first of our rectangles, add it to the pager and create the button for it:
3410  * @until smart_callback
3411  * @note The only line of above code that directly relates to our pager is the
3412  * call to elm_pager_content_push().
3413  *
3414  * And now we will do the same thing again twice for our next two rectangles:
3415  * @until smart_callback
3416  * @until smart_callback
3417  *
3418  * Now that we haver our widgets create we can get to running the main loop:
3419  * @until ELM_MAIN
3420  *
3421  * We also have the callback that is called when any of the buttons is pressed,
3422  * this callback is receiving the rectangle in it's @p data argument, so we
3423  * check if it's already on top and if not move it there:
3424  * @until }
3425  *
3426  * Our example will look like this:
3427  *
3428  * @image html screenshots/pager_example_01.png
3429  * @image latex screenshots/pager_example_01.eps width=\textwidth
3430  * @note Like all examples that involve animations the screenshot doesn't do it
3431  * justice, seeing it in action is a must.
3432  *
3433  * @example pager_example_01.c
3434  */
3435
3436 /**
3437  * @page tutorial_separator Separator example
3438  * @dontinclude separator_example_01.c
3439  *
3440  * In this example we are going to pack two rectangles in a box, and have a
3441  * separator in the middle.
3442  *
3443  * So we start we the window, background, box and rectangle creation, all pretty
3444  * normal stuff:
3445  * @until pack_end
3446  *
3447  * Once we have our first rectangle in the box we create and add our separator:
3448  * @until pack_end
3449  * @note Since our box is in horizontal mode it's a good idea to set the
3450  * separator to be horizontal too.
3451  *
3452  * And now we add our second rectangle and run the main loop:
3453  * @until ELM_MAIN
3454  *
3455  * This example will look like this:
3456  *
3457  * @image html screenshots/separator_example_01.png
3458  * @image eps screenshots/separator_example_01.eps width=\textwidth
3459  *
3460  * @example separator_example_01.c
3461  */
3462
3463 /**
3464  * @page tutorial_radio Radio example
3465  * @dontinclude radio_example_01.c
3466  *
3467  * In this example we will create 4 radio buttons, three of them in a group and
3468  * another one not in the group. We will also have the radios in the group
3469  * change the value of a variable directly and have then print it when the value
3470  * changes. The fourth button is in the example just to make clear that radios
3471  * outside the group don't affect the group.
3472  *
3473  * We'll start with the usual includes:
3474  * @until #endif
3475  *
3476  * And move right to declaring a static variable(the one whose value the radios
3477  * will change):
3478  * @until static
3479  *
3480  * We now need to have a window and all that good stuff to be able to place our
3481  * radios in:
3482  * @until show(bx)
3483  *
3484  * And now we create a radio button, since this is the first button in our group
3485  * we set the group to be the radio(so we can set the other radios in the same
3486  * group). We also set the state value of this radio to 1 and the value pointer
3487  * to @p val, since val is @p 1 this has the additional effect of setting the
3488  * radio value to @p 1. For this radio we choose the default home icon:
3489  * @until show
3490  *
3491  * To check that our radio buttons are working we'll add a callback to the
3492  * "changed" signal of the radio:
3493  * @until smart_callback
3494  *
3495  * The creation of our second radio button is almost identical, the 2
3496  * differences worth noting are, the value of this radio 2 and that we add this
3497  * radio to the group of the first radio:
3498  * @until smart_callback
3499  *
3500  * For our third callback we'll omit the icon and set the value to 3, we'll also
3501  * add it to the group of the first radio:
3502  * @until smart_callback
3503  *
3504  * Our fourth callback has a value of 4, no icon and most relevantly is not a
3505  * member of the same group as the other radios:
3506  * @until show
3507  *
3508  * We finally run the main loop:
3509  * @until ELM_MAIN
3510  *
3511  * And the last detail in our example is the callback that prints @p val so that
3512  * we can see that the radios are indeed changing its value:
3513  * @until }
3514  *
3515  * The example will look like this:
3516  *
3517  * @image html screenshots/radio_example_01.png
3518  * @image latex screenshots/radio_example_01.epx width=\textwidth
3519  *
3520  * @example radio_example_01.c
3521  */
3522
3523 /**
3524  * @page tutorial_toggle Toggle example
3525  * @dontinclude toggle_example_01.c
3526  *
3527  * In this example we'll create 2 toggle widgets. The first will have an icon
3528  * and the state names will be the default "on"/"off", it will also change the
3529  * value of a variable directly. The second won't have a icon, the state names
3530  * will be "Enabled"/"Disabled", it will  start "Enabled" and it won't set the
3531  * value of a variable.
3532  *
3533  * We start with the usual includes and prototype for callback which will be
3534  * implemented and detailed later on:
3535  * @until _cb2
3536  *
3537  * We then declare a static global variable(the one whose value will be changed
3538  * by the first toggle):
3539  * @until static
3540  *
3541  * We now have to create our window and all that usual stuff:
3542  * @until show(bx)
3543  *
3544  * The creation of a toggle is no more complicated than that of any other
3545  * widget:
3546  * @until add
3547  *
3548  * For our first toggle we don't set the states labels so they will stay the
3549  * default, however we do set a label for the toggle, an icon and the variable
3550  * whose value it should change:
3551  * @until show
3552  *
3553  * We also set the callback that will be called when the toggles value changes:
3554  * @until smart_callback
3555  *
3556  * For our second toggle it important to note that we set the states labels,
3557  * don't set an icon or variable, but set the initial state to
3558  * EINA_TRUE("Enabled"):
3559  * @until show
3560  *
3561  * For the second toggle we will use a different callback:
3562  * @until smart_callback
3563  *
3564  * We then ask the main loop to start:
3565  * @until ELM_MAIN
3566  *
3567  * The callback for our first toggle will look the value of @p val and print it:
3568  * @until }
3569  *
3570  * For our second callback we need to do a little bit more, since the second
3571  * toggle doesn't change the value of a variable we have to ask it what its
3572  * state is:
3573  * @until }
3574  *
3575  * This example will look like this:
3576  *
3577  * @image html screenshots/toggle_example_01.png
3578  * @image latex screenshots/toggle_example_01.eps width=\textwidth
3579  *
3580  * @example toggle_example_01.c
3581  */
3582
3583 /**
3584  * @page tutorial_panel Panel example
3585  * @dontinclude panel_example_01.c
3586  *
3587  * In this example will have 3 panels, one for each possible orientation. Two of
3588  * our panels will start out hidden, the third will start out expanded. For each
3589  * of the panels we will use a label as the content, it's however possible to
3590  * have any widget(including containers) as the content of panels.
3591  *
3592  * We start by doing some setup, code you should be familiar with from other
3593  * examples:
3594  * @until show(bx)
3595  *
3596  * And move right to creating our first panel, for this panel we are going to
3597  * choose the orientation as TOP and toggle it(tell it to hide itself):
3598  * @until pack_end
3599  *
3600  * For the second panel we choose the RIGHT orientation and explicitly set the
3601  * state as hidden:
3602  * @until pack_end
3603  *
3604  * For our third and last panel we won't set the orientation(which means it will
3605  * use the default: LEFT):
3606  * @until pack_end
3607  *
3608  * All that is left is running the main loop:
3609  * @until ELM_MAIN
3610  *
3611  * This example will look like this;
3612  *
3613  * @image html screenshots/panel_example_01.png
3614  * @image latex screenshots/panel_example_01.epx width=\textwidth
3615  * @note The buttons with arrow allow the user to hide/show the panels.
3616  *
3617  * @example panel_example_01.c
3618  */
3619
3620 /**
3621  * @page gengrid_example Gengrid widget example
3622  *
3623  * This application is a thorough exercise on the gengrid widget's
3624  * API. We place an Elementary gengrid widget on a window, with
3625  * various knobs below its viewport, each one acting on it somehow.
3626  *
3627  * The code's relevant part begins at the grid's creation. After
3628  * instantiating it, we set its items sizes, so that we don't end with
3629  * items one finger size wide, only. We're setting them to fat, 150
3630  * pixel wide ones, for this example. We give it some size hints, not
3631  * to be discussed in this context and, than, we register a callback
3632  * on one of its smart events -- the one coming each time an item gets
3633  * doubly clicked. There, we just print the item handle's value.
3634  * @dontinclude gengrid_example.c
3635  * @skip grid = elm_gengrid_add
3636  * @until evas_object_sho
3637  * @dontinclude gengrid_example.c
3638  * @skip item double click callback
3639  * @until }
3640  *
3641  * Before we actually start to deal with the items API, let's show
3642  * some things items will be using throughout all the code. The first
3643  * of them is a struct to be used as item data, for all of them:
3644  * @dontinclude gengrid_example.c
3645  * @skip typedef struct
3646  * @until Item;
3647  *
3648  * That path will be used to index an image, to be swallowed into one
3649  * of the item's icon spots. The imagens themselves are distributed
3650  * with Elementary:
3651  * @dontinclude gengrid_example.c
3652  * @skip static const char *imgs
3653  * @until ;
3654  *
3655  * We also have an (unique) gengrid item class we'll be using for
3656  * items in the example:
3657  * @dontinclude gengrid_example.c
3658  * @skip static Elm_Gengrid_Item_Class
3659  * @until static Elm_Gengrid_Item_Class
3660  * @dontinclude gengrid_example.c
3661  * @skip item_style =
3662  * @until _grid_del
3663  *
3664  * As you see, our items will follow the default theme on gengrid
3665  * items. For the label fetching code, we return a string composed of
3666  * the item's image path:
3667  * @dontinclude gengrid_example.c
3668  * @skip label fetching callback
3669  * @until }
3670  *
3671  * For item icons, we'll be populating the item default theme's two
3672  * icon spots, @c "elm.swallow.icon" and @c "elm.swallow.end". The
3673  * former will receive one of the images in our list (in the form of
3674  * a @ref bg_02_example_page "background"), while the latter will be
3675  * a check widget. Note that we prevent the check to propagate click
3676  * events, so that the user can toggle its state without messing with
3677  * the respective item's selection in the grid:
3678  * @dontinclude gengrid_example.c
3679  * @skip icon fetching callback
3680  * @until return NULL
3681  * @until }
3682  *
3683  * As the default gengrid item's theme does not have parts
3684  * implementing item states, we'll be just returning false for every
3685  * item state:
3686  * @dontinclude gengrid_example.c
3687  * @skip state fetching callback
3688  * @until }
3689  *
3690  * Finally, the deletion callback on gengrid items takes care of
3691  * freeing the item's label string and its data struct:
3692  * @dontinclude gengrid_example.c
3693  * @skip deletion callback
3694  * @until }
3695  *
3696  * Let's move to item insertion/deletion knobs, them. They are four
3697  * buttons, above the grid's viewport, namely
3698  * - "Append" (to append an item to the grid),
3699  * - "Prepend" (to prepend an item to the grid),
3700  * - "Insert before" (to insert an item before the selection, on the
3701  *   grid),
3702  * - "Insert after" (to insert an item after the selection, on the
3703  *   grid),
3704  * - "Clear" (to delete all items in the grid),
3705  * - "Bring in 1st" (to make the 1st item visible, by scrolling),
3706  * - "Show last" (to directly show the last item),
3707  * .
3708  * which are displaced and declared in that order. We're not dealing
3709  * with the buttons' creation code (see @ref button_example_01
3710  * "a button example", for more details on it), but with their @c
3711  * "clicked" registered callbacks.  For all of them, the grid's handle
3712  * is passed as @c data. The ones creating new items use a common
3713  * code, which just gives a new @c Example_Item struct, with @c path
3714  * filled with a random image in our images list:
3715  * @dontinclude gengrid_example.c
3716  * @skip new item with random path
3717  * @until }
3718  *
3719  * Moreover, that ones will set a common function to be issued on the
3720  * selection of the items. There, we print the item handle's value,
3721  * along with the callback function data. The latter will be @c NULL,
3722  * always, because it's what we pass when adding all icons. By using
3723  * elm_gengrid_item_data_get(), we can have the item data back and,
3724  * with that, we're priting the item's path string. Finally, we
3725  * exemplify elm_gengrid_item_pos_get(), printing the item's position
3726  * in the grid:
3727  * @dontinclude gengrid_example.c
3728  * @skip item selection callback
3729  * @until }
3730  *
3731  * The appending button will exercise elm_gengrid_item_append(), simply:
3732  * @dontinclude gengrid_example.c
3733  * @skip append an item
3734  * @until }
3735  *
3736  * The prepending, naturally, is analogous, but exercising
3737  * elm_gengrid_item_prepend(), on its turn. The "Insert before" one
3738  * will expect an item to be selected in the grid, so that it will
3739  * insert a new item just before it:
3740  * @dontinclude gengrid_example.c
3741  * @skip "insert before" callback
3742  * @until }
3743  *
3744  * The "Insert after" is analogous, just using
3745  * elm_gengrid_item_insert_after(), instead. The "Clear" button will,
3746  * as expected, just issue elm_gengrid_clear():
3747  * @dontinclude gengrid_example.c
3748  * @skip delete items
3749  * @until }
3750  *
3751  * The "Bring in 1st" button is there exercise two gengrid functions
3752  * -- elm_gengrid_first_item_get() and elm_gengrid_item_bring_in().
3753  * With the former, we get a handle to the first item and, with the
3754  * latter, you'll see that the widget animatedly scrolls its view
3755  * until we can see that item:
3756  * @dontinclude gengrid_example.c
3757  * @skip bring in 1st item
3758  * @until }
3759  *
3760  * The "Show last", in its turn, will use elm_gengrid_last_item_get()
3761  * and elm_gengrid_item_show(). The latter differs from
3762  * elm_gengrid_item_bring_in() in that it immediately replaces the
3763  * contents of the grid's viewport with the region containing the item
3764  * in question:
3765  * @dontinclude gengrid_example.c
3766  * @skip show last item
3767  * @until }
3768  *
3769  * To change the grid's cell (items) size, we've placed a spinner,
3770  * which has the following @c "changed" smart callback:
3771  * @dontinclude gengrid_example.c
3772  * @skip change items' size
3773  * @until }
3774  *
3775  * Experiment with it and see how the items are affected. The "Disable
3776  * item" button will, as the name says, disable the currently selected
3777  * item:
3778  * @dontinclude gengrid_example.c
3779  * @skip disable selected item
3780  * @until }
3781  * Note that we also make use of elm_gengrid_item_selected_set(),
3782  * there, thus making the item unselected before we actually disable
3783  * it.
3784  *
3785  * To toggle between horizontal and vertical layouting modes on the
3786  * grid, use the "Horizontal mode" check, which will call the
3787  * respective API function on the grid:
3788  * @dontinclude gengrid_example.c
3789  * @skip change layouting mode
3790  * @until }
3791  *
3792  * If you toggle the check right after that one, "Always select",
3793  * you'll notice all subsequent clicks on the @b same grid item will
3794  * still issue the selection callback on it, what is different from
3795  * when it's not checked. This is the
3796  * elm_gengrid_always_select_mode_set() behavior:
3797  * @dontinclude gengrid_example.c
3798  * @skip "always select" callback
3799  * @until }
3800  *
3801  * One more check follows, "Bouncing", which will turn on/off the
3802  * bouncing animations on the grid, when one scrolls past its
3803  * borders. Experiment with scrolling the grid to get the idea, having
3804  * it turned on and off:
3805  * @dontinclude gengrid_example.c
3806  * @skip "bouncing mode" callback
3807  * @until }
3808  *
3809  * The next two checks will affect items selection on the grid. The
3810  * first, "Multi-selection", will make it possible to select more the
3811  * one item on the grid. Because it wouldn't make sense to fetch for
3812  * an unique selected item on this case, we also disable two of the
3813  * buttons, which insert items relatively, if multi-selection is on:
3814  * @dontinclude gengrid_example.c
3815  * @skip multi-selection callback
3816  * @until }
3817  *
3818  * Note that we also @b unselect all items in the grid, when returning
3819  * from multi-selection mode, making use of
3820  * elm_gengrid_item_selected_set().
3821  *
3822  * The second check acting on selection, "No selection", is just what
3823  * its name depicts -- no selection will be allowed anymore, on the
3824  * grid, while it's on. Check it out for yourself, interacting with
3825  * the program:
3826  * @dontinclude gengrid_example.c
3827  * @skip no selection callback
3828  * @until }
3829  *
3830  * We have, finally, one more line of knobs, now sliders, to change
3831  * the grids behavior. The two first will change the horizontal @b
3832  * alignment of the whole actual grid of items within the gengrid's
3833  * viewport:
3834  * @dontinclude gengrid_example.c
3835  * @skip items grid horizontal alignment change
3836  * @until }
3837  *
3838  * Naturally, the vertical counterpart just issues
3839  * elm_gengrid_align_set() changing the second alignment component,
3840  * instead.
3841  *
3842  * The last slider will change the grid's <b>page size</b>, relative
3843  * to its own one. Try to change those values and, one manner of
3844  * observing the paging behavior, is to scroll softly and release the
3845  * mouse button, with different page sizes, at different grid
3846  * positions, while having lots of items in it -- you'll see it
3847  * snapping to page boundaries differenty, for each configuration:
3848  * @dontinclude gengrid_example.c
3849  * @skip page relative size change
3850  * @until }
3851  *
3852  * This is how the example program's window looks like:
3853  * @image html screenshots/gengrid_example.png
3854  * @image latex screenshots/gengrid_example.eps width=\textwidth
3855  *
3856  * Note that it starts with three items which we included at will:
3857  * @dontinclude gengrid_example.c
3858  * @skip _clicked(grid,
3859  * @until _clicked(grid,
3860  * @until _clicked(grid,
3861  * @until _clicked(grid,
3862  *
3863  * See the full @ref gengrid_example_c "source code" for
3864  * this example.
3865  *
3866  * @example gengrid_example.c
3867  */
3868 /**
3869  * @page entry_example_01 Entry - Example of simple editing
3870  *
3871  * As a general overview of @ref Entry we are going to write an, albeit simple,
3872  * functional editor. Although intended to show how elm_entry works, this
3873  * example also makes extensive use of several other widgets. The full code
3874  * can be found in @ref entry_example.c "entry_example.c" and in the following
3875  * lines we'll go through the parts especific to the @ref Entry widget.
3876  *
3877  * The program itself is a simple editor, with a file already set to it, that
3878  * can be set to autosave or not and allows insertion of emoticons and some
3879  * formatted text. As of this writing, the capabilities of format edition in
3880  * the entry are very limited, so a lot of manual work is required to change
3881  * the current text.
3882  *
3883  * In any case, the program allows some changes by using the buttons on the
3884  * top of the window and returning focus back to the main entry afterwards.
3885  *
3886  * @image html screenshots/entry_example.png
3887  * @image latex screenshots/entry_example.eps width=\textwidth
3888  *
3889  * We'll begin by showing a few structures used throught the program. First,
3890  * the application owns data that holds the main window and the main entry
3891  * where the editting happens. Then, an auxiliar structure we'll use later
3892  * when inserting icons in our text.
3893  * @dontinclude entry_example.c
3894  * @skip typedef
3895  * @until App_Inwin_Data
3896  *
3897  * A little convenience function will insert whatever text we need in the
3898  * buffer at the current cursor's position and set focus back to this entry.
3899  * This is done mostly because clicking on any button will make them steal
3900  * focus, which makes writing text more cumbersome.
3901  * @skip static void
3902  * @until }
3903  *
3904  * One of the buttons on the top will trigger an @ref Inwin to open and show
3905  * us several icons we can insert into the text. We'll jump over most of these
3906  * functions, but when all the options are chosen, we insert the special
3907  * markup text that will show the chosen icon in place.
3908  * @skip edje_file_collection_list_free(emos)
3909  * @skip static void
3910  * @until evas_object_del
3911  * @until }
3912  *
3913  * As can be seen in that function, the program lets us add icons to our entry
3914  * using all the possible configurations for them. That should help to
3915  * clarify how the different combinations work out by actually seeing them
3916  * in action.
3917  *
3918  * The same popup window has a page to set the settings of the chosen icon,
3919  * that is, the size and how the item will be placed within the line.
3920  *
3921  * The size is done with two entries, limitted to accept numbers and a fixed
3922  * size of characters. Changing the value in this entries will update the icon
3923  * size in our struct as seen in the next two callbacks.
3924  * @skip static void
3925  * @until }
3926  * @until }
3927  *
3928  * The rest of the options are handled with radio buttons, since only one type
3929  * of size can be used (@c size, @c absize or @c relsize) and for the vertical
3930  * sizing it needs to choose between @c ascent and @c full. Depending on which
3931  * is chosen, the @c item tag is formed accordingly as seen before.
3932  * @skip static Evas_Object
3933  * @until evas_object_show(rvascent)
3934  *
3935  * The first of our entries is here. There's something worth mentioning about
3936  * the way we'll create this one. Normally, any entry regardless of whether is
3937  * single line or not, will be set to scrollable, but in this case, since we
3938  * are limitting how many characters can fit in them and we know we don't need
3939  * scrolling, we are not setting this flag. This makes the entry have virtually
3940  * no appearance on screen, other than its text. This is because an entry is
3941  * just that, a box that holds text, and in order to have some frame around it
3942  * or a background color, another widget needs to provide this. When an entry
3943  * is scrollable, the same scroller used internally does this.
3944  * We are using @ref Frame "frames" here to provide some decoration around,
3945  * then creating our entries, set them to single line, add our two filters and
3946  * the callback for when their value change.
3947  * @until _height_changed_cb
3948  *
3949  * This function ends with the button that will finally call the item
3950  * into our editting string.
3951  * @until }
3952  *
3953  * Then we get to the format edition. Here we can add the @c bold and
3954  * @c emphasis tags to parts of our text. There's a lot of manual work to
3955  * know what to do here, since we are not implementing an entire state manager
3956  * and the entry itself doesn't, yet, support all the needed capabilities to
3957  * make this simpler. We begin by getting the format we are using in our
3958  * function from the button pressed.
3959  * @skip aid->pager = pager;
3960  * @until sizeof(fmt_close)
3961  *
3962  * Next we need to find out if we need to insert an opening or a closing tag.
3963  * For this, we store the current cursor position and create a selection
3964  * from this point until the beginning of our text, and then get the selected
3965  * text to look for any existing format tags in it. This is currently the only
3966  * way in which we can find out what formats is being used in the entry.
3967  * @until }
3968  * @until }
3969  *
3970  * Once we know what tag to insert, we need a second check in the case it was
3971  * a closing tag. This is because any other closing tag that comes after would
3972  * be left dangling alone, so we need to remove it to keep the text consistent.
3973  * @until }
3974  * @until }
3975  * Finally, we clear our fake selections and return the cursor back to the
3976  * position it had at first, since there is where we want to insert our format.
3977  * @until cursor_pos_set
3978  *
3979  * And finish by calling our convenience function from before, to insert the
3980  * text at the current cursor and give focus back to the entry.
3981  * @until }
3982  *
3983  * A checkbox on the top of our program tells us if the text we are editing
3984  * will autosave or not. In it's @c "changed" callback we get the value from
3985  * the checkbox and call the elm_entry_autosave_set() function with it. If
3986  * autosave is set, we also call elm_entry_file_save(). This is so the internal
3987  * timer used to periodically store to disk our changes is started.
3988  * @skip static void
3989  * @until }
3990  *
3991  * Two more functions to show some cursor playing. Whenever we double click
3992  * anywhere on our entry, we'll find what word is the cursor placed at and
3993  * select it. Likewise, for triple clicking, we select the entire line.
3994  * @skip static void
3995  * @until _edit_tplclick_cb
3996  * @until }
3997  *
3998  * And finally, the main window of the program contains the entry where we
3999  * do all the edition and some helping widgets to change format, add icons
4000  * or change the autosave flag.
4001  * @skip elm_exit
4002  * @skip int
4003  * @until _image_insert_cb
4004  *
4005  * And the main entry of the program. Set to scroll, by default we disable
4006  * autosave and we'll begin with a file set to it because no file selector
4007  * is being used here. The file is loaded with #ELM_TEXT_FORMAT_MARKUP_UTF8
4008  * so that any format contained in it is interpreted, otherwise the entry
4009  * would load it as just text, escaping any tags found and no format or icons
4010  * would be shown. Then we connect to the double and triple click signals
4011  * and set focus on the entry so we can start typing right away.
4012  * @until ELM_MAIN
4013  *
4014  * @example entry_example.c
4015  */
4016
4017 /**
4018  * @page genlist_example_01
4019  *
4020  * This example creates a simple genlist with a small number of items and
4021  * a callback that is called whenever an item is selected. All the properties of
4022  * this genlist are the default ones. The full code for this example can be seen
4023  * at @ref genlist_example_01_c.
4024  *
4025  * For the simplest list that you plan to create, it's necessary to define some
4026  * of the basic functions that are used for creating each list item, and
4027  * associating them with the "item class" for that list. The item class is just
4028  * an struct that contains pointers to the specific list item functions that are
4029  * common to all the items of the list.
4030  *
4031  * Let's show it by example. Our item class is declared globally and static as
4032  * it will be the only item class that we need (we are just creating one list):
4033  *
4034  * @dontinclude genlist_example_01.c
4035  * @skip static Elm_Genlist
4036  * @until static Elm_Genlist
4037  *
4038  * This item class will be used for every item that we create. The only
4039  * functions that we are going to set are @c label_get and @c icon_get. As the
4040  * name suggests, they are used by the genlist to generate the label for the
4041  * respective item, and to generate icon(s) to it too. Both the label and icon
4042  * get functions can be called more than once for each item, with different @c
4043  * part parameters, which represent where in the theme of the item that label or
4044  * icon is going to be set.
4045  *
4046  * The default theme for the genlist contains only one area for label, and two
4047  * areas for icon ("elm.swallow.icon" and "elm.swallow.end"). Since we just want
4048  * to set the first icon (that will be at the left side of the label), we
4049  * compare the part name given with "elm.swallow.icon". Notice that the
4050  * @c label_get function must return a strduped string, that will be freed later
4051  * automatically by the list. Here's the code for @c label_get and @c icon_get:
4052  *
4053  * @until static void
4054  *
4055  * We will also provide a function that will be called whenever an item is
4056  * selected in the genlist. However, this function is not part of the item
4057  * class, it will be passed for each item being added to the genlist explicitly.
4058  * Notice the similarity of the function signature with those used by @c
4059  * evas_object_smart_callback_add:
4060  *
4061  * @until }
4062  *
4063  * Now let's show the code used for really creating the list. Skipping
4064  * boilerplate code used for creating a window and background, the first piece
4065  * of code specific to our genlist example is setting the pointer functions of
4066  * the item class to our above defined functions:
4067  *
4068  * @skip _itc
4069  * @until func.del
4070  *
4071  * Notice that we also choose to use the "default" style for our genlist items.
4072  * Another interesting point is that @c state_get and @c del are set to @c NULL,
4073  * since we don't need these functions now. @c del doesn't need to be used
4074  * because we don't add any data that must be freed to our items, and @c
4075  * state_get is also not used since all of our items are the same and don't need
4076  * to have different states to be used for each item. Finally we create our
4077  * list:
4078  *
4079  * @until genlist_add
4080  *
4081  * Now we append several items to the list, and for all of them we need to give
4082  * the list pointer, a pointer to the item class, the data that will be used
4083  * with that item, a pointer to the parent of this item if it is in a group type
4084  * list (this is not the case so we pass @c NULL), possible flags for this item,
4085  * the callback for when the item is selected, and the data pointer that will be
4086  * given to the selected callback.
4087  *
4088  * @until }
4089  *
4090  * The rest of the code is also common to all the other examples, so it will be
4091  * omitted here (look at the full source code link above if you need it).
4092  *
4093  * You can try to play with this example, and see the selected callback being
4094  * called whenever an item is clicked. It also already has some features enabled
4095  * by default, like vertical bounce animation when reaching the end of the list,
4096  * automatically visible/invisible scrollbar, etc. Look at the @ref
4097  * genlist_example_02 to see an example of setting these properties to the list.
4098  *
4099  * The current example will look like this when running:
4100  *
4101  * @image html screenshots/genlist_example_01.png
4102  * @image latex screenshots/genlistexample_01.eps width=\textwidth
4103  */
4104
4105 /**
4106  * @page genlist_example_02
4107  *
4108  * This example is very similar to the @ref genlist_example_01, but it fetch
4109  * most of the properties of the genlist and displays them on startup (thus
4110  * getting the default value for them) and then set them to some other values,
4111  * to show how to use that API. The full source code is at @ref
4112  * genlist_example_02_c.
4113  *
4114  * Considering that the base code for instantiating a genlist was already
4115  * described in the previous example, we are going to focus on the new code.
4116  *
4117  * Just a small difference for the @c _item_label_get function, we are going to
4118  * store the time that this function was called. This is the "realized" time,
4119  * the time when the visual representation of this item was created. This is the
4120  * code for the @c label_get function:
4121  *
4122  * @dontinclude genlist_example_02.c
4123  * @skip static char
4124  * @until return strdup
4125  *
4126  * Now let's go to the list creation and setup. First, just after creating the
4127  * list, we get most of the default properties from it, and print them on the
4128  * console:
4129  *
4130  * @skip genlist_add
4131  * @until printf("\n")
4132  *
4133  * We are going to change some of the properties of our list.
4134  *
4135  * There's no need to call the selected callback at every click, just when the
4136  * selected item changes, thus we call elm_genlist_always_select_mode_set() with
4137  * false.
4138  *
4139  * For this list we don't want bounce animations at all, so we set both the
4140  * horizontal bounce and the vertical bounce to false with
4141  * elm_genlist_bounce_set().
4142  *
4143  * We also want our list to compress items if they are wider than the list
4144  * width (thus we call elm_genlist_compress_mode_set().
4145  *
4146  * The items have different width, so they are not homogeneous:
4147  * elm_genlist_homogeneous_set() is set to false.
4148  *
4149  * Since the compress mode is active, the call to
4150  * elm_genlist_horizontal_mode_set() doesn't make difference, but the current
4151  * option would make the list to have at least the width of the largest item.
4152  *
4153  * This list will support multiple selection, so we call
4154  * elm_genlist_multi_select_set() on it.
4155  *
4156  * The option elm_genlist_height_for_width_mode_set() would allow text block to
4157  * wrap lines if the Edje part is configured with "text.min: 0 1", for example.
4158  * But since we are compressing the elements to the width of the list, this
4159  * option wouldn't take any effect.
4160  *
4161  * We want the vertical scrollbar to be always displayed, and the orizontal one
4162  * to never be displayed, and set this with elm_genlist_scroller_policy_set().
4163  *
4164  * The timeout to consider a longpress is set to half of a second with
4165  * elm_genlist_longpress_timeout_set().
4166  *
4167  * We also change the block count to a smaller value, but that should have not
4168  * impact on performance since the number of visible items is too small. We just
4169  * increase the granularity of the block count (setting it to have at most 4
4170  * items).
4171  *
4172  * @until block_count_set
4173  *
4174  * Now let's add elements to the list:
4175  *
4176  * @until item_append
4177  * @until }
4178  *
4179  * It's exactly the same as the previous example. The difference is on the
4180  * behavior of the list, if you try to scroll, select items and so.
4181  *
4182  * In this example we also need two buttons. One of them, when clicked, will
4183  * display several status info about the current selection, the "realized"
4184  * items, the item in the middle of the screen, and the current mode and active
4185  * item of that mode for the genlist.
4186  *
4187  * The other button will ask the genlist to "realize" again the items already
4188  * "realized", so their respective label_get and icon_get functions will be
4189  * called again.
4190  *
4191  * These are the callbacks for both of these buttons:
4192  *
4193  * @dontinclude genlist_example_02.c
4194  * @skip item_sel_cb
4195  * @skip static
4196  * @until }
4197  * @until }
4198  *
4199  * Try to scroll, select some items and click on the "Show status" button.
4200  * You'll notice that not all items of the list are "realized", thus consuming
4201  * just a small amount of memory. The selected items are listed in the order
4202  * that they were selected, and the current selected item printed using
4203  * elm_genlist_selected_item_get() is the first selected item of the multiple
4204  * selection.
4205  *
4206  * Now resize the window so that you can see the "realized time" of some items.
4207  * This is the time of when the label_get function was called. If you click on
4208  * the "Realize" button, all the already realized items will be rebuilt, so the
4209  * time will be updated for all of them.
4210  *
4211  * The current example will look like this when running:
4212  *
4213  * @image html screenshots/genlist_example_02.png
4214  * @image latex screenshots/genlistexample_02.eps width=\textwidth
4215  */
4216
4217 /**
4218  * @page progressbar_example Progress bar widget example
4219  *
4220  * This application is a thorough example of the progress bar widget,
4221  * consisting of a window with varios progress bars, each with a given
4222  * look/style one can give to those widgets. With two auxiliary
4223  * buttons, one can start or stop a timer which will fill in the bars
4224  * in synchrony, simulating an underlying task being completed.
4225  *
4226  * We create @b seven progress bars, being three of them horizontal,
4227  * three vertical and a final one under the "wheel" alternate style.
4228  *
4229  * For the first one, we add a progress bar on total pristine state,
4230  * with no other call than the elm_progressbar_add() one:
4231  * @dontinclude progressbar_example.c
4232  * @skip pb with no label
4233  * @until pb1
4234  * See, than, that the defaults of a progress bar are:
4235  * - no primary label shown,
4236  * - unit label set to @c "%.0f %%",
4237  * - no icon set
4238  *
4239  * The second progress bar is given a primary label, <c>"Infinite
4240  * bounce"</c>, and, besides, it's set to @b pulse. See how, after one
4241  * starts the progress timer, with the "Start" button, it animates
4242  * differently than the previous one. It won't account for the
4243  * progress, itself, and just dumbly animate a small bar within its
4244  * bar region.
4245  * @dontinclude progressbar_example.c
4246  * @skip pb with label
4247  * @until pb2
4248  *
4249  * Next, comes a progress bar with an @b icon, a primary label and a
4250  * @b custom unit label set. It's also made to grow its bar in an
4251  * @b inverted manner, so check that out during the timer's progression:
4252  * @dontinclude progressbar_example.c
4253  * @skip ic1 =
4254  * @until pb3
4255  * Another important thing in this one is the call to
4256  * elm_progressbar_span_size_set() -- this is how we forcefully set a
4257  * minimum horizontal size to our whole window! We're not resizing it
4258  * manually, as you can see in the @ref progressbar_example_c
4259  * "complete code".
4260  *
4261  * The next three progress bars are just variants on the ones already
4262  * shown, but now all being @b vertical. Another time we use one of
4263  * than to give the window a minimum vertical size, with
4264  * elm_progressbar_span_size_set().  To demonstrate this trick once
4265  * more, the fifth one, which is also set to pulse, has a smaller
4266  * hardcoded span size:
4267  * @dontinclude progressbar_example.c
4268  * @skip vertical pb, with pulse
4269  * @until pb5
4270  *
4271  * We end the widget demonstration by showing a progress bar with the
4272  * special @b "wheel" progress bar style. One does @b not need to set
4273  * it to pulse, with elm_progressbar_pulse_set(), explicitly, because
4274  * its theme does not take it in account:
4275  * @dontinclude progressbar_example.c
4276  * @skip "wheel"
4277  * @until pb7
4278  *
4279  * The two buttons exercising the bars, the facto, follow:
4280  * @dontinclude progressbar_example.c
4281  * @skip elm_button_add
4282  * @until evas_object_show(bt)
4283  * @until evas_object_show(bt)
4284  *
4285  * The first of the callbacks will, for the progress bars set to
4286  * pulse, start the pulsing animation at that time. For the others, a
4287  * timer callback will take care of updating the values:
4288  * @dontinclude progressbar_example.c
4289  * @skip static Eina_Bool
4290  * @until }
4291  * @until }
4292  * @until }
4293  *
4294  * Finally, the callback to stop the progress timer will stop the
4295  * pulsing on the pulsing progress bars and, for the others, to delete
4296  * the timer which was acting on their values:
4297  * @dontinclude progressbar_example.c
4298  * @skip end of show
4299  * @until }
4300  * @until }
4301  *
4302  * This is how the example program's window looks like:
4303  * @image html screenshots/progressbar_example.png
4304  * @image latex screenshots/progressbar_example.eps width=\textwidth
4305  *
4306  * See the full @ref progressbar_example_c "source code" for
4307  * this example.
4308  *
4309  * @example progressbar_example.c
4310  */
4311
4312 /**
4313  * @page tutorial_notify Notify example
4314  * @dontinclude notify_example_01.c
4315  *
4316  * In this example we will have 3 notifys in 3 different positions. The first of
4317  * which will dissapear after 5 seconds or when a click outside it occurs, the
4318  * second and third will not dissapear and differ from each other only in
4319  * position.
4320  *
4321  * We start our example with the usual stuff you've seen in other examples:
4322  * @until show(bx)
4323  *
4324  * We now create a label to use as the content of our first notify:
4325  * @until show
4326  *
4327  * Having the label we move to creating our notify, telling it to block events,
4328  * setting its timeout(to autohide it):
4329  * @until pack_end
4330  *
4331  * To have the notify dissapear when a click outside its area occur we have to
4332  * listen to its "block,clicked" signal:
4333  * @until smart_callback
4334  *
4335  * Our callback will look like this:
4336  * @skip static
4337  * @until }
4338  * @dontinclude notify_example_01.c
4339  *
4340  * Next we create another label and another notify. Note, however, that this
4341  * time we don't set a timeout and don't have it block events. What we do is set
4342  * the orient so that this notify will appear in the bottom of its parent:
4343  * @skip smart_callback
4344  * @skip content
4345  * @until pack_end
4346  *
4347  * For our third notify the only change is the orient which is now center:
4348  * @until pack_end
4349  *
4350  * Now we tell the main loop to run:
4351  * @until ELM_MAIN
4352  *
4353  * Our example will initially look like this:
4354  *
4355  * @image html screenshots/notify_example_01.png
4356  * @image latex screenshots/notify_example_01.eps width=\textwidth
4357  *
4358  * Once the first notify is hidden:
4359  *
4360  * @image html screenshots/notify_example_01_a.png
4361  * @image latex screenshots/notify_example_01_a.eps width=\textwidth
4362  *
4363  * @example notify_example_01.c
4364  */
4365
4366 /**
4367  * @page tutorial_frame Frame example
4368  * @dontinclude frame_example_01.c
4369  *
4370  * In this example we are going to create 4 Frames with different styles and
4371  * add a rectangle of different color in each.
4372  *
4373  * We start we the usual setup code:
4374  * @until show(bg)
4375  *
4376  * And then create one rectangle:
4377  * @until show
4378  *
4379  * To add it in our first frame, which since it doesn't have it's style
4380  * specifically set uses the default style:
4381  * @until show
4382  *
4383  * And then create another rectangle:
4384  * @until show
4385  *
4386  * To add it in our second frame, which uses the "pad_small" style, note that
4387  * even tough we are setting a text for this frame it won't be show, only the
4388  * default style shows the Frame's title:
4389  * @until show
4390  * @note The "pad_small", "pad_medium", "pad_large" and "pad_huge" styles are
4391  * very similar, their only difference is the size of the empty area around
4392  * the content of the frame.
4393  *
4394  * And then create yet another rectangle:
4395  * @until show
4396  *
4397  * To add it in our third frame, which uses the "outdent_top" style, note
4398  * that even tough we are setting a text for this frame it won't be show,
4399  * only the default style shows the Frame's title:
4400  * @until show
4401  *
4402  * And then create one last rectangle:
4403  * @until show
4404  *
4405  * To add it in our fourth and final frame, which uses the "outdent_bottom"
4406  * style, note that even tough we are setting a text for this frame it won't
4407  * be show, only the default style shows the Frame's title:
4408  * @until show
4409  *
4410  * And now we are left with just some more setup code:
4411  * @until ELM_MAIN()
4412  *
4413  * Our example will look like this:
4414  *
4415  * @image html screenshots/frame_example_01.png
4416  * @image latex screenshots/frame_example_01.eps width=\textwidth
4417  *
4418  * @example frame_example_01.c
4419  */
4420
4421 /**
4422  * @page tutorial_anchorblock_example Anchorblock/Anchorview example
4423  * This example will show both Anchorblock and @ref Anchorview,
4424  * since both are very similar and it's easier to show them once and side
4425  * by side, so the difference is more clear.
4426  *
4427  * We'll show the relevant snippets of the code here, but the full example
4428  * can be found here... sorry, @ref anchorblock_example_01.c "here".
4429  *
4430  * As for the actual example, it's just a simple window with an anchorblock
4431  * and an anchorview, both containing the same text. After including
4432  * Elementary.h and declaring some functions we'll need, we jump to our
4433  * elm_main (see ELM_MAIN) and create our window.
4434  * @dontinclude anchorblock_example_01.c
4435  * @skip int
4436  * @until const char
4437  * @until ;
4438  *
4439  * With the needed variables declared, we'll create the window and a box to
4440  * hold our widgets, but we don't need to go through that here.
4441  *
4442  * In order to make clear where the anchorblock ends and the anchorview
4443  * begins, they'll be each inside a @ref Frame. After creating the frame,
4444  * the anchorblock follows.
4445  * @skip elm_frame_add
4446  * @until elm_frame_content_set
4447  *
4448  * Nothing out of the ordinary there. What's worth mentioning is the call
4449  * to elm_anchorblock_hover_parent_set(). We are telling our widget that
4450  * when an anchor is clicked, the hover for the popup will cover the entire
4451  * window. This affects the area that will be obscured by the hover and
4452  * where clicking will dismiss it, as well as the calculations it does to
4453  * inform the best locations where to insert the popups content.
4454  * Other than that, the code is pretty standard. We also need to set our
4455  * callback for when an anchor is clicked, since it's our task to populate
4456  * the popup. There's no default for it.
4457  *
4458  * The anchorview is no different, we only change a few things so it looks
4459  * different.
4460  * @until elm_frame_content_set
4461  *
4462  * Then we run, so stuff works and close our main function in the usual way.
4463  * @until ELM_MAIN
4464  *
4465  * Now, a little note. Normally you would use either one of anchorblock or
4466  * anchorview, set your one callback to clicks and do your stuff in there.
4467  * In this example, however, there are a few tricks to make it easier to
4468  * show both widgets in one go (and to save me some typing). So we have
4469  * two callbacks, one per widget, that will call a common function to do
4470  * the rest. The trick is using ::Elm_Entry_Anchorblock_Info for the
4471  * anchorview too, since both are equal, and passing a callback to use
4472  * for our buttons to end the hover, because each widget has a different
4473  * function for it.
4474  * @until _anchorview_clicked_cb
4475  * @until }
4476  *
4477  * The meat of our popup is in the following function. We check what kind
4478  * of menu we need to show, based on the name set to the anchor in the
4479  * markup text. If there's no type (something went wrong, no valid contact
4480  * in the address list) we are just putting a button that does nothing, but
4481  * it's perfectly reasonable to just end the hover and call it quits.
4482  *
4483  * Our popup will consist of one main button in the middle of our hover,
4484  * and possibly a secondary button and a list of other options. We'll create
4485  * first our main button and check what kind of popup we need afterwards.
4486  * @skip static void
4487  * @skip static void
4488  * @until eina_stringshare_add
4489  * @until }
4490  *
4491  * Each button has two callbacks, one is our hack to close the hover
4492  * properly based on which widget it belongs to, the other a simple
4493  * printf that will show the action with the anchors own data. This is
4494  * not how you would usually do it. Instead, the common case is to have
4495  * one callback for the button that will know which function to call to end
4496  * things, but since we are doing it this way it's worth noting that
4497  * smart callbacks will be called in reverse in respect to the order they
4498  * were added, and since our @c btn_end_cb will close the hover, and thus
4499  * delete our buttons, the other callback wouldn't be called if we had
4500  * added it before.
4501  *
4502  * After our telephone popup, there are a few others that are practically
4503  * the same, so they won't be shown here.
4504  *
4505  * Once we are done with that, it's time to place our actions into our
4506  * hover. Main button goes in the middle without much questioning, and then
4507  * we see if we have a secondary button and a box of extra options.
4508  * Because I said so, secondary button goes on either side and box of
4509  * options either on top or below the main one, but to choose which
4510  * exactly, we use the hints our callback info has, which saves us from
4511  * having to do the math and see which side has more space available, with
4512  * a little special case where we delete our extra stuff if there's nowhere
4513  * to place it.
4514  * @skip url:
4515  * @skip }
4516  * @skip evas_object_smart
4517  * @until evas_object_del(box)
4518  * @until }
4519  * @until }
4520  *
4521  * The example will look like this:
4522  *
4523  * @image html screenshots/anchorblock_01.png
4524  * @image latex screenshots/anchorblock_01.eps width=\textwidth
4525  *
4526  * @example anchorblock_example_01.c
4527  */
4528
4529 /**
4530  * @page tutorial_check Check example
4531  * @dontinclude check_example_01.c
4532  *
4533  * This example will show 2 checkboxes, one with just a label and the second
4534  * one with both a label and an icon. This example also ilustrates how to
4535  * have the checkbox change the value of a variable and how to react to those
4536  * changes.
4537  *
4538  * We will start with the usual setup code:
4539  * @until show(bg)
4540  *
4541  * And now we create our first checkbox, set its label, tell it to change
4542  * the value of @p value when the checkbox stats is changed and ask to be
4543  * notified of state changes:
4544  * @until show
4545  *
4546  * For our second checkbox we are going to set an icon so we need to create
4547  * and icon:
4548  * @until show
4549  * @note For simplicity we are using a rectangle as icon, but any evas object
4550  * can be used.
4551  *
4552  * And for our second checkbox we set the label, icon and state to true:
4553  * @until show
4554  *
4555  * We now do some more setup:
4556  * @until ELM_MAIN
4557  *
4558  * And finally implement the callback that will be called when the first
4559  * checkbox's state changes. This callback will use @p data to print a
4560  * message:
4561  * @until }
4562  * @note This work because @p data is @p value(from the main function) and @p
4563  * value is changed when the checkbox is changed.
4564  *
4565  * Our example will look like this:
4566  *
4567  * @image html screenshots/check_example_01.png
4568  * @image latex screenshots/check_example_01.eps width=\textwidth
4569  *
4570  * @example check_example_01.c
4571  */
4572
4573 /**
4574  * @page tutorial_colorselector Color selector example
4575  * @dontinclude colorselector_example_01.c
4576  *
4577  * This example shows how to change the color of a rectangle using a color
4578  * selector. We aren't going to explain a lot of the code since it's the
4579  * usual setup code:
4580  * @until show(rect)
4581  *
4582  * Now that we have a window with background and a rectangle we can create
4583  * our color_selector and set it's initial color to fully opaque blue:
4584  * @until show
4585  *
4586  * Next we tell ask to be notified whenever the color changes:
4587  * @until changed
4588  *
4589  * We follow that we some more run of the mill setup code:
4590  * @until ELM_MAIN()
4591  *
4592  * And now get to the callback that sets the color of the rectangle:
4593  * @until }
4594  *
4595  * This example will look like this:
4596  *
4597  * @image html screenshots/colorselector_example_01.png
4598  * @image latex screenshots/colorselector_example_01.eps width=\textwidth
4599  *
4600  * @example colorselector_example_01.c
4601  */
4602
4603 /**
4604  * @page slideshow_example Slideshow widget example
4605  *
4606  * This application is aimed to exemplify the slideshow widget. It
4607  * consists of a window with a slideshow widget set as "resize
4608  * object", along with a control bar, in the form of a notify. Those
4609  * controls will exercise most of the slideshow's API functions.
4610  *
4611  * We create the slideshow, itself, first, making it @b loop on its
4612  * image itens, when in slideshow mode:
4613  * @dontinclude slideshow_example.c
4614  * @skip slideshow = elm_slideshow_add
4615  * @until evas_object_show
4616  *
4617  * Next, we define the <b>item class</b> for our slideshow
4618  * items. Slideshow images are going to be Elementary @ref Photo "photo"
4619  * widgets, here, as pointed by our @c get class
4620  * function. We'll let the Elementary infrastructure to delete those
4621  * objects for us, and, as there's no additional data attached to our
4622  * slideshow items, the @c del class function can be left undefined:
4623  * @dontinclude slideshow_example.c
4624  * @skip itc
4625  * @until ;
4626  * @dontinclude slideshow_example.c
4627  * @skip itc.func
4628  * @until = NULL
4629  * @dontinclude slideshow_example.c
4630  * @skip get our images to make slideshow items
4631  * @until }
4632  *
4633  * We now get to populate the slideshow widget with items. Our images
4634  * are going to be some randomly chosen from the Elementary package,
4635  * nine of them. For the first eight, we insert them ordered in the
4636  * widget, by using elm_slideshow_item_sorted_insert(). The comparing
4637  * function will use the image names to sort items. The last item is
4638  * inserted at the end of the slideshow's items list, with
4639  * elm_slideshow_item_add(). We check out how that list ends with
4640  * elm_slideshow_items_get(), than:
4641  * @dontinclude slideshow_example.c
4642  * @skip static const char *img
4643  * @until _2
4644  * @dontinclude slideshow_example.c
4645  * @skip first =
4646  * @until data_get
4647  *
4648  * Note that we save the pointers to the first and last items in the
4649  * slideshow, for future use.
4650  *
4651  * What follows is the code creating a notify, to be shown over the
4652  * slideshow's viewport, with knobs to act on it. We're not showing
4653  * that boilerplate code, but only the callbacks attached to the
4654  * interesting smart events of those knobs. The first four are
4655  * buttons, which will:
4656  * - Select the @b next item in the slideshow
4657  * - Select the @b previous item in the slideshow
4658  * - Select the @b first item in the slideshow
4659  * - Select the @b last item in the slideshow
4660  *
4661  * Check out the code for those four actions, being the two last @c
4662  * data pointers the same @c first and @c last pointers we save
4663  * before, respectively:
4664  * @dontinclude slideshow_example.c
4665  * @skip jump to next
4666  * @until }
4667  * @until }
4668  * @until }
4669  * @until }
4670  *
4671  * What follow are two hoversels, meant for one to change the
4672  * slideshow's @b transition and @b layout styles, respectively. We
4673  * fetch all the available transition and layout names to populate
4674  * those widgets and, when one selects any of them, we apply the
4675  * corresponding setters on the slideshow:
4676  * @dontinclude slideshow_example.c
4677  * @skip hv = elm_hoversel_add
4678  * @until show(hv)
4679  * @until show(hv)
4680  * @dontinclude slideshow_example.c
4681  * @skip transition changed
4682  * @until }
4683  * @until }
4684  *
4685  * For one to change the transition @b time on the slideshow widget,
4686  * we use a spinner widget. We set it to the initial value of 3
4687  * (seconds), which will be probed by the next knob -- a button
4688  * starting the slideshow, de facto. Note that changing the transition
4689  * time while a slideshow is already happening will ajust its
4690  * transition time:
4691  * @dontinclude slideshow_example.c
4692  * @skip spin = elm_spinner_add
4693  * @until evas_object_show
4694  * @dontinclude slideshow_example.c
4695  * @skip slideshow transition time has
4696  * @until }
4697  *
4698  * Finally, we have two buttons which will, respectively, start and
4699  * stop the slideshow on our widget. Here are their "clicked"
4700  * callbacks:
4701  * @dontinclude slideshow_example.c
4702  * @skip start the show
4703  * @until }
4704  * @until }
4705  *
4706  * This is how the example program's window looks like:
4707  * @image html screenshots/slideshow_example.png
4708  * @image latex screenshots/slideshow_example.eps width=\textwidth
4709  *
4710  * See the full @ref slideshow_example_c "source code" for
4711  * this example.
4712  *
4713  * @example slideshow_example.c
4714  */
4715
4716 /**
4717  * @page bg_example_01_c bg_example_01.c
4718  * @include bg_example_01.c
4719  * @example bg_example_01.c
4720  */
4721
4722 /**
4723  * @page bg_example_02_c bg_example_02.c
4724  * @include bg_example_02.c
4725  * @example bg_example_02.c
4726  */
4727
4728 /**
4729  * @page bg_example_03_c bg_example_03.c
4730  * @include bg_example_03.c
4731  * @example bg_example_03.c
4732  */
4733
4734 /**
4735  * @page actionslider_example_01 Actionslider example
4736  * @include actionslider_example_01.c
4737  * @example actionslider_example_01.c
4738  */
4739
4740 /**
4741  * @page animator_example_01_c Animator example 01
4742  * @include animator_example_01.c
4743  * @example animator_example_01.c
4744  */
4745
4746 /**
4747  * @page transit_example_01_c Transit example 1
4748  * @include transit_example_01.c
4749  * @example transit_example_01.c
4750  */
4751
4752 /**
4753  * @page transit_example_02_c Transit example 2
4754  * @include transit_example_02.c
4755  * @example transit_example_02.c
4756  */
4757
4758 /**
4759  * @page general_functions_example_c General (top-level) functions example
4760  * @include general_funcs_example.c
4761  * @example general_funcs_example.c
4762  */
4763
4764 /**
4765  * @page clock_example_c Clock example
4766  * @include clock_example.c
4767  * @example clock_example.c
4768  */
4769
4770 /**
4771  * @page flipselector_example_c Flipselector example
4772  * @include flipselector_example.c
4773  * @example flipselector_example.c
4774  */
4775
4776 /**
4777  * @page fileselector_example_c Fileselector example
4778  * @include fileselector_example.c
4779  * @example fileselector_example.c
4780  */
4781
4782 /**
4783  * @page fileselector_button_example_c Fileselector button example
4784  * @include fileselector_button_example.c
4785  * @example fileselector_button_example.c
4786  */
4787
4788 /**
4789  * @page fileselector_entry_example_c Fileselector entry example
4790  * @include fileselector_entry_example.c
4791  * @example fileselector_entry_example.c
4792  */
4793
4794 /**
4795  * @page index_example_01_c Index example
4796  * @include index_example_01.c
4797  * @example index_example_01.c
4798  */
4799
4800 /**
4801  * @page index_example_02_c Index example
4802  * @include index_example_02.c
4803  * @example index_example_02.c
4804  */
4805
4806 /**
4807  * @page layout_example_01_c layout_example_01.c
4808  * @include layout_example_01.c
4809  * @example layout_example_01.c
4810  */
4811
4812 /**
4813  * @page layout_example_02_c layout_example_02.c
4814  * @include layout_example_02.c
4815  * @example layout_example_02.c
4816  */
4817
4818 /**
4819  * @page layout_example_03_c layout_example_03.c
4820  * @include layout_example_03.c
4821  * @example layout_example_03.c
4822  */
4823
4824 /**
4825  * @page layout_example_edc An example of layout theme file
4826  *
4827  * This theme file contains two groups. Each of them is a different theme, and
4828  * can be used by an Elementary Layout widget. A theme can be used more than
4829  * once by many different Elementary Layout widgets too.
4830  *
4831  * @include layout_example.edc
4832  * @example layout_example.edc
4833
4834 /**
4835  * @page gengrid_example_c Gengrid example
4836  * @include gengrid_example.c
4837  * @example gengrid_example.c
4838  */
4839
4840 /**
4841  * @page genlist_example_01_c genlist_example_01.c
4842  * @include genlist_example_01.c
4843  * @example genlist_example_01.c
4844  */
4845
4846 /**
4847  * @page genlist_example_02_c genlist_example_02.c
4848  * @include genlist_example_02.c
4849  * @example genlist_example_02.c
4850  */
4851
4852 /**
4853  * @page progressbar_example_c Progress bar example
4854  * @include progressbar_example.c
4855  * @example progressbar_example.c
4856  */
4857
4858 /**
4859  * @page slideshow_example_c Slideshow example
4860  * @include slideshow_example.c
4861  * @example slideshow_example.c
4862  */