2 * @page Examples Examples
4 * Here is a page with Elementary examples.
6 * @ref bg_01_example_page
8 * @ref bg_02_example_page
10 * @ref bg_03_example_page
12 * @ref actionslider_example_page
14 * @ref elm_animator_example_page_01
16 * @ref transit_example_01_explained
18 * @ref transit_example_02_explained
20 * @ref general_functions_example_page
22 * @ref calendar_example_01
24 * @ref calendar_example_02
26 * @ref calendar_example_03
28 * @ref calendar_example_04
30 * @ref calendar_example_05
32 * @ref calendar_example_06
34 * @ref spinner_example
42 * @ref diskselector_example_01
44 * @ref diskselector_example_02
46 * @ref list_example_01
48 * @ref list_example_02
50 * @ref list_example_03
52 * @ref segment_control_example
54 * @ref flipselector_example
56 * @ref fileselector_example
58 * @ref fileselector_button_example
60 * @ref fileselector_entry_example
62 * @ref index_example_01
64 * @ref index_example_02
66 * @ref gengrid_example
68 * @ref genlist_example_01
70 * @ref genlist_example_02
72 * @ref genlist_example_04
74 * @ref genlist_example_05
76 * @ref progressbar_example
78 * @ref slideshow_example
82 * @page bg_01_example_page elm_bg - Plain color background.
83 * @dontinclude bg_example_01.c
85 * The full code for this example can be found at @ref bg_example_01_c,
86 * in the function @c test_bg_plain. It's part of the @c elementar_test
87 * suite, and thus has the code for the three examples referenced by this
90 * This first example just sets a default background with a plain color. The
91 * first part consists of creating an Elementary window. It's the common
92 * piece of code that you'll see everywhere in Elementary: @skip elm_main
95 * Now we really create our background object, using the window object as
100 * Then we set the size hints of the background object so that it will use
101 * all space available for it, and then add it as a resize object to the
102 * window, making it visible in the end:
104 * @skip size_hint_weight_set
105 * @until resize_object_add
107 * See @ref evas_object_size_hint_weight_set and elm_win_resize_object_add()
108 * for more detailed info about these functions.
110 * The end of the example is quite simple, just setting the minimum and
111 * maximum size of the background, so the Elementary window knows that it
112 * has to have at least the minimum size. The background also won't scale to
113 * a size above its maximum. Then we resize the window and show it in the
116 * @skip set size hints
119 * And here we finish our very simple background object usage example.
123 * @page bg_02_example_page elm_bg - Image background.
124 * @dontinclude bg_example_02.c
126 * The full code for this example can be found at @ref bg_example_02_c,
127 * in the function @c test_bg_image. It's part of the @c elementar_test
128 * suite, and thus has the code for the three examples referenced by this
131 * This is the second example, and shows how to use the Elementary
132 * background object to set an image as background of your application.
134 * We start this example exactly in the same way as the previous one, even
135 * when creating the background object:
140 * Now it's the different part.
142 * Our background will have an image, that will be displayed over the
143 * background color. Before loading the image, we set the load size of the
144 * image. The load size is a hint about the size that we want the image
145 * displayed in the screen. It's not the exact size that the image will have,
146 * but usually a bit bigger. The background object can still be scaled to a
147 * size bigger than the one set here. Setting the image load size to
148 * something smaller than its real size will reduce the memory used to keep
149 * the pixmap representation of the image, and the time to load it. Here we
150 * set the load size to 20x20 pixels, but the image is loaded with a size
151 * bigger than that (since it's just a hint):
153 * @skipline load_size_set
155 * And set our background image to be centered, instead of stretched or
156 * scaled, so the effect of the elm_bg_load_size_set() can be easily
159 * @skipline option_set
161 * We need a filename to set, so we get one from the previous installed
162 * images in the @c PACKAGE_DATA_DIR, and write its full path to a buffer.
163 * Then we use this buffer to set the filename in the background object:
168 * Notice that the third argument of the elm_bg_file_set() function is @c
169 * NULL, since we are setting an image to this background. This function
170 * also supports setting an edje group as background, in which case the @c
171 * group parameter wouldn't be @c NULL, but be the name of the group
174 * Finally, we can set the size hints, add the background as a resize
175 * object, and resize the window, exactly the same thing we do in the @ref
176 * bg_01_example_page example:
181 * And this is the end of this example.
183 * This example will look like this:
185 * @image html screenshots/bg_01.png
186 * @image latex screenshots/bg_01.eps width=\textwidth
190 * @page bg_03_example_page elm_bg - Background properties.
191 * @dontinclude bg_example_03.c
193 * The full code for this example can be found at @ref bg_example_03_c, in the
194 * function @c test_bg_options, with the callbacks @c _cb_overlay_changed, @c
195 * _cb_color_changed and @c _cb_radio_changed defined in the beginning of the
196 * file. It's part of the @c elementar_test suite, and thus has the code for
197 * the three examples referenced by this documentation.
199 * This example will show the properties available for the background object,
200 * and will use of some more widgets to set them.
202 * In order to do this, we will set some callbacks for these widgets. The
203 * first is for the radio buttons that will be used to choose the option
204 * passed as argument to elm_bg_option_set():
206 * @skip _cb_radio_changed
209 * The next callback will be used when setting the overlay (using
210 * elm_bg_overlay_set()):
212 * @skip _cb_overlay_changed
216 * And the last one, used to set the color (with elm_bg_color_set()):
218 * @skip _cb_color_changed
221 * We will get back to what these functions do soon. If you want to know more
222 * about how to set these callbacks and what these widgets are, look for:
223 * @li elm_radio_add()
224 * @li elm_check_add()
225 * @li elm_spinner_add()
227 * Now going to the main function, @c test_bg_options, we have the common
228 * code with the other examples:
233 * We add a plain background to this window, so it will have the default
234 * background color behind everything:
236 * @skip bg = elm_bg_add
237 * @until evas_object_show(bg)
239 * Then we add a vertical box (elm_box_add()) that will hold the background
240 * object that we are going to play with, as well as a horizontal box that
244 * @until evas_object_show
246 * Now we add the background object that is going to be of use for our
247 * example. It is an image background, as used in @ref bg_02_example_page ,
248 * so the code should be familiar:
251 * @until evas_object_show
253 * Notice the call to elm_box_pack_end(): it will pack the background object
254 * in the end of the Elementary box declared above. Just refer to that
255 * documentation for more info.
257 * Since this Elementary background is already an image background, we are
258 * going to play with its other properties. We will change its option
259 * (CENTER, SCALE, STRETCH, TILE), its color (RGB), and add an overlay to it.
260 * For all of these properties, we are going to add widgets that will
263 * First, lets add the horizontal box that will hold these widgets:
267 * For now, just consider this @c hbox as a rectangle that will contain the
268 * widgets, and will distribute them horizontally inside its content. Then we
269 * add radio buttons that will allow us to choose the property to use with
273 * @until evas_object_show
275 * Again, I won't give details about the use of these widgets, just look for
276 * their documentation if necessary. It's enough to know for now that we are
277 * packing them in the @c hbox, setting a label for them, and the most
278 * important parts: setting its value to @c ELM_BG_OPTION_CENTER and its
279 * callback to @c _cb_radio_changed (the function defined in the beginning of
280 * this example). We do this for the next 3 radio buttons added after this
281 * one, each of them with a different value.
283 * Now taking a look at the code of the callback @c _cb_radio_changed again,
284 * it will call elm_bg_option_set() with the value set from the checked radio
285 * button, thus setting the option for this background. The background is
286 * passed as argument to the @p data parameter of this callback, and is
287 * referenced here as @c o_bg.
289 * Later we set the default value for this radio button:
291 * @skipline elm_radio_value_set
293 * Then we add a checkbox for the elm_bg_overlay_set() function:
296 * @until evas_object_show
298 * Now look at the code of the @c _cb_overlay_changed again. If the checkbox
299 * state is checked, an overlay will be added to the background. It's done by
300 * creating an Edje object, and setting it with elm_bg_overlay_set() to the
301 * background object. For information about what are and how to set Edje
302 * object, look at the Edje documentation.
304 * Finally we add a spinner object (elm_spinner_add()) to be used to select
305 * the color of our background. In its callback it's possible to see the call
306 * to elm_bg_color_set(), which will change the color of this background.
307 * This color is used by the background to fill areas where the image doesn't
308 * cover (in this case, where we have an image background). The spinner is
309 * also packed into the @c hbox :
311 * @skip elm_spinner_add
312 * @until evas_object_show
314 * Then we just have to pack the @c hbox inside the @c box, set some size
315 * hints, and show our window:
320 * Now to see this code in action, open elementary_test, and go to the "Bg
321 * Options" test. It should demonstrate what was implemented here.
325 * @page actionslider_example_page Actionslider usage
326 * @dontinclude actionslider_example_01.c
328 * For this example we are going to assume knowledge of evas smart callbacks
329 * and some basic evas object functions. Elementary is not meant to be used
330 * without evas, if you're not yet familiar with evas it probably is worth
333 * And now to the example, when using Elementary we start by including
337 * Next we define some callbacks, they all share the same signature because
338 * they are all to be used with evas_object_smart_callback_add().
339 * The first one just prints the selected label(in two different ways):
342 * This next callback is a little more interesting, it makes the selected
343 * label magnetic(except if it's the center label):
346 * This callback enables or disables the magnetic propertty of the center
350 * And finally a callback to stop the main loop when the window is closed:
353 * To be able to create our actionsliders we need to do some setup, but this
354 * isn't really relevant here, so if you want to know about that go @ref
357 * With all that boring stuff out of the way we can proceed to creating some
359 * All actionsliders are created the same way:
360 * @skipline actionslider_add
361 * Next we must choose where the indicator starts, and for this one we choose
362 * the right, and set the right as magnetic:
363 * @skipline indicator_pos_set
364 * @until magnet_pos_set
366 * We then set the labels for the left and right, passing NULL as an argument
367 * to any of the labels makes that position have no label.
370 * Furthermore we mark both left and right as enabled positions, if we didn't
371 * do this all three positions would be enabled:
374 * Having the the enabled positions we now add a smart callback to change
375 * which position is magnetic, so that only the last selected position is
379 * And finally we set our printing callback and show the actionslider:
383 * For our next actionslider we are going to do much as we did for the
384 * previous except we are going to have the center as the magnet(and not
386 * @skipline actionslider_add
387 * @skipline indicator_pos_set
390 * And another actionslider, in this one the indicator starts on the left.
391 * It has labels only in the center and right, and both bositions are
392 * magnetic. Because the left doesn't have a label and is not magnetic once
393 * the indicator leaves it can't return:
394 * @skipline actionslider_add
395 * @skipline indicator_pos_set
397 * @note The greyed out area is a @ref Styles "style".
399 * And now an actionslider with a label in the indicator, and whose magnet
400 * properties change based on what was last selected:
401 * @skipline actionslider_add
402 * @skipline indicator_pos_set
404 * @note The greyed out area is a @ref Styles "style".
406 * We are almost done, this next one is just an actionslider with all
407 * positions magnetized and having every possible label:
408 * @skipline actionslider_add
409 * @skipline indicator_pos_set
412 * And for our last actionslider we have one that turns the magnetic property
414 * @skipline actionslider_add
415 * @skipline indicator_pos_set
418 * The example will look like this:
420 * @image html screenshots/actionslider_01.png
421 * @image latex screenshots/actionslider_01.eps width=\textwidth
423 * See the full source code @ref actionslider_example_01 "here"
427 * @page elm_animator_example_page_01 Animator usage
428 * @dontinclude animator_example_01.c
430 * For this example we will be using a bit of evas, you could animate a
431 * elementary widget in much the same way, but to keep things simple we use
432 * an evas_object_rectangle.
434 * As every other example we start with our include and a simple callback to
435 * exit the app when the window is closed:
439 * This next callback is the one that actually creates our animation, it
440 * changes the size, position and color of a rectangle given to it in @a
444 * Next we have a callback that prints a string, nothing special:
447 * This next callback is a little more interesting, it has a state variable
448 * to know if the animation is currently paused or running, and it toogles
449 * the state of the animation accordingly:
454 * Finally we have a callback to stop the animation:
457 * As with every example we need to do a bit of setup before we can actually
458 * use an animation, but for the purposes of this example that's not relevant
459 * so let's just skip to the good stuff, creating an animator:
460 * @skipline animator_add
461 * @note Since elm_animator is not a widget we can give it a NULL parent.
463 * Now that we have an elm_animator we set it's duration to 1 second:
466 * We would also like our animation to be reversible, so:
469 * We also set our animation to repeat as many times as possible, which will
470 * mean that _end_cb will only be called after UINT_MAX * 2 seconds(UINT_MAX
471 * for the animation running forward and UNIT_MAX for the animation running
475 * To add some fun to our animation we will use the IN_OUT curve style:
478 * To actually animate anything we need an operation callback:
479 * @line operation_callback
481 * Even though we set our animation to repeat for a very long time we are
482 * going to set a end callback to it:
483 * @line completion_callback
484 * @note Notice that stoping the animation with the stop button will not make
487 * Now that we have fully set up our animator we can tell it to start
491 * There's a bit more of code that doesn't really matter to use so we skip
492 * right down to our last interesting point:
493 * @skipline animator_del
494 * @note Because we created our animator with no parent we need to delete it
497 * The example should look like this:
499 * @image html screenshots/animator_example_01.png
500 * @image latex screenshots/animator_example_01.eps width=\textwidth
502 * @image html screenshots/animator_example_02.png
503 * @image latex screenshots/animator_example_02.eps width=\textwidth
505 * @image html screenshots/animator_example_03.png
506 * @image latex screenshots/animator_example_03.eps width=\textwidth
508 * The full source code for this example can be found @ref
509 * animator_example_01_c "here"
513 * @page transit_example_03_c elm_transit - Combined effects and options.
515 * This example shows how to apply the following transition effects:
523 * It allows you to apply more than one effect at once, and also allows to
524 * set properties like event_enabled, auto_reverse, repeat_times and
527 * @include transit_example_03.c
531 * @page transit_example_04_c elm_transit - Combined effects over two objects.
533 * This example shows how to apply the transition effects:
538 * over two objects. This kind of transition effect is used to make one
539 * object disappear and another one appear on its place.
541 * You can mix more than one effect of this type on the same objects, and the
542 * transition will apply both.
544 * @include transit_example_04.c
548 * @page transit_example_01_explained elm_transit - Basic transit usage.
549 * @dontinclude transit_example_01.c
551 * The full code for this example can be found at @ref transit_example_01_c.
553 * This example shows the simplest way of creating a transition and applying
554 * it to an object. Similarly to every other elementary example, we create a
555 * window, set its title, size, autodel property, and setup a callback to
556 * exit the program when finished:
559 * @until evas_object_resize
561 * We also add a resizeable white background to use behind our animation:
564 * @until evas_object_show
566 * And then we add a button that we will use to demonstrate the effects of
570 * @until evas_object_show(win)
572 * Notice that we are not adding the button with elm_win_resize_object_add()
573 * because we don't want the window to control the size of the button. We
574 * will use the transition to change the button size, so it could conflict
575 * with something else trying to control that size.
577 * Now, the simplest code possible to create the resize animation:
582 * As you can see, this code is very easy to understand. First, we create the
583 * transition itself with elm_transit_add(). Then we add the button to this
584 * transition with elm_transit_object_add(), which means that the transition
585 * will operate over this button. The effect that we want now is changing the
586 * object size from 100x50 to 300x150, and can be achieved by adding the
587 * resize effect with elm_transit_effect_resizing_add().
589 * Finally, we set the transition time to 5 seconds and start the transition
590 * with elm_transit_go(). If we wanted more effects applied to this
591 * button, we could add them to the same transition. See the
592 * @ref transit_example_03_c to watch many transitions being applied to an
597 * @page transit_example_02_explained elm_transit - Chained transitions.
598 * @dontinclude transit_example_02.c
600 * The full code for this example can be found at @ref transit_example_02_c.
602 * This example shows how to implement a chain of transitions. This chain is
603 * used to start a transition just after another transition ended. Similarly
604 * to every other elementary example, we create a window, set its title,
605 * size, autodel property, and setup a callback to exit the program when
609 * @until evas_object_resize
611 * We also add a resizeable white background to use behind our animation:
614 * @until evas_object_show
616 * This example will have a chain of 4 transitions, each of them applied to
617 * one button. Thus we create 4 different buttons:
620 * @until evas_object_show(bt4)
622 * Now we create a simple translation transition that will be started as soon
623 * as the program loads. It will be our first transition, and the other
624 * transitions will be started just after this transition ends:
629 * The code displayed until now has nothing different from what you have
630 * already seen in @ref transit_example_01_explained, but now comes the new
631 * part: instead of creating a second transition that will start later using
632 * a timer, we create the it normally, and use
633 * elm_transit_chain_transit_add() instead of elm_transit_go. Since we are
634 * adding it in a chain after the first transition, it will start as soon as
635 * the first transition ends:
638 * @until transit_chain_transit_add
640 * Finally we add the 2 other transitions to the chain, and run our program.
641 * It will make one transition start after the other finish, and there is the
646 * @page general_functions_example_page General (top-level) functions example
647 * @dontinclude general_funcs_example.c
649 * As told in their documentation blocks, the
650 * elm_app_compile_*_dir_set() family of functions have to be called
651 * before elm_app_info_set():
652 * @skip tell elm about
653 * @until elm_app_info_set
655 * We are here setting the fallback paths to the compiling time target
656 * paths, naturally. If you're building the example out of the
657 * project's build system, we're assuming they are the canonical ones.
659 * After the program starts, elm_app_info_set() will actually run and
660 * then you'll see an intrincasy: Elementary does the prefix lookup @b
661 * twice. This is so because of the quicklaunch infrastructure in
662 * Elementary (@ref Start), which will register a predefined prefix
663 * for possible users of the launch schema. We're not hooking into a
664 * quick launch, so this first call can't be avoided.
666 * If you ran this example from your "bindir" installation
667 * directiory, no output will emerge from these both attempts -- it
668 * will find the "magic" file there registered and set the prefixes
669 * silently. Otherwise, you could get something like:
671 WARNING: Could not determine its installed prefix for 'ELM'
672 so am falling back on the compiled in default:
674 implied by the following:
677 datadir = usr/share/elementary
678 localedir = usr/share/locale
679 Try setting the following environment variables:
680 ELM_PREFIX - points to the base prefix of install
681 or the next 4 variables
682 ELM_BIN_DIR - provide a specific binary directory
683 ELM_LIB_DIR - provide a specific library directory
684 ELM_DATA_DIR - provide a specific data directory
685 ELM_LOCALE_DIR - provide a specific locale directory
687 * if you also didn't change those environment variables (remember
688 * they are also a valid way of communicating your prefix to the
689 * binary) - this is the scenario where it fallbacks to the paths set
692 * Then, you can check the prefixes set on the standard output:
693 * @skip prefix was set to
694 * @until locale directory is
697 * @skip by using this policy
698 * @until elm_win_autodel_set
699 * we demonstrate the use of Elementary policies. The policy defining
700 * under which circunstances our application should quit automatically
701 * is set to when its last window is closed (this one has just one
702 * window, though). This will save us from having to set a callback
703 * ourselves on the window, like done in @ref bg_example_01_c "this"
704 * example. Note that we need to tell the window to delete itself's
705 * object on a request to destroy the canvas coming, with
706 * elm_win_autodel_set().
708 * What follows is some boilerplate code, creating a frame with a @b
709 * button, our object of interest, and, below, widgets to change the
710 * button's behavior and exemplify the group of functions in question.
712 * @dontinclude general_funcs_example.c
713 * We enabled the focus highlight object for this window, so that you
714 * can keep track of the current focused object better:
715 * @skip elm_win_focus_highlight_enabled_set
716 * @until evas_object_show
717 * Use the tab key to navigate through the focus chain.
719 * @dontinclude general_funcs_example.c
720 * While creating the button, we exemplify how to use Elementary's
721 * finger size information to scale our UI:
722 * @skip fprintf(stdout, "Elementary
723 * @until evas_object_show
725 * @dontinclude general_funcs_example.c
726 * The first checkbox's callback is:
729 * When unsetting the checkbox, we disable the button, which will get a new
730 * decoration (greyed out) and stop receiving events. The focus chain
731 * will also ignore it.
733 * Following, there are 2 more buttons whose actions are focus/unfocus
734 * the top button, respectively:
735 * @skip focus callback
738 * @skip unfocus callback
740 * Note the situations in which they won't take effect:
741 * - the button is not allowed to get focus or
742 * - the button is disabled
744 * The first restriction above you'll get by a second checkbox, whose
746 * @skip focus allow callback
748 * Note that the button will still get mouse events, though.
750 * Next, there's a slider controlling the button's scale:
751 * @skip scaling callback
754 * Experiment with it, so you understand the effect better. If you
755 * change its value, it will mess with the button's original size,
758 * The full code for this example can be found
759 * @ref general_functions_example_c "here".
763 * @page theme_example_01 Theme - Using extensions
765 * @dontinclude theme_example_01.c
767 * Using extensions is extremely easy, discarding the part where you have to
768 * write the theme for them.
770 * In the following example we'll be creating two buttons, one to load or
771 * unload our extension theme and one to cycle around three possible styles,
772 * one of which we created.
774 * After including our one and only header we'll jump to the callback for
775 * the buttons. First one takes care of loading or unloading our extension
776 * file, relative to the default theme set (thus the @c NULL in the
777 * functions first parameter).
778 * @skipline Elementary.h
784 * The second button, as we said before, will just switch around different
785 * styles. In this case we have three of them. The first one is our custom
786 * style, named after something very unlikely to find in the default theme.
787 * The other two styles are the standard and one more, anchor, which exists
788 * in the default and is similar to the default, except the button vanishes
789 * when the mouse is not over it.
794 * So what happens if the style switches to our custom one when the
795 * extension is loaded? Elementary falls back to the default for the
798 * And the main function, simply enough, will create the window, set the
799 * buttons and their callbacks, and just to begin with our button styled
800 * we're also loading our extension at the beginning.
804 * In this case we wanted to easily remove extensions, but all adding an
805 * extension does is tell Elementary where else it should look for themes
806 * when it can't find them in the default theme. Another way to do this
807 * is to set the theme search order using elm_theme_set(), but this requires
808 * that the developer is careful not to override any user configuration.
809 * That can be helped by adding our theme to the end of whatver is already
810 * set, like in the following snippet.
813 * snprintf(buf, sizeof(buf), "%s:./theme_example.edj", elme_theme_get(NULL);
814 * elm_theme_set(NULL, buf);
817 * If we were using overlays instead of extensions, the same thing applies,
818 * but the custom theme must be added to the front of the search path.
820 * In the end, we should be looking at something like this:
822 * @image html screenshots/theme_example_01.png
823 * @image latex screenshots/theme_example_01.eps width=\textwidth
825 * That's all. Boringly simple, and the full code in one piece can be found
826 * @ref theme_example_01.c "here".
828 * And the code for our extension is @ref theme_example.edc "here".
830 * @example theme_example_01.c
831 * @example theme_example.edc
835 * @page theme_example_02 Theme - Using overlays
837 * @dontinclude theme_example_02.c
839 * Overlays are like extensions in that you tell Elementary that some other
840 * theme contains the styles you need for your program. The difference is that
841 * they will be look in first, so they can override the default style of any
844 * There's not much to say about them that hasn't been said in our previous
845 * example about @ref theme_example_01 "extensions", so going quickly through
846 * the code we have a function to load or unload the theme, which will be
847 * called when we click any button.
848 * @skipline Elementary.h
852 * And the main function, creating the window and adding some buttons to it.
853 * We load our theme as an overlay and nothing else. Notice there's no style
854 * set for any button there, which means they should be using the default
859 * That's pretty much it. The full code is @ref theme_example_02.c "here" and
860 * the definition of the theme is the same as before, and can be found in
861 * @ref theme_example.edc "here".
863 * @example theme_example_02.c
867 * @page button_example_01 Button - Complete example
869 * @dontinclude button_example_01.c
871 * A button is simple, you click on it and something happens. That said,
872 * we'll go through an example to show in detail the button API less
875 * In the end, we'll be presented with something that looks like this:
877 * @image html screenshots/button_01.png
878 * @image latex screenshots/button_01.eps width=\textwidth
880 * The full code of the example is @ref button_example_01.c "here" and we
881 * will follow here with a rundown of it.
884 * @until Elementary.h
888 * We have several buttons to set different times for the autorepeat timeouts
889 * of the buttons that use it and a few more that we keep track of in our
890 * data struct. The mid button doesn't do much, just moves around according
891 * to what other buttons the user presses. Then four more buttons to move the
892 * central one, and we're also keeping track of the icon set in the middle
893 * button, since when this one moves, we change the icon, and when movement
894 * is finished (by releasing one of the four arrow buttons), we set back the
899 * Keeping any of those four buttons pressed will trigger their autorepeat
900 * callback, where we move the button doing some size hint magic. To
901 * understand how that works better, refer to the @ref Box documentation.
902 * Also, the first time the function is called, we change the icon in the
903 * middle button, using elm_button_icon_unset() first to keep the reference
904 * to the previous one, so we don't need to recreate it when we are done
908 * @until size_hint_align_set
911 * One more callback for the option buttons, that just sets the timeouts for
912 * the different autorepeat options.
919 * And the main function, which does some setting up of the buttons in boxes
920 * to make things work. Here we'll go through some snippets only.
922 * For the option buttons, it's just the button with its label and callback.
923 * @skip elm_button_add
924 * @until smart_callback_add
926 * For the ones that move the central button, we have no labels. There are
927 * icons instead, and the autorepeat option is toggled.
929 * @skip elm_button_add
930 * @until data.cursors.up
932 * And just to show the mid button, which doesn't have anything special.
933 * @skip data.cursors.left
934 * @skip elm_button_add
939 * @example button_example_01.c
943 * @page bubble_01_example_page elm_bubble - Simple use.
944 * @dontinclude bubble_example_01.c
946 * This example shows a bubble with all fields set(label, info, content and
947 * icon) and the selected corner changing when the bubble is clicked. To be
948 * able use a bubble we need to do some setup and create a window, for this
949 * example we are going to ignore that part of the code since it isn't
950 * relevant to the bubble.
952 * To have the selected corner change in a clockwise motion we are going to
953 * use the following callback:
958 * Here we are creating an elm_label that is going to be used as the content
960 * @skipline elm_label
962 * @note You could use any evas_object for this, we are using an elm_label
965 * Despite it's name the bubble's icon doesn't have to be an icon, it can be
966 * any evas_object. For this example we are going to make the icon a simple
970 * And finally we have the actual bubble creation and the setting of it's
971 * label, info and content:
974 * @note Because we didn't set a corner, the default("top_left") will be
977 * Now that we have our bubble all that is left is connecting the "clicked"
978 * signals to our callback:
979 * @line smart_callback
981 * This last bubble we created was very complete, so it's pertinent to show
982 * that most of that stuff is optional a bubble can be created with nothing
987 * Our example will look like this:
989 * @image html screenshots/bubble_example_01.png
990 * @image latex screenshots/bubble_example_01.eps width=\textwidth
992 * See the full source code @ref bubble_example_01.c here.
993 * @example bubble_example_01.c
997 * @page box_example_01 Box - Basic API
999 * @dontinclude button_example_01.c
1001 * As a special guest tonight, we have the @ref button_example_01 "simple
1002 * button example". There are plenty of boxes in it, and to make the cursor
1003 * buttons that moved a central one around when pressed, we had to use a
1004 * variety of values for their hints.
1006 * To start, let's take a look at the handling of the central button when
1007 * we were moving it around. To achieve this effect without falling back to
1008 * a complete manual positioning of the @c Evas_Object in our canvas, we just
1009 * put it in a box and played with its alignment within it, as seen in the
1010 * following snippet of the callback for the pressed buttons.
1011 * @skip evas_object_size_hint_align_get
1012 * @until evas_object_size_hint_align_set
1014 * Not much to it. We get the current alignment of the object and change it
1015 * by just a little, depending on which button was pressed, then set it
1016 * again, making sure we stay within the 0.0-1.0 range so the button moves
1017 * inside the space it has, instead of disappearing under the other objects.
1019 * But as useful as an example as that may have been, the usual case with boxes
1020 * is to set everything at the moment they are created, like we did for
1021 * everything else in our main function.
1023 * The entire layout of our program is made with boxes. We have one set as the
1024 * resize object for the window, which means it will always be resized with
1025 * the window. The weight hints set to @c EVAS_HINT_EXPAND will tell the
1026 * window that the box can grow past it's minimum size, which allows resizing
1030 * @until evas_object_show
1032 * Two more boxes, set to horizontal, hold the buttons to change the autorepeat
1033 * configuration used by the buttons. We create each to take over all the
1034 * available space horizontally, but we don't want them to grow vertically,
1035 * so we keep that axis of the weight with 0.0. Then it gets packed in the
1038 * @until evas_object_show
1040 * The buttons in each of those boxes have nothing special, they are just packed
1041 * in with their default values and the box will use their minimum size, as set
1042 * by Elementary itself based on the label, icon, finger size and theme.
1044 * But the buttons used to move the central one have a special disposition.
1045 * The top one first, is placed right into the main box like our other smaller
1046 * boxes. Set to expand horizontally and not vertically, and in this case we
1047 * also tell it to fill that space, so it gets resized to take the entire
1048 * width of the window.
1050 * @skip elm_button_add
1051 * @until evas_object_show
1053 * The bottom one will be the same, but for the other two we need to use a
1054 * second box set to take as much space as we have, so we can place our side
1055 * buttons in place and have the big empty space where the central button will
1058 * @until evas_object_show
1060 * Then the buttons will have their hints inverted to the other top and bottom
1061 * ones, to expand and fill vertically and keep their minimum size horizontally.
1062 * @skip elm_button_add
1063 * @until evas_object_show
1065 * The central button takes every thing else. It will ask to be expanded in
1066 * both directions, but without filling its cell. Changing its alignment by
1067 * pressing the buttons will make it move around.
1068 * @skip elm_button_add
1069 * @until evas_object_show
1071 * To end, the rightmost button is packed in the smaller box after the central
1072 * one, and back to the main box we have the bottom button at the end.
1076 * @page box_example_02 Box - Layout transitions
1078 * @dontinclude box_example_02.c
1080 * Setting a customized layout for a box is simple once you have the layout
1081 * function, which is just like the layout function for @c Evas_Box. The new
1082 * and fancier thing we can do with Elementary is animate the transition from
1083 * one layout to the next. We'll see now how to do that through a simple
1084 * example, while also taking a look at some of the API that was left
1085 * untouched in our @ref box_example_01 "previous example".
1087 * @image html screenshots/box_example_02.png
1088 * @image latex screenshots/box_example_02.eps width=\textwidth
1090 * @skipline Elementary.h
1092 * Our application data consists of a list of layout functions, given by
1093 * @c transitions. We'll be animating through them throughout the entire run.
1094 * The box with the stuff to move around and the last layout that was set to
1095 * make things easier in the code.
1097 * @until Transitions_Data
1099 * The box starts with three buttons, clicking on any of them will take it
1100 * out of the box without deleting the object. There are also two more buttons
1101 * outside, one to add an object to the box and the other to clear it.
1102 * This is all to show how you can interact with the items in the box, add
1103 * things and even remove them, while the transitions occur.
1105 * One of the callback we'll be using creates a new button, asks the box for
1106 * the list of its children and if it's not empty, we add the new object after
1107 * the first one, otherwise just place at the end as it will not make any
1113 * The clear button is even simpler. Everything in the box will be deleted,
1114 * leaving it empty and ready to fill it up with more stuff.
1118 * And a little function to remove buttons from the box without deleting them.
1119 * This one is set for the @c clicked callback of the original buttons,
1120 * unpacking them when clicked and placing it somewhere in the screen where
1121 * they will not disturb. Once we do this, the box no longer has any control
1122 * of it, so it will be left untouched until the program ends.
1126 * If we wanted, we could just call @c evas_object_del() on the object to
1127 * destroy it. In this case, no unpack is really necessary, as the box would
1128 * be notified of a child being deleted and adjust its calculations accordingly.
1130 * The core of the program is the following function. It takes whatever
1131 * function is first on our list of layouts and together with the
1132 * @c last_layout, it creates an ::Elm_Box_Transition to use with
1133 * elm_box_layout_transition(). In here, we tell it to start from whatever
1134 * layout we last set, end with the one that was at the top of the list and
1135 * when everything is finished, call us back so we can create another
1136 * transition. Finally, move the new layout to the end of the list so we
1137 * can continue running through them until the program ends.
1141 * The main function doesn't have antyhing special. Creation of box, initial
1142 * buttons and some callback setting. The only part worth mentioning is the
1143 * initialization of our application data.
1145 * @until evas_object_box_layout_stack
1147 * We have a simple static variable, set the box, the first layout we are
1148 * using as last and create the list with the different functions to go
1151 * And in the end, we set the first layout and call the same function we went
1152 * through before to start the run of transitions.
1153 * @until _test_box_transition_change
1155 * For the full code, follow @ref box_example_02.c "here".
1157 * @example box_example_02.c
1161 * @page calendar_example_01 Calendar - Simple creation.
1162 * @dontinclude calendar_example_01.c
1164 * As a first example, let's just display a calendar in our window,
1165 * explaining all steps required to do so.
1167 * First you should declare objects we intend to use:
1168 * @skipline Evas_Object
1170 * Then a window is created, a title is set and its set to be autodeleted.
1171 * More details can be found on windows examples:
1172 * @until elm_win_autodel
1174 * Next a simple background is placed on our windows. More details on
1175 * @ref bg_01_example_page:
1176 * @until evas_object_show(bg)
1178 * Now, the exciting part, let's add the calendar with elm_calendar_add(),
1179 * passing our window object as parent.
1180 * @until evas_object_show(cal);
1182 * To conclude our example, we should show the window and run elm mainloop:
1185 * Our example will look like this:
1187 * @image html screenshots/calendar_example_01.png
1188 * @image latex screenshots/calendar_example_01.eps width=\textwidth
1190 * See the full source code @ref calendar_example_01.c here.
1191 * @example calendar_example_01.c
1195 * @page calendar_example_02 Calendar - Layout strings formatting.
1196 * @dontinclude calendar_example_02.c
1198 * In this simple example, we'll explain how to format the label displaying
1199 * month and year, and also set weekday names.
1201 * To format month and year label, we need to create a callback function
1202 * to create a string given the selected time, declared under a
1203 * <tt> struct tm </tt>.
1205 * <tt> struct tm </tt>, declared on @c time.h, is a structure composed by
1207 * @li tm_sec seconds [0,59]
1208 * @li tm_min minutes [0,59]
1209 * @li tm_hour hour [0,23]
1210 * @li tm_mday day of month [1,31]
1211 * @li tm_mon month of year [0,11]
1212 * @li tm_year years since 1900
1213 * @li tm_wday day of week [0,6] (Sunday = 0)
1214 * @li tm_yday day of year [0,365]
1215 * @li tm_isdst daylight savings flag
1216 * @note glib version has 2 additional fields.
1218 * For our function, only stuff that matters are tm_mon and tm_year.
1219 * But we don't need to access it directly, since there are nice functions
1220 * to format date and time, as @c strftime.
1221 * We will get abbreviated month (%b) and year (%y) (check strftime manpage
1222 * for more) in our example:
1223 * @skipline static char
1226 * We need to alloc the string to be returned, and calendar widget will
1227 * free it when it's not needed, what is done by @c strdup.
1228 * So let's register our callback to calendar object:
1229 * @skipline elm_calendar_format_function_set
1231 * To set weekday names, we should declare them as an array of strings:
1232 * @dontinclude calendar_example_02.c
1233 * @skipline weekdays
1236 * And finally set them to calendar:
1237 * skipline weekdays_names_set
1239 * Our example will look like this:
1241 * @image html screenshots/calendar_example_02.png
1242 * @image latex screenshots/calendar_example_02.eps width=\textwidth
1244 * See the full source code @ref calendar_example_02.c here.
1245 * @example calendar_example_02.c
1249 * @page calendar_example_03 Calendar - Years restrictions.
1250 * @dontinclude calendar_example_03.c
1252 * This example explains how to set max and min year to be displayed
1253 * by a calendar object. This means that user won't be able to
1254 * see or select a date before and after selected years.
1255 * By default, limits are 1902 and maximun value will depends
1256 * on platform architecture (year 2037 for 32 bits); You can
1257 * read more about time functions on @c ctime manpage.
1259 * Straigh to the point, to set it is enough to call
1260 * elm_calendar_min_max_year_set(). First value is minimun year, second
1261 * is maximum. If first value is negative, it won't apply limit for min
1262 * year, if the second one is negative, won't apply for max year.
1263 * Setting both to negative value will clear limits (default state):
1264 * @skipline elm_calendar_min_max_year_set
1266 * Our example will look like this:
1268 * @image html screenshots/calendar_example_03.png
1269 * @image latex screenshots/calendar_example_03.eps width=\textwidth
1271 * See the full source code @ref calendar_example_03.c here.
1272 * @example calendar_example_03.c
1276 * @page calendar_example_04 Calendar - Days selection.
1277 * @dontinclude calendar_example_04.c
1279 * It's possible to disable date selection and to select a date
1280 * from your program, and that's what we'll see on this example.
1282 * If isn't required that users could select a day on calendar,
1283 * only interacting going through months, disabling days selection
1284 * could be a good idea to avoid confusion. For that:
1285 * @skipline elm_calendar_day_selection_enabled_set
1287 * Also, regarding days selection, you could be interested to set a
1288 * date to be highlighted on calendar from your code, maybe when
1289 * a specific event happens, or after calendar creation. Let's select
1290 * two days from current day:
1291 * @dontinclude calendar_example_04.c
1292 * @skipline SECS_DAY
1293 * @skipline current_time
1294 * @until elm_calendar_selected_time_set
1296 * Our example will look like this:
1298 * @image html screenshots/calendar_example_04.png
1299 * @image latex screenshots/calendar_example_04.eps width=\textwidth
1301 * See the full source code @ref calendar_example_04.c here.
1302 * @example calendar_example_04.c
1306 * @page calendar_example_05 Calendar - Signal callback and getters.
1307 * @dontinclude calendar_example_05.c
1309 * Most of setters explained on previous examples have associated getters.
1310 * That's the subject of this example. We'll add a callback to display
1311 * all calendar information every time user interacts with the calendar.
1313 * Let's check our callback function:
1314 * @skipline static void
1315 * @until double interval;
1317 * To get selected day, we need to call elm_calendar_selected_time_get(),
1318 * but to assure nothing wrong happened, we must check for function return.
1319 * It'll return @c EINA_FALSE if fail. Otherwise we can use time set to
1320 * our structure @p stime.
1321 * @skipline elm_calendar_selected_time_get
1324 * Next we'll get information from calendar and place on declared vars:
1325 * @skipline interval
1326 * @until elm_calendar_weekdays_names_get
1328 * The only tricky part is that last line gets an array of strings
1329 * (char arrays), one for each weekday.
1331 * Then we can simple print that to stdin:
1335 * <tt> struct tm </tt> is declared on @c time.h. You can check @c ctime
1336 * manpage to read about it.
1338 * To register this callback, that will be called every time user selects
1339 * a day or goes to next or previous month, just add a callback for signal
1341 * @skipline evas_object_smart_callback_add
1343 * Our example will look like this:
1345 * @image html screenshots/calendar_example_05.png
1346 * @image latex screenshots/calendar_example_05.eps width=\textwidth
1348 * See the full source code @ref calendar_example_05.c here.
1349 * @example calendar_example_05.c
1353 * @page calendar_example_06 Calendar - Calendar marks.
1354 * @dontinclude calendar_example_06.c
1356 * On this example marks management will be explained. Functions
1357 * elm_calendar_mark_add(), elm_calendar_mark_del() and
1358 * elm_calendar_marks_clear() will be covered.
1360 * To add a mark, will be required to choose three things:
1362 * @li mark date, or start date if it will be repeated
1363 * @li mark periodicity
1365 * Style defines the kind of mark will be displayed over marked day,
1366 * on caledar. Default theme supports @b holiday and @b checked.
1367 * If more is required, is possible to set a new theme to calendar
1368 * widget using elm_object_style_set(), and use
1369 * the signal that will be used by such marks.
1371 * Date is a <tt> struct tm </tt>, as defined by @c time.h. More can
1372 * be read on @c ctime manpage.
1373 * If a date relative from current is required, this struct can be set
1375 * @skipline current_time
1376 * @until localtime_r
1378 * Or if it's an absolute date, you can just declare the struct like:
1379 * @dontinclude calendar_example_06.c
1381 * @until christmas.tm_mon
1383 * Periodicity is how frequently the mark will be displayed over the
1384 * calendar. Can be a unique mark (that don't repeat), or it can repeat
1385 * daily, weekly, monthly or annually. It's enumerated by
1386 * @c Elm_Calendar_Mark_Repeat.
1388 * So let's add some marks to our calendar. We will add christmas holiday,
1389 * set Sundays as holidays, and check current day and day after that.
1390 * @dontinclude calendar_example_06.c
1392 * @until christmas.tm_mon
1393 * @skipline current_time
1394 * @until ELM_CALENDAR_WEEKLY
1396 * We kept the return of first mark add, because we don't really won't it
1397 * to be checked, so let's remove it:
1398 * @skipline elm_calendar_mark_del
1400 * After all marks are added and removed, is required to draw them:
1401 * @skipline elm_calendar_marks_draw
1403 * Finally, to clear all marks, let's set a callback for our button:
1404 * @skipline elm_button_add
1405 * @until evas_object_show(bt);
1407 * This callback will receive our calendar object, and should clear it:
1408 * @dontinclude calendar_example_06.c
1411 * @note Remember to draw marks after clear the calendar.
1413 * Our example will look like this:
1415 * @image html screenshots/calendar_example_06.png
1416 * @image latex screenshots/calendar_example_06.eps width=\textwidth
1418 * See the full source code @ref calendar_example_06.c here.
1419 * @example calendar_example_06.c
1423 * @page spinner_example Spinner widget example
1425 * This code places seven Elementary spinner widgets on a window, each of
1426 * them exemplifying a part of the widget's API.
1428 * The first of them is the default spinner:
1429 * @dontinclude spinner_example.c
1430 * @skipline elm_spinner_add
1431 * @until evas_object_show
1432 * As you see, the defaults for a spinner are:
1434 * @li min value set to 0
1435 * @li max value set to 100
1436 * @li step value set to 1
1437 * @li label format set to "%0.f"
1439 * If another format is required, see the second spinner. It will put a text
1440 * before and after the value, and also format value to display two decimals:
1441 * @skipline format_set
1443 * The third one will use a customized step, define new minimum and maximum
1444 * values and enable wrap, so when value reaches minimum it jumps to maximum,
1445 * or jumps to minimum after maximum value is reached. Format is set to display
1447 * @skipline elm_spinner_add
1448 * @until evas_object_show
1450 * The fourth uses @c vertical style, so instead of left and right arrows,
1451 * top and bottom are displayed. Also the change interval is reduced, so
1452 * user can change value faster.
1454 * @skipline interval
1456 * In the fifth the user won't be allowed to set value directly, i.e., will
1457 * be obligate change value only using arrows:
1458 * @skipline editable
1460 * The sixth widget will receive a lot of special values, so
1461 * instead of reading numeric values, user will see labels for each one.
1462 * Also direct edition is disabled, otherwise users would see the numeric
1463 * value on edition mode. User will be able to select a month in this widget:
1464 * @skipline elm_spinner_add
1465 * @until evas_object_show
1467 * Finally the last widget will exemplify how to listen to widget's signals,
1468 * <tt> changed </tt> and <tt> delay,changed </tt>. First we need to
1469 * implement callback functions that will simply print spinner's value:
1470 * @dontinclude spinner_example.c
1477 * The first callback function should be called everytime value changes,
1478 * the second one only after user stops to increment or decrement. Try
1479 * to keep arrows pressed and check the difference.
1480 * @skip smart_callback
1481 * @skipline smart_callback
1482 * @skipline smart_callback
1484 * See the full @ref spinner_example.c "example", whose window should
1485 * look like this picture:
1487 * @image html screenshots/spinner_example.png
1488 * @image latex screenshots/spinner_example.eps width=\textwidth
1490 * See the full @ref spinner_example_c "source code" for this example.
1492 * @example spinner_example.c
1496 * @page slider_example Slider widget example
1498 * This code places seven Elementary slider widgets on a window, each of
1499 * them exemplifying a part of the widget's API.
1501 * The first of them is the default slider:
1502 * @dontinclude slider_example.c
1503 * @skipline elm_slider_add
1504 * @until evas_object_show
1506 * As you see, the defaults for a slider are:
1509 * @li no values (on indicator or unit labels)
1511 * Actually it's pretty useless this way. So let's learn how to improve it.
1513 * If some decoration is required, a label can be set, and icon before and
1514 * after the bar as well. On the second slider will add a @c home icon
1515 * and a @c folder icon at @c end.
1516 * @skipline text_set
1519 * If the bar size need to be changed, it can be done with span set function,
1520 * that doesn't accounts other widget's parts size. Also the bar can starts
1521 * with a not default value (0.0), as we done on third slider:
1522 * @skipline value_set
1523 * @skipline span_size_set
1525 * So far, users won't be able to see the slider value. If it's required,
1526 * it can be displayed in two different areas, units label or above
1529 * Let's place a units label on our widget, and also let's set minimum and
1530 * maximum value (uses 0.0 and 1.0 by default):
1531 * @skipline unit_format_set
1532 * @skipline min_max_set
1534 * If above the indicator is the place to display the value, just set it.
1535 * Also, is possible to invert a bar, as you can see:
1536 * @skipline indicator_format_set
1537 * @skipline inverted_set
1539 * But if you require to use a function a bit more customized to show the value,
1540 * is possible to registry a callback function that will be called
1541 * to display unit or indicator label. Only the value will be passed to this
1542 * function, that should return a string.
1543 * In this case, a function to free this string will be required.
1545 * Let's exemplify with indicator label on our sixth slider:
1546 * @dontinclude slider_example.c
1557 * Setting callback functions:
1558 * @skipline indicator_format_function_set
1559 * @skipline _indicator_free
1561 * Also, a slider can be displayed vertically:
1562 * @dontinclude slider_example.c
1563 * @skipline elm_slider_horizontal_set
1565 * Finally the last widget will exemplify how to listen to widget's signals,
1566 * <tt> changed </tt> and <tt> delay,changed </tt>. First we need to
1567 * implement callback functions that will simply print slider's value:
1568 * @dontinclude slider_example.c
1575 * The first callback function should be called everytime value changes,
1576 * the second one only after user stops to increment or decrement. Try
1577 * to keep arrows pressed and check the difference.
1578 * @skip smart_callback
1579 * @skipline smart_callback
1580 * @skipline smart_callback
1582 * See the full @ref slider_example.c "example", whose window should
1583 * look like this picture:
1585 * @image html screenshots/slider_example.png
1586 * @image latex screenshots/slider_example.eps width=\textwidth
1588 * See the full @ref slider_example_c "source code" for this example.
1590 * @example slider_example.c
1594 * @page panes_example Panes widget example
1596 * This code places two Elementary panes widgets on a window, one of them
1597 * displayed vertically and the other horizontally, to exemplify
1598 * a part of the widget's API. Also, all the signals emitted by this
1599 * widget will be covered.
1601 * Let's start adding a panes to our window:
1602 * @dontinclude panes_example.c
1603 * @skipline elm_panes_add
1604 * @until evas_object_show
1606 * Now we will set a content (a simple button) to the left side of our
1608 * @skipline elm_button_add
1609 * @until content_left_set
1611 * The content of the right side will be something a bit more elaborated, we'll
1612 * place another panes, displayed vertically (it's displayed horizontally
1614 * @skipline elm_panes_add
1615 * @until content_right_set
1617 * When populating a panes displayed vertically, remember that left content
1618 * will be placed at top, and right content will place at bottom. Next
1619 * we will add two buttons to exemplify that:
1620 * @skipline elm_button_add
1621 * @until content_right_set
1623 * Panes widgets emits 4 different signals, depending on users interaction
1624 * with the draggable bar. We'll add a callback function for each of them.
1626 * <tt> "clicked" signal </tt>:
1628 * Callback function that just print "Clicked" to stdin:
1629 * @dontinclude panes_example.c
1636 * @skipline static void
1639 * Also, add callback function to the panes:
1640 * @skipline "clicked"
1642 * <tt> "press" signal </tt>:
1644 * Callback function that just print "Pressed" to stdin:
1645 * @dontinclude panes_example.c
1648 * @skipline static void
1651 * Also, add callback function to the panes:
1654 * Now, let's try to make our callback functions a bit more useful:
1656 * <tt> "unpress" signal </tt>:
1658 * Suppose we want to know the size proportion of left content after
1659 * user drags the bar. We need to listen for @c unpress signal, and
1660 * get this size from our panes widget. It's done on the following
1662 * @dontinclude panes_example.c
1667 * @skipline static void
1670 * Adding the callback function to the panes:
1671 * @skipline "unpress"
1673 * <tt> "clicked,double" signal </tt>:
1675 * Now, a interesting feature that could be addded to panes widget.
1676 * Hide a content when user double click the draggable bar. It's done
1677 * using a variable to store size and content left size getter and setter
1678 * on the following function:
1679 * @dontinclude panes_example.c
1680 * @skipline static double
1687 * @skipline static void
1692 * Adding the callback function to the panes:
1693 * @skipline "clicked,double"
1696 * See the full @ref panes_example.c "example", whose window should
1697 * look like this picture:
1699 * @image html screenshots/panes_example.png
1700 * @image latex screenshots/panes_example.eps width=\textwidth
1702 * @example panes_example.c
1706 * @page clock_example Clock widget example
1708 * This code places five Elementary clock widgets on a window, each of
1709 * them exemplifying a part of the widget's API.
1711 * The first of them is the pristine clock:
1712 * @dontinclude clock_example.c
1714 * @until evas_object_show
1715 * As you see, the defaults for a clock are:
1717 * - no seconds shown
1719 * For am/pm time, see the second clock:
1720 * @dontinclude clock_example.c
1722 * @until evas_object_show
1724 * The third one will show the seconds digits, which will flip in
1725 * synchrony with system time. Note, besides, that the time itself is
1726 * @b different from the system's -- it was customly set with
1727 * elm_clock_time_set():
1728 * @dontinclude clock_example.c
1729 * @skip with seconds
1730 * @until evas_object_show
1732 * In both fourth and fifth ones, we turn on the <b>edition
1733 * mode</b>. See how you can change each of the sheets on it, and be
1734 * sure to try holding the mouse pressed over one of the sheet
1735 * arrows. The forth one also starts with a custom time set:
1736 * @dontinclude clock_example.c
1738 * @until evas_object_show
1740 * The fifth, besides editable, has only the time @b units editable,
1741 * for hours, minutes and seconds. This exemplifies
1742 * elm_clock_digit_edit_set():
1743 * @dontinclude clock_example.c
1745 * @until evas_object_show
1747 * See the full @ref clock_example.c "example", whose window should
1748 * look like this picture:
1750 * @image html screenshots/clock_example.png
1751 * @image latex screenshots/clock_example.eps width=\textwidth
1753 * See the full @ref clock_example_c "source code" for this example.
1755 * @example clock_example.c
1759 * @page diskselector_example_01 Diskselector widget example
1761 * This code places 4 Elementary diskselector widgets on a window, each of
1762 * them exemplifying a part of the widget's API.
1764 * All of them will have weekdays as items, since we won't focus
1765 * on items management on this example. For an example about this subject,
1766 * check @ref diskselector_example_02.
1768 * The first of them is a default diskselector.
1769 * @dontinclude diskselector_example_01.c
1772 * @skipline elm_diskselector_add
1773 * @until evas_object_show
1775 * We are just adding the diskselector, so as you can see, defaults for it are:
1776 * @li Only 3 items visible each time.
1777 * @li Only 3 characters are displayed for labels on side positions.
1778 * @li The first added item remains centeres, i.e., it's the selected item.
1780 * To add items, we are just appending it on a loop, using function
1781 * elm_diskselector_item_append(), that will be better exaplained on
1782 * items management example.
1784 * For a circular diskselector, check the second widget. A circular
1785 * diskselector will display first item after last, and last previous to
1786 * the first one. So, as you can see, @b Sa will appears on left side
1787 * of selected @b Sunday. This property is set with
1788 * elm_diskselector_round_set().
1790 * Also, we decide to display only 2 character for side labels, instead of 3.
1791 * For this we call elm_diskselector_side_label_length_set(). As result,
1792 * we'll see @b Mo displayed instead of @b Mon, when @b Monday is on a
1795 * @skipline elm_diskselector_add
1796 * @until evas_object_show
1798 * But so far, we are only displaying 3 items at once. If more are wanted,
1799 * is enough to call elm_diskselector_display_item_num_set(), as you can
1801 * @skipline elm_diskselector_add
1802 * @until evas_object_show
1804 * @note You can't set less than 3 items to be displayed.
1806 * Finally, if a bounce effect is required, or you would like to see
1807 * scrollbars, it is possible. But, for default theme, diskselector
1808 * scrollbars will be invisible anyway.
1809 * @skipline elm_diskselector_add
1810 * @until evas_object_show
1812 * See the full @ref diskselector_example_01.c "diskselector_example_01.c"
1813 * code, whose window should look like this picture:
1815 * @image html screenshots/diskselector_example_01.png
1816 * @image latex screenshots/diskselector_example_01.eps width=\textwidth
1818 * @example diskselector_example_01.c
1822 * @page diskselector_example_02 Diskselector - Items management
1824 * This code places a Elementary diskselector widgets on a window,
1825 * along with some buttons trigerring actions on it (though its API).
1826 * It covers most of Elm_Diskselector_Item functions.
1828 * On our @c main function, we are adding a default diskselector with
1829 * 3 items. We are only setting their labels (second parameter of function
1830 * elm_diskselector_item_append):
1831 * @dontinclude diskselector_example_02.c
1832 * @skipline elm_diskselector_add
1835 * Next we are adding lots of buttons, each one for a callback function
1836 * that will realize a task covering part of diskselector items API.
1837 * Lets check the first one:
1838 * @skipline elm_button_add
1839 * @until evas_object_show
1841 * We are labeling the button with a task description with
1842 * elm_object_text_set() and setting a callback
1843 * function evas_object_smart_callback_add().
1844 * Each callback function will have the signature:
1845 * <tt> static void _task_cb(void *data, Evas_Object *obj,
1846 * void *event_info)</tt> with the function name varying for each task.
1848 * Now let's cover all of them.
1850 * <b> Appending an item: </b>
1851 * @dontinclude diskselector_example_02.c
1855 * All items are included on diskselector after last one. You @b can't
1858 * The first parameter of elm_diskselector_item_append() is the diskselector
1859 * object, that we are receiving as data on our callback function.
1860 * The second one is a label, the string that will be placed in the center
1861 * of our item. As we don't wan't icons or callback functions, we can
1862 * send NULL as third, fourth and fifth parameters.
1864 * <b> Appending an item with icon: </b>
1865 * @dontinclude diskselector_example_02.c
1866 * @skipline _add_ic_cb
1869 * If an icon is required, you can pass it as third paramenter on our
1870 * elm_diskselector_item_append() function. It will be place on the
1871 * left side of item's label, that will be shifted to right a bit.
1873 * For more details about how to create icons, look for elm_icon examples.
1875 * <b> Appending an item with callback function for selected: </b>
1876 * @dontinclude diskselector_example_02.c
1881 * To set a callback function that will be called every time an item is
1882 * selected, i.e., everytime the diskselector stops with this item in
1883 * center position, just pass the function as fourth paramenter.
1885 * <b> Appending an item with callback function for selected with data: </b>
1886 * @dontinclude diskselector_example_02.c
1887 * @skipline _sel_data_cb
1893 * If the callback function request an extra data, it can be attached to our
1894 * item passing a pointer for data as fifth parameter.
1895 * Our function _sel_data_cb will receive it as <tt> void *data </tt>.
1897 * If you want to free this data, or handle that the way you need when the
1898 * item is deleted, set a callback function for that, with
1899 * elm_diskselector_item_del_cb_set().
1901 * As you can see we check if @c it is not @c NULL after appending it.
1902 * If an error happens, we won't try to set a function for it.
1904 * <b> Deleting an item: </b>
1905 * @dontinclude diskselector_example_02.c
1910 * To delete an item we simple need to call elm_diskselector_item_del() with
1911 * a pointer for such item.
1913 * If you need, you can get selected item with
1914 * elm_diskselector_selected_item_get(), that will return a pointer for it.
1916 * <b> Unselecting an item: </b>
1917 * @dontinclude diskselector_example_02.c
1918 * @skipline _unselect_cb
1921 * To select an item, you should call elm_diskselector_item_selected_set()
1922 * passing @c EINA_TRUE, and to unselect it, @c EINA_FALSE.
1924 * If you unselect the selected item, diskselector will automatically select
1927 * <b> Printing all items: </b>
1928 * @dontinclude diskselector_example_02.c
1929 * @skipline _print_cb
1932 * <b> Clearing the diskselector: </b>
1933 * @dontinclude diskselector_example_02.c
1934 * @skipline _clear_cb
1937 * <b> Selecting the first item: </b>
1938 * @dontinclude diskselector_example_02.c
1939 * @skipline _select_first_cb
1942 * <b> Selecting the last item: </b>
1943 * @dontinclude diskselector_example_02.c
1944 * @skipline _select_last_cb
1947 * <b> Selecting the next item: </b>
1948 * @dontinclude diskselector_example_02.c
1949 * @skipline _select_next_cb
1952 * <b> Selecting the previous item: </b>
1953 * @dontinclude diskselector_example_02.c
1954 * @skipline _select_prev_cb
1957 * See the full @ref diskselector_example_02.c "diskselector_example_02.c"
1958 * code, whose window should look like this picture:
1960 * @image html screenshots/diskselector_example_02.png
1961 * @image latex screenshots/diskselector_example_02.eps width=\textwidth
1963 * @example diskselector_example_02.c
1967 * @page list_example_01 List widget example
1969 * This code places a single Elementary list widgets on a window, just
1970 * to exemplify the more simple and common use case: a list will be created
1971 * and populated with a few items.
1973 * To keep it simple, we won't show how to customize the list, for this check
1974 * @ref list_example_02. Also, we won't focus
1975 * on items management on this example. For an example about this subject,
1976 * check @ref list_example_03.
1978 * To add a list widget.
1979 * @dontinclude list_example_01.c
1980 * @skipline elm_list_add
1982 * We are just adding the list, so as you can see, defaults for it are:
1983 * @li Items are displayed vertically.
1984 * @li Only one item can be selected.
1985 * @li The list doesn't bouce.
1987 * To add items, we are just appending it on a loop, using function
1988 * elm_list_item_append(), that will be better exaplained on
1989 * items management example.
1990 * @dontinclude list_example_01.c
1994 * @skipline elm_list_item_append
1996 * After we just want to show the list. But first we need to start the widget.
1997 * It was done this way to improve widget's performance. So, always remember
1999 * @warning Call elm_list_go before showing the object
2000 * @skipline elm_list_go
2003 * See the full @ref list_example_01.c "list_example_01.c"
2004 * code, whose window should look like this picture:
2006 * @image html screenshots/list_example_01.png
2007 * @image latex screenshots/list_example_01.eps width=\textwidth
2009 * @example list_example_01.c
2013 * @page list_example_02 List widget example
2015 * This code places a single Elementary list widgets on a window,
2016 * exemplifying a part of the widget's API.
2018 * First, we will just create a simple list, as done on @ref list_example_01 :
2019 * @dontinclude list_example_02.c
2022 * @skipline elm_list_add
2023 * @until elm_list_item_append
2025 * Now, let's customize this list a bit. First we will display items
2027 * @skipline horizontal_set
2029 * Then we will choose another list mode. There are four of them, and
2030 * the default #Elm_List_Mode is #ELM_LIST_SCROLL. Let's set compress mode:
2031 * @skipline mode_set
2033 * To enable multiple items selection, we need to enable it, since only one
2034 * selected item is allowed by default:
2035 * @skipline elm_list_multi_select_set
2037 * We are not adding items with callback functions here,
2038 * since we'll explain it better on @ref list_example_03. But if the callback
2039 * need to be called everytime user clicks an item, even if already selected,
2040 * it's required to enable this behavior:
2041 * @skipline elm_list_always_select_mode_set
2043 * Finally, if a bounce effect is required, or you would like to see
2044 * scrollbars, it is possible. But, for default theme, list
2045 * scrollbars will be invisible anyway.
2046 * @skipline bounce_set
2047 * @until SCROLLER_POLICY_ON
2049 * See the full @ref list_example_02.c "list_example_02.c"
2050 * code, whose window should look like this picture:
2052 * @image html screenshots/list_example_02.png
2053 * @image latex screenshots/list_example_02.eps width=\textwidth
2055 * @example list_example_02.c
2059 * @page list_example_03 List - Items management
2061 * This code places a Elementary list widgets on a window,
2062 * along with some buttons trigerring actions on it (though its API).
2063 * It covers most of Elm_List_Item functions.
2065 * On our @c main function, we are adding a default list with
2066 * 3 items. We are only setting their labels (second parameter of function
2067 * elm_list_item_append):
2068 * @dontinclude list_example_03.c
2069 * @skipline elm_list_add
2072 * Next we are adding lots of buttons, each one for a callback function
2073 * that will realize a task covering part of list items API.
2074 * Lets check the first one:
2075 * @skipline elm_button_add
2076 * @until evas_object_show
2078 * We are labeling the button with a task description with
2079 * elm_object_text_set() and setting a callback
2080 * function evas_object_smart_callback_add().
2081 * Each callback function will have the signature:
2082 * <tt> static void _task_cb(void *data, Evas_Object *obj,
2083 * void *event_info)</tt> with the function name varying for each task.
2085 * Now let's cover all of them.
2087 * <b> Prepending an item: </b>
2088 * @dontinclude list_example_03.c
2089 * @skipline _prepend_cb
2092 * The item will be placed on the begining of the list,
2093 * i.e. it will be the first one.
2095 * The first parameter of elm_list_item_prepend() is the list
2096 * object, that we are receiving as data on our callback function.
2097 * The second one is a label, the string that will be placed in the center
2098 * of our item. As we don't wan't icons or callback functions, we can
2099 * send NULL as third, fourth, fifth and sixth parameters.
2101 * <b> Appending an item: </b>
2102 * @dontinclude list_example_03.c
2106 * Items included with append will be inserted inserted after the last one.
2108 * <b> Appending an item with icon: </b>
2109 * @dontinclude list_example_03.c
2110 * @skipline _add_ic_cb
2113 * If an icon is required, you can pass it as third paramenter on our
2114 * elm_list_item_append() function. It will be place on the
2115 * left side of item's label. If an icon is wanted on the right side,
2116 * it should be passed as fourth parameter.
2118 * For more details about how to create icons, look for elm_icon examples
2119 * @ref tutorial_icon.
2121 * <b> Appending an item with callback function for selected: </b>
2122 * @dontinclude list_example_03.c
2127 * To set a callback function that will be called every time an item is
2128 * selected, i.e., everytime the list stops with this item in
2129 * center position, just pass the function as fifth paramenter.
2131 * <b> Appending an item with callback function for selected with data: </b>
2132 * @dontinclude list_example_03.c
2133 * @skipline _sel_data_cb
2139 * If the callback function request an extra data, it can be attached to our
2140 * item passing a pointer for data as sixth parameter.
2141 * Our function _sel_data_cb will receive it as <tt> void *data </tt>.
2143 * If you want to free this data, or handle that the way you need when the
2144 * item is deleted, set a callback function for that, with
2145 * elm_list_item_del_cb_set().
2147 * As you can see we check if @c it is not @c NULL after appending it.
2148 * If an error happens, we won't try to set a function for it.
2150 * <b> Deleting an item: </b>
2151 * @dontinclude list_example_03.c
2152 * @skipline _del_cb(
2155 * To delete an item we simple need to call elm_list_item_del() with
2156 * a pointer for such item.
2158 * If you need, you can get selected item with
2159 * elm_list_selected_item_get(), that will return a pointer for it.
2161 * <b> Unselecting an item: </b>
2162 * @dontinclude list_example_03.c
2163 * @skipline _unselect_cb
2166 * To select an item, you should call elm_list_item_selected_set()
2167 * passing @c EINA_TRUE, and to unselect it, @c EINA_FALSE.
2169 * <b> Printing all items: </b>
2170 * @dontinclude list_example_03.c
2171 * @skipline _print_cb
2174 * <b> Clearing the list: </b>
2175 * @dontinclude list_example_03.c
2176 * @skipline _clear_cb
2179 * <b> Selecting the next item: </b>
2180 * @dontinclude list_example_03.c
2181 * @skipline _select_next_cb
2184 * <b> Inserting after an item: </b>
2185 * @dontinclude list_example_03.c
2186 * @skipline _insert_after_cb
2189 * <b> Selecting the previous item: </b>
2190 * @dontinclude list_example_03.c
2191 * @skipline _select_prev_cb
2194 * <b> Inserting before an item: </b>
2195 * @dontinclude list_example_03.c
2196 * @skipline _insert_before_cb
2199 * If a separator is required, just set an item as such:
2200 * @dontinclude list_example_03.c
2201 * @skipline _set_separator_cb
2204 * Also an item can be disabled, and the user won't be allowed to (un)select it:
2205 * @dontinclude list_example_03.c
2206 * @skipline _disable_cb
2209 * See the full @ref list_example_03.c "list_example_03.c"
2210 * code, whose window should look like this picture:
2212 * @image html screenshots/list_example_03.png
2213 * @image latex screenshots/list_example_03.eps width=\textwidth
2215 * @example list_example_03.c
2219 * @page segment_control_example Segment Control Example
2221 * This code places a Elementary segment control widgets on a window,
2222 * to exemplify part of the widget's API.
2224 * Let's start adding a segment control to our window:
2225 * @dontinclude segment_control_example.c
2226 * @skipline elm_segment_control_add
2227 * @until evas_object_show
2229 * Now will add an item only with label:
2230 * @skipline item_add
2232 * Really simple. To add an item with only an icon, the icon needs to be created
2233 * first, them added with this same function:
2234 * @skipline icon_add
2237 * If an item with label and icon is required, it can be done as well. In this
2238 * case, instead of a label (or icon) centered, the item will display an icon
2239 * at left and the label at right:
2240 * @skipline icon_add
2243 * But, if you need to add some items that can have or not a label, but
2244 * want that all of them looks the same way, with icon at left, just add
2245 * an empty string label. It's done on our example to ilustrate that:
2246 * @skipline icon_add
2249 * So far, all the item were added to the last position of the widget,
2250 * but if something different is required, it can be done using another
2251 * insertion function. Let's suppose we want to put an item just before
2256 * There are two ways to delete items. Using the item handle, like:
2257 * @skipline insert_at
2260 * Or using item's index:
2261 * @skipline insert_at
2264 * To set properties of an item already added to the widget, you just need
2265 * to get the item and set icon or label, as the following code shows:
2266 * @skipline item_get
2269 * Finally, it's possible to select an item from the code, and also get
2270 * the selected item. We will select the item at the center of the widget
2271 * and print its position.
2272 * @skipline count_get
2275 * See the full @ref segment_control_example.c "example", whose window should
2276 * look like this picture:
2278 * @image html screenshots/segment_control_example.png
2279 * @image latex screenshots/segment_control_example.eps width=\textwidth
2281 * @example segment_control_example.c
2285 * @page flipselector_example Flip selector widget example
2287 * This code places an Elementary flip selector widget on a window,
2288 * along with two buttons trigerring actions on it (though its API).
2290 * The selector is being populated with the following items:
2291 * @dontinclude flipselector_example.c
2295 * Next, we create it, populating it with those items and registering
2296 * two (smart) callbacks on it:
2297 * @dontinclude flipselector_example.c
2298 * @skip fp = elm_flipselector_add
2299 * @until object_show
2301 * Those two callbacks will take place whenever one of those smart
2302 * events occur, and they will just print something to @c stdout:
2303 * @dontinclude flipselector_example.c
2304 * @skip underflow callback
2305 * @until static void
2306 * Flip the sheets on the widget while looking at the items list, in
2307 * the source code, and you'll get the idea of those events.
2309 * The two buttons below the flip selector will take the actions
2310 * described in their labels:
2311 * @dontinclude flipselector_example.c
2312 * @skip bt = elm_button_add
2313 * @until callback_add(win
2315 * @dontinclude flipselector_example.c
2316 * @skip unselect the item
2319 * Click on them to exercise those flip selector API calls. To
2320 * interact with the other parts of this API, there's a command line
2321 * interface, whose help string can be asked for with the 'h' key:
2322 * @dontinclude flipselector_example.c
2326 * The 'n' and 'p' keys will exemplify elm_flipselector_flip_next()
2327 * and elm_flipselector_flip_prev(), respectively. 'f' and 'l' account
2328 * for elm_flipselector_first_item_get() and
2329 * elm_flipselector_last_item_get(), respectively. Finally, 's' will
2330 * issue elm_flipselector_selected_item_get() on our example flip
2333 * See the full @ref flipselector_example.c "example", whose window should
2334 * look like this picture:
2336 * @image html screenshots/flipselector_example.png
2337 * @image latex screenshots/flipselector_example.eps width=\textwidth
2339 * See the full @ref flipselector_example_c "source code" for this example.
2341 * @example flipselector_example.c
2345 * @page fileselector_example File selector widget example
2347 * This code places two Elementary file selector widgets on a window.
2348 * The one on the left is layouting file system items in a @b list,
2349 * while the the other is layouting them in a @b grid.
2351 * The one having the majority of hooks of interest is on the left,
2352 * which we create as follows:
2353 * @dontinclude fileselector_example.c
2354 * @skip first file selector
2355 * @until object_show
2357 * Note that we enable custom edition of file/directory selection, via
2358 * the text entry it has on its bottom, via
2359 * elm_fileselector_is_save_set(). It starts with the list view, which
2360 * is the default, and we make it not expandable in place
2361 * (elm_fileselector_expandable_set()), so that it replaces its view's
2362 * contents with the current directory's entries each time one
2363 * navigates to a different folder. For both of file selectors we are
2364 * starting to list the contents found in the @c "/tmp" directory
2365 * (elm_fileselector_path_set()).
2367 * Note the code setting it to "grid mode" and observe the differences
2368 * in the file selector's views, in the example. We also hide the
2369 * second file selector's Ok/Cancel buttons -- since it's there just
2370 * to show the grid view (and navigation) -- via
2371 * elm_fileselector_buttons_ok_cancel_set().
2373 * The @c "done" event, which triggers the callback below
2374 * @dontinclude fileselector_example.c
2377 * will be called at the time one clicks the "Ok"/"Cancel" buttons of
2378 * the file selector (on the left). Note that it will print the path
2379 * to the current selection, if any.
2381 * The @c "selected" event, which triggers the callback below
2382 * @dontinclude fileselector_example.c
2383 * @skip bt = 'selected' cb
2385 * takes place when one selects a file (if the file selector is @b not
2386 * under folders-only mode) or when one selects a folder (when in
2387 * folders-only mode). Experiment it by selecting different file
2390 * What comes next is the code creating the three check boxes and two
2391 * buttons below the file selector in the right. They will exercise a
2392 * bunch of functions on the file selector's API, for the instance on
2393 * the left. Experiment with them, specially the buttons, to get the
2394 * difference between elm_fileselector_path_get() and
2395 * elm_fileselector_selected_get().
2397 * Finally, there's the code adding the second file selector, on the
2399 * @dontinclude fileselector_example.c
2400 * @skip second file selector
2401 * @until object_show
2403 * Pay attention to the code setting it to "grid mode" and observe the
2404 * differences in the file selector's views, in the example. We also
2405 * hide the second file selector's Ok/Cancel buttons -- since it's
2406 * there just to show the grid view (and navigation) -- via
2407 * elm_fileselector_buttons_ok_cancel_set().
2409 * See the full @ref fileselector_example.c "example", whose window
2410 * should look like this picture:
2412 * @image html screenshots/fileselector_example.png
2413 * @image latex screenshots/fileselector_example.eps width=\textwidth
2415 * See the full @ref fileselector_example_c "source code" for this example.
2417 * @example fileselector_example.c
2421 * @page fileselector_button_example File selector button widget example
2423 * This code places an Elementary file selector button widget on a
2424 * window, along with some other checkboxes and a text entry. Those
2425 * are there just as knobs on the file selector button's state and to
2426 * display information from it.
2428 * Here's how we instantiate it:
2429 * @dontinclude fileselector_button_example.c
2430 * @skip ic = elm_icon_add
2431 * @until evas_object_show
2433 * Note that we set on it both icon and label decorations. It's set to
2434 * list the contents of the @c "/tmp" directory, too, with
2435 * elm_fileselector_button_path_set(). What follows are checkboxes to
2436 * exercise some of its API funtions:
2437 * @dontinclude fileselector_button_example.c
2438 * @skip ck = elm_check_add
2439 * @until evas_object_show(en)
2441 * The checkboxes will toggle whether the file selector button's
2442 * internal file selector:
2443 * - must have an editable text entry for file names (thus, be in
2444 * "save dialog mode")
2445 * - is to be raised as an "inner window" (note it's the default
2446 * behavior) or as a dedicated window
2447 * - is to populate its view with folders only
2448 * - is to expand its folders, in its view, <b>in place</b>, and not
2449 * repainting it entirely just with the contents of a sole
2452 * The entry labeled @c "Last selection" will exercise the @c
2453 * "file,chosen" smart event coming from the file selector button:
2454 * @dontinclude fileselector_button_example.c
2456 * @until toggle inwin
2458 * Whenever you dismiss or acknowledges the file selector, after it's
2459 * raised, the @c event_info string will contain the last selection on
2460 * it (if any was made).
2462 * This is how the example, just after called, should look like:
2464 * @image html screenshots/fileselector_button_example_00.png
2465 * @image latex screenshots/fileselector_button_example_00.eps width=\textwidth
2467 * Click on the file selector button to raise its internal file
2468 * selector, which will be contained on an <b>"inner window"</b>:
2470 * @image html screenshots/fileselector_button_example_01.png
2471 * @image latex screenshots/fileselector_button_example_01.eps width=\textwidth
2473 * Toggle the "inwin mode" switch off and, if you click on the file
2474 * selector button again, you'll get @b two windows, the original one
2475 * (note the last selection there!)
2477 * @image html screenshots/fileselector_button_example_02.png
2478 * @image latex screenshots/fileselector_button_example_02.eps width=\textwidth
2480 * and the file selector's new one
2482 * @image html screenshots/fileselector_button_example_03.png
2483 * @image latex screenshots/fileselector_button_example_03.eps width=\textwidth
2485 * Play with the checkboxes to get the behavior changes on the file
2486 * selector button. The respective API calls on the widget coming from
2487 * those knobs where shown in the code already.
2489 * See the full @ref fileselector_button_example_c "source code" for
2492 * @example fileselector_button_example.c
2496 * @page fileselector_entry_example File selector entry widget example
2498 * This code places an Elementary file selector entry widget on a
2499 * window, along with some other checkboxes. Those are there just as
2500 * knobs on the file selector entry's state.
2502 * Here's how we instantiate it:
2503 * @dontinclude fileselector_entry_example.c
2504 * @skip ic = elm_icon_add
2505 * @until evas_object_show
2507 * Note that we set on it's button both icon and label
2508 * decorations. It's set to exhibit the path of (and list the contents
2509 * of, when internal file selector is launched) the @c "/tmp"
2510 * directory, also, with elm_fileselector_entry_path_set(). What
2511 * follows are checkboxes to exercise some of its API funtions:
2512 * @dontinclude fileselector_entry_example.c
2513 * @skip ck = elm_check_add
2514 * @until callback_add(fs_entry
2516 * The checkboxes will toggle whether the file selector entry's
2517 * internal file selector:
2518 * - must have an editable text entry for file names (thus, be in
2519 * "save dialog mode")
2520 * - is to be raised as an "inner window" (note it's the default
2521 * behavior) or as a dedicated window
2522 * - is to populate its view with folders only
2523 * - is to expand its folders, in its view, <b>in place</b>, and not
2524 * repainting it entirely just with the contents of a sole
2527 * Observe how the entry's text will match the string coming from the
2528 * @c "file,chosen" smart event:
2529 * @dontinclude fileselector_entry_example.c
2532 * Whenever you dismiss or acknowledges the file selector, after it's
2533 * raised, the @c event_info string will contain the last selection on
2534 * it (if any was made).
2536 * Try, also, to type in a valid system path and, then, open the file
2537 * selector's window: it will start the file browsing there, for you.
2539 * This is how the example, just after called, should look like:
2541 * @image html screenshots/fileselector_entry_example_00.png
2542 * @image latex screenshots/fileselector_entry_example_00.eps width=\textwidth
2544 * Click on the file selector entry to raise its internal file
2545 * selector, which will be contained on an <b>"inner window"</b>:
2547 * @image html screenshots/fileselector_entry_example_01.png
2548 * @image latex screenshots/fileselector_entry_example_01.eps width=\textwidth
2550 * Toggle the "inwin mode" switch off and, if you click on the file
2551 * selector entry again, you'll get @b two windows, the original one
2552 * (note the last selection there!)
2554 * @image html screenshots/fileselector_entry_example_02.png
2555 * @image latex screenshots/fileselector_entry_example_02.eps width=\textwidth
2557 * and the file selector's new one
2559 * @image html screenshots/fileselector_entry_example_03.png
2560 * @image latex screenshots/fileselector_entry_example_03.eps width=\textwidth
2562 * Play with the checkboxes to get the behavior changes on the file
2563 * selector entry. The respective API calls on the widget coming from
2564 * those knobs where shown in the code already.
2566 * See the full @ref fileselector_entry_example_c "source code" for
2569 * @example fileselector_entry_example.c
2573 * @page layout_example_01 Layout - Content, Table and Box
2575 * This example shows how one can use the @ref Layout widget to create a
2576 * customized distribution of widgets on the screen, controled by an Edje theme.
2577 * The full source code for this example can be found at @ref
2578 * layout_example_01_c.
2580 * Our custom layout is defined by a file, @ref layout_example_edc, which is an
2581 * Edje theme file. Look for the Edje documentation to understand it. For now,
2582 * it's enough to know that we describe some specific parts on this layout
2584 * @li a title text field;
2585 * @li a box container;
2586 * @li a table container;
2587 * @li and a content container.
2589 * Going straight to the code, the following snippet instantiates the layout
2592 * @dontinclude layout_example_01.c
2593 * @skip elm_layout_add
2594 * @until evas_object_show(layout)
2596 * As any other widget, we set some properties for the size calculation. But
2597 * notice on this piece of code the call to the function elm_layout_file_set().
2598 * Here is where the theme file is loaded, and particularly the specific group
2599 * from this theme file. Also notice that the theme file here is referenced as
2600 * an .edj, which is a .edc theme file compiled to its binary form. Again, look
2601 * for the Edje documentation for more information about theme files.
2603 * Next, we fetch from our theme a data string referenced by the key "title".
2604 * This data was defined in the theme, and can be used as parameters which the
2605 * program get from the specific theme that it is using. In this case, we store
2606 * the title of this window and program in the theme, as a "data" entry, just
2607 * for demonstration purposes:
2611 * This call elm_layout_data_get() is used to fetch the string based on the key,
2612 * and elm_object_text_part_set() will set the part defined in the theme as
2613 * "example/title" to contain this string. This key "example/title" has nothing
2614 * special. It's just an arbitrary convention that we are using in this example.
2615 * Every string in this example referencing a part of this theme will be of the
2616 * form "example/<something>".
2618 * Now let's start using our layout to distribute things on the window space.
2619 * Since the layout was added as a resize object to the elementary window, it
2620 * will always occupy the entire space available for this window.
2622 * The theme already has a title, and it also defines a table element which is
2623 * positioned approximately between 50% and 70% of the height of this window,
2624 * and has 100% of the width. We create some widgets (two icons, a clock and a
2625 * button) and pack them inside the table, in a distribution similar to a HTML
2628 * @until evas_object_show(bt)
2630 * Notice that we just set size hints for every object, and call the function
2631 * elm_layout_table_pack(), which does all the work. It will place the elements
2632 * in the specified row/column, with row and column span if required, and then
2633 * the object's size and position will be controled by the layout widget. It
2634 * will also respect size hints, alignments and weight properties set to these
2635 * widgets. The resulting distribution on the screen depends on the table
2636 * properties (described in the theme), the size hints set on each widget, and
2637 * on the cells of the table that are being used.
2639 * For instance, we add the two icons and the clock on the first, second and
2640 * third cells of the first row, and add the button the second row, making it
2641 * span for 3 columns (thus having the size of the entire table width). This
2642 * will result in a table that has 2 rows and 3 columns.
2644 * Now let's add some widgets to the box area of our layout. This box is around
2645 * 20% and 50% of the vertical size of the layout, and 100% of its width. The
2646 * theme defines that it will use an "horizontal flow" distribution to its
2647 * elements. Unlike the table, a box will distribute elements without knowing
2648 * about rows and columns, and the distribution function selected will take care
2649 * of putting them in row, column, both, or any other available layout. This is
2650 * also described in the Edje documentation.
2652 * This box area is similar to the @ref Box widget of elementary, with the
2653 * difference that its position and properties are controled by the theme of the
2654 * layout. It also contains more than one API to add items to it, since the
2655 * items position now is defined in terms of a list of items, not a matrix.
2656 * There's the first position (can have items added to it with
2657 * elm_layout_box_prepend()), the last position (elm_layout_box_append()), the
2658 * nth position (elm_layout_box_insert_at()) and the position right before an
2659 * element (elm_layout_box_insert_before()). We use insert_at and prepend
2660 * functions to add the first two buttons to this box, and insert_before on the
2661 * callback of each button. The callback code will be shown later, but it
2662 * basically adds a button just before the clicked button using the
2663 * elm_layout_box_insert_before() function. Here's the code for adding the first
2666 * @until evas_object_show(item)
2667 * @until evas_object_show(item)
2669 * Finally, we have an area in this layout theme, in the bottom part of it,
2670 * reserved for adding an specific widget. Differently from the 2 parts
2671 * described until now, this one can only receive one widget with the call
2672 * elm_layout_content_set(). If there was already an item on this specific part,
2673 * it will be deleted (one can use elm_layout_content_unset() in order to remove
2674 * it without deleting). An example of removing it without deleting, but
2675 * manually deleting this widget just after that, can be seen on the callback
2676 * for this button. Actually, the callback defined for this button will clean
2677 * the two other parts (deleting all of their elements) and then remove and
2678 * delete this button.
2680 * @until _swallow_btn_cb
2682 * Also notice that, for this last added button, we don't have to call
2683 * evas_object_show() on it. This is a particularity of the theme for layouts,
2684 * that will have total control over the properties like size, position,
2685 * visibility and clipping of a widget added with elm_layout_content_set().
2686 * Again, read the Edje documentation to understand this better.
2688 * Now we just put the code for the different callbacks specified for each kind
2689 * of button and make simple comments about them:
2691 * @dontinclude layout_example_01.c
2693 * @until evas_object_del(item)
2696 * The first callback is used for the button in the table, and will just remove
2697 * itself from the table with elm_layout_table_unpack(), which remove items
2698 * without deleting them, and then calling evas_object_del() on itself.
2700 * The second callback is for buttons added to the box. When clicked, these
2701 * buttons will create a new button, and add them to the same box, in the
2702 * position just before the clicked button.
2704 * And the last callback is for the button added to the "content" area. It will
2705 * clear both the table and the box, passing @c EINA_TRUE to their respective @c
2706 * clear parameters, which will imply on the items of these containers being
2709 * A screenshot of this example can be seen on:
2711 * @image html screenshots/layout_example_01.png
2712 * @image latex screenshots/layout_example_01.eps width=\textwidth
2717 * @page layout_example_02 Layout - Predefined Layout
2719 * This example shows how one can use the @ref Layout with a predefined theme
2720 * layout to add a back and next button to a simple window. The full source code
2721 * for this example can be found at @ref layout_example_02_c.
2723 * After setting up the window and background, we add the layout widget to the
2724 * window. But instead of using elm_layout_file_set() to load its theme from a
2725 * custom theme file, we can use elm_layout_theme_set() to load one of the
2726 * predefined layouts that come with elementary. Particularly on this example,
2727 * we load the them of class "layout", group "application" and style
2728 * "content-back-next" (since we want the back and next buttons).
2730 * @dontinclude layout_example_02.c
2731 * @skip elm_layout_add
2732 * @until evas_object_show(layout)
2734 * This default theme contains only a "content" area named
2735 * "elm.swallow.content", where we can add any widget (it can be even a
2736 * container widget, like a box, frame, list, or even another layout). Since we
2737 * just want to show the resulting layout, we add a simple icon to it:
2739 * @until layout_content_set
2741 * This default layout also provides some signals when the next and prev buttons
2742 * are clicked. We can register callbacks to them with the
2743 * elm_object_signal_callback_add() function:
2745 * @until elm,action,next
2747 * In the @ref layout_example_03 you can see how to send signals to the layout with
2748 * elm_object_signal_emit().
2750 * Now our callback just changes the picture being displayed when one of the
2751 * buttons are clicked:
2753 * @dontinclude layout_example_02.c
2755 * @until standard_set
2758 * It's possible to see that it gets the name of the image being shown from the
2759 * array of image names, going forward on this array when "next" is clicked and
2760 * backward when "back" is clicked.
2762 * A screenshot of this example can be seen on:
2764 * @image html screenshots/layout_example_02.png
2765 * @image latex screenshots/layout_example_02.eps width=\textwidth
2769 * @page layout_example_03 Layout - Signals and Size Changed
2771 * This example shows how one can send and receive signals to/from the layout,
2772 * and what to do when the layout theme has its size changed. The full source
2773 * code for this example can be found at @ref layout_example_03_c.
2775 * In this exmaple we will use another group from the same layout theme file
2776 * used in @ref layout_example_01. Its instanciation and loading happens in the
2779 * @dontinclude layout_example_03.c
2780 * @skip elm_layout_add
2781 * @until evas_object_show
2783 * This time we register a callback to be called whenever we receive a signal
2784 * after the end of the animation that happens in this layout:
2786 * @until signal_callback_add
2788 * We also add a button that will send signals to the layout:
2790 * @until callback_add
2792 * The callback for this button will check what type of signal it should send,
2793 * and then emit it. The code for this callback follows:
2795 * @dontinclude layout_exmaple_03.c
2796 * @skip static Eina_Bool
2801 * As we said before, we are receiving a signal whenever the animation started
2802 * by the button click ends. This is the callback for that signal:
2806 * Notice from this callback that the elm_layout_sizing_eval() function must be
2807 * called if we want our widget to update its size after the layout theme having
2808 * changed its minimum size. This happens because the animation specified in the
2809 * theme increases the size of the content area to a value higher than the
2810 * widget size, thus requiring more space. But the elementary layout widget
2811 * has no way to know this, thus needing the elm_layout_sizing_eval() to
2812 * be called on the layout, informing that this size has changed.
2814 * A screenshot of this example can be seen on:
2816 * @image html screenshots/layout_example_03.png
2817 * @image latex screenshots/layout_example_03.eps width=\textwidth
2821 * @page tutorial_hover Hover example
2822 * @dontinclude hover_example_01.c
2824 * On this example we are going to have a button that when clicked will show our
2825 * hover widget, this hover will have content set on it's left, top, right and
2826 * middle positions. In the middle position we are placing a button that when
2827 * clicked will hide the hover. We are also going to use a non-default theme
2828 * for our hover. We won't explain the functioning of button for that see @ref
2831 * We start our example with a couple of callbacks that show and hide the data
2832 * they're given(which we'll see later on is the hover widget):
2837 * In our main function we'll do some initialization and then create 3
2838 * rectangles, one red, one green and one blue to use in our hover. We'll also
2839 * create the 2 buttons that will show and hide the hover:
2842 * With all of that squared away we can now get to the heart of the matter,
2843 * creating our hover widget, which is easy as pie:
2846 * Having created our hover we now need to set the parent and target. Which if
2847 * you recall from the function documentations are going to tell the hover which
2848 * area it should cover and where it should be centered:
2851 * Now we set the theme for our hover. We're using the popout theme which gives
2852 * our contents a white background and causes their appearance to be animated:
2855 * And finally we set the content for our positions:
2858 * So far so good? Great 'cause that's all there is too it, what is left now is
2859 * just connecting our buttons to the callbacks we defined at the beginning of
2860 * the example and run the main loop:
2863 * Our example will initially look like this:
2865 * @image html screenshots/hover_example_01.png
2866 * @image latex screenshots/hover_example_01.eps width=\textwidth
2868 * And after you click the "Show hover" button it will look like this:
2870 * @image html screenshots/hover_example_01_a.png
2871 * @image latex screenshots/hover_example_01_a.eps width=\textwidth
2873 * @example hover_example_01.c
2877 * @page tutorial_flip Flip example
2878 * @dontinclude flip_example_01.c
2880 * This example will show a flip with two rectangles on it(one blue, one
2881 * green). Our example will allow the user to choose the animation the flip
2882 * uses and to interact with it. To allow the user to choose the interaction
2883 * mode we use radio buttons, we will however not explain them, if you would
2884 * like to know more about radio buttons see @ref radio.
2886 * We start our example with the usual setup and then create the 2 rectangles
2887 * we will use in our flip:
2888 * @until show(rect2)
2890 * The next thing to do is to create our flip and set it's front and back
2894 * The next thing we do is set the interaction mode(which the user can later
2895 * change) to the page animation:
2898 * Setting a interaction mode however is not sufficient, we also need to
2899 * choose which directions we allow interaction from, for this example we
2900 * will use all of them:
2903 * We are also going to set the hitsize to the entire flip(in all directions)
2904 * to make our flip very easy to interact with:
2907 * After that we create our radio buttons and start the main loop:
2910 * When the user clicks a radio button a function that changes the
2911 * interaction mode and animates the flip is called:
2913 * @note The elm_flip_go() call here serves no purpose other than to
2914 * ilustrate that it's possible to animate the flip programmatically.
2916 * Our example will look like this:
2918 * @image html screenshots/flip_example_01.png
2919 * @image latex screenshots/flip_example_01.eps width=\textwidth
2921 * @note Since this is an animated example the screenshot doesn't do it
2922 * justice, it is a good idea to compile it and see the animations.
2924 * @example flip_example_01.c
2928 * @page tutorial_label Label example
2929 * @dontinclude label_example_01.c
2931 * In this example we are going to create 6 labels, set some properties on
2932 * them and see what changes in appearance those properties cause.
2934 * We start with the setup code that by now you should be familiar with:
2937 * For our first label we have a moderately long text(that doesn't fit in the
2938 * label's width) so we will make it a sliding label. Since the text isn't
2939 * too long we don't need the animation to be very long, 3 seconds should
2940 * give us a nice speed:
2943 * For our second label we have the same text, but this time we aren't going
2944 * to have it slide, we're going to ellipsize it. Because we ask our label
2945 * widget to ellipsize the text it will first diminsh the fontsize so that it
2946 * can show as much of the text as possible:
2949 * For the third label we are going to ellipsize the text again, however this
2950 * time to make sure the fontsize isn't diminshed we will set a line wrap.
2951 * The wrap won't actually cause a line break because we set the label to
2955 * For our fourth label we will set line wrapping but won't set ellipsis, so
2956 * that our text will indeed be wrapped instead of ellipsized. For this label
2957 * we choose character wrap:
2960 * Just two more, for our fifth label we do the same as for the fourth
2961 * except we set the wrap to word:
2964 * And last but not least for our sixth label we set the style to "marker" and
2965 * the color to red(the default color is white which would be hard to see on
2966 * our white background):
2969 * Our example will look like this:
2971 * @image html screenshots/label_example_01.png
2972 * @image latex screenshots/label_example_01.eps width=\textwidth
2974 * @example label_example_01.c
2978 * @page tutorial_image Image example
2979 * @dontinclude image_example_01.c
2981 * This example is as simple as possible. An image object will be added to the
2982 * window over a white background, and set to be resizeable together with the
2983 * window. All the options set through the example will affect the behavior of
2986 * We start with the code for creating a window and its background, and also
2987 * add the code to write the path to the image that will be loaded:
2992 * Now we create the image object, and set that file to be loaded:
2996 * We can now go setting our options.
2998 * elm_image_no_scale_set() is used just to set this value to true (we
2999 * don't want to scale our image anyway, just resize it).
3001 * elm_image_scale_set() is used to allow the image to be resized to a size
3002 * smaller than the original one, but not to a size bigger than it.
3004 * elm_elm_image_smooth_set() will disable the smooth scaling, so the scale
3005 * algorithm used to scale the image to the new object size is going to be
3006 * faster, but with a lower quality.
3008 * elm_image_orient_set() is used to flip the image around the (1, 0) (0, 1)
3011 * elm_image_aspect_ratio_retained_set() is used to keep the original aspect
3012 * ratio of the image, even when the window is resized to another aspect ratio.
3014 * elm_image_fill_outside_set() is used to ensure that the image will fill the
3015 * entire area available to it, even if keeping the aspect ratio. The image
3016 * will overflow its width or height (any of them that is necessary) to the
3017 * object area, instead of resizing the image down until it can fit entirely in
3020 * elm_image_editable_set() is used just to cover the API, but won't affect
3021 * this example since we are not using any copy & paste property.
3023 * This is the code for setting these options:
3027 * Now some last touches in our object size hints, window and background, to
3028 * display this image properly:
3032 * This example will look like this:
3034 * @image html screenshots/image_example_01.png
3035 * @image latex screenshots/image_example_01.eps width=\textwidth
3037 * @example image_example_01.c
3041 * @page tutorial_icon Icon example
3042 * @dontinclude icon_example_01.c
3044 * This example is as simple as possible. An icon object will be added to the
3045 * window over a white background, and set to be resizeable together with the
3046 * window. All the options set through the example will affect the behavior of
3049 * We start with the code for creating a window and its background:
3054 * Now we create the icon object, and set lookup order of the icon, and choose
3059 * An intersting thing is that after setting this, it's possible to check where
3060 * in the filesystem is the theme used by this icon, and the name of the group
3065 * We can now go setting our options.
3067 * elm_icon_no_scale_set() is used just to set this value to true (we
3068 * don't want to scale our icon anyway, just resize it).
3070 * elm_icon_scale_set() is used to allow the icon to be resized to a size
3071 * smaller than the original one, but not to a size bigger than it.
3073 * elm_elm_icon_smooth_set() will disable the smooth scaling, so the scale
3074 * algorithm used to scale the icon to the new object size is going to be
3075 * faster, but with a lower quality.
3077 * elm_icon_fill_outside_set() is used to ensure that the icon will fill the
3078 * entire area available to it, even if keeping the aspect ratio. The icon
3079 * will overflow its width or height (any of them that is necessary) to the
3080 * object area, instead of resizing the icon down until it can fit entirely in
3083 * This is the code for setting these options:
3085 * @until fill_outside
3087 * However, if you try this example you may notice that this image is not being
3088 * affected by all of these options. This happens because the used icon will be
3089 * from elementary theme, and thus it has its own set of options like smooth
3090 * scaling and fill_outside options. You can change the "home" icon to use some
3091 * image (from your system) and see that then those options will be respected.
3093 * Now some last touches in our object size hints, window and background, to
3094 * display this icon properly:
3098 * This example will look like this:
3100 * @image html screenshots/icon_example_01.png
3101 * @image latex screenshots/icon_example_01.eps width=\textwidth
3103 * @example icon_example_01.c
3107 * @page tutorial_hoversel Hoversel example
3108 * @dontinclude hoversel_example_01.c
3110 * In this example we will create a hoversel with 3 items, one with a label but
3111 * no icon and two with both a label and an icon. Every item that is clicked
3112 * will be deleted, but everytime the hoversel is activated we will also add an
3113 * item. In addition our first item will print all items when clicked and our
3114 * third item will clear all items in the hoversel.
3116 * We will start with the normal creation of window stuff:
3119 * Next we will create a red rectangle to use as the icon of our hoversel:
3122 * And now we create our hoversel and set some of it's properties. We set @p win
3123 * as its parent, ask it to not be horizontal(be vertical) and give it a label
3127 * Next we will add our three items, setting a callback to be called for the
3131 * We also set a pair of callbacks to be called whenever any item is selected or
3132 * when the hoversel is activated:
3135 * And then ask that our hoversel be shown and run the main loop:
3138 * We now have the callback for our first item which prints all items in the
3142 * Next we have the callback for our third item which removes all items from the
3146 * Next we have the callback that is called whenever an item is clicked and
3147 * deletes that item:
3150 * And the callback that is called when the hoversel is activated and adds an
3151 * item to the hoversel. Note that since we allocate memory for the item we need
3152 * to know when the item dies so we can free that memory:
3155 * And finally the callback that frees the memory we allocated for items created
3156 * in the @p _add_item callback:
3159 * Our example will initially look like this:
3161 * @image html screenshots/hoversel_example_01.png
3162 * @image latex screenshots/hoversel_example_01.eps width=\textwidth
3164 * And when the hoversel is clicked it will look like this:
3166 * @image html screenshots/hoversel_example_01_a.png
3167 * @image latex screenshots/hoversel_example_01_a.eps width=\textwidth
3169 * @example hoversel_example_01.c
3173 * @page conformant_example Conformant Example.
3175 * In this example we'll explain how to create applications to work
3176 * with illume, considering space required for virtual keyboards, indicator
3179 * Illume is a module for Enlightenment that modifies the user interface
3180 * to work cleanly and nicely on a mobile device. It has support for
3181 * virtual keyboard, among other nice features.
3183 * Let's start creating a very simple window with a vertical box
3184 * with multi-line entry between two buttons.
3185 * This entry will expand filling all space on window not used by buttons.
3187 * @dontinclude conformant_example_01.c
3188 * @skipline elm_main
3191 * For information about how to create windows, boxes, buttons or entries,
3192 * look for documentation for these widgets.
3194 * It will looks fine when you don't need a virtual keyboard, as you
3195 * can see on the following image:
3197 * @image html screenshots/conformant_example_01.png
3198 * @image latex screenshots/conformant_example_01.eps width=\textwidth
3200 * But if you call a virtual keyboard, the window will resize, changing
3201 * widgets size and position. All the content will shrink.
3203 * If you don't want such behaviour, you
3204 * will need a conformant to account for space taken up by the indicator,
3205 * virtual keyboard and softkey.
3207 * In this case, using the conformant in a proper way, you will have
3208 * a window like the following:
3210 * @image html screenshots/conformant_example_02.png
3211 * @image latex screenshots/conformant_example_02.eps width=\textwidth
3213 * As you can see, it guess the space that will be required by the keyboard,
3214 * indicator and softkey bars.
3216 * So, let's study each step required to transform our initial example on
3219 * First of all, we need to set the window as an illume conformant window:
3220 * @dontinclude conformant_example_02.c
3221 * @skipline elm_win_conformant_set
3223 * Next, we'll add a conformant widget, and set it to resize with the window,
3224 * instead of the box.
3226 * @until evas_object_show
3228 * Finally, we'll set the box as conformant's content, just like this:
3229 * @skipline elm_conformant_content_set
3231 * Compare both examples code:
3232 * @ref conformant_example_01.c "conformant_example_01.c"
3233 * @ref conformant_example_02.c "conformant_example_02.c"
3235 * @example conformant_example_01.c
3236 * @example conformant_example_02.c
3240 * @page index_example_01 Index widget example 1
3242 * This code places an Elementary index widget on a window, which also
3243 * has a very long list of arbitrary strings on it. The list is
3244 * sorted alphabetically and the index will be used to index the first
3245 * items of each set of strings beginning with an alphabet letter.
3247 * Below the list are some buttons, which are there just to exercise
3248 * some index widget's API.
3250 * Here's how we instantiate it:
3251 * @dontinclude index_example_01.c
3252 * @skip elm_list_add
3253 * @until evas_object_show(d.index)
3254 * where we're showing also the list being created. Note that we issue
3255 * elm_win_resize_object_add() on the index, so that it's set to have
3256 * the whole window as its container. Then, we have to populate both
3257 * list and index widgets:
3258 * @dontinclude index_example_01.c
3259 * @skip for (i = 0; i < (sizeof(dict) / sizeof(dict[0])); i++)
3263 * The strings populating the list come from a file
3264 * @dontinclude index_example_01.c
3265 * @skip static const char *dict
3268 * We use the @c curr char variable to hold the last initial letter
3269 * seen on that ordered list of strings, so that we're able to have an
3270 * index item pointing to each list item starting a new letter
3271 * "section". Note that our index item data pointers will be the list
3272 * item handles. We are also setting a callback function to index
3273 * items deletion events:
3274 * @dontinclude index_example_01.c
3278 * There, we show you that the @c event_info pointer will contain the
3279 * item in question's data, i.e., a given list item's pointer. Because
3280 * item data is also returned in the @c data argument on
3281 * @c Evas_Smart_Cb functions, those two pointers must have the same
3282 * values. On this deletion callback, we're deleting the referred list
3283 * item too, just to exemplify that anything could be done there.
3285 * Next, we hook to two smart events of the index object:
3286 * @dontinclude index_example_01.c
3287 * @skip smart_callback_add(d.index
3288 * @until _index_selected
3289 * @dontinclude index_example_01.c
3290 * @skip "delay,changed" hook
3294 * Check that, whenever one holds the mouse pressed over a given index
3295 * letter for some time, the list beneath it will roll down to the
3296 * item pointed to by that index item. When one releases the mouse
3297 * button, the second callback takes place. There, we check that the
3298 * reported item data, on @c event_info, is the same reported by
3299 * elm_index_item_selected_get(), which gives the last selection's
3300 * data on the index widget.
3302 * The first of the three buttons that follow will call
3303 * elm_index_active_set(), thus showing the index automatically for
3304 * you, if it's not already visible, what is checked with
3305 * elm_index_active_get(). The second button will exercise @b deletion
3306 * of index item objects, by the following code:
3307 * @dontinclude index_example_01.c
3308 * @skip delete an index item
3311 * It will get the last index item selected's data and find the
3312 * respective #Elm_Index_Item handle with elm_index_item_find(). We
3313 * need the latter to query the indexing letter string from, with
3314 * elm_index_item_letter_get(). Next, comes the delition, itself,
3315 * which will also trigger the @c _index_item_del callback function,
3318 * The third button, finally, will exercise elm_index_item_clear(),
3319 * which will delete @b all of the index's items.
3321 * This is how the example program's window looks like with the index
3323 * @image html screenshots/index_example_00.png
3324 * @image latex screenshots/index_example_00.eps
3326 * When it's shown, it's like the following figure:
3327 * @image html screenshots/index_example_01.png
3328 * @image latex screenshots/index_example_01.eps
3330 * See the full @ref index_example_01_c "source code" for
3333 * @example index_example_01.c
3337 * @page index_example_02 Index widget example 2
3339 * This code places an Elementary index widget on a window, indexing
3340 * grid items. The items are placed so that their labels @b don't
3341 * follow any order, but the index itself is ordered (through
3342 * elm_index_item_sorted_insert()). This is a complement to to @ref
3343 * index_example_01 "the first example on indexes".
3345 * Here's the list of item labels to be used on the grid (in that
3347 * @dontinclude index_example_02.c
3348 * @skip static const char *items
3351 * In the interesting part of the code, here, we first instantiate the
3352 * grid (more on grids on their examples) and, after creating our
3353 * index, for each grid item we also create an index one to reference
3355 * @dontinclude index_example_02.c
3356 * @skip grid = elm_gengrid_add
3358 * @until smart_callback_add
3360 * The order in which they'll appear in the index, though, is @b
3361 * alphabetical, becase of elm_index_item_sorted_insert() usage
3362 * together with the comparing function, where we take the letters of
3363 * each index item to base our ordering on. The parameters on
3364 * @c _index_cmp have to be declared as void pointers because of the
3365 * @c Eina_Compare_Cb prototype requisition, but in this case we know
3366 * they'll be #Elm_Index_Item's:
3367 * @dontinclude index_example_02.c
3368 * @skip ordering alphabetically
3371 * The last interesting bit is the callback in the @c "delay,changed"
3372 * smart event, which will bring the given grid item to the grid's
3374 * @dontinclude index_example_02.c
3378 * Note how the grid will move kind of randomly while you move your
3379 * mouse pointer held over the index from top to bottom -- that's
3380 * because of the the random order the items have in the grid itself.
3382 * This is how the example program's window looks like:
3383 * @image html screenshots/index_example_03.png
3384 * @image latex screenshots/index_example_03.eps
3386 * See the full @ref index_example_c "source code" for
3389 * @example index_example_02.c
3393 * @page tutorial_ctxpopup Ctxpopup example
3394 * @dontinclude ctxpopup_example_01.c
3396 * In this example we have a list with two items, when either item is clicked
3397 * a ctxpopup for it will be shown. Our two ctxpopups are quite different, the
3398 * one for the first item is a vertical and it's items contain both labels and
3399 * icons, the one for the second item is horizontal and it's items have icons
3402 * We will begin examining our example code by looking at the callback we'll use
3403 * when items in the ctxpopup are clicked. It's very simple, all it does is
3404 * print the label present in the ctxpopup item:
3407 * Next we examine a function that creates ctxpopup items, it was created to
3408 * avoid repeating the same code whenever we needed to add an item to our
3409 * ctxpopup. Our function creates an icon from the standard set of icons, and
3410 * then creates the item, with the label received as an argument. We also set
3411 * the callback to be called when the item is clicked:
3414 * Finally we have the function that will create the ctxpopup for the first item
3415 * in our list. This one is somewhat more complex though, so let's go through it
3416 * in parts. First we declare our variable and add the ctxpopup:
3417 * @until ctxpopup_add
3419 * Next we create a bunch of items for our ctxpopup, marking two of them as
3420 * disabled just so we can see what that will look like:
3421 * @until disabled_set
3422 * @until disabled_set
3424 * Then we ask evas where the mouse pointer was so that we can have our ctxpopup
3425 * appear in the right place, set a maximum size for the ctxpopup, move it and
3429 * And last we mark the list item as not selected:
3432 * Our next function is the callback that will create the ctxpopup for the
3433 * second list item, it is very similar to the previous function. A couple of
3434 * interesting things to note is that we ask our ctxpopup to be horizontal, and
3435 * that we pass NULL as the label for every item:
3438 * And with all of that in place we can now get to our main function where we
3439 * create the window, the list, the list items and run the main loop:
3442 * The example will initially look like this:
3444 * @image html screenshots/ctxpopup_example_01.png
3445 * @image latex screenshots/ctxpopup_example_01.eps width=\textwidth
3447 * @note This doesn't show the ctxpopup tough, since it will only appear when
3448 * we click one of the list items.
3450 * Here is what our first ctxpopup will look like:
3452 * @image html screenshots/ctxpopup_example_01_a.png
3453 * @image latex screenshots/ctxpopup_example_01_a.eps width=\textwidth
3455 * And here the second ctxpopup:
3457 * @image html screenshots/ctxpopup_example_01_b.png
3458 * @image latex screenshots/ctxpopup_example_01_b.eps width=\textwidth
3460 * @example ctxpopup_example_01.c
3464 * @page tutorial_pager
3465 * @dontinclude pager_example_01.c
3467 * In this example we'll have a pager with 3 rectangles on it, one blue, one
3468 * green and one blue, we'll also have 1 button for each rectangle. Pressing a
3469 * button will bring the associated rectangle to the front of the pager(promote
3472 * We start our example with some run of the mill code that you've seen in other
3476 * And then we get right to creating our pager, setting a style and some basic
3480 * Well a pager without any content is not of much use, so let's create the
3481 * first of our rectangles, add it to the pager and create the button for it:
3482 * @until smart_callback
3483 * @note The only line of above code that directly relates to our pager is the
3484 * call to elm_pager_content_push().
3486 * And now we will do the same thing again twice for our next two rectangles:
3487 * @until smart_callback
3488 * @until smart_callback
3490 * Now that we haver our widgets create we can get to running the main loop:
3493 * We also have the callback that is called when any of the buttons is pressed,
3494 * this callback is receiving the rectangle in it's @p data argument, so we
3495 * check if it's already on top and if not move it there:
3498 * Our example will look like this:
3500 * @image html screenshots/pager_example_01.png
3501 * @image latex screenshots/pager_example_01.eps width=\textwidth
3502 * @note Like all examples that involve animations the screenshot doesn't do it
3503 * justice, seeing it in action is a must.
3505 * @example pager_example_01.c
3509 * @page tutorial_separator Separator example
3510 * @dontinclude separator_example_01.c
3512 * In this example we are going to pack two rectangles in a box, and have a
3513 * separator in the middle.
3515 * So we start we the window, background, box and rectangle creation, all pretty
3519 * Once we have our first rectangle in the box we create and add our separator:
3521 * @note Since our box is in horizontal mode it's a good idea to set the
3522 * separator to be horizontal too.
3524 * And now we add our second rectangle and run the main loop:
3527 * This example will look like this:
3529 * @image html screenshots/separator_example_01.png
3530 * @image eps screenshots/separator_example_01.eps width=\textwidth
3532 * @example separator_example_01.c
3536 * @page tutorial_radio Radio example
3537 * @dontinclude radio_example_01.c
3539 * In this example we will create 4 radio buttons, three of them in a group and
3540 * another one not in the group. We will also have the radios in the group
3541 * change the value of a variable directly and have then print it when the value
3542 * changes. The fourth button is in the example just to make clear that radios
3543 * outside the group don't affect the group.
3545 * We'll start with the usual includes:
3548 * And move right to declaring a static variable(the one whose value the radios
3552 * We now need to have a window and all that good stuff to be able to place our
3556 * And now we create a radio button, since this is the first button in our group
3557 * we set the group to be the radio(so we can set the other radios in the same
3558 * group). We also set the state value of this radio to 1 and the value pointer
3559 * to @p val, since val is @p 1 this has the additional effect of setting the
3560 * radio value to @p 1. For this radio we choose the default home icon:
3563 * To check that our radio buttons are working we'll add a callback to the
3564 * "changed" signal of the radio:
3565 * @until smart_callback
3567 * The creation of our second radio button is almost identical, the 2
3568 * differences worth noting are, the value of this radio 2 and that we add this
3569 * radio to the group of the first radio:
3570 * @until smart_callback
3572 * For our third callback we'll omit the icon and set the value to 3, we'll also
3573 * add it to the group of the first radio:
3574 * @until smart_callback
3576 * Our fourth callback has a value of 4, no icon and most relevantly is not a
3577 * member of the same group as the other radios:
3580 * We finally run the main loop:
3583 * And the last detail in our example is the callback that prints @p val so that
3584 * we can see that the radios are indeed changing its value:
3587 * The example will look like this:
3589 * @image html screenshots/radio_example_01.png
3590 * @image latex screenshots/radio_example_01.epx width=\textwidth
3592 * @example radio_example_01.c
3596 * @page tutorial_toggle Toggle example
3597 * @dontinclude toggle_example_01.c
3599 * In this example we'll create 2 toggle widgets. The first will have an icon
3600 * and the state names will be the default "on"/"off", it will also change the
3601 * value of a variable directly. The second won't have a icon, the state names
3602 * will be "Enabled"/"Disabled", it will start "Enabled" and it won't set the
3603 * value of a variable.
3605 * We start with the usual includes and prototype for callback which will be
3606 * implemented and detailed later on:
3609 * We then declare a static global variable(the one whose value will be changed
3610 * by the first toggle):
3613 * We now have to create our window and all that usual stuff:
3616 * The creation of a toggle is no more complicated than that of any other
3620 * For our first toggle we don't set the states labels so they will stay the
3621 * default, however we do set a label for the toggle, an icon and the variable
3622 * whose value it should change:
3625 * We also set the callback that will be called when the toggles value changes:
3626 * @until smart_callback
3628 * For our second toggle it important to note that we set the states labels,
3629 * don't set an icon or variable, but set the initial state to
3630 * EINA_TRUE("Enabled"):
3633 * For the second toggle we will use a different callback:
3634 * @until smart_callback
3636 * We then ask the main loop to start:
3639 * The callback for our first toggle will look the value of @p val and print it:
3642 * For our second callback we need to do a little bit more, since the second
3643 * toggle doesn't change the value of a variable we have to ask it what its
3647 * This example will look like this:
3649 * @image html screenshots/toggle_example_01.png
3650 * @image latex screenshots/toggle_example_01.eps width=\textwidth
3652 * @example toggle_example_01.c
3656 * @page tutorial_panel Panel example
3657 * @dontinclude panel_example_01.c
3659 * In this example will have 3 panels, one for each possible orientation. Two of
3660 * our panels will start out hidden, the third will start out expanded. For each
3661 * of the panels we will use a label as the content, it's however possible to
3662 * have any widget(including containers) as the content of panels.
3664 * We start by doing some setup, code you should be familiar with from other
3668 * And move right to creating our first panel, for this panel we are going to
3669 * choose the orientation as TOP and toggle it(tell it to hide itself):
3672 * For the second panel we choose the RIGHT orientation and explicitly set the
3676 * For our third and last panel we won't set the orientation(which means it will
3677 * use the default: LEFT):
3680 * All that is left is running the main loop:
3683 * This example will look like this;
3685 * @image html screenshots/panel_example_01.png
3686 * @image latex screenshots/panel_example_01.epx width=\textwidth
3687 * @note The buttons with arrow allow the user to hide/show the panels.
3689 * @example panel_example_01.c
3693 * @page gengrid_example Gengrid widget example
3695 * This application is a thorough exercise on the gengrid widget's
3696 * API. We place an Elementary gengrid widget on a window, with
3697 * various knobs below its viewport, each one acting on it somehow.
3699 * The code's relevant part begins at the grid's creation. After
3700 * instantiating it, we set its items sizes, so that we don't end with
3701 * items one finger size wide, only. We're setting them to fat, 150
3702 * pixel wide ones, for this example. We give it some size hints, not
3703 * to be discussed in this context and, than, we register a callback
3704 * on one of its smart events -- the one coming each time an item gets
3705 * doubly clicked. There, we just print the item handle's value.
3706 * @dontinclude gengrid_example.c
3707 * @skip grid = elm_gengrid_add
3708 * @until evas_object_sho
3709 * @dontinclude gengrid_example.c
3710 * @skip item double click callback
3713 * Before we actually start to deal with the items API, let's show
3714 * some things items will be using throughout all the code. The first
3715 * of them is a struct to be used as item data, for all of them:
3716 * @dontinclude gengrid_example.c
3717 * @skip typedef struct
3720 * That path will be used to index an image, to be swallowed into one
3721 * of the item's icon spots. The imagens themselves are distributed
3723 * @dontinclude gengrid_example.c
3724 * @skip static const char *imgs
3727 * We also have an (unique) gengrid item class we'll be using for
3728 * items in the example:
3729 * @dontinclude gengrid_example.c
3730 * @skip static Elm_Gengrid_Item_Class
3731 * @until static Elm_Gengrid_Item_Class
3732 * @dontinclude gengrid_example.c
3733 * @skip item_style =
3736 * As you see, our items will follow the default theme on gengrid
3737 * items. For the label fetching code, we return a string composed of
3738 * the item's image path:
3739 * @dontinclude gengrid_example.c
3740 * @skip label fetching callback
3743 * For item icons, we'll be populating the item default theme's two
3744 * icon spots, @c "elm.swallow.icon" and @c "elm.swallow.end". The
3745 * former will receive one of the images in our list (in the form of
3746 * a @ref bg_02_example_page "background"), while the latter will be
3747 * a check widget. Note that we prevent the check to propagate click
3748 * events, so that the user can toggle its state without messing with
3749 * the respective item's selection in the grid:
3750 * @dontinclude gengrid_example.c
3751 * @skip icon fetching callback
3752 * @until return NULL
3755 * As the default gengrid item's theme does not have parts
3756 * implementing item states, we'll be just returning false for every
3758 * @dontinclude gengrid_example.c
3759 * @skip state fetching callback
3762 * Finally, the deletion callback on gengrid items takes care of
3763 * freeing the item's label string and its data struct:
3764 * @dontinclude gengrid_example.c
3765 * @skip deletion callback
3768 * Let's move to item insertion/deletion knobs, them. They are four
3769 * buttons, above the grid's viewport, namely
3770 * - "Append" (to append an item to the grid),
3771 * - "Prepend" (to prepend an item to the grid),
3772 * - "Insert before" (to insert an item before the selection, on the
3774 * - "Insert after" (to insert an item after the selection, on the
3776 * - "Clear" (to delete all items in the grid),
3777 * - "Bring in 1st" (to make the 1st item visible, by scrolling),
3778 * - "Show last" (to directly show the last item),
3780 * which are displaced and declared in that order. We're not dealing
3781 * with the buttons' creation code (see @ref button_example_01
3782 * "a button example", for more details on it), but with their @c
3783 * "clicked" registered callbacks. For all of them, the grid's handle
3784 * is passed as @c data. The ones creating new items use a common
3785 * code, which just gives a new @c Example_Item struct, with @c path
3786 * filled with a random image in our images list:
3787 * @dontinclude gengrid_example.c
3788 * @skip new item with random path
3791 * Moreover, that ones will set a common function to be issued on the
3792 * selection of the items. There, we print the item handle's value,
3793 * along with the callback function data. The latter will be @c NULL,
3794 * always, because it's what we pass when adding all icons. By using
3795 * elm_gengrid_item_data_get(), we can have the item data back and,
3796 * with that, we're priting the item's path string. Finally, we
3797 * exemplify elm_gengrid_item_pos_get(), printing the item's position
3799 * @dontinclude gengrid_example.c
3800 * @skip item selection callback
3803 * The appending button will exercise elm_gengrid_item_append(), simply:
3804 * @dontinclude gengrid_example.c
3805 * @skip append an item
3808 * The prepending, naturally, is analogous, but exercising
3809 * elm_gengrid_item_prepend(), on its turn. The "Insert before" one
3810 * will expect an item to be selected in the grid, so that it will
3811 * insert a new item just before it:
3812 * @dontinclude gengrid_example.c
3813 * @skip "insert before" callback
3816 * The "Insert after" is analogous, just using
3817 * elm_gengrid_item_insert_after(), instead. The "Clear" button will,
3818 * as expected, just issue elm_gengrid_clear():
3819 * @dontinclude gengrid_example.c
3820 * @skip delete items
3823 * The "Bring in 1st" button is there exercise two gengrid functions
3824 * -- elm_gengrid_first_item_get() and elm_gengrid_item_bring_in().
3825 * With the former, we get a handle to the first item and, with the
3826 * latter, you'll see that the widget animatedly scrolls its view
3827 * until we can see that item:
3828 * @dontinclude gengrid_example.c
3829 * @skip bring in 1st item
3832 * The "Show last", in its turn, will use elm_gengrid_last_item_get()
3833 * and elm_gengrid_item_show(). The latter differs from
3834 * elm_gengrid_item_bring_in() in that it immediately replaces the
3835 * contents of the grid's viewport with the region containing the item
3837 * @dontinclude gengrid_example.c
3838 * @skip show last item
3841 * To change the grid's cell (items) size, we've placed a spinner,
3842 * which has the following @c "changed" smart callback:
3843 * @dontinclude gengrid_example.c
3844 * @skip change items' size
3847 * Experiment with it and see how the items are affected. The "Disable
3848 * item" button will, as the name says, disable the currently selected
3850 * @dontinclude gengrid_example.c
3851 * @skip disable selected item
3853 * Note that we also make use of elm_gengrid_item_selected_set(),
3854 * there, thus making the item unselected before we actually disable
3857 * To toggle between horizontal and vertical layouting modes on the
3858 * grid, use the "Horizontal mode" check, which will call the
3859 * respective API function on the grid:
3860 * @dontinclude gengrid_example.c
3861 * @skip change layouting mode
3864 * If you toggle the check right after that one, "Always select",
3865 * you'll notice all subsequent clicks on the @b same grid item will
3866 * still issue the selection callback on it, what is different from
3867 * when it's not checked. This is the
3868 * elm_gengrid_always_select_mode_set() behavior:
3869 * @dontinclude gengrid_example.c
3870 * @skip "always select" callback
3873 * One more check follows, "Bouncing", which will turn on/off the
3874 * bouncing animations on the grid, when one scrolls past its
3875 * borders. Experiment with scrolling the grid to get the idea, having
3876 * it turned on and off:
3877 * @dontinclude gengrid_example.c
3878 * @skip "bouncing mode" callback
3881 * The next two checks will affect items selection on the grid. The
3882 * first, "Multi-selection", will make it possible to select more the
3883 * one item on the grid. Because it wouldn't make sense to fetch for
3884 * an unique selected item on this case, we also disable two of the
3885 * buttons, which insert items relatively, if multi-selection is on:
3886 * @dontinclude gengrid_example.c
3887 * @skip multi-selection callback
3890 * Note that we also @b unselect all items in the grid, when returning
3891 * from multi-selection mode, making use of
3892 * elm_gengrid_item_selected_set().
3894 * The second check acting on selection, "No selection", is just what
3895 * its name depicts -- no selection will be allowed anymore, on the
3896 * grid, while it's on. Check it out for yourself, interacting with
3898 * @dontinclude gengrid_example.c
3899 * @skip no selection callback
3902 * We have, finally, one more line of knobs, now sliders, to change
3903 * the grids behavior. The two first will change the horizontal @b
3904 * alignment of the whole actual grid of items within the gengrid's
3906 * @dontinclude gengrid_example.c
3907 * @skip items grid horizontal alignment change
3910 * Naturally, the vertical counterpart just issues
3911 * elm_gengrid_align_set() changing the second alignment component,
3914 * The last slider will change the grid's <b>page size</b>, relative
3915 * to its own one. Try to change those values and, one manner of
3916 * observing the paging behavior, is to scroll softly and release the
3917 * mouse button, with different page sizes, at different grid
3918 * positions, while having lots of items in it -- you'll see it
3919 * snapping to page boundaries differenty, for each configuration:
3920 * @dontinclude gengrid_example.c
3921 * @skip page relative size change
3924 * This is how the example program's window looks like:
3925 * @image html screenshots/gengrid_example.png
3926 * @image latex screenshots/gengrid_example.eps width=\textwidth
3928 * Note that it starts with three items which we included at will:
3929 * @dontinclude gengrid_example.c
3930 * @skip _clicked(grid,
3931 * @until _clicked(grid,
3932 * @until _clicked(grid,
3933 * @until _clicked(grid,
3935 * See the full @ref gengrid_example_c "source code" for
3938 * @example gengrid_example.c
3941 * @page entry_example_01 Entry - Example of simple editing
3943 * As a general overview of @ref Entry we are going to write an, albeit simple,
3944 * functional editor. Although intended to show how elm_entry works, this
3945 * example also makes extensive use of several other widgets. The full code
3946 * can be found in @ref entry_example.c "entry_example.c" and in the following
3947 * lines we'll go through the parts especific to the @ref Entry widget.
3949 * The program itself is a simple editor, with a file already set to it, that
3950 * can be set to autosave or not and allows insertion of emoticons and some
3951 * formatted text. As of this writing, the capabilities of format edition in
3952 * the entry are very limited, so a lot of manual work is required to change
3955 * In any case, the program allows some changes by using the buttons on the
3956 * top of the window and returning focus back to the main entry afterwards.
3958 * @image html screenshots/entry_example.png
3959 * @image latex screenshots/entry_example.eps width=\textwidth
3961 * We'll begin by showing a few structures used throught the program. First,
3962 * the application owns data that holds the main window and the main entry
3963 * where the editting happens. Then, an auxiliar structure we'll use later
3964 * when inserting icons in our text.
3965 * @dontinclude entry_example.c
3967 * @until App_Inwin_Data
3969 * A little convenience function will insert whatever text we need in the
3970 * buffer at the current cursor's position and set focus back to this entry.
3971 * This is done mostly because clicking on any button will make them steal
3972 * focus, which makes writing text more cumbersome.
3976 * One of the buttons on the top will trigger an @ref Inwin to open and show
3977 * us several icons we can insert into the text. We'll jump over most of these
3978 * functions, but when all the options are chosen, we insert the special
3979 * markup text that will show the chosen icon in place.
3980 * @skip edje_file_collection_list_free(emos)
3982 * @until evas_object_del
3985 * As can be seen in that function, the program lets us add icons to our entry
3986 * using all the possible configurations for them. That should help to
3987 * clarify how the different combinations work out by actually seeing them
3990 * The same popup window has a page to set the settings of the chosen icon,
3991 * that is, the size and how the item will be placed within the line.
3993 * The size is done with two entries, limitted to accept numbers and a fixed
3994 * size of characters. Changing the value in this entries will update the icon
3995 * size in our struct as seen in the next two callbacks.
4000 * The rest of the options are handled with radio buttons, since only one type
4001 * of size can be used (@c size, @c absize or @c relsize) and for the vertical
4002 * sizing it needs to choose between @c ascent and @c full. Depending on which
4003 * is chosen, the @c item tag is formed accordingly as seen before.
4004 * @skip static Evas_Object
4005 * @until evas_object_show(rvascent)
4007 * The first of our entries is here. There's something worth mentioning about
4008 * the way we'll create this one. Normally, any entry regardless of whether is
4009 * single line or not, will be set to scrollable, but in this case, since we
4010 * are limitting how many characters can fit in them and we know we don't need
4011 * scrolling, we are not setting this flag. This makes the entry have virtually
4012 * no appearance on screen, other than its text. This is because an entry is
4013 * just that, a box that holds text, and in order to have some frame around it
4014 * or a background color, another widget needs to provide this. When an entry
4015 * is scrollable, the same scroller used internally does this.
4016 * We are using @ref Frame "frames" here to provide some decoration around,
4017 * then creating our entries, set them to single line, add our two filters and
4018 * the callback for when their value change.
4019 * @until _height_changed_cb
4021 * This function ends with the button that will finally call the item
4022 * into our editting string.
4025 * Then we get to the format edition. Here we can add the @c bold and
4026 * @c emphasis tags to parts of our text. There's a lot of manual work to
4027 * know what to do here, since we are not implementing an entire state manager
4028 * and the entry itself doesn't, yet, support all the needed capabilities to
4029 * make this simpler. We begin by getting the format we are using in our
4030 * function from the button pressed.
4031 * @skip aid->pager = pager;
4032 * @until sizeof(fmt_close)
4034 * Next we need to find out if we need to insert an opening or a closing tag.
4035 * For this, we store the current cursor position and create a selection
4036 * from this point until the beginning of our text, and then get the selected
4037 * text to look for any existing format tags in it. This is currently the only
4038 * way in which we can find out what formats is being used in the entry.
4042 * Once we know what tag to insert, we need a second check in the case it was
4043 * a closing tag. This is because any other closing tag that comes after would
4044 * be left dangling alone, so we need to remove it to keep the text consistent.
4047 * Finally, we clear our fake selections and return the cursor back to the
4048 * position it had at first, since there is where we want to insert our format.
4049 * @until cursor_pos_set
4051 * And finish by calling our convenience function from before, to insert the
4052 * text at the current cursor and give focus back to the entry.
4055 * A checkbox on the top of our program tells us if the text we are editing
4056 * will autosave or not. In it's @c "changed" callback we get the value from
4057 * the checkbox and call the elm_entry_autosave_set() function with it. If
4058 * autosave is set, we also call elm_entry_file_save(). This is so the internal
4059 * timer used to periodically store to disk our changes is started.
4063 * Two more functions to show some cursor playing. Whenever we double click
4064 * anywhere on our entry, we'll find what word is the cursor placed at and
4065 * select it. Likewise, for triple clicking, we select the entire line.
4067 * @until _edit_tplclick_cb
4070 * And finally, the main window of the program contains the entry where we
4071 * do all the edition and some helping widgets to change format, add icons
4072 * or change the autosave flag.
4075 * @until _image_insert_cb
4077 * And the main entry of the program. Set to scroll, by default we disable
4078 * autosave and we'll begin with a file set to it because no file selector
4079 * is being used here. The file is loaded with #ELM_TEXT_FORMAT_MARKUP_UTF8
4080 * so that any format contained in it is interpreted, otherwise the entry
4081 * would load it as just text, escaping any tags found and no format or icons
4082 * would be shown. Then we connect to the double and triple click signals
4083 * and set focus on the entry so we can start typing right away.
4086 * @example entry_example.c
4090 * @page genlist_example_01 Genlist - basic usage
4092 * This example creates a simple genlist with a small number of items and
4093 * a callback that is called whenever an item is selected. All the properties of
4094 * this genlist are the default ones. The full code for this example can be seen
4095 * at @ref genlist_example_01_c.
4097 * For the simplest list that you plan to create, it's necessary to define some
4098 * of the basic functions that are used for creating each list item, and
4099 * associating them with the "item class" for that list. The item class is just
4100 * an struct that contains pointers to the specific list item functions that are
4101 * common to all the items of the list.
4103 * Let's show it by example. Our item class is declared globally and static as
4104 * it will be the only item class that we need (we are just creating one list):
4106 * @dontinclude genlist_example_01.c
4107 * @skip static Elm_Genlist
4108 * @until static Elm_Genlist
4110 * This item class will be used for every item that we create. The only
4111 * functions that we are going to set are @c label_get and @c icon_get. As the
4112 * name suggests, they are used by the genlist to generate the label for the
4113 * respective item, and to generate icon(s) to it too. Both the label and icon
4114 * get functions can be called more than once for each item, with different @c
4115 * part parameters, which represent where in the theme of the item that label or
4116 * icon is going to be set.
4118 * The default theme for the genlist contains only one area for label, and two
4119 * areas for icon ("elm.swallow.icon" and "elm.swallow.end"). Since we just want
4120 * to set the first icon (that will be at the left side of the label), we
4121 * compare the part name given with "elm.swallow.icon". Notice that the
4122 * @c label_get function must return a strduped string, that will be freed later
4123 * automatically by the list. Here's the code for @c label_get and @c icon_get:
4125 * @until static void
4127 * We will also provide a function that will be called whenever an item is
4128 * selected in the genlist. However, this function is not part of the item
4129 * class, it will be passed for each item being added to the genlist explicitly.
4130 * Notice the similarity of the function signature with those used by @c
4131 * evas_object_smart_callback_add:
4135 * Now let's show the code used for really creating the list. Skipping
4136 * boilerplate code used for creating a window and background, the first piece
4137 * of code specific to our genlist example is setting the pointer functions of
4138 * the item class to our above defined functions:
4143 * Notice that we also choose to use the "default" style for our genlist items.
4144 * Another interesting point is that @c state_get and @c del are set to @c NULL,
4145 * since we don't need these functions now. @c del doesn't need to be used
4146 * because we don't add any data that must be freed to our items, and @c
4147 * state_get is also not used since all of our items are the same and don't need
4148 * to have different states to be used for each item. Finally we create our
4151 * @until genlist_add
4153 * Now we append several items to the list, and for all of them we need to give
4154 * the list pointer, a pointer to the item class, the data that will be used
4155 * with that item, a pointer to the parent of this item if it is in a group type
4156 * list (this is not the case so we pass @c NULL), possible flags for this item,
4157 * the callback for when the item is selected, and the data pointer that will be
4158 * given to the selected callback.
4162 * The rest of the code is also common to all the other examples, so it will be
4163 * omitted here (look at the full source code link above if you need it).
4165 * You can try to play with this example, and see the selected callback being
4166 * called whenever an item is clicked. It also already has some features enabled
4167 * by default, like vertical bounce animation when reaching the end of the list,
4168 * automatically visible/invisible scrollbar, etc. Look at the @ref
4169 * genlist_example_02 to see an example of setting these properties to the list.
4171 * The current example will look like this when running:
4173 * @image html screenshots/genlist_example_01.png
4174 * @image latex screenshots/genlistexample_01.eps width=\textwidth
4178 * @page genlist_example_02 Genlist - list setup functions
4180 * This example is very similar to the @ref genlist_example_01, but it fetch
4181 * most of the properties of the genlist and displays them on startup (thus
4182 * getting the default value for them) and then set them to some other values,
4183 * to show how to use that API. The full source code is at @ref
4184 * genlist_example_02_c.
4186 * Considering that the base code for instantiating a genlist was already
4187 * described in the previous example, we are going to focus on the new code.
4189 * Just a small difference for the @c _item_label_get function, we are going to
4190 * store the time that this function was called. This is the "realized" time,
4191 * the time when the visual representation of this item was created. This is the
4192 * code for the @c label_get function:
4194 * @dontinclude genlist_example_02.c
4196 * @until return strdup
4198 * Now let's go to the list creation and setup. First, just after creating the
4199 * list, we get most of the default properties from it, and print them on the
4203 * @until printf("\n")
4205 * We are going to change some of the properties of our list.
4207 * There's no need to call the selected callback at every click, just when the
4208 * selected item changes, thus we call elm_genlist_always_select_mode_set() with
4211 * For this list we don't want bounce animations at all, so we set both the
4212 * horizontal bounce and the vertical bounce to false with
4213 * elm_genlist_bounce_set().
4215 * We also want our list to compress items if they are wider than the list
4216 * width (thus we call elm_genlist_compress_mode_set().
4218 * The items have different width, so they are not homogeneous:
4219 * elm_genlist_homogeneous_set() is set to false.
4221 * Since the compress mode is active, the call to
4222 * elm_genlist_horizontal_mode_set() doesn't make difference, but the current
4223 * option would make the list to have at least the width of the largest item.
4225 * This list will support multiple selection, so we call
4226 * elm_genlist_multi_select_set() on it.
4228 * The option elm_genlist_height_for_width_mode_set() would allow text block to
4229 * wrap lines if the Edje part is configured with "text.min: 0 1", for example.
4230 * But since we are compressing the elements to the width of the list, this
4231 * option wouldn't take any effect.
4233 * We want the vertical scrollbar to be always displayed, and the orizontal one
4234 * to never be displayed, and set this with elm_genlist_scroller_policy_set().
4236 * The timeout to consider a longpress is set to half of a second with
4237 * elm_genlist_longpress_timeout_set().
4239 * We also change the block count to a smaller value, but that should have not
4240 * impact on performance since the number of visible items is too small. We just
4241 * increase the granularity of the block count (setting it to have at most 4
4244 * @until block_count_set
4246 * Now let's add elements to the list:
4248 * @until item_append
4251 * It's exactly the same as the previous example. The difference is on the
4252 * behavior of the list, if you try to scroll, select items and so.
4254 * In this example we also need two buttons. One of them, when clicked, will
4255 * display several status info about the current selection, the "realized"
4256 * items, the item in the middle of the screen, and the current mode and active
4257 * item of that mode for the genlist.
4259 * The other button will ask the genlist to "realize" again the items already
4260 * "realized", so their respective label_get and icon_get functions will be
4263 * These are the callbacks for both of these buttons:
4265 * @dontinclude genlist_example_02.c
4271 * Try to scroll, select some items and click on the "Show status" button.
4272 * You'll notice that not all items of the list are "realized", thus consuming
4273 * just a small amount of memory. The selected items are listed in the order
4274 * that they were selected, and the current selected item printed using
4275 * elm_genlist_selected_item_get() is the first selected item of the multiple
4278 * Now resize the window so that you can see the "realized time" of some items.
4279 * This is the time of when the label_get function was called. If you click on
4280 * the "Realize" button, all the already realized items will be rebuilt, so the
4281 * time will be updated for all of them.
4283 * The current example will look like this when running:
4285 * @image html screenshots/genlist_example_02.png
4286 * @image latex screenshots/genlistexample_02.eps width=\textwidth
4290 * @page genlist_example_04 Genlist - items manipulation
4292 * This example is also similar ot the @ref genlist_example_01, but it
4293 * demonstrates most of the item manipulation functions. See the full source
4294 * code at @ref genlist_example_04_c.
4296 * In this example, we also will use the concept of creating groups of items in
4297 * the genlist. Each group of items is composed by a parent item (which will be
4298 * the index of the group) and several children of this item. Thus, for the
4299 * children, we declare a normal item class. But we also are going to declare a
4300 * different item class for the group index (which in practice is another type
4301 * of item in the genlist):
4303 * @dontinclude genlist_example_04.c
4304 * @skip _item_sel_cb
4309 * We will add buttons to the window, where each button provides one
4310 * functionality of the genlist item API. Each button will have a callback
4311 * attached, that will really execute this functionality. An example of these
4312 * callbacks is the next one, for the elm_genlist_item_insert_after() function:
4314 * @skip insert_before_cb
4318 * If you want ot see the other button functions, look at the full source code
4321 * Each button will be created with a function that already creates the button,
4322 * add it to an elementary box, and attach the specified callback. This is the
4323 * function that does it:
4325 * @skip genlist_item_update
4329 * In our @c elm_main function, besides the code for setting up the window, box
4330 * and background, we also initialize our two item classes:
4332 * @skip _itc.item_style
4333 * @until _itc_group.func.del
4335 * This example uses a different style for the items, the @a double_label, which
4336 * provides a text field for the item text, and another text field for a subtext.
4338 * For the group index we use the @a group_index style, which provides a
4339 * different appearance, helping to identify the end of a group and beginning of
4342 * Now, after the code for creating the list, setting up the box and other
4343 * stuff, let's add the buttons with their respective callbacks:
4346 * @until bt_top_show
4348 * The main code for adding items to the list is a bit more complex than the one
4349 * from the previous examples. We check if each item is multiple of 7, and if
4350 * so, they are group indexes (thus each group has 6 elements by default, in
4357 * Then we also check for specific items, and add callbacks to them on the
4358 * respective buttons, so we can show, bring in, etc.:
4363 * Once you understand the code from the @ref genlist_example_01, it should be
4364 * easy to understand this one too. Look at the full code, and also try to play
4365 * a bit with the buttons, adding items, bringing them to the viewport, and so.
4367 * The example will look like this when running:
4369 * @image html screenshots/genlist_example_04.png
4370 * @image latex screenshots/genlistexample_04.eps width=\textwidth
4374 * @page genlist_example_05 Genlist - working with subitems
4376 * This is probably the most complex example of elementary @ref Genlist. We
4377 * create a tree of items, using the subitems properties of the items, and keep
4378 * it in memory to be able to expand/hide subitems of an item. The full source
4379 * code can be found at @ref genlist_example_05_c
4381 * The main point is the way that Genlist manages subitems. Clicking on an
4382 * item's button to expand it won't really show its children. It will only
4383 * generate the "expand,request" signal, and the expansion must be done
4386 * In this example we want to be able to add items as subitems of another item.
4387 * If an item has any child, it must be displayed using a parent class,
4388 * otherwise it will use the normal item class.
4390 * It will be possible to delete items too. Once a tree is constructed (with
4391 * subitems of subitems), and the user clicks on the first parent (root of the
4392 * tree), the entire subtree must be hidden. However, just calling
4393 * elm_genlist_item_expanded_set(item, EINA_FALSE) won't hide them. The only
4394 * thing that happens is that the parent item will change its appearance to
4395 * represent that it's contracted. And the signal "contracted" will be emitted
4396 * from the genlist. Thus, we must call elm_genlist_item_subitems_clear() to
4397 * delete all its subitems, but still keep a way to recreate them when expanding
4398 * the parent again. That's why we are going to keep a node struct for each
4399 * item, that will be the data of the item, with the following information:
4401 * @dontinclude genlist_example_05.c
4405 * This @c Node_Data contains the value for the item, a number indicating its
4406 * level under the tree, a list of children (to be able to expand it later) and
4407 * a boolean indicating if it's a favorite item or not.
4409 * We use 3 different item classes in this example:
4411 * One for items that don't have children:
4418 * One for items that have children:
4425 * And one for items that were favorited:
4431 * The favorite item class is there just to demonstrate the
4432 * elm_genlist_item_item_class_update() function in action. It would be much
4433 * simpler to implement the favorite behavior by just changing the icon inside
4434 * the icon_get functions when the @c favorite boolean is activated.
4436 * Now we are going to declare the callbacks for the buttons that add, delete
4439 * First, a button for appending items to the list:
4441 * @until item_append
4444 * If an item is selected, a new item will be appended to the same level of that
4445 * item, but using the selected item's parent as its parent too. If no item is
4446 * selected, the new item will be appended to the root of the tree.
4448 * Then the callback for marking an item as favorite:
4450 * @until elm_genlist_item_update
4453 * This callback is very simple, it just changes the item class of the selected
4454 * item for the "favorite" one, or go back to the "item" or "parent" class
4455 * depending on that item having children or not.
4457 * Now, the most complex operation (adding a child to an item):
4459 * @until elm_genlist_item_update
4462 * This function gets the data of the selected item, create a new data (for the
4463 * item being added), and appends it to the children list of the selected item.
4465 * Then we must check if the selected item (let's call it @c item1 now) to which
4466 * the new item (called @c item2 from now on) was already a parent item too
4467 * (using the parent item class) or just a normal item (using the default item
4468 * class). In the first case, we just have to append the item to the end of the
4469 * @c item1 children list.
4471 * However, if the @c item1 didn't have any child previously, we have to change
4472 * it to a parent item now. It would be easy to just change its item class to
4473 * the parent type, but there's no way to change the item flags and make it be
4474 * of the type #ELM_GENLIST_ITEM_SUBITEMS. Thus, we have to delete it and create
4475 * a new item, and add this new item to the same position that the deleted one
4476 * was. That's the reason of the checks inside the bigger @c if.
4478 * After adding the item to the newly converted parent, we set it to not
4479 * expanded (since we don't want to show the added item immediately) and select
4480 * it again, since the original item was deleted and no item is selected at the
4483 * Finally, let's show the callback for deleting items:
4485 * @until elm_genlist_item_update
4488 * Since we have an iternal list representing each element of our tree, once we
4489 * delete an item we have to go deleting each child of that item, in our
4490 * internal list. That's why we have the function @c _clear_list, which
4491 * recursively goes freeing all the item data.
4493 * This is necessary because only when we really want to delete the item is when
4494 * we need to delete the item data. When we are just contracting the item, we
4495 * need to hide the children by deleting them, but keeping the item data.
4497 * Now there are two callbacks that will be called whenever the user clicks on
4498 * the expand/contract icon of the item. They will just request to items to be
4499 * contracted or expanded:
4501 * @until elm_genlist_item_expanded_set(
4502 * @until elm_genlist_item_expanded_set(
4505 * When the elm_genlist_item_expanded_set() function is called with @c
4506 * EINA_TRUE, the @c _expanded_cb will be called. And when this happens, the
4507 * subtree of that item must be recreated again. This is done using the internal
4508 * list stored as item data for each item. The function code follows:
4512 * Each appended item is set to contracted, so we don't have to deal with
4513 * checking if the item was contracted or expanded before its parent being
4514 * contracted. It could be easily implemented, though, by adding a flag expanded
4515 * inside the item data.
4517 * Now, the @c _contracted_cb, which is much simpler:
4521 * We just have to call elm_genlist_item_subitems_clear(), that will take care
4522 * of deleting every item, and keep the item data still stored (since we don't
4523 * have any del function set on any of our item classes).
4525 * Finally, the code inside @c elm_main is very similar to the other examples:
4530 * The example will look like this when running:
4532 * @image html screenshots/genlist_example_05.png
4533 * @image latex screenshots/genlistexample_05.eps width=\textwidth
4537 * @page progressbar_example Progress bar widget example
4539 * This application is a thorough example of the progress bar widget,
4540 * consisting of a window with varios progress bars, each with a given
4541 * look/style one can give to those widgets. With two auxiliary
4542 * buttons, one can start or stop a timer which will fill in the bars
4543 * in synchrony, simulating an underlying task being completed.
4545 * We create @b seven progress bars, being three of them horizontal,
4546 * three vertical and a final one under the "wheel" alternate style.
4548 * For the first one, we add a progress bar on total pristine state,
4549 * with no other call than the elm_progressbar_add() one:
4550 * @dontinclude progressbar_example.c
4551 * @skip pb with no label
4553 * See, than, that the defaults of a progress bar are:
4554 * - no primary label shown,
4555 * - unit label set to @c "%.0f %%",
4558 * The second progress bar is given a primary label, <c>"Infinite
4559 * bounce"</c>, and, besides, it's set to @b pulse. See how, after one
4560 * starts the progress timer, with the "Start" button, it animates
4561 * differently than the previous one. It won't account for the
4562 * progress, itself, and just dumbly animate a small bar within its
4564 * @dontinclude progressbar_example.c
4565 * @skip pb with label
4568 * Next, comes a progress bar with an @b icon, a primary label and a
4569 * @b custom unit label set. It's also made to grow its bar in an
4570 * @b inverted manner, so check that out during the timer's progression:
4571 * @dontinclude progressbar_example.c
4574 * Another important thing in this one is the call to
4575 * elm_progressbar_span_size_set() -- this is how we forcefully set a
4576 * minimum horizontal size to our whole window! We're not resizing it
4577 * manually, as you can see in the @ref progressbar_example_c
4580 * The next three progress bars are just variants on the ones already
4581 * shown, but now all being @b vertical. Another time we use one of
4582 * than to give the window a minimum vertical size, with
4583 * elm_progressbar_span_size_set(). To demonstrate this trick once
4584 * more, the fifth one, which is also set to pulse, has a smaller
4585 * hardcoded span size:
4586 * @dontinclude progressbar_example.c
4587 * @skip vertical pb, with pulse
4590 * We end the widget demonstration by showing a progress bar with the
4591 * special @b "wheel" progress bar style. One does @b not need to set
4592 * it to pulse, with elm_progressbar_pulse_set(), explicitly, because
4593 * its theme does not take it in account:
4594 * @dontinclude progressbar_example.c
4598 * The two buttons exercising the bars, the facto, follow:
4599 * @dontinclude progressbar_example.c
4600 * @skip elm_button_add
4601 * @until evas_object_show(bt)
4602 * @until evas_object_show(bt)
4604 * The first of the callbacks will, for the progress bars set to
4605 * pulse, start the pulsing animation at that time. For the others, a
4606 * timer callback will take care of updating the values:
4607 * @dontinclude progressbar_example.c
4608 * @skip static Eina_Bool
4613 * Finally, the callback to stop the progress timer will stop the
4614 * pulsing on the pulsing progress bars and, for the others, to delete
4615 * the timer which was acting on their values:
4616 * @dontinclude progressbar_example.c
4621 * This is how the example program's window looks like:
4622 * @image html screenshots/progressbar_example.png
4623 * @image latex screenshots/progressbar_example.eps width=\textwidth
4625 * See the full @ref progressbar_example_c "source code" for
4628 * @example progressbar_example.c
4632 * @page tutorial_notify Notify example
4633 * @dontinclude notify_example_01.c
4635 * In this example we will have 3 notifys in 3 different positions. The first of
4636 * which will dissapear after 5 seconds or when a click outside it occurs, the
4637 * second and third will not dissapear and differ from each other only in
4640 * We start our example with the usual stuff you've seen in other examples:
4643 * We now create a label to use as the content of our first notify:
4646 * Having the label we move to creating our notify, telling it to block events,
4647 * setting its timeout(to autohide it):
4650 * To have the notify dissapear when a click outside its area occur we have to
4651 * listen to its "block,clicked" signal:
4652 * @until smart_callback
4654 * Our callback will look like this:
4657 * @dontinclude notify_example_01.c
4659 * Next we create another label and another notify. Note, however, that this
4660 * time we don't set a timeout and don't have it block events. What we do is set
4661 * the orient so that this notify will appear in the bottom of its parent:
4662 * @skip smart_callback
4666 * For our third notify the only change is the orient which is now center:
4669 * Now we tell the main loop to run:
4672 * Our example will initially look like this:
4674 * @image html screenshots/notify_example_01.png
4675 * @image latex screenshots/notify_example_01.eps width=\textwidth
4677 * Once the first notify is hidden:
4679 * @image html screenshots/notify_example_01_a.png
4680 * @image latex screenshots/notify_example_01_a.eps width=\textwidth
4682 * @example notify_example_01.c
4686 * @page tutorial_frame Frame example
4687 * @dontinclude frame_example_01.c
4689 * In this example we are going to create 4 Frames with different styles and
4690 * add a rectangle of different color in each.
4692 * We start we the usual setup code:
4695 * And then create one rectangle:
4698 * To add it in our first frame, which since it doesn't have it's style
4699 * specifically set uses the default style:
4702 * And then create another rectangle:
4705 * To add it in our second frame, which uses the "pad_small" style, note that
4706 * even tough we are setting a text for this frame it won't be show, only the
4707 * default style shows the Frame's title:
4709 * @note The "pad_small", "pad_medium", "pad_large" and "pad_huge" styles are
4710 * very similar, their only difference is the size of the empty area around
4711 * the content of the frame.
4713 * And then create yet another rectangle:
4716 * To add it in our third frame, which uses the "outdent_top" style, note
4717 * that even tough we are setting a text for this frame it won't be show,
4718 * only the default style shows the Frame's title:
4721 * And then create one last rectangle:
4724 * To add it in our fourth and final frame, which uses the "outdent_bottom"
4725 * style, note that even tough we are setting a text for this frame it won't
4726 * be show, only the default style shows the Frame's title:
4729 * And now we are left with just some more setup code:
4732 * Our example will look like this:
4734 * @image html screenshots/frame_example_01.png
4735 * @image latex screenshots/frame_example_01.eps width=\textwidth
4737 * @example frame_example_01.c
4741 * @page tutorial_anchorblock_example Anchorblock/Anchorview example
4742 * This example will show both Anchorblock and @ref Anchorview,
4743 * since both are very similar and it's easier to show them once and side
4744 * by side, so the difference is more clear.
4746 * We'll show the relevant snippets of the code here, but the full example
4747 * can be found here... sorry, @ref anchorblock_example_01.c "here".
4749 * As for the actual example, it's just a simple window with an anchorblock
4750 * and an anchorview, both containing the same text. After including
4751 * Elementary.h and declaring some functions we'll need, we jump to our
4752 * elm_main (see ELM_MAIN) and create our window.
4753 * @dontinclude anchorblock_example_01.c
4758 * With the needed variables declared, we'll create the window and a box to
4759 * hold our widgets, but we don't need to go through that here.
4761 * In order to make clear where the anchorblock ends and the anchorview
4762 * begins, they'll be each inside a @ref Frame. After creating the frame,
4763 * the anchorblock follows.
4764 * @skip elm_frame_add
4765 * @until elm_frame_content_set
4767 * Nothing out of the ordinary there. What's worth mentioning is the call
4768 * to elm_anchorblock_hover_parent_set(). We are telling our widget that
4769 * when an anchor is clicked, the hover for the popup will cover the entire
4770 * window. This affects the area that will be obscured by the hover and
4771 * where clicking will dismiss it, as well as the calculations it does to
4772 * inform the best locations where to insert the popups content.
4773 * Other than that, the code is pretty standard. We also need to set our
4774 * callback for when an anchor is clicked, since it's our task to populate
4775 * the popup. There's no default for it.
4777 * The anchorview is no different, we only change a few things so it looks
4779 * @until elm_frame_content_set
4781 * Then we run, so stuff works and close our main function in the usual way.
4784 * Now, a little note. Normally you would use either one of anchorblock or
4785 * anchorview, set your one callback to clicks and do your stuff in there.
4786 * In this example, however, there are a few tricks to make it easier to
4787 * show both widgets in one go (and to save me some typing). So we have
4788 * two callbacks, one per widget, that will call a common function to do
4789 * the rest. The trick is using ::Elm_Entry_Anchorblock_Info for the
4790 * anchorview too, since both are equal, and passing a callback to use
4791 * for our buttons to end the hover, because each widget has a different
4793 * @until _anchorview_clicked_cb
4796 * The meat of our popup is in the following function. We check what kind
4797 * of menu we need to show, based on the name set to the anchor in the
4798 * markup text. If there's no type (something went wrong, no valid contact
4799 * in the address list) we are just putting a button that does nothing, but
4800 * it's perfectly reasonable to just end the hover and call it quits.
4802 * Our popup will consist of one main button in the middle of our hover,
4803 * and possibly a secondary button and a list of other options. We'll create
4804 * first our main button and check what kind of popup we need afterwards.
4807 * @until eina_stringshare_add
4810 * Each button has two callbacks, one is our hack to close the hover
4811 * properly based on which widget it belongs to, the other a simple
4812 * printf that will show the action with the anchors own data. This is
4813 * not how you would usually do it. Instead, the common case is to have
4814 * one callback for the button that will know which function to call to end
4815 * things, but since we are doing it this way it's worth noting that
4816 * smart callbacks will be called in reverse in respect to the order they
4817 * were added, and since our @c btn_end_cb will close the hover, and thus
4818 * delete our buttons, the other callback wouldn't be called if we had
4821 * After our telephone popup, there are a few others that are practically
4822 * the same, so they won't be shown here.
4824 * Once we are done with that, it's time to place our actions into our
4825 * hover. Main button goes in the middle without much questioning, and then
4826 * we see if we have a secondary button and a box of extra options.
4827 * Because I said so, secondary button goes on either side and box of
4828 * options either on top or below the main one, but to choose which
4829 * exactly, we use the hints our callback info has, which saves us from
4830 * having to do the math and see which side has more space available, with
4831 * a little special case where we delete our extra stuff if there's nowhere
4835 * @skip evas_object_smart
4836 * @until evas_object_del(box)
4840 * The example will look like this:
4842 * @image html screenshots/anchorblock_01.png
4843 * @image latex screenshots/anchorblock_01.eps width=\textwidth
4845 * @example anchorblock_example_01.c
4849 * @page tutorial_check Check example
4850 * @dontinclude check_example_01.c
4852 * This example will show 2 checkboxes, one with just a label and the second
4853 * one with both a label and an icon. This example also ilustrates how to
4854 * have the checkbox change the value of a variable and how to react to those
4857 * We will start with the usual setup code:
4860 * And now we create our first checkbox, set its label, tell it to change
4861 * the value of @p value when the checkbox stats is changed and ask to be
4862 * notified of state changes:
4865 * For our second checkbox we are going to set an icon so we need to create
4868 * @note For simplicity we are using a rectangle as icon, but any evas object
4871 * And for our second checkbox we set the label, icon and state to true:
4874 * We now do some more setup:
4877 * And finally implement the callback that will be called when the first
4878 * checkbox's state changes. This callback will use @p data to print a
4881 * @note This work because @p data is @p value(from the main function) and @p
4882 * value is changed when the checkbox is changed.
4884 * Our example will look like this:
4886 * @image html screenshots/check_example_01.png
4887 * @image latex screenshots/check_example_01.eps width=\textwidth
4889 * @example check_example_01.c
4893 * @page tutorial_colorselector Color selector example
4894 * @dontinclude colorselector_example_01.c
4896 * This example shows how to change the color of a rectangle using a color
4897 * selector. We aren't going to explain a lot of the code since it's the
4901 * Now that we have a window with background and a rectangle we can create
4902 * our color_selector and set it's initial color to fully opaque blue:
4905 * Next we tell ask to be notified whenever the color changes:
4908 * We follow that we some more run of the mill setup code:
4911 * And now get to the callback that sets the color of the rectangle:
4914 * This example will look like this:
4916 * @image html screenshots/colorselector_example_01.png
4917 * @image latex screenshots/colorselector_example_01.eps width=\textwidth
4919 * @example colorselector_example_01.c
4923 * @page slideshow_example Slideshow widget example
4925 * This application is aimed to exemplify the slideshow widget. It
4926 * consists of a window with a slideshow widget set as "resize
4927 * object", along with a control bar, in the form of a notify. Those
4928 * controls will exercise most of the slideshow's API functions.
4930 * We create the slideshow, itself, first, making it @b loop on its
4931 * image itens, when in slideshow mode:
4932 * @dontinclude slideshow_example.c
4933 * @skip slideshow = elm_slideshow_add
4934 * @until evas_object_show
4936 * Next, we define the <b>item class</b> for our slideshow
4937 * items. Slideshow images are going to be Elementary @ref Photo "photo"
4938 * widgets, here, as pointed by our @c get class
4939 * function. We'll let the Elementary infrastructure to delete those
4940 * objects for us, and, as there's no additional data attached to our
4941 * slideshow items, the @c del class function can be left undefined:
4942 * @dontinclude slideshow_example.c
4945 * @dontinclude slideshow_example.c
4948 * @dontinclude slideshow_example.c
4949 * @skip get our images to make slideshow items
4952 * We now get to populate the slideshow widget with items. Our images
4953 * are going to be some randomly chosen from the Elementary package,
4954 * nine of them. For the first eight, we insert them ordered in the
4955 * widget, by using elm_slideshow_item_sorted_insert(). The comparing
4956 * function will use the image names to sort items. The last item is
4957 * inserted at the end of the slideshow's items list, with
4958 * elm_slideshow_item_add(). We check out how that list ends with
4959 * elm_slideshow_items_get(), than:
4960 * @dontinclude slideshow_example.c
4961 * @skip static const char *img
4963 * @dontinclude slideshow_example.c
4967 * Note that we save the pointers to the first and last items in the
4968 * slideshow, for future use.
4970 * What follows is the code creating a notify, to be shown over the
4971 * slideshow's viewport, with knobs to act on it. We're not showing
4972 * that boilerplate code, but only the callbacks attached to the
4973 * interesting smart events of those knobs. The first four are
4974 * buttons, which will:
4975 * - Select the @b next item in the slideshow
4976 * - Select the @b previous item in the slideshow
4977 * - Select the @b first item in the slideshow
4978 * - Select the @b last item in the slideshow
4980 * Check out the code for those four actions, being the two last @c
4981 * data pointers the same @c first and @c last pointers we save
4982 * before, respectively:
4983 * @dontinclude slideshow_example.c
4984 * @skip jump to next
4990 * What follow are two hoversels, meant for one to change the
4991 * slideshow's @b transition and @b layout styles, respectively. We
4992 * fetch all the available transition and layout names to populate
4993 * those widgets and, when one selects any of them, we apply the
4994 * corresponding setters on the slideshow:
4995 * @dontinclude slideshow_example.c
4996 * @skip hv = elm_hoversel_add
4999 * @dontinclude slideshow_example.c
5000 * @skip transition changed
5004 * For one to change the transition @b time on the slideshow widget,
5005 * we use a spinner widget. We set it to the initial value of 3
5006 * (seconds), which will be probed by the next knob -- a button
5007 * starting the slideshow, de facto. Note that changing the transition
5008 * time while a slideshow is already happening will ajust its
5010 * @dontinclude slideshow_example.c
5011 * @skip spin = elm_spinner_add
5012 * @until evas_object_show
5013 * @dontinclude slideshow_example.c
5014 * @skip slideshow transition time has
5017 * Finally, we have two buttons which will, respectively, start and
5018 * stop the slideshow on our widget. Here are their "clicked"
5020 * @dontinclude slideshow_example.c
5021 * @skip start the show
5025 * This is how the example program's window looks like:
5026 * @image html screenshots/slideshow_example.png
5027 * @image latex screenshots/slideshow_example.eps width=\textwidth
5029 * See the full @ref slideshow_example_c "source code" for
5032 * @example slideshow_example.c
5036 * @page tutorial_photocam Photocam example
5037 * @dontinclude photocam_example_01.c
5039 * In this example we will have a photocam and a couple of buttons and slider to
5040 * control the photocam. To avoid cluttering we'll only show the parts of the
5041 * example that relate to the photocam, the full source code can be seen @ref
5042 * photocam_example_01.c "here".
5044 * Creating a photocam is as easy as creating any other widget:
5045 * @skipline elm_photocam_add
5047 * A photocam is only useful if we have a image on it, so lets set a file for it
5051 * We now set the photocam to not bounce horizontally:
5054 * And we want to know when the photocam has finished loading the image so:
5055 * @until smart_callback
5057 * The reason to know when the image is loaded is so that we can bring the
5058 * center of the image into view:
5062 * As mentioned we have 2 buttons in this example, the "Fit" one will cause
5063 * the photocam to go in to a zoom mode that makes the image fit inside the
5064 * photocam. Tough this has no effect on the image we also print what region was
5065 * being viewed before setting the zoom mode:
5067 * @note When in fit mode our slider(explained below) won't work.
5069 * The second button("Unfit") will bring the photocam back into manual zoom
5073 * Our slider controls the level of zoom of the photocam:
5075 * @note It is important to note that this only works when in manual zoom mode.
5077 * Our example will initially look like this:
5079 * @image html screenshots/photocam_example_01.png
5080 * @image latex screenshots/photocam_example_01.eps width=\textwidth
5082 * @example photocam_example_01.c
5086 * @page inwin_example_01 Inwin - General overview
5088 * Inwin is a very simple widget to show, so this example will be a very simple
5089 * one, just using all of the available API.
5091 * The program is nothing but a window with a lonely button, as shown here.
5093 * @image html screenshots/inwin_example.png
5094 * @image latex screenshots/inwin_example.eps width=\textwidth
5096 * And pressing the button makes an inwin appear.
5098 * @image html screenshots/inwin_example_a.png
5099 * @image latex screenshots/inwin_example_a.eps width=\textwidth
5101 * And the code is just as simple. We being with some global variables to keep
5102 * track of our Inwin.
5103 * @dontinclude inwin_example.c
5105 * @until current_style
5107 * And two callbacks used by the buttons the above screenshot showed. In these,
5108 * we check if @c inwin exists and execute the proper action on it. If it's not
5109 * there anymore, then we were abandoned to our luck, so we disabled ourselves.
5110 * @until _inwin_destroy
5114 * The lonely button from the beginning, when clicked, will call the following
5115 * function, which begins by checking if an inwin exists, and if it's there,
5116 * we bring it back to the front and exit from our function without any further
5120 * But if no inwin is there to show, we need to create one. First we need the
5121 * top-most window for the program, as no inwin can be created using other
5122 * objects as parents. Then we create our popup, set the next style in the list
5124 * @until current_style =
5126 * As for the content of our inwin, it's just a box with a label and some
5128 * @until _inwin_destroy
5131 * Now, all the code above shows how every object must always be set as content
5132 * for some other object, be it by setting the full content, packing it in a
5133 * box or table or working as icon for some other widget. But we didn't do
5134 * anything like that for the inwin, this one is just created and shown and
5135 * everything works. Other widgets can be used this way, but they would need
5136 * to be placed and resized manually or nothing would be shown correctly. The
5137 * inwin, however, sets itself as a children of the top-level window and will
5138 * be resized as the parent window changes too.
5140 * Another characteristic of Inwin is that when it's shown above everyone else,
5141 * it will work kind of like a modal window, blocking any other widget from
5142 * receiving events until the window is manually dismissed by pressing some
5143 * button to close it or having blocking task signalling its completion so
5144 * normal operations can be resumed. This is unlike the @ref Hover widget,
5145 * that would show its content on top of the designated target, but clicking
5146 * anywhere else would dismiss it automatically.
5148 * To illustrate that last point, when we close the main window and an inwin
5149 * is still there, we'll take out the content from the inwin and place it in
5154 * And the rest of the program doesn't have anything else related to inwin,
5155 * so it won't be shown here, but you can find it in
5156 * @ref inwin_example.c "inwin_example.c".
5158 * @example inwin_example.c
5162 * @page tutorial_scroller Scroller example
5163 * @dontinclude scroller_example_01.c
5165 * This example is very short and will illustrate one way to use a scroller.
5166 * We'll omit the declaration of the @p text variable because it's a very long
5167 * @htmlonly<a href="http://lipsum.com/">@endhtmlonly ipsum lorem
5168 * @htmlonly</a>@endhtmlonly. If you really want to see the full code, it's @ref
5169 * scroller_example_01.c "scroller_example_01.c".
5171 * We start our example by creating our window and background:
5175 * Next we create a label and set it's text to @p text(very long ipsum lorem):
5176 * @until show(label)
5178 * We then create our scroller, ask that it have the same size as the window and
5180 * @until content_set
5182 * We are now going to set a number of properties in our scroller:
5183 * @li We make it bounce horizontally but not vertically.
5184 * @li We make both scrollbars always be visible.
5185 * @li We have the events be propagated from the content to the scroller.
5186 * @li We enforce a page policy vertically(having a page be the size of the
5187 * viewport) and leave horizontal scrolling free.
5188 * @li And finally we ask the scroller to show us a region starting at 50,50 and
5189 * having a width and height of 200px.
5190 * @until region_show
5191 * @note Observant reader will note that the elm_scroller_region_show() didn't
5192 * scroll the view vertically, this is because we told the scroller to only
5193 * accept vertical scrolling in pages.
5195 * And now we're done:
5198 * Our example will look like this:
5200 * @image html screenshots/scroller_example_01.png
5201 * @image latex screenshots/scroller_example_01.eps width=\textwidth
5203 * @example scroller_example_01.c
5207 * @page tutorial_table_01
5209 * In this example we add four labels to a homogeneous table that has a padding
5210 * of 5px between cells.
5212 * The interesting bits from this example are:
5213 * @li Where we set the table as homogeneous and the padding:
5214 * @dontinclude table_example_01.c
5216 * @until homogeneous_set
5217 * @li Where we add each label to the table:
5218 * @skipline elm_table_pack
5219 * @skipline elm_table_pack
5220 * @skipline elm_table_pack
5221 * @skipline elm_table_pack
5223 * Here you can see the full source:
5224 * @include table_example_01.c
5226 * Our example will look like this:
5228 * @image html screenshots/table_example_01.png
5229 * @image latex screenshots/table_example_01.eps width=\textwidth
5231 * @example table_example_01.c
5235 * @page tutorial_table_02
5237 * For our second example we'll create a table with 4 rectangles in it. Since
5238 * our rectangles are of different sizes our table won't be homogeneous.
5240 * The interesting bits from this example are:
5241 * @li Where we set the table as not homogeneous:
5242 * @dontinclude table_example_02.c
5243 * @skipline homogeneous_set
5244 * @li Where we add each rectangle to the table:
5245 * @skipline elm_table_pack
5246 * @skipline elm_table_pack
5247 * @skipline elm_table_pack
5248 * @skipline elm_table_pack
5250 * Here you can see the full source:
5251 * @include table_example_02.c
5253 * Our example will look like this:
5255 * @image html screenshots/table_example_02.png
5256 * @image latex screenshots/table_example_02.eps width=\textwidth
5258 * @example table_example_02.c
5262 * @page bg_example_01_c bg_example_01.c
5263 * @include bg_example_01.c
5264 * @example bg_example_01.c
5268 * @page bg_example_02_c bg_example_02.c
5269 * @include bg_example_02.c
5270 * @example bg_example_02.c
5274 * @page bg_example_03_c bg_example_03.c
5275 * @include bg_example_03.c
5276 * @example bg_example_03.c
5280 * @page actionslider_example_01 Actionslider example
5281 * @include actionslider_example_01.c
5282 * @example actionslider_example_01.c
5286 * @page animator_example_01_c Animator example 01
5287 * @include animator_example_01.c
5288 * @example animator_example_01.c
5292 * @page transit_example_01_c Transit example 1
5293 * @include transit_example_01.c
5294 * @example transit_example_01.c
5298 * @page transit_example_02_c Transit example 2
5299 * @include transit_example_02.c
5300 * @example transit_example_02.c
5304 * @page general_functions_example_c General (top-level) functions example
5305 * @include general_funcs_example.c
5306 * @example general_funcs_example.c
5310 * @page clock_example_c Clock example
5311 * @include clock_example.c
5312 * @example clock_example.c
5316 * @page flipselector_example_c Flipselector example
5317 * @include flipselector_example.c
5318 * @example flipselector_example.c
5322 * @page fileselector_example_c Fileselector example
5323 * @include fileselector_example.c
5324 * @example fileselector_example.c
5328 * @page fileselector_button_example_c Fileselector button example
5329 * @include fileselector_button_example.c
5330 * @example fileselector_button_example.c
5334 * @page fileselector_entry_example_c Fileselector entry example
5335 * @include fileselector_entry_example.c
5336 * @example fileselector_entry_example.c
5340 * @page index_example_01_c Index example
5341 * @include index_example_01.c
5342 * @example index_example_01.c
5346 * @page index_example_02_c Index example
5347 * @include index_example_02.c
5348 * @example index_example_02.c
5352 * @page layout_example_01_c layout_example_01.c
5353 * @include layout_example_01.c
5354 * @example layout_example_01.c
5358 * @page layout_example_02_c layout_example_02.c
5359 * @include layout_example_02.c
5360 * @example layout_example_02.c
5364 * @page layout_example_03_c layout_example_03.c
5365 * @include layout_example_03.c
5366 * @example layout_example_03.c
5370 * @page layout_example_edc An example of layout theme file
5372 * This theme file contains two groups. Each of them is a different theme, and
5373 * can be used by an Elementary Layout widget. A theme can be used more than
5374 * once by many different Elementary Layout widgets too.
5376 * @include layout_example.edc
5377 * @example layout_example.edc
5381 * @page gengrid_example_c Gengrid example
5382 * @include gengrid_example.c
5383 * @example gengrid_example.c
5387 * @page genlist_example_01_c genlist_example_01.c
5388 * @include genlist_example_01.c
5389 * @example genlist_example_01.c
5393 * @page genlist_example_02_c genlist_example_02.c
5394 * @include genlist_example_02.c
5395 * @example genlist_example_02.c
5399 * @page genlist_example_04_c genlist_example_04.c
5400 * @include genlist_example_04.c
5401 * @example genlist_example_04.c
5405 * @page genlist_example_05_c genlist_example_05.c
5406 * @include genlist_example_05.c
5407 * @example genlist_example_05.c
5411 * @page progressbar_example_c Progress bar example
5412 * @include progressbar_example.c
5413 * @example progressbar_example.c
5417 * @page slideshow_example_c Slideshow example
5418 * @include slideshow_example.c
5419 * @example slideshow_example.c