*
* @ref actionslider_example_page
*
- * @ref elm_animator_example_page_01
- *
* @ref transit_example_01_explained
*
* @ref transit_example_02_explained
*
* @ref clock_example
*
+ * @ref datetime_example
+ *
+ * @ref dayselector_example
+ *
+ * @ref mapbuf_example
+
+ * @ref map_example_01
+ *
+ * @ref map_example_02
+ *
+ * @ref map_example_03
+ *
* @ref diskselector_example_01
*
* @ref diskselector_example_02
*
+ * @ref entry_example
+ *
* @ref list_example_01
*
* @ref list_example_02
*
* @ref list_example_03
*
+ * @ref toolbar_example_01
+ *
+ * @ref toolbar_example_02
+ *
+ * @ref toolbar_example_03
+ *
+ * @ref segment_control_example
+ *
* @ref flipselector_example
*
* @ref fileselector_example
*
* @ref genlist_example_02
*
+ * @ref genlist_example_03
+ *
+ * @ref genlist_example_04
+ *
+ * @ref genlist_example_05
+ *
+ * @ref glview_example_01_page
+ *
+ * @ref thumb_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
*/
/**
* @skip size_hint_weight_set
* @until resize_object_add
*
- * See @ref evas_object_size_hint_weight_set and elm_win_resize_object_add()
+ * See evas_object_size_hint_weight_set() and elm_win_resize_object_add()
* for more detailed info about these functions.
*
* The end of the example is quite simple, just setting the minimum and
* @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
*/
/**
+ * @page button_example_00 Button - Hello, Button!
+ *
+ * @dontinclude button_example_00.c
+ *
+ * Keeping the tradition, this is a simple "Hello, World" button example. We
+ * will show how to create a button and associate and action to be performed
+ * when you click on it.
+ *
+ * In the end, we'll be presented with something that looks like this:
+ *
+ * @image html screenshots/button_00.png
+ * @image latex screenshots/button_00.eps width=\textwidth
+ *
+ * The full code of the example is @ref button_example_00.c "here" and we
+ * will follow here with a rundown of it.
+ *
+ *
+ * There is only one button on the interface which performs a basic action:
+ * close the application. This behavior is described by on_click() function,
+ * that interrupt the program invoking elm_exit().
+ * @skip static void
+ * @until }
+ *
+ *
+ * On the main() function, we set the basic characteristics of the user
+ * interface. First we use the Elementary library to create a window and
+ * set its policies (such as close when the user click on the window close
+ * icon).
+ *
+ * @skip elm_win_add
+ * @until elm_policy_set
+ *
+ * In order to turn it visible on the WM (Window Manager), we also have to
+ * associate it to a canvas through Evas library, and set its dimensions.
+ *
+ * @skip evas_object_resize
+ * @until evas_object_show(win)
+ *
+ * Then we create a background associated to the window, define its dimensions,
+ * and turn it visible on the canvas.
+ * @skip elm_bg_add
+ * @until evas_object_show(bg)
+ *
+ *
+ * Finally we use Elementary to create a button and Evas to set its
+ * proprieties. Here we have not only to give the button dimensions, but also
+ * its coordinates and the action to be performed on the click event.
+ * @skip elm_button_add
+ * @until evas_object_show(btn)
+ *
+ *
+ * And we are done.
+ *
+ * @example button_example_00.c
+ */
+
+/**
* @page button_example_01 Button - Complete example
*
* @dontinclude button_example_01.c
* 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(),
*
* To set weekday names, we should declare them as an array of strings:
* @dontinclude calendar_example_02.c
- * @skipline weekdays
+ * @skipline weekdays[]
* @until }
*
* And finally set them to calendar:
- * skipline weekdays_names_set
+ * @skipline weekdays_names_set
*
* Our example will look like this:
*
* If isn't required that users could select a day on calendar,
* only interacting going through months, disabling days selection
* could be a good idea to avoid confusion. For that:
- * @skipline elm_calendar_day_selection_enabled_set
+ * @skipline elm_calendar_day_selection_disabled_set
*
* Also, regarding days selection, you could be interested to set a
* date to be highlighted on calendar from your code, maybe when
- * a specific event happens, or after calendar creation. Let's select
- * two days from current day:
+ * a specific event happens, or after calendar creation. As @c time output is
+ * in seconds, we define the number of seconds contained within a day as a
+ * constant:
* @dontinclude calendar_example_04.c
* @skipline SECS_DAY
- * @skipline current_time
+ *
+ * Now let's select two days from current day:
+ * @skipline time(NULL)
* @until elm_calendar_selected_time_set
*
* Our example will look like this:
* be read on @c ctime manpage.
* If a date relative from current is required, this struct can be set
* as:
- * @skipline current_time
+ * @skipline time(NULL)
* @until localtime_r
*
* Or if it's an absolute date, you can just declare the struct like:
* Periodicity is how frequently the mark will be displayed over the
* calendar. Can be a unique mark (that don't repeat), or it can repeat
* daily, weekly, monthly or annually. It's enumerated by
- * @c Elm_Calendar_Mark_Repeat.
+ * @c Elm_Calendar_Mark_Repeat_Type.
*
* So let's add some marks to our calendar. We will add christmas holiday,
* set Sundays as holidays, and check current day and day after that.
* @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
*/
* If some decoration is required, a label can be set, and icon before and
* after the bar as well. On the second slider will add a @c home icon
* and a @c folder icon at @c end.
- * @skipline text_set
- * @until end_set
+ * @skip elm_object_text_set
+ * @until elm_object_part_content_set(sl, "end", ic)
*
* If the bar size need to be changed, it can be done with span set function,
* that doesn't accounts other widget's parts size. Also the bar can starts
* @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
*/
*
* The fifth, besides editable, has only the time @b units editable,
* for hours, minutes and seconds. This exemplifies
- * elm_clock_digit_edit_set():
+ * elm_clock_edit_mode_set():
* @dontinclude clock_example.c
* @skip but only
* @until evas_object_show
*/
/**
+ * @page datetime_example Datetime widget example
+ *
+ * This code places three Elementary Datetime widgets on a window, each of
+ * them exemplifying the widget's different usage.
+ *
+ * The first of them is <b>"only Date display"</b>:
+ * @dontinclude datetime_example.c
+ * @skip only DATE
+ * @until evas_object_show
+ *
+ * For <b>"only Time display"</b>, see the second datetime:
+ * @dontinclude datetime_example.c
+ * @skip only TIME
+ * @until evas_object_show
+ *
+ * The third one will display datetime shows both <b>Date and Time</b>, corresponding format will be
+ * taken from system @b locale. Note, besides, that the strings are different
+ * for different language settings.
+ *
+ * <b>Datetime format</b> can be programmatically set by using
+ * elm_datetime_format_set():
+ * @dontinclude datetime_example.c
+ * @skip DATE and TIME
+ * @until evas_object_show
+ * The default format of any locale consists:
+ * - Year Field
+ * - Month Field
+ * - Date Field
+ * - Hour Field(12hr/24hr format)
+ * - Minute Field
+ * - AM/PM (if exists).
+ *
+ * This is how the example program's window looks like with the datetime widget
+ * showing only date, only time and both date & time:
+ *
+ * @image html screenshots/datetime_example.png
+ * @image latex screenshots/datetime_example.eps width=\textwidth
+ *
+ * See the full @ref datetime_example_c "source code" for
+ * this example.
+ *
+ * @example datetime_example.c
+ */
+
+/**
+ * @page dayselector_example Dayselector widget example
+ *
+ * This code places two Elementary dayselector widgets on a window, each of
+ * them exemplifying the different widget styles.
+ *
+ * The first of them is the dayselector in default style:
+ * @dontinclude dayselector_example.c
+ * @skip weekdays starting from Sunday
+ * @until evas_object_show
+ *
+ * As you see, the default style displays the weekdays starting from Sunday.
+ *
+ * One can select/unselect a day just by clicking on the day object.
+ * The selection toggles once it is being pressed.
+ *
+ *
+ * For showing weekdays starting from Monday, see the second dayselector:
+ * @dontinclude dayselector_example.c
+ * @skip weekdays starting from Monday
+ * @until evas_object_show
+ *
+ *
+ * The following code exemplifies the selection APIs of Dayselector:
+ * @dontinclude dayselector_example.c
+ * @skip Callback function
+ * @until End of clicked callback
+ *
+ *
+ * See the full @ref dayselector_example.c "example", whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/dayselector_example.png
+ * @image latex screenshots/dayselector_example.eps width=\textwidth
+ *
+ * See the full @ref dayselector_example_c "source code" for this example.
+ *
+ * @example dayselector_example.c
+ */
+
+/**
+ * @page mapbuf_example Mapbuf Widget Example
+ *
+ * This code places a Elementary mapbuf widget on a window,
+ * to exemplify part of the widget's API.
+ *
+ * First we'll add an window with a background and a vertical box to
+ * pack our interface elements:
+ * @dontinclude mapbuf_example.c
+ * @skipline win_add
+ * @until show(bx)
+ *
+ * Next we'll simply add the mapbuf widget to the box:
+ * @skipline mapbuf_add
+ * @until pack_end
+ *
+ * But mapbuf is a container widget, it won't do anything alone. So let's
+ * create a table full of icons. For that we'll loop to fill each line of each
+ * column. See @ref tutorial_table_01 "tutorial_table_01"
+ * if you don't know how to use tables:
+ * @skipline table_add
+ * @until }
+ * @until }
+ *
+ * Finally, setting mapbuf content:
+ * @skipline content_set
+ * @skipline show
+ *
+ * Also, would be good a horizontal box with some controls to change mapbuf
+ * behavior:
+ * @skipline box_add
+ * @until show
+ *
+ * By default map is disabled. So just setting content isn't enough.
+ * Alpha and smooth settings will be applied when map is enabled.
+ * So we'll add a check for that. Everytime the map properties
+ * are changed, map will need to be enabled again. So if you
+ * want to play a bit with our example, remember to always enable
+ * map again after concluding your changes.
+ * @skipline check_add
+ * @until show
+ *
+ * We have added a callback function to this check, so it will enable
+ * or disable map:
+ * @dontinclude mapbuf_example.c
+ * @skip static
+ * @skip }
+ * @skipline static
+ * @until }
+ *
+ * Let's add check boxes for alpha blending and smooth rendering:
+ * @skipline check_add
+ * @until show
+ * @until show
+ *
+ * By default, mapbuf would enable alpha blending and smooth rendering,
+ * so we need to check boxes to be consistent with its behavior.
+ *
+ * Callback functions look like the one added to the check. This way we
+ * could enable or disable the both properties:
+ * @dontinclude mapbuf_example.c
+ * @skip static
+ * @skip }
+ * @skip static
+ * @skip }
+ * @skipline static
+ * @until }
+ * @until }
+ *
+ * You'll see that disabling alpha blending will set a black rectangle below
+ * the icons. That's the reason you only should enable that when you're sure
+ * the mapbuf content is 100% solid.
+ *
+ * See @ref mapbuf_example.c "mapbuf_example.c", whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/mapbuf_example.png
+ * @image latex screenshots/mapbuf_example.eps width=\textwidth
+ *
+ * @example mapbuf_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 - Overlay Usage
+ *
+ * This code places a Elementary map widget on a window,
+ * to exemplify part of the widget's API, related to overlays.
+ *
+ * We'll start this example in 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
+ *
+ * Overlays can be placed over the map to represent anything we want. Let's
+ * say we want to represent some countries and cities with overlays.
+ *
+ * Before we create city or country overlays, let's create class overlays.
+ *
+ * @skipline elm_map_overlay_class_add
+ * @until elm_map_overlay_icon_set
+ * These lines create a class overlay which represents cities.
+ * This class overlay will be used for grouping city overlays.
+ * Later city overlays in the same class are appended to this class overlay.
+ * if city overlays are near each other, they will be grouped.
+ *
+ * We can set the icon for the class so that the icon will be displayed
+ * when city overlays are grouped.
+ * We can set the zoom required to display the overlays that belongs
+ * to this class, so if the zoom is less than this value, nothing
+ * will be shown.
+ *
+ * Country class can be created in the same way.
+ * @skipline elm_map_overlay_class_add
+ * @until elm_map_overlay_icon_set
+ *
+ * Next we'll create some overlays representing cities and coutries.
+ * We set the data for the overlay so that can be used later when
+ * clicked callback is called.
+ * We'll append them into city class to be grouped.
+ * We'll append them in a list, to close up them later.
+ * To create a default overlay, we need to pass the coordinates.
+ * @skipline elm_map_overlay_add
+ * @until eina_list_append
+ *
+ * We subscribe a smart callback "overlay,clicked" to create bubble on
+ * the clicked overlay.
+ * @dontinclude map_example_02.c
+ * @skipline "overlay,clicked"
+ *
+ * Finally, on our @c main function, we ask the map to show all the overlays
+ * with the biggest zoom possible, passing the list of overlays added.
+ * @skipline elm_map_overlays_show
+ *
+ * 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 Overlay_Data;
+ *
+ * We'll create instances for each place:
+ * @skipline argentina
+ * @until sky_03
+ *
+ * To return an icon, all we need to do is to add a elm_icon and return it:
+ * @dontinclude map_example_02.c
+ * @skipline _icon_get(
+ * @until }
+ *
+ * For the content, let's return something more elaborate. We will return
+ * a box with an image representing the place, and the name of this place:
+ * @skipline _box_get(
+ * @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 in 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_name_geo_request() 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
* diskselector will display first item after last, and last previous to
* the first one. So, as you can see, @b Sa will appears on left side
* of selected @b Sunday. This property is set with
- * elm_diskselector_round_set().
+ * elm_diskselector_round_enabled_set().
*
* Also, we decide to display only 2 character for side labels, instead of 3.
- * For this we call elm_diskselector_side_label_length_set(). As result,
+ * For this we call elm_diskselector_side_text_max_length_set(). As result,
* we'll see @b Mo displayed instead of @b Mon, when @b Monday is on a
* side position.
*
* is enough to call elm_diskselector_display_item_num_set(), as you can
* see here:
* @skipline elm_diskselector_add
- * @until evas_object_show
+ * @until elm_diskselector_display_item_num_set
*
* @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_display_item_num_get
+ *
* 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.
*
* This code places a Elementary diskselector widgets on a window,
* along with some buttons trigerring actions on it (though its API).
- * It covers most of Elm_Diskselector_Item functions.
+ * It covers most of diskselector item functions.
*
* On our @c main function, we are adding a default diskselector with
* 3 items. We are only setting their labels (second parameter of function
*
* If you want to free this data, or handle that the way you need when the
* item is deleted, set a callback function for that, with
- * elm_diskselector_item_del_cb_set().
+ * elm_object_item_del_cb_set().
*
* As you can see we check if @c it is not @c NULL after appending it.
* If an error happens, we won't try to set a function for it.
*
* <b> Deleting an item: </b>
* @dontinclude diskselector_example_02.c
- * @skip _del_cb
- * @skipline _del_cb
+ * @skipline _del_cb(void
* @until }
*
- * To delete an item we simple need to call elm_diskselector_item_del() with
+ * To delete an item we simple need to call elm_object_item_del() with
* a pointer for such item.
*
* If you need, you can get selected item with
* since we'll explain it better on @ref list_example_03. But if the callback
* need to be called everytime user clicks an item, even if already selected,
* it's required to enable this behavior:
- * @skipline elm_list_always_select_mode_set
+ * @skipline elm_list_select_mode_set
*
* Finally, if a bounce effect is required, or you would like to see
* scrollbars, it is possible. But, for default theme, list
*
* This code places a Elementary list widgets on a window,
* along with some buttons trigerring actions on it (though its API).
- * It covers most of Elm_List_Item functions.
+ * It covers most of elm_list_item functions.
*
* On our @c main function, we are adding a default list with
* 3 items. We are only setting their labels (second parameter of function
*
* If you want to free this data, or handle that the way you need when the
* item is deleted, set a callback function for that, with
- * elm_list_item_del_cb_set().
+ * elm_object_item_del_cb_set().
*
* As you can see we check if @c it is not @c NULL after appending it.
* If an error happens, we won't try to set a function for it.
* @skipline _del_cb(
* @until }
*
- * To delete an item we simple need to call elm_list_item_del() with
+ * To delete an item we simple need to call elm_object_item_del() with
* a pointer for such item.
*
* If you need, you can get selected item with
*/
/**
- * @page flipselector_example Flip selector widget example
+ * @page toolbar_example_01 Toolbar Example - Simple Items
*
- * This code places an Elementary flip selector widget on a window,
- * along with two buttons trigerring actions on it (though its API).
+ * This code places a Elementary toolbar widget on a window,
+ * to exemplify part of the widget's API.
*
- * The selector is being populated with the following items:
- * @dontinclude flipselector_example.c
- * @skip lbl[]
- * @until ;
+ * Let's start adding a button to our window, that will have its text
+ * modified depending on which item is selected. It's used just to exemplify
+ * how to change a window content from the toolbar.
+ * @dontinclude toolbar_example_01.c
+ * @skipline elm_button_add
+ * @until evas_object_show
*
- * Next, we create it, populating it with those items and registering
- * two (smart) callbacks on it:
- * @dontinclude flipselector_example.c
- * @skip fp = elm_flipselector_add
- * @until object_show
+ * Also, we'll need a toolbar widget, obviously:
+ * @skipline elm_toolbar_add
+ * @until evas_object_show
*
- * Those two callbacks will take place whenever one of those smart
- * events occur, and they will just print something to @c stdout:
- * @dontinclude flipselector_example.c
- * @skip underflow callback
- * @until static void
- * Flip the sheets on the widget while looking at the items list, in
- * the source code, and you'll get the idea of those events.
+ * When appending an item is possible to set an icon, label, and a callback
+ * function that will receive passed data.
+ * @skipline _item_append
+ * @until Folder
*
- * The two buttons below the flip selector will take the actions
- * described in their labels:
- * @dontinclude flipselector_example.c
- * @skip bt = elm_button_add
- * @until callback_add(win
+ * It's possible to disable items, so the user can't select then. We will
+ * disable the third item:
+ * @skipline _item_append
+ * @until disable
*
- * @dontinclude flipselector_example.c
- * @skip unselect the item
- * @until underflow
+ * Our callbacks will just set button's label:
+ * @dontinclude toolbar_example_01.c
+ * @skip static
+ * @skip }
+ * @skipline static
+ * @until }
+ * @until }
+ * @until }
*
- * Click on them to exercise those flip selector API calls. To
- * interact with the other parts of this API, there's a command line
- * interface, whose help string can be asked for with the 'h' key:
- * @dontinclude flipselector_example.c
- * @skip commands
- * @until ;
+ * By default, toolbars would display items homogeneously, so item with
+ * long labels, like the third, will make all of them occupy a lot of space.
+ * To avoid that, we can disable it:
+ * @dontinclude toolbar_example_01.c
+ * @skipline homogeneous
*
- * The 'n' and 'p' keys will exemplify elm_flipselector_flip_next()
- * and elm_flipselector_flip_prev(), respectively. 'f' and 'l' account
+ * Another default behavior, is to add an menu item if we have more items
+ * that would fit on toolbar size. To simply enable scroll, without menus,
+ * it's required to change toolbar's shrink mode:
+ * @dontinclude toolbar_example_01.c
+ * @skipline shrink
+ *
+ * See @ref toolbar_example_01.c "toolbar_example_01.c", whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/toolbar_example_01.png
+ * @image latex screenshots/toolbar_example_01.eps width=\textwidth
+ *
+ * @example toolbar_example_01.c
+ */
+
+/**
+ * @page toolbar_example_02 Toolbar Example - Items with States
+ *
+ * This code places a Elementary toolbar widget on a window,
+ * to exemplify part of the widget's API.
+ *
+ * Toolbar widgets has support to items with states. Each state
+ * can have it's own label, icon, and callback function.
+ *
+ * Let's start populating a toolbar with some regular items.
+ * If you don't know how to do that, see
+ * @ref toolbar_example_01 "Toolbar Example 1".
+ * @dontinclude toolbar_example_02.c
+ * @skipline elm_toolbar_add
+ * @until Update
+ *
+ * The only difference here is that we set shrink mode to #ELM_TOOLBAR_SHRINK_HIDE,
+ * that won't display items that doesn't fit to the window.
+ *
+ * Now, let's add an item with states. First, add the item just as any other.
+ * @skipline elm_toolbar_item_append
+ * @until _item_pressed
+ *
+ * After that states can be added to this item:
+ * @skipline state_add
+ * @until Full
+ * @until _item_pressed
+ *
+ * The both states and the item are using the same callback function,
+ * that will cycle between states and unselect the item. Unseleting
+ * is required because it won't call the callback if an user clicks
+ * over an item already selected:
+ * @dontinclude toolbar_example_02.c
+ * @skip static
+ * @skip }
+ * @skipline static
+ * @until }
+ *
+ * On our example, some items are hidden
+ * because we set the window to be small. But if an item should be displayed
+ * anyway, is needed to set its priority to be higher than others.
+ * Any positive value will be enough in our case. Let's force the item
+ * with multiple states to be displayed.
+ * @skipline priority
+ *
+ * See @ref toolbar_example_02.c "toolbar_example_02.c", whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/toolbar_example_02.png
+ * @image latex screenshots/toolbar_example_02.eps width=\textwidth
+ *
+ * @example toolbar_example_02.c
+ */
+
+/**
+ * @page toolbar_example_03 Toolbar Example - Items with Menus
+ *
+ * Toolbar widgets have support to items with menus. This kind
+ * of item will display a menu when selected by the user.
+ *
+ * Let's start populating a toolbar with some regular items, the same
+ * way we started @ref toolbar_example_02 "Toolbar Example 2".
+ * @dontinclude toolbar_example_03.c
+ * @skipline elm_toolbar_add
+ * @until Update
+ *
+ * The only difference is that we'll keep the default shrink mode, that
+ * adds an item with a menu of hidden items.
+ *
+ * So, a important thing to do is to set a parent for toolbar menus, or they
+ * will use the toolbar as parent, and its size will be restricted to that.
+ * @skipline parent_set
+ *
+ * Not only items' menus will respect this parent, but also the own toolbar
+ * menu, used to show hidden items.
+ *
+ * Next, let's add an item set to display a menu:
+ * @skipline elm_toolbar_item_append
+ * @until _menu_set
+ *
+ * Now, to add two options to this item, we can get the menu object and use
+ * it as a regular elm_menu. See @ref tutorial_menu "Menu example" for more
+ * about menu widget.
+ * @skipline _menu_get
+ * @until Full
+ *
+ * See @ref toolbar_example_03.c "toolbar_example_03.c", whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/toolbar_example_03.png
+ * @image latex screenshots/toolbar_example_03.eps width=\textwidth
+ *
+ * @example toolbar_example_03.c
+ */
+
+/**
+ * @page segment_control_example Segment Control Example
+ *
+ * This code places a Elementary segment control widgets on a window,
+ * to exemplify part of the widget's API.
+ *
+ * Let's start adding a segment control to our window:
+ * @dontinclude segment_control_example.c
+ * @skipline elm_segment_control_add
+ * @until evas_object_show
+ *
+ * Now will add an item only with label:
+ * @skipline item_add
+ *
+ * Really simple. To add an item with only an icon, the icon needs to be created
+ * first, them added with this same function:
+ * @skipline icon_add
+ * @until item_add
+ *
+ * If an item with label and icon is required, it can be done as well. In this
+ * case, instead of a label (or icon) centered, the item will display an icon
+ * at left and the label at right:
+ * @skipline icon_add
+ * @until item_add
+ *
+ * But, if you need to add some items that can have or not a label, but
+ * want that all of them looks the same way, with icon at left, just add
+ * an empty string label. It's done on our example to ilustrate that:
+ * @skipline icon_add
+ * @until item_add
+ *
+ * So far, all the item were added to the last position of the widget,
+ * but if something different is required, it can be done using another
+ * insertion function. Let's suppose we want to put an item just before
+ * the last item:
+ * @skipline count
+ * @until insert_at
+ *
+ * There are two ways to delete items. Using the item handle, like:
+ * @skipline insert_at
+ * @until del
+ *
+ * Or using item's index:
+ * @skipline insert_at
+ * @until del_at
+ *
+ * To set properties of an item already added to the widget, you just need
+ * to get the item and set icon or label, as the following code shows:
+ * @skipline item_get
+ * @until label_set
+ *
+ * Finally, it's possible to select an item from the code, and also get
+ * the selected item. We will select the item at the center of the widget
+ * and print its position.
+ * @skipline count_get
+ * @until printf
+ *
+ * See the full @ref segment_control_example.c "example", whose window should
+ * look like this picture:
+ *
+ * @image html screenshots/segment_control_example.png
+ * @image latex screenshots/segment_control_example.eps width=\textwidth
+ *
+ * @example segment_control_example.c
+ */
+
+/**
+ * @page flipselector_example Flip selector widget example
+ *
+ * This code places an Elementary flip selector widget on a window,
+ * along with two buttons trigerring actions on it (though its API).
+ *
+ * The selector is being populated with the following items:
+ * @dontinclude flipselector_example.c
+ * @skip lbl[]
+ * @until ;
+ *
+ * Next, we create it, populating it with those items and registering
+ * two (smart) callbacks on it:
+ * @dontinclude flipselector_example.c
+ * @skip fp = elm_flipselector_add
+ * @until object_show
+ *
+ * Those two callbacks will take place whenever one of those smart
+ * events occur, and they will just print something to @c stdout:
+ * @dontinclude flipselector_example.c
+ * @skip underflow callback
+ * @until }
+ * @until }
+ * Flip the sheets on the widget while looking at the items list, in
+ * the source code, and you'll get the idea of those events.
+ *
+ * The two buttons below the flip selector will take the actions
+ * described in their labels:
+ * @dontinclude flipselector_example.c
+ * @skip bt = elm_button_add
+ * @until callback_add(win
+ *
+ * @dontinclude flipselector_example.c
+ * @skip unselect the item
+ * @until }
+ * @until }
+ *
+ * Click on them to exercise those flip selector API calls. To
+ * interact with the other parts of this API, there's a command line
+ * interface, whose help string can be asked for with the 'h' key:
+ * @dontinclude flipselector_example.c
+ * @skip commands
+ * @until ;
+ *
+ * The 'n' and 'p' keys will exemplify elm_flipselector_flip_next()
+ * and elm_flipselector_flip_prev(), respectively. 'f' and 'l' account
* for elm_flipselector_first_item_get() and
* elm_flipselector_last_item_get(), respectively. Finally, 's' will
* issue elm_flipselector_selected_item_get() on our example flip
* @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 }
*/
/**
+ * @page glview_example_01_page - GLView Example
+ * @include glview_example_01.c
+ */
+
+/**
* @page tutorial_flip Flip example
* @dontinclude flip_example_01.c
*
* 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.
*
* elm_image_no_scale_set() is used just to set this value to true (we
* don't want to scale our image anyway, just resize it).
*
- * elm_image_scale_set() is used to allow the image to be resized to a size
+ * elm_image_resizable_set() is used to allow the image to be resized to a size
* smaller than the original one, but not to a size bigger than it.
*
* elm_elm_image_smooth_set() will disable the smooth scaling, so the scale
* elm_image_orient_set() is used to flip the image around the (1, 0) (0, 1)
* diagonal.
*
- * elm_image_aspect_ratio_retained_set() is used to keep the original aspect
+ * elm_image_aspect_fixed_set() is used to keep the original aspect
* ratio of the image, even when the window is resized to another aspect ratio.
*
* elm_image_fill_outside_set() is used to ensure that the image will fill the
* @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.
*
* elm_icon_no_scale_set() is used just to set this value to true (we
* don't want to scale our icon anyway, just resize it).
*
- * elm_icon_scale_set() is used to allow the icon to be resized to a size
+ * elm_icon_resizable_set() is used to allow the icon to be resized to a size
* smaller than the original one, but not to a size bigger than it.
*
* elm_elm_icon_smooth_set() will disable the smooth scaling, so the scale
* 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
+ * @until "icon", rect)
*
* Next we will add our three items, setting a callback to be called for the
* first and third:
* @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"
* 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
+ * elm_index_selected_item_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
+ * elm_index_autohide_disabled_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
+ * elm_index_autohide_disabled_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
+ * respective index item handle(#Elm_Object_Item) 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.
* 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:
+ * they'll be index item(#Elm_Object_Item)'s:
* @dontinclude index_example_02.c
* @skip ordering alphabetically
* @until }
* @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_02.c "source code" for
* this example.
*
* @example index_example_02.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
*
* 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
*/
* The example will look like this:
*
* @image html screenshots/radio_example_01.png
- * @image latex screenshots/radio_example_01.epx width=\textwidth
+ * @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
*
* This example will look like this;
*
* @image html screenshots/panel_example_01.png
- * @image latex screenshots/panel_example_01.epx width=\textwidth
+ * @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
* 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,
+ * elm_object_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:
* 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:
+ * elm_gengrid_select_mode_set() behavior:
* @dontinclude gengrid_example.c
* @skip "always select" callback
* @until }
* @example gengrid_example.c
*/
/**
- * @page entry_example_01 Entry - Example of simple editing
+ * @page entry_example 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
* 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;
+ * @skip _format_change_cb(void *data, Evas_Object *obj, void *event __UNUSED__)
* @until sizeof(fmt_close)
*
* Next we need to find out if we need to insert an opening or a closing tag.
*/
/**
- * @page genlist_example_01
+ * @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
* The current example will look like this when running:
*
* @image html screenshots/genlist_example_01.png
- * @image latex screenshots/genlistexample_01.eps width=\textwidth
+ * @image latex screenshots/genlist_example_01.eps width=\textwidth
*/
/**
- * @page genlist_example_02
+ * @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
* 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.
+ * selected item changes, thus we call elm_genlist_select_mode_set() with
+ * ELM_OBJECT_SELECT_MODE_ALWAYS.
*
* 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().
+ * width (thus we call elm_genlist_mode_set(obj, ELM_LIST_COMPRESS).
*
* 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
+ * elm_genlist_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
+ * The option elm_genlist_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.
* The current example will look like this when running:
*
* @image html screenshots/genlist_example_02.png
- * @image latex screenshots/genlistexample_02.eps width=\textwidth
+ * @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_TREE. 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 popup_example_01_c popup_example_01.c
+ * @include popup_example_01.c
+ *
+ * This example will initially look like this:
+ *
+ * @image html screenshots/popup_example_01.png
+ * @image latex screenshots/popup_example_01.eps width=\textwidth
+ *
+ * Once the popup is hidden after timeout:
+ *
+ * @image html screenshots/popup_example_01_a.png
+ * @image latex screenshots/popup_example_01_a.eps width=\textwidth
+ *
+ * @example popup_example_01.c
+ */
+
+ /** @page popup_example_02_c popup_example_02.c
+ * @include popup_example_02.c
+ *
+ * This example will look like this:
+ *
+ * @image html screenshots/popup_example_02.png
+ * @image latex screenshots/popup_example_02.eps width=\textwidth
+ *
+ * @example popup_example_02.c
+ */
+
+/**
+ * @page popup_example_03_c popup_example_03.c
+ * @include popup_example_03.c
+ *
+ * This example will look like this:
+ *
+ * @image html screenshots/popup_example_03.png
+ * @image latex screenshots/popup_example_03.eps width=\textwidth
+ *
+ * @example popup_example_03.c
+ */
+
+/**
* @page tutorial_frame Frame example
* @dontinclude 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
*
* @until show(rect)
*
* Now that we have a window with background and a rectangle we can create
- * our color_selector and set it's initial color to fully opaque blue:
- * @until show
+ * 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 tell ask to be notified whenever the color changes:
+ * Next we ask to be notified whenever the color changes on selector:
* @until changed
*
- * We follow that we some more run of the mill setup code:
+ * 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()
*
- * And now get to the callback that sets the color of the rectangle:
+ * 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:
* 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:
+ * @skip static
* @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:
+ * @skip static
* @until }
*
* Our slider controls the level of zoom of the photocam:
+ * @skip static
* @until }
* @note It is important to note that this only works when in manual zoom mode.
*
*/
/**
+ * @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 td->tab = NULL
+ * @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
* @example clock_example.c
*/
+ /**
+ * @page datetime_example_c Datetime example
+ * @include datetime_example.c
+ * @example datetime_example.c
+ */
+
+/**
+ * @page dayselector_example_c Dayselector example
+ * @include dayselector_example.c
+ * @example dayselector_example.c
+ */
+
/**
* @page flipselector_example_c Flipselector example
* @include flipselector_example.c
*
* @include layout_example.edc
* @example layout_example.edc
+ */
/**
* @page gengrid_example_c Gengrid example
*/
/**
+ * @page genlist_example_04_c genlist_example_04.c
+ * @include genlist_example_04.c
+ * @example genlist_example_04.c
+ */
+
+/**
+ * @page genlist_example_05_c genlist_example_05.c
+ * @include genlist_example_05.c
+ * @example genlist_example_05.c
+ */
+
+/**
+ * @page thumb_example_01_c thumb_example_01.c
+ * @include thumb_example_01.c
+ * @example thumb_example_01.c
+ */
+
+/**
* @page progressbar_example_c Progress bar example
* @include progressbar_example.c
* @example progressbar_example.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