+/**
+ * @page tutorial_hoversel Hoversel example
+ * @dontinclude hoversel_example_01.c
+ *
+ * In this example we will create a hoversel with 3 items, one with a label but
+ * no icon and two with both a label and an icon. Every item that is clicked
+ * will be deleted, but everytime the hoversel is activated we will also add an
+ * item. In addition our first item will print all items when clicked and our
+ * third item will clear all items in the hoversel.
+ *
+ * We will start with the normal creation of window stuff:
+ * @until show(bg)
+ *
+ * Next we will create a red rectangle to use as the icon of our hoversel:
+ * @until show
+ *
+ * And now we create our hoversel and set some of it's properties. We set @p win
+ * as its parent, ask it to not be horizontal(be vertical) and give it a label
+ * and icon:
+ * @until icon_set
+ *
+ * Next we will add our three items, setting a callback to be called for the
+ * first and third:
+ * @until _rm_items
+ *
+ * We also set a pair of callbacks to be called whenever any item is selected or
+ * when the hoversel is activated:
+ * @until clicked
+ *
+ * And then ask that our hoversel be shown and run the main loop:
+ * @until ELM_MAIN
+ *
+ * We now have the callback for our first item which prints all items in the
+ * hoversel:
+ * @until }
+ *
+ * Next we have the callback for our third item which removes all items from the
+ * hoversel:
+ * @until }
+ *
+ * Next we have the callback that is called whenever an item is clicked and
+ * deletes that item:
+ * @until }
+ *
+ * And the callback that is called when the hoversel is activated and adds an
+ * item to the hoversel. Note that since we allocate memory for the item we need
+ * to know when the item dies so we can free that memory:
+ * @until }
+ *
+ * And finally the callback that frees the memory we allocated for items created
+ * in the @p _add_item callback:
+ * @until }
+ *
+ * Our example will initially look like this:
+ *
+ * @image html screenshots/hoversel_example_01.png
+ * @image latex screenshots/hoversel_example_01.eps width=\textwidth
+ *
+ * And when the hoversel is clicked it will look like this:
+ *
+ * @image html screenshots/hoversel_example_01_a.png
+ * @image latex screenshots/hoversel_example_01_a.eps width=\textwidth
+ *
+ * @example hoversel_example_01.c
+ */
+
+/**
+ * @page conformant_example Conformant Example.
+ *
+ * In this example we'll explain how to create applications to work
+ * with illume, considering space required for virtual keyboards, indicator
+ * and softkeys.
+ *
+ * Illume is a module for Enlightenment that modifies the user interface
+ * to work cleanly and nicely on a mobile device. It has support for
+ * virtual keyboard, among other nice features.
+ *
+ * Let's start creating a very simple window with a vertical box
+ * with multi-line entry between two buttons.
+ * This entry will expand filling all space on window not used by buttons.
+ *
+ * @dontinclude conformant_example_01.c
+ * @skipline elm_main
+ * @until }
+ *
+ * For information about how to create windows, boxes, buttons or entries,
+ * look for documentation for these widgets.
+ *
+ * It will looks fine when you don't need a virtual keyboard, as you
+ * can see on the following image:
+ *
+ * @image html screenshots/conformant_example_01.png
+ * @image latex screenshots/conformant_example_01.eps width=\textwidth
+ *
+ * But if you call a virtual keyboard, the window will resize, changing
+ * widgets size and position. All the content will shrink.
+ *
+ * If you don't want such behaviour, you
+ * will need a conformant to account for space taken up by the indicator,
+ * virtual keyboard and softkey.
+ *
+ * In this case, using the conformant in a proper way, you will have
+ * a window like the following:
+ *
+ * @image html screenshots/conformant_example_02.png
+ * @image latex screenshots/conformant_example_02.eps width=\textwidth
+ *
+ * As you can see, it guess the space that will be required by the keyboard,
+ * indicator and softkey bars.
+ *
+ * So, let's study each step required to transform our initial example on
+ * the second one.
+ *
+ * First of all, we need to set the window as an illume conformant window:
+ * @dontinclude conformant_example_02.c
+ * @skipline elm_win_conformant_set
+ *
+ * Next, we'll add a conformant widget, and set it to resize with the window,
+ * instead of the box.
+ * @skipline conform
+ * @until evas_object_show
+ *
+ * Finally, we'll set the box as conformant's content, just like this:
+ * @skipline elm_object_content_set
+ *
+ * Compare both examples code:
+ * @ref conformant_example_01.c "conformant_example_01.c"
+ * @ref conformant_example_02.c "conformant_example_02.c"
+ *
+ * @example conformant_example_01.c
+ * @example conformant_example_02.c
+ */
+
+/**
+ * @page index_example_01 Index widget example 1
+ *
+ * This code places an Elementary index widget on a window, which also
+ * has a very long list of arbitrary strings on it. The list is
+ * sorted alphabetically and the index will be used to index the first
+ * items of each set of strings beginning with an alphabet letter.
+ *
+ * Below the list are some buttons, which are there just to exercise
+ * some index widget's API.
+ *
+ * Here's how we instantiate it:
+ * @dontinclude index_example_01.c
+ * @skip elm_list_add
+ * @until evas_object_show(d.index)
+ * where we're showing also the list being created. Note that we issue
+ * elm_win_resize_object_add() on the index, so that it's set to have
+ * the whole window as its container. Then, we have to populate both
+ * list and index widgets:
+ * @dontinclude index_example_01.c
+ * @skip for (i = 0; i < (sizeof(dict) / sizeof(dict[0])); i++)
+ * @until }
+ * @until }
+ *
+ * The strings populating the list come from a file
+ * @dontinclude index_example_01.c
+ * @skip static const char *dict
+ * @until }
+ *
+ * We use the @c curr char variable to hold the last initial letter
+ * seen on that ordered list of strings, so that we're able to have an
+ * index item pointing to each list item starting a new letter
+ * "section". Note that our index item data pointers will be the list
+ * item handles. We are also setting a callback function to index
+ * items deletion events:
+ * @dontinclude index_example_01.c
+ * @skip static void
+ * @until }
+ *
+ * There, we show you that the @c event_info pointer will contain the
+ * item in question's data, i.e., a given list item's pointer. Because
+ * item data is also returned in the @c data argument on
+ * @c Evas_Smart_Cb functions, those two pointers must have the same
+ * values. On this deletion callback, we're deleting the referred list
+ * item too, just to exemplify that anything could be done there.
+ *
+ * Next, we hook to two smart events of the index object:
+ * @dontinclude index_example_01.c
+ * @skip smart_callback_add(d.index
+ * @until _index_selected
+ * @dontinclude index_example_01.c
+ * @skip "delay,changed" hook
+ * @until }
+ * @until }
+ *
+ * Check that, whenever one holds the mouse pressed over a given index
+ * letter for some time, the list beneath it will roll down to the
+ * item pointed to by that index item. When one releases the mouse
+ * button, the second callback takes place. There, we check that the
+ * reported item data, on @c event_info, is the same reported by
+ * elm_index_item_selected_get(), which gives the last selection's
+ * data on the index widget.
+ *
+ * The first of the three buttons that follow will call
+ * elm_index_active_set(), thus showing the index automatically for
+ * you, if it's not already visible, what is checked with
+ * elm_index_active_get(). The second button will exercise @b deletion
+ * of index item objects, by the following code:
+ * @dontinclude index_example_01.c
+ * @skip delete an index item
+ * @until }
+ *
+ * It will get the last index item selected's data and find the
+ * respective #Elm_Index_Item handle with elm_index_item_find(). We
+ * need the latter to query the indexing letter string from, with
+ * elm_index_item_letter_get(). Next, comes the delition, itself,
+ * which will also trigger the @c _index_item_del callback function,
+ * as said above.
+ *
+ * The third button, finally, will exercise elm_index_item_clear(),
+ * which will delete @b all of the index's items.
+ *
+ * This is how the example program's window looks like with the index
+ * widget hidden:
+ * @image html screenshots/index_example_00.png
+ * @image latex screenshots/index_example_00.eps
+ *
+ * When it's shown, it's like the following figure:
+ * @image html screenshots/index_example_01.png
+ * @image latex screenshots/index_example_01.eps
+ *
+ * See the full @ref index_example_01_c "source code" for
+ * this example.
+ *
+ * @example index_example_01.c
+ */
+
+/**
+ * @page index_example_02 Index widget example 2
+ *
+ * This code places an Elementary index widget on a window, indexing
+ * grid items. The items are placed so that their labels @b don't
+ * follow any order, but the index itself is ordered (through
+ * elm_index_item_sorted_insert()). This is a complement to to @ref
+ * index_example_01 "the first example on indexes".
+ *
+ * Here's the list of item labels to be used on the grid (in that
+ * order):
+ * @dontinclude index_example_02.c
+ * @skip static const char *items
+ * @until };
+ *
+ * In the interesting part of the code, here, we first instantiate the
+ * grid (more on grids on their examples) and, after creating our
+ * index, for each grid item we also create an index one to reference
+ * it:
+ * @dontinclude index_example_02.c
+ * @skip grid = elm_gengrid_add
+ * @until }
+ * @until smart_callback_add
+ *
+ * The order in which they'll appear in the index, though, is @b
+ * alphabetical, becase of elm_index_item_sorted_insert() usage
+ * together with the comparing function, where we take the letters of
+ * each index item to base our ordering on. The parameters on
+ * @c _index_cmp have to be declared as void pointers because of the
+ * @c Eina_Compare_Cb prototype requisition, but in this case we know
+ * they'll be #Elm_Index_Item's:
+ * @dontinclude index_example_02.c
+ * @skip ordering alphabetically
+ * @until }
+ *
+ * The last interesting bit is the callback in the @c "delay,changed"
+ * smart event, which will bring the given grid item to the grid's
+ * visible area:
+ * @dontinclude index_example_02.c
+ * @skip static void
+ * @until }
+ *
+ * Note how the grid will move kind of randomly while you move your
+ * mouse pointer held over the index from top to bottom -- that's
+ * because of the the random order the items have in the grid itself.
+ *
+ * This is how the example program's window looks like:
+ * @image html screenshots/index_example_03.png
+ * @image latex screenshots/index_example_03.eps
+ *
+ * See the full @ref index_example.c "source code" for
+ * this example.
+ *
+ * @example index_example_02.c
+ */
+
+/**
+ * @page tutorial_ctxpopup Ctxpopup example
+ * @dontinclude ctxpopup_example_01.c
+ *
+ * In this example we have a list with two items, when either item is clicked
+ * a ctxpopup for it will be shown. Our two ctxpopups are quite different, the
+ * one for the first item is a vertical and it's items contain both labels and
+ * icons, the one for the second item is horizontal and it's items have icons
+ * but not labels.
+ *
+ * We will begin examining our example code by looking at the callback we'll use
+ * when items in the ctxpopup are clicked. It's very simple, all it does is
+ * print the label present in the ctxpopup item:
+ * @until }
+ *
+ * Next we examine a function that creates ctxpopup items, it was created to
+ * avoid repeating the same code whenever we needed to add an item to our
+ * ctxpopup. Our function creates an icon from the standard set of icons, and
+ * then creates the item, with the label received as an argument. We also set
+ * the callback to be called when the item is clicked:
+ * @until }
+ *
+ * Finally we have the function that will create the ctxpopup for the first item
+ * in our list. This one is somewhat more complex though, so let's go through it
+ * in parts. First we declare our variable and add the ctxpopup:
+ * @until ctxpopup_add
+ *
+ * Next we create a bunch of items for our ctxpopup, marking two of them as
+ * disabled just so we can see what that will look like:
+ * @until disabled_set
+ * @until disabled_set
+ *
+ * Then we ask evas where the mouse pointer was so that we can have our ctxpopup
+ * appear in the right place, set a maximum size for the ctxpopup, move it and
+ * show it:
+ * @until show
+ *
+ * And last we mark the list item as not selected:
+ * @until }
+ *
+ * Our next function is the callback that will create the ctxpopup for the
+ * second list item, it is very similar to the previous function. A couple of
+ * interesting things to note is that we ask our ctxpopup to be horizontal, and
+ * that we pass NULL as the label for every item:
+ * @until }
+ *
+ * And with all of that in place we can now get to our main function where we
+ * create the window, the list, the list items and run the main loop:
+ * @until ELM_MAIN()
+ *
+ * The example will initially look like this:
+ *
+ * @image html screenshots/ctxpopup_example_01.png
+ * @image latex screenshots/ctxpopup_example_01.eps width=\textwidth
+ *
+ * @note This doesn't show the ctxpopup tough, since it will only appear when
+ * we click one of the list items.
+ *
+ * Here is what our first ctxpopup will look like:
+ *
+ * @image html screenshots/ctxpopup_example_01_a.png
+ * @image latex screenshots/ctxpopup_example_01_a.eps width=\textwidth
+ *
+ * And here the second ctxpopup:
+ *
+ * @image html screenshots/ctxpopup_example_01_b.png
+ * @image latex screenshots/ctxpopup_example_01_b.eps width=\textwidth
+ *
+ * @example ctxpopup_example_01.c
+ */
+
+/**
+ * @page tutorial_pager
+ * @dontinclude pager_example_01.c
+ *
+ * In this example we'll have a pager with 3 rectangles on it, one blue, one
+ * green and one blue, we'll also have 1 button for each rectangle. Pressing a
+ * button will bring the associated rectangle to the front of the pager(promote
+ * it).
+ *
+ * We start our example with some run of the mill code that you've seen in other
+ * examples:
+ * @until show
+ *
+ * And then we get right to creating our pager, setting a style and some basic
+ * properties to it:
+ * @until show
+ *
+ * Well a pager without any content is not of much use, so let's create the
+ * first of our rectangles, add it to the pager and create the button for it:
+ * @until smart_callback
+ * @note The only line of above code that directly relates to our pager is the
+ * call to elm_pager_content_push().
+ *
+ * And now we will do the same thing again twice for our next two rectangles:
+ * @until smart_callback
+ * @until smart_callback
+ *
+ * Now that we haver our widgets create we can get to running the main loop:
+ * @until ELM_MAIN
+ *
+ * We also have the callback that is called when any of the buttons is pressed,
+ * this callback is receiving the rectangle in it's @p data argument, so we
+ * check if it's already on top and if not move it there:
+ * @until }
+ *
+ * Our example will look like this:
+ *
+ * @image html screenshots/pager_example_01.png
+ * @image latex screenshots/pager_example_01.eps width=\textwidth
+ * @note Like all examples that involve animations the screenshot doesn't do it
+ * justice, seeing it in action is a must.
+ *
+ * @example pager_example_01.c
+ */
+
+/**
+ * @page tutorial_separator Separator example
+ * @dontinclude separator_example_01.c
+ *
+ * In this example we are going to pack two rectangles in a box, and have a
+ * separator in the middle.
+ *
+ * So we start we the window, background, box and rectangle creation, all pretty
+ * normal stuff:
+ * @until pack_end
+ *
+ * Once we have our first rectangle in the box we create and add our separator:
+ * @until pack_end
+ * @note Since our box is in horizontal mode it's a good idea to set the
+ * separator to be horizontal too.
+ *
+ * And now we add our second rectangle and run the main loop:
+ * @until ELM_MAIN
+ *
+ * This example will look like this:
+ *
+ * @image html screenshots/separator_example_01.png
+ * @image latex screenshots/separator_example_01.eps width=\textwidth
+ *
+ * @example separator_example_01.c
+ */
+
+/**
+ * @page tutorial_radio Radio example
+ * @dontinclude radio_example_01.c
+ *
+ * In this example we will create 4 radio buttons, three of them in a group and
+ * another one not in the group. We will also have the radios in the group
+ * change the value of a variable directly and have then print it when the value
+ * changes. The fourth button is in the example just to make clear that radios
+ * outside the group don't affect the group.
+ *
+ * We'll start with the usual includes:
+ * @until #endif
+ *
+ * And move right to declaring a static variable(the one whose value the radios
+ * will change):
+ * @until static
+ *
+ * We now need to have a window and all that good stuff to be able to place our
+ * radios in:
+ * @until show(bx)
+ *
+ * And now we create a radio button, since this is the first button in our group
+ * we set the group to be the radio(so we can set the other radios in the same
+ * group). We also set the state value of this radio to 1 and the value pointer
+ * to @p val, since val is @p 1 this has the additional effect of setting the
+ * radio value to @p 1. For this radio we choose the default home icon:
+ * @until show
+ *
+ * To check that our radio buttons are working we'll add a callback to the
+ * "changed" signal of the radio:
+ * @until smart_callback
+ *
+ * The creation of our second radio button is almost identical, the 2
+ * differences worth noting are, the value of this radio 2 and that we add this
+ * radio to the group of the first radio:
+ * @until smart_callback
+ *
+ * For our third callback we'll omit the icon and set the value to 3, we'll also
+ * add it to the group of the first radio:
+ * @until smart_callback
+ *
+ * Our fourth callback has a value of 4, no icon and most relevantly is not a
+ * member of the same group as the other radios:
+ * @until show
+ *
+ * We finally run the main loop:
+ * @until ELM_MAIN
+ *
+ * And the last detail in our example is the callback that prints @p val so that
+ * we can see that the radios are indeed changing its value:
+ * @until }
+ *
+ * The example will look like this:
+ *
+ * @image html screenshots/radio_example_01.png
+ * @image latex screenshots/radio_example_01.eps width=\textwidth
+ *
+ * @example radio_example_01.c
+ */
+
+/**
+ * @page tutorial_toggle Toggle example
+ * @dontinclude toggle_example_01.c
+ *
+ * In this example we'll create 2 toggle widgets. The first will have an icon
+ * and the state names will be the default "on"/"off", it will also change the
+ * value of a variable directly. The second won't have a icon, the state names
+ * will be "Enabled"/"Disabled", it will start "Enabled" and it won't set the
+ * value of a variable.
+ *
+ * We start with the usual includes and prototype for callback which will be
+ * implemented and detailed later on:
+ * @until _cb2
+ *
+ * We then declare a static global variable(the one whose value will be changed
+ * by the first toggle):
+ * @until static
+ *
+ * We now have to create our window and all that usual stuff:
+ * @until show(bx)
+ *
+ * The creation of a toggle is no more complicated than that of any other
+ * widget:
+ * @until add
+ *
+ * For our first toggle we don't set the states labels so they will stay the
+ * default, however we do set a label for the toggle, an icon and the variable
+ * whose value it should change:
+ * @until show
+ *
+ * We also set the callback that will be called when the toggles value changes:
+ * @until smart_callback
+ *
+ * For our second toggle it important to note that we set the states labels,
+ * don't set an icon or variable, but set the initial state to
+ * EINA_TRUE("Enabled"):
+ * @until show
+ *
+ * For the second toggle we will use a different callback:
+ * @until smart_callback
+ *
+ * We then ask the main loop to start:
+ * @until ELM_MAIN
+ *
+ * The callback for our first toggle will look the value of @p val and print it:
+ * @until }
+ *
+ * For our second callback we need to do a little bit more, since the second
+ * toggle doesn't change the value of a variable we have to ask it what its
+ * state is:
+ * @until }
+ *
+ * This example will look like this:
+ *
+ * @image html screenshots/toggle_example_01.png
+ * @image latex screenshots/toggle_example_01.eps width=\textwidth
+ *
+ * @example toggle_example_01.c
+ */
+
+/**
+ * @page tutorial_panel Panel example
+ * @dontinclude panel_example_01.c
+ *
+ * In this example will have 3 panels, one for each possible orientation. Two of
+ * our panels will start out hidden, the third will start out expanded. For each
+ * of the panels we will use a label as the content, it's however possible to
+ * have any widget(including containers) as the content of panels.
+ *
+ * We start by doing some setup, code you should be familiar with from other
+ * examples:
+ * @until show(bx)
+ *
+ * And move right to creating our first panel, for this panel we are going to
+ * choose the orientation as TOP and toggle it(tell it to hide itself):
+ * @until pack_end
+ *
+ * For the second panel we choose the RIGHT orientation and explicitly set the
+ * state as hidden:
+ * @until pack_end
+ *
+ * For our third and last panel we won't set the orientation(which means it will
+ * use the default: LEFT):
+ * @until pack_end
+ *
+ * All that is left is running the main loop:
+ * @until ELM_MAIN
+ *
+ * This example will look like this;
+ *
+ * @image html screenshots/panel_example_01.png
+ * @image latex screenshots/panel_example_01.eps width=\textwidth
+ * @note The buttons with arrow allow the user to hide/show the panels.
+ *
+ * @example panel_example_01.c
+ */
+
+/**
+ * @page gengrid_example Gengrid widget example
+ *
+ * This application is a thorough exercise on the gengrid widget's
+ * API. We place an Elementary gengrid widget on a window, with
+ * various knobs below its viewport, each one acting on it somehow.
+ *
+ * The code's relevant part begins at the grid's creation. After
+ * instantiating it, we set its items sizes, so that we don't end with
+ * items one finger size wide, only. We're setting them to fat, 150
+ * pixel wide ones, for this example. We give it some size hints, not
+ * to be discussed in this context and, than, we register a callback
+ * on one of its smart events -- the one coming each time an item gets
+ * doubly clicked. There, we just print the item handle's value.
+ * @dontinclude gengrid_example.c
+ * @skip grid = elm_gengrid_add
+ * @until evas_object_sho
+ * @dontinclude gengrid_example.c
+ * @skip item double click callback
+ * @until }
+ *
+ * Before we actually start to deal with the items API, let's show
+ * some things items will be using throughout all the code. The first
+ * of them is a struct to be used as item data, for all of them:
+ * @dontinclude gengrid_example.c
+ * @skip typedef struct
+ * @until Item;
+ *
+ * That path will be used to index an image, to be swallowed into one
+ * of the item's icon spots. The imagens themselves are distributed
+ * with Elementary:
+ * @dontinclude gengrid_example.c
+ * @skip static const char *imgs
+ * @until ;
+ *
+ * We also have an (unique) gengrid item class we'll be using for
+ * items in the example:
+ * @dontinclude gengrid_example.c
+ * @skip static Elm_Gengrid_Item_Class
+ * @until static Elm_Gengrid_Item_Class
+ * @dontinclude gengrid_example.c
+ * @skip item_style =
+ * @until _grid_del
+ *
+ * As you see, our items will follow the default theme on gengrid
+ * items. For the label fetching code, we return a string composed of
+ * the item's image path:
+ * @dontinclude gengrid_example.c
+ * @skip label fetching callback
+ * @until }
+ *
+ * For item icons, we'll be populating the item default theme's two
+ * icon spots, @c "elm.swallow.icon" and @c "elm.swallow.end". The
+ * former will receive one of the images in our list (in the form of
+ * a @ref bg_02_example_page "background"), while the latter will be
+ * a check widget. Note that we prevent the check to propagate click
+ * events, so that the user can toggle its state without messing with
+ * the respective item's selection in the grid:
+ * @dontinclude gengrid_example.c
+ * @skip icon fetching callback
+ * @until return NULL
+ * @until }
+ *
+ * As the default gengrid item's theme does not have parts
+ * implementing item states, we'll be just returning false for every
+ * item state:
+ * @dontinclude gengrid_example.c
+ * @skip state fetching callback
+ * @until }
+ *
+ * Finally, the deletion callback on gengrid items takes care of
+ * freeing the item's label string and its data struct:
+ * @dontinclude gengrid_example.c
+ * @skip deletion callback
+ * @until }
+ *
+ * Let's move to item insertion/deletion knobs, them. They are four
+ * buttons, above the grid's viewport, namely
+ * - "Append" (to append an item to the grid),
+ * - "Prepend" (to prepend an item to the grid),
+ * - "Insert before" (to insert an item before the selection, on the
+ * grid),
+ * - "Insert after" (to insert an item after the selection, on the
+ * grid),
+ * - "Clear" (to delete all items in the grid),
+ * - "Bring in 1st" (to make the 1st item visible, by scrolling),
+ * - "Show last" (to directly show the last item),
+ * .
+ * which are displaced and declared in that order. We're not dealing
+ * with the buttons' creation code (see @ref button_example_01
+ * "a button example", for more details on it), but with their @c
+ * "clicked" registered callbacks. For all of them, the grid's handle
+ * is passed as @c data. The ones creating new items use a common
+ * code, which just gives a new @c Example_Item struct, with @c path
+ * filled with a random image in our images list:
+ * @dontinclude gengrid_example.c
+ * @skip new item with random path
+ * @until }
+ *
+ * Moreover, that ones will set a common function to be issued on the
+ * selection of the items. There, we print the item handle's value,
+ * along with the callback function data. The latter will be @c NULL,
+ * always, because it's what we pass when adding all icons. By using
+ * elm_gengrid_item_data_get(), we can have the item data back and,
+ * with that, we're priting the item's path string. Finally, we
+ * exemplify elm_gengrid_item_pos_get(), printing the item's position
+ * in the grid:
+ * @dontinclude gengrid_example.c
+ * @skip item selection callback
+ * @until }
+ *
+ * The appending button will exercise elm_gengrid_item_append(), simply:
+ * @dontinclude gengrid_example.c
+ * @skip append an item
+ * @until }
+ *
+ * The prepending, naturally, is analogous, but exercising
+ * elm_gengrid_item_prepend(), on its turn. The "Insert before" one
+ * will expect an item to be selected in the grid, so that it will
+ * insert a new item just before it:
+ * @dontinclude gengrid_example.c
+ * @skip "insert before" callback
+ * @until }
+ *
+ * The "Insert after" is analogous, just using
+ * elm_gengrid_item_insert_after(), instead. The "Clear" button will,
+ * as expected, just issue elm_gengrid_clear():
+ * @dontinclude gengrid_example.c
+ * @skip delete items
+ * @until }
+ *
+ * The "Bring in 1st" button is there exercise two gengrid functions
+ * -- elm_gengrid_first_item_get() and elm_gengrid_item_bring_in().
+ * With the former, we get a handle to the first item and, with the
+ * latter, you'll see that the widget animatedly scrolls its view
+ * until we can see that item:
+ * @dontinclude gengrid_example.c
+ * @skip bring in 1st item
+ * @until }
+ *
+ * The "Show last", in its turn, will use elm_gengrid_last_item_get()
+ * and elm_gengrid_item_show(). The latter differs from
+ * elm_gengrid_item_bring_in() in that it immediately replaces the
+ * contents of the grid's viewport with the region containing the item
+ * in question:
+ * @dontinclude gengrid_example.c
+ * @skip show last item
+ * @until }
+ *
+ * To change the grid's cell (items) size, we've placed a spinner,
+ * which has the following @c "changed" smart callback:
+ * @dontinclude gengrid_example.c
+ * @skip change items' size
+ * @until }
+ *
+ * Experiment with it and see how the items are affected. The "Disable
+ * item" button will, as the name says, disable the currently selected
+ * item:
+ * @dontinclude gengrid_example.c
+ * @skip disable selected item
+ * @until }
+ * Note that we also make use of elm_gengrid_item_selected_set(),
+ * there, thus making the item unselected before we actually disable
+ * it.
+ *
+ * To toggle between horizontal and vertical layouting modes on the
+ * grid, use the "Horizontal mode" check, which will call the
+ * respective API function on the grid:
+ * @dontinclude gengrid_example.c
+ * @skip change layouting mode
+ * @until }
+ *
+ * If you toggle the check right after that one, "Always select",
+ * you'll notice all subsequent clicks on the @b same grid item will
+ * still issue the selection callback on it, what is different from
+ * when it's not checked. This is the
+ * elm_gengrid_always_select_mode_set() behavior:
+ * @dontinclude gengrid_example.c
+ * @skip "always select" callback
+ * @until }
+ *
+ * One more check follows, "Bouncing", which will turn on/off the
+ * bouncing animations on the grid, when one scrolls past its
+ * borders. Experiment with scrolling the grid to get the idea, having
+ * it turned on and off:
+ * @dontinclude gengrid_example.c
+ * @skip "bouncing mode" callback
+ * @until }
+ *
+ * The next two checks will affect items selection on the grid. The
+ * first, "Multi-selection", will make it possible to select more the
+ * one item on the grid. Because it wouldn't make sense to fetch for
+ * an unique selected item on this case, we also disable two of the
+ * buttons, which insert items relatively, if multi-selection is on:
+ * @dontinclude gengrid_example.c
+ * @skip multi-selection callback
+ * @until }
+ *
+ * Note that we also @b unselect all items in the grid, when returning
+ * from multi-selection mode, making use of
+ * elm_gengrid_item_selected_set().
+ *
+ * The second check acting on selection, "No selection", is just what
+ * its name depicts -- no selection will be allowed anymore, on the
+ * grid, while it's on. Check it out for yourself, interacting with
+ * the program:
+ * @dontinclude gengrid_example.c
+ * @skip no selection callback
+ * @until }
+ *
+ * We have, finally, one more line of knobs, now sliders, to change
+ * the grids behavior. The two first will change the horizontal @b
+ * alignment of the whole actual grid of items within the gengrid's
+ * viewport:
+ * @dontinclude gengrid_example.c
+ * @skip items grid horizontal alignment change
+ * @until }
+ *
+ * Naturally, the vertical counterpart just issues
+ * elm_gengrid_align_set() changing the second alignment component,
+ * instead.
+ *
+ * The last slider will change the grid's <b>page size</b>, relative
+ * to its own one. Try to change those values and, one manner of
+ * observing the paging behavior, is to scroll softly and release the
+ * mouse button, with different page sizes, at different grid
+ * positions, while having lots of items in it -- you'll see it
+ * snapping to page boundaries differenty, for each configuration:
+ * @dontinclude gengrid_example.c
+ * @skip page relative size change
+ * @until }
+ *
+ * This is how the example program's window looks like:
+ * @image html screenshots/gengrid_example.png
+ * @image latex screenshots/gengrid_example.eps width=\textwidth
+ *
+ * Note that it starts with three items which we included at will:
+ * @dontinclude gengrid_example.c
+ * @skip _clicked(grid,
+ * @until _clicked(grid,
+ * @until _clicked(grid,
+ * @until _clicked(grid,
+ *
+ * See the full @ref gengrid_example_c "source code" for
+ * this example.
+ *
+ * @example gengrid_example.c
+ */
+/**
+ * @page entry_example_01 Entry - Example of simple editing
+ *
+ * As a general overview of @ref Entry we are going to write an, albeit simple,
+ * functional editor. Although intended to show how elm_entry works, this
+ * example also makes extensive use of several other widgets. The full code
+ * can be found in @ref entry_example.c "entry_example.c" and in the following
+ * lines we'll go through the parts especific to the @ref Entry widget.
+ *
+ * The program itself is a simple editor, with a file already set to it, that
+ * can be set to autosave or not and allows insertion of emoticons and some
+ * formatted text. As of this writing, the capabilities of format edition in
+ * the entry are very limited, so a lot of manual work is required to change
+ * the current text.
+ *
+ * In any case, the program allows some changes by using the buttons on the
+ * top of the window and returning focus back to the main entry afterwards.
+ *
+ * @image html screenshots/entry_example.png
+ * @image latex screenshots/entry_example.eps width=\textwidth
+ *
+ * We'll begin by showing a few structures used throught the program. First,
+ * the application owns data that holds the main window and the main entry
+ * where the editting happens. Then, an auxiliar structure we'll use later
+ * when inserting icons in our text.
+ * @dontinclude entry_example.c
+ * @skip typedef
+ * @until App_Inwin_Data
+ *
+ * A little convenience function will insert whatever text we need in the
+ * buffer at the current cursor's position and set focus back to this entry.
+ * This is done mostly because clicking on any button will make them steal
+ * focus, which makes writing text more cumbersome.
+ * @skip static void
+ * @until }
+ *
+ * One of the buttons on the top will trigger an @ref Inwin to open and show
+ * us several icons we can insert into the text. We'll jump over most of these
+ * functions, but when all the options are chosen, we insert the special
+ * markup text that will show the chosen icon in place.
+ * @skip edje_file_collection_list_free(emos)
+ * @skip static void
+ * @until evas_object_del
+ * @until }
+ *
+ * As can be seen in that function, the program lets us add icons to our entry
+ * using all the possible configurations for them. That should help to
+ * clarify how the different combinations work out by actually seeing them
+ * in action.
+ *
+ * The same popup window has a page to set the settings of the chosen icon,
+ * that is, the size and how the item will be placed within the line.
+ *
+ * The size is done with two entries, limitted to accept numbers and a fixed
+ * size of characters. Changing the value in this entries will update the icon
+ * size in our struct as seen in the next two callbacks.
+ * @skip static void
+ * @until }
+ * @until }
+ *
+ * The rest of the options are handled with radio buttons, since only one type
+ * of size can be used (@c size, @c absize or @c relsize) and for the vertical
+ * sizing it needs to choose between @c ascent and @c full. Depending on which
+ * is chosen, the @c item tag is formed accordingly as seen before.
+ * @skip static Evas_Object
+ * @until evas_object_show(rvascent)
+ *
+ * The first of our entries is here. There's something worth mentioning about
+ * the way we'll create this one. Normally, any entry regardless of whether is
+ * single line or not, will be set to scrollable, but in this case, since we
+ * are limitting how many characters can fit in them and we know we don't need
+ * scrolling, we are not setting this flag. This makes the entry have virtually
+ * no appearance on screen, other than its text. This is because an entry is
+ * just that, a box that holds text, and in order to have some frame around it
+ * or a background color, another widget needs to provide this. When an entry
+ * is scrollable, the same scroller used internally does this.
+ * We are using @ref Frame "frames" here to provide some decoration around,
+ * then creating our entries, set them to single line, add our two filters and
+ * the callback for when their value change.
+ * @until _height_changed_cb
+ *
+ * This function ends with the button that will finally call the item
+ * into our editting string.
+ * @until }
+ *
+ * Then we get to the format edition. Here we can add the @c bold and
+ * @c emphasis tags to parts of our text. There's a lot of manual work to
+ * know what to do here, since we are not implementing an entire state manager
+ * and the entry itself doesn't, yet, support all the needed capabilities to
+ * make this simpler. We begin by getting the format we are using in our
+ * function from the button pressed.
+ * @skip aid->pager = pager;
+ * @until sizeof(fmt_close)
+ *
+ * Next we need to find out if we need to insert an opening or a closing tag.
+ * For this, we store the current cursor position and create a selection
+ * from this point until the beginning of our text, and then get the selected
+ * text to look for any existing format tags in it. This is currently the only
+ * way in which we can find out what formats is being used in the entry.
+ * @until }
+ * @until }
+ *
+ * Once we know what tag to insert, we need a second check in the case it was
+ * a closing tag. This is because any other closing tag that comes after would
+ * be left dangling alone, so we need to remove it to keep the text consistent.
+ * @until }
+ * @until }
+ * Finally, we clear our fake selections and return the cursor back to the
+ * position it had at first, since there is where we want to insert our format.
+ * @until cursor_pos_set
+ *
+ * And finish by calling our convenience function from before, to insert the
+ * text at the current cursor and give focus back to the entry.
+ * @until }
+ *
+ * A checkbox on the top of our program tells us if the text we are editing
+ * will autosave or not. In it's @c "changed" callback we get the value from
+ * the checkbox and call the elm_entry_autosave_set() function with it. If
+ * autosave is set, we also call elm_entry_file_save(). This is so the internal
+ * timer used to periodically store to disk our changes is started.
+ * @skip static void
+ * @until }
+ *
+ * Two more functions to show some cursor playing. Whenever we double click
+ * anywhere on our entry, we'll find what word is the cursor placed at and
+ * select it. Likewise, for triple clicking, we select the entire line.
+ * @skip static void
+ * @until _edit_tplclick_cb
+ * @until }
+ *
+ * And finally, the main window of the program contains the entry where we
+ * do all the edition and some helping widgets to change format, add icons
+ * or change the autosave flag.
+ * @skip elm_exit
+ * @skip int
+ * @until _image_insert_cb
+ *
+ * And the main entry of the program. Set to scroll, by default we disable
+ * autosave and we'll begin with a file set to it because no file selector
+ * is being used here. The file is loaded with #ELM_TEXT_FORMAT_MARKUP_UTF8
+ * so that any format contained in it is interpreted, otherwise the entry
+ * would load it as just text, escaping any tags found and no format or icons
+ * would be shown. Then we connect to the double and triple click signals
+ * and set focus on the entry so we can start typing right away.
+ * @until ELM_MAIN
+ *
+ * @example entry_example.c
+ */
+
+/**
+ * @page genlist_example_01 Genlist - basic usage
+ *
+ * This example creates a simple genlist with a small number of items and
+ * a callback that is called whenever an item is selected. All the properties of
+ * this genlist are the default ones. The full code for this example can be seen
+ * at @ref genlist_example_01_c.
+ *
+ * For the simplest list that you plan to create, it's necessary to define some
+ * of the basic functions that are used for creating each list item, and
+ * associating them with the "item class" for that list. The item class is just
+ * an struct that contains pointers to the specific list item functions that are
+ * common to all the items of the list.
+ *
+ * Let's show it by example. Our item class is declared globally and static as
+ * it will be the only item class that we need (we are just creating one list):
+ *
+ * @dontinclude genlist_example_01.c
+ * @skip static Elm_Genlist
+ * @until static Elm_Genlist
+ *
+ * This item class will be used for every item that we create. The only
+ * functions that we are going to set are @c label_get and @c icon_get. As the
+ * name suggests, they are used by the genlist to generate the label for the
+ * respective item, and to generate icon(s) to it too. Both the label and icon
+ * get functions can be called more than once for each item, with different @c
+ * part parameters, which represent where in the theme of the item that label or
+ * icon is going to be set.
+ *
+ * The default theme for the genlist contains only one area for label, and two
+ * areas for icon ("elm.swallow.icon" and "elm.swallow.end"). Since we just want
+ * to set the first icon (that will be at the left side of the label), we
+ * compare the part name given with "elm.swallow.icon". Notice that the
+ * @c label_get function must return a strduped string, that will be freed later
+ * automatically by the list. Here's the code for @c label_get and @c icon_get:
+ *
+ * @until static void
+ *
+ * We will also provide a function that will be called whenever an item is
+ * selected in the genlist. However, this function is not part of the item
+ * class, it will be passed for each item being added to the genlist explicitly.
+ * Notice the similarity of the function signature with those used by @c
+ * evas_object_smart_callback_add:
+ *
+ * @until }
+ *
+ * Now let's show the code used for really creating the list. Skipping
+ * boilerplate code used for creating a window and background, the first piece
+ * of code specific to our genlist example is setting the pointer functions of
+ * the item class to our above defined functions:
+ *
+ * @skip _itc
+ * @until func.del
+ *
+ * Notice that we also choose to use the "default" style for our genlist items.
+ * Another interesting point is that @c state_get and @c del are set to @c NULL,
+ * since we don't need these functions now. @c del doesn't need to be used
+ * because we don't add any data that must be freed to our items, and @c
+ * state_get is also not used since all of our items are the same and don't need
+ * to have different states to be used for each item. Finally we create our
+ * list:
+ *
+ * @until genlist_add
+ *
+ * Now we append several items to the list, and for all of them we need to give
+ * the list pointer, a pointer to the item class, the data that will be used
+ * with that item, a pointer to the parent of this item if it is in a group type
+ * list (this is not the case so we pass @c NULL), possible flags for this item,
+ * the callback for when the item is selected, and the data pointer that will be
+ * given to the selected callback.
+ *
+ * @until }
+ *
+ * The rest of the code is also common to all the other examples, so it will be
+ * omitted here (look at the full source code link above if you need it).
+ *
+ * You can try to play with this example, and see the selected callback being
+ * called whenever an item is clicked. It also already has some features enabled
+ * by default, like vertical bounce animation when reaching the end of the list,
+ * automatically visible/invisible scrollbar, etc. Look at the @ref
+ * genlist_example_02 to see an example of setting these properties to the list.
+ *
+ * The current example will look like this when running:
+ *
+ * @image html screenshots/genlist_example_01.png
+ * @image latex screenshots/genlist_example_01.eps width=\textwidth
+ */
+
+/**
+ * @page genlist_example_02 Genlist - list setup functions
+ *
+ * This example is very similar to the @ref genlist_example_01, but it fetch
+ * most of the properties of the genlist and displays them on startup (thus
+ * getting the default value for them) and then set them to some other values,
+ * to show how to use that API. The full source code is at @ref
+ * genlist_example_02_c.
+ *
+ * Considering that the base code for instantiating a genlist was already
+ * described in the previous example, we are going to focus on the new code.
+ *
+ * Just a small difference for the @c _item_label_get function, we are going to
+ * store the time that this function was called. This is the "realized" time,
+ * the time when the visual representation of this item was created. This is the
+ * code for the @c label_get function:
+ *
+ * @dontinclude genlist_example_02.c
+ * @skip static char
+ * @until return strdup
+ *
+ * Now let's go to the list creation and setup. First, just after creating the
+ * list, we get most of the default properties from it, and print them on the
+ * console:
+ *
+ * @skip genlist_add
+ * @until printf("\n")
+ *
+ * We are going to change some of the properties of our list.
+ *
+ * There's no need to call the selected callback at every click, just when the
+ * selected item changes, thus we call elm_genlist_always_select_mode_set() with
+ * false.
+ *
+ * For this list we don't want bounce animations at all, so we set both the
+ * horizontal bounce and the vertical bounce to false with
+ * elm_genlist_bounce_set().
+ *
+ * We also want our list to compress items if they are wider than the list
+ * width (thus we call elm_genlist_compress_mode_set().
+ *
+ * The items have different width, so they are not homogeneous:
+ * elm_genlist_homogeneous_set() is set to false.
+ *
+ * Since the compress mode is active, the call to
+ * elm_genlist_horizontal_mode_set() doesn't make difference, but the current
+ * option would make the list to have at least the width of the largest item.
+ *
+ * This list will support multiple selection, so we call
+ * elm_genlist_multi_select_set() on it.
+ *
+ * The option elm_genlist_height_for_width_mode_set() would allow text block to
+ * wrap lines if the Edje part is configured with "text.min: 0 1", for example.
+ * But since we are compressing the elements to the width of the list, this
+ * option wouldn't take any effect.
+ *
+ * We want the vertical scrollbar to be always displayed, and the orizontal one
+ * to never be displayed, and set this with elm_genlist_scroller_policy_set().
+ *
+ * The timeout to consider a longpress is set to half of a second with
+ * elm_genlist_longpress_timeout_set().
+ *
+ * We also change the block count to a smaller value, but that should have not
+ * impact on performance since the number of visible items is too small. We just
+ * increase the granularity of the block count (setting it to have at most 4
+ * items).
+ *
+ * @until block_count_set
+ *
+ * Now let's add elements to the list:
+ *
+ * @until item_append
+ * @until }
+ *
+ * It's exactly the same as the previous example. The difference is on the
+ * behavior of the list, if you try to scroll, select items and so.
+ *
+ * In this example we also need two buttons. One of them, when clicked, will
+ * display several status info about the current selection, the "realized"
+ * items, the item in the middle of the screen, and the current mode and active
+ * item of that mode for the genlist.
+ *
+ * The other button will ask the genlist to "realize" again the items already
+ * "realized", so their respective label_get and icon_get functions will be
+ * called again.
+ *
+ * These are the callbacks for both of these buttons:
+ *
+ * @dontinclude genlist_example_02.c
+ * @skip item_sel_cb
+ * @skip static
+ * @until }
+ * @until }
+ *
+ * Try to scroll, select some items and click on the "Show status" button.
+ * You'll notice that not all items of the list are "realized", thus consuming
+ * just a small amount of memory. The selected items are listed in the order
+ * that they were selected, and the current selected item printed using
+ * elm_genlist_selected_item_get() is the first selected item of the multiple
+ * selection.
+ *
+ * Now resize the window so that you can see the "realized time" of some items.
+ * This is the time of when the label_get function was called. If you click on
+ * the "Realize" button, all the already realized items will be rebuilt, so the
+ * time will be updated for all of them.
+ *
+ * The current example will look like this when running:
+ *
+ * @image html screenshots/genlist_example_02.png
+ * @image latex screenshots/genlist_example_02.eps width=\textwidth
+ */
+
+/**
+ * @page genlist_example_03 Genlist - different width options
+ *
+ * This example doesn't present any other feature that is not already present in
+ * the other examples, but visually shows the difference between using the
+ * default list options (first list of the example), setting the horizontal mode
+ * to #ELM_LIST_LIMIT (second list), enabling compress mode (third list) and
+ * using height_for_width option (fourth list).
+ *
+ * The full code for this example is listed below:
+ *
+ * @include genlist_example_03.c
+ *
+ * And the screenshot of the running example:
+ *
+ * @image html screenshots/genlist_example_03.png
+ * @image latex screenshots/genlist_example_03.eps width=\textwidth
+ *
+ * @example genlist_example_03.c
+ */
+
+/**
+ * @page genlist_example_04 Genlist - items manipulation
+ *
+ * This example is also similar ot the @ref genlist_example_01, but it
+ * demonstrates most of the item manipulation functions. See the full source
+ * code at @ref genlist_example_04_c.
+ *
+ * In this example, we also will use the concept of creating groups of items in
+ * the genlist. Each group of items is composed by a parent item (which will be
+ * the index of the group) and several children of this item. Thus, for the
+ * children, we declare a normal item class. But we also are going to declare a
+ * different item class for the group index (which in practice is another type
+ * of item in the genlist):
+ *
+ * @dontinclude genlist_example_04.c
+ * @skip _item_sel_cb
+ * @skip static
+ * @until }
+ * @until }
+ *
+ * We will add buttons to the window, where each button provides one
+ * functionality of the genlist item API. Each button will have a callback
+ * attached, that will really execute this functionality. An example of these
+ * callbacks is the next one, for the elm_genlist_item_insert_after() function:
+ *
+ * @skip insert_before_cb
+ * @skip static
+ * @until }
+ *
+ * If you want ot see the other button functions, look at the full source code
+ * link above.
+ *
+ * Each button will be created with a function that already creates the button,
+ * add it to an elementary box, and attach the specified callback. This is the
+ * function that does it:
+ *
+ * @skip genlist_item_update
+ * @skip static
+ * @until }
+ *
+ * In our @c elm_main function, besides the code for setting up the window, box
+ * and background, we also initialize our two item classes:
+ *
+ * @skip _itc.item_style
+ * @until _itc_group.func.del
+ *
+ * This example uses a different style for the items, the @a double_label, which
+ * provides a text field for the item text, and another text field for a subtext.
+ *
+ * For the group index we use the @a group_index style, which provides a
+ * different appearance, helping to identify the end of a group and beginning of
+ * another one.
+ *
+ * Now, after the code for creating the list, setting up the box and other
+ * stuff, let's add the buttons with their respective callbacks:
+ *
+ * @skip _button_add
+ * @until bt_top_show
+ *
+ * The main code for adding items to the list is a bit more complex than the one
+ * from the previous examples. We check if each item is multiple of 7, and if
+ * so, they are group indexes (thus each group has 6 elements by default, in
+ * this example):
+ *
+ * @skip for
+ * @until }
+ * @until }
+ *
+ * Then we also check for specific items, and add callbacks to them on the
+ * respective buttons, so we can show, bring in, etc.:
+ *
+ * @until }
+ * @until }
+ *
+ * Once you understand the code from the @ref genlist_example_01, it should be
+ * easy to understand this one too. Look at the full code, and also try to play
+ * a bit with the buttons, adding items, bringing them to the viewport, and so.
+ *
+ * The example will look like this when running:
+ *
+ * @image html screenshots/genlist_example_04.png
+ * @image latex screenshots/genlist_example_04.eps width=\textwidth
+ */
+
+/**
+ * @page genlist_example_05 Genlist - working with subitems
+ *
+ * This is probably the most complex example of elementary @ref Genlist. We
+ * create a tree of items, using the subitems properties of the items, and keep
+ * it in memory to be able to expand/hide subitems of an item. The full source
+ * code can be found at @ref genlist_example_05_c
+ *
+ * The main point is the way that Genlist manages subitems. Clicking on an
+ * item's button to expand it won't really show its children. It will only
+ * generate the "expand,request" signal, and the expansion must be done
+ * manually.
+ *
+ * In this example we want to be able to add items as subitems of another item.
+ * If an item has any child, it must be displayed using a parent class,
+ * otherwise it will use the normal item class.
+ *
+ * It will be possible to delete items too. Once a tree is constructed (with
+ * subitems of subitems), and the user clicks on the first parent (root of the
+ * tree), the entire subtree must be hidden. However, just calling
+ * elm_genlist_item_expanded_set(item, EINA_FALSE) won't hide them. The only
+ * thing that happens is that the parent item will change its appearance to
+ * represent that it's contracted. And the signal "contracted" will be emitted
+ * from the genlist. Thus, we must call elm_genlist_item_subitems_clear() to
+ * delete all its subitems, but still keep a way to recreate them when expanding
+ * the parent again. That's why we are going to keep a node struct for each
+ * item, that will be the data of the item, with the following information:
+ *
+ * @dontinclude genlist_example_05.c
+ * @skip typedef
+ * @until }
+ *
+ * This @c Node_Data contains the value for the item, a number indicating its
+ * level under the tree, a list of children (to be able to expand it later) and
+ * a boolean indicating if it's a favorite item or not.
+ *
+ * We use 3 different item classes in this example:
+ *
+ * One for items that don't have children:
+ *
+ * @skip nitems
+ * @skip static
+ * @until }
+ * @until }
+ *
+ * One for items that have children:
+ *
+ * @skip item_sel
+ * @skip static
+ * @until }
+ * @until }
+ *
+ * And one for items that were favorited:
+ *
+ * @skip static
+ * @until }
+ * @until }
+ *
+ * The favorite item class is there just to demonstrate the
+ * elm_genlist_item_item_class_update() function in action. It would be much
+ * simpler to implement the favorite behavior by just changing the icon inside
+ * the icon_get functions when the @c favorite boolean is activated.
+ *
+ * Now we are going to declare the callbacks for the buttons that add, delete
+ * and change items.
+ *
+ * First, a button for appending items to the list:
+ *
+ * @until item_append
+ * @until }
+ *
+ * If an item is selected, a new item will be appended to the same level of that
+ * item, but using the selected item's parent as its parent too. If no item is
+ * selected, the new item will be appended to the root of the tree.
+ *
+ * Then the callback for marking an item as favorite:
+ *
+ * @until elm_genlist_item_update
+ * @until }
+ *
+ * This callback is very simple, it just changes the item class of the selected
+ * item for the "favorite" one, or go back to the "item" or "parent" class
+ * depending on that item having children or not.
+ *
+ * Now, the most complex operation (adding a child to an item):
+ *
+ * @until elm_genlist_item_update
+ * @until }
+ *
+ * This function gets the data of the selected item, create a new data (for the
+ * item being added), and appends it to the children list of the selected item.
+ *
+ * Then we must check if the selected item (let's call it @c item1 now) to which
+ * the new item (called @c item2 from now on) was already a parent item too
+ * (using the parent item class) or just a normal item (using the default item
+ * class). In the first case, we just have to append the item to the end of the
+ * @c item1 children list.
+ *
+ * However, if the @c item1 didn't have any child previously, we have to change
+ * it to a parent item now. It would be easy to just change its item class to
+ * the parent type, but there's no way to change the item flags and make it be
+ * of the type #ELM_GENLIST_ITEM_SUBITEMS. Thus, we have to delete it and create
+ * a new item, and add this new item to the same position that the deleted one
+ * was. That's the reason of the checks inside the bigger @c if.
+ *
+ * After adding the item to the newly converted parent, we set it to not
+ * expanded (since we don't want to show the added item immediately) and select
+ * it again, since the original item was deleted and no item is selected at the
+ * moment.
+ *
+ * Finally, let's show the callback for deleting items:
+ *
+ * @until elm_genlist_item_update
+ * @until }
+ *
+ * Since we have an iternal list representing each element of our tree, once we
+ * delete an item we have to go deleting each child of that item, in our
+ * internal list. That's why we have the function @c _clear_list, which
+ * recursively goes freeing all the item data.
+ *
+ * This is necessary because only when we really want to delete the item is when
+ * we need to delete the item data. When we are just contracting the item, we
+ * need to hide the children by deleting them, but keeping the item data.
+ *
+ * Now there are two callbacks that will be called whenever the user clicks on
+ * the expand/contract icon of the item. They will just request to items to be
+ * contracted or expanded:
+ *
+ * @until elm_genlist_item_expanded_set(
+ * @until elm_genlist_item_expanded_set(
+ * @until }
+ *
+ * When the elm_genlist_item_expanded_set() function is called with @c
+ * EINA_TRUE, the @c _expanded_cb will be called. And when this happens, the
+ * subtree of that item must be recreated again. This is done using the internal
+ * list stored as item data for each item. The function code follows:
+ *
+ * @until }
+ *
+ * Each appended item is set to contracted, so we don't have to deal with
+ * checking if the item was contracted or expanded before its parent being
+ * contracted. It could be easily implemented, though, by adding a flag expanded
+ * inside the item data.
+ *
+ * Now, the @c _contracted_cb, which is much simpler:
+ *
+ * @until }
+ *
+ * We just have to call elm_genlist_item_subitems_clear(), that will take care
+ * of deleting every item, and keep the item data still stored (since we don't
+ * have any del function set on any of our item classes).
+ *
+ * Finally, the code inside @c elm_main is very similar to the other examples:
+ *
+ * @skip elm_main
+ * @until ELM_MAIN
+ *
+ * The example will look like this when running:
+ *
+ * @image html screenshots/genlist_example_05.png
+ * @image latex screenshots/genlist_example_05.eps width=\textwidth
+ */
+
+/**
+ * @page thumb_example_01 Thumb - generating thumbnails.
+ *
+ * This example shows how to create a simple thumbnail object with Elementary.
+ * The full source code can be found at @ref thumb_example_01_c
+ *
+ * Everything is very simple. First we need to tell elementary that we need
+ * Ethumb to generate the thumbnails:
+ *
+ * @dontinclude thumb_example_01.c
+ * @skipline elm_need_ethumb
+ *
+ * Then, after creating the window and background, we setup our client to
+ * generate images of 160x160:
+ *
+ * @skip client_get
+ * @until size_set
+ *
+ * After that, we can start creating thumbnail objects. They are very similar to
+ * image or icon objects:
+ *
+ * @until thumb_reload
+ *
+ * As you can see, the main different function here is elm_thumb_reload(), which
+ * will check if the options of the Ethumb client have changed. If so, it will
+ * re-generate the thumbnail, and show the new one.
+ *
+ * Notice in this example that the thumbnail object is displayed on the size of
+ * the window (320x320 pixels), but the thumbnail generated and stored has size
+ * 160x160 pixels. That's why the picture seems upscaled.
+ *
+ * Ideally, you will be generating thumbnails with the size that you will be
+ * using them.
+ *
+ * The example will look like this when running:
+ *
+ * @image html screenshots/thumb_example_01.png
+ * @image latex screenshots/thumb_example_01.eps width=\textwidth
+ */
+
+/**
+ * @page progressbar_example Progress bar widget example
+ *
+ * This application is a thorough example of the progress bar widget,
+ * consisting of a window with varios progress bars, each with a given
+ * look/style one can give to those widgets. With two auxiliary
+ * buttons, one can start or stop a timer which will fill in the bars
+ * in synchrony, simulating an underlying task being completed.
+ *
+ * We create @b seven progress bars, being three of them horizontal,
+ * three vertical and a final one under the "wheel" alternate style.
+ *
+ * For the first one, we add a progress bar on total pristine state,
+ * with no other call than the elm_progressbar_add() one:
+ * @dontinclude progressbar_example.c
+ * @skip pb with no label
+ * @until pb1
+ * See, than, that the defaults of a progress bar are:
+ * - no primary label shown,
+ * - unit label set to @c "%.0f %%",
+ * - no icon set
+ *
+ * The second progress bar is given a primary label, <c>"Infinite
+ * bounce"</c>, and, besides, it's set to @b pulse. See how, after one
+ * starts the progress timer, with the "Start" button, it animates
+ * differently than the previous one. It won't account for the
+ * progress, itself, and just dumbly animate a small bar within its
+ * bar region.
+ * @dontinclude progressbar_example.c
+ * @skip pb with label
+ * @until pb2
+ *
+ * Next, comes a progress bar with an @b icon, a primary label and a
+ * @b custom unit label set. It's also made to grow its bar in an
+ * @b inverted manner, so check that out during the timer's progression:
+ * @dontinclude progressbar_example.c
+ * @skip ic1 =
+ * @until pb3
+ * Another important thing in this one is the call to
+ * elm_progressbar_span_size_set() -- this is how we forcefully set a
+ * minimum horizontal size to our whole window! We're not resizing it
+ * manually, as you can see in the @ref progressbar_example_c
+ * "complete code".
+ *
+ * The next three progress bars are just variants on the ones already
+ * shown, but now all being @b vertical. Another time we use one of
+ * than to give the window a minimum vertical size, with
+ * elm_progressbar_span_size_set(). To demonstrate this trick once
+ * more, the fifth one, which is also set to pulse, has a smaller
+ * hardcoded span size:
+ * @dontinclude progressbar_example.c
+ * @skip vertical pb, with pulse
+ * @until pb5
+ *
+ * We end the widget demonstration by showing a progress bar with the
+ * special @b "wheel" progress bar style. One does @b not need to set
+ * it to pulse, with elm_progressbar_pulse_set(), explicitly, because
+ * its theme does not take it in account:
+ * @dontinclude progressbar_example.c
+ * @skip "wheel"
+ * @until pb7
+ *
+ * The two buttons exercising the bars, the facto, follow:
+ * @dontinclude progressbar_example.c
+ * @skip elm_button_add
+ * @until evas_object_show(bt)
+ * @until evas_object_show(bt)
+ *
+ * The first of the callbacks will, for the progress bars set to
+ * pulse, start the pulsing animation at that time. For the others, a
+ * timer callback will take care of updating the values:
+ * @dontinclude progressbar_example.c
+ * @skip static Eina_Bool
+ * @until }
+ * @until }
+ * @until }
+ *
+ * Finally, the callback to stop the progress timer will stop the
+ * pulsing on the pulsing progress bars and, for the others, to delete
+ * the timer which was acting on their values:
+ * @dontinclude progressbar_example.c
+ * @skip end of show
+ * @until }
+ * @until }
+ *
+ * This is how the example program's window looks like:
+ * @image html screenshots/progressbar_example.png
+ * @image latex screenshots/progressbar_example.eps width=\textwidth
+ *
+ * See the full @ref progressbar_example_c "source code" for
+ * this example.
+ *
+ * @example progressbar_example.c
+ */
+
+/**
+ * @page tutorial_notify Notify example
+ * @dontinclude notify_example_01.c
+ *
+ * In this example we will have 3 notifys in 3 different positions. The first of
+ * which will dissapear after 5 seconds or when a click outside it occurs, the
+ * second and third will not dissapear and differ from each other only in
+ * position.
+ *
+ * We start our example with the usual stuff you've seen in other examples:
+ * @until show(bx)
+ *
+ * We now create a label to use as the content of our first notify:
+ * @until show
+ *
+ * Having the label we move to creating our notify, telling it to block events,
+ * setting its timeout(to autohide it):
+ * @until pack_end
+ *
+ * To have the notify dissapear when a click outside its area occur we have to
+ * listen to its "block,clicked" signal:
+ * @until smart_callback
+ *
+ * Our callback will look like this:
+ * @skip static
+ * @until }
+ * @dontinclude notify_example_01.c
+ *
+ * Next we create another label and another notify. Note, however, that this
+ * time we don't set a timeout and don't have it block events. What we do is set
+ * the orient so that this notify will appear in the bottom of its parent:
+ * @skip smart_callback
+ * @skip content
+ * @until pack_end
+ *
+ * For our third notify the only change is the orient which is now center:
+ * @until pack_end
+ *
+ * Now we tell the main loop to run:
+ * @until ELM_MAIN
+ *
+ * Our example will initially look like this:
+ *
+ * @image html screenshots/notify_example_01.png
+ * @image latex screenshots/notify_example_01.eps width=\textwidth
+ *
+ * Once the first notify is hidden:
+ *
+ * @image html screenshots/notify_example_01_a.png
+ * @image latex screenshots/notify_example_01_a.eps width=\textwidth
+ *
+ * @example notify_example_01.c
+ */