+ * @page tutorial_frame Frame example
+ * @dontinclude frame_example_01.c
+ *
+ * In this example we are going to create 4 Frames with different styles and
+ * add a rectangle of different color in each.
+ *
+ * We start we the usual setup code:
+ * @until show(bg)
+ *
+ * And then create one rectangle:
+ * @until show
+ *
+ * To add it in our first frame, which since it doesn't have it's style
+ * specifically set uses the default style:
+ * @until show
+ *
+ * And then create another rectangle:
+ * @until show
+ *
+ * To add it in our second frame, which uses the "pad_small" style, note that
+ * even tough we are setting a text for this frame it won't be show, only the
+ * default style shows the Frame's title:
+ * @until show
+ * @note The "pad_small", "pad_medium", "pad_large" and "pad_huge" styles are
+ * very similar, their only difference is the size of the empty area around
+ * the content of the frame.
+ *
+ * And then create yet another rectangle:
+ * @until show
+ *
+ * To add it in our third frame, which uses the "outdent_top" style, note
+ * that even tough we are setting a text for this frame it won't be show,
+ * only the default style shows the Frame's title:
+ * @until show
+ *
+ * And then create one last rectangle:
+ * @until show
+ *
+ * To add it in our fourth and final frame, which uses the "outdent_bottom"
+ * style, note that even tough we are setting a text for this frame it won't
+ * be show, only the default style shows the Frame's title:
+ * @until show
+ *
+ * And now we are left with just some more setup code:
+ * @until ELM_MAIN()
+ *
+ * Our example will look like this:
+ *
+ * @image html screenshots/frame_example_01.png
+ * @image latex screenshots/frame_example_01.eps width=\textwidth
+ *
+ * @example frame_example_01.c
+ */
+
+/**
+ * @page tutorial_anchorblock_example Anchorblock/Anchorview example
+ * This example will show both Anchorblock and @ref Anchorview,
+ * since both are very similar and it's easier to show them once and side
+ * by side, so the difference is more clear.
+ *
+ * We'll show the relevant snippets of the code here, but the full example
+ * can be found here... sorry, @ref anchorblock_example_01.c "here".
+ *
+ * As for the actual example, it's just a simple window with an anchorblock
+ * and an anchorview, both containing the same text. After including
+ * Elementary.h and declaring some functions we'll need, we jump to our
+ * elm_main (see ELM_MAIN) and create our window.
+ * @dontinclude anchorblock_example_01.c
+ * @skip int
+ * @until const char
+ * @until ;
+ *
+ * With the needed variables declared, we'll create the window and a box to
+ * hold our widgets, but we don't need to go through that here.
+ *
+ * In order to make clear where the anchorblock ends and the anchorview
+ * begins, they'll be each inside a @ref Frame. After creating the frame,
+ * the anchorblock follows.
+ * @skip elm_frame_add
+ * @until elm_frame_content_set
+ *
+ * Nothing out of the ordinary there. What's worth mentioning is the call
+ * to elm_anchorblock_hover_parent_set(). We are telling our widget that
+ * when an anchor is clicked, the hover for the popup will cover the entire
+ * window. This affects the area that will be obscured by the hover and
+ * where clicking will dismiss it, as well as the calculations it does to
+ * inform the best locations where to insert the popups content.
+ * Other than that, the code is pretty standard. We also need to set our
+ * callback for when an anchor is clicked, since it's our task to populate
+ * the popup. There's no default for it.
+ *
+ * The anchorview is no different, we only change a few things so it looks
+ * different.
+ * @until elm_frame_content_set
+ *
+ * Then we run, so stuff works and close our main function in the usual way.
+ * @until ELM_MAIN
+ *
+ * Now, a little note. Normally you would use either one of anchorblock or
+ * anchorview, set your one callback to clicks and do your stuff in there.
+ * In this example, however, there are a few tricks to make it easier to
+ * show both widgets in one go (and to save me some typing). So we have
+ * two callbacks, one per widget, that will call a common function to do
+ * the rest. The trick is using ::Elm_Entry_Anchorblock_Info for the
+ * anchorview too, since both are equal, and passing a callback to use
+ * for our buttons to end the hover, because each widget has a different
+ * function for it.
+ * @until _anchorview_clicked_cb
+ * @until }
+ *
+ * The meat of our popup is in the following function. We check what kind
+ * of menu we need to show, based on the name set to the anchor in the
+ * markup text. If there's no type (something went wrong, no valid contact
+ * in the address list) we are just putting a button that does nothing, but
+ * it's perfectly reasonable to just end the hover and call it quits.
+ *
+ * Our popup will consist of one main button in the middle of our hover,
+ * and possibly a secondary button and a list of other options. We'll create
+ * first our main button and check what kind of popup we need afterwards.
+ * @skip static void
+ * @skip static void
+ * @until eina_stringshare_add
+ * @until }
+ *
+ * Each button has two callbacks, one is our hack to close the hover
+ * properly based on which widget it belongs to, the other a simple
+ * printf that will show the action with the anchors own data. This is
+ * not how you would usually do it. Instead, the common case is to have
+ * one callback for the button that will know which function to call to end
+ * things, but since we are doing it this way it's worth noting that
+ * smart callbacks will be called in reverse in respect to the order they
+ * were added, and since our @c btn_end_cb will close the hover, and thus
+ * delete our buttons, the other callback wouldn't be called if we had
+ * added it before.
+ *
+ * After our telephone popup, there are a few others that are practically
+ * the same, so they won't be shown here.
+ *
+ * Once we are done with that, it's time to place our actions into our
+ * hover. Main button goes in the middle without much questioning, and then
+ * we see if we have a secondary button and a box of extra options.
+ * Because I said so, secondary button goes on either side and box of
+ * options either on top or below the main one, but to choose which
+ * exactly, we use the hints our callback info has, which saves us from
+ * having to do the math and see which side has more space available, with
+ * a little special case where we delete our extra stuff if there's nowhere
+ * to place it.
+ * @skip url:
+ * @skip }
+ * @skip evas_object_smart
+ * @until evas_object_del(box)
+ * @until }
+ * @until }
+ *
+ * The example will look like this:
+ *
+ * @image html screenshots/anchorblock_01.png
+ * @image latex screenshots/anchorblock_01.eps width=\textwidth
+ *
+ * @example anchorblock_example_01.c
+ */
+
+/**
+ * @page tutorial_check Check example
+ * @dontinclude check_example_01.c
+ *
+ * This example will show 2 checkboxes, one with just a label and the second
+ * one with both a label and an icon. This example also ilustrates how to
+ * have the checkbox change the value of a variable and how to react to those
+ * changes.
+ *
+ * We will start with the usual setup code:
+ * @until show(bg)
+ *
+ * And now we create our first checkbox, set its label, tell it to change
+ * the value of @p value when the checkbox stats is changed and ask to be
+ * notified of state changes:
+ * @until show
+ *
+ * For our second checkbox we are going to set an icon so we need to create
+ * and icon:
+ * @until show
+ * @note For simplicity we are using a rectangle as icon, but any evas object
+ * can be used.
+ *
+ * And for our second checkbox we set the label, icon and state to true:
+ * @until show
+ *
+ * We now do some more setup:
+ * @until ELM_MAIN
+ *
+ * And finally implement the callback that will be called when the first
+ * checkbox's state changes. This callback will use @p data to print a
+ * message:
+ * @until }
+ * @note This work because @p data is @p value(from the main function) and @p
+ * value is changed when the checkbox is changed.
+ *
+ * Our example will look like this:
+ *
+ * @image html screenshots/check_example_01.png
+ * @image latex screenshots/check_example_01.eps width=\textwidth
+ *
+ * @example check_example_01.c
+ */
+
+/**
+ * @page tutorial_colorselector Color selector example
+ * @dontinclude colorselector_example_01.c
+ *
+ * This example shows how to change the color of a rectangle using a color
+ * selector. We aren't going to explain a lot of the code since it's the
+ * usual setup code:
+ * @until show(rect)
+ *
+ * Now that we have a window with background and a rectangle we can create
+ * our color_selector
+ * @until elm_colorselector_add
+ *
+ * Now colors can be loaded to color selector's palette by setting the palette name
+ * @until show(cs)
+ *
+ * Next we ask to be notified whenever the color changes on selector:
+ * @until changed
+ *
+ * Next we ask to be notified whenever the color item is selected and longpressed:
+ * @until color,item,longpressed
+ *
+ * We add some more code to the usual setup code:
+ * @until ELM_MAIN()
+ *
+ * now get to the "changed" callback that sets the color of the rectangle:
+ * @until }
+ *
+ * And now get to the "color,item,selected" callback that sets the color of the rectangle:
+ * @until }
+ *
+ * And now get to the "color,item,longpressed" callback that gets and displays
+ * the color of the rectangle:
+ * @until }
+ *
+ * This example will look like this:
+ *
+ * @image html screenshots/colorselector_example_01.png
+ * @image latex screenshots/colorselector_example_01.eps width=\textwidth
+ *
+ * @example colorselector_example_01.c
+ */
+
+/**
+ * @page slideshow_example Slideshow widget example
+ *
+ * This application is aimed to exemplify the slideshow widget. It
+ * consists of a window with a slideshow widget set as "resize
+ * object", along with a control bar, in the form of a notify. Those
+ * controls will exercise most of the slideshow's API functions.
+ *
+ * We create the slideshow, itself, first, making it @b loop on its
+ * image itens, when in slideshow mode:
+ * @dontinclude slideshow_example.c
+ * @skip slideshow = elm_slideshow_add
+ * @until evas_object_show
+ *
+ * Next, we define the <b>item class</b> for our slideshow
+ * items. Slideshow images are going to be Elementary @ref Photo "photo"
+ * widgets, here, as pointed by our @c get class
+ * function. We'll let the Elementary infrastructure to delete those
+ * objects for us, and, as there's no additional data attached to our
+ * slideshow items, the @c del class function can be left undefined:
+ * @dontinclude slideshow_example.c
+ * @skip itc
+ * @until ;
+ * @dontinclude slideshow_example.c
+ * @skip itc.func
+ * @until = NULL
+ * @dontinclude slideshow_example.c
+ * @skip get our images to make slideshow items
+ * @until }
+ *
+ * We now get to populate the slideshow widget with items. Our images
+ * are going to be some randomly chosen from the Elementary package,
+ * nine of them. For the first eight, we insert them ordered in the
+ * widget, by using elm_slideshow_item_sorted_insert(). The comparing
+ * function will use the image names to sort items. The last item is
+ * inserted at the end of the slideshow's items list, with
+ * elm_slideshow_item_add(). We check out how that list ends with
+ * elm_slideshow_items_get(), than:
+ * @dontinclude slideshow_example.c
+ * @skip static const char *img
+ * @until _2
+ * @dontinclude slideshow_example.c
+ * @skip first =
+ * @until data_get
+ *
+ * Note that we save the pointers to the first and last items in the
+ * slideshow, for future use.
+ *
+ * What follows is the code creating a notify, to be shown over the
+ * slideshow's viewport, with knobs to act on it. We're not showing
+ * that boilerplate code, but only the callbacks attached to the
+ * interesting smart events of those knobs. The first four are
+ * buttons, which will:
+ * - Select the @b next item in the slideshow
+ * - Select the @b previous item in the slideshow
+ * - Select the @b first item in the slideshow
+ * - Select the @b last item in the slideshow
+ *
+ * Check out the code for those four actions, being the two last @c
+ * data pointers the same @c first and @c last pointers we save
+ * before, respectively:
+ * @dontinclude slideshow_example.c
+ * @skip jump to next
+ * @until }
+ * @until }
+ * @until }
+ * @until }
+ *
+ * What follow are two hoversels, meant for one to change the
+ * slideshow's @b transition and @b layout styles, respectively. We
+ * fetch all the available transition and layout names to populate
+ * those widgets and, when one selects any of them, we apply the
+ * corresponding setters on the slideshow:
+ * @dontinclude slideshow_example.c
+ * @skip hv = elm_hoversel_add
+ * @until show(hv)
+ * @until show(hv)
+ * @dontinclude slideshow_example.c
+ * @skip transition changed
+ * @until }
+ * @until }
+ *
+ * For one to change the transition @b time on the slideshow widget,
+ * we use a spinner widget. We set it to the initial value of 3
+ * (seconds), which will be probed by the next knob -- a button
+ * starting the slideshow, de facto. Note that changing the transition
+ * time while a slideshow is already happening will ajust its
+ * transition time:
+ * @dontinclude slideshow_example.c
+ * @skip spin = elm_spinner_add
+ * @until evas_object_show
+ * @dontinclude slideshow_example.c
+ * @skip slideshow transition time has
+ * @until }
+ *
+ * Finally, we have two buttons which will, respectively, start and
+ * stop the slideshow on our widget. Here are their "clicked"
+ * callbacks:
+ * @dontinclude slideshow_example.c
+ * @skip start the show
+ * @until }
+ * @until }
+ *
+ * This is how the example program's window looks like:
+ * @image html screenshots/slideshow_example.png
+ * @image latex screenshots/slideshow_example.eps width=\textwidth
+ *
+ * See the full @ref slideshow_example_c "source code" for
+ * this example.
+ *
+ * @example slideshow_example.c
+ */
+
+/**
+ * @page tutorial_photocam Photocam example
+ * @dontinclude photocam_example_01.c
+ *
+ * In this example we will have a photocam and a couple of buttons and slider to
+ * control the photocam. To avoid cluttering we'll only show the parts of the
+ * example that relate to the photocam, the full source code can be seen @ref
+ * photocam_example_01.c "here".
+ *
+ * Creating a photocam is as easy as creating any other widget:
+ * @skipline elm_photocam_add
+ *
+ * A photocam is only useful if we have a image on it, so lets set a file for it
+ * to work with:
+ * @until file_set
+ *
+ * We now set the photocam to not bounce horizontally:
+ * @until bounce_set
+ *
+ * And we want to know when the photocam has finished loading the image so:
+ * @until smart_callback
+ *
+ * The reason to know when the image is loaded is so that we can bring the
+ * center of the image into view:
+ * @skip static
+ * @until }
+ *
+ * As mentioned we have 2 buttons in this example, the "Fit" one will cause
+ * the photocam to go in to a zoom mode that makes the image fit inside the
+ * photocam. Tough this has no effect on the image we also print what region was
+ * being viewed before setting the zoom mode:
+ * @until }
+ * @note When in fit mode our slider(explained below) won't work.
+ *
+ * The second button("Unfit") will bring the photocam back into manual zoom
+ * mode:
+ * @until }
+ *
+ * Our slider controls the level of zoom of the photocam:
+ * @until }
+ * @note It is important to note that this only works when in manual zoom mode.
+ *
+ * Our example will initially look like this:
+ *
+ * @image html screenshots/photocam_example_01.png
+ * @image latex screenshots/photocam_example_01.eps width=\textwidth
+ *
+ * @example photocam_example_01.c
+ */
+
+/**
+ * @page inwin_example_01 Inwin - General overview
+ *
+ * Inwin is a very simple widget to show, so this example will be a very simple
+ * one, just using all of the available API.
+ *
+ * The program is nothing but a window with a lonely button, as shown here.
+ *
+ * @image html screenshots/inwin_example.png
+ * @image latex screenshots/inwin_example.eps width=\textwidth
+ *
+ * And pressing the button makes an inwin appear.
+ *
+ * @image html screenshots/inwin_example_a.png
+ * @image latex screenshots/inwin_example_a.eps width=\textwidth
+ *
+ * And the code is just as simple. We being with some global variables to keep
+ * track of our Inwin.
+ * @dontinclude inwin_example.c
+ * @skip static
+ * @until current_style
+ *
+ * And two callbacks used by the buttons the above screenshot showed. In these,
+ * we check if @c inwin exists and execute the proper action on it. If it's not
+ * there anymore, then we were abandoned to our luck, so we disabled ourselves.
+ * @until _inwin_destroy
+ * @until }
+ * @until }
+ *
+ * The lonely button from the beginning, when clicked, will call the following
+ * function, which begins by checking if an inwin exists, and if it's there,
+ * we bring it back to the front and exit from our function without any further
+ * ado.
+ * @until }
+ *
+ * But if no inwin is there to show, we need to create one. First we need the
+ * top-most window for the program, as no inwin can be created using other
+ * objects as parents. Then we create our popup, set the next style in the list
+ * and show it.
+ * @until current_style =
+ *
+ * As for the content of our inwin, it's just a box with a label and some
+ * buttons inside.
+ * @until _inwin_destroy
+ * @until }
+ *
+ * Now, all the code above shows how every object must always be set as content
+ * for some other object, be it by setting the full content, packing it in a
+ * box or table or working as icon for some other widget. But we didn't do
+ * anything like that for the inwin, this one is just created and shown and
+ * everything works. Other widgets can be used this way, but they would need
+ * to be placed and resized manually or nothing would be shown correctly. The
+ * inwin, however, sets itself as a children of the top-level window and will
+ * be resized as the parent window changes too.
+ *
+ * Another characteristic of Inwin is that when it's shown above everyone else,
+ * it will work kind of like a modal window, blocking any other widget from
+ * receiving events until the window is manually dismissed by pressing some
+ * button to close it or having blocking task signalling its completion so
+ * normal operations can be resumed. This is unlike the @ref Hover widget,
+ * that would show its content on top of the designated target, but clicking
+ * anywhere else would dismiss it automatically.
+ *
+ * To illustrate that last point, when we close the main window and an inwin
+ * is still there, we'll take out the content from the inwin and place it in
+ * a hover.
+ * @until }
+ * @until }
+ *
+ * And the rest of the program doesn't have anything else related to inwin,
+ * so it won't be shown here, but you can find it in
+ * @ref inwin_example.c "inwin_example.c".
+ *
+ * @example inwin_example.c
+ */
+
+/**
+ * @page tutorial_scroller Scroller example
+ * @dontinclude scroller_example_01.c
+ *
+ * This example is very short and will illustrate one way to use a scroller.
+ * We'll omit the declaration of the @p text variable because it's a very long
+ * @htmlonly<a href="http://lipsum.com/">@endhtmlonly ipsum lorem
+ * @htmlonly</a>@endhtmlonly. If you really want to see the full code, it's @ref
+ * scroller_example_01.c "scroller_example_01.c".
+ *
+ * We start our example by creating our window and background:
+ * @skip EAPI
+ * @until show(bg)
+ *
+ * Next we create a label and set it's text to @p text(very long ipsum lorem):
+ * @until show(label)
+ *
+ * We then create our scroller, ask that it have the same size as the window and
+ * set its content:
+ * @until content_set
+ *
+ * We are now going to set a number of properties in our scroller:
+ * @li We make it bounce horizontally but not vertically.
+ * @li We make both scrollbars always be visible.
+ * @li We have the events be propagated from the content to the scroller.
+ * @li We enforce a page policy vertically(having a page be the size of the
+ * viewport) and leave horizontal scrolling free.
+ * @li And finally we ask the scroller to show us a region starting at 50,50 and
+ * having a width and height of 200px.
+ * @until region_show
+ * @note Observant reader will note that the elm_scroller_region_show() didn't
+ * scroll the view vertically, this is because we told the scroller to only
+ * accept vertical scrolling in pages.
+ *
+ * And now we're done:
+ * @until ELM_MAIN
+ *
+ * Our example will look like this:
+ *
+ * @image html screenshots/scroller_example_01.png
+ * @image latex screenshots/scroller_example_01.eps width=\textwidth
+ *
+ * @example scroller_example_01.c
+ */
+
+/**
+ * @page tutorial_table_01
+ *
+ * In this example we add four labels to a homogeneous table that has a padding
+ * of 5px between cells.
+ *
+ * The interesting bits from this example are:
+ * @li Where we set the table as homogeneous and the padding:
+ * @dontinclude table_example_01.c
+ * @skip padding_set
+ * @until homogeneous_set
+ * @li Where we add each label to the table:
+ * @skipline elm_table_pack
+ * @skipline elm_table_pack
+ * @skipline elm_table_pack
+ * @skipline elm_table_pack
+ *
+ * Here you can see the full source:
+ * @include table_example_01.c
+ *
+ * Our example will look like this:
+ *
+ * @image html screenshots/table_example_01.png
+ * @image latex screenshots/table_example_01.eps width=\textwidth
+ *
+ * @example table_example_01.c
+ */
+
+/**
+ * @page tutorial_table_02
+ *
+ * For our second example we'll create a table with 4 rectangles in it. Since
+ * our rectangles are of different sizes our table won't be homogeneous.
+ *
+ * The interesting bits from this example are:
+ * @li Where we set the table as not homogeneous:
+ * @dontinclude table_example_02.c
+ * @skipline homogeneous_set
+ * @li Where we add each rectangle to the table:
+ * @skipline elm_table_pack
+ * @skipline elm_table_pack
+ * @skipline elm_table_pack
+ * @skipline elm_table_pack
+ *
+ * Here you can see the full source:
+ * @include table_example_02.c
+ *
+ * Our example will look like this:
+ *
+ * @image html screenshots/table_example_02.png
+ * @image latex screenshots/table_example_02.eps width=\textwidth
+ *
+ * @example table_example_02.c
+ */
+
+/**
+ * @page tutorial_menu Menu Example
+ * @dontinclude menu_example_01.c
+ *
+ * This example shows how to create a menu with regular items, object items,
+ * submenus and how to delete items from a menu. The full source for this
+ * example is @ref menu_example_01.c "menu_example_01.c".
+ *
+ * We'll start looking at the menu creation and how to create a very simple
+ * item:
+ * @skip menu_add
+ * @until item_add
+ *
+ * For our next item we are going to add an icon:
+ * @until item_add
+ *
+ * Now we are going to add more items, but these icons are going to have a
+ * parent, which will put them in a sub-menu. First just another item with an
+ * icon:
+ * @until item_add
+ *
+ * Next we are going to add a button to our menu(any elm widget can be added to
+ * a menu):
+ * @until item_add
+ *
+ * We are also going to have the button delete the first item of our
+ * sub-menu when clicked:
+ * @until smart_callback
+ * @dontinclude menu_example_01.c
+ * @skip static
+ * @until }
+ *
+ * We now add a separator and three more regular items:
+ * @until item_add
+ * @until item_add
+ * @until item_add
+ *
+ * We now add another item, however this time it won't go the sub-menu and it'll
+ * be disabled:
+ * @until disabled_set
+ *
+ * To make sure that our menu is shown whenever the window is clicked(and where
+ * clicked) we use the following callback:
+ * @dontinclude menu_example_01.c
+ * @skip static
+ * @skipline static
+ * @until }
+ *
+ * Our example will look like this:
+ *
+ * @image html screenshots/menu_example_01.png
+ * @image latex screenshots/menu_example_01.eps width=\textwidth
+ *
+ * @example menu_example_01.c
+ */
+
+/**
+ * @page win_example_01 Win - General API overview
+ *
+ * For most users of the Elementary API, the @ref Win widget has a lot more
+ * functions than what they need.
+ *
+ * In general, a developer will create a window, set some content on it and
+ * forget about it for the rest of its program's life, letting whatever
+ * Window Manager is there to handle the window. Here, however, we are going
+ * to show how to generally manage a window.
+ *
+ * We'll have a bit more than the usual includes here, since part of the
+ * example requires some low level fiddling.
+ * @dontinclude win_example.c
+ * @skip Elementary.h
+ * @until Ecore_X.h
+ *
+ * The program then, consists of one window with two lists of buttons, each
+ * of which operates on another two windows. One of them is a normal window,
+ * the other has the @c override flag set so the Window Manager ignores it.
+ *
+ * Pressing each button will call the corresponding function to act on the
+ * corresponding window. These are pretty self explanatory, so we'll show
+ * them in one batch.
+ * @skip static void
+ * @until elm_win_sticky_set
+ * @until }
+ *
+ * Next, we handle the main window closing. We have a @c "delete,request"
+ * callback set to ask if really want to quit. If so, we end the main loop,
+ * otherwise just delete the popup message and continue running normally.
+ * @until _no_quit_cb
+ * @until _no_quit_cb
+ * @until }
+ *
+ * The non-managed window, being completely ignored by the Window Manager,
+ * is likely to never receive keyboard focus, even if we click on its entry
+ * to write something. So we have a button on it that will forcefully focus
+ * it by using some lower level functions to act directly on the X window.
+ * Then, each time one of the window is focused, we print some message on a
+ * console to show this more clearly.
+ * @until _win_focused_cb
+ * @until }
+ *
+ * And to finalize, the main function creates a window to hold all the action
+ * buttons and another two to show how (and what) works on each of them.
+ *
+ * First, the main window will be a normal window, we'll enable the focus
+ * highlight regardless of how it is configured so it's easier to navigate
+ * the window with the keyboard. Then we hook our focus and delete callbacks
+ * and set up the rest of the window's content.
+ * @until evas_object_show(box)
+ *
+ * The first of our sub-windows is the managed one. We'll create it as a
+ * dialog, which should make the Window Manager treat it as a non-resizable
+ * window. We are also setting the window to be auto-deleted when the close
+ * button in the titlebar is pressed.
+ * @until evas_object_show(o)
+ *
+ * Now, we added an icon to the window as a resize object. We also set this
+ * icon to not scale, and no weight size hints have been set for it. This way,
+ * even if we hadn't created the window as a dialog, it would still not be
+ * resizable. The window size is defined by its content, so it would never be
+ * smaller than the smallest of its resize objects, and for it to be resizable,
+ * all of those objects have to allow it.
+ *
+ * Next, we add the buttons with the actions to perform on this window. Using
+ * a macro saves us typing and makes the world a happier place.
+ * @until WIN_ACTION(sticky)
+ *
+ * The maximize one is likely to not work, because the Window Manager will
+ * probably not enforce it upon a window that states its maximum size, much
+ * less a dialog. But that can be changed by editting the example to use
+ * #ELM_WIN_BASIC when creating the window and adding the following line to
+ * the icon set as content
+ * @code
+ * evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ * @endcode
+ *
+ * Lastly, the second sub-window will have it's override flag set. In it we
+ * have a label with some text, and entry and a button. The entry can be
+ * clicked normally to set focus on it, but whether it actually gets keyboard
+ * input will also depend on the window getting focus, and since the window
+ * is an override one, it will probably not gain it by normal means. The
+ * button is there to force the focus at the X level to go to our window.
+ * And to finish, another list of buttons with actions to perform on this
+ * last window. Remember that most of them are requests or hints for the
+ * Window Manager, so they are likely to do nothing on this window.
+ * Similarly, there won't be any way to move it or resize it, because we
+ * haven't implemented that kind of control on this example and that's
+ * something controlled by Window Managers on windows they are tracking, which
+ * is not the case with this one.
+ * @until ELM_MAIN
+ *
+ * The full code listing of this example can be found at
+ * @ref win_example.c "win_example.c".
+ *
+ * @example win_example.c
+ */
+
+/**
+ * @page web_example_01 Web - Simple example
+ *
+ * WebKit-EFL is independent of any particular toolkit, such as Elementary,
+ * so using it on applications requires that the programmer writes a lot of
+ * boiler plate code to manage to manage the web object.
+ *
+ * For a full featured browser this may make sense, as the programmer will
+ * want to have full control of every aspect of the web object, since it's the
+ * main component of the application. But other programs with simpler
+ * requirements, having to write so much code is undesired.
+ *
+ * This is where elm_web comes in. Its purpose is to provide a simple way
+ * for developers to embed a simple web object in their programs, simplifying
+ * the common use cases.
+ *
+ * This is not to say that a browser can't be made out of it, as this example
+ * shows.
+ *
+ * We'll be making a simple browser, consisting of one window with an URL bar,
+ * a toolbar to be used for the tabs and a pager to show one page at a time.
+ *
+ * When all tabs are closed, we'll be showing a default view with some custom
+ * content, for which we need to get the internal @c ewk_view object and use
+ * some WebKit functions on it, thus we need to include the necessary headers
+ * first.
+ *
+ * @dontinclude web_example.c
+ * @skip include
+ * @until EWebKit
+ *
+ * A struct to keep track of the different widgets in use and the currently
+ * shown tab. There's also an @c exiting flag, used to work around the overly
+ * simplistic way in which this example is written, just to avoid some
+ * warnings when closing the program.
+ *
+ * @skip typedef
+ * @skip typedef
+ * @until App_Data
+ *
+ * Each tab has its own struct too, but there's not much to it.
+ * @until };
+ *
+ * Whenever the currently selected tab changes, we need to update some state
+ * on the application. The back and forward buttons need to be disabled
+ * accordingly and the URL bar needs to show the right address.
+ *
+ * @skip static void
+ * @until naviframe_item_simple_promote
+ * @until }
+ *
+ * Other updates happen based on events from the web object, like title change
+ * to update the name shown in the tab, and URL change which will update the
+ * URL bar if the event came from the currently selected tab.
+ *
+ * @skip tab_current_set
+ * @skip static void
+ * @until }
+ * @until }
+ *
+ * Adding a new tab is just a matter of creating a new web widget, its data
+ * and pushing it into the pager. A lot of the things that we should handle
+ * here, such as how to react to popups and JavaScript dialogs, are done
+ * already in the @c elm_web widget, so we can rely on their default
+ * implementations. For the JavaScript dialogs we are going to avoid having
+ * them open in a new window by setting the @c Inwin mode.
+ *
+ * There is no default implementation, however, for the requests to create a
+ * new window, so we have to handle them by setting a callback function that
+ * will ultimately call this very same function to add a new tab.
+ *
+ * @skip Tab_Data
+ * @until }
+ *
+ * Entering an address in the URL bar will check if a tab exists, and if not,
+ * create one and set the URL for it. The address needs to conform to the URI
+ * format, so we check that it does and add the protocol if it's missing.
+ *
+ * @skip static char
+ * @until eina_stringshare_del
+ * @until }
+ *
+ * The navigation buttons are simple enough. As for the refresh, it normally
+ * reloads the page using anything that may exist in the caches if applicable,
+ * but we can press it while holding the @c Shift key to avoid the cache.
+ *
+ * @skip static void
+ * @until web_forward
+ * @until }
+ *
+ * The callback set for the new window request creates a new tab and returns
+ * the web widget associated with it. This is important, this function must
+ * return a valid web widget returned by elm_web_add().
+ *
+ * @skip static Evas_Object
+ * @until }
+ *
+ * Pressing @c Ctrl-F will bring up the search box. Nothing about the box
+ * itself is worth mentioning here, but it works as you would expect from any
+ * other browser. While typing on it, it will highlight all occurrences of the
+ * searched word. Pressing @c Enter will go to the next instance and the two
+ * buttons next to the entry will move forward and backwards through the found
+ * keywords.
+ *
+ * @skip win_del_request
+ * @skip static void
+ * @until win_search_trigger
+ * @until }
+ *
+ * Last, create the main window and put all of the things used above in it. It
+ * contains a default web widget that will be shown when no tabs exist. This
+ * web object is not browsable per se, so history is disabled in it, and we
+ * set the same callback to create new windows, on top of setting some custom
+ * content of our own on it, with some links that will open new tabs to start
+ * browsing quickly.
+ *
+ * @skip static void
+ * @until ELM_MAIN
+ *
+ * Some parts of the code were left out, as they are not relevant to the
+ * example, but the full listing can be found at @ref web_example.c
+ * "web_example.c".
+ *
+ * @example web_example.c
+ */
+
+/**
+ * @page efl_thread_1 EFL Threading example 1
+ *
+ * You can use threads with Elementary (and EFL) but you need to be careful
+ * to only use eina or eet calls inside a thread. Other libraries are not
+ * totally threadsafe except for some specific ecore calls designed for
+ * working from threads like the ecore_pipe_write() and ecore_thread calls.
+ *
+ * Below is an example of how to use EFL calls from a native thread you have
+ * already created. You have to put the EFL calls inside the critical block
+ * between ecore_thread_main_loop_begin() and ecore_thread_main_loop_end()
+ * which ensure you gain a lock on the mainloop. Beware that this requires
+ * that the thread WAIT to synchronize with the mainloop at the beginning of
+ * the critical section. It is highly suggested you use as few of these
+ * in your thread as possible and probably put just a single
+ * ecore_thread_main_loop_begin() / ecore_thread_main_loop_end() section
+ * at the end of the threads calculation or work when it is done and
+ * would otherwise exit to sit idle.
+ *
+ * For a progression of examples that become more complex and show other
+ * ways to use threading with EFL, please see:
+ *
+ * @ref efl_thread_2
+ *
+ * @ref efl_thread_3
+ *
+ * @ref efl_thread_4
+ *
+ * @ref efl_thread_5
+ *
+ * @ref efl_thread_6
+ *
+ * @include efl_thread_1.c
+ */
+
+/**
+ * @page efl_thread_2 EFL Threading example 2
+ *
+ * You can also use ecore_main_loop_thread_safe_call_sync() to call a
+ * specific function that needs to do EFL main loop operations. This call
+ * will block and wait to synchronise to the mainloop just like
+ * ecore_thread_main_loop_begin() / ecore_thread_main_loop_end() will,
+ * but instead you simply provide it the function callback to call instead
+ * of inlining your code.
+ *
+ * @ref efl_thread_3
+ *
+ * @ref efl_thread_4
+ *
+ * @ref efl_thread_5
+ *
+ * @ref efl_thread_6
+ *
+ * @include efl_thread_2.c
+ */
+
+/**
+ * @page efl_thread_3 EFL Threading example 3
+ *
+ * Like with ecore_main_loop_thread_safe_call_sync() you can provide a
+ * callback to call inline in the mainloop, but this time with
+ * ecore_main_loop_thread_safe_call_async() the callback is queued and
+ * called asynchronously, without the thread blocking. The mainloop will
+ * call this function when it comes around to its synchronisation point. This
+ * acts as a "fire and forget" way of having the mainloop do some work
+ * for a thread that has finished processing some data and is read to hand it
+ * off to the mainloop and the thread wants to march on and do some more work
+ * while the main loop deals with "displaying" the results of the previous
+ * calculation.
+ *
+ * @ref efl_thread_4
+ *
+ * @ref efl_thread_5
+ *
+ * @ref efl_thread_6
+ *
+ * @include efl_thread_3.c
+ */
+
+/**
+ * @page efl_thread_4 EFL Threading example 4
+ *
+ * Now when you want to have a thread do some work, send back results to
+ * the mainloop and continue running but the mainloop controls when the
+ * thread should stop working, you need some extra flags. This is an example
+ * of how you might use ecore_main_loop_thread_safe_call_async() and pthreads
+ * to do this.
+ *
+ * @ref efl_thread_5
+ *
+ * @ref efl_thread_6
+ *
+ * @include efl_thread_4.c
+ */
+
+/**
+ * @page efl_thread_5 EFL Threading example 5
+ *
+ * This is the same as @ref efl_thread_4 but now uses the ecore_thread
+ * infrastructure to have a running worker thread that feeds results back
+ * to the mainloop and can easily be cancelled. This saves some code in the
+ * application and makes for fewer problem spots if you forget a mutex.
+ *
+ * @ref efl_thread_6
+ *
+ * @include efl_thread_5.c
+ */
+
+/**
+ * @page efl_thread_6 EFL Threading example 6
+ *
+ * You can also use the ecore_thread infrastructure for compute tasks that
+ * don't send feedback as they go - they are one-shot compute jobs and when
+ * done they will trigger the end callback in the mainloop which is intended
+ * to pick up the results and "display them".
+ *
+ * @include efl_thread_6.c
+ */
+
+/**
+ * @page bg_example_01_c bg_example_01.c
+ * @include bg_example_01.c
+ * @example bg_example_01.c
+ */
+
+/**
+ * @page bg_example_02_c bg_example_02.c
+ * @include bg_example_02.c
+ * @example bg_example_02.c
+ */
+
+/**
+ * @page bg_example_03_c bg_example_03.c
+ * @include bg_example_03.c
+ * @example bg_example_03.c
+ */
+
+/**
+ * @page actionslider_example_01 Actionslider example
+ * @include actionslider_example_01.c
+ * @example actionslider_example_01.c
+ */
+
+/**
+ * @page transit_example_01_c Transit example 1
+ * @include transit_example_01.c
+ * @example transit_example_01.c
+ */
+
+/**
+ * @page transit_example_02_c Transit example 2
+ * @include transit_example_02.c
+ * @example transit_example_02.c