*
* @ref actionslider_example_page
*
- * @ref elm_animator_example_page_01
- *
* @ref transit_example_01_explained
*
* @ref transit_example_02_explained
* @ref clock_example
*
* @ref mapbuf_example
+
+ * @ref map_example_01
+ *
+ * @ref map_example_02
+ *
+ * @ref map_example_03
*
* @ref diskselector_example_01
*
* @ref progressbar_example
*
* @ref slideshow_example
+ *
+ * @ref efl_thread_1
+ *
+ * @ref efl_thread_2
+ *
+ * @ref efl_thread_3
+ *
+ * @ref efl_thread_4
+ *
+ * @ref efl_thread_5
+ *
+ * @ref efl_thread_6
*/
/**
* @until }
*
* The next callback will be used when setting the overlay (using
- * elm_bg_overlay_set()):
+ * elm_object_content_set()):
*
* @skip _cb_overlay_changed
* @until }
*
* @skipline elm_radio_value_set
*
- * Then we add a checkbox for the elm_bg_overlay_set() function:
+ * Then we add a checkbox for the elm_object_content_set() function for the bg:
*
* @skip check_add
* @until evas_object_show
*
* Now look at the code of the @c _cb_overlay_changed again. If the checkbox
* state is checked, an overlay will be added to the background. It's done by
- * creating an Edje object, and setting it with elm_bg_overlay_set() to the
+ * creating an Edje object, and setting it with elm_object_content_set() to the
* background object. For information about what are and how to set Edje
* object, look at the Edje documentation.
*
*/
/**
- * @page elm_animator_example_page_01 Animator usage
- * @dontinclude animator_example_01.c
- *
- * For this example we will be using a bit of evas, you could animate a
- * elementary widget in much the same way, but to keep things simple we use
- * an evas_object_rectangle.
- *
- * As every other example we start with our include and a simple callback to
- * exit the app when the window is closed:
- * @skipline #include
- * @until }
- *
- * This next callback is the one that actually creates our animation, it
- * changes the size, position and color of a rectangle given to it in @a
- * data:
- * @until }
- *
- * Next we have a callback that prints a string, nothing special:
- * @until }
- *
- * This next callback is a little more interesting, it has a state variable
- * to know if the animation is currently paused or running, and it toogles
- * the state of the animation accordingly:
- * @until }
- * @until }
- * @until }
- *
- * Finally we have a callback to stop the animation:
- * @until }
- *
- * As with every example we need to do a bit of setup before we can actually
- * use an animation, but for the purposes of this example that's not relevant
- * so let's just skip to the good stuff, creating an animator:
- * @skipline animator_add
- * @note Since elm_animator is not a widget we can give it a NULL parent.
- *
- * Now that we have an elm_animator we set it's duration to 1 second:
- * @line duration_set
- *
- * We would also like our animation to be reversible, so:
- * @line reverse_set
- *
- * We also set our animation to repeat as many times as possible, which will
- * mean that _end_cb will only be called after UINT_MAX * 2 seconds(UINT_MAX
- * for the animation running forward and UNIT_MAX for the animation running
- * backwards):
- * @line repeat_set
- *
- * To add some fun to our animation we will use the IN_OUT curve style:
- * @line curve_style
- *
- * To actually animate anything we need an operation callback:
- * @line operation_callback
- *
- * Even though we set our animation to repeat for a very long time we are
- * going to set a end callback to it:
- * @line completion_callback
- * @note Notice that stoping the animation with the stop button will not make
- * _end_cb be called.
- *
- * Now that we have fully set up our animator we can tell it to start
- * animating:
- * @line animate
- *
- * There's a bit more of code that doesn't really matter to use so we skip
- * right down to our last interesting point:
- * @skipline animator_del
- * @note Because we created our animator with no parent we need to delete it
- * ourselves.
- *
- * The example should look like this:
- *
- * @image html screenshots/animator_example_01.png
- * @image latex screenshots/animator_example_01.eps width=\textwidth
- * @n
- * @image html screenshots/animator_example_02.png
- * @image latex screenshots/animator_example_02.eps width=\textwidth
- * @n
- * @image html screenshots/animator_example_03.png
- * @image latex screenshots/animator_example_03.eps width=\textwidth
- *
- * The full source code for this example can be found @ref
- * animator_example_01_c "here"
- */
-
-/**
* @page transit_example_03_c elm_transit - Combined effects and options.
*
* This example shows how to apply the following transition effects:
* @skip on_done
* @until evas_object_resize
*
- * We also add a resizeable white background to use behind our animation:
+ * We also add a resizable white background to use behind our animation:
*
* @skip bg_add
* @until evas_object_show
* @skip on_done
* @until evas_object_resize
*
- * We also add a resizeable white background to use behind our animation:
+ * We also add a resizable white background to use behind our animation:
*
* @skip bg_add
* @until evas_object_show
* callback, where we move the button doing some size hint magic. To
* understand how that works better, refer to the @ref Box documentation.
* Also, the first time the function is called, we change the icon in the
- * middle button, using elm_button_icon_unset() first to keep the reference
+ * middle button, using elm_object_content_unset() first to keep the reference
* to the previous one, so we don't need to recreate it when we are done
* moving it.
* @skip static void
* @until elm_win_autodel
*
* Next a simple background is placed on our windows. More details on
- * @ref bg_01_example_page:
+ * @ref bg_01_example_page :
* @until evas_object_show(bg)
*
* Now, the exciting part, let's add the calendar with elm_calendar_add(),
* @image html screenshots/spinner_example.png
* @image latex screenshots/spinner_example.eps width=\textwidth
*
- * See the full @ref spinner_example_c "source code" for this example.
+ * See the full @ref spinner_example.c "source code" for this example.
*
* @example spinner_example.c
*/
* @image html screenshots/slider_example.png
* @image latex screenshots/slider_example.eps width=\textwidth
*
- * See the full @ref slider_example_c "source code" for this example.
+ * See the full @ref slider_example.c "source code" for this example.
*
* @example slider_example.c
*/
*/
/**
+ * @page map_example_01 Map Example - Creation and Zoom
+ *
+ * This code places a Elementary map widget on a window,
+ * to exemplify part of the widget's API.
+ *
+ * Let's start adding a map to our window:
+ * @dontinclude map_example_01.c
+ * @skipline elm_map_add
+ * @until evas_object_show
+ *
+ * It's enough to display a world map inside our window. But usually you'll
+ * need to let user interact with the map. We need to place some buttons,
+ * so the user could control the map. It's done on the followin code.
+ * If you don't know about boxes, or buttons, check their examples,
+ * @ref box_example_01 "Box Example 1" and
+ * @ref button_example_01 "Button Example 1".
+ * @skipline elm_box_add
+ * @until _bt_zoom_fill
+ *
+ * We are adding callback functions that will be called when the user clicks
+ * over these buttons. Let's study such functions, starting from the function
+ * that will zoom in the map:
+ * @dontinclude map_example_01.c
+ * @skipline static void
+ * @until }
+ *
+ * First thing done is assure zoom mode is set to manual. It's the default
+ * mode, but the other buttons will change this, so before setting a new
+ * zoom value, we need to change the zoom mode.
+ *
+ * Then, we get the current zoom value, increment that, and set the new
+ * value to the map. If it's bigger than max zoom value allowed, it will
+ * remain on the maximum allowed, nothing bad will happen. This way we
+ * don't need to check first if it won't be bigger than max.
+ *
+ * Zoom out function is basically the same thing, but zoom will be decremented
+ * instead of incremented:
+ * @skipline static void
+ * @until }
+ *
+ * The "X" button, when pressed, will call a function that will
+ * zoom the map until it fits
+ * inside the scroll frame with no pixels outside this area:
+ * @skipline static void
+ * @until }
+ *
+ * And the "#" button, will call a function that will zoom until map fills
+ * scroll, ensuring no pixels are left unfilled:
+ * @skipline static void
+ * @until }
+ *
+ * But we can also set map to show something different from default
+ * world map, changing the zoom level and region shown. Let's pick a
+ * wonderful city coordinates, one placed at <tt> 43 20 S, 22 90 W </tt>.
+ * Since map uses double variables to represent latitude and longitude,
+ * to represent north or east, we should represent it as positive values,
+ * and south or west as negative. Also, the value will be represented as
+ * degree.min. So, for example, our longitude <tt> 43 20 S </tt> will
+ * be represented
+ * by the value <tt> -43.20 </tt>. A zoom set to @c 12 should be enough
+ * to show a city.
+ * @skipline region_show
+ * @until zoom_set
+ *
+ * See @ref map_example_01.c "map_example_01.c" for full source,
+ * whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/map_example_01.png
+ * @image latex screenshots/map_example_01.eps width=\textwidth
+ *
+ * @example map_example_01.c
+ */
+
+/**
+ * @page map_example_02 Map Example - Markers Usage
+ *
+ * This code places a Elementary map widget on a window,
+ * to exemplify part of the widget's API, related to markers.
+ *
+ * We'll start this example the same way
+ * @ref map_example_01 "Map Example 1". Adding a map with buttons to control
+ * zoom, so if you didn't read it yet, just do it now.
+ * @dontinclude map_example_02.c
+ * @skipline elm_map_add
+ * @until zoom_fill
+ *
+ * Markers can be placed over the map to represent anything we want. Let's
+ * say we want to represent some countries and cities with markers. To add
+ * a mark we need a marker class and also a group class.
+ *
+ * A marker class can be created as the following code does:
+ * @skipline marker_class_new
+ * @until style_set
+ *
+ * These lines create a new class, set a function to return the object
+ * to be displayed inside the bubble that opens when a user clicks over
+ * the mark, set the function to retrieve an icon to be placed inside
+ * the marker, and defines the style of this marker. It can be @c empty
+ * that will just show the icon, @c radio, that will place a blue circle,
+ * and @c radio2 that will place a green circle.
+ *
+ * The group classes can be created in a very similar way, but you won't
+ * set callback functions to get stuff to be placed inside the bubble,
+ * since clicking over a group marker will just get the content
+ * of all the markers composing the group and place on this bubble.
+ * The limit of markers to get can be set with function
+ * elm_map_max_marker_per_group_set() but we won't need on this example.
+ * But we can set the zoom required to display the marks that belongs
+ * to this group class, so if the zoom is less than this value, nothing
+ * will be show. The group marker style will be used when markers are
+ * near each other, and the count of markers grouped will be placed
+ * inside the group marker.
+ * @skipline group_class_new
+ * @until displayed_set
+ *
+ * For marker and group classes to represent a country, the same is done:
+ * @skipline marker_class_new
+ * @until displayed_set
+ *
+ * Next we'll create some markers representing cities and coutries.
+ * We'll append them in a list, to close up them later. To create a marker
+ * we need to pass the coordinates, marker class, group class and optionally,
+ * data:
+ * @skipline marker_add
+ * @until data_chile
+ * @until append
+ *
+ * We have created a specific structure for this example to store the name
+ * of the place and a path to a image file to represent it.
+ * @dontinclude map_example_02.c
+ * @skipline typedef
+ * @until Marker_Data;
+ *
+ * We'll create instances for each place:
+ * @skipline argentina
+ * @until sky_03
+ *
+ * Finally, on our @c main function, we ask the map to show all the markers
+ * with the biggest zoom possible, passing the list of markers added:
+ * @skipline list_show
+ *
+ * Actually the zoom is not what we want, so after the download of the map
+ * is concluded, let's set another zoom level. For this we add a callback
+ * for @c "downloaded" signal:
+ * @skipline callback_add
+ *
+ * The callback function will simply set the zoom level we want and remove
+ * the callback, otherwise it would be called all the time, after the map
+ * is downloaded:
+ * @dontinclude map_example_02.c
+ * @skipline _map_downloaded
+ * @until }
+ *
+ * We added two kinds of callback functions when we added the markers.
+ * One will return the content of the bubbles, and other the icon to be
+ * placed inside the marker.
+ *
+ * To return an icon, all we need to do is add a elm_icon and return it:
+ * @dontinclude map_example_02.c
+ * @skip static Evas_Object
+ * @skip }
+ * @skipline static Evas_Object
+ * @until }
+ *
+ * For the content, let's return something more elaboreate. We will return
+ * a box with an image representing the place, and the name of this place:
+ * @skipline static Evas_Object
+ * @until }
+ *
+ * See @ref map_example_02.c "map_example_02.c" for full source,
+ * whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/map_example_02.png
+ * @image latex screenshots/map_example_02.eps width=\textwidth
+ *
+ * @example map_example_02.c
+ */
+
+/**
+ * @page map_example_03 Map Example - Route and Name Usage
+ *
+ * This code places a Elementary map widget on a window,
+ * to exemplify part of the widget's API, related routes and names.
+ *
+ * In this example, we will suppose we need to set a route for the user
+ * from his current point (a gps could provide us this information)
+ * to somewhere else. So we would have coordinates of this
+ * start point, and would like that he enters the address of his
+ * destination in a entry, and we'll trace a route on the map.
+ *
+ * We'll start this example the same way
+ * @ref map_example_01 "Map Example 1". Adding a map with buttons to control
+ * zoom, so if you didn't read it yet, just do it now. Actually there is
+ * a change, that we're aligning buttons to the top, since we wan't a
+ * vertical control box this time.
+ * @dontinclude map_example_03.c
+ * @skipline elm_map_add
+ * @until zoom_fill
+ * @until align_set
+ *
+ * Next we set the box to be vertical and change it's size, weight
+ * and alignment, so it will occupy the top of the window, from left
+ * to right:
+ * @skipline horizontal_set
+ * @until align_set
+ *
+ * We'll add an entry with a preliminar address, that I know will
+ * find a coordinate, to examplify names work. But you can try
+ * lots of addresses. From city or country names to pubs, or whatever
+ * you want. To try is enough to run the example, type the address and
+ * press "Route" button. This button will call a function that will
+ * get the typed address and find the route.
+ * @skipline entry_add
+ * @until align_set
+ * @until align_set
+ *
+ * The button pass an structure
+ * instance we make for this example, with all the fields we'll need.
+ * @dontinclude map_example_03.c
+ * @skipline _Example_Data
+ * @until example_data;
+ *
+ * Let's initialize it's fields:
+ * @skipline example_data.map
+ * @until example_data.start_lat
+ *
+ * @c map and @c entry are our elementary objects, @c route is set to @c NULL,
+ * since we don't have one yet, and the coordinates of the start point is set
+ * (longitude and latitude).
+ *
+ * Also, let's show this start point at the center of the map, and set a zoom
+ * nice enough to close it:
+ * @skipline region_show
+ * @until zoom_set
+ *
+ * These lines were already explained on @ref map_example_02 "Map Example 2".
+ *
+ * Now we'll see the "Route" button callback function:
+ * @dontinclude map_example_03.c
+ * @skip static void
+ * @skip }
+ * @skipline static void
+ * @until }
+ *
+ * First we get the address string from our entry. Then we use @c name
+ * conversion
+ * util functions, so we could get coordinates for this address. These
+ * functions return an #Elm_Map_Name handle for us.
+ * Function elm_map_utils_convert_name_into_coord() will do this job for us,
+ * but it's an assyncronous function, since it requires this
+ * information from the server.
+ *
+ * That's the reason we need to wait for
+ * <tt> "name,loaded" </tt> signal. We add a callback function for this:
+ * @dontinclude map_example_03.c
+ * @skipline static void
+ * @until }
+ *
+ * This function will check if a previous route was traced, and if it was,
+ * it will remove it. Next we'll get destination coordinates from our
+ * @c name, and use them to add a new route.
+ *
+ * To trace a route we need to know how the user will go through the path.
+ * Let's suppose he'll be walking, but doesn't like to walk, so we
+ * need to choose the shortest path intead of the route that would
+ * made him spend less time. Coordinates of the point from where he will
+ * start and of the destination point need to be passed as well.
+ *
+ * Finally we'll set a color different from solid red (default), to show
+ * our route. We set it green.
+ *
+ * See @ref map_example_03.c "map_example_03.c" for full source,
+ * whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/map_example_03.png
+ * @image latex screenshots/map_example_03.eps width=\textwidth
+ *
+ * @example map_example_03.c
+ */
+
+/**
* @page diskselector_example_01 Diskselector widget example
*
* This code places 4 Elementary diskselector widgets on a window, each of
*
* @note You can't set less than 3 items to be displayed.
*
+ * You can get the number of items in the diskselector by calling
+ * elm_diskselector_display_item_num_get(), as you can see here:
+ * @skipline elm_diskselector_add
+ *
* Finally, if a bounce effect is required, or you would like to see
* scrollbars, it is possible. But, for default theme, diskselector
* scrollbars will be invisible anyway.
* @until }
*
* This call elm_layout_data_get() is used to fetch the string based on the key,
- * and elm_object_text_part_set() will set the part defined in the theme as
+ * and elm_object_part_text_set() will set the part defined in the theme as
* "example/title" to contain this string. This key "example/title" has nothing
* special. It's just an arbitrary convention that we are using in this example.
* Every string in this example referencing a part of this theme will be of the
* Finally, we have an area in this layout theme, in the bottom part of it,
* reserved for adding an specific widget. Differently from the 2 parts
* described until now, this one can only receive one widget with the call
- * elm_layout_content_set(). If there was already an item on this specific part,
- * it will be deleted (one can use elm_layout_content_unset() in order to remove
+ * elm_object_part_content_set() for the layout. If there was already an item on this specific part,
+ * it will be deleted (one can use elm_object_part_content_unset() in order to remove
* it without deleting). An example of removing it without deleting, but
* manually deleting this widget just after that, can be seen on the callback
* for this button. Actually, the callback defined for this button will clean
* Also notice that, for this last added button, we don't have to call
* evas_object_show() on it. This is a particularity of the theme for layouts,
* that will have total control over the properties like size, position,
- * visibility and clipping of a widget added with elm_layout_content_set().
+ * visibility and clipping of a widget added with elm_object_part_content_set().
* Again, read the Edje documentation to understand this better.
*
* Now we just put the code for the different callbacks specified for each kind
* The callback for this button will check what type of signal it should send,
* and then emit it. The code for this callback follows:
*
- * @dontinclude layout_exmaple_03.c
+ * @dontinclude layout_example_03.c
* @skip static Eina_Bool
* @until Enlarge
* @until }
* green). Our example will allow the user to choose the animation the flip
* uses and to interact with it. To allow the user to choose the interaction
* mode we use radio buttons, we will however not explain them, if you would
- * like to know more about radio buttons see @ref radio.
+ * like to know more about radio buttons see @ref Radio.
*
* We start our example with the usual setup and then create the 2 rectangles
* we will use in our flip:
* @dontinclude image_example_01.c
*
* This example is as simple as possible. An image object will be added to the
- * window over a white background, and set to be resizeable together with the
+ * window over a white background, and set to be resizable together with the
* window. All the options set through the example will affect the behavior of
* this image.
*
* @dontinclude icon_example_01.c
*
* This example is as simple as possible. An icon object will be added to the
- * window over a white background, and set to be resizeable together with the
+ * window over a white background, and set to be resizable together with the
* window. All the options set through the example will affect the behavior of
* this icon.
*
* @until evas_object_show
*
* Finally, we'll set the box as conformant's content, just like this:
- * @skipline elm_conformant_content_set
+ * @skipline elm_object_content_set
*
* Compare both examples code:
* @ref conformant_example_01.c "conformant_example_01.c"
* @image html screenshots/index_example_03.png
* @image latex screenshots/index_example_03.eps
*
- * See the full @ref index_example_c "source code" for
+ * See the full @ref index_example.c "source code" for
* this example.
*
* @example index_example_02.c
* This example will look like this:
*
* @image html screenshots/separator_example_01.png
- * @image eps screenshots/separator_example_01.eps width=\textwidth
+ * @image latex screenshots/separator_example_01.eps width=\textwidth
*
* @example separator_example_01.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 pager_content_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 animator_example_01_c Animator example 01
- * @include animator_example_01.c
- * @example animator_example_01.c
- */
-
-/**
* @page transit_example_01_c Transit example 1
* @include transit_example_01.c
* @example transit_example_01.c
* @include slideshow_example.c
* @example slideshow_example.c
*/
+
+/**
+ * @page efl_thread_1_c EFL Threading example 1
+ * @include efl_thread_1.c
+ * @example efl_thread_1.c
+ */
+
+/**
+ * @page efl_thread_2_c EFL Threading example 2
+ * @include efl_thread_2.c
+ * @example efl_thread_2.c
+ */
+
+/**
+ * @page efl_thread_3_c EFL Threading example 3
+ * @include efl_thread_3.c
+ * @example efl_thread_3.c
+ */
+
+/**
+ * @page efl_thread_4_c EFL Threading example 4
+ * @include efl_thread_4.c
+ * @example efl_thread_4.c
+ */
+
+/**
+ * @page efl_thread_5_c EFL Threading example 5
+ * @include efl_thread_5.c
+ * @example efl_thread_5.c
+ */
+
+/**
+ * @page efl_thread_6_c EFL Threading example 6
+ * @include efl_thread_6.c
+ * @example efl_thread_6.c
+ */
projects / framework / uifw / elementary.git / blobdiff