2011-06-21 11:14:26 -07:00
|
|
|
/**
|
|
|
|
* @page Examples Examples
|
|
|
|
*
|
|
|
|
* Here is a page with Elementary examples.
|
|
|
|
*
|
|
|
|
* @ref bg_01_example_page
|
|
|
|
*
|
|
|
|
* @ref bg_02_example_page
|
|
|
|
*
|
|
|
|
* @ref bg_03_example_page
|
|
|
|
*
|
|
|
|
* @ref actionslider_example_page
|
|
|
|
*
|
|
|
|
* @ref transit_example_01_explained
|
|
|
|
*
|
|
|
|
* @ref transit_example_02_explained
|
2011-06-22 07:52:05 -07:00
|
|
|
*
|
|
|
|
* @ref general_functions_example_page
|
2011-07-11 06:51:32 -07:00
|
|
|
*
|
2011-07-14 08:45:44 -07:00
|
|
|
* @ref calendar_example_01
|
|
|
|
*
|
|
|
|
* @ref calendar_example_02
|
|
|
|
*
|
|
|
|
* @ref calendar_example_03
|
|
|
|
*
|
|
|
|
* @ref calendar_example_04
|
|
|
|
*
|
|
|
|
* @ref calendar_example_05
|
|
|
|
*
|
|
|
|
* @ref calendar_example_06
|
|
|
|
*
|
2011-07-26 10:27:05 -07:00
|
|
|
* @ref spinner_example
|
|
|
|
*
|
2011-07-27 06:32:51 -07:00
|
|
|
* @ref slider_example
|
|
|
|
*
|
2011-07-27 10:06:40 -07:00
|
|
|
* @ref panes_example
|
|
|
|
*
|
2011-07-11 06:51:32 -07:00
|
|
|
* @ref clock_example
|
2011-07-25 12:51:57 -07:00
|
|
|
*
|
2012-03-05 03:07:05 -08:00
|
|
|
* @ref datetime_example
|
|
|
|
*
|
2012-03-06 20:57:03 -08:00
|
|
|
* @ref dayselector_example
|
|
|
|
*
|
2011-08-01 14:32:25 -07:00
|
|
|
* @ref mapbuf_example
|
2011-08-04 15:35:12 -07:00
|
|
|
|
|
|
|
* @ref map_example_01
|
|
|
|
*
|
|
|
|
* @ref map_example_02
|
|
|
|
*
|
|
|
|
* @ref map_example_03
|
2011-08-01 14:32:25 -07:00
|
|
|
*
|
2011-07-15 14:29:34 -07:00
|
|
|
* @ref diskselector_example_01
|
|
|
|
*
|
|
|
|
* @ref diskselector_example_02
|
2011-07-11 14:06:04 -07:00
|
|
|
*
|
2012-03-21 10:57:34 -07:00
|
|
|
* @ref entry_example
|
|
|
|
*
|
2011-07-25 13:47:59 -07:00
|
|
|
* @ref list_example_01
|
|
|
|
*
|
|
|
|
* @ref list_example_02
|
|
|
|
*
|
|
|
|
* @ref list_example_03
|
2011-08-01 07:51:18 -07:00
|
|
|
*
|
|
|
|
* @ref toolbar_example_01
|
|
|
|
*
|
|
|
|
* @ref toolbar_example_02
|
|
|
|
*
|
|
|
|
* @ref toolbar_example_03
|
|
|
|
*
|
2011-07-28 14:51:02 -07:00
|
|
|
* @ref segment_control_example
|
2011-07-25 13:47:59 -07:00
|
|
|
*
|
2011-07-11 14:06:04 -07:00
|
|
|
* @ref flipselector_example
|
2011-07-15 07:02:54 -07:00
|
|
|
*
|
|
|
|
* @ref fileselector_example
|
2011-07-15 07:03:21 -07:00
|
|
|
*
|
|
|
|
* @ref fileselector_button_example
|
|
|
|
*
|
|
|
|
* @ref fileselector_entry_example
|
2011-07-20 09:28:12 -07:00
|
|
|
*
|
|
|
|
* @ref index_example_01
|
|
|
|
*
|
|
|
|
* @ref index_example_02
|
2011-07-25 12:51:57 -07:00
|
|
|
*
|
|
|
|
* @ref gengrid_example
|
2011-07-26 11:32:14 -07:00
|
|
|
*
|
|
|
|
* @ref genlist_example_01
|
|
|
|
*
|
|
|
|
* @ref genlist_example_02
|
2011-07-26 13:11:39 -07:00
|
|
|
*
|
2011-07-29 07:59:45 -07:00
|
|
|
* @ref genlist_example_03
|
|
|
|
*
|
2011-07-28 14:27:32 -07:00
|
|
|
* @ref genlist_example_04
|
|
|
|
*
|
|
|
|
* @ref genlist_example_05
|
|
|
|
*
|
2012-03-21 10:57:34 -07:00
|
|
|
* @ref glview_example_01_page
|
|
|
|
*
|
2011-08-01 10:37:10 -07:00
|
|
|
* @ref thumb_example_01
|
|
|
|
*
|
2011-07-26 13:11:39 -07:00
|
|
|
* @ref progressbar_example
|
2011-07-27 12:38:43 -07:00
|
|
|
*
|
|
|
|
* @ref slideshow_example
|
2011-09-28 04:53:41 -07:00
|
|
|
*
|
|
|
|
* @ref efl_thread_1
|
|
|
|
*
|
|
|
|
* @ref efl_thread_2
|
|
|
|
*
|
|
|
|
* @ref efl_thread_3
|
|
|
|
*
|
|
|
|
* @ref efl_thread_4
|
|
|
|
*
|
|
|
|
* @ref efl_thread_5
|
|
|
|
*
|
|
|
|
* @ref efl_thread_6
|
2011-06-21 11:14:26 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page bg_01_example_page elm_bg - Plain color background.
|
|
|
|
* @dontinclude bg_example_01.c
|
|
|
|
*
|
|
|
|
* The full code for this example can be found at @ref bg_example_01_c,
|
|
|
|
* in the function @c test_bg_plain. It's part of the @c elementar_test
|
|
|
|
* suite, and thus has the code for the three examples referenced by this
|
|
|
|
* documentation.
|
|
|
|
*
|
|
|
|
* This first example just sets a default background with a plain color. The
|
|
|
|
* first part consists of creating an Elementary window. It's the common
|
|
|
|
* piece of code that you'll see everywhere in Elementary: @skip elm_main
|
|
|
|
* @until autodel_set
|
|
|
|
*
|
|
|
|
* Now we really create our background object, using the window object as
|
|
|
|
* its parent:
|
|
|
|
*
|
|
|
|
* @skipline bg_add
|
|
|
|
*
|
|
|
|
* Then we set the size hints of the background object so that it will use
|
|
|
|
* all space available for it, and then add it as a resize object to the
|
|
|
|
* window, making it visible in the end:
|
|
|
|
*
|
|
|
|
* @skip size_hint_weight_set
|
|
|
|
* @until resize_object_add
|
|
|
|
*
|
|
|
|
* See @ref 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
|
|
|
|
* maximum size of the background, so the Elementary window knows that it
|
|
|
|
* has to have at least the minimum size. The background also won't scale to
|
|
|
|
* a size above its maximum. Then we resize the window and show it in the
|
|
|
|
* end:
|
|
|
|
*
|
|
|
|
* @skip set size hints
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And here we finish our very simple background object usage example.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page bg_02_example_page elm_bg - Image background.
|
|
|
|
* @dontinclude bg_example_02.c
|
|
|
|
*
|
|
|
|
* The full code for this example can be found at @ref bg_example_02_c,
|
|
|
|
* in the function @c test_bg_image. It's part of the @c elementar_test
|
|
|
|
* suite, and thus has the code for the three examples referenced by this
|
|
|
|
* documentation.
|
|
|
|
*
|
|
|
|
* This is the second example, and shows how to use the Elementary
|
|
|
|
* background object to set an image as background of your application.
|
|
|
|
*
|
|
|
|
* We start this example exactly in the same way as the previous one, even
|
|
|
|
* when creating the background object:
|
|
|
|
*
|
|
|
|
* @skip elm_main
|
|
|
|
* @until bg_add
|
|
|
|
*
|
|
|
|
* Now it's the different part.
|
|
|
|
*
|
|
|
|
* Our background will have an image, that will be displayed over the
|
|
|
|
* background color. Before loading the image, we set the load size of the
|
|
|
|
* image. The load size is a hint about the size that we want the image
|
|
|
|
* displayed in the screen. It's not the exact size that the image will have,
|
|
|
|
* but usually a bit bigger. The background object can still be scaled to a
|
|
|
|
* size bigger than the one set here. Setting the image load size to
|
|
|
|
* something smaller than its real size will reduce the memory used to keep
|
|
|
|
* the pixmap representation of the image, and the time to load it. Here we
|
|
|
|
* set the load size to 20x20 pixels, but the image is loaded with a size
|
|
|
|
* bigger than that (since it's just a hint):
|
|
|
|
*
|
|
|
|
* @skipline load_size_set
|
|
|
|
*
|
|
|
|
* And set our background image to be centered, instead of stretched or
|
|
|
|
* scaled, so the effect of the elm_bg_load_size_set() can be easily
|
|
|
|
* understood:
|
|
|
|
*
|
|
|
|
* @skipline option_set
|
|
|
|
*
|
|
|
|
* We need a filename to set, so we get one from the previous installed
|
|
|
|
* images in the @c PACKAGE_DATA_DIR, and write its full path to a buffer.
|
|
|
|
* Then we use this buffer to set the filename in the background object:
|
|
|
|
*
|
|
|
|
* @skip snprintf
|
|
|
|
* @until bg_file_set
|
|
|
|
*
|
|
|
|
* Notice that the third argument of the elm_bg_file_set() function is @c
|
|
|
|
* NULL, since we are setting an image to this background. This function
|
|
|
|
* also supports setting an edje group as background, in which case the @c
|
|
|
|
* group parameter wouldn't be @c NULL, but be the name of the group
|
|
|
|
* instead.
|
|
|
|
*
|
|
|
|
* Finally, we can set the size hints, add the background as a resize
|
|
|
|
* object, and resize the window, exactly the same thing we do in the @ref
|
|
|
|
* bg_01_example_page example:
|
|
|
|
*
|
|
|
|
* @skip size_hint
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And this is the end of this example.
|
|
|
|
*
|
|
|
|
* This example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-06-21 11:14:26 -07:00
|
|
|
* @image html screenshots/bg_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/bg_01.eps width=\textwidth
|
2011-06-21 11:14:26 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page bg_03_example_page elm_bg - Background properties.
|
|
|
|
* @dontinclude bg_example_03.c
|
|
|
|
*
|
|
|
|
* The full code for this example can be found at @ref bg_example_03_c, in the
|
|
|
|
* function @c test_bg_options, with the callbacks @c _cb_overlay_changed, @c
|
|
|
|
* _cb_color_changed and @c _cb_radio_changed defined in the beginning of the
|
|
|
|
* file. It's part of the @c elementar_test suite, and thus has the code for
|
|
|
|
* the three examples referenced by this documentation.
|
|
|
|
*
|
|
|
|
* This example will show the properties available for the background object,
|
|
|
|
* and will use of some more widgets to set them.
|
|
|
|
*
|
|
|
|
* In order to do this, we will set some callbacks for these widgets. The
|
|
|
|
* first is for the radio buttons that will be used to choose the option
|
|
|
|
* passed as argument to elm_bg_option_set():
|
|
|
|
*
|
|
|
|
* @skip _cb_radio_changed
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The next callback will be used when setting the overlay (using
|
2011-10-28 01:31:42 -07:00
|
|
|
* elm_object_content_set()):
|
2011-06-21 11:14:26 -07:00
|
|
|
*
|
|
|
|
* @skip _cb_overlay_changed
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And the last one, used to set the color (with elm_bg_color_set()):
|
|
|
|
*
|
|
|
|
* @skip _cb_color_changed
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* We will get back to what these functions do soon. If you want to know more
|
|
|
|
* about how to set these callbacks and what these widgets are, look for:
|
|
|
|
* @li elm_radio_add()
|
|
|
|
* @li elm_check_add()
|
|
|
|
* @li elm_spinner_add()
|
|
|
|
*
|
|
|
|
* Now going to the main function, @c test_bg_options, we have the common
|
|
|
|
* code with the other examples:
|
|
|
|
*
|
|
|
|
* @skip bg-options
|
|
|
|
* @until autodel_set
|
|
|
|
*
|
|
|
|
* We add a plain background to this window, so it will have the default
|
|
|
|
* background color behind everything:
|
|
|
|
*
|
|
|
|
* @skip bg = elm_bg_add
|
|
|
|
* @until evas_object_show(bg)
|
|
|
|
*
|
|
|
|
* Then we add a vertical box (elm_box_add()) that will hold the background
|
|
|
|
* object that we are going to play with, as well as a horizontal box that
|
|
|
|
* will hold widgets:
|
|
|
|
*
|
|
|
|
* @skip elm_box_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Now we add the background object that is going to be of use for our
|
|
|
|
* example. It is an image background, as used in @ref bg_02_example_page ,
|
|
|
|
* so the code should be familiar:
|
|
|
|
*
|
|
|
|
* @skip elm_bg_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Notice the call to elm_box_pack_end(): it will pack the background object
|
|
|
|
* in the end of the Elementary box declared above. Just refer to that
|
|
|
|
* documentation for more info.
|
|
|
|
*
|
|
|
|
* Since this Elementary background is already an image background, we are
|
|
|
|
* going to play with its other properties. We will change its option
|
|
|
|
* (CENTER, SCALE, STRETCH, TILE), its color (RGB), and add an overlay to it.
|
|
|
|
* For all of these properties, we are going to add widgets that will
|
|
|
|
* configure them.
|
|
|
|
*
|
|
|
|
* First, lets add the horizontal box that will hold these widgets:
|
|
|
|
* @skip hbox
|
|
|
|
* @until align_set
|
|
|
|
*
|
|
|
|
* For now, just consider this @c hbox as a rectangle that will contain the
|
|
|
|
* widgets, and will distribute them horizontally inside its content. Then we
|
|
|
|
* add radio buttons that will allow us to choose the property to use with
|
|
|
|
* this background:
|
|
|
|
*
|
|
|
|
* @skip radio_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Again, I won't give details about the use of these widgets, just look for
|
|
|
|
* their documentation if necessary. It's enough to know for now that we are
|
|
|
|
* packing them in the @c hbox, setting a label for them, and the most
|
|
|
|
* important parts: setting its value to @c ELM_BG_OPTION_CENTER and its
|
|
|
|
* callback to @c _cb_radio_changed (the function defined in the beginning of
|
|
|
|
* this example). We do this for the next 3 radio buttons added after this
|
|
|
|
* one, each of them with a different value.
|
|
|
|
*
|
|
|
|
* Now taking a look at the code of the callback @c _cb_radio_changed again,
|
|
|
|
* it will call elm_bg_option_set() with the value set from the checked radio
|
|
|
|
* button, thus setting the option for this background. The background is
|
|
|
|
* passed as argument to the @p data parameter of this callback, and is
|
|
|
|
* referenced here as @c o_bg.
|
|
|
|
*
|
|
|
|
* Later we set the default value for this radio button:
|
|
|
|
*
|
|
|
|
* @skipline elm_radio_value_set
|
|
|
|
*
|
2011-10-28 01:31:42 -07:00
|
|
|
* Then we add a checkbox for the elm_object_content_set() function for the bg:
|
2011-06-21 11:14:26 -07:00
|
|
|
*
|
|
|
|
* @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
|
2011-10-28 01:31:42 -07:00
|
|
|
* creating an Edje object, and setting it with elm_object_content_set() to the
|
2011-06-21 11:14:26 -07:00
|
|
|
* background object. For information about what are and how to set Edje
|
|
|
|
* object, look at the Edje documentation.
|
|
|
|
*
|
|
|
|
* Finally we add a spinner object (elm_spinner_add()) to be used to select
|
|
|
|
* the color of our background. In its callback it's possible to see the call
|
|
|
|
* to elm_bg_color_set(), which will change the color of this background.
|
|
|
|
* This color is used by the background to fill areas where the image doesn't
|
|
|
|
* cover (in this case, where we have an image background). The spinner is
|
|
|
|
* also packed into the @c hbox :
|
|
|
|
*
|
|
|
|
* @skip elm_spinner_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Then we just have to pack the @c hbox inside the @c box, set some size
|
|
|
|
* hints, and show our window:
|
|
|
|
*
|
|
|
|
* @skip pack_end
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Now to see this code in action, open elementary_test, and go to the "Bg
|
|
|
|
* Options" test. It should demonstrate what was implemented here.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page actionslider_example_page Actionslider usage
|
|
|
|
* @dontinclude actionslider_example_01.c
|
|
|
|
*
|
|
|
|
* For this example we are going to assume knowledge of evas smart callbacks
|
|
|
|
* and some basic evas object functions. Elementary is not meant to be used
|
|
|
|
* without evas, if you're not yet familiar with evas it probably is worth
|
|
|
|
* checking that out.
|
|
|
|
*
|
|
|
|
* And now to the example, when using Elementary we start by including
|
|
|
|
* Elementary.h:
|
|
|
|
* @skipline #include
|
|
|
|
*
|
|
|
|
* Next we define some callbacks, they all share the same signature because
|
|
|
|
* they are all to be used with evas_object_smart_callback_add().
|
|
|
|
* The first one just prints the selected label(in two different ways):
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* This next callback is a little more interesting, it makes the selected
|
|
|
|
* label magnetic(except if it's the center label):
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* This callback enables or disables the magnetic propertty of the center
|
|
|
|
* label:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And finally a callback to stop the main loop when the window is closed:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* To be able to create our actionsliders we need to do some setup, but this
|
|
|
|
* isn't really relevant here, so if you want to know about that go @ref
|
|
|
|
* Win "here".
|
|
|
|
*
|
|
|
|
* With all that boring stuff out of the way we can proceed to creating some
|
|
|
|
* actionsliders.@n
|
|
|
|
* All actionsliders are created the same way:
|
|
|
|
* @skipline actionslider_add
|
|
|
|
* Next we must choose where the indicator starts, and for this one we choose
|
|
|
|
* the right, and set the right as magnetic:
|
|
|
|
* @skipline indicator_pos_set
|
|
|
|
* @until magnet_pos_set
|
|
|
|
*
|
|
|
|
* We then set the labels for the left and right, passing NULL as an argument
|
|
|
|
* to any of the labels makes that position have no label.
|
|
|
|
* @until Stop
|
|
|
|
*
|
|
|
|
* Furthermore we mark both left and right as enabled positions, if we didn't
|
|
|
|
* do this all three positions would be enabled:
|
|
|
|
* @until RIGHT
|
|
|
|
*
|
|
|
|
* Having the the enabled positions we now add a smart callback to change
|
|
|
|
* which position is magnetic, so that only the last selected position is
|
|
|
|
* magnetic:
|
|
|
|
* @until NULL
|
|
|
|
*
|
|
|
|
* And finally we set our printing callback and show the actionslider:
|
|
|
|
* @until object_show
|
|
|
|
* @skip pack_end
|
|
|
|
*
|
|
|
|
* For our next actionslider we are going to do much as we did for the
|
|
|
|
* previous except we are going to have the center as the magnet(and not
|
|
|
|
* change it):
|
|
|
|
* @skipline actionslider_add
|
|
|
|
* @skipline indicator_pos_set
|
|
|
|
* @until object_show
|
|
|
|
*
|
|
|
|
* And another actionslider, in this one the indicator starts on the left.
|
|
|
|
* It has labels only in the center and right, and both bositions are
|
|
|
|
* magnetic. Because the left doesn't have a label and is not magnetic once
|
|
|
|
* the indicator leaves it can't return:
|
|
|
|
* @skipline actionslider_add
|
|
|
|
* @skipline indicator_pos_set
|
|
|
|
* @until object_show
|
|
|
|
* @note The greyed out area is a @ref Styles "style".
|
|
|
|
*
|
|
|
|
* And now an actionslider with a label in the indicator, and whose magnet
|
|
|
|
* properties change based on what was last selected:
|
|
|
|
* @skipline actionslider_add
|
|
|
|
* @skipline indicator_pos_set
|
|
|
|
* @until object_show
|
|
|
|
* @note The greyed out area is a @ref Styles "style".
|
|
|
|
*
|
|
|
|
* We are almost done, this next one is just an actionslider with all
|
|
|
|
* positions magnetized and having every possible label:
|
|
|
|
* @skipline actionslider_add
|
|
|
|
* @skipline indicator_pos_set
|
|
|
|
* @until object_show
|
|
|
|
*
|
|
|
|
* And for our last actionslider we have one that turns the magnetic property
|
|
|
|
* on and off:
|
|
|
|
* @skipline actionslider_add
|
|
|
|
* @skipline indicator_pos_set
|
|
|
|
* @until object_show
|
|
|
|
*
|
|
|
|
* The example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-06-21 11:14:26 -07:00
|
|
|
* @image html screenshots/actionslider_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/actionslider_01.eps width=\textwidth
|
2011-06-21 11:14:26 -07:00
|
|
|
*
|
|
|
|
* See the full source code @ref actionslider_example_01 "here"
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page transit_example_03_c elm_transit - Combined effects and options.
|
|
|
|
*
|
|
|
|
* This example shows how to apply the following transition effects:
|
|
|
|
* @li translation
|
|
|
|
* @li color
|
|
|
|
* @li rotation
|
|
|
|
* @li wipe
|
|
|
|
* @li zoom
|
|
|
|
* @li resizing
|
|
|
|
*
|
|
|
|
* It allows you to apply more than one effect at once, and also allows to
|
|
|
|
* set properties like event_enabled, auto_reverse, repeat_times and
|
|
|
|
* tween_mode.
|
|
|
|
*
|
|
|
|
* @include transit_example_03.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page transit_example_04_c elm_transit - Combined effects over two objects.
|
|
|
|
*
|
|
|
|
* This example shows how to apply the transition effects:
|
|
|
|
* @li flip
|
|
|
|
* @li resizable_flip
|
|
|
|
* @li fade
|
|
|
|
* @li blend
|
|
|
|
* over two objects. This kind of transition effect is used to make one
|
|
|
|
* object disappear and another one appear on its place.
|
|
|
|
*
|
|
|
|
* You can mix more than one effect of this type on the same objects, and the
|
|
|
|
* transition will apply both.
|
|
|
|
*
|
|
|
|
* @include transit_example_04.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page transit_example_01_explained elm_transit - Basic transit usage.
|
|
|
|
* @dontinclude transit_example_01.c
|
|
|
|
*
|
|
|
|
* The full code for this example can be found at @ref transit_example_01_c.
|
|
|
|
*
|
|
|
|
* This example shows the simplest way of creating a transition and applying
|
|
|
|
* it to an object. Similarly to every other elementary example, we create a
|
|
|
|
* window, set its title, size, autodel property, and setup a callback to
|
|
|
|
* exit the program when finished:
|
|
|
|
*
|
|
|
|
* @skip on_done
|
|
|
|
* @until evas_object_resize
|
|
|
|
*
|
2011-08-14 00:47:29 -07:00
|
|
|
* We also add a resizable white background to use behind our animation:
|
2011-06-21 11:14:26 -07:00
|
|
|
*
|
|
|
|
* @skip bg_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* And then we add a button that we will use to demonstrate the effects of
|
|
|
|
* our animation:
|
|
|
|
*
|
|
|
|
* @skip button_add
|
|
|
|
* @until evas_object_show(win)
|
|
|
|
*
|
|
|
|
* Notice that we are not adding the button with elm_win_resize_object_add()
|
|
|
|
* because we don't want the window to control the size of the button. We
|
|
|
|
* will use the transition to change the button size, so it could conflict
|
|
|
|
* with something else trying to control that size.
|
|
|
|
*
|
|
|
|
* Now, the simplest code possible to create the resize animation:
|
|
|
|
*
|
|
|
|
* @skip transit_add
|
|
|
|
* @until transit_go
|
|
|
|
*
|
|
|
|
* As you can see, this code is very easy to understand. First, we create the
|
|
|
|
* transition itself with elm_transit_add(). Then we add the button to this
|
|
|
|
* transition with elm_transit_object_add(), which means that the transition
|
|
|
|
* will operate over this button. The effect that we want now is changing the
|
|
|
|
* object size from 100x50 to 300x150, and can be achieved by adding the
|
|
|
|
* resize effect with elm_transit_effect_resizing_add().
|
|
|
|
*
|
|
|
|
* Finally, we set the transition time to 5 seconds and start the transition
|
|
|
|
* with elm_transit_go(). If we wanted more effects applied to this
|
|
|
|
* button, we could add them to the same transition. See the
|
|
|
|
* @ref transit_example_03_c to watch many transitions being applied to an
|
|
|
|
* object.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page transit_example_02_explained elm_transit - Chained transitions.
|
|
|
|
* @dontinclude transit_example_02.c
|
|
|
|
*
|
|
|
|
* The full code for this example can be found at @ref transit_example_02_c.
|
|
|
|
*
|
|
|
|
* This example shows how to implement a chain of transitions. This chain is
|
|
|
|
* used to start a transition just after another transition ended. Similarly
|
|
|
|
* to every other elementary example, we create a window, set its title,
|
|
|
|
* size, autodel property, and setup a callback to exit the program when
|
|
|
|
* finished:
|
|
|
|
*
|
|
|
|
* @skip on_done
|
|
|
|
* @until evas_object_resize
|
|
|
|
*
|
2011-08-14 00:47:29 -07:00
|
|
|
* We also add a resizable white background to use behind our animation:
|
2011-06-21 11:14:26 -07:00
|
|
|
*
|
|
|
|
* @skip bg_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* This example will have a chain of 4 transitions, each of them applied to
|
|
|
|
* one button. Thus we create 4 different buttons:
|
|
|
|
*
|
|
|
|
* @skip button_add
|
|
|
|
* @until evas_object_show(bt4)
|
|
|
|
*
|
|
|
|
* Now we create a simple translation transition that will be started as soon
|
|
|
|
* as the program loads. It will be our first transition, and the other
|
|
|
|
* transitions will be started just after this transition ends:
|
|
|
|
*
|
|
|
|
* @skip transit_add
|
|
|
|
* @until transit_go
|
|
|
|
*
|
|
|
|
* The code displayed until now has nothing different from what you have
|
|
|
|
* already seen in @ref transit_example_01_explained, but now comes the new
|
|
|
|
* part: instead of creating a second transition that will start later using
|
|
|
|
* a timer, we create the it normally, and use
|
|
|
|
* elm_transit_chain_transit_add() instead of elm_transit_go. Since we are
|
|
|
|
* adding it in a chain after the first transition, it will start as soon as
|
|
|
|
* the first transition ends:
|
|
|
|
*
|
|
|
|
* @skip transit_add
|
|
|
|
* @until transit_chain_transit_add
|
|
|
|
*
|
|
|
|
* Finally we add the 2 other transitions to the chain, and run our program.
|
|
|
|
* It will make one transition start after the other finish, and there is the
|
|
|
|
* transition chain.
|
|
|
|
*/
|
|
|
|
|
2011-06-22 07:52:05 -07:00
|
|
|
/**
|
|
|
|
* @page general_functions_example_page General (top-level) functions example
|
|
|
|
* @dontinclude general_funcs_example.c
|
|
|
|
*
|
|
|
|
* As told in their documentation blocks, the
|
|
|
|
* elm_app_compile_*_dir_set() family of functions have to be called
|
|
|
|
* before elm_app_info_set():
|
|
|
|
* @skip tell elm about
|
|
|
|
* @until elm_app_info_set
|
|
|
|
*
|
|
|
|
* We are here setting the fallback paths to the compiling time target
|
|
|
|
* paths, naturally. If you're building the example out of the
|
|
|
|
* project's build system, we're assuming they are the canonical ones.
|
|
|
|
*
|
|
|
|
* After the program starts, elm_app_info_set() will actually run and
|
|
|
|
* then you'll see an intrincasy: Elementary does the prefix lookup @b
|
|
|
|
* twice. This is so because of the quicklaunch infrastructure in
|
|
|
|
* Elementary (@ref Start), which will register a predefined prefix
|
|
|
|
* for possible users of the launch schema. We're not hooking into a
|
|
|
|
* quick launch, so this first call can't be avoided.
|
|
|
|
*
|
|
|
|
* If you ran this example from your "bindir" installation
|
|
|
|
* directiory, no output will emerge from these both attempts -- it
|
|
|
|
* will find the "magic" file there registered and set the prefixes
|
|
|
|
* silently. Otherwise, you could get something like:
|
|
|
|
@verbatim
|
|
|
|
WARNING: Could not determine its installed prefix for 'ELM'
|
|
|
|
so am falling back on the compiled in default:
|
|
|
|
usr
|
|
|
|
implied by the following:
|
|
|
|
bindir = usr/lib
|
|
|
|
libdir = usr/lib
|
|
|
|
datadir = usr/share/elementary
|
|
|
|
localedir = usr/share/locale
|
|
|
|
Try setting the following environment variables:
|
|
|
|
ELM_PREFIX - points to the base prefix of install
|
|
|
|
or the next 4 variables
|
|
|
|
ELM_BIN_DIR - provide a specific binary directory
|
|
|
|
ELM_LIB_DIR - provide a specific library directory
|
|
|
|
ELM_DATA_DIR - provide a specific data directory
|
|
|
|
ELM_LOCALE_DIR - provide a specific locale directory
|
|
|
|
@endverbatim
|
|
|
|
* if you also didn't change those environment variables (remember
|
|
|
|
* they are also a valid way of communicating your prefix to the
|
|
|
|
* binary) - this is the scenario where it fallbacks to the paths set
|
|
|
|
* for compile time.
|
|
|
|
*
|
|
|
|
* Then, you can check the prefixes set on the standard output:
|
|
|
|
* @skip prefix was set to
|
|
|
|
* @until locale directory is
|
|
|
|
*
|
|
|
|
* In the fragment
|
|
|
|
* @skip by using this policy
|
|
|
|
* @until elm_win_autodel_set
|
|
|
|
* we demonstrate the use of Elementary policies. The policy defining
|
|
|
|
* under which circunstances our application should quit automatically
|
|
|
|
* is set to when its last window is closed (this one has just one
|
|
|
|
* window, though). This will save us from having to set a callback
|
|
|
|
* ourselves on the window, like done in @ref bg_example_01_c "this"
|
|
|
|
* example. Note that we need to tell the window to delete itself's
|
|
|
|
* object on a request to destroy the canvas coming, with
|
|
|
|
* elm_win_autodel_set().
|
|
|
|
*
|
|
|
|
* What follows is some boilerplate code, creating a frame with a @b
|
|
|
|
* button, our object of interest, and, below, widgets to change the
|
|
|
|
* button's behavior and exemplify the group of functions in question.
|
|
|
|
*
|
|
|
|
* @dontinclude general_funcs_example.c
|
|
|
|
* We enabled the focus highlight object for this window, so that you
|
|
|
|
* can keep track of the current focused object better:
|
|
|
|
* @skip elm_win_focus_highlight_enabled_set
|
|
|
|
* @until evas_object_show
|
|
|
|
* Use the tab key to navigate through the focus chain.
|
|
|
|
*
|
|
|
|
* @dontinclude general_funcs_example.c
|
|
|
|
* While creating the button, we exemplify how to use Elementary's
|
|
|
|
* finger size information to scale our UI:
|
|
|
|
* @skip fprintf(stdout, "Elementary
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* @dontinclude general_funcs_example.c
|
|
|
|
* The first checkbox's callback is:
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
* When unsetting the checkbox, we disable the button, which will get a new
|
|
|
|
* decoration (greyed out) and stop receiving events. The focus chain
|
|
|
|
* will also ignore it.
|
|
|
|
*
|
|
|
|
* Following, there are 2 more buttons whose actions are focus/unfocus
|
|
|
|
* the top button, respectively:
|
|
|
|
* @skip focus callback
|
|
|
|
* @until }
|
|
|
|
* and
|
|
|
|
* @skip unfocus callback
|
|
|
|
* @until }
|
|
|
|
* Note the situations in which they won't take effect:
|
|
|
|
* - the button is not allowed to get focus or
|
|
|
|
* - the button is disabled
|
|
|
|
*
|
|
|
|
* The first restriction above you'll get by a second checkbox, whose
|
|
|
|
* callback is:
|
|
|
|
* @skip focus allow callback
|
|
|
|
* @until }
|
|
|
|
* Note that the button will still get mouse events, though.
|
|
|
|
*
|
|
|
|
* Next, there's a slider controlling the button's scale:
|
|
|
|
* @skip scaling callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Experiment with it, so you understand the effect better. If you
|
|
|
|
* change its value, it will mess with the button's original size,
|
|
|
|
* naturally.
|
|
|
|
*
|
|
|
|
* The full code for this example can be found
|
|
|
|
* @ref general_functions_example_c "here".
|
|
|
|
*/
|
|
|
|
|
2011-06-22 12:06:01 -07:00
|
|
|
/**
|
|
|
|
* @page theme_example_01 Theme - Using extensions
|
|
|
|
*
|
|
|
|
* @dontinclude theme_example_01.c
|
|
|
|
*
|
|
|
|
* Using extensions is extremely easy, discarding the part where you have to
|
|
|
|
* write the theme for them.
|
|
|
|
*
|
|
|
|
* In the following example we'll be creating two buttons, one to load or
|
|
|
|
* unload our extension theme and one to cycle around three possible styles,
|
|
|
|
* one of which we created.
|
|
|
|
*
|
|
|
|
* After including our one and only header we'll jump to the callback for
|
|
|
|
* the buttons. First one takes care of loading or unloading our extension
|
|
|
|
* file, relative to the default theme set (thus the @c NULL in the
|
|
|
|
* functions first parameter).
|
|
|
|
* @skipline Elementary.h
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The second button, as we said before, will just switch around different
|
|
|
|
* styles. In this case we have three of them. The first one is our custom
|
|
|
|
* style, named after something very unlikely to find in the default theme.
|
|
|
|
* The other two styles are the standard and one more, anchor, which exists
|
|
|
|
* in the default and is similar to the default, except the button vanishes
|
|
|
|
* when the mouse is not over it.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* So what happens if the style switches to our custom one when the
|
|
|
|
* extension is loaded? Elementary falls back to the default for the
|
|
|
|
* widget.
|
|
|
|
*
|
|
|
|
* And the main function, simply enough, will create the window, set the
|
|
|
|
* buttons and their callbacks, and just to begin with our button styled
|
|
|
|
* we're also loading our extension at the beginning.
|
|
|
|
* @skip int
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* In this case we wanted to easily remove extensions, but all adding an
|
|
|
|
* extension does is tell Elementary where else it should look for themes
|
|
|
|
* when it can't find them in the default theme. Another way to do this
|
|
|
|
* is to set the theme search order using elm_theme_set(), but this requires
|
|
|
|
* that the developer is careful not to override any user configuration.
|
|
|
|
* That can be helped by adding our theme to the end of whatver is already
|
|
|
|
* set, like in the following snippet.
|
|
|
|
* @code
|
|
|
|
* char buf[4096];
|
|
|
|
* snprintf(buf, sizeof(buf), "%s:./theme_example.edj", elme_theme_get(NULL);
|
|
|
|
* elm_theme_set(NULL, buf);
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* If we were using overlays instead of extensions, the same thing applies,
|
|
|
|
* but the custom theme must be added to the front of the search path.
|
|
|
|
*
|
|
|
|
* In the end, we should be looking at something like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-06-22 12:06:01 -07:00
|
|
|
* @image html screenshots/theme_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/theme_example_01.eps width=\textwidth
|
2011-06-22 12:06:01 -07:00
|
|
|
*
|
|
|
|
* That's all. Boringly simple, and the full code in one piece can be found
|
|
|
|
* @ref theme_example_01.c "here".
|
|
|
|
*
|
|
|
|
* And the code for our extension is @ref theme_example.edc "here".
|
|
|
|
*
|
|
|
|
* @example theme_example_01.c
|
|
|
|
* @example theme_example.edc
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page theme_example_02 Theme - Using overlays
|
|
|
|
*
|
|
|
|
* @dontinclude theme_example_02.c
|
|
|
|
*
|
|
|
|
* Overlays are like extensions in that you tell Elementary that some other
|
|
|
|
* theme contains the styles you need for your program. The difference is that
|
|
|
|
* they will be look in first, so they can override the default style of any
|
|
|
|
* widget.
|
|
|
|
*
|
|
|
|
* There's not much to say about them that hasn't been said in our previous
|
|
|
|
* example about @ref theme_example_01 "extensions", so going quickly through
|
|
|
|
* the code we have a function to load or unload the theme, which will be
|
|
|
|
* called when we click any button.
|
|
|
|
* @skipline Elementary.h
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And the main function, creating the window and adding some buttons to it.
|
|
|
|
* We load our theme as an overlay and nothing else. Notice there's no style
|
|
|
|
* set for any button there, which means they should be using the default
|
|
|
|
* that we override.
|
|
|
|
* @skip int
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* That's pretty much it. The full code is @ref theme_example_02.c "here" and
|
|
|
|
* the definition of the theme is the same as before, and can be found in
|
|
|
|
* @ref theme_example.edc "here".
|
|
|
|
*
|
|
|
|
* @example theme_example_02.c
|
|
|
|
*/
|
|
|
|
|
2011-06-27 10:16:00 -07:00
|
|
|
/**
|
2012-03-19 05:58:12 -07:00
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2011-06-27 10:16:00 -07:00
|
|
|
* @page button_example_01 Button - Complete example
|
|
|
|
*
|
|
|
|
* @dontinclude button_example_01.c
|
|
|
|
*
|
|
|
|
* A button is simple, you click on it and something happens. That said,
|
|
|
|
* we'll go through an example to show in detail the button API less
|
|
|
|
* commonly used.
|
|
|
|
*
|
|
|
|
* In the end, we'll be presented with something that looks like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-06-27 10:16:00 -07:00
|
|
|
* @image html screenshots/button_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/button_01.eps width=\textwidth
|
2011-06-27 10:16:00 -07:00
|
|
|
*
|
|
|
|
* The full code of the example is @ref button_example_01.c "here" and we
|
|
|
|
* will follow here with a rundown of it.
|
|
|
|
*
|
|
|
|
* @skip Elementary.h
|
|
|
|
* @until Elementary.h
|
|
|
|
* @skip struct
|
|
|
|
* @until App_Data
|
|
|
|
*
|
|
|
|
* We have several buttons to set different times for the autorepeat timeouts
|
|
|
|
* of the buttons that use it and a few more that we keep track of in our
|
|
|
|
* data struct. The mid button doesn't do much, just moves around according
|
|
|
|
* to what other buttons the user presses. Then four more buttons to move the
|
|
|
|
* central one, and we're also keeping track of the icon set in the middle
|
|
|
|
* button, since when this one moves, we change the icon, and when movement
|
|
|
|
* is finished (by releasing one of the four arrow buttons), we set back the
|
|
|
|
* normal icon.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Keeping any of those four buttons pressed will trigger their autorepeat
|
|
|
|
* 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
|
2011-10-24 18:23:25 -07:00
|
|
|
* middle button, using elm_object_content_unset() first to keep the reference
|
2011-06-27 10:16:00 -07:00
|
|
|
* to the previous one, so we don't need to recreate it when we are done
|
|
|
|
* moving it.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
* @until size_hint_align_set
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* One more callback for the option buttons, that just sets the timeouts for
|
|
|
|
* the different autorepeat options.
|
|
|
|
*
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And the main function, which does some setting up of the buttons in boxes
|
|
|
|
* to make things work. Here we'll go through some snippets only.
|
|
|
|
*
|
|
|
|
* For the option buttons, it's just the button with its label and callback.
|
|
|
|
* @skip elm_button_add
|
|
|
|
* @until smart_callback_add
|
|
|
|
*
|
|
|
|
* For the ones that move the central button, we have no labels. There are
|
|
|
|
* icons instead, and the autorepeat option is toggled.
|
|
|
|
* @skip Gap: 1.0
|
|
|
|
* @skip elm_button_add
|
|
|
|
* @until data.cursors.up
|
|
|
|
*
|
|
|
|
* And just to show the mid button, which doesn't have anything special.
|
|
|
|
* @skip data.cursors.left
|
|
|
|
* @skip elm_button_add
|
|
|
|
* @until data.mid
|
|
|
|
*
|
|
|
|
* And we are done.
|
|
|
|
*
|
|
|
|
* @example button_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-06-29 13:47:41 -07:00
|
|
|
/**
|
|
|
|
* @page bubble_01_example_page elm_bubble - Simple use.
|
|
|
|
* @dontinclude bubble_example_01.c
|
|
|
|
*
|
|
|
|
* This example shows a bubble with all fields set(label, info, content and
|
|
|
|
* icon) and the selected corner changing when the bubble is clicked. To be
|
|
|
|
* able use a bubble we need to do some setup and create a window, for this
|
|
|
|
* example we are going to ignore that part of the code since it isn't
|
|
|
|
* relevant to the bubble.
|
|
|
|
*
|
|
|
|
* To have the selected corner change in a clockwise motion we are going to
|
|
|
|
* use the following callback:
|
|
|
|
* @skip static
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Here we are creating an elm_label that is going to be used as the content
|
|
|
|
* for our bubble:
|
|
|
|
* @skipline elm_label
|
|
|
|
* @until show
|
|
|
|
* @note You could use any evas_object for this, we are using an elm_label
|
|
|
|
* for simplicity.
|
|
|
|
*
|
|
|
|
* Despite it's name the bubble's icon doesn't have to be an icon, it can be
|
|
|
|
* any evas_object. For this example we are going to make the icon a simple
|
|
|
|
* blue rectangle:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* And finally we have the actual bubble creation and the setting of it's
|
|
|
|
* label, info and content:
|
|
|
|
* @until content
|
|
|
|
* @skipline show
|
|
|
|
* @note Because we didn't set a corner, the default("top_left") will be
|
|
|
|
* used.
|
|
|
|
*
|
|
|
|
* Now that we have our bubble all that is left is connecting the "clicked"
|
|
|
|
* signals to our callback:
|
|
|
|
* @line smart_callback
|
|
|
|
*
|
|
|
|
* This last bubble we created was very complete, so it's pertinent to show
|
|
|
|
* that most of that stuff is optional a bubble can be created with nothing
|
|
|
|
* but content:
|
|
|
|
* @until content
|
|
|
|
* @skipline show
|
|
|
|
*
|
2011-06-29 15:09:27 -07:00
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-06-29 15:09:27 -07:00
|
|
|
* @image html screenshots/bubble_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/bubble_example_01.eps width=\textwidth
|
2011-06-29 15:09:27 -07:00
|
|
|
*
|
2011-06-29 13:47:41 -07:00
|
|
|
* See the full source code @ref bubble_example_01.c here.
|
|
|
|
* @example bubble_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-06-29 14:04:23 -07:00
|
|
|
/**
|
|
|
|
* @page box_example_01 Box - Basic API
|
|
|
|
*
|
|
|
|
* @dontinclude button_example_01.c
|
|
|
|
*
|
|
|
|
* As a special guest tonight, we have the @ref button_example_01 "simple
|
|
|
|
* button example". There are plenty of boxes in it, and to make the cursor
|
|
|
|
* buttons that moved a central one around when pressed, we had to use a
|
|
|
|
* variety of values for their hints.
|
|
|
|
*
|
|
|
|
* To start, let's take a look at the handling of the central button when
|
|
|
|
* we were moving it around. To achieve this effect without falling back to
|
|
|
|
* a complete manual positioning of the @c Evas_Object in our canvas, we just
|
|
|
|
* put it in a box and played with its alignment within it, as seen in the
|
|
|
|
* following snippet of the callback for the pressed buttons.
|
|
|
|
* @skip evas_object_size_hint_align_get
|
|
|
|
* @until evas_object_size_hint_align_set
|
|
|
|
*
|
|
|
|
* Not much to it. We get the current alignment of the object and change it
|
|
|
|
* by just a little, depending on which button was pressed, then set it
|
|
|
|
* again, making sure we stay within the 0.0-1.0 range so the button moves
|
|
|
|
* inside the space it has, instead of disappearing under the other objects.
|
|
|
|
*
|
|
|
|
* But as useful as an example as that may have been, the usual case with boxes
|
|
|
|
* is to set everything at the moment they are created, like we did for
|
|
|
|
* everything else in our main function.
|
|
|
|
*
|
|
|
|
* The entire layout of our program is made with boxes. We have one set as the
|
|
|
|
* resize object for the window, which means it will always be resized with
|
|
|
|
* the window. The weight hints set to @c EVAS_HINT_EXPAND will tell the
|
|
|
|
* window that the box can grow past it's minimum size, which allows resizing
|
|
|
|
* of it.
|
|
|
|
* @skip elm_main
|
|
|
|
* @skip elm_box_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Two more boxes, set to horizontal, hold the buttons to change the autorepeat
|
|
|
|
* configuration used by the buttons. We create each to take over all the
|
|
|
|
* available space horizontally, but we don't want them to grow vertically,
|
|
|
|
* so we keep that axis of the weight with 0.0. Then it gets packed in the
|
|
|
|
* main box.
|
|
|
|
* @skip box2
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* The buttons in each of those boxes have nothing special, they are just packed
|
|
|
|
* in with their default values and the box will use their minimum size, as set
|
|
|
|
* by Elementary itself based on the label, icon, finger size and theme.
|
|
|
|
*
|
|
|
|
* But the buttons used to move the central one have a special disposition.
|
|
|
|
* The top one first, is placed right into the main box like our other smaller
|
|
|
|
* boxes. Set to expand horizontally and not vertically, and in this case we
|
|
|
|
* also tell it to fill that space, so it gets resized to take the entire
|
|
|
|
* width of the window.
|
|
|
|
* @skip Gap: 1.0
|
|
|
|
* @skip elm_button_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* The bottom one will be the same, but for the other two we need to use a
|
|
|
|
* second box set to take as much space as we have, so we can place our side
|
|
|
|
* buttons in place and have the big empty space where the central button will
|
|
|
|
* move.
|
|
|
|
* @skip elm_box_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Then the buttons will have their hints inverted to the other top and bottom
|
|
|
|
* ones, to expand and fill vertically and keep their minimum size horizontally.
|
|
|
|
* @skip elm_button_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* The central button takes every thing else. It will ask to be expanded in
|
|
|
|
* both directions, but without filling its cell. Changing its alignment by
|
|
|
|
* pressing the buttons will make it move around.
|
|
|
|
* @skip elm_button_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* To end, the rightmost button is packed in the smaller box after the central
|
|
|
|
* one, and back to the main box we have the bottom button at the end.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page box_example_02 Box - Layout transitions
|
|
|
|
*
|
|
|
|
* @dontinclude box_example_02.c
|
|
|
|
*
|
|
|
|
* Setting a customized layout for a box is simple once you have the layout
|
|
|
|
* function, which is just like the layout function for @c Evas_Box. The new
|
|
|
|
* and fancier thing we can do with Elementary is animate the transition from
|
|
|
|
* one layout to the next. We'll see now how to do that through a simple
|
|
|
|
* example, while also taking a look at some of the API that was left
|
|
|
|
* untouched in our @ref box_example_01 "previous example".
|
|
|
|
*
|
|
|
|
* @image html screenshots/box_example_02.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/box_example_02.eps width=\textwidth
|
2011-06-29 14:04:23 -07:00
|
|
|
*
|
|
|
|
* @skipline Elementary.h
|
|
|
|
*
|
|
|
|
* Our application data consists of a list of layout functions, given by
|
|
|
|
* @c transitions. We'll be animating through them throughout the entire run.
|
|
|
|
* The box with the stuff to move around and the last layout that was set to
|
|
|
|
* make things easier in the code.
|
|
|
|
* @skip typedef
|
|
|
|
* @until Transitions_Data
|
|
|
|
*
|
|
|
|
* The box starts with three buttons, clicking on any of them will take it
|
|
|
|
* out of the box without deleting the object. There are also two more buttons
|
|
|
|
* outside, one to add an object to the box and the other to clear it.
|
|
|
|
* This is all to show how you can interact with the items in the box, add
|
|
|
|
* things and even remove them, while the transitions occur.
|
|
|
|
*
|
|
|
|
* One of the callback we'll be using creates a new button, asks the box for
|
|
|
|
* the list of its children and if it's not empty, we add the new object after
|
|
|
|
* the first one, otherwise just place at the end as it will not make any
|
|
|
|
* difference.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The clear button is even simpler. Everything in the box will be deleted,
|
|
|
|
* leaving it empty and ready to fill it up with more stuff.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And a little function to remove buttons from the box without deleting them.
|
|
|
|
* This one is set for the @c clicked callback of the original buttons,
|
|
|
|
* unpacking them when clicked and placing it somewhere in the screen where
|
|
|
|
* they will not disturb. Once we do this, the box no longer has any control
|
|
|
|
* of it, so it will be left untouched until the program ends.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* If we wanted, we could just call @c evas_object_del() on the object to
|
|
|
|
* destroy it. In this case, no unpack is really necessary, as the box would
|
|
|
|
* be notified of a child being deleted and adjust its calculations accordingly.
|
|
|
|
*
|
|
|
|
* The core of the program is the following function. It takes whatever
|
|
|
|
* function is first on our list of layouts and together with the
|
|
|
|
* @c last_layout, it creates an ::Elm_Box_Transition to use with
|
|
|
|
* elm_box_layout_transition(). In here, we tell it to start from whatever
|
|
|
|
* layout we last set, end with the one that was at the top of the list and
|
|
|
|
* when everything is finished, call us back so we can create another
|
|
|
|
* transition. Finally, move the new layout to the end of the list so we
|
|
|
|
* can continue running through them until the program ends.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The main function doesn't have antyhing special. Creation of box, initial
|
|
|
|
* buttons and some callback setting. The only part worth mentioning is the
|
|
|
|
* initialization of our application data.
|
|
|
|
* @skip tdata.box
|
|
|
|
* @until evas_object_box_layout_stack
|
|
|
|
*
|
|
|
|
* We have a simple static variable, set the box, the first layout we are
|
|
|
|
* using as last and create the list with the different functions to go
|
|
|
|
* through.
|
|
|
|
*
|
|
|
|
* And in the end, we set the first layout and call the same function we went
|
|
|
|
* through before to start the run of transitions.
|
|
|
|
* @until _test_box_transition_change
|
|
|
|
*
|
|
|
|
* For the full code, follow @ref box_example_02.c "here".
|
|
|
|
*
|
|
|
|
* @example box_example_02.c
|
|
|
|
*/
|
|
|
|
|
2011-07-14 08:45:44 -07:00
|
|
|
/**
|
|
|
|
* @page calendar_example_01 Calendar - Simple creation.
|
|
|
|
* @dontinclude calendar_example_01.c
|
|
|
|
*
|
|
|
|
* As a first example, let's just display a calendar in our window,
|
|
|
|
* explaining all steps required to do so.
|
|
|
|
*
|
|
|
|
* First you should declare objects we intend to use:
|
|
|
|
* @skipline Evas_Object
|
|
|
|
*
|
|
|
|
* Then a window is created, a title is set and its set to be autodeleted.
|
|
|
|
* More details can be found on windows examples:
|
|
|
|
* @until elm_win_autodel
|
|
|
|
*
|
|
|
|
* Next a simple background is placed on our windows. More details on
|
2011-08-03 12:07:43 -07:00
|
|
|
* @ref bg_01_example_page :
|
2011-07-14 08:45:44 -07:00
|
|
|
* @until evas_object_show(bg)
|
|
|
|
*
|
|
|
|
* Now, the exciting part, let's add the calendar with elm_calendar_add(),
|
|
|
|
* passing our window object as parent.
|
|
|
|
* @until evas_object_show(cal);
|
|
|
|
*
|
|
|
|
* To conclude our example, we should show the window and run elm mainloop:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-14 08:45:44 -07:00
|
|
|
* @image html screenshots/calendar_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/calendar_example_01.eps width=\textwidth
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* See the full source code @ref calendar_example_01.c here.
|
|
|
|
* @example calendar_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page calendar_example_02 Calendar - Layout strings formatting.
|
|
|
|
* @dontinclude calendar_example_02.c
|
|
|
|
*
|
|
|
|
* In this simple example, we'll explain how to format the label displaying
|
|
|
|
* month and year, and also set weekday names.
|
|
|
|
*
|
|
|
|
* To format month and year label, we need to create a callback function
|
|
|
|
* to create a string given the selected time, declared under a
|
|
|
|
* <tt> struct tm </tt>.
|
|
|
|
*
|
|
|
|
* <tt> struct tm </tt>, declared on @c time.h, is a structure composed by
|
|
|
|
* nine integers:
|
|
|
|
* @li tm_sec seconds [0,59]
|
|
|
|
* @li tm_min minutes [0,59]
|
|
|
|
* @li tm_hour hour [0,23]
|
|
|
|
* @li tm_mday day of month [1,31]
|
|
|
|
* @li tm_mon month of year [0,11]
|
|
|
|
* @li tm_year years since 1900
|
|
|
|
* @li tm_wday day of week [0,6] (Sunday = 0)
|
|
|
|
* @li tm_yday day of year [0,365]
|
|
|
|
* @li tm_isdst daylight savings flag
|
|
|
|
* @note glib version has 2 additional fields.
|
|
|
|
*
|
|
|
|
* For our function, only stuff that matters are tm_mon and tm_year.
|
|
|
|
* But we don't need to access it directly, since there are nice functions
|
|
|
|
* to format date and time, as @c strftime.
|
|
|
|
* We will get abbreviated month (%b) and year (%y) (check strftime manpage
|
|
|
|
* for more) in our example:
|
|
|
|
* @skipline static char
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* We need to alloc the string to be returned, and calendar widget will
|
|
|
|
* free it when it's not needed, what is done by @c strdup.
|
|
|
|
* So let's register our callback to calendar object:
|
|
|
|
* @skipline elm_calendar_format_function_set
|
|
|
|
*
|
|
|
|
* To set weekday names, we should declare them as an array of strings:
|
|
|
|
* @dontinclude calendar_example_02.c
|
2012-03-21 10:57:27 -07:00
|
|
|
* @skipline weekdays[]
|
2011-07-14 08:45:44 -07:00
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And finally set them to calendar:
|
2012-03-21 10:57:27 -07:00
|
|
|
* @skipline weekdays_names_set
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-14 08:45:44 -07:00
|
|
|
* @image html screenshots/calendar_example_02.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/calendar_example_02.eps width=\textwidth
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* See the full source code @ref calendar_example_02.c here.
|
|
|
|
* @example calendar_example_02.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page calendar_example_03 Calendar - Years restrictions.
|
|
|
|
* @dontinclude calendar_example_03.c
|
|
|
|
*
|
|
|
|
* This example explains how to set max and min year to be displayed
|
|
|
|
* by a calendar object. This means that user won't be able to
|
|
|
|
* see or select a date before and after selected years.
|
|
|
|
* By default, limits are 1902 and maximun value will depends
|
|
|
|
* on platform architecture (year 2037 for 32 bits); You can
|
|
|
|
* read more about time functions on @c ctime manpage.
|
|
|
|
*
|
|
|
|
* Straigh to the point, to set it is enough to call
|
|
|
|
* elm_calendar_min_max_year_set(). First value is minimun year, second
|
|
|
|
* is maximum. If first value is negative, it won't apply limit for min
|
|
|
|
* year, if the second one is negative, won't apply for max year.
|
|
|
|
* Setting both to negative value will clear limits (default state):
|
|
|
|
* @skipline elm_calendar_min_max_year_set
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-14 08:45:44 -07:00
|
|
|
* @image html screenshots/calendar_example_03.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/calendar_example_03.eps width=\textwidth
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* See the full source code @ref calendar_example_03.c here.
|
|
|
|
* @example calendar_example_03.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page calendar_example_04 Calendar - Days selection.
|
|
|
|
* @dontinclude calendar_example_04.c
|
|
|
|
*
|
|
|
|
* It's possible to disable date selection and to select a date
|
|
|
|
* from your program, and that's what we'll see on this example.
|
|
|
|
*
|
|
|
|
* 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:
|
2012-03-12 01:12:49 -07:00
|
|
|
* @skipline elm_calendar_day_selection_disabled_set
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* Also, regarding days selection, you could be interested to set a
|
|
|
|
* date to be highlighted on calendar from your code, maybe when
|
2012-03-21 10:57:27 -07:00
|
|
|
* 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:
|
2011-07-14 08:45:44 -07:00
|
|
|
* @dontinclude calendar_example_04.c
|
|
|
|
* @skipline SECS_DAY
|
2012-03-21 10:57:27 -07:00
|
|
|
*
|
|
|
|
* Now let's select two days from current day:
|
|
|
|
* @skipline time(NULL)
|
2011-07-14 08:45:44 -07:00
|
|
|
* @until elm_calendar_selected_time_set
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-14 08:45:44 -07:00
|
|
|
* @image html screenshots/calendar_example_04.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/calendar_example_04.eps width=\textwidth
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* See the full source code @ref calendar_example_04.c here.
|
|
|
|
* @example calendar_example_04.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page calendar_example_05 Calendar - Signal callback and getters.
|
|
|
|
* @dontinclude calendar_example_05.c
|
|
|
|
*
|
|
|
|
* Most of setters explained on previous examples have associated getters.
|
|
|
|
* That's the subject of this example. We'll add a callback to display
|
|
|
|
* all calendar information every time user interacts with the calendar.
|
|
|
|
*
|
|
|
|
* Let's check our callback function:
|
|
|
|
* @skipline static void
|
|
|
|
* @until double interval;
|
|
|
|
*
|
|
|
|
* To get selected day, we need to call elm_calendar_selected_time_get(),
|
|
|
|
* but to assure nothing wrong happened, we must check for function return.
|
|
|
|
* It'll return @c EINA_FALSE if fail. Otherwise we can use time set to
|
|
|
|
* our structure @p stime.
|
|
|
|
* @skipline elm_calendar_selected_time_get
|
|
|
|
* @until return
|
|
|
|
*
|
|
|
|
* Next we'll get information from calendar and place on declared vars:
|
|
|
|
* @skipline interval
|
|
|
|
* @until elm_calendar_weekdays_names_get
|
|
|
|
*
|
|
|
|
* The only tricky part is that last line gets an array of strings
|
|
|
|
* (char arrays), one for each weekday.
|
|
|
|
*
|
|
|
|
* Then we can simple print that to stdin:
|
|
|
|
* @skipline printf
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <tt> struct tm </tt> is declared on @c time.h. You can check @c ctime
|
|
|
|
* manpage to read about it.
|
|
|
|
*
|
|
|
|
* To register this callback, that will be called every time user selects
|
|
|
|
* a day or goes to next or previous month, just add a callback for signal
|
|
|
|
* @b changed.
|
|
|
|
* @skipline evas_object_smart_callback_add
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-14 08:45:44 -07:00
|
|
|
* @image html screenshots/calendar_example_05.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/calendar_example_05.eps width=\textwidth
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* See the full source code @ref calendar_example_05.c here.
|
|
|
|
* @example calendar_example_05.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page calendar_example_06 Calendar - Calendar marks.
|
|
|
|
* @dontinclude calendar_example_06.c
|
|
|
|
*
|
|
|
|
* On this example marks management will be explained. Functions
|
|
|
|
* elm_calendar_mark_add(), elm_calendar_mark_del() and
|
|
|
|
* elm_calendar_marks_clear() will be covered.
|
|
|
|
*
|
|
|
|
* To add a mark, will be required to choose three things:
|
|
|
|
* @li mark style
|
|
|
|
* @li mark date, or start date if it will be repeated
|
|
|
|
* @li mark periodicity
|
|
|
|
*
|
|
|
|
* Style defines the kind of mark will be displayed over marked day,
|
|
|
|
* on caledar. Default theme supports @b holiday and @b checked.
|
|
|
|
* If more is required, is possible to set a new theme to calendar
|
|
|
|
* widget using elm_object_style_set(), and use
|
|
|
|
* the signal that will be used by such marks.
|
|
|
|
*
|
|
|
|
* Date is a <tt> struct tm </tt>, as defined by @c time.h. More can
|
|
|
|
* be read on @c ctime manpage.
|
|
|
|
* If a date relative from current is required, this struct can be set
|
|
|
|
* as:
|
2012-03-21 10:57:27 -07:00
|
|
|
* @skipline time(NULL)
|
2011-07-14 08:45:44 -07:00
|
|
|
* @until localtime_r
|
|
|
|
*
|
|
|
|
* Or if it's an absolute date, you can just declare the struct like:
|
|
|
|
* @dontinclude calendar_example_06.c
|
|
|
|
* @skipline sunday
|
|
|
|
* @until christmas.tm_mon
|
|
|
|
*
|
|
|
|
* 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
|
2012-03-12 01:12:49 -07:00
|
|
|
* @c Elm_Calendar_Mark_Repeat_Type.
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
* @dontinclude calendar_example_06.c
|
|
|
|
* @skipline sunday
|
|
|
|
* @until christmas.tm_mon
|
|
|
|
* @skipline current_time
|
|
|
|
* @until ELM_CALENDAR_WEEKLY
|
|
|
|
*
|
|
|
|
* We kept the return of first mark add, because we don't really won't it
|
|
|
|
* to be checked, so let's remove it:
|
|
|
|
* @skipline elm_calendar_mark_del
|
|
|
|
*
|
|
|
|
* After all marks are added and removed, is required to draw them:
|
|
|
|
* @skipline elm_calendar_marks_draw
|
|
|
|
*
|
|
|
|
* Finally, to clear all marks, let's set a callback for our button:
|
|
|
|
* @skipline elm_button_add
|
|
|
|
* @until evas_object_show(bt);
|
|
|
|
*
|
|
|
|
* This callback will receive our calendar object, and should clear it:
|
|
|
|
* @dontinclude calendar_example_06.c
|
|
|
|
* @skipline static
|
|
|
|
* @until }
|
|
|
|
* @note Remember to draw marks after clear the calendar.
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-14 08:45:44 -07:00
|
|
|
* @image html screenshots/calendar_example_06.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/calendar_example_06.eps width=\textwidth
|
2011-07-14 08:45:44 -07:00
|
|
|
*
|
|
|
|
* See the full source code @ref calendar_example_06.c here.
|
|
|
|
* @example calendar_example_06.c
|
|
|
|
*/
|
|
|
|
|
2011-07-26 10:27:05 -07:00
|
|
|
/**
|
|
|
|
* @page spinner_example Spinner widget example
|
|
|
|
*
|
|
|
|
* This code places seven Elementary spinner widgets on a window, each of
|
|
|
|
* them exemplifying a part of the widget's API.
|
|
|
|
*
|
|
|
|
* The first of them is the default spinner:
|
|
|
|
* @dontinclude spinner_example.c
|
|
|
|
* @skipline elm_spinner_add
|
|
|
|
* @until evas_object_show
|
|
|
|
* As you see, the defaults for a spinner are:
|
|
|
|
* @li no wrap
|
|
|
|
* @li min value set to 0
|
|
|
|
* @li max value set to 100
|
|
|
|
* @li step value set to 1
|
|
|
|
* @li label format set to "%0.f"
|
|
|
|
*
|
|
|
|
* If another format is required, see the second spinner. It will put a text
|
|
|
|
* before and after the value, and also format value to display two decimals:
|
|
|
|
* @skipline format_set
|
|
|
|
*
|
|
|
|
* The third one will use a customized step, define new minimum and maximum
|
|
|
|
* values and enable wrap, so when value reaches minimum it jumps to maximum,
|
|
|
|
* or jumps to minimum after maximum value is reached. Format is set to display
|
|
|
|
* a decimal:
|
|
|
|
* @skipline elm_spinner_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* The fourth uses @c vertical style, so instead of left and right arrows,
|
|
|
|
* top and bottom are displayed. Also the change interval is reduced, so
|
|
|
|
* user can change value faster.
|
|
|
|
* @skipline style
|
|
|
|
* @skipline interval
|
|
|
|
*
|
|
|
|
* In the fifth the user won't be allowed to set value directly, i.e., will
|
|
|
|
* be obligate change value only using arrows:
|
|
|
|
* @skipline editable
|
|
|
|
*
|
|
|
|
* The sixth widget will receive a lot of special values, so
|
|
|
|
* instead of reading numeric values, user will see labels for each one.
|
|
|
|
* Also direct edition is disabled, otherwise users would see the numeric
|
|
|
|
* value on edition mode. User will be able to select a month in this widget:
|
|
|
|
* @skipline elm_spinner_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Finally the last widget will exemplify how to listen to widget's signals,
|
|
|
|
* <tt> changed </tt> and <tt> delay,changed </tt>. First we need to
|
|
|
|
* implement callback functions that will simply print spinner's value:
|
|
|
|
* @dontinclude spinner_example.c
|
|
|
|
* @skip static
|
|
|
|
* @skip }
|
|
|
|
* @skipline static
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The first callback function should be called everytime value changes,
|
|
|
|
* the second one only after user stops to increment or decrement. Try
|
|
|
|
* to keep arrows pressed and check the difference.
|
|
|
|
* @skip smart_callback
|
|
|
|
* @skipline smart_callback
|
|
|
|
* @skipline smart_callback
|
|
|
|
*
|
|
|
|
* See the full @ref spinner_example.c "example", whose window should
|
|
|
|
* look like this picture:
|
|
|
|
*
|
|
|
|
* @image html screenshots/spinner_example.png
|
|
|
|
* @image latex screenshots/spinner_example.eps width=\textwidth
|
|
|
|
*
|
2011-08-03 12:07:43 -07:00
|
|
|
* See the full @ref spinner_example.c "source code" for this example.
|
2011-07-26 10:27:05 -07:00
|
|
|
*
|
|
|
|
* @example spinner_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-27 06:32:51 -07:00
|
|
|
/**
|
|
|
|
* @page slider_example Slider widget example
|
|
|
|
*
|
|
|
|
* This code places seven Elementary slider widgets on a window, each of
|
|
|
|
* them exemplifying a part of the widget's API.
|
|
|
|
*
|
|
|
|
* The first of them is the default slider:
|
|
|
|
* @dontinclude slider_example.c
|
|
|
|
* @skipline elm_slider_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* As you see, the defaults for a slider are:
|
|
|
|
* @li horizontal
|
|
|
|
* @li no label
|
|
|
|
* @li no values (on indicator or unit labels)
|
|
|
|
*
|
|
|
|
* Actually it's pretty useless this way. So let's learn how to improve it.
|
|
|
|
*
|
|
|
|
* 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.
|
2012-03-19 05:58:07 -07:00
|
|
|
* @skip elm_object_text_set
|
|
|
|
* @until elm_object_part_content_set(sl, "end", ic)
|
2011-07-27 06:32:51 -07:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* with a not default value (0.0), as we done on third slider:
|
|
|
|
* @skipline value_set
|
|
|
|
* @skipline span_size_set
|
|
|
|
*
|
|
|
|
* So far, users won't be able to see the slider value. If it's required,
|
|
|
|
* it can be displayed in two different areas, units label or above
|
|
|
|
* the indicator.
|
|
|
|
*
|
|
|
|
* Let's place a units label on our widget, and also let's set minimum and
|
|
|
|
* maximum value (uses 0.0 and 1.0 by default):
|
|
|
|
* @skipline unit_format_set
|
|
|
|
* @skipline min_max_set
|
|
|
|
*
|
|
|
|
* If above the indicator is the place to display the value, just set it.
|
|
|
|
* Also, is possible to invert a bar, as you can see:
|
|
|
|
* @skipline indicator_format_set
|
|
|
|
* @skipline inverted_set
|
|
|
|
*
|
|
|
|
* But if you require to use a function a bit more customized to show the value,
|
|
|
|
* is possible to registry a callback function that will be called
|
|
|
|
* to display unit or indicator label. Only the value will be passed to this
|
|
|
|
* function, that should return a string.
|
|
|
|
* In this case, a function to free this string will be required.
|
|
|
|
*
|
|
|
|
* Let's exemplify with indicator label on our sixth slider:
|
|
|
|
* @dontinclude slider_example.c
|
|
|
|
* @skip static
|
|
|
|
* @skip }
|
|
|
|
* @skip static
|
|
|
|
* @skip }
|
|
|
|
* @skip static
|
|
|
|
* @skip }
|
|
|
|
* @skipline static
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Setting callback functions:
|
|
|
|
* @skipline indicator_format_function_set
|
|
|
|
* @skipline _indicator_free
|
|
|
|
*
|
|
|
|
* Also, a slider can be displayed vertically:
|
|
|
|
* @dontinclude slider_example.c
|
|
|
|
* @skipline elm_slider_horizontal_set
|
|
|
|
*
|
|
|
|
* Finally the last widget will exemplify how to listen to widget's signals,
|
|
|
|
* <tt> changed </tt> and <tt> delay,changed </tt>. First we need to
|
|
|
|
* implement callback functions that will simply print slider's value:
|
|
|
|
* @dontinclude slider_example.c
|
|
|
|
* @skip static
|
|
|
|
* @skip }
|
|
|
|
* @skipline static
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The first callback function should be called everytime value changes,
|
|
|
|
* the second one only after user stops to increment or decrement. Try
|
|
|
|
* to keep arrows pressed and check the difference.
|
|
|
|
* @skip smart_callback
|
|
|
|
* @skipline smart_callback
|
|
|
|
* @skipline smart_callback
|
|
|
|
*
|
|
|
|
* See the full @ref slider_example.c "example", whose window should
|
|
|
|
* look like this picture:
|
|
|
|
*
|
|
|
|
* @image html screenshots/slider_example.png
|
|
|
|
* @image latex screenshots/slider_example.eps width=\textwidth
|
|
|
|
*
|
2011-08-03 12:07:43 -07:00
|
|
|
* See the full @ref slider_example.c "source code" for this example.
|
2011-07-27 06:32:51 -07:00
|
|
|
*
|
|
|
|
* @example slider_example.c
|
2011-07-27 10:06:40 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page panes_example Panes widget example
|
|
|
|
*
|
|
|
|
* This code places two Elementary panes widgets on a window, one of them
|
|
|
|
* displayed vertically and the other horizontally, to exemplify
|
|
|
|
* a part of the widget's API. Also, all the signals emitted by this
|
|
|
|
* widget will be covered.
|
|
|
|
*
|
|
|
|
* Let's start adding a panes to our window:
|
|
|
|
* @dontinclude panes_example.c
|
|
|
|
* @skipline elm_panes_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Now we will set a content (a simple button) to the left side of our
|
|
|
|
* panes widget:
|
|
|
|
* @skipline elm_button_add
|
|
|
|
* @until content_left_set
|
|
|
|
*
|
|
|
|
* The content of the right side will be something a bit more elaborated, we'll
|
|
|
|
* place another panes, displayed vertically (it's displayed horizontally
|
|
|
|
* by default):
|
|
|
|
* @skipline elm_panes_add
|
|
|
|
* @until content_right_set
|
|
|
|
*
|
|
|
|
* When populating a panes displayed vertically, remember that left content
|
|
|
|
* will be placed at top, and right content will place at bottom. Next
|
|
|
|
* we will add two buttons to exemplify that:
|
|
|
|
* @skipline elm_button_add
|
|
|
|
* @until content_right_set
|
|
|
|
*
|
|
|
|
* Panes widgets emits 4 different signals, depending on users interaction
|
|
|
|
* with the draggable bar. We'll add a callback function for each of them.
|
|
|
|
*
|
|
|
|
* <tt> "clicked" signal </tt>:
|
|
|
|
*
|
|
|
|
* Callback function that just print "Clicked" to stdin:
|
|
|
|
* @dontinclude panes_example.c
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skipline static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Also, add callback function to the panes:
|
|
|
|
* @skipline "clicked"
|
|
|
|
*
|
|
|
|
* <tt> "press" signal </tt>:
|
|
|
|
*
|
|
|
|
* Callback function that just print "Pressed" to stdin:
|
|
|
|
* @dontinclude panes_example.c
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skipline static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Also, add callback function to the panes:
|
|
|
|
* @skipline "press"
|
|
|
|
*
|
|
|
|
* Now, let's try to make our callback functions a bit more useful:
|
|
|
|
*
|
|
|
|
* <tt> "unpress" signal </tt>:
|
|
|
|
*
|
|
|
|
* Suppose we want to know the size proportion of left content after
|
|
|
|
* user drags the bar. We need to listen for @c unpress signal, and
|
|
|
|
* get this size from our panes widget. It's done on the following
|
|
|
|
* function:
|
|
|
|
* @dontinclude panes_example.c
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skipline static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Adding the callback function to the panes:
|
|
|
|
* @skipline "unpress"
|
|
|
|
|
|
|
|
* <tt> "clicked,double" signal </tt>:
|
|
|
|
*
|
|
|
|
* Now, a interesting feature that could be addded to panes widget.
|
|
|
|
* Hide a content when user double click the draggable bar. It's done
|
|
|
|
* using a variable to store size and content left size getter and setter
|
|
|
|
* on the following function:
|
|
|
|
* @dontinclude panes_example.c
|
|
|
|
* @skipline static double
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skip static void
|
|
|
|
* @skip }
|
|
|
|
* @skipline static void
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Adding the callback function to the panes:
|
|
|
|
* @skipline "clicked,double"
|
|
|
|
* @until panes);
|
|
|
|
*
|
|
|
|
* See the full @ref panes_example.c "example", whose window should
|
|
|
|
* look like this picture:
|
|
|
|
*
|
|
|
|
* @image html screenshots/panes_example.png
|
|
|
|
* @image latex screenshots/panes_example.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example panes_example.c
|
2011-07-27 06:32:51 -07:00
|
|
|
*/
|
|
|
|
|
2011-07-11 06:51:32 -07:00
|
|
|
/**
|
|
|
|
* @page clock_example Clock widget example
|
|
|
|
*
|
|
|
|
* This code places five Elementary clock widgets on a window, each of
|
|
|
|
* them exemplifying a part of the widget's API.
|
|
|
|
*
|
|
|
|
* The first of them is the pristine clock:
|
|
|
|
* @dontinclude clock_example.c
|
|
|
|
* @skip pristine
|
|
|
|
* @until evas_object_show
|
|
|
|
* As you see, the defaults for a clock are:
|
|
|
|
* - military time
|
|
|
|
* - no seconds shown
|
|
|
|
*
|
|
|
|
* For am/pm time, see the second clock:
|
|
|
|
* @dontinclude clock_example.c
|
|
|
|
* @skip am/pm
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* The third one will show the seconds digits, which will flip in
|
|
|
|
* synchrony with system time. Note, besides, that the time itself is
|
|
|
|
* @b different from the system's -- it was customly set with
|
|
|
|
* elm_clock_time_set():
|
|
|
|
* @dontinclude clock_example.c
|
|
|
|
* @skip with seconds
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* In both fourth and fifth ones, we turn on the <b>edition
|
|
|
|
* mode</b>. See how you can change each of the sheets on it, and be
|
|
|
|
* sure to try holding the mouse pressed over one of the sheet
|
|
|
|
* arrows. The forth one also starts with a custom time set:
|
|
|
|
* @dontinclude clock_example.c
|
|
|
|
* @skip in edition
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* The fifth, besides editable, has only the time @b units editable,
|
|
|
|
* for hours, minutes and seconds. This exemplifies
|
2012-03-13 00:53:05 -07:00
|
|
|
* elm_clock_edit_mode_set():
|
2011-07-11 06:51:32 -07:00
|
|
|
* @dontinclude clock_example.c
|
|
|
|
* @skip but only
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* See the full @ref clock_example.c "example", whose window should
|
|
|
|
* look like this picture:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-11 06:51:32 -07:00
|
|
|
* @image html screenshots/clock_example.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/clock_example.eps width=\textwidth
|
2011-07-11 06:51:32 -07:00
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* See the full @ref clock_example_c "source code" for this example.
|
|
|
|
*
|
2011-07-11 06:51:32 -07:00
|
|
|
* @example clock_example.c
|
|
|
|
*/
|
|
|
|
|
2012-03-05 03:07:05 -08:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2012-03-06 20:57:03 -08:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-08-01 14:32:25 -07:00
|
|
|
/**
|
|
|
|
* @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.
|
2012-03-16 16:45:48 -07:00
|
|
|
* So we'll add a check for that. Everytime the map properties
|
2011-08-01 14:32:25 -07:00
|
|
|
* 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.
|
2012-03-16 16:45:48 -07:00
|
|
|
* @skipline check_add
|
2011-08-01 14:32:25 -07:00
|
|
|
* @until show
|
|
|
|
*
|
2012-03-16 16:45:48 -07:00
|
|
|
* We have added a callback function to this check, so it will enable
|
2011-08-01 14:32:25 -07:00
|
|
|
* 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.
|
|
|
|
*
|
2012-03-16 16:45:48 -07:00
|
|
|
* Callback functions look like the one added to the check. This way we
|
2011-08-01 14:32:25 -07:00
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2011-08-04 15:35:12 -07:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* @page map_example_02 Map Example - Overlay Usage
|
2011-08-04 15:35:12 -07:00
|
|
|
*
|
|
|
|
* This code places a Elementary map widget on a window,
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* to exemplify part of the widget's API, related to overlays.
|
2011-08-04 15:35:12 -07:00
|
|
|
*
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* We'll start this example in the same way
|
2011-08-04 15:35:12 -07:00
|
|
|
* @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
|
|
|
|
*
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* 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
|
2011-08-04 15:35:12 -07:00
|
|
|
*
|
|
|
|
* 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
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* @until Overlay_Data;
|
2011-08-04 15:35:12 -07:00
|
|
|
*
|
|
|
|
* We'll create instances for each place:
|
|
|
|
* @skipline argentina
|
|
|
|
* @until sky_03
|
|
|
|
*
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* To return an icon, all we need to do is to add a elm_icon and return it:
|
2011-08-04 15:35:12 -07:00
|
|
|
* @dontinclude map_example_02.c
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* @skipline _icon_get(
|
2011-08-04 15:35:12 -07:00
|
|
|
* @until }
|
|
|
|
*
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* For the content, let's return something more elaborate. We will return
|
2011-08-04 15:35:12 -07:00
|
|
|
* a box with an image representing the place, and the name of this place:
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* @skipline _box_get(
|
2011-08-04 15:35:12 -07:00
|
|
|
* @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.
|
|
|
|
*
|
From: Bluezery <ohpowel@gmail.com>
Subject: [E-devel] [Patch][elm_map] Add overlay in the map
I made a overlay APIs in the map. This will replace the marker APIs.
I hope that markers will be deleted before elementary 1.0 release.
This was discussed before in
http://marc.info/?l=enlightenment-devel&m=132685497711772&w=2
Marker only supports layout style overlay. So only icon and image are
suitable for marker. For now on, overlay can support any evas object
and also layout style.
Currently overlay support default, bubble, and class types. And more
types will be added (Polyline, Polygon, scale, POI etc.).
I made a Elm_Map_Overlay opaque structure for handling general overlay
properties (hide, pause, show, etc.) and coordinates or internal
content (icon, content, etc.) for those different types.
Class type overlay is something like mixture of previous marker group
and marker class.
If member overlays in the same class are closed, they will be grouped.
(Same functionality as previous maker group.) The group's properties
and contents are defined by using general overlay functions. (New
functionality)
This defined properties and contents can be be propagated to member
overlays appended to this class. (Same functionality as previous
maker class.)
There are some missing functionalities remained. Group callbacks are
not supported yet in the overlays.
So images inside group bubble can not be shown. I will implement this
feature.
After this patch, I will fix signals and function names before
elementary 1.0 releases.
SVN revision: 68672
2012-03-04 20:18:33 -08:00
|
|
|
* We'll start this example in the same way
|
2011-08-04 15:35:12 -07:00
|
|
|
* @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.
|
2012-03-10 02:07:27 -08:00
|
|
|
* Function elm_map_name_geo_request() will do this job for us,
|
2011-08-04 15:35:12 -07:00
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2011-07-15 14:29:34 -07:00
|
|
|
/**
|
|
|
|
* @page diskselector_example_01 Diskselector widget example
|
|
|
|
*
|
|
|
|
* This code places 4 Elementary diskselector widgets on a window, each of
|
|
|
|
* them exemplifying a part of the widget's API.
|
|
|
|
*
|
|
|
|
* All of them will have weekdays as items, since we won't focus
|
|
|
|
* on items management on this example. For an example about this subject,
|
|
|
|
* check @ref diskselector_example_02.
|
|
|
|
*
|
|
|
|
* The first of them is a default diskselector.
|
|
|
|
* @dontinclude diskselector_example_01.c
|
|
|
|
* @skipline lbl
|
|
|
|
* @until }
|
|
|
|
* @skipline elm_diskselector_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* We are just adding the diskselector, so as you can see, defaults for it are:
|
|
|
|
* @li Only 3 items visible each time.
|
|
|
|
* @li Only 3 characters are displayed for labels on side positions.
|
|
|
|
* @li The first added item remains centeres, i.e., it's the selected item.
|
|
|
|
*
|
|
|
|
* To add items, we are just appending it on a loop, using function
|
|
|
|
* elm_diskselector_item_append(), that will be better exaplained on
|
|
|
|
* items management example.
|
|
|
|
*
|
|
|
|
* For a circular diskselector, check the second widget. A circular
|
|
|
|
* 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
|
2012-03-07 04:30:00 -08:00
|
|
|
* elm_diskselector_round_enabled_set().
|
2011-07-15 14:29:34 -07:00
|
|
|
*
|
|
|
|
* Also, we decide to display only 2 character for side labels, instead of 3.
|
2012-03-07 04:30:00 -08:00
|
|
|
* For this we call elm_diskselector_side_text_max_length_set(). As result,
|
2011-07-15 14:29:34 -07:00
|
|
|
* we'll see @b Mo displayed instead of @b Mon, when @b Monday is on a
|
|
|
|
* side position.
|
|
|
|
*
|
|
|
|
* @skipline elm_diskselector_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* But so far, we are only displaying 3 items at once. If more are wanted,
|
|
|
|
* is enough to call elm_diskselector_display_item_num_set(), as you can
|
|
|
|
* see here:
|
|
|
|
* @skipline elm_diskselector_add
|
2012-03-21 10:57:34 -07:00
|
|
|
* @until elm_diskselector_display_item_num_set
|
2011-07-15 14:29:34 -07:00
|
|
|
*
|
|
|
|
* @note You can't set less than 3 items to be displayed.
|
|
|
|
*
|
2011-09-02 22:13:25 -07:00
|
|
|
* You can get the number of items in the diskselector by calling
|
|
|
|
* elm_diskselector_display_item_num_get(), as you can see here:
|
2012-03-21 10:57:34 -07:00
|
|
|
* @skipline elm_diskselector_display_item_num_get
|
2011-09-02 22:13:25 -07:00
|
|
|
*
|
2011-07-15 14:29:34 -07:00
|
|
|
* 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.
|
|
|
|
* @skipline elm_diskselector_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* See the full @ref diskselector_example_01.c "diskselector_example_01.c"
|
|
|
|
* code, whose window should look like this picture:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 14:29:34 -07:00
|
|
|
* @image html screenshots/diskselector_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/diskselector_example_01.eps width=\textwidth
|
2011-07-15 14:29:34 -07:00
|
|
|
*
|
|
|
|
* @example diskselector_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page diskselector_example_02 Diskselector - Items management
|
|
|
|
*
|
|
|
|
* This code places a Elementary diskselector widgets on a window,
|
|
|
|
* along with some buttons trigerring actions on it (though its API).
|
2011-12-30 00:33:50 -08:00
|
|
|
* It covers most of diskselector item functions.
|
2011-07-15 14:29:34 -07:00
|
|
|
*
|
|
|
|
* On our @c main function, we are adding a default diskselector with
|
|
|
|
* 3 items. We are only setting their labels (second parameter of function
|
|
|
|
* elm_diskselector_item_append):
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline elm_diskselector_add
|
|
|
|
* @until Item 2
|
|
|
|
*
|
|
|
|
* Next we are adding lots of buttons, each one for a callback function
|
|
|
|
* that will realize a task covering part of diskselector items API.
|
|
|
|
* Lets check the first one:
|
|
|
|
* @skipline elm_button_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* We are labeling the button with a task description with
|
|
|
|
* elm_object_text_set() and setting a callback
|
|
|
|
* function evas_object_smart_callback_add().
|
|
|
|
* Each callback function will have the signature:
|
|
|
|
* <tt> static void _task_cb(void *data, Evas_Object *obj,
|
|
|
|
* void *event_info)</tt> with the function name varying for each task.
|
|
|
|
*
|
|
|
|
* Now let's cover all of them.
|
|
|
|
*
|
|
|
|
* <b> Appending an item: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _add_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* All items are included on diskselector after last one. You @b can't
|
|
|
|
* preprend items.
|
|
|
|
*
|
|
|
|
* The first parameter of elm_diskselector_item_append() is the diskselector
|
|
|
|
* object, that we are receiving as data on our callback function.
|
|
|
|
* The second one is a label, the string that will be placed in the center
|
|
|
|
* of our item. As we don't wan't icons or callback functions, we can
|
|
|
|
* send NULL as third, fourth and fifth parameters.
|
|
|
|
*
|
|
|
|
* <b> Appending an item with icon: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _add_ic_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* If an icon is required, you can pass it as third paramenter on our
|
|
|
|
* elm_diskselector_item_append() function. It will be place on the
|
|
|
|
* left side of item's label, that will be shifted to right a bit.
|
|
|
|
*
|
|
|
|
* For more details about how to create icons, look for elm_icon examples.
|
|
|
|
*
|
|
|
|
* <b> Appending an item with callback function for selected: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _sel_cb
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* To set a callback function that will be called every time an item is
|
|
|
|
* selected, i.e., everytime the diskselector stops with this item in
|
|
|
|
* center position, just pass the function as fourth paramenter.
|
|
|
|
*
|
|
|
|
* <b> Appending an item with callback function for selected with data: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _sel_data_cb
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* If the callback function request an extra data, it can be attached to our
|
|
|
|
* item passing a pointer for data as fifth parameter.
|
|
|
|
* Our function _sel_data_cb will receive it as <tt> void *data </tt>.
|
|
|
|
*
|
|
|
|
* 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
|
2012-01-02 03:46:32 -08:00
|
|
|
* elm_object_item_del_cb_set().
|
2011-07-15 14:29:34 -07:00
|
|
|
*
|
|
|
|
* 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
|
2012-03-21 10:57:34 -07:00
|
|
|
* @skipline _del_cb(void
|
2011-07-15 14:29:34 -07:00
|
|
|
* @until }
|
|
|
|
*
|
elementary/menu, ctxpopup, index, segment_control, diskselector, multibuttonentry, toolbar, naviframe, slideshow, hoversel, filpselector - deprecated xxxx_item_del() APIs.
But instead, made to use the elm_object_item_del() APIs
for this, elm_widget_item needed to provide elm_widget_item_del_pre_hook.
SVN revision: 67010
2012-01-09 21:02:11 -08:00
|
|
|
* To delete an item we simple need to call elm_object_item_del() with
|
2011-07-15 14:29:34 -07:00
|
|
|
* a pointer for such item.
|
|
|
|
*
|
|
|
|
* If you need, you can get selected item with
|
|
|
|
* elm_diskselector_selected_item_get(), that will return a pointer for it.
|
|
|
|
*
|
|
|
|
* <b> Unselecting an item: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _unselect_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* To select an item, you should call elm_diskselector_item_selected_set()
|
|
|
|
* passing @c EINA_TRUE, and to unselect it, @c EINA_FALSE.
|
|
|
|
*
|
|
|
|
* If you unselect the selected item, diskselector will automatically select
|
|
|
|
* the first item.
|
|
|
|
*
|
|
|
|
* <b> Printing all items: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _print_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Clearing the diskselector: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _clear_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Selecting the first item: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _select_first_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Selecting the last item: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _select_last_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Selecting the next item: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _select_next_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Selecting the previous item: </b>
|
|
|
|
* @dontinclude diskselector_example_02.c
|
|
|
|
* @skipline _select_prev_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* See the full @ref diskselector_example_02.c "diskselector_example_02.c"
|
|
|
|
* code, whose window should look like this picture:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 14:29:34 -07:00
|
|
|
* @image html screenshots/diskselector_example_02.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/diskselector_example_02.eps width=\textwidth
|
2011-07-15 14:29:34 -07:00
|
|
|
*
|
|
|
|
* @example diskselector_example_02.c
|
|
|
|
*/
|
|
|
|
|
2011-07-25 13:47:59 -07:00
|
|
|
/**
|
|
|
|
* @page list_example_01 List widget example
|
|
|
|
*
|
|
|
|
* This code places a single Elementary list widgets on a window, just
|
|
|
|
* to exemplify the more simple and common use case: a list will be created
|
|
|
|
* and populated with a few items.
|
|
|
|
*
|
|
|
|
* To keep it simple, we won't show how to customize the list, for this check
|
|
|
|
* @ref list_example_02. Also, we won't focus
|
|
|
|
* on items management on this example. For an example about this subject,
|
|
|
|
* check @ref list_example_03.
|
|
|
|
*
|
|
|
|
* To add a list widget.
|
|
|
|
* @dontinclude list_example_01.c
|
|
|
|
* @skipline elm_list_add
|
|
|
|
*
|
|
|
|
* We are just adding the list, so as you can see, defaults for it are:
|
|
|
|
* @li Items are displayed vertically.
|
|
|
|
* @li Only one item can be selected.
|
|
|
|
* @li The list doesn't bouce.
|
|
|
|
*
|
|
|
|
* To add items, we are just appending it on a loop, using function
|
|
|
|
* elm_list_item_append(), that will be better exaplained on
|
|
|
|
* items management example.
|
|
|
|
* @dontinclude list_example_01.c
|
|
|
|
* @skipline lbl[]
|
|
|
|
* @until };
|
|
|
|
* @skipline for
|
|
|
|
* @skipline elm_list_item_append
|
|
|
|
*
|
|
|
|
* After we just want to show the list. But first we need to start the widget.
|
|
|
|
* It was done this way to improve widget's performance. So, always remember
|
|
|
|
* that:
|
|
|
|
* @warning Call elm_list_go before showing the object
|
|
|
|
* @skipline elm_list_go
|
|
|
|
* @skipline show
|
|
|
|
*
|
|
|
|
* See the full @ref list_example_01.c "list_example_01.c"
|
|
|
|
* code, whose window should look like this picture:
|
|
|
|
*
|
|
|
|
* @image html screenshots/list_example_01.png
|
|
|
|
* @image latex screenshots/list_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example list_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page list_example_02 List widget example
|
|
|
|
*
|
|
|
|
* This code places a single Elementary list widgets on a window,
|
|
|
|
* exemplifying a part of the widget's API.
|
|
|
|
*
|
|
|
|
* First, we will just create a simple list, as done on @ref list_example_01 :
|
|
|
|
* @dontinclude list_example_02.c
|
|
|
|
* @skipline lbl
|
|
|
|
* @until }
|
|
|
|
* @skipline elm_list_add
|
|
|
|
* @until elm_list_item_append
|
|
|
|
*
|
|
|
|
* Now, let's customize this list a bit. First we will display items
|
|
|
|
* horizontally:
|
|
|
|
* @skipline horizontal_set
|
|
|
|
*
|
|
|
|
* Then we will choose another list mode. There are four of them, and
|
|
|
|
* the default #Elm_List_Mode is #ELM_LIST_SCROLL. Let's set compress mode:
|
|
|
|
* @skipline mode_set
|
|
|
|
*
|
|
|
|
* To enable multiple items selection, we need to enable it, since only one
|
|
|
|
* selected item is allowed by default:
|
|
|
|
* @skipline elm_list_multi_select_set
|
|
|
|
*
|
|
|
|
* We are not adding items with callback functions here,
|
|
|
|
* 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:
|
2012-03-14 04:13:24 -07:00
|
|
|
* @skipline elm_list_select_mode_set
|
2011-07-25 13:47:59 -07:00
|
|
|
*
|
|
|
|
* Finally, if a bounce effect is required, or you would like to see
|
|
|
|
* scrollbars, it is possible. But, for default theme, list
|
|
|
|
* scrollbars will be invisible anyway.
|
|
|
|
* @skipline bounce_set
|
|
|
|
* @until SCROLLER_POLICY_ON
|
|
|
|
*
|
|
|
|
* See the full @ref list_example_02.c "list_example_02.c"
|
|
|
|
* code, whose window should look like this picture:
|
|
|
|
*
|
|
|
|
* @image html screenshots/list_example_02.png
|
|
|
|
* @image latex screenshots/list_example_02.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example list_example_02.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page list_example_03 List - Items management
|
|
|
|
*
|
|
|
|
* This code places a Elementary list widgets on a window,
|
|
|
|
* along with some buttons trigerring actions on it (though its API).
|
2012-01-11 19:03:56 -08:00
|
|
|
* It covers most of elm_list_item functions.
|
2011-07-25 13:47:59 -07:00
|
|
|
*
|
|
|
|
* On our @c main function, we are adding a default list with
|
|
|
|
* 3 items. We are only setting their labels (second parameter of function
|
|
|
|
* elm_list_item_append):
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline elm_list_add
|
|
|
|
* @until Item 2
|
|
|
|
*
|
|
|
|
* Next we are adding lots of buttons, each one for a callback function
|
|
|
|
* that will realize a task covering part of list items API.
|
|
|
|
* Lets check the first one:
|
|
|
|
* @skipline elm_button_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* We are labeling the button with a task description with
|
|
|
|
* elm_object_text_set() and setting a callback
|
|
|
|
* function evas_object_smart_callback_add().
|
|
|
|
* Each callback function will have the signature:
|
|
|
|
* <tt> static void _task_cb(void *data, Evas_Object *obj,
|
|
|
|
* void *event_info)</tt> with the function name varying for each task.
|
|
|
|
*
|
|
|
|
* Now let's cover all of them.
|
|
|
|
*
|
|
|
|
* <b> Prepending an item: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _prepend_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The item will be placed on the begining of the list,
|
|
|
|
* i.e. it will be the first one.
|
|
|
|
*
|
|
|
|
* The first parameter of elm_list_item_prepend() is the list
|
|
|
|
* object, that we are receiving as data on our callback function.
|
|
|
|
* The second one is a label, the string that will be placed in the center
|
|
|
|
* of our item. As we don't wan't icons or callback functions, we can
|
|
|
|
* send NULL as third, fourth, fifth and sixth parameters.
|
|
|
|
*
|
|
|
|
* <b> Appending an item: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _add_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Items included with append will be inserted inserted after the last one.
|
|
|
|
*
|
|
|
|
* <b> Appending an item with icon: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _add_ic_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* If an icon is required, you can pass it as third paramenter on our
|
|
|
|
* elm_list_item_append() function. It will be place on the
|
|
|
|
* left side of item's label. If an icon is wanted on the right side,
|
|
|
|
* it should be passed as fourth parameter.
|
|
|
|
*
|
|
|
|
* For more details about how to create icons, look for elm_icon examples
|
|
|
|
* @ref tutorial_icon.
|
|
|
|
*
|
|
|
|
* <b> Appending an item with callback function for selected: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _sel_cb
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* To set a callback function that will be called every time an item is
|
|
|
|
* selected, i.e., everytime the list stops with this item in
|
|
|
|
* center position, just pass the function as fifth paramenter.
|
|
|
|
*
|
|
|
|
* <b> Appending an item with callback function for selected with data: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _sel_data_cb
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* If the callback function request an extra data, it can be attached to our
|
|
|
|
* item passing a pointer for data as sixth parameter.
|
|
|
|
* Our function _sel_data_cb will receive it as <tt> void *data </tt>.
|
|
|
|
*
|
|
|
|
* 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
|
2012-03-09 07:03:18 -08:00
|
|
|
* elm_object_item_del_cb_set().
|
2011-07-25 13:47:59 -07:00
|
|
|
*
|
|
|
|
* 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 list_example_03.c
|
|
|
|
* @skipline _del_cb(
|
|
|
|
* @until }
|
|
|
|
*
|
2012-01-29 22:06:03 -08:00
|
|
|
* To delete an item we simple need to call elm_object_item_del() with
|
2011-07-25 13:47:59 -07:00
|
|
|
* a pointer for such item.
|
|
|
|
*
|
|
|
|
* If you need, you can get selected item with
|
|
|
|
* elm_list_selected_item_get(), that will return a pointer for it.
|
|
|
|
*
|
|
|
|
* <b> Unselecting an item: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _unselect_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* To select an item, you should call elm_list_item_selected_set()
|
|
|
|
* passing @c EINA_TRUE, and to unselect it, @c EINA_FALSE.
|
|
|
|
*
|
|
|
|
* <b> Printing all items: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _print_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Clearing the list: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _clear_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Selecting the next item: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _select_next_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Inserting after an item: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _insert_after_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Selecting the previous item: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _select_prev_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* <b> Inserting before an item: </b>
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _insert_before_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* If a separator is required, just set an item as such:
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _set_separator_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Also an item can be disabled, and the user won't be allowed to (un)select it:
|
|
|
|
* @dontinclude list_example_03.c
|
|
|
|
* @skipline _disable_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* See the full @ref list_example_03.c "list_example_03.c"
|
|
|
|
* code, whose window should look like this picture:
|
|
|
|
*
|
|
|
|
* @image html screenshots/list_example_03.png
|
|
|
|
* @image latex screenshots/list_example_03.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example list_example_03.c
|
|
|
|
*/
|
|
|
|
|
2011-08-01 07:51:18 -07:00
|
|
|
/**
|
|
|
|
* @page toolbar_example_01 Toolbar Example - Simple Items
|
|
|
|
*
|
|
|
|
* This code places a Elementary toolbar widget on a window,
|
|
|
|
* to exemplify part of the widget's API.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* Also, we'll need a toolbar widget, obviously:
|
|
|
|
* @skipline elm_toolbar_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* It's possible to disable items, so the user can't select then. We will
|
|
|
|
* disable the third item:
|
|
|
|
* @skipline _item_append
|
|
|
|
* @until disable
|
|
|
|
*
|
|
|
|
* Our callbacks will just set button's label:
|
|
|
|
* @dontinclude toolbar_example_01.c
|
|
|
|
* @skip static
|
|
|
|
* @skip }
|
|
|
|
* @skipline static
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @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
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
2011-12-29 23:20:48 -08:00
|
|
|
* The only difference here is that we set shrink mode to #ELM_TOOLBAR_SHRINK_HIDE,
|
2011-08-01 07:51:18 -07:00
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2011-07-28 14:51:02 -07:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-07-11 14:06:04 -07:00
|
|
|
/**
|
|
|
|
* @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
|
2012-03-21 10:57:34 -07:00
|
|
|
* @until }
|
|
|
|
* @until }
|
2011-07-11 14:06:04 -07:00
|
|
|
* 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
|
2012-03-21 10:57:34 -07:00
|
|
|
* @until }
|
|
|
|
* @until }
|
2011-07-11 14:06:04 -07:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* selector widget.
|
|
|
|
*
|
|
|
|
* See the full @ref flipselector_example.c "example", whose window should
|
|
|
|
* look like this picture:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-11 14:06:04 -07:00
|
|
|
* @image html screenshots/flipselector_example.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/flipselector_example.eps width=\textwidth
|
2011-07-11 14:06:04 -07:00
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* See the full @ref flipselector_example_c "source code" for this example.
|
|
|
|
*
|
2011-07-11 14:06:04 -07:00
|
|
|
* @example flipselector_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-15 07:02:54 -07:00
|
|
|
/**
|
|
|
|
* @page fileselector_example File selector widget example
|
|
|
|
*
|
|
|
|
* This code places two Elementary file selector widgets on a window.
|
|
|
|
* The one on the left is layouting file system items in a @b list,
|
|
|
|
* while the the other is layouting them in a @b grid.
|
|
|
|
*
|
|
|
|
* The one having the majority of hooks of interest is on the left,
|
|
|
|
* which we create as follows:
|
|
|
|
* @dontinclude fileselector_example.c
|
|
|
|
* @skip first file selector
|
|
|
|
* @until object_show
|
|
|
|
*
|
|
|
|
* Note that we enable custom edition of file/directory selection, via
|
|
|
|
* the text entry it has on its bottom, via
|
|
|
|
* elm_fileselector_is_save_set(). It starts with the list view, which
|
|
|
|
* is the default, and we make it not expandable in place
|
|
|
|
* (elm_fileselector_expandable_set()), so that it replaces its view's
|
|
|
|
* contents with the current directory's entries each time one
|
|
|
|
* navigates to a different folder. For both of file selectors we are
|
|
|
|
* starting to list the contents found in the @c "/tmp" directory
|
|
|
|
* (elm_fileselector_path_set()).
|
|
|
|
*
|
|
|
|
* Note the code setting it to "grid mode" and observe the differences
|
|
|
|
* in the file selector's views, in the example. We also hide the
|
|
|
|
* second file selector's Ok/Cancel buttons -- since it's there just
|
|
|
|
* to show the grid view (and navigation) -- via
|
|
|
|
* elm_fileselector_buttons_ok_cancel_set().
|
|
|
|
*
|
|
|
|
* The @c "done" event, which triggers the callback below
|
|
|
|
* @dontinclude fileselector_example.c
|
|
|
|
* @skip 'done' cb
|
|
|
|
* @until }
|
|
|
|
* will be called at the time one clicks the "Ok"/"Cancel" buttons of
|
|
|
|
* the file selector (on the left). Note that it will print the path
|
|
|
|
* to the current selection, if any.
|
|
|
|
*
|
|
|
|
* The @c "selected" event, which triggers the callback below
|
|
|
|
* @dontinclude fileselector_example.c
|
|
|
|
* @skip bt = 'selected' cb
|
|
|
|
* @until }
|
|
|
|
* takes place when one selects a file (if the file selector is @b not
|
|
|
|
* under folders-only mode) or when one selects a folder (when in
|
|
|
|
* folders-only mode). Experiment it by selecting different file
|
|
|
|
* system entries.
|
|
|
|
*
|
|
|
|
* What comes next is the code creating the three check boxes and two
|
|
|
|
* buttons below the file selector in the right. They will exercise a
|
|
|
|
* bunch of functions on the file selector's API, for the instance on
|
|
|
|
* the left. Experiment with them, specially the buttons, to get the
|
|
|
|
* difference between elm_fileselector_path_get() and
|
|
|
|
* elm_fileselector_selected_get().
|
|
|
|
*
|
|
|
|
* Finally, there's the code adding the second file selector, on the
|
|
|
|
* right:
|
|
|
|
* @dontinclude fileselector_example.c
|
|
|
|
* @skip second file selector
|
|
|
|
* @until object_show
|
|
|
|
*
|
|
|
|
* Pay attention to the code setting it to "grid mode" and observe the
|
|
|
|
* differences in the file selector's views, in the example. We also
|
|
|
|
* hide the second file selector's Ok/Cancel buttons -- since it's
|
|
|
|
* there just to show the grid view (and navigation) -- via
|
|
|
|
* elm_fileselector_buttons_ok_cancel_set().
|
|
|
|
*
|
|
|
|
* See the full @ref fileselector_example.c "example", whose window
|
|
|
|
* should look like this picture:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:02:54 -07:00
|
|
|
* @image html screenshots/fileselector_example.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_example.eps width=\textwidth
|
2011-07-15 07:02:54 -07:00
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* See the full @ref fileselector_example_c "source code" for this example.
|
|
|
|
*
|
2011-07-15 07:02:54 -07:00
|
|
|
* @example fileselector_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-15 07:03:08 -07:00
|
|
|
/**
|
|
|
|
* @page fileselector_button_example File selector button widget example
|
|
|
|
*
|
|
|
|
* This code places an Elementary file selector button widget on a
|
|
|
|
* window, along with some other checkboxes and a text entry. Those
|
|
|
|
* are there just as knobs on the file selector button's state and to
|
|
|
|
* display information from it.
|
|
|
|
*
|
|
|
|
* Here's how we instantiate it:
|
|
|
|
* @dontinclude fileselector_button_example.c
|
|
|
|
* @skip ic = elm_icon_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Note that we set on it both icon and label decorations. It's set to
|
|
|
|
* list the contents of the @c "/tmp" directory, too, with
|
|
|
|
* elm_fileselector_button_path_set(). What follows are checkboxes to
|
|
|
|
* exercise some of its API funtions:
|
|
|
|
* @dontinclude fileselector_button_example.c
|
|
|
|
* @skip ck = elm_check_add
|
|
|
|
* @until evas_object_show(en)
|
|
|
|
*
|
|
|
|
* The checkboxes will toggle whether the file selector button's
|
|
|
|
* internal file selector:
|
|
|
|
* - must have an editable text entry for file names (thus, be in
|
|
|
|
* "save dialog mode")
|
|
|
|
* - is to be raised as an "inner window" (note it's the default
|
|
|
|
* behavior) or as a dedicated window
|
|
|
|
* - is to populate its view with folders only
|
|
|
|
* - is to expand its folders, in its view, <b>in place</b>, and not
|
|
|
|
* repainting it entirely just with the contents of a sole
|
|
|
|
* directory.
|
|
|
|
*
|
|
|
|
* The entry labeled @c "Last selection" will exercise the @c
|
|
|
|
* "file,chosen" smart event coming from the file selector button:
|
|
|
|
* @dontinclude fileselector_button_example.c
|
|
|
|
* @skip hook on the
|
|
|
|
* @until toggle inwin
|
|
|
|
*
|
|
|
|
* Whenever you dismiss or acknowledges the file selector, after it's
|
|
|
|
* raised, the @c event_info string will contain the last selection on
|
|
|
|
* it (if any was made).
|
|
|
|
*
|
|
|
|
* This is how the example, just after called, should look like:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:03:08 -07:00
|
|
|
* @image html screenshots/fileselector_button_example_00.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_button_example_00.eps width=\textwidth
|
2011-07-15 07:03:08 -07:00
|
|
|
*
|
|
|
|
* Click on the file selector button to raise its internal file
|
|
|
|
* selector, which will be contained on an <b>"inner window"</b>:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:03:08 -07:00
|
|
|
* @image html screenshots/fileselector_button_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_button_example_01.eps width=\textwidth
|
2011-07-15 07:03:08 -07:00
|
|
|
*
|
|
|
|
* Toggle the "inwin mode" switch off and, if you click on the file
|
|
|
|
* selector button again, you'll get @b two windows, the original one
|
|
|
|
* (note the last selection there!)
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:03:08 -07:00
|
|
|
* @image html screenshots/fileselector_button_example_02.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_button_example_02.eps width=\textwidth
|
|
|
|
*
|
2011-07-15 07:03:08 -07:00
|
|
|
* and the file selector's new one
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:03:08 -07:00
|
|
|
* @image html screenshots/fileselector_button_example_03.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_button_example_03.eps width=\textwidth
|
2011-07-15 07:03:08 -07:00
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* Play with the checkboxes to get the behavior changes on the file
|
|
|
|
* selector button. The respective API calls on the widget coming from
|
|
|
|
* those knobs where shown in the code already.
|
|
|
|
*
|
|
|
|
* See the full @ref fileselector_button_example_c "source code" for
|
|
|
|
* this example.
|
2011-07-15 07:03:08 -07:00
|
|
|
*
|
|
|
|
* @example fileselector_button_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-15 07:03:21 -07:00
|
|
|
/**
|
|
|
|
* @page fileselector_entry_example File selector entry widget example
|
|
|
|
*
|
|
|
|
* This code places an Elementary file selector entry widget on a
|
|
|
|
* window, along with some other checkboxes. Those are there just as
|
|
|
|
* knobs on the file selector entry's state.
|
|
|
|
*
|
|
|
|
* Here's how we instantiate it:
|
|
|
|
* @dontinclude fileselector_entry_example.c
|
|
|
|
* @skip ic = elm_icon_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Note that we set on it's button both icon and label
|
|
|
|
* decorations. It's set to exhibit the path of (and list the contents
|
|
|
|
* of, when internal file selector is launched) the @c "/tmp"
|
|
|
|
* directory, also, with elm_fileselector_entry_path_set(). What
|
|
|
|
* follows are checkboxes to exercise some of its API funtions:
|
|
|
|
* @dontinclude fileselector_entry_example.c
|
|
|
|
* @skip ck = elm_check_add
|
|
|
|
* @until callback_add(fs_entry
|
|
|
|
*
|
|
|
|
* The checkboxes will toggle whether the file selector entry's
|
|
|
|
* internal file selector:
|
|
|
|
* - must have an editable text entry for file names (thus, be in
|
|
|
|
* "save dialog mode")
|
|
|
|
* - is to be raised as an "inner window" (note it's the default
|
|
|
|
* behavior) or as a dedicated window
|
|
|
|
* - is to populate its view with folders only
|
|
|
|
* - is to expand its folders, in its view, <b>in place</b>, and not
|
|
|
|
* repainting it entirely just with the contents of a sole
|
|
|
|
* directory.
|
|
|
|
*
|
|
|
|
* Observe how the entry's text will match the string coming from the
|
|
|
|
* @c "file,chosen" smart event:
|
|
|
|
* @dontinclude fileselector_entry_example.c
|
|
|
|
* @skip hook on the
|
|
|
|
* @until }
|
|
|
|
* Whenever you dismiss or acknowledges the file selector, after it's
|
|
|
|
* raised, the @c event_info string will contain the last selection on
|
|
|
|
* it (if any was made).
|
|
|
|
*
|
|
|
|
* Try, also, to type in a valid system path and, then, open the file
|
|
|
|
* selector's window: it will start the file browsing there, for you.
|
|
|
|
*
|
|
|
|
* This is how the example, just after called, should look like:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* @image html screenshots/fileselector_entry_example_00.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_entry_example_00.eps width=\textwidth
|
2011-07-15 07:03:21 -07:00
|
|
|
*
|
|
|
|
* Click on the file selector entry to raise its internal file
|
|
|
|
* selector, which will be contained on an <b>"inner window"</b>:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* @image html screenshots/fileselector_entry_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_entry_example_01.eps width=\textwidth
|
2011-07-15 07:03:21 -07:00
|
|
|
*
|
|
|
|
* Toggle the "inwin mode" switch off and, if you click on the file
|
|
|
|
* selector entry again, you'll get @b two windows, the original one
|
|
|
|
* (note the last selection there!)
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* @image html screenshots/fileselector_entry_example_02.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_entry_example_02.eps width=\textwidth
|
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* and the file selector's new one
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 07:03:21 -07:00
|
|
|
* @image html screenshots/fileselector_entry_example_03.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/fileselector_entry_example_03.eps width=\textwidth
|
2011-07-15 07:03:21 -07:00
|
|
|
*
|
|
|
|
* Play with the checkboxes to get the behavior changes on the file
|
|
|
|
* selector entry. The respective API calls on the widget coming from
|
|
|
|
* those knobs where shown in the code already.
|
|
|
|
*
|
|
|
|
* See the full @ref fileselector_entry_example_c "source code" for
|
|
|
|
* this example.
|
|
|
|
*
|
|
|
|
* @example fileselector_entry_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-20 13:58:17 -07:00
|
|
|
/**
|
|
|
|
* @page layout_example_01 Layout - Content, Table and Box
|
|
|
|
*
|
|
|
|
* This example shows how one can use the @ref Layout widget to create a
|
|
|
|
* customized distribution of widgets on the screen, controled by an Edje theme.
|
|
|
|
* The full source code for this example can be found at @ref
|
|
|
|
* layout_example_01_c.
|
|
|
|
*
|
|
|
|
* Our custom layout is defined by a file, @ref layout_example_edc, which is an
|
|
|
|
* Edje theme file. Look for the Edje documentation to understand it. For now,
|
|
|
|
* it's enough to know that we describe some specific parts on this layout
|
|
|
|
* theme:
|
|
|
|
* @li a title text field;
|
|
|
|
* @li a box container;
|
|
|
|
* @li a table container;
|
|
|
|
* @li and a content container.
|
|
|
|
*
|
|
|
|
* Going straight to the code, the following snippet instantiates the layout
|
|
|
|
* widget:
|
|
|
|
*
|
|
|
|
* @dontinclude layout_example_01.c
|
|
|
|
* @skip elm_layout_add
|
|
|
|
* @until evas_object_show(layout)
|
|
|
|
*
|
|
|
|
* As any other widget, we set some properties for the size calculation. But
|
|
|
|
* notice on this piece of code the call to the function elm_layout_file_set().
|
|
|
|
* Here is where the theme file is loaded, and particularly the specific group
|
|
|
|
* from this theme file. Also notice that the theme file here is referenced as
|
|
|
|
* an .edj, which is a .edc theme file compiled to its binary form. Again, look
|
|
|
|
* for the Edje documentation for more information about theme files.
|
|
|
|
*
|
|
|
|
* Next, we fetch from our theme a data string referenced by the key "title".
|
|
|
|
* This data was defined in the theme, and can be used as parameters which the
|
|
|
|
* program get from the specific theme that it is using. In this case, we store
|
|
|
|
* the title of this window and program in the theme, as a "data" entry, just
|
|
|
|
* for demonstration purposes:
|
|
|
|
*
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* This call elm_layout_data_get() is used to fetch the string based on the key,
|
2011-11-16 12:17:25 -08:00
|
|
|
* and elm_object_part_text_set() will set the part defined in the theme as
|
2011-07-20 13:58:17 -07:00
|
|
|
* "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
|
|
|
|
* form "example/<something>".
|
|
|
|
*
|
|
|
|
* Now let's start using our layout to distribute things on the window space.
|
|
|
|
* Since the layout was added as a resize object to the elementary window, it
|
|
|
|
* will always occupy the entire space available for this window.
|
|
|
|
*
|
|
|
|
* The theme already has a title, and it also defines a table element which is
|
|
|
|
* positioned approximately between 50% and 70% of the height of this window,
|
|
|
|
* and has 100% of the width. We create some widgets (two icons, a clock and a
|
|
|
|
* button) and pack them inside the table, in a distribution similar to a HTML
|
|
|
|
* table:
|
|
|
|
*
|
|
|
|
* @until evas_object_show(bt)
|
|
|
|
*
|
|
|
|
* Notice that we just set size hints for every object, and call the function
|
|
|
|
* elm_layout_table_pack(), which does all the work. It will place the elements
|
|
|
|
* in the specified row/column, with row and column span if required, and then
|
|
|
|
* the object's size and position will be controled by the layout widget. It
|
|
|
|
* will also respect size hints, alignments and weight properties set to these
|
|
|
|
* widgets. The resulting distribution on the screen depends on the table
|
|
|
|
* properties (described in the theme), the size hints set on each widget, and
|
|
|
|
* on the cells of the table that are being used.
|
|
|
|
*
|
|
|
|
* For instance, we add the two icons and the clock on the first, second and
|
|
|
|
* third cells of the first row, and add the button the second row, making it
|
|
|
|
* span for 3 columns (thus having the size of the entire table width). This
|
|
|
|
* will result in a table that has 2 rows and 3 columns.
|
|
|
|
*
|
|
|
|
* Now let's add some widgets to the box area of our layout. This box is around
|
|
|
|
* 20% and 50% of the vertical size of the layout, and 100% of its width. The
|
|
|
|
* theme defines that it will use an "horizontal flow" distribution to its
|
|
|
|
* elements. Unlike the table, a box will distribute elements without knowing
|
|
|
|
* about rows and columns, and the distribution function selected will take care
|
|
|
|
* of putting them in row, column, both, or any other available layout. This is
|
|
|
|
* also described in the Edje documentation.
|
|
|
|
*
|
|
|
|
* This box area is similar to the @ref Box widget of elementary, with the
|
|
|
|
* difference that its position and properties are controled by the theme of the
|
|
|
|
* layout. It also contains more than one API to add items to it, since the
|
|
|
|
* items position now is defined in terms of a list of items, not a matrix.
|
|
|
|
* There's the first position (can have items added to it with
|
|
|
|
* elm_layout_box_prepend()), the last position (elm_layout_box_append()), the
|
|
|
|
* nth position (elm_layout_box_insert_at()) and the position right before an
|
|
|
|
* element (elm_layout_box_insert_before()). We use insert_at and prepend
|
|
|
|
* functions to add the first two buttons to this box, and insert_before on the
|
|
|
|
* callback of each button. The callback code will be shown later, but it
|
|
|
|
* basically adds a button just before the clicked button using the
|
|
|
|
* elm_layout_box_insert_before() function. Here's the code for adding the first
|
|
|
|
* 2 buttons:
|
|
|
|
*
|
|
|
|
* @until evas_object_show(item)
|
|
|
|
* @until evas_object_show(item)
|
|
|
|
*
|
|
|
|
* 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
|
2011-11-17 13:02:31 -08:00
|
|
|
* 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
|
2011-07-20 13:58:17 -07:00
|
|
|
* 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
|
|
|
|
* the two other parts (deleting all of their elements) and then remove and
|
|
|
|
* delete this button.
|
|
|
|
*
|
|
|
|
* @until _swallow_btn_cb
|
|
|
|
*
|
|
|
|
* 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,
|
2011-11-17 13:02:31 -08:00
|
|
|
* visibility and clipping of a widget added with elm_object_part_content_set().
|
2011-07-20 13:58:17 -07:00
|
|
|
* Again, read the Edje documentation to understand this better.
|
|
|
|
*
|
|
|
|
* Now we just put the code for the different callbacks specified for each kind
|
|
|
|
* of button and make simple comments about them:
|
|
|
|
*
|
|
|
|
* @dontinclude layout_example_01.c
|
|
|
|
* @skip static void
|
|
|
|
* @until evas_object_del(item)
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The first callback is used for the button in the table, and will just remove
|
|
|
|
* itself from the table with elm_layout_table_unpack(), which remove items
|
|
|
|
* without deleting them, and then calling evas_object_del() on itself.
|
|
|
|
*
|
|
|
|
* The second callback is for buttons added to the box. When clicked, these
|
|
|
|
* buttons will create a new button, and add them to the same box, in the
|
|
|
|
* position just before the clicked button.
|
|
|
|
*
|
|
|
|
* And the last callback is for the button added to the "content" area. It will
|
|
|
|
* clear both the table and the box, passing @c EINA_TRUE to their respective @c
|
|
|
|
* clear parameters, which will imply on the items of these containers being
|
|
|
|
* deleted.
|
|
|
|
*
|
|
|
|
* A screenshot of this example can be seen on:
|
|
|
|
*
|
|
|
|
* @image html screenshots/layout_example_01.png
|
|
|
|
* @image latex screenshots/layout_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page layout_example_02 Layout - Predefined Layout
|
|
|
|
*
|
|
|
|
* This example shows how one can use the @ref Layout with a predefined theme
|
|
|
|
* layout to add a back and next button to a simple window. The full source code
|
|
|
|
* for this example can be found at @ref layout_example_02_c.
|
|
|
|
*
|
|
|
|
* After setting up the window and background, we add the layout widget to the
|
|
|
|
* window. But instead of using elm_layout_file_set() to load its theme from a
|
|
|
|
* custom theme file, we can use elm_layout_theme_set() to load one of the
|
|
|
|
* predefined layouts that come with elementary. Particularly on this example,
|
|
|
|
* we load the them of class "layout", group "application" and style
|
|
|
|
* "content-back-next" (since we want the back and next buttons).
|
|
|
|
*
|
|
|
|
* @dontinclude layout_example_02.c
|
|
|
|
* @skip elm_layout_add
|
|
|
|
* @until evas_object_show(layout)
|
|
|
|
*
|
|
|
|
* This default theme contains only a "content" area named
|
|
|
|
* "elm.swallow.content", where we can add any widget (it can be even a
|
|
|
|
* container widget, like a box, frame, list, or even another layout). Since we
|
|
|
|
* just want to show the resulting layout, we add a simple icon to it:
|
|
|
|
*
|
|
|
|
* @until layout_content_set
|
|
|
|
*
|
|
|
|
* This default layout also provides some signals when the next and prev buttons
|
|
|
|
* are clicked. We can register callbacks to them with the
|
|
|
|
* elm_object_signal_callback_add() function:
|
|
|
|
*
|
|
|
|
* @until elm,action,next
|
|
|
|
*
|
|
|
|
* In the @ref layout_example_03 you can see how to send signals to the layout with
|
|
|
|
* elm_object_signal_emit().
|
|
|
|
*
|
|
|
|
* Now our callback just changes the picture being displayed when one of the
|
|
|
|
* buttons are clicked:
|
|
|
|
*
|
|
|
|
* @dontinclude layout_example_02.c
|
|
|
|
* @skip images
|
|
|
|
* @until standard_set
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* It's possible to see that it gets the name of the image being shown from the
|
|
|
|
* array of image names, going forward on this array when "next" is clicked and
|
|
|
|
* backward when "back" is clicked.
|
|
|
|
*
|
|
|
|
* A screenshot of this example can be seen on:
|
|
|
|
*
|
|
|
|
* @image html screenshots/layout_example_02.png
|
|
|
|
* @image latex screenshots/layout_example_02.eps width=\textwidth
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page layout_example_03 Layout - Signals and Size Changed
|
|
|
|
*
|
|
|
|
* This example shows how one can send and receive signals to/from the layout,
|
|
|
|
* and what to do when the layout theme has its size changed. The full source
|
|
|
|
* code for this example can be found at @ref layout_example_03_c.
|
|
|
|
*
|
|
|
|
* In this exmaple we will use another group from the same layout theme file
|
|
|
|
* used in @ref layout_example_01. Its instanciation and loading happens in the
|
|
|
|
* following lines:
|
|
|
|
*
|
|
|
|
* @dontinclude layout_example_03.c
|
|
|
|
* @skip elm_layout_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* This time we register a callback to be called whenever we receive a signal
|
|
|
|
* after the end of the animation that happens in this layout:
|
|
|
|
*
|
|
|
|
* @until signal_callback_add
|
|
|
|
*
|
|
|
|
* We also add a button that will send signals to the layout:
|
|
|
|
*
|
|
|
|
* @until callback_add
|
|
|
|
*
|
|
|
|
* The callback for this button will check what type of signal it should send,
|
|
|
|
* and then emit it. The code for this callback follows:
|
|
|
|
*
|
2011-08-03 12:07:43 -07:00
|
|
|
* @dontinclude layout_example_03.c
|
2011-07-20 13:58:17 -07:00
|
|
|
* @skip static Eina_Bool
|
|
|
|
* @until Enlarge
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* As we said before, we are receiving a signal whenever the animation started
|
|
|
|
* by the button click ends. This is the callback for that signal:
|
|
|
|
*
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Notice from this callback that the elm_layout_sizing_eval() function must be
|
|
|
|
* called if we want our widget to update its size after the layout theme having
|
|
|
|
* changed its minimum size. This happens because the animation specified in the
|
|
|
|
* theme increases the size of the content area to a value higher than the
|
|
|
|
* widget size, thus requiring more space. But the elementary layout widget
|
|
|
|
* has no way to know this, thus needing the elm_layout_sizing_eval() to
|
|
|
|
* be called on the layout, informing that this size has changed.
|
|
|
|
*
|
|
|
|
* A screenshot of this example can be seen on:
|
|
|
|
*
|
|
|
|
* @image html screenshots/layout_example_03.png
|
|
|
|
* @image latex screenshots/layout_example_03.eps width=\textwidth
|
|
|
|
*/
|
|
|
|
|
2011-07-14 07:37:53 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_hover Hover example
|
|
|
|
* @dontinclude hover_example_01.c
|
|
|
|
*
|
|
|
|
* On this example we are going to have a button that when clicked will show our
|
|
|
|
* hover widget, this hover will have content set on it's left, top, right and
|
|
|
|
* middle positions. In the middle position we are placing a button that when
|
|
|
|
* clicked will hide the hover. We are also going to use a non-default theme
|
|
|
|
* for our hover. We won't explain the functioning of button for that see @ref
|
|
|
|
* Button.
|
|
|
|
*
|
|
|
|
* We start our example with a couple of callbacks that show and hide the data
|
|
|
|
* they're given(which we'll see later on is the hover widget):
|
|
|
|
* @skip static
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* In our main function we'll do some initialization and then create 3
|
|
|
|
* rectangles, one red, one green and one blue to use in our hover. We'll also
|
|
|
|
* create the 2 buttons that will show and hide the hover:
|
|
|
|
* @until show(bt2)
|
|
|
|
*
|
|
|
|
* With all of that squared away we can now get to the heart of the matter,
|
|
|
|
* creating our hover widget, which is easy as pie:
|
|
|
|
* @until hover
|
|
|
|
*
|
|
|
|
* Having created our hover we now need to set the parent and target. Which if
|
|
|
|
* you recall from the function documentations are going to tell the hover which
|
|
|
|
* area it should cover and where it should be centered:
|
|
|
|
* @until bt
|
|
|
|
*
|
|
|
|
* Now we set the theme for our hover. We're using the popout theme which gives
|
|
|
|
* our contents a white background and causes their appearance to be animated:
|
|
|
|
* @until popout
|
|
|
|
*
|
|
|
|
* And finally we set the content for our positions:
|
|
|
|
* @until bt2
|
|
|
|
*
|
|
|
|
* So far so good? Great 'cause that's all there is too it, what is left now is
|
|
|
|
* just connecting our buttons to the callbacks we defined at the beginning of
|
|
|
|
* the example and run the main loop:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* Our example will initially look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-14 07:37:53 -07:00
|
|
|
* @image html screenshots/hover_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/hover_example_01.eps width=\textwidth
|
2011-07-14 07:37:53 -07:00
|
|
|
*
|
|
|
|
* And after you click the "Show hover" button it will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-14 07:37:53 -07:00
|
|
|
* @image html screenshots/hover_example_01_a.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/hover_example_01_a.eps width=\textwidth
|
2011-07-14 07:37:53 -07:00
|
|
|
*
|
|
|
|
* @example hover_example_01.c
|
|
|
|
*/
|
|
|
|
|
2012-03-21 10:57:31 -07:00
|
|
|
/**
|
|
|
|
* @page glview_01_example_page - GLView Example
|
|
|
|
* @include glview_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-13 11:11:41 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_flip Flip example
|
|
|
|
* @dontinclude flip_example_01.c
|
|
|
|
*
|
|
|
|
* This example will show a flip with two rectangles on it(one blue, one
|
|
|
|
* 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
|
2011-08-03 12:07:43 -07:00
|
|
|
* like to know more about radio buttons see @ref Radio.
|
2011-07-13 11:11:41 -07:00
|
|
|
*
|
|
|
|
* We start our example with the usual setup and then create the 2 rectangles
|
|
|
|
* we will use in our flip:
|
|
|
|
* @until show(rect2)
|
|
|
|
*
|
|
|
|
* The next thing to do is to create our flip and set it's front and back
|
|
|
|
* content:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* The next thing we do is set the interaction mode(which the user can later
|
|
|
|
* change) to the page animation:
|
|
|
|
* @until PAGE
|
|
|
|
*
|
|
|
|
* Setting a interaction mode however is not sufficient, we also need to
|
|
|
|
* choose which directions we allow interaction from, for this example we
|
|
|
|
* will use all of them:
|
|
|
|
* @until RIGHT
|
|
|
|
*
|
|
|
|
* We are also going to set the hitsize to the entire flip(in all directions)
|
|
|
|
* to make our flip very easy to interact with:
|
|
|
|
* @until RIGHT
|
|
|
|
*
|
|
|
|
* After that we create our radio buttons and start the main loop:
|
|
|
|
* @until ELM_MAIN()
|
|
|
|
*
|
|
|
|
* When the user clicks a radio button a function that changes the
|
|
|
|
* interaction mode and animates the flip is called:
|
|
|
|
* @until }
|
|
|
|
* @note The elm_flip_go() call here serves no purpose other than to
|
|
|
|
* ilustrate that it's possible to animate the flip programmatically.
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-13 11:11:41 -07:00
|
|
|
* @image html screenshots/flip_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/flip_example_01.eps width=\textwidth
|
|
|
|
*
|
2011-07-13 11:11:41 -07:00
|
|
|
* @note Since this is an animated example the screenshot doesn't do it
|
|
|
|
* justice, it is a good idea to compile it and see the animations.
|
|
|
|
*
|
|
|
|
* @example flip_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-13 11:12:04 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_label Label example
|
|
|
|
* @dontinclude label_example_01.c
|
|
|
|
*
|
|
|
|
* In this example we are going to create 6 labels, set some properties on
|
|
|
|
* them and see what changes in appearance those properties cause.
|
|
|
|
*
|
|
|
|
* We start with the setup code that by now you should be familiar with:
|
|
|
|
* @until show(bg)
|
|
|
|
*
|
|
|
|
* For our first label we have a moderately long text(that doesn't fit in the
|
|
|
|
* label's width) so we will make it a sliding label. Since the text isn't
|
|
|
|
* too long we don't need the animation to be very long, 3 seconds should
|
|
|
|
* give us a nice speed:
|
|
|
|
* @until show(label
|
|
|
|
*
|
|
|
|
* For our second label we have the same text, but this time we aren't going
|
|
|
|
* to have it slide, we're going to ellipsize it. Because we ask our label
|
|
|
|
* widget to ellipsize the text it will first diminsh the fontsize so that it
|
|
|
|
* can show as much of the text as possible:
|
|
|
|
* @until show(label
|
|
|
|
*
|
|
|
|
* For the third label we are going to ellipsize the text again, however this
|
|
|
|
* time to make sure the fontsize isn't diminshed we will set a line wrap.
|
|
|
|
* The wrap won't actually cause a line break because we set the label to
|
|
|
|
* ellipsize:
|
|
|
|
* @until show(label
|
|
|
|
*
|
|
|
|
* For our fourth label we will set line wrapping but won't set ellipsis, so
|
|
|
|
* that our text will indeed be wrapped instead of ellipsized. For this label
|
|
|
|
* we choose character wrap:
|
|
|
|
* @until show(label
|
|
|
|
*
|
|
|
|
* Just two more, for our fifth label we do the same as for the fourth
|
|
|
|
* except we set the wrap to word:
|
|
|
|
* @until show(label
|
|
|
|
*
|
|
|
|
* And last but not least for our sixth label we set the style to "marker" and
|
|
|
|
* the color to red(the default color is white which would be hard to see on
|
|
|
|
* our white background):
|
|
|
|
* @until show(label
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-13 11:12:04 -07:00
|
|
|
* @image html screenshots/label_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/label_example_01.eps width=\textwidth
|
2011-07-13 11:12:04 -07:00
|
|
|
*
|
|
|
|
* @example label_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-14 13:48:00 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_image Image example
|
|
|
|
* @dontinclude image_example_01.c
|
|
|
|
*
|
|
|
|
* This example is as simple as possible. An image object will be added to the
|
2011-08-14 00:47:29 -07:00
|
|
|
* window over a white background, and set to be resizable together with the
|
2011-07-14 13:48:00 -07:00
|
|
|
* window. All the options set through the example will affect the behavior of
|
|
|
|
* this image.
|
|
|
|
*
|
|
|
|
* We start with the code for creating a window and its background, and also
|
|
|
|
* add the code to write the path to the image that will be loaded:
|
|
|
|
*
|
|
|
|
* @skip int
|
|
|
|
* @until snprintf
|
|
|
|
*
|
|
|
|
* Now we create the image object, and set that file to be loaded:
|
|
|
|
*
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* We can now go setting our options.
|
|
|
|
*
|
|
|
|
* 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).
|
|
|
|
*
|
2012-03-05 07:10:59 -08:00
|
|
|
* elm_image_resizable_set() is used to allow the image to be resized to a size
|
2011-07-14 13:48:00 -07:00
|
|
|
* 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
|
|
|
|
* algorithm used to scale the image to the new object size is going to be
|
|
|
|
* faster, but with a lower quality.
|
|
|
|
*
|
|
|
|
* elm_image_orient_set() is used to flip the image around the (1, 0) (0, 1)
|
|
|
|
* diagonal.
|
|
|
|
*
|
2012-01-05 21:55:51 -08:00
|
|
|
* elm_image_aspect_fixed_set() is used to keep the original aspect
|
2011-07-14 13:48:00 -07:00
|
|
|
* 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
|
|
|
|
* entire area available to it, even if keeping the aspect ratio. The image
|
|
|
|
* will overflow its width or height (any of them that is necessary) to the
|
|
|
|
* object area, instead of resizing the image down until it can fit entirely in
|
|
|
|
* this area.
|
|
|
|
*
|
|
|
|
* elm_image_editable_set() is used just to cover the API, but won't affect
|
|
|
|
* this example since we are not using any copy & paste property.
|
|
|
|
*
|
|
|
|
* This is the code for setting these options:
|
|
|
|
*
|
|
|
|
* @until editable
|
|
|
|
*
|
|
|
|
* Now some last touches in our object size hints, window and background, to
|
|
|
|
* display this image properly:
|
|
|
|
*
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* This example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/image_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/image_example_01.eps width=\textwidth
|
2011-07-14 13:48:00 -07:00
|
|
|
*
|
|
|
|
* @example image_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-18 11:08:39 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_icon Icon example
|
|
|
|
* @dontinclude icon_example_01.c
|
|
|
|
*
|
|
|
|
* This example is as simple as possible. An icon object will be added to the
|
2011-08-14 00:47:29 -07:00
|
|
|
* window over a white background, and set to be resizable together with the
|
2011-07-18 11:08:39 -07:00
|
|
|
* window. All the options set through the example will affect the behavior of
|
|
|
|
* this icon.
|
|
|
|
*
|
|
|
|
* We start with the code for creating a window and its background:
|
|
|
|
*
|
|
|
|
* @skip int
|
|
|
|
* @until show(bg)
|
|
|
|
*
|
|
|
|
* Now we create the icon object, and set lookup order of the icon, and choose
|
|
|
|
* the "home" icon:
|
|
|
|
*
|
|
|
|
* @until home
|
|
|
|
*
|
|
|
|
* An intersting thing is that after setting this, it's possible to check where
|
|
|
|
* in the filesystem is the theme used by this icon, and the name of the group
|
|
|
|
* used:
|
|
|
|
*
|
|
|
|
* @until printf
|
|
|
|
*
|
|
|
|
* We can now go setting our options.
|
|
|
|
*
|
|
|
|
* 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).
|
|
|
|
*
|
2012-03-05 07:10:59 -08:00
|
|
|
* elm_icon_resizable_set() is used to allow the icon to be resized to a size
|
2011-07-18 11:08:39 -07:00
|
|
|
* 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
|
|
|
|
* algorithm used to scale the icon to the new object size is going to be
|
|
|
|
* faster, but with a lower quality.
|
|
|
|
*
|
|
|
|
* elm_icon_fill_outside_set() is used to ensure that the icon will fill the
|
|
|
|
* entire area available to it, even if keeping the aspect ratio. The icon
|
|
|
|
* will overflow its width or height (any of them that is necessary) to the
|
|
|
|
* object area, instead of resizing the icon down until it can fit entirely in
|
|
|
|
* this area.
|
|
|
|
*
|
|
|
|
* This is the code for setting these options:
|
|
|
|
*
|
|
|
|
* @until fill_outside
|
|
|
|
*
|
|
|
|
* However, if you try this example you may notice that this image is not being
|
|
|
|
* affected by all of these options. This happens because the used icon will be
|
|
|
|
* from elementary theme, and thus it has its own set of options like smooth
|
|
|
|
* scaling and fill_outside options. You can change the "home" icon to use some
|
|
|
|
* image (from your system) and see that then those options will be respected.
|
|
|
|
*
|
|
|
|
* Now some last touches in our object size hints, window and background, to
|
|
|
|
* display this icon properly:
|
|
|
|
*
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* This example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/icon_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/icon_example_01.eps width=\textwidth
|
2011-07-18 11:08:39 -07:00
|
|
|
*
|
|
|
|
* @example icon_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-15 06:54:39 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_hoversel Hoversel example
|
|
|
|
* @dontinclude hoversel_example_01.c
|
|
|
|
*
|
|
|
|
* In this example we will create a hoversel with 3 items, one with a label but
|
|
|
|
* no icon and two with both a label and an icon. Every item that is clicked
|
|
|
|
* will be deleted, but everytime the hoversel is activated we will also add an
|
|
|
|
* item. In addition our first item will print all items when clicked and our
|
|
|
|
* third item will clear all items in the hoversel.
|
|
|
|
*
|
|
|
|
* We will start with the normal creation of window stuff:
|
|
|
|
* @until show(bg)
|
|
|
|
*
|
|
|
|
* Next we will create a red rectangle to use as the icon of our hoversel:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* And now we create our hoversel and set some of it's properties. We set @p win
|
|
|
|
* as its parent, ask it to not be horizontal(be vertical) and give it a label
|
|
|
|
* and icon:
|
2012-03-14 10:20:15 -07:00
|
|
|
* @until "icon", rect)
|
2011-07-15 06:54:39 -07:00
|
|
|
*
|
|
|
|
* Next we will add our three items, setting a callback to be called for the
|
|
|
|
* first and third:
|
|
|
|
* @until _rm_items
|
|
|
|
*
|
|
|
|
* We also set a pair of callbacks to be called whenever any item is selected or
|
|
|
|
* when the hoversel is activated:
|
|
|
|
* @until clicked
|
|
|
|
*
|
|
|
|
* And then ask that our hoversel be shown and run the main loop:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* We now have the callback for our first item which prints all items in the
|
|
|
|
* hoversel:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Next we have the callback for our third item which removes all items from the
|
|
|
|
* hoversel:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Next we have the callback that is called whenever an item is clicked and
|
|
|
|
* deletes that item:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And the callback that is called when the hoversel is activated and adds an
|
|
|
|
* item to the hoversel. Note that since we allocate memory for the item we need
|
|
|
|
* to know when the item dies so we can free that memory:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And finally the callback that frees the memory we allocated for items created
|
|
|
|
* in the @p _add_item callback:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Our example will initially look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 06:54:39 -07:00
|
|
|
* @image html screenshots/hoversel_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/hoversel_example_01.eps width=\textwidth
|
2011-07-15 06:54:39 -07:00
|
|
|
*
|
|
|
|
* And when the hoversel is clicked it will look like this:
|
2011-07-18 15:11:49 -07:00
|
|
|
*
|
2011-07-15 06:54:39 -07:00
|
|
|
* @image html screenshots/hoversel_example_01_a.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/hoversel_example_01_a.eps width=\textwidth
|
2011-07-15 06:54:39 -07:00
|
|
|
*
|
|
|
|
* @example hoversel_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-18 07:00:36 -07:00
|
|
|
/**
|
|
|
|
* @page conformant_example Conformant Example.
|
|
|
|
*
|
|
|
|
* In this example we'll explain how to create applications to work
|
2011-07-22 08:14:11 -07:00
|
|
|
* with illume, considering space required for virtual keyboards, indicator
|
|
|
|
* and softkeys.
|
2011-07-18 07:00:36 -07:00
|
|
|
*
|
|
|
|
* Illume is a module for Enlightenment that modifies the user interface
|
|
|
|
* to work cleanly and nicely on a mobile device. It has support for
|
|
|
|
* virtual keyboard, among other nice features.
|
|
|
|
*
|
|
|
|
* Let's start creating a very simple window with a vertical box
|
|
|
|
* with multi-line entry between two buttons.
|
|
|
|
* This entry will expand filling all space on window not used by buttons.
|
|
|
|
*
|
|
|
|
* @dontinclude conformant_example_01.c
|
|
|
|
* @skipline elm_main
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* For information about how to create windows, boxes, buttons or entries,
|
|
|
|
* look for documentation for these widgets.
|
|
|
|
*
|
|
|
|
* It will looks fine when you don't need a virtual keyboard, as you
|
|
|
|
* can see on the following image:
|
|
|
|
*
|
|
|
|
* @image html screenshots/conformant_example_01.png
|
2011-07-18 15:11:49 -07:00
|
|
|
* @image latex screenshots/conformant_example_01.eps width=\textwidth
|
2011-07-18 07:00:36 -07:00
|
|
|
*
|
|
|
|
* But if you call a virtual keyboard, the window will resize, changing
|
|
|
|
* widgets size and position. All the content will shrink.
|
|
|
|
*
|
|
|
|
* If you don't want such behaviour, you
|
|
|
|
* will need a conformant to account for space taken up by the indicator,
|
2011-07-22 08:14:11 -07:00
|
|
|
* virtual keyboard and softkey.
|
2011-07-18 07:00:36 -07:00
|
|
|
*
|
|
|
|
* In this case, using the conformant in a proper way, you will have
|
2011-07-22 08:14:11 -07:00
|
|
|
* a window like the following:
|
2011-07-18 07:00:36 -07:00
|
|
|
*
|
2011-07-22 08:14:11 -07:00
|
|
|
* @image html screenshots/conformant_example_02.png
|
|
|
|
* @image latex screenshots/conformant_example_02.eps width=\textwidth
|
2011-07-18 07:00:36 -07:00
|
|
|
*
|
2011-07-22 08:14:11 -07:00
|
|
|
* As you can see, it guess the space that will be required by the keyboard,
|
|
|
|
* indicator and softkey bars.
|
2011-07-18 07:00:36 -07:00
|
|
|
*
|
|
|
|
* So, let's study each step required to transform our initial example on
|
|
|
|
* the second one.
|
|
|
|
*
|
|
|
|
* First of all, we need to set the window as an illume conformant window:
|
|
|
|
* @dontinclude conformant_example_02.c
|
|
|
|
* @skipline elm_win_conformant_set
|
|
|
|
*
|
|
|
|
* Next, we'll add a conformant widget, and set it to resize with the window,
|
|
|
|
* instead of the box.
|
|
|
|
* @skipline conform
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Finally, we'll set the box as conformant's content, just like this:
|
2011-10-28 02:36:50 -07:00
|
|
|
* @skipline elm_object_content_set
|
2011-07-18 07:00:36 -07:00
|
|
|
*
|
|
|
|
* Compare both examples code:
|
|
|
|
* @ref conformant_example_01.c "conformant_example_01.c"
|
|
|
|
* @ref conformant_example_02.c "conformant_example_02.c"
|
|
|
|
*
|
|
|
|
* @example conformant_example_01.c
|
|
|
|
* @example conformant_example_02.c
|
|
|
|
*/
|
|
|
|
|
2011-07-20 09:28:12 -07:00
|
|
|
/**
|
|
|
|
* @page index_example_01 Index widget example 1
|
|
|
|
*
|
|
|
|
* This code places an Elementary index widget on a window, which also
|
|
|
|
* has a very long list of arbitrary strings on it. The list is
|
|
|
|
* sorted alphabetically and the index will be used to index the first
|
|
|
|
* items of each set of strings beginning with an alphabet letter.
|
|
|
|
*
|
|
|
|
* Below the list are some buttons, which are there just to exercise
|
|
|
|
* some index widget's API.
|
|
|
|
*
|
|
|
|
* Here's how we instantiate it:
|
|
|
|
* @dontinclude index_example_01.c
|
|
|
|
* @skip elm_list_add
|
|
|
|
* @until evas_object_show(d.index)
|
|
|
|
* where we're showing also the list being created. Note that we issue
|
|
|
|
* elm_win_resize_object_add() on the index, so that it's set to have
|
|
|
|
* the whole window as its container. Then, we have to populate both
|
|
|
|
* list and index widgets:
|
|
|
|
* @dontinclude index_example_01.c
|
|
|
|
* @skip for (i = 0; i < (sizeof(dict) / sizeof(dict[0])); i++)
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The strings populating the list come from a file
|
|
|
|
* @dontinclude index_example_01.c
|
|
|
|
* @skip static const char *dict
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* We use the @c curr char variable to hold the last initial letter
|
|
|
|
* seen on that ordered list of strings, so that we're able to have an
|
|
|
|
* index item pointing to each list item starting a new letter
|
|
|
|
* "section". Note that our index item data pointers will be the list
|
|
|
|
* item handles. We are also setting a callback function to index
|
|
|
|
* items deletion events:
|
|
|
|
* @dontinclude index_example_01.c
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* There, we show you that the @c event_info pointer will contain the
|
|
|
|
* item in question's data, i.e., a given list item's pointer. Because
|
|
|
|
* item data is also returned in the @c data argument on
|
|
|
|
* @c Evas_Smart_Cb functions, those two pointers must have the same
|
|
|
|
* values. On this deletion callback, we're deleting the referred list
|
|
|
|
* item too, just to exemplify that anything could be done there.
|
|
|
|
*
|
|
|
|
* Next, we hook to two smart events of the index object:
|
|
|
|
* @dontinclude index_example_01.c
|
|
|
|
* @skip smart_callback_add(d.index
|
|
|
|
* @until _index_selected
|
|
|
|
* @dontinclude index_example_01.c
|
|
|
|
* @skip "delay,changed" hook
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Check that, whenever one holds the mouse pressed over a given index
|
|
|
|
* letter for some time, the list beneath it will roll down to the
|
|
|
|
* item pointed to by that index item. When one releases the mouse
|
|
|
|
* button, the second callback takes place. There, we check that the
|
|
|
|
* reported item data, on @c event_info, is the same reported by
|
2012-03-12 18:51:46 -07:00
|
|
|
* elm_index_selected_item_get(), which gives the last selection's
|
2011-07-20 09:28:12 -07:00
|
|
|
* data on the index widget.
|
|
|
|
*
|
|
|
|
* The first of the three buttons that follow will call
|
2012-03-12 03:00:17 -07:00
|
|
|
* elm_index_autohide_disabled_set(), thus showing the index automatically for
|
2011-07-20 09:28:12 -07:00
|
|
|
* you, if it's not already visible, what is checked with
|
2012-03-12 03:00:17 -07:00
|
|
|
* elm_index_autohide_disabled_get(). The second button will exercise @b deletion
|
2011-07-20 09:28:12 -07:00
|
|
|
* 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
|
2011-12-29 20:57:28 -08:00
|
|
|
* respective index item handle(#Elm_Object_Item) with elm_index_item_find().
|
|
|
|
* We need the latter to query the indexing letter string from, with
|
2011-07-20 09:28:12 -07:00
|
|
|
* elm_index_item_letter_get(). Next, comes the delition, itself,
|
|
|
|
* which will also trigger the @c _index_item_del callback function,
|
|
|
|
* as said above.
|
|
|
|
*
|
|
|
|
* The third button, finally, will exercise elm_index_item_clear(),
|
|
|
|
* which will delete @b all of the index's items.
|
|
|
|
*
|
|
|
|
* This is how the example program's window looks like with the index
|
|
|
|
* widget hidden:
|
|
|
|
* @image html screenshots/index_example_00.png
|
|
|
|
* @image latex screenshots/index_example_00.eps
|
|
|
|
*
|
|
|
|
* When it's shown, it's like the following figure:
|
|
|
|
* @image html screenshots/index_example_01.png
|
|
|
|
* @image latex screenshots/index_example_01.eps
|
|
|
|
*
|
|
|
|
* See the full @ref index_example_01_c "source code" for
|
|
|
|
* this example.
|
|
|
|
*
|
|
|
|
* @example index_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page index_example_02 Index widget example 2
|
|
|
|
*
|
|
|
|
* This code places an Elementary index widget on a window, indexing
|
|
|
|
* grid items. The items are placed so that their labels @b don't
|
|
|
|
* follow any order, but the index itself is ordered (through
|
|
|
|
* elm_index_item_sorted_insert()). This is a complement to to @ref
|
|
|
|
* index_example_01 "the first example on indexes".
|
|
|
|
*
|
|
|
|
* Here's the list of item labels to be used on the grid (in that
|
|
|
|
* order):
|
|
|
|
* @dontinclude index_example_02.c
|
|
|
|
* @skip static const char *items
|
|
|
|
* @until };
|
|
|
|
*
|
|
|
|
* In the interesting part of the code, here, we first instantiate the
|
|
|
|
* grid (more on grids on their examples) and, after creating our
|
|
|
|
* index, for each grid item we also create an index one to reference
|
|
|
|
* it:
|
|
|
|
* @dontinclude index_example_02.c
|
|
|
|
* @skip grid = elm_gengrid_add
|
|
|
|
* @until }
|
|
|
|
* @until smart_callback_add
|
|
|
|
*
|
|
|
|
* The order in which they'll appear in the index, though, is @b
|
|
|
|
* alphabetical, becase of elm_index_item_sorted_insert() usage
|
|
|
|
* together with the comparing function, where we take the letters of
|
|
|
|
* each index item to base our ordering on. The parameters on
|
|
|
|
* @c _index_cmp have to be declared as void pointers because of the
|
|
|
|
* @c Eina_Compare_Cb prototype requisition, but in this case we know
|
2011-12-29 20:57:28 -08:00
|
|
|
* they'll be index item(#Elm_Object_Item)'s:
|
2011-07-20 09:28:12 -07:00
|
|
|
* @dontinclude index_example_02.c
|
|
|
|
* @skip ordering alphabetically
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The last interesting bit is the callback in the @c "delay,changed"
|
|
|
|
* smart event, which will bring the given grid item to the grid's
|
|
|
|
* visible area:
|
|
|
|
* @dontinclude index_example_02.c
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Note how the grid will move kind of randomly while you move your
|
|
|
|
* mouse pointer held over the index from top to bottom -- that's
|
|
|
|
* because of the the random order the items have in the grid itself.
|
|
|
|
*
|
|
|
|
* This is how the example program's window looks like:
|
|
|
|
* @image html screenshots/index_example_03.png
|
|
|
|
* @image latex screenshots/index_example_03.eps
|
|
|
|
*
|
2011-08-03 12:07:43 -07:00
|
|
|
* See the full @ref index_example.c "source code" for
|
2011-07-20 09:28:12 -07:00
|
|
|
* this example.
|
|
|
|
*
|
|
|
|
* @example index_example_02.c
|
|
|
|
*/
|
|
|
|
|
2011-07-21 07:09:10 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_ctxpopup Ctxpopup example
|
|
|
|
* @dontinclude ctxpopup_example_01.c
|
|
|
|
*
|
|
|
|
* In this example we have a list with two items, when either item is clicked
|
|
|
|
* a ctxpopup for it will be shown. Our two ctxpopups are quite different, the
|
|
|
|
* one for the first item is a vertical and it's items contain both labels and
|
|
|
|
* icons, the one for the second item is horizontal and it's items have icons
|
|
|
|
* but not labels.
|
|
|
|
*
|
|
|
|
* We will begin examining our example code by looking at the callback we'll use
|
|
|
|
* when items in the ctxpopup are clicked. It's very simple, all it does is
|
|
|
|
* print the label present in the ctxpopup item:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Next we examine a function that creates ctxpopup items, it was created to
|
|
|
|
* avoid repeating the same code whenever we needed to add an item to our
|
|
|
|
* ctxpopup. Our function creates an icon from the standard set of icons, and
|
|
|
|
* then creates the item, with the label received as an argument. We also set
|
|
|
|
* the callback to be called when the item is clicked:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Finally we have the function that will create the ctxpopup for the first item
|
|
|
|
* in our list. This one is somewhat more complex though, so let's go through it
|
|
|
|
* in parts. First we declare our variable and add the ctxpopup:
|
|
|
|
* @until ctxpopup_add
|
|
|
|
*
|
|
|
|
* Next we create a bunch of items for our ctxpopup, marking two of them as
|
|
|
|
* disabled just so we can see what that will look like:
|
|
|
|
* @until disabled_set
|
|
|
|
* @until disabled_set
|
|
|
|
*
|
|
|
|
* Then we ask evas where the mouse pointer was so that we can have our ctxpopup
|
|
|
|
* appear in the right place, set a maximum size for the ctxpopup, move it and
|
|
|
|
* show it:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* And last we mark the list item as not selected:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Our next function is the callback that will create the ctxpopup for the
|
|
|
|
* second list item, it is very similar to the previous function. A couple of
|
|
|
|
* interesting things to note is that we ask our ctxpopup to be horizontal, and
|
|
|
|
* that we pass NULL as the label for every item:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And with all of that in place we can now get to our main function where we
|
|
|
|
* create the window, the list, the list items and run the main loop:
|
|
|
|
* @until ELM_MAIN()
|
|
|
|
*
|
|
|
|
* The example will initially look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/ctxpopup_example_01.png
|
|
|
|
* @image latex screenshots/ctxpopup_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @note This doesn't show the ctxpopup tough, since it will only appear when
|
|
|
|
* we click one of the list items.
|
|
|
|
*
|
|
|
|
* Here is what our first ctxpopup will look like:
|
|
|
|
*
|
|
|
|
* @image html screenshots/ctxpopup_example_01_a.png
|
|
|
|
* @image latex screenshots/ctxpopup_example_01_a.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* And here the second ctxpopup:
|
|
|
|
*
|
|
|
|
* @image html screenshots/ctxpopup_example_01_b.png
|
|
|
|
* @image latex screenshots/ctxpopup_example_01_b.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example ctxpopup_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-25 09:58:32 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_separator Separator example
|
|
|
|
* @dontinclude separator_example_01.c
|
|
|
|
*
|
|
|
|
* In this example we are going to pack two rectangles in a box, and have a
|
|
|
|
* separator in the middle.
|
|
|
|
*
|
|
|
|
* So we start we the window, background, box and rectangle creation, all pretty
|
|
|
|
* normal stuff:
|
|
|
|
* @until pack_end
|
|
|
|
*
|
|
|
|
* Once we have our first rectangle in the box we create and add our separator:
|
|
|
|
* @until pack_end
|
|
|
|
* @note Since our box is in horizontal mode it's a good idea to set the
|
|
|
|
* separator to be horizontal too.
|
|
|
|
*
|
|
|
|
* And now we add our second rectangle and run the main loop:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* This example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/separator_example_01.png
|
2011-08-03 12:07:43 -07:00
|
|
|
* @image latex screenshots/separator_example_01.eps width=\textwidth
|
2011-07-25 09:58:32 -07:00
|
|
|
*
|
|
|
|
* @example separator_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-25 09:58:54 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_radio Radio example
|
|
|
|
* @dontinclude radio_example_01.c
|
|
|
|
*
|
|
|
|
* In this example we will create 4 radio buttons, three of them in a group and
|
|
|
|
* another one not in the group. We will also have the radios in the group
|
|
|
|
* change the value of a variable directly and have then print it when the value
|
|
|
|
* changes. The fourth button is in the example just to make clear that radios
|
|
|
|
* outside the group don't affect the group.
|
|
|
|
*
|
|
|
|
* We'll start with the usual includes:
|
|
|
|
* @until #endif
|
|
|
|
*
|
|
|
|
* And move right to declaring a static variable(the one whose value the radios
|
|
|
|
* will change):
|
|
|
|
* @until static
|
|
|
|
*
|
|
|
|
* We now need to have a window and all that good stuff to be able to place our
|
|
|
|
* radios in:
|
|
|
|
* @until show(bx)
|
|
|
|
*
|
|
|
|
* And now we create a radio button, since this is the first button in our group
|
|
|
|
* we set the group to be the radio(so we can set the other radios in the same
|
|
|
|
* group). We also set the state value of this radio to 1 and the value pointer
|
|
|
|
* to @p val, since val is @p 1 this has the additional effect of setting the
|
|
|
|
* radio value to @p 1. For this radio we choose the default home icon:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* To check that our radio buttons are working we'll add a callback to the
|
|
|
|
* "changed" signal of the radio:
|
|
|
|
* @until smart_callback
|
|
|
|
*
|
|
|
|
* The creation of our second radio button is almost identical, the 2
|
|
|
|
* differences worth noting are, the value of this radio 2 and that we add this
|
|
|
|
* radio to the group of the first radio:
|
|
|
|
* @until smart_callback
|
|
|
|
*
|
|
|
|
* For our third callback we'll omit the icon and set the value to 3, we'll also
|
|
|
|
* add it to the group of the first radio:
|
|
|
|
* @until smart_callback
|
|
|
|
*
|
|
|
|
* Our fourth callback has a value of 4, no icon and most relevantly is not a
|
|
|
|
* member of the same group as the other radios:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* We finally run the main loop:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* And the last detail in our example is the callback that prints @p val so that
|
|
|
|
* we can see that the radios are indeed changing its value:
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/radio_example_01.png
|
2011-07-29 13:17:21 -07:00
|
|
|
* @image latex screenshots/radio_example_01.eps width=\textwidth
|
2011-07-25 09:58:54 -07:00
|
|
|
*
|
|
|
|
* @example radio_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-25 10:40:57 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_panel Panel example
|
|
|
|
* @dontinclude panel_example_01.c
|
|
|
|
*
|
|
|
|
* In this example will have 3 panels, one for each possible orientation. Two of
|
|
|
|
* our panels will start out hidden, the third will start out expanded. For each
|
|
|
|
* of the panels we will use a label as the content, it's however possible to
|
|
|
|
* have any widget(including containers) as the content of panels.
|
|
|
|
*
|
|
|
|
* We start by doing some setup, code you should be familiar with from other
|
|
|
|
* examples:
|
|
|
|
* @until show(bx)
|
|
|
|
*
|
|
|
|
* And move right to creating our first panel, for this panel we are going to
|
|
|
|
* choose the orientation as TOP and toggle it(tell it to hide itself):
|
|
|
|
* @until pack_end
|
|
|
|
*
|
|
|
|
* For the second panel we choose the RIGHT orientation and explicitly set the
|
|
|
|
* state as hidden:
|
|
|
|
* @until pack_end
|
|
|
|
*
|
|
|
|
* For our third and last panel we won't set the orientation(which means it will
|
|
|
|
* use the default: LEFT):
|
|
|
|
* @until pack_end
|
|
|
|
*
|
|
|
|
* All that is left is running the main loop:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* This example will look like this;
|
|
|
|
*
|
|
|
|
* @image html screenshots/panel_example_01.png
|
2011-07-29 13:17:21 -07:00
|
|
|
* @image latex screenshots/panel_example_01.eps width=\textwidth
|
2011-07-25 10:40:57 -07:00
|
|
|
* @note The buttons with arrow allow the user to hide/show the panels.
|
|
|
|
*
|
|
|
|
* @example panel_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-25 12:51:57 -07:00
|
|
|
/**
|
|
|
|
* @page gengrid_example Gengrid widget example
|
|
|
|
*
|
|
|
|
* This application is a thorough exercise on the gengrid widget's
|
|
|
|
* API. We place an Elementary gengrid widget on a window, with
|
|
|
|
* various knobs below its viewport, each one acting on it somehow.
|
|
|
|
*
|
|
|
|
* The code's relevant part begins at the grid's creation. After
|
|
|
|
* instantiating it, we set its items sizes, so that we don't end with
|
|
|
|
* items one finger size wide, only. We're setting them to fat, 150
|
|
|
|
* pixel wide ones, for this example. We give it some size hints, not
|
|
|
|
* to be discussed in this context and, than, we register a callback
|
|
|
|
* on one of its smart events -- the one coming each time an item gets
|
|
|
|
* doubly clicked. There, we just print the item handle's value.
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip grid = elm_gengrid_add
|
|
|
|
* @until evas_object_sho
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip item double click callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Before we actually start to deal with the items API, let's show
|
|
|
|
* some things items will be using throughout all the code. The first
|
|
|
|
* of them is a struct to be used as item data, for all of them:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip typedef struct
|
|
|
|
* @until Item;
|
|
|
|
*
|
|
|
|
* That path will be used to index an image, to be swallowed into one
|
|
|
|
* of the item's icon spots. The imagens themselves are distributed
|
|
|
|
* with Elementary:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip static const char *imgs
|
|
|
|
* @until ;
|
|
|
|
*
|
|
|
|
* We also have an (unique) gengrid item class we'll be using for
|
|
|
|
* items in the example:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip static Elm_Gengrid_Item_Class
|
|
|
|
* @until static Elm_Gengrid_Item_Class
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip item_style =
|
|
|
|
* @until _grid_del
|
|
|
|
*
|
|
|
|
* As you see, our items will follow the default theme on gengrid
|
|
|
|
* items. For the label fetching code, we return a string composed of
|
|
|
|
* the item's image path:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip label fetching callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* For item icons, we'll be populating the item default theme's two
|
|
|
|
* icon spots, @c "elm.swallow.icon" and @c "elm.swallow.end". The
|
|
|
|
* former will receive one of the images in our list (in the form of
|
|
|
|
* a @ref bg_02_example_page "background"), while the latter will be
|
|
|
|
* a check widget. Note that we prevent the check to propagate click
|
|
|
|
* events, so that the user can toggle its state without messing with
|
|
|
|
* the respective item's selection in the grid:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip icon fetching callback
|
|
|
|
* @until return NULL
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* As the default gengrid item's theme does not have parts
|
|
|
|
* implementing item states, we'll be just returning false for every
|
|
|
|
* item state:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip state fetching callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Finally, the deletion callback on gengrid items takes care of
|
|
|
|
* freeing the item's label string and its data struct:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip deletion callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Let's move to item insertion/deletion knobs, them. They are four
|
|
|
|
* buttons, above the grid's viewport, namely
|
|
|
|
* - "Append" (to append an item to the grid),
|
|
|
|
* - "Prepend" (to prepend an item to the grid),
|
|
|
|
* - "Insert before" (to insert an item before the selection, on the
|
|
|
|
* grid),
|
|
|
|
* - "Insert after" (to insert an item after the selection, on the
|
|
|
|
* grid),
|
|
|
|
* - "Clear" (to delete all items in the grid),
|
2011-07-25 12:52:15 -07:00
|
|
|
* - "Bring in 1st" (to make the 1st item visible, by scrolling),
|
|
|
|
* - "Show last" (to directly show the last item),
|
2011-07-25 12:51:57 -07:00
|
|
|
* .
|
|
|
|
* which are displaced and declared in that order. We're not dealing
|
|
|
|
* with the buttons' creation code (see @ref button_example_01
|
|
|
|
* "a button example", for more details on it), but with their @c
|
|
|
|
* "clicked" registered callbacks. For all of them, the grid's handle
|
|
|
|
* is passed as @c data. The ones creating new items use a common
|
|
|
|
* code, which just gives a new @c Example_Item struct, with @c path
|
|
|
|
* filled with a random image in our images list:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip new item with random path
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Moreover, that ones will set a common function to be issued on the
|
|
|
|
* selection of the items. There, we print the item handle's value,
|
|
|
|
* along with the callback function data. The latter will be @c NULL,
|
2011-07-25 12:52:31 -07:00
|
|
|
* always, because it's what we pass when adding all icons. By using
|
2012-01-30 17:22:16 -08:00
|
|
|
* elm_object_item_data_get(), we can have the item data back and,
|
2011-07-25 12:52:31 -07:00
|
|
|
* with that, we're priting the item's path string. Finally, we
|
|
|
|
* exemplify elm_gengrid_item_pos_get(), printing the item's position
|
|
|
|
* in the grid:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip item selection callback
|
|
|
|
* @until }
|
2011-07-25 12:51:57 -07:00
|
|
|
*
|
|
|
|
* The appending button will exercise elm_gengrid_item_append(), simply:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip append an item
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The prepending, naturally, is analogous, but exercising
|
|
|
|
* elm_gengrid_item_prepend(), on its turn. The "Insert before" one
|
|
|
|
* will expect an item to be selected in the grid, so that it will
|
|
|
|
* insert a new item just before it:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip "insert before" callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The "Insert after" is analogous, just using
|
|
|
|
* elm_gengrid_item_insert_after(), instead. The "Clear" button will,
|
|
|
|
* as expected, just issue elm_gengrid_clear():
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip delete items
|
|
|
|
* @until }
|
|
|
|
*
|
2011-07-25 12:52:15 -07:00
|
|
|
* The "Bring in 1st" button is there exercise two gengrid functions
|
|
|
|
* -- elm_gengrid_first_item_get() and elm_gengrid_item_bring_in().
|
|
|
|
* With the former, we get a handle to the first item and, with the
|
|
|
|
* latter, you'll see that the widget animatedly scrolls its view
|
|
|
|
* until we can see that item:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip bring in 1st item
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The "Show last", in its turn, will use elm_gengrid_last_item_get()
|
|
|
|
* and elm_gengrid_item_show(). The latter differs from
|
|
|
|
* elm_gengrid_item_bring_in() in that it immediately replaces the
|
|
|
|
* contents of the grid's viewport with the region containing the item
|
|
|
|
* in question:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip show last item
|
|
|
|
* @until }
|
|
|
|
*
|
2011-07-25 12:51:57 -07:00
|
|
|
* To change the grid's cell (items) size, we've placed a spinner,
|
|
|
|
* which has the following @c "changed" smart callback:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip change items' size
|
|
|
|
* @until }
|
|
|
|
*
|
2011-07-25 12:52:31 -07:00
|
|
|
* Experiment with it and see how the items are affected. The "Disable
|
|
|
|
* item" button will, as the name says, disable the currently selected
|
|
|
|
* item:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip disable selected item
|
|
|
|
* @until }
|
|
|
|
* Note that we also make use of elm_gengrid_item_selected_set(),
|
|
|
|
* there, thus making the item unselected before we actually disable
|
|
|
|
* it.
|
|
|
|
*
|
|
|
|
* To toggle between horizontal and vertical layouting modes on the
|
|
|
|
* grid, use the "Horizontal mode" check, which will call the
|
|
|
|
* respective API function on the grid:
|
2011-07-25 12:51:57 -07:00
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip change layouting mode
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* If you toggle the check right after that one, "Always select",
|
|
|
|
* you'll notice all subsequent clicks on the @b same grid item will
|
|
|
|
* still issue the selection callback on it, what is different from
|
|
|
|
* when it's not checked. This is the
|
2012-03-13 00:39:31 -07:00
|
|
|
* elm_gengrid_select_mode_set() behavior:
|
2011-07-25 12:51:57 -07:00
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip "always select" callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* One more check follows, "Bouncing", which will turn on/off the
|
|
|
|
* bouncing animations on the grid, when one scrolls past its
|
|
|
|
* borders. Experiment with scrolling the grid to get the idea, having
|
|
|
|
* it turned on and off:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip "bouncing mode" callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The next two checks will affect items selection on the grid. The
|
|
|
|
* first, "Multi-selection", will make it possible to select more the
|
|
|
|
* one item on the grid. Because it wouldn't make sense to fetch for
|
|
|
|
* an unique selected item on this case, we also disable two of the
|
|
|
|
* buttons, which insert items relatively, if multi-selection is on:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip multi-selection callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Note that we also @b unselect all items in the grid, when returning
|
|
|
|
* from multi-selection mode, making use of
|
|
|
|
* elm_gengrid_item_selected_set().
|
|
|
|
*
|
|
|
|
* The second check acting on selection, "No selection", is just what
|
|
|
|
* its name depicts -- no selection will be allowed anymore, on the
|
|
|
|
* grid, while it's on. Check it out for yourself, interacting with
|
|
|
|
* the program:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip no selection callback
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* We have, finally, one more line of knobs, now sliders, to change
|
|
|
|
* the grids behavior. The two first will change the horizontal @b
|
|
|
|
* alignment of the whole actual grid of items within the gengrid's
|
|
|
|
* viewport:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip items grid horizontal alignment change
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Naturally, the vertical counterpart just issues
|
|
|
|
* elm_gengrid_align_set() changing the second alignment component,
|
|
|
|
* instead.
|
|
|
|
*
|
|
|
|
* The last slider will change the grid's <b>page size</b>, relative
|
|
|
|
* to its own one. Try to change those values and, one manner of
|
|
|
|
* observing the paging behavior, is to scroll softly and release the
|
|
|
|
* mouse button, with different page sizes, at different grid
|
|
|
|
* positions, while having lots of items in it -- you'll see it
|
|
|
|
* snapping to page boundaries differenty, for each configuration:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip page relative size change
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* This is how the example program's window looks like:
|
|
|
|
* @image html screenshots/gengrid_example.png
|
2011-07-26 13:11:39 -07:00
|
|
|
* @image latex screenshots/gengrid_example.eps width=\textwidth
|
2011-07-25 12:51:57 -07:00
|
|
|
*
|
|
|
|
* Note that it starts with three items which we included at will:
|
|
|
|
* @dontinclude gengrid_example.c
|
|
|
|
* @skip _clicked(grid,
|
|
|
|
* @until _clicked(grid,
|
|
|
|
* @until _clicked(grid,
|
|
|
|
* @until _clicked(grid,
|
|
|
|
*
|
|
|
|
* See the full @ref gengrid_example_c "source code" for
|
|
|
|
* this example.
|
|
|
|
*
|
|
|
|
* @example gengrid_example.c
|
|
|
|
*/
|
2011-07-26 12:01:31 -07:00
|
|
|
/**
|
2012-03-21 10:57:34 -07:00
|
|
|
* @page entry_example Entry - Example of simple editing
|
2011-07-26 12:01:31 -07:00
|
|
|
*
|
|
|
|
* As a general overview of @ref Entry we are going to write an, albeit simple,
|
|
|
|
* functional editor. Although intended to show how elm_entry works, this
|
|
|
|
* example also makes extensive use of several other widgets. The full code
|
|
|
|
* can be found in @ref entry_example.c "entry_example.c" and in the following
|
|
|
|
* lines we'll go through the parts especific to the @ref Entry widget.
|
|
|
|
*
|
|
|
|
* The program itself is a simple editor, with a file already set to it, that
|
|
|
|
* can be set to autosave or not and allows insertion of emoticons and some
|
|
|
|
* formatted text. As of this writing, the capabilities of format edition in
|
|
|
|
* the entry are very limited, so a lot of manual work is required to change
|
|
|
|
* the current text.
|
|
|
|
*
|
|
|
|
* In any case, the program allows some changes by using the buttons on the
|
|
|
|
* top of the window and returning focus back to the main entry afterwards.
|
|
|
|
*
|
|
|
|
* @image html screenshots/entry_example.png
|
|
|
|
* @image latex screenshots/entry_example.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* We'll begin by showing a few structures used throught the program. First,
|
|
|
|
* the application owns data that holds the main window and the main entry
|
|
|
|
* where the editting happens. Then, an auxiliar structure we'll use later
|
|
|
|
* when inserting icons in our text.
|
|
|
|
* @dontinclude entry_example.c
|
|
|
|
* @skip typedef
|
|
|
|
* @until App_Inwin_Data
|
|
|
|
*
|
|
|
|
* A little convenience function will insert whatever text we need in the
|
|
|
|
* buffer at the current cursor's position and set focus back to this entry.
|
|
|
|
* This is done mostly because clicking on any button will make them steal
|
|
|
|
* focus, which makes writing text more cumbersome.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* One of the buttons on the top will trigger an @ref Inwin to open and show
|
|
|
|
* us several icons we can insert into the text. We'll jump over most of these
|
|
|
|
* functions, but when all the options are chosen, we insert the special
|
|
|
|
* markup text that will show the chosen icon in place.
|
|
|
|
* @skip edje_file_collection_list_free(emos)
|
|
|
|
* @skip static void
|
|
|
|
* @until evas_object_del
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* As can be seen in that function, the program lets us add icons to our entry
|
|
|
|
* using all the possible configurations for them. That should help to
|
|
|
|
* clarify how the different combinations work out by actually seeing them
|
|
|
|
* in action.
|
|
|
|
*
|
|
|
|
* The same popup window has a page to set the settings of the chosen icon,
|
|
|
|
* that is, the size and how the item will be placed within the line.
|
|
|
|
*
|
|
|
|
* The size is done with two entries, limitted to accept numbers and a fixed
|
|
|
|
* size of characters. Changing the value in this entries will update the icon
|
|
|
|
* size in our struct as seen in the next two callbacks.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The rest of the options are handled with radio buttons, since only one type
|
|
|
|
* of size can be used (@c size, @c absize or @c relsize) and for the vertical
|
|
|
|
* sizing it needs to choose between @c ascent and @c full. Depending on which
|
|
|
|
* is chosen, the @c item tag is formed accordingly as seen before.
|
|
|
|
* @skip static Evas_Object
|
|
|
|
* @until evas_object_show(rvascent)
|
|
|
|
*
|
|
|
|
* The first of our entries is here. There's something worth mentioning about
|
|
|
|
* the way we'll create this one. Normally, any entry regardless of whether is
|
|
|
|
* single line or not, will be set to scrollable, but in this case, since we
|
|
|
|
* are limitting how many characters can fit in them and we know we don't need
|
|
|
|
* scrolling, we are not setting this flag. This makes the entry have virtually
|
|
|
|
* no appearance on screen, other than its text. This is because an entry is
|
|
|
|
* just that, a box that holds text, and in order to have some frame around it
|
|
|
|
* or a background color, another widget needs to provide this. When an entry
|
|
|
|
* is scrollable, the same scroller used internally does this.
|
|
|
|
* We are using @ref Frame "frames" here to provide some decoration around,
|
|
|
|
* then creating our entries, set them to single line, add our two filters and
|
|
|
|
* the callback for when their value change.
|
|
|
|
* @until _height_changed_cb
|
|
|
|
*
|
|
|
|
* This function ends with the button that will finally call the item
|
|
|
|
* into our editting string.
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Then we get to the format edition. Here we can add the @c bold and
|
|
|
|
* @c emphasis tags to parts of our text. There's a lot of manual work to
|
|
|
|
* know what to do here, since we are not implementing an entire state manager
|
|
|
|
* and the entry itself doesn't, yet, support all the needed capabilities to
|
|
|
|
* make this simpler. We begin by getting the format we are using in our
|
|
|
|
* function from the button pressed.
|
2012-03-21 10:57:34 -07:00
|
|
|
* @skip _format_change_cb(void *data, Evas_Object *obj, void *event __UNUSED__)
|
2011-07-26 12:01:31 -07:00
|
|
|
* @until sizeof(fmt_close)
|
|
|
|
*
|
|
|
|
* Next we need to find out if we need to insert an opening or a closing tag.
|
|
|
|
* For this, we store the current cursor position and create a selection
|
|
|
|
* from this point until the beginning of our text, and then get the selected
|
|
|
|
* text to look for any existing format tags in it. This is currently the only
|
|
|
|
* way in which we can find out what formats is being used in the entry.
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Once we know what tag to insert, we need a second check in the case it was
|
|
|
|
* a closing tag. This is because any other closing tag that comes after would
|
|
|
|
* be left dangling alone, so we need to remove it to keep the text consistent.
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* Finally, we clear our fake selections and return the cursor back to the
|
|
|
|
* position it had at first, since there is where we want to insert our format.
|
|
|
|
* @until cursor_pos_set
|
|
|
|
*
|
|
|
|
* And finish by calling our convenience function from before, to insert the
|
|
|
|
* text at the current cursor and give focus back to the entry.
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* A checkbox on the top of our program tells us if the text we are editing
|
|
|
|
* will autosave or not. In it's @c "changed" callback we get the value from
|
|
|
|
* the checkbox and call the elm_entry_autosave_set() function with it. If
|
|
|
|
* autosave is set, we also call elm_entry_file_save(). This is so the internal
|
|
|
|
* timer used to periodically store to disk our changes is started.
|
|
|
|
* @skip static void
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Two more functions to show some cursor playing. Whenever we double click
|
|
|
|
* anywhere on our entry, we'll find what word is the cursor placed at and
|
|
|
|
* select it. Likewise, for triple clicking, we select the entire line.
|
|
|
|
* @skip static void
|
|
|
|
* @until _edit_tplclick_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And finally, the main window of the program contains the entry where we
|
|
|
|
* do all the edition and some helping widgets to change format, add icons
|
|
|
|
* or change the autosave flag.
|
|
|
|
* @skip elm_exit
|
|
|
|
* @skip int
|
|
|
|
* @until _image_insert_cb
|
|
|
|
*
|
|
|
|
* And the main entry of the program. Set to scroll, by default we disable
|
|
|
|
* autosave and we'll begin with a file set to it because no file selector
|
|
|
|
* is being used here. The file is loaded with #ELM_TEXT_FORMAT_MARKUP_UTF8
|
|
|
|
* so that any format contained in it is interpreted, otherwise the entry
|
|
|
|
* would load it as just text, escaping any tags found and no format or icons
|
|
|
|
* would be shown. Then we connect to the double and triple click signals
|
|
|
|
* and set focus on the entry so we can start typing right away.
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* @example entry_example.c
|
|
|
|
*/
|
2011-07-25 12:51:57 -07:00
|
|
|
|
2011-07-26 11:32:14 -07:00
|
|
|
/**
|
2011-07-28 14:27:32 -07:00
|
|
|
* @page genlist_example_01 Genlist - basic usage
|
2011-07-26 11:32:14 -07:00
|
|
|
*
|
|
|
|
* This example creates a simple genlist with a small number of items and
|
|
|
|
* a callback that is called whenever an item is selected. All the properties of
|
|
|
|
* this genlist are the default ones. The full code for this example can be seen
|
|
|
|
* at @ref genlist_example_01_c.
|
|
|
|
*
|
|
|
|
* For the simplest list that you plan to create, it's necessary to define some
|
|
|
|
* of the basic functions that are used for creating each list item, and
|
|
|
|
* associating them with the "item class" for that list. The item class is just
|
|
|
|
* an struct that contains pointers to the specific list item functions that are
|
|
|
|
* common to all the items of the list.
|
|
|
|
*
|
|
|
|
* Let's show it by example. Our item class is declared globally and static as
|
|
|
|
* it will be the only item class that we need (we are just creating one list):
|
|
|
|
*
|
|
|
|
* @dontinclude genlist_example_01.c
|
|
|
|
* @skip static Elm_Genlist
|
|
|
|
* @until static Elm_Genlist
|
|
|
|
*
|
|
|
|
* This item class will be used for every item that we create. The only
|
|
|
|
* functions that we are going to set are @c label_get and @c icon_get. As the
|
|
|
|
* name suggests, they are used by the genlist to generate the label for the
|
|
|
|
* respective item, and to generate icon(s) to it too. Both the label and icon
|
|
|
|
* get functions can be called more than once for each item, with different @c
|
|
|
|
* part parameters, which represent where in the theme of the item that label or
|
|
|
|
* icon is going to be set.
|
|
|
|
*
|
|
|
|
* The default theme for the genlist contains only one area for label, and two
|
|
|
|
* areas for icon ("elm.swallow.icon" and "elm.swallow.end"). Since we just want
|
|
|
|
* to set the first icon (that will be at the left side of the label), we
|
|
|
|
* compare the part name given with "elm.swallow.icon". Notice that the
|
|
|
|
* @c label_get function must return a strduped string, that will be freed later
|
|
|
|
* automatically by the list. Here's the code for @c label_get and @c icon_get:
|
|
|
|
*
|
|
|
|
* @until static void
|
|
|
|
*
|
|
|
|
* We will also provide a function that will be called whenever an item is
|
|
|
|
* selected in the genlist. However, this function is not part of the item
|
|
|
|
* class, it will be passed for each item being added to the genlist explicitly.
|
|
|
|
* Notice the similarity of the function signature with those used by @c
|
|
|
|
* evas_object_smart_callback_add:
|
|
|
|
*
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Now let's show the code used for really creating the list. Skipping
|
|
|
|
* boilerplate code used for creating a window and background, the first piece
|
|
|
|
* of code specific to our genlist example is setting the pointer functions of
|
|
|
|
* the item class to our above defined functions:
|
|
|
|
*
|
|
|
|
* @skip _itc
|
|
|
|
* @until func.del
|
|
|
|
*
|
|
|
|
* Notice that we also choose to use the "default" style for our genlist items.
|
|
|
|
* Another interesting point is that @c state_get and @c del are set to @c NULL,
|
|
|
|
* since we don't need these functions now. @c del doesn't need to be used
|
|
|
|
* because we don't add any data that must be freed to our items, and @c
|
|
|
|
* state_get is also not used since all of our items are the same and don't need
|
|
|
|
* to have different states to be used for each item. Finally we create our
|
|
|
|
* list:
|
|
|
|
*
|
|
|
|
* @until genlist_add
|
|
|
|
*
|
|
|
|
* Now we append several items to the list, and for all of them we need to give
|
|
|
|
* the list pointer, a pointer to the item class, the data that will be used
|
|
|
|
* with that item, a pointer to the parent of this item if it is in a group type
|
|
|
|
* list (this is not the case so we pass @c NULL), possible flags for this item,
|
|
|
|
* the callback for when the item is selected, and the data pointer that will be
|
|
|
|
* given to the selected callback.
|
|
|
|
*
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The rest of the code is also common to all the other examples, so it will be
|
|
|
|
* omitted here (look at the full source code link above if you need it).
|
|
|
|
*
|
|
|
|
* You can try to play with this example, and see the selected callback being
|
|
|
|
* called whenever an item is clicked. It also already has some features enabled
|
|
|
|
* by default, like vertical bounce animation when reaching the end of the list,
|
|
|
|
* automatically visible/invisible scrollbar, etc. Look at the @ref
|
|
|
|
* genlist_example_02 to see an example of setting these properties to the list.
|
|
|
|
*
|
|
|
|
* The current example will look like this when running:
|
|
|
|
*
|
|
|
|
* @image html screenshots/genlist_example_01.png
|
2011-07-29 13:17:21 -07:00
|
|
|
* @image latex screenshots/genlist_example_01.eps width=\textwidth
|
2011-07-26 11:32:14 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2011-07-28 14:27:32 -07:00
|
|
|
* @page genlist_example_02 Genlist - list setup functions
|
2011-07-26 11:32:14 -07:00
|
|
|
*
|
|
|
|
* This example is very similar to the @ref genlist_example_01, but it fetch
|
|
|
|
* most of the properties of the genlist and displays them on startup (thus
|
|
|
|
* getting the default value for them) and then set them to some other values,
|
|
|
|
* to show how to use that API. The full source code is at @ref
|
|
|
|
* genlist_example_02_c.
|
|
|
|
*
|
|
|
|
* Considering that the base code for instantiating a genlist was already
|
|
|
|
* described in the previous example, we are going to focus on the new code.
|
|
|
|
*
|
|
|
|
* Just a small difference for the @c _item_label_get function, we are going to
|
|
|
|
* store the time that this function was called. This is the "realized" time,
|
|
|
|
* the time when the visual representation of this item was created. This is the
|
|
|
|
* code for the @c label_get function:
|
|
|
|
*
|
|
|
|
* @dontinclude genlist_example_02.c
|
|
|
|
* @skip static char
|
|
|
|
* @until return strdup
|
|
|
|
*
|
|
|
|
* Now let's go to the list creation and setup. First, just after creating the
|
|
|
|
* list, we get most of the default properties from it, and print them on the
|
|
|
|
* console:
|
|
|
|
*
|
|
|
|
* @skip genlist_add
|
|
|
|
* @until printf("\n")
|
|
|
|
*
|
|
|
|
* We are going to change some of the properties of our list.
|
|
|
|
*
|
|
|
|
* There's no need to call the selected callback at every click, just when the
|
2012-03-14 23:22:25 -07:00
|
|
|
* selected item changes, thus we call elm_genlist_select_mode_set() with
|
|
|
|
* ELM_OBJECT_SELECT_MODE_ALWAYS.
|
2011-07-26 11:32:14 -07:00
|
|
|
*
|
|
|
|
* 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
|
2012-03-07 08:37:08 -08:00
|
|
|
* width (thus we call elm_genlist_mode_set(obj, ELM_LIST_COMPRESS).
|
2011-07-26 11:32:14 -07:00
|
|
|
*
|
|
|
|
* 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
|
2012-01-25 01:25:12 -08:00
|
|
|
* elm_genlist_mode_set() doesn't make difference, but the current
|
2011-07-26 11:32:14 -07:00
|
|
|
* 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.
|
|
|
|
*
|
2012-03-15 01:46:29 -07:00
|
|
|
* The option elm_genlist_mode_set() would allow text block to
|
2011-07-26 11:32:14 -07:00
|
|
|
* wrap lines if the Edje part is configured with "text.min: 0 1", for example.
|
|
|
|
* But since we are compressing the elements to the width of the list, this
|
|
|
|
* option wouldn't take any effect.
|
|
|
|
*
|
|
|
|
* We want the vertical scrollbar to be always displayed, and the orizontal one
|
|
|
|
* to never be displayed, and set this with elm_genlist_scroller_policy_set().
|
|
|
|
*
|
|
|
|
* The timeout to consider a longpress is set to half of a second with
|
|
|
|
* elm_genlist_longpress_timeout_set().
|
|
|
|
*
|
|
|
|
* We also change the block count to a smaller value, but that should have not
|
|
|
|
* impact on performance since the number of visible items is too small. We just
|
|
|
|
* increase the granularity of the block count (setting it to have at most 4
|
|
|
|
* items).
|
|
|
|
*
|
|
|
|
* @until block_count_set
|
|
|
|
*
|
|
|
|
* Now let's add elements to the list:
|
|
|
|
*
|
|
|
|
* @until item_append
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* It's exactly the same as the previous example. The difference is on the
|
|
|
|
* behavior of the list, if you try to scroll, select items and so.
|
|
|
|
*
|
|
|
|
* In this example we also need two buttons. One of them, when clicked, will
|
|
|
|
* display several status info about the current selection, the "realized"
|
|
|
|
* items, the item in the middle of the screen, and the current mode and active
|
|
|
|
* item of that mode for the genlist.
|
|
|
|
*
|
|
|
|
* The other button will ask the genlist to "realize" again the items already
|
|
|
|
* "realized", so their respective label_get and icon_get functions will be
|
|
|
|
* called again.
|
|
|
|
*
|
|
|
|
* These are the callbacks for both of these buttons:
|
|
|
|
*
|
|
|
|
* @dontinclude genlist_example_02.c
|
|
|
|
* @skip item_sel_cb
|
|
|
|
* @skip static
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Try to scroll, select some items and click on the "Show status" button.
|
|
|
|
* You'll notice that not all items of the list are "realized", thus consuming
|
|
|
|
* just a small amount of memory. The selected items are listed in the order
|
|
|
|
* that they were selected, and the current selected item printed using
|
|
|
|
* elm_genlist_selected_item_get() is the first selected item of the multiple
|
|
|
|
* selection.
|
|
|
|
*
|
|
|
|
* Now resize the window so that you can see the "realized time" of some items.
|
|
|
|
* This is the time of when the label_get function was called. If you click on
|
|
|
|
* the "Realize" button, all the already realized items will be rebuilt, so the
|
|
|
|
* time will be updated for all of them.
|
|
|
|
*
|
|
|
|
* The current example will look like this when running:
|
|
|
|
*
|
|
|
|
* @image html screenshots/genlist_example_02.png
|
2011-07-29 13:17:21 -07:00
|
|
|
* @image latex screenshots/genlist_example_02.eps width=\textwidth
|
2011-07-26 11:32:14 -07:00
|
|
|
*/
|
|
|
|
|
2011-07-29 07:59:45 -07:00
|
|
|
/**
|
|
|
|
* @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
|
2011-07-29 13:17:21 -07:00
|
|
|
* @image latex screenshots/genlist_example_03.eps width=\textwidth
|
2011-07-29 07:59:45 -07:00
|
|
|
*
|
|
|
|
* @example genlist_example_03.c
|
|
|
|
*/
|
|
|
|
|
2011-07-28 14:27:32 -07:00
|
|
|
/**
|
|
|
|
* @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
|
2011-07-29 13:17:21 -07:00
|
|
|
* @image latex screenshots/genlist_example_04.eps width=\textwidth
|
2011-07-28 14:27:32 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @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
|
2012-03-07 04:57:13 -08:00
|
|
|
* of the type #ELM_GENLIST_ITEM_TREE. Thus, we have to delete it and create
|
2011-07-28 14:27:32 -07:00
|
|
|
* 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
|
2011-07-29 13:17:21 -07:00
|
|
|
* @image latex screenshots/genlist_example_05.eps width=\textwidth
|
2011-07-28 14:27:32 -07:00
|
|
|
*/
|
|
|
|
|
2011-08-01 10:37:10 -07:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-07-26 13:11:39 -07:00
|
|
|
/**
|
|
|
|
* @page progressbar_example Progress bar widget example
|
|
|
|
*
|
|
|
|
* This application is a thorough example of the progress bar widget,
|
|
|
|
* consisting of a window with varios progress bars, each with a given
|
|
|
|
* look/style one can give to those widgets. With two auxiliary
|
|
|
|
* buttons, one can start or stop a timer which will fill in the bars
|
|
|
|
* in synchrony, simulating an underlying task being completed.
|
|
|
|
*
|
|
|
|
* We create @b seven progress bars, being three of them horizontal,
|
|
|
|
* three vertical and a final one under the "wheel" alternate style.
|
|
|
|
*
|
|
|
|
* For the first one, we add a progress bar on total pristine state,
|
|
|
|
* with no other call than the elm_progressbar_add() one:
|
|
|
|
* @dontinclude progressbar_example.c
|
|
|
|
* @skip pb with no label
|
|
|
|
* @until pb1
|
|
|
|
* See, than, that the defaults of a progress bar are:
|
|
|
|
* - no primary label shown,
|
|
|
|
* - unit label set to @c "%.0f %%",
|
|
|
|
* - no icon set
|
|
|
|
*
|
|
|
|
* The second progress bar is given a primary label, <c>"Infinite
|
|
|
|
* bounce"</c>, and, besides, it's set to @b pulse. See how, after one
|
|
|
|
* starts the progress timer, with the "Start" button, it animates
|
|
|
|
* differently than the previous one. It won't account for the
|
|
|
|
* progress, itself, and just dumbly animate a small bar within its
|
|
|
|
* bar region.
|
|
|
|
* @dontinclude progressbar_example.c
|
|
|
|
* @skip pb with label
|
|
|
|
* @until pb2
|
|
|
|
*
|
|
|
|
* Next, comes a progress bar with an @b icon, a primary label and a
|
|
|
|
* @b custom unit label set. It's also made to grow its bar in an
|
|
|
|
* @b inverted manner, so check that out during the timer's progression:
|
|
|
|
* @dontinclude progressbar_example.c
|
|
|
|
* @skip ic1 =
|
|
|
|
* @until pb3
|
|
|
|
* Another important thing in this one is the call to
|
|
|
|
* elm_progressbar_span_size_set() -- this is how we forcefully set a
|
|
|
|
* minimum horizontal size to our whole window! We're not resizing it
|
|
|
|
* manually, as you can see in the @ref progressbar_example_c
|
|
|
|
* "complete code".
|
|
|
|
*
|
|
|
|
* The next three progress bars are just variants on the ones already
|
|
|
|
* shown, but now all being @b vertical. Another time we use one of
|
|
|
|
* than to give the window a minimum vertical size, with
|
|
|
|
* elm_progressbar_span_size_set(). To demonstrate this trick once
|
|
|
|
* more, the fifth one, which is also set to pulse, has a smaller
|
|
|
|
* hardcoded span size:
|
|
|
|
* @dontinclude progressbar_example.c
|
|
|
|
* @skip vertical pb, with pulse
|
|
|
|
* @until pb5
|
|
|
|
*
|
|
|
|
* We end the widget demonstration by showing a progress bar with the
|
|
|
|
* special @b "wheel" progress bar style. One does @b not need to set
|
|
|
|
* it to pulse, with elm_progressbar_pulse_set(), explicitly, because
|
|
|
|
* its theme does not take it in account:
|
|
|
|
* @dontinclude progressbar_example.c
|
|
|
|
* @skip "wheel"
|
|
|
|
* @until pb7
|
|
|
|
*
|
|
|
|
* The two buttons exercising the bars, the facto, follow:
|
|
|
|
* @dontinclude progressbar_example.c
|
|
|
|
* @skip elm_button_add
|
|
|
|
* @until evas_object_show(bt)
|
|
|
|
* @until evas_object_show(bt)
|
|
|
|
*
|
|
|
|
* The first of the callbacks will, for the progress bars set to
|
|
|
|
* pulse, start the pulsing animation at that time. For the others, a
|
|
|
|
* timer callback will take care of updating the values:
|
|
|
|
* @dontinclude progressbar_example.c
|
|
|
|
* @skip static Eina_Bool
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Finally, the callback to stop the progress timer will stop the
|
|
|
|
* pulsing on the pulsing progress bars and, for the others, to delete
|
|
|
|
* the timer which was acting on their values:
|
|
|
|
* @dontinclude progressbar_example.c
|
|
|
|
* @skip end of show
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* This is how the example program's window looks like:
|
|
|
|
* @image html screenshots/progressbar_example.png
|
|
|
|
* @image latex screenshots/progressbar_example.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* See the full @ref progressbar_example_c "source code" for
|
|
|
|
* this example.
|
|
|
|
*
|
|
|
|
* @example progressbar_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-27 06:40:30 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_notify Notify example
|
|
|
|
* @dontinclude notify_example_01.c
|
|
|
|
*
|
|
|
|
* In this example we will have 3 notifys in 3 different positions. The first of
|
|
|
|
* which will dissapear after 5 seconds or when a click outside it occurs, the
|
|
|
|
* second and third will not dissapear and differ from each other only in
|
|
|
|
* position.
|
|
|
|
*
|
|
|
|
* We start our example with the usual stuff you've seen in other examples:
|
|
|
|
* @until show(bx)
|
|
|
|
*
|
|
|
|
* We now create a label to use as the content of our first notify:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* Having the label we move to creating our notify, telling it to block events,
|
|
|
|
* setting its timeout(to autohide it):
|
|
|
|
* @until pack_end
|
|
|
|
*
|
|
|
|
* To have the notify dissapear when a click outside its area occur we have to
|
|
|
|
* listen to its "block,clicked" signal:
|
|
|
|
* @until smart_callback
|
|
|
|
*
|
|
|
|
* Our callback will look like this:
|
|
|
|
* @skip static
|
|
|
|
* @until }
|
|
|
|
* @dontinclude notify_example_01.c
|
|
|
|
*
|
|
|
|
* Next we create another label and another notify. Note, however, that this
|
|
|
|
* time we don't set a timeout and don't have it block events. What we do is set
|
|
|
|
* the orient so that this notify will appear in the bottom of its parent:
|
|
|
|
* @skip smart_callback
|
|
|
|
* @skip content
|
|
|
|
* @until pack_end
|
|
|
|
*
|
|
|
|
* For our third notify the only change is the orient which is now center:
|
|
|
|
* @until pack_end
|
|
|
|
*
|
|
|
|
* Now we tell the main loop to run:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* Our example will initially look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/notify_example_01.png
|
|
|
|
* @image latex screenshots/notify_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* Once the first notify is hidden:
|
|
|
|
*
|
|
|
|
* @image html screenshots/notify_example_01_a.png
|
|
|
|
* @image latex screenshots/notify_example_01_a.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example notify_example_01.c
|
|
|
|
*/
|
|
|
|
|
2012-03-05 15:51:56 -08:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-07-27 12:38:52 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_frame Frame example
|
|
|
|
* @dontinclude frame_example_01.c
|
|
|
|
*
|
|
|
|
* In this example we are going to create 4 Frames with different styles and
|
|
|
|
* add a rectangle of different color in each.
|
|
|
|
*
|
|
|
|
* We start we the usual setup code:
|
|
|
|
* @until show(bg)
|
|
|
|
*
|
|
|
|
* And then create one rectangle:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* To add it in our first frame, which since it doesn't have it's style
|
|
|
|
* specifically set uses the default style:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* And then create another rectangle:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* To add it in our second frame, which uses the "pad_small" style, note that
|
|
|
|
* even tough we are setting a text for this frame it won't be show, only the
|
|
|
|
* default style shows the Frame's title:
|
|
|
|
* @until show
|
|
|
|
* @note The "pad_small", "pad_medium", "pad_large" and "pad_huge" styles are
|
|
|
|
* very similar, their only difference is the size of the empty area around
|
|
|
|
* the content of the frame.
|
|
|
|
*
|
|
|
|
* And then create yet another rectangle:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* To add it in our third frame, which uses the "outdent_top" style, note
|
|
|
|
* that even tough we are setting a text for this frame it won't be show,
|
|
|
|
* only the default style shows the Frame's title:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* And then create one last rectangle:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* To add it in our fourth and final frame, which uses the "outdent_bottom"
|
|
|
|
* style, note that even tough we are setting a text for this frame it won't
|
|
|
|
* be show, only the default style shows the Frame's title:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* And now we are left with just some more setup code:
|
|
|
|
* @until ELM_MAIN()
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/frame_example_01.png
|
|
|
|
* @image latex screenshots/frame_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example frame_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page tutorial_anchorblock_example Anchorblock/Anchorview example
|
|
|
|
* This example will show both Anchorblock and @ref Anchorview,
|
|
|
|
* since both are very similar and it's easier to show them once and side
|
|
|
|
* by side, so the difference is more clear.
|
|
|
|
*
|
|
|
|
* We'll show the relevant snippets of the code here, but the full example
|
|
|
|
* can be found here... sorry, @ref anchorblock_example_01.c "here".
|
|
|
|
*
|
|
|
|
* As for the actual example, it's just a simple window with an anchorblock
|
|
|
|
* and an anchorview, both containing the same text. After including
|
|
|
|
* Elementary.h and declaring some functions we'll need, we jump to our
|
|
|
|
* elm_main (see ELM_MAIN) and create our window.
|
|
|
|
* @dontinclude anchorblock_example_01.c
|
|
|
|
* @skip int
|
|
|
|
* @until const char
|
|
|
|
* @until ;
|
|
|
|
*
|
|
|
|
* With the needed variables declared, we'll create the window and a box to
|
|
|
|
* hold our widgets, but we don't need to go through that here.
|
|
|
|
*
|
|
|
|
* In order to make clear where the anchorblock ends and the anchorview
|
|
|
|
* begins, they'll be each inside a @ref Frame. After creating the frame,
|
|
|
|
* the anchorblock follows.
|
|
|
|
* @skip elm_frame_add
|
|
|
|
* @until elm_frame_content_set
|
|
|
|
*
|
|
|
|
* Nothing out of the ordinary there. What's worth mentioning is the call
|
|
|
|
* to elm_anchorblock_hover_parent_set(). We are telling our widget that
|
|
|
|
* when an anchor is clicked, the hover for the popup will cover the entire
|
|
|
|
* window. This affects the area that will be obscured by the hover and
|
|
|
|
* where clicking will dismiss it, as well as the calculations it does to
|
|
|
|
* inform the best locations where to insert the popups content.
|
|
|
|
* Other than that, the code is pretty standard. We also need to set our
|
|
|
|
* callback for when an anchor is clicked, since it's our task to populate
|
|
|
|
* the popup. There's no default for it.
|
|
|
|
*
|
|
|
|
* The anchorview is no different, we only change a few things so it looks
|
|
|
|
* different.
|
|
|
|
* @until elm_frame_content_set
|
|
|
|
*
|
|
|
|
* Then we run, so stuff works and close our main function in the usual way.
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* Now, a little note. Normally you would use either one of anchorblock or
|
|
|
|
* anchorview, set your one callback to clicks and do your stuff in there.
|
|
|
|
* In this example, however, there are a few tricks to make it easier to
|
|
|
|
* show both widgets in one go (and to save me some typing). So we have
|
|
|
|
* two callbacks, one per widget, that will call a common function to do
|
|
|
|
* the rest. The trick is using ::Elm_Entry_Anchorblock_Info for the
|
|
|
|
* anchorview too, since both are equal, and passing a callback to use
|
|
|
|
* for our buttons to end the hover, because each widget has a different
|
|
|
|
* function for it.
|
|
|
|
* @until _anchorview_clicked_cb
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The meat of our popup is in the following function. We check what kind
|
|
|
|
* of menu we need to show, based on the name set to the anchor in the
|
|
|
|
* markup text. If there's no type (something went wrong, no valid contact
|
|
|
|
* in the address list) we are just putting a button that does nothing, but
|
|
|
|
* it's perfectly reasonable to just end the hover and call it quits.
|
|
|
|
*
|
|
|
|
* Our popup will consist of one main button in the middle of our hover,
|
|
|
|
* and possibly a secondary button and a list of other options. We'll create
|
|
|
|
* first our main button and check what kind of popup we need afterwards.
|
|
|
|
* @skip static void
|
|
|
|
* @skip static void
|
|
|
|
* @until eina_stringshare_add
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Each button has two callbacks, one is our hack to close the hover
|
|
|
|
* properly based on which widget it belongs to, the other a simple
|
|
|
|
* printf that will show the action with the anchors own data. This is
|
|
|
|
* not how you would usually do it. Instead, the common case is to have
|
|
|
|
* one callback for the button that will know which function to call to end
|
|
|
|
* things, but since we are doing it this way it's worth noting that
|
|
|
|
* smart callbacks will be called in reverse in respect to the order they
|
|
|
|
* were added, and since our @c btn_end_cb will close the hover, and thus
|
|
|
|
* delete our buttons, the other callback wouldn't be called if we had
|
|
|
|
* added it before.
|
|
|
|
*
|
|
|
|
* After our telephone popup, there are a few others that are practically
|
|
|
|
* the same, so they won't be shown here.
|
|
|
|
*
|
|
|
|
* Once we are done with that, it's time to place our actions into our
|
|
|
|
* hover. Main button goes in the middle without much questioning, and then
|
|
|
|
* we see if we have a secondary button and a box of extra options.
|
|
|
|
* Because I said so, secondary button goes on either side and box of
|
|
|
|
* options either on top or below the main one, but to choose which
|
|
|
|
* exactly, we use the hints our callback info has, which saves us from
|
|
|
|
* having to do the math and see which side has more space available, with
|
|
|
|
* a little special case where we delete our extra stuff if there's nowhere
|
|
|
|
* to place it.
|
|
|
|
* @skip url:
|
|
|
|
* @skip }
|
|
|
|
* @skip evas_object_smart
|
|
|
|
* @until evas_object_del(box)
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/anchorblock_01.png
|
|
|
|
* @image latex screenshots/anchorblock_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example anchorblock_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page tutorial_check Check example
|
|
|
|
* @dontinclude check_example_01.c
|
|
|
|
*
|
|
|
|
* This example will show 2 checkboxes, one with just a label and the second
|
|
|
|
* one with both a label and an icon. This example also ilustrates how to
|
|
|
|
* have the checkbox change the value of a variable and how to react to those
|
|
|
|
* changes.
|
|
|
|
*
|
|
|
|
* We will start with the usual setup code:
|
|
|
|
* @until show(bg)
|
|
|
|
*
|
|
|
|
* And now we create our first checkbox, set its label, tell it to change
|
|
|
|
* the value of @p value when the checkbox stats is changed and ask to be
|
|
|
|
* notified of state changes:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* For our second checkbox we are going to set an icon so we need to create
|
|
|
|
* and icon:
|
|
|
|
* @until show
|
|
|
|
* @note For simplicity we are using a rectangle as icon, but any evas object
|
|
|
|
* can be used.
|
|
|
|
*
|
|
|
|
* And for our second checkbox we set the label, icon and state to true:
|
|
|
|
* @until show
|
|
|
|
*
|
|
|
|
* We now do some more setup:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* And finally implement the callback that will be called when the first
|
|
|
|
* checkbox's state changes. This callback will use @p data to print a
|
|
|
|
* message:
|
|
|
|
* @until }
|
|
|
|
* @note This work because @p data is @p value(from the main function) and @p
|
|
|
|
* value is changed when the checkbox is changed.
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/check_example_01.png
|
|
|
|
* @image latex screenshots/check_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example check_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page tutorial_colorselector Color selector example
|
|
|
|
* @dontinclude colorselector_example_01.c
|
|
|
|
*
|
|
|
|
* This example shows how to change the color of a rectangle using a color
|
|
|
|
* selector. We aren't going to explain a lot of the code since it's the
|
|
|
|
* usual setup code:
|
|
|
|
* @until show(rect)
|
|
|
|
*
|
|
|
|
* Now that we have a window with background and a rectangle we can create
|
2012-03-09 05:04:00 -08:00
|
|
|
* 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)
|
2011-07-27 12:38:52 -07:00
|
|
|
*
|
2012-03-09 05:04:00 -08:00
|
|
|
* Next we ask to be notified whenever the color changes on selector:
|
2011-07-27 12:38:52 -07:00
|
|
|
* @until changed
|
|
|
|
*
|
2012-03-09 05:04:00 -08:00
|
|
|
* 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:
|
2011-07-27 12:38:52 -07:00
|
|
|
* @until ELM_MAIN()
|
|
|
|
*
|
2012-03-09 05:04:00 -08:00
|
|
|
* 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:
|
2011-07-27 12:38:52 -07:00
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* This example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/colorselector_example_01.png
|
|
|
|
* @image latex screenshots/colorselector_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example colorselector_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-27 12:38:43 -07:00
|
|
|
/**
|
|
|
|
* @page slideshow_example Slideshow widget example
|
|
|
|
*
|
|
|
|
* This application is aimed to exemplify the slideshow widget. It
|
|
|
|
* consists of a window with a slideshow widget set as "resize
|
|
|
|
* object", along with a control bar, in the form of a notify. Those
|
|
|
|
* controls will exercise most of the slideshow's API functions.
|
|
|
|
*
|
|
|
|
* We create the slideshow, itself, first, making it @b loop on its
|
|
|
|
* image itens, when in slideshow mode:
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip slideshow = elm_slideshow_add
|
|
|
|
* @until evas_object_show
|
|
|
|
*
|
|
|
|
* Next, we define the <b>item class</b> for our slideshow
|
|
|
|
* items. Slideshow images are going to be Elementary @ref Photo "photo"
|
|
|
|
* widgets, here, as pointed by our @c get class
|
|
|
|
* function. We'll let the Elementary infrastructure to delete those
|
|
|
|
* objects for us, and, as there's no additional data attached to our
|
|
|
|
* slideshow items, the @c del class function can be left undefined:
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip itc
|
|
|
|
* @until ;
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip itc.func
|
|
|
|
* @until = NULL
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip get our images to make slideshow items
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* We now get to populate the slideshow widget with items. Our images
|
|
|
|
* are going to be some randomly chosen from the Elementary package,
|
|
|
|
* nine of them. For the first eight, we insert them ordered in the
|
|
|
|
* widget, by using elm_slideshow_item_sorted_insert(). The comparing
|
|
|
|
* function will use the image names to sort items. The last item is
|
|
|
|
* inserted at the end of the slideshow's items list, with
|
|
|
|
* elm_slideshow_item_add(). We check out how that list ends with
|
|
|
|
* elm_slideshow_items_get(), than:
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip static const char *img
|
|
|
|
* @until _2
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip first =
|
|
|
|
* @until data_get
|
|
|
|
*
|
|
|
|
* Note that we save the pointers to the first and last items in the
|
|
|
|
* slideshow, for future use.
|
|
|
|
*
|
|
|
|
* What follows is the code creating a notify, to be shown over the
|
|
|
|
* slideshow's viewport, with knobs to act on it. We're not showing
|
|
|
|
* that boilerplate code, but only the callbacks attached to the
|
|
|
|
* interesting smart events of those knobs. The first four are
|
|
|
|
* buttons, which will:
|
|
|
|
* - Select the @b next item in the slideshow
|
|
|
|
* - Select the @b previous item in the slideshow
|
|
|
|
* - Select the @b first item in the slideshow
|
|
|
|
* - Select the @b last item in the slideshow
|
|
|
|
*
|
|
|
|
* Check out the code for those four actions, being the two last @c
|
|
|
|
* data pointers the same @c first and @c last pointers we save
|
|
|
|
* before, respectively:
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip jump to next
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* What follow are two hoversels, meant for one to change the
|
|
|
|
* slideshow's @b transition and @b layout styles, respectively. We
|
|
|
|
* fetch all the available transition and layout names to populate
|
|
|
|
* those widgets and, when one selects any of them, we apply the
|
|
|
|
* corresponding setters on the slideshow:
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip hv = elm_hoversel_add
|
|
|
|
* @until show(hv)
|
|
|
|
* @until show(hv)
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip transition changed
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* For one to change the transition @b time on the slideshow widget,
|
|
|
|
* we use a spinner widget. We set it to the initial value of 3
|
|
|
|
* (seconds), which will be probed by the next knob -- a button
|
|
|
|
* starting the slideshow, de facto. Note that changing the transition
|
|
|
|
* time while a slideshow is already happening will ajust its
|
|
|
|
* transition time:
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip spin = elm_spinner_add
|
|
|
|
* @until evas_object_show
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip slideshow transition time has
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Finally, we have two buttons which will, respectively, start and
|
|
|
|
* stop the slideshow on our widget. Here are their "clicked"
|
|
|
|
* callbacks:
|
|
|
|
* @dontinclude slideshow_example.c
|
|
|
|
* @skip start the show
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* This is how the example program's window looks like:
|
|
|
|
* @image html screenshots/slideshow_example.png
|
|
|
|
* @image latex screenshots/slideshow_example.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* See the full @ref slideshow_example_c "source code" for
|
|
|
|
* this example.
|
|
|
|
*
|
|
|
|
* @example slideshow_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-27 13:36:47 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_photocam Photocam example
|
|
|
|
* @dontinclude photocam_example_01.c
|
|
|
|
*
|
|
|
|
* In this example we will have a photocam and a couple of buttons and slider to
|
|
|
|
* control the photocam. To avoid cluttering we'll only show the parts of the
|
|
|
|
* example that relate to the photocam, the full source code can be seen @ref
|
|
|
|
* photocam_example_01.c "here".
|
|
|
|
*
|
|
|
|
* Creating a photocam is as easy as creating any other widget:
|
|
|
|
* @skipline elm_photocam_add
|
|
|
|
*
|
|
|
|
* A photocam is only useful if we have a image on it, so lets set a file for it
|
|
|
|
* to work with:
|
|
|
|
* @until file_set
|
|
|
|
*
|
|
|
|
* We now set the photocam to not bounce horizontally:
|
|
|
|
* @until bounce_set
|
|
|
|
*
|
|
|
|
* And we want to know when the photocam has finished loading the image so:
|
|
|
|
* @until smart_callback
|
|
|
|
*
|
|
|
|
* The reason to know when the image is loaded is so that we can bring the
|
|
|
|
* center of the image into view:
|
|
|
|
* @skip static
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* As mentioned we have 2 buttons in this example, the "Fit" one will cause
|
|
|
|
* the photocam to go in to a zoom mode that makes the image fit inside the
|
|
|
|
* photocam. Tough this has no effect on the image we also print what region was
|
|
|
|
* being viewed before setting the zoom mode:
|
2012-03-21 10:57:34 -07:00
|
|
|
* @skip static
|
2011-07-27 13:36:47 -07:00
|
|
|
* @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:
|
2012-03-21 10:57:34 -07:00
|
|
|
* @skip static
|
2011-07-27 13:36:47 -07:00
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Our slider controls the level of zoom of the photocam:
|
2012-03-21 10:57:34 -07:00
|
|
|
* @skip static
|
2011-07-27 13:36:47 -07:00
|
|
|
* @until }
|
|
|
|
* @note It is important to note that this only works when in manual zoom mode.
|
|
|
|
*
|
|
|
|
* Our example will initially look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/photocam_example_01.png
|
|
|
|
* @image latex screenshots/photocam_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example photocam_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-28 05:11:26 -07:00
|
|
|
/**
|
|
|
|
* @page inwin_example_01 Inwin - General overview
|
|
|
|
*
|
|
|
|
* Inwin is a very simple widget to show, so this example will be a very simple
|
|
|
|
* one, just using all of the available API.
|
|
|
|
*
|
|
|
|
* The program is nothing but a window with a lonely button, as shown here.
|
|
|
|
*
|
|
|
|
* @image html screenshots/inwin_example.png
|
|
|
|
* @image latex screenshots/inwin_example.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* And pressing the button makes an inwin appear.
|
|
|
|
*
|
|
|
|
* @image html screenshots/inwin_example_a.png
|
|
|
|
* @image latex screenshots/inwin_example_a.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* And the code is just as simple. We being with some global variables to keep
|
|
|
|
* track of our Inwin.
|
|
|
|
* @dontinclude inwin_example.c
|
|
|
|
* @skip static
|
|
|
|
* @until current_style
|
|
|
|
*
|
|
|
|
* And two callbacks used by the buttons the above screenshot showed. In these,
|
|
|
|
* we check if @c inwin exists and execute the proper action on it. If it's not
|
|
|
|
* there anymore, then we were abandoned to our luck, so we disabled ourselves.
|
|
|
|
* @until _inwin_destroy
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* The lonely button from the beginning, when clicked, will call the following
|
|
|
|
* function, which begins by checking if an inwin exists, and if it's there,
|
|
|
|
* we bring it back to the front and exit from our function without any further
|
|
|
|
* ado.
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* But if no inwin is there to show, we need to create one. First we need the
|
|
|
|
* top-most window for the program, as no inwin can be created using other
|
|
|
|
* objects as parents. Then we create our popup, set the next style in the list
|
|
|
|
* and show it.
|
|
|
|
* @until current_style =
|
|
|
|
*
|
|
|
|
* As for the content of our inwin, it's just a box with a label and some
|
|
|
|
* buttons inside.
|
|
|
|
* @until _inwin_destroy
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* Now, all the code above shows how every object must always be set as content
|
|
|
|
* for some other object, be it by setting the full content, packing it in a
|
|
|
|
* box or table or working as icon for some other widget. But we didn't do
|
|
|
|
* anything like that for the inwin, this one is just created and shown and
|
|
|
|
* everything works. Other widgets can be used this way, but they would need
|
|
|
|
* to be placed and resized manually or nothing would be shown correctly. The
|
|
|
|
* inwin, however, sets itself as a children of the top-level window and will
|
|
|
|
* be resized as the parent window changes too.
|
|
|
|
*
|
|
|
|
* Another characteristic of Inwin is that when it's shown above everyone else,
|
|
|
|
* it will work kind of like a modal window, blocking any other widget from
|
|
|
|
* receiving events until the window is manually dismissed by pressing some
|
|
|
|
* button to close it or having blocking task signalling its completion so
|
|
|
|
* normal operations can be resumed. This is unlike the @ref Hover widget,
|
|
|
|
* that would show its content on top of the designated target, but clicking
|
|
|
|
* anywhere else would dismiss it automatically.
|
|
|
|
*
|
|
|
|
* To illustrate that last point, when we close the main window and an inwin
|
|
|
|
* is still there, we'll take out the content from the inwin and place it in
|
|
|
|
* a hover.
|
|
|
|
* @until }
|
|
|
|
* @until }
|
|
|
|
*
|
|
|
|
* And the rest of the program doesn't have anything else related to inwin,
|
|
|
|
* so it won't be shown here, but you can find it in
|
|
|
|
* @ref inwin_example.c "inwin_example.c".
|
|
|
|
*
|
|
|
|
* @example inwin_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-28 07:53:26 -07:00
|
|
|
/**
|
|
|
|
* @page tutorial_scroller Scroller example
|
|
|
|
* @dontinclude scroller_example_01.c
|
|
|
|
*
|
|
|
|
* This example is very short and will illustrate one way to use a scroller.
|
|
|
|
* We'll omit the declaration of the @p text variable because it's a very long
|
|
|
|
* @htmlonly<a href="http://lipsum.com/">@endhtmlonly ipsum lorem
|
|
|
|
* @htmlonly</a>@endhtmlonly. If you really want to see the full code, it's @ref
|
|
|
|
* scroller_example_01.c "scroller_example_01.c".
|
|
|
|
*
|
|
|
|
* We start our example by creating our window and background:
|
|
|
|
* @skip EAPI
|
|
|
|
* @until show(bg)
|
|
|
|
*
|
|
|
|
* Next we create a label and set it's text to @p text(very long ipsum lorem):
|
|
|
|
* @until show(label)
|
|
|
|
*
|
|
|
|
* We then create our scroller, ask that it have the same size as the window and
|
|
|
|
* set its content:
|
|
|
|
* @until content_set
|
|
|
|
*
|
|
|
|
* We are now going to set a number of properties in our scroller:
|
|
|
|
* @li We make it bounce horizontally but not vertically.
|
|
|
|
* @li We make both scrollbars always be visible.
|
|
|
|
* @li We have the events be propagated from the content to the scroller.
|
|
|
|
* @li We enforce a page policy vertically(having a page be the size of the
|
|
|
|
* viewport) and leave horizontal scrolling free.
|
|
|
|
* @li And finally we ask the scroller to show us a region starting at 50,50 and
|
|
|
|
* having a width and height of 200px.
|
|
|
|
* @until region_show
|
|
|
|
* @note Observant reader will note that the elm_scroller_region_show() didn't
|
|
|
|
* scroll the view vertically, this is because we told the scroller to only
|
|
|
|
* accept vertical scrolling in pages.
|
|
|
|
*
|
|
|
|
* And now we're done:
|
|
|
|
* @until ELM_MAIN
|
|
|
|
*
|
|
|
|
* Our example will look like this:
|
|
|
|
*
|
|
|
|
* @image html screenshots/scroller_example_01.png
|
|
|
|
* @image latex screenshots/scroller_example_01.eps width=\textwidth
|
|
|
|
*
|
|
|
|
* @example scroller_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-28 09:51:39 -07:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-07-29 14:40:54 -07:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-08-02 09:44:48 -07:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-10-12 21:45:18 -07:00
|
|
|
/**
|
|
|
|
* @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
|
2012-02-16 01:26:35 -08:00
|
|
|
* @until naviframe_item_simple_promote
|
2011-10-12 21:45:18 -07:00
|
|
|
* @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.
|
|
|
|
*
|
2012-03-21 10:57:34 -07:00
|
|
|
* @skip td->tab = NULL
|
2011-10-12 21:45:18 -07:00
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-09-28 04:53:41 -07:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-06-21 11:14:26 -07:00
|
|
|
/**
|
|
|
|
* @page bg_example_01_c bg_example_01.c
|
|
|
|
* @include bg_example_01.c
|
|
|
|
* @example bg_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page bg_example_02_c bg_example_02.c
|
|
|
|
* @include bg_example_02.c
|
|
|
|
* @example bg_example_02.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page bg_example_03_c bg_example_03.c
|
|
|
|
* @include bg_example_03.c
|
|
|
|
* @example bg_example_03.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page actionslider_example_01 Actionslider example
|
|
|
|
* @include actionslider_example_01.c
|
|
|
|
* @example actionslider_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page transit_example_01_c Transit example 1
|
|
|
|
* @include transit_example_01.c
|
|
|
|
* @example transit_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page transit_example_02_c Transit example 2
|
|
|
|
* @include transit_example_02.c
|
|
|
|
* @example transit_example_02.c
|
|
|
|
*/
|
2011-06-22 07:52:05 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @page general_functions_example_c General (top-level) functions example
|
|
|
|
* @include general_funcs_example.c
|
|
|
|
* @example general_funcs_example.c
|
|
|
|
*/
|
2011-07-15 07:03:21 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @page clock_example_c Clock example
|
|
|
|
* @include clock_example.c
|
|
|
|
* @example clock_example.c
|
|
|
|
*/
|
|
|
|
|
2012-03-05 03:07:05 -08:00
|
|
|
/**
|
|
|
|
* @page datetime_example_c Datetime example
|
|
|
|
* @include datetime_example.c
|
|
|
|
* @example datetime_example.c
|
|
|
|
*/
|
|
|
|
|
2012-03-06 20:57:03 -08:00
|
|
|
/**
|
|
|
|
* @page dayselector_example_c Dayselector example
|
|
|
|
* @include dayselector_example.c
|
|
|
|
* @example dayselector_example.c
|
|
|
|
*/
|
|
|
|
|
2011-07-15 07:03:21 -07:00
|
|
|
/**
|
|
|
|
* @page flipselector_example_c Flipselector example
|
|
|
|
* @include flipselector_example.c
|
|
|
|
* @example flipselector_example.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page fileselector_example_c Fileselector example
|
|
|
|
* @include fileselector_example.c
|
|
|
|
* @example fileselector_example.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page fileselector_button_example_c Fileselector button example
|
|
|
|
* @include fileselector_button_example.c
|
|
|
|
* @example fileselector_button_example.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page fileselector_entry_example_c Fileselector entry example
|
|
|
|
* @include fileselector_entry_example.c
|
|
|
|
* @example fileselector_entry_example.c
|
|
|
|
*/
|
2011-07-20 09:28:12 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @page index_example_01_c Index example
|
|
|
|
* @include index_example_01.c
|
|
|
|
* @example index_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page index_example_02_c Index example
|
|
|
|
* @include index_example_02.c
|
|
|
|
* @example index_example_02.c
|
|
|
|
*/
|
2011-07-20 13:58:17 -07:00
|
|
|
|
2011-07-20 14:10:30 -07:00
|
|
|
/**
|
2011-07-20 13:58:17 -07:00
|
|
|
* @page layout_example_01_c layout_example_01.c
|
|
|
|
* @include layout_example_01.c
|
|
|
|
* @example layout_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page layout_example_02_c layout_example_02.c
|
|
|
|
* @include layout_example_02.c
|
|
|
|
* @example layout_example_02.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page layout_example_03_c layout_example_03.c
|
|
|
|
* @include layout_example_03.c
|
|
|
|
* @example layout_example_03.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page layout_example_edc An example of layout theme file
|
|
|
|
*
|
|
|
|
* This theme file contains two groups. Each of them is a different theme, and
|
|
|
|
* can be used by an Elementary Layout widget. A theme can be used more than
|
|
|
|
* once by many different Elementary Layout widgets too.
|
|
|
|
*
|
|
|
|
* @include layout_example.edc
|
|
|
|
* @example layout_example.edc
|
2011-07-28 14:27:32 -07:00
|
|
|
*/
|
2011-07-25 12:51:57 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @page gengrid_example_c Gengrid example
|
|
|
|
* @include gengrid_example.c
|
|
|
|
* @example gengrid_example.c
|
2011-07-20 13:58:17 -07:00
|
|
|
*/
|
2011-07-26 11:32:14 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @page genlist_example_01_c genlist_example_01.c
|
|
|
|
* @include genlist_example_01.c
|
|
|
|
* @example genlist_example_01.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @page genlist_example_02_c genlist_example_02.c
|
|
|
|
* @include genlist_example_02.c
|
|
|
|
* @example genlist_example_02.c
|
|
|
|
*/
|
2011-07-26 13:11:39 -07:00
|
|
|
|
2011-07-28 14:27:32 -07:00
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|
|
|
|
|
2011-08-01 10:37:10 -07:00
|
|
|
/**
|
|
|
|
* @page thumb_example_01_c thumb_example_01.c
|
|
|
|
* @include thumb_example_01.c
|
|
|
|
* @example thumb_example_01.c
|
|
|
|
*/
|
|
|
|
|
2011-07-26 13:11:39 -07:00
|
|
|
/**
|
|
|
|
* @page progressbar_example_c Progress bar example
|
|
|
|
* @include progressbar_example.c
|
|
|
|
* @example progressbar_example.c
|
|
|
|
*/
|
2011-07-27 12:38:43 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @page slideshow_example_c Slideshow example
|
|
|
|
* @include slideshow_example.c
|
|
|
|
* @example slideshow_example.c
|
|
|
|
*/
|
2011-09-28 04:53:41 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @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
|
|
|
|
*/
|