/**
 * @page Examples-cxx Examples with C++ Bindings.
 *
 * Here is a list of Elementary C++ Examples.
 *
 * @ref bg_cxx_example_01
 *
 * @ref bg_cxx_example_02
 *
 * @ref bubble_cxx_example_01
 *
 * @ref button_cxx_example_00
 * 
 * @ref button_cxx_example_01
 *
 * @ref calendar_cxx_example_01
 *
 * @ref calendar_cxx_example_02
 *
 * @ref calendar_cxx_example_03
 *
 * @ref calendar_cxx_example_04
 *
 * @ref calendar_cxx_example_05
 *
 * @ref clock_cxx_example
 *
 * @ref datetime_cxx_example
 *
 * @ref glview_cxx_example_01
 *
 * @ref hoversel_cxx_example_01
 *
 * @ref icon_cxx_example_01
 *
 * @ref menu_cxx_example_01
 *
 * @ref popup_cxx_example_01
 *
 * @ref radio_cxx_example_01
 *
 * @ref separator_cxx_example_01
 *
 * @ref slider_cxx_example
 *
 * @ref spinner_cxx_example
 *
 * @ref table_cxx_example_01
 *
 * @ref table_cxx_example_02
 *
 * @ref thumb_cxx_example_01
 * 
 */

/**
 * @page lambda Lambda Functions with Elementary - C++11
 
 * With this tutorial we'll give you a better view of how the lambda
 * function can and will be constantly use in the C++ bindings. For a
 * more broad approach you should do a little web research.
 
 * The syntax adopted for these examples:
 
 * @c [capture] @c (parameters) @c {body}
 
 * @a capture: Determinate how and if the capture occurs. Possible
 * indicators, two or more should be intercalated by commas:

 * @li [ ] - Capture nothing

 * @li [&] - Capture variables by reference

 * @li [=] - Capture variables by copy

 * @li [&a, b] - Capture <b> only @a a </b> by reference and <b> only
 * @a b </b> by copy

 * @li [&, a] - Capture variables by reference and <b> only @a a </b>
 * by copy

 * @li [this] - Capture @c this pointer by copy

 * @a parameters: List of parameters necessary for each specific
 * lambda function.
 
 * @a body: Function body

 * Let's start with a more simple lambda and later a more complex one,
 * all extracted from elementary examples:

 * <b>First Example</b> - @ref button_cxx_example_00 : 
 
 * @image html screenshots/button_cxx_example_00.png
 * @image latex screenshots/button_cxx_example_00.eps width=\textwidth

 * @dontinclude button_cxx_example_00.cc
 * @skipline btn
 * @skip auto
 * @until clicked_add

 * In this example we use a @a lambda function for elm::button
 * btn that will be called when that button is clicked in
 * callback_clicked_add( on_click ). This lambda will then ask to exit
 * Elementary's main loop with @a elm_exit(). If this call is issued,
 * it will flag the main loop to cease processing and return back to
 * its parent function, usually your elm_main() function.

 * Now let's analize the sintax used for this lambda:

 * With @a [] we are signaling that we don't want to capture any
 * variables and with @a () we are indicating that this lambda doesn't
 * need parameters to work as it should. Now the important part of this
 * function it's the @a body represented by @a {} where we are applying
 * elm_exit() everytime this lambda is called.

 * In this case we are using @a std::bind to bind the parameters of
 * our lambda function to return as @a std::function object to
 * on_click which was declare as auto.

 * For this example with std::bind we simplified our work simply
 * because we didn't have to search in the code or documentation of
 * Elementary to look for the parameters and/or values that the
 * callback_clicked_add requires of the function we are adding.

 * <b>Second Example</b> - @ref hoversel_cxx_example_01 : 
 
 * @image html screenshots/hoversel_cxx_example_01.png
 * @image latex screenshots/hoverse_cxx_example_01.eps width=\textwidth

 * @dontinclude hoversel_cxx_example_01.cc
 * @skip add_item
 * @until clicked_add

 * In this example we use a @a lambda function for @a hoversel that
 * will be called when that hoversel is clicked in
 * callback_clicked_add( add_item ). This lambda will then add an item
 * to heversel, note that since we allocate memory for the item we
 * need to know when the item dies so we can free that memory.

 * Now let's analize the sintax used for this lambda:

 * @li @a [] : signaling that we don't want to capture any
 * variables

 * @li @a (::elm::hoversel obj ) : indicating that this lambda needs
 * the parameter @p obj to work as it should. Bbecause we are only
 * adding the parameter we need instead of all the parameters this
 * callback requires we need to use placeholders in std::bind,
 * indicating the place that @obj should occupy in our
 * callback_clicked_add.

 * When the function object returned by bind is called, an argument
 * with placeholder _1 is replaced by the first argument in the call,
 * _2 is replaced by the second argument in the call, and so on.

 * @li @a body represented by @a {} where we are adding ervery
 * function and local variables that will be needed.

 * In this case we are using @a std::bind to bind the parameters of
 * our lambda function to return as @a std::function object to
 * add_item which was declare as auto.

 * @see Consult all examples from elementary with C++ Bindings @ref
 * Examples-cxx "here"
 */

/**
 * @page bg_cxx_example_01 elm::bg - Plain color background with C++ binding
 * @dontinclude bg_cxx_example_01.cc
 
 * This example just sets a default background with a plain color.

 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively. In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set
 
 * Next step is creating an Elementary window, where win calls a
 * constructor and sets the type of the win to ELM_WIN_BASIC
 * (Elm_Win_Type), which is the indicated type for most of our
 * examples. Here we also set the title that will appear at the top of
 * our window and then the autohide state for it.
 
 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
  
 * Now we construct the elm background and for this we use the C++
 * method below, setting it's parent.

 * @skipline ::elm::bg

 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate. This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the background as a resize_object to win informing that
 * when the size of the win changes so should the background's
 * size. And finally we make it visible.
 
 * @skip win
 * @until visibility_set 
 
 * @remarks  If a color it's not setted the default color will be used.
  
 * Now we set the size for the window, making it visible in the end.
 
 * @skip size_set
 * @until visibility_set
 
 * Finally we just have to start the elm mainloop, starting to handle
 * events and drawing operations.
 
 * @skip elm_run
 * @until ELM_MAIN
 
 * The full code for this example can be found at @ref
 * bg_cxx_example_01.cc .

 * @example bg_cxx_example_01.cc
*/

/**
 * @page bg_cxx_example_02 elm::bg - Image background using C++ binding
 * @dontinclude bg_cxx_example_02.cc

 * This is the second background example and shows how to use the
 * Elementary background object to set an image as background of your
 * application.

 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;

 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;

 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;

 * @skip EAPI_MAIN
 * @until elm_policy_set

 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().

 * @see For more details consult elm_policy_set
 
 * Next step is creating an Elementary window, where win calls a
 * constructor and sets the type of the win to ELM_WIN_BASIC
 * (Elm_Win_Type), which is the indicated type for most of our
 * examples. Here we also set the title that will appear at the top of
 * our window and then the autohide state for it.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Our background will have an image, that will be displayed over the
 * background color.

 * To do so, first we set the directory and archive for the image. And
 * create the background that will display it.

 * @skip elm_app_info_set
 * @until ::elm::bg
  
 * Before loading this 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 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 std::stringstream. Then we use this stringstream to set
 * the file name in the background object:
 
 * @skip std::stringstream
 * @until file_set
 
 * Notice that the second argument of the file_set() function is @c
 * nullptr, since we are setting an image to this background. This
 * function also supports setting an Eet file as background, in which
 * case the @c key parameter wouldn't be @c nullptr, but be the name
 * of the Eet key instead.
 
 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * This is a hint on how a container object should resize a given
 * child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the background as a resize_object to win informing that
 * when the size of the win changes so should the background's
 * size. And finally we make background.

 * @skip win
 * @until visibility

 * Now we only have to set the size for our window and make it
 * visible.
 
 * @skip size_set
 * @until visibility_set

 * Finally we just have to start the elm mainloop, starting to handle
 * events and drawing operations.
 
 * @skip elm_run
 * @until ELM_MAIN

 * The full code for this example can be found at @ref
 * bg_cxx_example_02.cc .

 * This example will look like this:

 * @image html screenshots/bg_cxx_example_02.png
 * @image latex screenshots/bg_cxx_example_02.eps width=\textwidth
 * @example bg_cxx_example_02.cc
 */

/**
 * @page bubble_cxx_example_01 elm::bubble - Simple use with C++ binding
 * @dontinclude bubble_cxx_example_01.cc

 * This example shows a bubble with all fields set - label, info,
 * content and icon - and the selected corner changing when the bubble
 * is clicked.
  
 * The first part consists of including the headers. In this case we
 * are working with the Elementary and Evas C++ bindings and thus we
 * need only to include them.
  
 * @skip Elementary
 * @untilt Evas
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an Elementary window, where win calls a
 * constructor and sets the type of the win to ELM_WIN_BASIC
 * (Elm_Win_Type), which is the indicated type for most of our
 * examples. Here we also set the title that will appear at the top of
 * our window and then the autohide state for it.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
 
 * Now we construct the elm background using the C++ method below,
 * setting it's parent.

 * @skipline elm::bg
 
 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.

 * The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * This is a hint on how a container object should resize a given
 * child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the background as a resize_object to win informing that
 * when the size of the win changes so should the background's
 * size. And finally we make it visible. 

 * @skip resize
 * @until visibility_set 

 * @note If a color it's not setted the standard color will be used.
 
 * Here we are creating an elm::label that is going to be used as the
 * content for our bubble:

 * @skip elm::label
 * @until visibility_set
 
 * Despite it's name the bubble's icon in this case it's actually
 * evas::rectangle, that we set it's color to blue and at the end make
 * it visible.

 * @skip evas::rectangle
 * @until visibility_set
  
 * And finally we have the actual bubble creation and the setting of
 * it's label, info and content:

 * @skip elm::bubble
 * @until visibility_set

 * @remark Because we didn't set a corner, the default "top_left" will be used.

 * To have the selected corner change in a clockwise motion we are going to
 * use the following callback using lambda:

 * @skip auto
 * @until });
 
 * @see To learn more about consult @ref lambda.

 * Now that we have our bubble and callback all that is left is adding our
 * lambda as a clicked callback:

 * @line callback_clicked_add

 * 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:

 * @skip label2
 * @until bubble2.visibility_set

 * Now we only have to set the size for our window and make it
 * visible.
 
 * @skip size_set
 * @until visibility_set

 * And finally, start the elm mainloop, starting to handle events and
 * drawing operations.

 * @skip elm_run
 * @until ELM_MAIN

 * Our example will look like this:

 * @image html screenshots/bubble_cxx_example_01.png
 * @image latex screenshots/bubble_cxx_example_01.eps width=\textwidth

 * @see Full source code @ref bubble_cxx_example_01.cc .

 * @example bubble_cxx_example_01.cc
 */

/**
 * @page button_cxx_example_00 Button - Hello, Button!
 * @dontinclude button_cxx_example_00.cc
 
 * Keeping the tradition, this is a simple "Hello, World" button
 * example. We will show how to create a button and associate an
 * action to be performed when you click on it. 
 
 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set
 
 * Next step is creating an Elementary window, where win calls a
 * constructor and sets the type of the win to ELM_WIN_BASIC
 * (Elm_Win_Type), which is the indicated type for most of our
 * examples. Here we also set the title that will appear at the top of
 * our window and then the autohide state for it.
 
 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
  
 * Now we construct the elm background and for this we use the C++
 * method below, setting it's parent.

 * @skipline ::elm::bg

 * The function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's weight. The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.  This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the background as a resize_object to win informing that
 * when the size of the win changes so should the background's
 * size. And finally we make it visible.
 
 * @skip win
 * @until visibility_set 
 
 * @remarks  If a color it's not setted the default color will be used.
  
 * There is only one button on this interface. We need to create this
 * button with the C++ method, set the text to be displayed, the size,
 * position and the size hint for weight.

 * @skip btn
 * @until weight

 * For alignment we'll use the function @c size_hint_align_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_align_set, that is EFL Evas type
 * function. With this function we set the hints for an object's
 * alignment. The parameters are:
 
 * @li x - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as horizontal alignment hint.

 * @li y - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as vertical alignment hint.

 * These are hints on how to align an object inside the boundaries of
 * a container/manager. Accepted values are in the 0.0 to 1.0 range,
 * with the special value EVAS_HINT_FILL used to specify "justify" or
 * "fill" by some users. In this case, maximum size hints should be
 * enforced with higher priority, if they are set. Also, any padding
 * hint set on objects should add up to the alignment space on the
 * final scene composition.

 * For the horizontal component, 0.0 means to the left, 1.0 means to
 * the right. Analogously, for the vertical component, 0.0 to the top,
 * 1.0 means to the bottom.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * @skipline align

 * @note Default alignment hint values are 0.5, for both axis.

 * Continuing with our button we make it visible.

 * @skipline visibility

 * This button performs a basic action: close the application. This
 * behavior is described by on_click() which is a lambda function,
 * that interrupt the program invoking elm_exit(). The lambda function
 * on_click is the added as a clicked callback to btn.

 * @skip on_click
 * @until callback

 * @see For more details consult @ref lambda 
 
 * Now we set the size for the window, making it visible in the end:
 
 * @skip size_set
 * @until visibility_set
 
 * Finally we just have to start the elm mainloop, starting to handle
 * events and drawing operations.

 * @skip elm_run
 * @until ELM_MAIN

 * The full code for this example can be found at @ref
 * button_cxx_example_00.cc .

 * This example will look like this:
 * @image html screenshots/button_cxx_example_00.png
 * @image latex screenshots/button_cxx_example_00.eps width=\textwidth
 * @example button_cxx_example_00.cc
 */

/**
 * @page button_cxx_example_01 Button - Complete example
 * @dontinclude button_cxx_example_01.cc

 * 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.
 
 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
 
 * In this example we'll have several buttons that will be arranged in
 * two boxes that will be inserted in a bigger box. One of the smaller
 * boxes will contain a set of buttons that will set different times
 * for the autorepeat timeouts of the buttons that will be contained in
 * the other smaller box.

 * For all this to work, we will construct the three smaller boxes and
 * all the button that will be needed. The smaller boxes will be then
 * packed in the bigger one.

 * In this part we'll create our directional buttons, that we'll be
 * added in the third smaller box, this is necessary for our callback
 * to work properly.

 * @skip icon
 * @until right

 * Now let's create our bigger box using the C++ method and setting
 * it's parent as win.

 * @skipline box

 * The function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's weight. The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.  This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.
 
 * Now we add the box as a resize_object to win informing that when
 * the size of the win changes so should the box's size. And finally
 * we make it visible.
 
 * @skip win
 * @until visibility_set 

 * Creating our initial box, again using the C++ method, in this case
 * we want the arrangement of the objects, that this box will contain,
 * to be displayed horizontally and fot this we will set horizontal to
 * @p true, vertical by default.
 
 * @skip box
 * @until horizontal

 * Again we'll set the size hint for weight, but in this box we will
 * set the packing method to include this box inside the bigger one.

 * When using the elm box the packing method of the subobj - box in
 * this case - should be defined. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality. In this part of the code we also make calendar
 * visible.

 * @skip pack_end
 * @until visibility

 * Now let's start creating the buttons that will be included in this
 * first small box, this will contain the initial timeout button.

 * We'll use again the C++ method to create this button, set a text,
 * packing method for btn and finally make it visible.

 * @skip btn
 * @until visibility

 * In this part we'll use Lambda type function that will be added in
 * the clicked callback for all buttons in the first smaller box,
 * that'll identify the current initial and gap to be use in the
 * autorepeat timeout that will move the central button.

 * @skip auto
 * @until callback

 * @note To learn more about Lambda Function and its use in Elementary
 * consult @ref lambda.

 * The second and third button will also set the initial timeout but
 * with different values.

 * @skip btn2
 * @until btn3.callback

 * Now for our gap timeout buttons will create our second smaller box,
 * the same way with the initial box, we'll use the C++ method, set to
 * be horizontal, set the size hint weight, choose the packing method
 * and set the visibility to true.

 * @skip box_gap
 * @until visibility
 
 * For our gap buttons we'll again, use the C++ method, set the texts
 * with the different values for gap, choose the packing method, set
 * the visibility and the clicked callback.

 * @skip btn4
 * @until btn6.callback

 * Now we'll give our directional buttons more options so that it will
 * visible and also have all the caracteristics that is require.

 * For the up button, we'll set to @p true the autorepeat,
 * autorepeat_initial_timeout, autoreapet_gap_timeout, the size hints
 * for weight and alignment, choose our packing method and making out
 * up button visible.

 * @skip up
 * @until visibility

 * For this directional buttons we'll have a different repeated
 * callback that will insure the timeouts of our middle button in the
 * gap and initial timeout that is current setted.

 * @skip auto
 * @until 

 * For our second callback, we'll detail the release of our
 * directional buttons.

 * @skip auto
 * @until callback

 * Finishing our up button, we'll create an icon, that'll will be the
 * standard "arrow_up".

 * @skip icon
 * @until content

 * This last box, will content all the directional buttons and the
 * middle button. As before, we use the C++ method, horizontal set,
 * weight and align hints, chose the packing method and make it
 * visible.

 * @skip box
 * @until visibility

 * Now we'll create all the directional and middle buttons, the same as we did with the up button,
 * changing only the icon.

 * @skip left
 * @until down.content

 * Now we set the size for the window, making it visible in the end:
 
 * @skip size_set
 * @until visibility_set
 
 * Finally we just have to start the elm mainloop, starting to handle
 * events and drawing operations.

 * @skip elm_run
 * @until ELM_MAIN

 * The full code for this example can be found at @ref
 * button_cxx_example_01.cc .
 
 * This example will look like this:
 * @image html screenshots/button_cxx_example_01.png
 * @image latex screenshots/button_cxx_example_01.eps width=\textwidth
 * @example button_cxx_example_01.cc
 */

/**
 * @page calendar_cxx_example_01 Calendar - Simple creation with C++ binding
 * @dontinclude calendar_cxx_example_01.cc

 * As a first example, let's just display a calendar in our window,
 * explaining all steps required to do so.
 
 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
 
 * Now, the exciting part, let's create the calendar with the C++
 * binding method, passing our window object as parent.

 * @skipline elm::calendar

 * The function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's weight. The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.  This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the calendar as a resize-object to win informing that
 * when the size of the win changes so should the calendar's
 * size. And finally we make it visible.

 * @skip win
 * @until visibility

 * Finally we just have to start the elm mainloop, starting to handle
 * events and drawing operations.
 
 * @skip elm_run
 * @until ELM_MAIN

 * Our example will look like this:

 * @image html screenshots/calendar_cxx_example_01.png

 * @image latex screenshots/calendar_cxx_example_01.eps width=\textwidth

 * See the full source code @ref calendar_cxx_example_01.cc here.

 * @example calendar_cxx_example_01.cc
 */

/**
 * @page calendar_cxx_example_02 Calendar - Layout strings formatting with C++ binding
 * @dontinclude calendar_cxx_example_02.cc
 
 * In this simple example, we'll explain how to format the labels
 * displaying month and year, and also set weekday names.

 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we will jump to the actual code and later explain the function
 * to make this tutorial more didactical.

 * We must set the elm_policy, which defines for a given policy
 * group/identifier a new policy's value, respectively.  In this
 * example the only policy we need to set a value for is @c
 * ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.
 
 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Now let's create the calendar with the C++ binding method, passing
 * our window object as parent.

 * @skipline elm::calendar

 * The function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's weight. The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.  This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the calendar as a resize-object to win informing that
 * when the size of the win changes so should the calendar's
 * size.

 * @skipline win

 * To format month and year labels, 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 <tt> tm_sec   seconds [0,59] </tt>
 * @li <tt> tm_min   minutes [0,59] </tt>
 * @li <tt> tm_hour  hour [0,23] </tt>
 * @li <tt> tm_mday  day of month [1,31] </tt>
 * @li <tt> tm_mon   month of year [0,11] </tt>
 * @li <tt> tm_year  years since 1900 </tt>
 * @li <tt> tm_wday  day of week [0,6] (Sunday = 0) </tt>
 * @li <tt> tm_yday  day of year [0,365] </tt>
 * @li <tt> tm_isdst daylight savings flag </tt>

 * @note Glib version has 2 additional fields.

 * For our function @p _format_month_year , only stuff that matters
 * are <tt>tm_mon</tt> and <tt>tm_year</tt>. 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:

 * @dontinclude calendar_cxx_example_02.cc
 * @skip 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 format_function_set
 
 * To set weekday names, we should declare them as an array of
 * strings:

 * @dontinclude calendar_cxx_example_02.cc
 * @skip weekdays[]
 * @until }

 * And then set them to calendar:
 * @skipline weekdays_names_set

 * Finally we just have to make the calendar and window visible and
 * then start the elm mainloop, starting to handle events and drawing
 * operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * Our example will look like this:

 * @image html screenshots/calendar_cxx_example_02.png
 * @image latex screenshots/calendar_cxx_example_02.eps width=\textwidth
 
 * See the full source code @ref calendar_cxx_example_02.cc here.
 * @example calendar_cxx_example_02.cc
 */

/**
 * @page calendar_cxx_example_03 Calendar - Years restrictions with C++ binding
 * @dontinclude calendar_cxx_example_03.cc

 * 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 maximum value will depends on platform architecture
 * (year 2037 for 32 bits); You can read more about time functions on
 * @c ctime manpage.

 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively. In this example the only policy we need to set
 * a value for is @c ELM_POLICY_QUIT, possibles values for it are:
 * function to make this tutorial more didactical.

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.
 
 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Now let's create the calendar with the C++ binding method, passing
 * our window object as parent.

 * @skipline elm::calendar

 * The function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's weight. The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.  This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the calendar as a resize-object to win informing that
 * when the size of the win changes so should the calendar's
 * size.

 * @skipline win

 * Straigh to the point, to set it is enough to call
 * min_max_year_set(). First value is minimum 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 min_max_year_set 

 * Finally we just have to make the calendar and window visible and
 * then start the elm mainloop, starting to handle events and drawing
 * operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * Our example will look like this:

 * @image html screenshots/calendar_cxx_example_03.png
 * @image latex screenshots/calendar_cxx_example_03.eps width=\textwidth

 * See the full source code @ref calendar_cxx_example_03.cc here.

 * @example calendar_cxx_example_03.cc
 */

/**
 * @page calendar_cxx_example_04 Calendar - Days selection with C++ binding.
 * @dontinclude calendar_cxx_example_04.cc
 
 * 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.

 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively. In this example the only policy we need to set
 * a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * In this example we'll need to use a elm::box to layout the two
 * calendars that'll be created. A box arranges objects in a linear
 * fashion, governed by a layout function that defines the details of
 * this arrangement. The box will use an internal function
 * to set the layout to a single row, vertical by default.

 * Now let's create the box with the C++ binding method, passing
 * our window object as parent.

 * @skipline elm::box

 * The function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's weight. The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.  This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the box as a resize-object to win informing that when
 * the size of the win changes so should the box's size. Remember
 * always to set the box visibility to true.

 * @skip win  
 * @until visibility

 * Now let's create the calendar with the C++ binding method, passing
 * our window object as parent. The function size_hint_weight_set
 * works with calendar the same way as with box, for more, search
 * above.

 * @skip elm::calendar
 * @until weight_set
 
 * The function @c size_hint_align_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_align_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's alignment. The parameters are:
 
 * @li x - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as horizontal alignment hint.

 * @li y - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as vertical alignment hint.

 * These are hints on how to align an object inside the boundaries of
 * a container/manager. Accepted values are in the 0.0 to 1.0 range,
 * with the special value EVAS_HINT_FILL used to specify "justify" or
 * "fill" by some users. In this case, maximum size hints should be
 * enforced with higher priority, if they are set. Also, any padding
 * hint set on objects should add up to the alignment space on the
 * final scene composition.

 * For the horizontal component, 0.0 means to the left, 1.0 means to
 * the right. Analogously, for the vertical component, 0.0 to the top,
 * 1.0 means to the bottom.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * @note Default alignment hint values are 0.5, for both axis.

 * @skipline align_set

 * If isn't required that users could select a day on calendar, only
 * interacting going through months, disabling days selection could be
 * a good idea to avoid confusion. For that:

 * @skipline select_mode_set

 * When using the elm box the packing method of the subobj - calendar
 * in this case - should be defined. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality. In this part of the code we also make calendar
 * visible.

 * @skip visibility
 * @until pack_end

 * Also, regarding days selection, you could be interested to set a
 * date to be highlighted on calendar from your code, maybe when a
 * specific event happens or after calendar creation. As @c time
 * output is in seconds, we define the number of seconds contained
 * within a day as a constant:

 * @dontinclude calendar_cxx_example_04.cc
 * @skipline SECS_DAY

 * As with the first calendar, we'll also construct cal2, set it's
 * hint_weight and hint_align, make cal2 visible and choose the
 * packing method.
 
 * @skip cal2
 * @until weight
 * @skip visibility
 * @until pack

 * Now let's select two days from current day:

 * @dontinclude calendar_cxx_example_04.cc
 * @skip time(NULL)
 * @until selected_time_set

 * Finally we just have to make window visible and then start the elm
 * mainloop, starting to handle events and drawing operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * Our example will look like this:

 * @image html screenshots/calendar_cxx_example_04.png
 * @image latex screenshots/calendar_cxx_example_04.eps width=\textwidth

 * See the full source code @ref calendar_cxx_example_04.cc here.
 * @example calendar_cxx_example_04.cc
 */

/**
 * @page calendar_cxx_example_05 Calendar - Signal callback and getters with C++ binding.
 * @dontinclude calendar_cxx_example_05.cc

 * 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. To be more didatical we'll start with the basics.

 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * included here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively. In this example the only policy we need to set
 * a value for is @c ELM_POLICY_QUIT, possibles values for it are:
 * function to make this tutorial more didactical.

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.
 
 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Now let's create the calendar with the C++ binding method, passing
 * our window object as parent.

 * @skipline elm::calendar

 * The function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's weight. The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.  This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the calendar as a resize-object to win informing that
 * when the size of the win changes so should the calendar's
 * size.

 * Let's check our callback function, type lambda:
 * @skip print_cal_info
 * @until double interval;
 
 * To learn more about consult @ref lambda.
 
 * To get selected day, we need to call 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.

 * @skip selected_time_get
 * @until return
 
 * Next we'll get information from calendar and place on declared
 * vars:

 * @skip interval
 * @until 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 with std::cout and finish the lambda
 * function:

 * @skip std::cout
 * @until std::placeholders::_1

 * <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 callback_changed_add

 * Finally we just have to make calendar and window visibles and then
 * start the elm mainloop, starting to handle events and drawing
 * operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * Our example will look like this:

 * @image html screenshots/calendar_cxx_example_05.png
 * @image latex screenshots/calendar_cxx_example_05.eps width=\textwidth

 * See the full source code @ref calendar_cxx_example_05.cc here.
 * @example calendar_cxx_example_05.cc
 */

/**
 * @page clock_cxx_example Clock widget example wit C++ binding.
 * @dontinclude clock_cxx_example.cc
 
 * This code places five Elementary clock widgets on a window, each of
 * them exemplifying a part of the widget's API. Before explaining
 * each clock to be more didatical let's start with the basics.

 * The first part consists of including the headers. In this
 * case we are only working with the Elementary C++ binding and thus
 * we need only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set
 
 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * And we also set the autohide state for win, autohide works
 * similarly to @p autodel, automatically handling "delete,request"
 * signals when set to @p true, with the difference that it will hide
 * the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
  
 * @see For more details consult elm::win::autohide_set().

 * A box arranges objects in a linear fashion, governed by a layout
 * function that defines the details of this arrangement. The box will
 * use an internal function to set the layout to a single row,
 * vertical by default.

 * Now let's create the box with the C++ binding method, passing our
 * window object as parent.

 * @skipline elm::box

 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate. This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Then we add the box as a resize-object to win informing that when
 * the size of the win changes so should the box's size. Remember
 * always to set the box visibility to true.

 * @skip win  
 * @until visibility

 * We create each clock with the C++ binding method, passing our
 * window object as parent. The first of them is the pristine clock,
 * using the defaults for a clock, which are military time with no
 * seconds shown.
 
 * @skipline clock

 * When using the elm::box the packing method of the subobj - clock
 * in this case - should be defined. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality. In this part of the code we also make clock
 * visible.

 * @skip pack_end
 * @until visibility

 * The second clock shows the am/pm time, that we also create with
 * the C++ binding method, passing our window object as
 * parent. Setting show_am_pm to true and again choosing the packing
 * method and making clock visible.

 * @skip clock
 * @until visibility

 * 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
 * time_set():

 * @skip ck3
 * @until visibility

 * 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:

 * @skip ck4
 * @until visibility

 * The fifth, besides editable, has only the time @b units editable,
 * for hours, minutes and seconds. This exemplifies edit_mode_set():

 * @skip ck5
 * @until visibility

 * Finally we just have to make our window visible and then run the
 * elm mainloop, starting to handle events and drawing operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * See the full @ref clock_cxx_example.cc, whose window should look
 * like this picture:

 * @image html screenshots/clock_cxx_example.png
 * @image latex screenshots/clock_cxx_example.eps width=\textwidth
 * @example clock_cxx_example.cc
 */

 /**
 * @page datetime_cxx_example Datetime Example with C++ binding
 * @dontinclude datetime_cxx_example.cc

 * This example places three Elementary Datetime widgets on a window,
 * each of them exemplifying the widget's different usage.

 * The first part consists of including the headers. In this
 * case we are only working with the Elementary C++ binding and thus
 * we need only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set
 
 * Next step is creating an Elementary window, where win calls a
 * constructor and sets the type of the win to ELM_WIN_BASIC
 * (Elm_Win_Type), which is the indicated type for most of our
 * examples. Here we also set the title that will appear at the top of
 * our window and then the autohide state for win.
 
 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
  
 * Now we construct the elm background and for this we use the C++
 * method below, setting it's parent.

 * @skipline ::elm::bg

 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate. This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the background as a resize_object to win informing that
 * when the size of the win changes so should the background's
 * size. And finally we make it visible.
 
 * @skip win
 * @until visibility_set 
 
 * @remarks  If a color it's not setted the default color will be used.

 * A box arranges objects in a linear fashion, governed by a layout
 * function that defines the details of this arrangement. The box will
 * use an internal function to set the layout to a single row,
 * vertical by default.

 * Now let's create the box with the C++ binding method, passing our
 * window object as parent. Using Evas weight_set function again to
 * hint on how a container object should resize a given child within
 * its area. 

 * @skipline elm::box
 * @until weight_set

 * Then we add the box as a resize-object to win informing that when
 * the size of the win changes so should the box's size. Remember
 * always to set the box visibility to true.

 * @skip win  
 * @until visibility

 * The first of them is <b>"only Date display"</b>. We will create it
 * using the C++ method below. The weight hint works with datetime the
 * same as it did with background and box.

 * @skip datetime
 * @until weight

 * Now we have to The function @c size_hint_align_set for C++ bindings
 * originated from C bindings function
 * evas_object_size_hint_align_set, that is EFL Evas type
 * function. With this function we set the hints for an object's
 * alignment. The parameters are:
 
 * @li x - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as horizontal alignment hint.

 * @li y - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as vertical alignment hint.

 * These are hints on how to align an object inside the boundaries of
 * a container/manager. Accepted values are in the 0.0 to 1.0 range,
 * with the special value EVAS_HINT_FILL used to specify "justify" or
 * "fill" by some users. In this case, maximum size hints should be
 * enforced with higher priority, if they are set. Also, any padding
 * hint set on objects should add up to the alignment space on the
 * final scene composition.

 * For the horizontal component, 0.0 means to the left, 1.0 means to
 * the right. Analogously, for the vertical component, 0.0 to the top,
 * 1.0 means to the bottom.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * @skipline align

 * @note Default alignment hint values are 0.5, for both axis.

 * An important feature for the datetime is the setting of what we
 * want it to display. We can achieve that by using:

 * @p field_visible_set ( Elm_Datetime_Field_Type fieldtype_, bool
 *		         visible_)
 
 * Parameters are:

 * @li @p fieldtype_: type of the field, supports 6 fields: 
      
 * @p ELM_DATETIME_YEAR: Indicates Year field.

 * @p ELM_DATETIME_MONTH: Indicates Month field.

 * @p ELM_DATETIME_DATE: Indicates Date field.

 * @p ELM_DATETIME_HOUR: Indicates Hour field,
 
 * @p ELM_DATETIME_MINUTE: Indicates Minute field.

 * @p ELM_DATETIME_AMPM: Indicates AM/PM field.

 * @li @p visible_: @p true field can be visible, @p false otherwise.

 * @attention Setting this API True does not ensure that the field is
 * visible, apart from this, the field's format must be present in
 * Datetime overall format. If a field's visibility is set to False
 * then it won't appear even though its format is present in overall
 * format. So if and only if this API is set true and the
 * corresponding field's format is present in Datetime format, the
 * field is visible.

 * @note By default the field visibility is set to @p true.

 * For this first datetime we are setting the HOUR, MINUTE and AM/PM
 * to not be visible, doing this we'll display in our datetime the
 * year, month and date.

 * @note Hour format 12hr(1-12) or 24hr(0-23) display can be selected
 * by setting the corresponding user format. The corresponding Month
 * and AM/PM strings are displayed according to the system’s language
 * settings.

 * @skip HOUR
 * @until AMPM
 
 * When using the elm box the packing method of the subobj - datetime
 * in this case - should be defined. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality. In this part of the code we also make datetime
 * visible.

 * @skip pack_end
 * @until visibility

 * For our second datetime, we'll also set the size hints weight and
 * align, but in this case, the fields YEAR, MONTH and DATE will be not
 * visible, and thus displaying in our datetime the hour, minute and
 * AM/PM. Finally we choose it's packing method and set the visibility
 * of datetime to @p true.

 * @skip datetime2
 * @until visibility

 * For our third and last datetime, we setted the weight and align as
 * before, chose our packing method and made it visible. Note that in
 * this case we didn't exclude any type of field leaving all visible.
 
 * @skip datetime3
 * @until visibility

 * And finally, we set our win's visibility and start the elm
 * mainloop, starting to handle events and drawing operations.

 * @skip win
 * @until ELM_MAIN

 * See the full @ref datetime_cxx_example.cc .

 * This example should look like:

 * @image html screenshots/datetime_cxx_example.png
 * @image latex screenshots/datetime_cxx_example.eps width=\textwidth

 * @example datetime_cxx_example.cc
 */

/**
 * @page glview_cxx_example_01 Glview example with C++ Binding
 * @dontinclude glview_cxx_example_01.cc
 
 * In this example we'll illustrate how to use Glview and it's
 * features.

 * The first part consists of including the headers. In this case we
 * need to include @p Elementary.hh, @p Evas_GL.h and @p stdio.h.

 *@li @p Elementary.hh: library for Elementary with support for C++
 * language;

 *@li @p Evas_GL.h: has functions that are used to do OpenGL rendering
 * on Evas, Evas allows us to use OpenGL to render to specially set up
 * image objects, which act as render target surfaces. 

 *@li @p stdio.h is a C library with functions tha perform
 * Input/Output operations.

 * @skip Elementary.hh
 * @until stdio
 
 * Continuing with the code, at this point we create a GL related
 * struct:

 *@li @p Evas_GL_API that is the structure type of the Evas GL API object
 * that contains the GL APIs to be used in Evas GL.

 *@li @p GLuint one of the pre-defined types of OpenGL which is a unsigned binary integer.

 *@li @p int AKA @p int.

 * @skip typedef
 * @until };

 * Here we're simply initializing a type float, that we named red.
 
 * @skipline red

 * In this example we'll need a type C helper function to load shaders
 * from a shader source.

 * @skip static
 * @until GLint

 * Inside this function we create the shader objectand load/compile
 * shader source.

 * @skip shader
 * @until return shader;

 * Completing our load shader function.
 
 * @skipline }

 * This example will also need a function to initialize the shader and
 * program object.

 * @skip static
 * @until linked

 * In this function we load the vertex/fragment shaders, create the
 * program object and finish our function.

 * @skip gld
 * @until return 1;
 * @skiline }

 * We need the following callbacks:

 * @li initialize callback: that get called once for
 * initialization;

 * @skip void
 * @until BufferData
 * @skipline }

 * @li delete callback: gets called when glview is deleted;

 * @skip void
 * @until free
 * @skipline }

 * @li resize callback: gets called every time object is resized;

 * @skip void
 * @skipline }

 * @li draw callback: is where all the main GL rendering happens.

 * @skip void
 * @until COLOR_BUFFER

 * Inside this callback, we'll draw a triangle.
 
 * @skip gl
 * @until DrawArrays

 * Still inside as an option we are going to flush the GL pipeline and
 * end our callback.

 * @skip Finish
 * @until }

 * We create @p _anim to notify that glview has changed so it can
 * render.

 * @skip static
 * @until }

 * Now that we finished with the GL preparations, we'll start the main
 * code and initialize our GLData pointer object to NULL and run a
 * check just in case.

 * @skip EAPI_MAIN
 * @until if

 * Let's set the elm_policy, which defines for a given policy
 * group/identifier a new policy's value, respectively. In this
 * example the only policy we need to set a value for is @c
 * ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skipline elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Now let's create a box with the C++ binding method, passing our
 * window object as parent, we'll use this box to contain our glview
 * object.

 * @skipline bx

 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate. This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Then we add the box as a resize-object to win informing that when
 * the size of the win changes so should the box's size. Remember
 * always to set the box visibility to true.

 * @skip win
 * @until visibility

 * In this part we'll create a new elm glview, using the C++ method,
 * in this case it requires that we set @p Evas_GL_Context_Version
 * with the version_constructor. @p Evas_GL_Context_Version is a
 * enumeration that defines the available OpenGL ES version numbers,
 * it can be used to create OpenGL-ES 1.1 contexts.

 * @skip glview
 * @until glapi

 * The function size_hint_weight_set works with glview the same way as
 * with box, for more, search above.

 * The function @c size_hint_align_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_align_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's alignment. The parameters are:
 
 * @li x - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as horizontal alignment hint.

 * @li y - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as vertical alignment hint.

 * These are hints on how to align an object inside the boundaries of
 * a container/manager. Accepted values are in the 0.0 to 1.0 range,
 * with the special value EVAS_HINT_FILL used to specify "justify" or
 * "fill" by some users. In this case, maximum size hints should be
 * enforced with higher priority, if they are set. Also, any padding
 * hint set on objects should add up to the alignment space on the
 * final scene composition.

 * For the horizontal component, 0.0 means to the left, 1.0 means to
 * the right. Analogously, for the vertical component, 0.0 to the top,
 * 1.0 means to the bottom.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * @note Default alignment hint values are 0.5, for both axis.

 * @skipline align_set

 * Mode is simply for supporting alpha, depth buffering and stencil
 * buffering.

 * @skip mode
 * @until mode_set

 * Resize policy tells glview what to do with the surface when it
 * resizes. ELM_VIEW_RESIZE_POLICY_RECREATE will tell it to destroy
 * the current surface and recreate it to the new size.

 * @skipline resize

 * Render policy tells glview how it would like glview to render gl
 * code. ELM_GLVIEW_RENDER_POLICY_ON_DEMAND will have the gl calls
 * called in the pixel_get callback, which only gets called if the
 * object is visible, hence ON_DEMAND. ALWAYS mode renders it despite
 * the visibility of the object.

 * @skipline render

 * Now we'll register our callbacks.

 * @skip init
 * @until draw

 * When using the elm box the packing method of the subobj - glview in
 * this case - should be defined. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality, in this part of the code we also make glview visible
 * and set to focus.

 * @skip pack_end
 * @until focus

 * For a simple demonstration of the animation we'll have to use
 * ecore::animator. As long as tou trigger an update on the image via
 * @p changed_set() it will be updated.
 
 * @skip ani
 * @until "gld"

 * If you delete gl, this animator will keep running trying to access
 * gl so it's better to delete this animator with
 * ecore_animator_del(), as seen inside the lambda function.
 
 * @skipline callback_del

 * @note To learn more about Lambda Function and its use in Elementary
 * consult @ref lambda.

 * We're going to add a "OK" button to end the program. First step is
 * to create it using the C++ method, setting it's parent.

 * @skipline button
 
 * Second, set the text, alignment and weight hints, the hints work
 * the same as with box and glview.
 
 * @skip text
 * @until weight

 * Pack our button in the same box as glview and set the visibility for
 * it.
 
 * @skip pack
 * @until visibility

 * As a final step for our button, we are going to add a clicked
 * callback, using again Lambda Type Function.

 * @skipline clicked

 * @note To learn more about Lambda Function and its use in Elementary
 * consult @ref lambda.

 * Now we only have to set the size for our window and make it
 * visible.
 
 * @skip size_set
 * @until visibility_set

 * And finally, start the elm mainloop, starting to handle events and
 * drawing operations.

 * @skip elm_run
 * @until ELM_MAIN

 * See full code for this example @ref glview_cxx_example_01.cc "here" .

 * @example glview_cxx_example_01.cc
 */

/**
 * @page hoversel_cxx_example_01 Hoversel example with C++ Binding
 * @dontinclude hoversel_cxx_example_01.cc
 
 * In this example we'll 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.
 
 * The first part consists of including the headers. We'll include @p
 * Elementary.hh, @p Eina.hh and @p Evas.hh, that are C++ bindings
 * that are needed in this example.

 * @skip Elementary
 * @until Evas

 * Before our main code we'll need the following callbacks:

 *@li @p _print_items: callback for our first item which prints all
 * items in the hoversel.

 * @until print

 *@li @p _free: callback that frees the allocated memory.
 
 * @until free

 * Starting the main code and initializing Eina C++ Lybrary, always
 * initiate Eina when included.

 * @skip EAPI
 * @until eina

 * Now let's set the elm_policy, which defines for a given policy
 * group/identifier a new policy's value, respectively. In this
 * example the only policy we need to set a value for is @c
 * ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skipline elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Next we'll create a red evas::rectangle to use as the icon of our
 * hoversel, for thus using the C++ method, setting the color and
 * making it visible.

 * @skip evas
 * @until visibility

 * And now we create our hoversel and set some of it's properties. We
 * set @p win as its parent, set it to be vertical and give it a label
 * and content, that will work as icon:

 * @skip hoversel
 * @until content
 
 * Next we will add callbacks to be called for the first and third:

 * @skip item
 * @until "Option 2"
 
 * We also set a pair of callbacks to be called whenever any item is
 * selected or when the hoversel is activated, for this we'll use
 * Lambda type function, @p add_item 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.

 * @skip add
 * @until clicked

 * @see For more on Lambda check @ref lambda "here"
 
 * Finishing with hoversel we set its size, position and make it
 * visible.

 * @skip size
 * @until visibility
 
 * In our second hoversel we'll add a button and for this we need
 * create it using C++ method, set a text, add a callback for when
 * button is clicked. This callback is type Lambda, it will clear
 * hoversel when clicked.

 * @skip button
 * @until callback

 * Concluding our button options, we will set the size, position and
 * visibility.

 * @skip size
 * @until visibility

 * Now we set the size for the window, making it visible in the end:
 
 * @skip size_set
 * @until visibility_set
 
 * Finally we just have to start the elm mainloop, starting to handle
 * events and drawing operations.

 * @skip elm_run
 * @until ELM_MAIN

 * Our example will look like this:
 
 * @image html screenshots/hoversel_cxx_example_01.png
 * @image latex screenshots/hoversel_cxx_example_01.eps width=\textwidth
 
 * @example hoversel_cxx_example_01.cc
 */

/**
 * @page icon_cxx_example_01 Icon Example with C++ binding
 * @dontinclude icon_cxx_example_01.cc

 * This example is as simple as possible. An icon object will be added
 * to the window over a blank background, and set to be resizable
 * together with the window. All the options set through the example
 * will affect the behavior of this icon.
 
 * The first part consists of including the headers. In this case we
 * are only working with the Elementary C++ binding and thus we need
 * only to include him.
 
 * @skipline Elementary.hh

 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively. In this example the only policy we need to set
 * a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Now we construct the elm icon and for this we use the C++ method
 * below, setting it's parent. An icon object is used to display
 * standard icon images ("delete", "edit", "arrows", etc.) or images
 * coming from a custom file (PNG, JPG, EDJE, etc.), on icon contexts.

 * @skipline ::elm::icon

 * The icon image requested can be in the Elementary theme in use, or
 * in the freedesktop.org theme paths. It's possible to set the order
 * of preference from where an image will be fetched and for that
 * we'll use the function @ order_lookup_set(order_) that will be use
 * by standard_set. Possibles values for @p order_ are:

 * @li @p ELM_ICON_LOOKUP_FDO_THEME: icon look up order is freedesktop
 * then theme;

 * @li @p ELM_ICON_LOOKUP_THEME_FDO: icon look up order is theme then
 * freedesktop;

 * @li @p ELM_ICON_LOOKUP_FDO: icon look up order is only freedesktop;

 * @li @p ELM_ICON_LOOKUP_THEME: icon look up order is only theme;
 
 * @skipline order
 
 * Now that we setted the order value we can set the standard "home"
 * icon, chosen for this example.
  
 * @skipline standard

 * An interesting 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, using file_get.
 
 * @skip file
 * @until std::cout

 * We can also get the name of the standard icon that we setted
 * before.

 * @skip name
 * @until std::cout

 * We can now go setting our options.
 
 * no_scale_set() is used just to set this value to true as we don't
 * actually want to scale our icon, just resize it.
 
 * resizable_set() is used to allow the icon to be resized to a size
 * smaller than the original one, but not to a size bigger than it.
 
 * 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.
 
 * 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.
 
 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * This is a hint on how a container object should resize a given
 * child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the icon as a resize_object to win informing that
 * when the size of the win changes so should the icon's
 * size. And finally we make icon visible. 

 * Now we set the size for the window, making it visible in the end:
 
 * @skip size_set
 * @until visibility_set
 
 * Finally we just have to start the elm mainloop, starting to handle
 * events and drawing operations.

 * @skip elm_run
 * @until ELM_MAIN
 
 * The full code for this example can be found at @ref icon_cxx_example_01.cc
 
 * This example will look like this:
 
 * @image html screenshots/icon_cxx_example_01.png
 * @image latex screenshots/icon_cxx_example_01.eps width=\textwidth
 
 * @example icon_cxx_example_01.cc
 */

/**
 * @page menu_cxx_example_01 Menu Example with C++ Binding
 * @dontinclude menu_cxx_example_01.cc
 
 * This example shows how to create a menu with regular items, object
 * items, submenus and how to delete items from a menu.
 
 * The first part consists of including the headers. We'll include @p
 * Elementary.hh, @p Eina.hh and @p Evas.hh, that are C++ bindings
 * that are needed in this example.

 * @skip Elementary
 * @until Evas

 * Starting the main code and initializing Eina C++ Lybrary, always
 * initiate Eina when included. We'll also initialize a couple of
 * pointers.

 * @skip EAPI
 * @until menu_it

 * Now let's set the elm_policy, which defines for a given policy
 * group/identifier a new policy's value, respectively. In this
 * example the only policy we need to set a value for is @c
 * ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skipline elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Next we'll create a evas::rectangle to use as the icon of our menu
 * for thus using the C++ method, adding our rect as a resize-object
 * to win informing that when the size of the win changes so should
 * the box's size. 
 
 * @skip evas
 * @until resize

 * We'll also set, for rect, the hint for it's minimum size, it's
 * color and making it visible.

 * @skip size
 * @until visibility

 * Creating the menu using the C++ method, setting it's parent and
 * adding an item to this menu. We are going to add more items, but
 * these icons are going to have a parent, which will put them in a
 * sub-menu.

 * @skip menu
 * @until "menu 1"

 * We'll add a button to a menu_item, where this button will delete
 * the first item of our sub-menu when clicked, we'll do this
 * using @p elm_object_item_content_set().
 
 * @skip button
 * @until content_set

 * Now, for the callback that will be used in this button we're use
 * lambda type function and then add as clicked callback to button.

 * @skip del_it
 * @until clicked

 * @see To learn more about consult @ref lambda.

 * 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, we use the following callback, also lambda:

 * @skip show
 * @until ( show );

 * Finally. we just make menu visible, set a size for our window
 * making it visible and then start the elm mainloop, starting to
 * handle events and drawing operations.

 * @skip visibility
 * @until ELM_MAIN
 
 * Our example will look like this:
 
 * @image html screenshots/menu_cxx_example_01.png
 * @image latex screenshots/menu_cxx_example_01.eps width=\textwidth
 
 * @example menu_cxx_example_01.cc
 */

/**
 * @page popup_cxx_example_01 Popup example with C++ Binding
 * @dontinclude popup_cxx_example_01.cc

 * The first part consists of including the headers. In this
 * case we are only working with the Elementary C++ binding and thus
 * we need only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.

 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Now let's create the label with the C++ binding method, passing our
 * window object as parent. We'll also set to this label the text that
 * we'll use later on the popup.

 * @skip elm::label
 * @until text

 * Using the same method we'll create our popup passing our window
 * object as parent. We'll also set the timeout to 3.0 seconds, label
 * as content, the title and visibility true for our popup.

 * @skip elm::popup
 * @until visibility

 * Our popup will hide every time the lambda type function is called.
 * The lambda function get the popup object by reference and set it's
 * visibility to false, making it invisible. In this example we are
 * using @a std::bind to bind the parameters of our lambda function to
 * return as @a std::function object to popup_hide which was declare
 * as auto.

 * @skip popup_hide
 * @until });

 * To learn more consult @ref lambda.

 * In this example we'll add the popup_hide in the timeout callback
 * and the block_clicked callback. This results in hiding the popup in
 * maximum of 3.0 seconds or when the popup block is clicked.

 * @skip timeout
 * @until block 

 * Finally we just have to make our window visible and set it's size,
 * then run the elm mainloop, starting to handle events and drawing
 * operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * This example will initially look like this:

 * @image html screenshots/popup_cxx_example_01.png
 * @image latex screenshots/popup_cxx_example_01.eps width=\textwidth

 * Once the popup is hidden after timeout:

 * @image html screenshots/popup_cxx_example_01_a.png
 * @image latex screenshots/popup_cxx_example_01_a.eps width=\textwidth
 
 * @example popup_cxx_example_01.cc
 */

/**
 * @page radio_cxx_example_01 Radio example with C++ Binding
 * @dontinclude radio_cxx_example_01.cc
 
 * In this example we will create 4 radios, and add them to the same
 * 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 first part consists of including the headers. In this
 * case we are only working with the Elementary C++ binding and thus
 * we need only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively. In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * And move right to declaring a static variable, the one whose value
 * the radios will change:
 
 * @skipline static

 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.

 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure. 

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it. 

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * A box arranges objects in a linear fashion, governed by a layout
 * function that defines the details of this arrangement. The box will
 * use an internal function to set the layout to a single row,
 * vertical by default.

 * Now let's create the box with the C++ binding method, passing our
 * window object as parent and then setting box's layout as
 * horizontal.

 * @skipline elm::box
 * @until horizontal

 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate. This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the box as a resize_object to win informing that when
 * the size of the win changes so should the box's size. And finally
 * we make it visible.
 
 * @skip win
 * @until visibility_set 

 * Radio is a widget that allows for one or more options to be
 * displayed and have the user choose only one of them. It contains an
 * indicator, an optional label and an optional icon object. While
 * it's possible to have a group of only one radio they, are normally
 * used in groups of 2 or more.

 * We will create the box with the C++ binding method, passing our
 * window object as parent and then setting box's layout as
 * horizontal.

 * And now we create a radio with the C++ binding method, passing our
 * window object as parent. Since this is the first radio in our group
 * we set the group to be the radio, so we can set the other radios in
 * the same group.

 * @skip radio
 * @until radio;

 * We also set the text, then 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.
 
 * @skip text
 * @until pointer

 * For this radio we choose the standard home icon, the icon will be
 * created with the same method and setting the icon as content of
 * radio.

 * @skip icon
 * @until content

 * When using the elm::box the packing method of the subobj - radio
 * in this case - should be defined. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality.

 * @skipline pack_end
 
 * The function size_hint_weight_set works with radio the same way
 * as with box, as above.

 * @skipline weight_set
 
 * The function @c size_hint_align_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_align_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's alignment. The parameters are:
 
 * @li x - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as horizontal alignment hint.

 * @li y - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as vertical alignment hint.

 * These are hints on how to align an object inside the boundaries of
 * a container/manager. Accepted values are in the 0.0 to 1.0 range,
 * with the special value EVAS_HINT_FILL used to specify "justify" or
 * "fill" by some users. In this case, maximum size hints should be
 * enforced with higher priority, if they are set. Also, any padding
 * hint set on objects should add up to the alignment space on the
 * final scene composition.

 * For the horizontal component, 0.0 means to the left, 1.0 means to
 * the right. Analogously, for the vertical component, 0.0 to the top,
 * 1.0 means to the bottom.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * @skipline align_set

 * @note Default alignment hint values are 0.5, for both axis.

 * To end the settings of radio we'll make it visible and with our
 * lambda type function we output the current value of @p val. In this
 * example we are using @a std::bind to bind the parameters of our
 * lambda function to return as @a std::function object to @p cb_val
 * which was declare as @p auto. Now we just have to add @p cb_val as
 * changed radio callback of our radio.

 * @skip visibility
 * @until changed

 * @see To learn more consult @ref lambda.

 * The creation of our second radio is almost identical, using the
 * same method we create radio2 passing win as parent. We also set the
 * text, then state value of this radio to 2 and the value pointer to
 * @p val. This radio will be added in the same group as the first
 * radio.
 
 * @skip text
 * @until group

 * Then we set the standard file icon, the icon will be created with
 * the same method and then set the icon as content of radio.

 * @skip ic2
 * @until content

 * As before, we set packing method of radio2 in the box, the weight,
 * alignment and visibility of radio2. Then add cb_val as callback
 * when the radio changes.

 * @skip pack
 * @until changed

 * For our third and fourth radios we'll omit the icon and set the
 * value to 3 and 4, respectively, we'll also add them to the group of
 * the first radio:

 * @skip radio3
 * @until radio4.callback

 * Finally we just have to make our window visible and set it's size,
 * then run the elm mainloop, starting to handle events and drawing
 * operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * The full code for this example can be found at @ref radio_cxx_example_01.cc

 * The example will look like this:

 * @image html screenshots/radio_cxx_example_01.png
 * @image latex screenshots/radio_cxx_example_01.eps width=\textwidth

 * @example radio_cxx_example_01.cc
 */

/**
 * @page separator_cxx_example_01  Separator with C++ Binding
 * @dontinclude separator_cxx_example_01.cc

 * Separator is a very thin object used to separate other objects,
 * which can be vertical or horizontal.

 * This example shows how to create a window and separate in two
 * parts, each one will be filled with a background color to show the
 * division. The @a separator is used to visually mark the division
 * between two parts.

 * The first part consists of including the headers. In this case we
 * are only working with the Elementary and Evas C++ bindings.
  
 * @skip Elementary.hh
 * @until Evas
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively. In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;

 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
   
 * @n @skip EAPI_MAIN int
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events at ELM_MAIN() because of this. ??
  
 * @see  elm_policy_set()
 
 * Next step is creating an Elementary window, where win calls a
 * constructor and sets the type of the win to ELM_WIN_BASIC
 * (Elm_Win_Type), which is the indicated type for most of our
 * examples. Here we also set the title that will appear at the top of
 * our window and then the autohide state for it.
 
 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Now let's create the background with the C++ binding method, passing
 * our window as parent.

 * @skipline elm::bg

 * The function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's weight. The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.  This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the background as a resize-object to win informing that
 * when the size of the win changes so should the background's size
 * and setting it's visibility. You can change the background's color
 * using color_set, if not, the default color will be used.
 
 * @skip win
 * @until visibility_set 
 
 * To put a box in the window we also need to set it's parent. By
 * default, box object arranges their contents vertically from top to
 * bottom. By calling this function with horizontal as @a true, the
 * box will become horizontal, arranging contents from left to right.

 * @skip ::elm::box
 * @until horizontal

 * The value that we set EFL Evas function size_hint_weight_set
 * expands the box to cover all win's area and adding it as a
 * resize_object to win informing that when the size of the win
 * changes so should the box's size. In the end we make the box
 * visible.
 
 * @skip weight
 * @until visibility
  
 * Now we create a retangle, like before, we just need to setting it's
 * parent. After created, we set the color to show the difference
 * between the next rectangle and define the minimun size of each side
 * by using size_hint_min_set(minimum width, minimum height).

 * @skip rect
 * @until min_set

 * As in the background, the value we set EFL Evas function
 * size_hint_weight_set expands the background to cover all area
 * defined in size_hint_min_set. We also need to expand the rectangle
 * to fill the area if the win's size change, if not, win can change
 * it's size and the rectangle will only fill it's own previous area.

 * @until weight
 
 * The function @c size_hint_align_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_align_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's alignment. The parameters are:
 
 * @li x - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as horizontal alignment hint.

 * @li y - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as vertical alignment hint.

 * These are hints on how to align an object inside the boundaries of
 * a container/manager. Accepted values are in the 0.0 to 1.0 range,
 * with the special value EVAS_HINT_FILL used to specify "justify" or
 * "fill" by some users. In this case, maximum size hints should be
 * enforced with higher priority, if they are set. Also, any padding
 * hint set on objects should add up to the alignment space on the
 * final scene composition.

 * For the horizontal component, 0.0 means to the left, 1.0 means to
 * the right. Analogously, for the vertical component, 0.0 to the top,
 * 1.0 means to the bottom.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * @skipline align_set

 * @note Default alignment hint values are 0.5, for both axis.

 * Now we only need to set the visibility of the rectangle and add our
 * retangle to box with the packing method of the subobj - rectangle
 * in this case. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality. In this part of the code we also make rectangle
 * visible.
 
 * @skip visibility
 * @until pack
 
 * Once we have our first rectangle in the box we create and add our
 * separator. Using the same approach, we setting it's parent. Since
 * our box is in horizontal mode it's a good idea to set the separator
 * to be horizontal too. Finishing with the visibility and packing
 * method.

 * @skip elm::separator
 * @until pack

 * After all this, we just need to create another rectangle, setting
 * the color, size hints, make rect2 visible and packing in the
 * box. Don't forget to set the win's visibility as true.

 * @skip rect2
 * @until win.visibility

 * Finally we just have to start the elm mainloop, starting to handle
 * events and drawing operations.

 * @skip elm_run
 * @until ELM_MAIN()
 
 * The full code for this example can be found at @ref separator_cxx_example_01.cc .

 * This example will look like:

 * @image html screenshots/separator_cxx_example_01.png
 * @image latex screenshots/separator_cxx_example_01.eps width=\textwidth

 * @example separator_cxx_example_01.cc
 */

/**
 * @page slider_cxx_example Slider widget example with C++ Binding
 * @dontinclude slider_cxx_example.cc 

 * This code places seven Elementary slider widgets on a window, each of
 * them exemplifying a part of the widget's API.
 
 * The first part consists of including the headers. In this
 * case we are only working with the Elementary C++ binding and thus
 * we need only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.

 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Now let's create a box with the C++ binding method, passing our
 * window object as parent, we'll use this box to contain our slider
 * object.

 * @skipline bx

 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate. This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Then we add the box as a resize-object to win informing that when
 * the size of the win changes so should the box's size. Remember
 * always to set the box visibility to true.

 * @skip win
 * @until visibility

 * Now we'll create our slider, using the C++ binding method and set
 * it's size hint that works with slider the same way as with box, for
 * more, look above. This is the default slider.

 * @skip slider
 * @until weight

 * The function @c size_hint_align_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_align_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's alignment. The parameters are:
 
 * @li x - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as horizontal alignment hint.

 * @li y - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as vertical alignment hint.

 * These are hints on how to align an object inside the boundaries of
 * a container/manager. Accepted values are in the 0.0 to 1.0 range,
 * with the special value EVAS_HINT_FILL used to specify "justify" or
 * "fill" by some users. In this case, maximum size hints should be
 * enforced with higher priority, if they are set. Also, any padding
 * hint set on objects should add up to the alignment space on the
 * final scene composition.

 * For the horizontal component, 0.0 means to the left, 1.0 means to
 * the right. Analogously, for the vertical component, 0.0 to the top,
 * 1.0 means to the bottom.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * @skipline align

 * @note Default alignment hint values are 0.5, for both axis.

 * When using the elm box the packing method of the subobj - slider
 * in this case - should be defined. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality, in this part of the code we also make slider visible.

 * @skip pack
 * @until visibility

 * 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.

 * Creating the second slider, the difference being that we set a text
 * and two icons.

 * @skip slider
 * @until text

 * Creating the first icon as standard "home" and not resizable and
 * finally add icon as content for the second slider.

 * @skip icon
 * @until content

 * Our second icon is the standard "folder", also not resizable and
 * with add it also to the second slider.

 * @skip ic2
 * @until content

 * The same as before, the size hints weight, align will be setted and
 * the packing method for the second slider. Also making it visible.

 * @skip align
 * @until visibility

 * 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:

 * @skip slider
 * @until visibility

 * 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, by default it uses 0.0 and 1.0:

 * @skip slider
 * @until visibility

 * 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:

 * @skip slider
 * @until visibility

 * 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. For this we suggest you
 * use a lambda type function.
 
 * @skip slider
 * @until };

 * In this case, a function to free this will be required, also a
 * Lambda.
 
 * @skipline auto

 * @see To learn more consult @ref lambda.

 * Now we add our two labdas as indicators for our sixth slider and
 * set the hints, packing method and visibility for our slider.

 * @skip indicator
 * @until visibility

 * For our seventh slider we'll show that slider can also be displayed
 * vertically:
 
 * @skip slider
 * @until visibility

 * Finally the last slider will exemplify how to listen to slider's
 * signals, <tt> changed </tt> and <tt> delay,changed </tt>. First we
 * need to implement callback functions that will simply print
 * slider's value, using lambda again:

 * @skip changed
 * @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 callback
 * @until callback_delay

 * Finally we just have to make our window visible. Then run the elm
 * mainloop, starting to handle events and drawing operations.
 
 * @skip visibility
 * @until ELM_MAIN
 
 * See the full @ref slider_cxx_example.cc "example", whose window should
 * look like this picture:
 
 * @image html screenshots/slider_cxx_example.png
 * @image latex screenshots/slider_cxx_example.eps width=\textwidth
 
 * @example slider_cxx_example.cc
 */

/**
 * @page spinner_cxx_example Spinner widget example with C++ Binding
 * @dontinclude spinner_cxx_example.cc

 * This code places seven Elementary spinner widgets on a window, each of
 * them exemplifying a part of the widget's API.
 
 * The first part consists of including the headers. In this
 * case we are only working with the Elementary C++ binding and thus
 * we need only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively. In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.

 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure. 

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it. 

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * A box arranges objects in a linear fashion, governed by a layout
 * function that defines the details of this arrangement. The box will
 * use an internal function to set the layout to a single row,
 * vertical by default.

 * Now let's create the box with the C++ binding method, passing our
 * window object as parent.

 * @skipline elm::box

 * To better understand, the function @c size_hint_weight_set for C++
 * bindings originated from C bindings function
 * evas_object_size_hint_weight_set, that is EFL Evas type function.
 * With this function we set the hints for an object's weight.  The
 * parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate. This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Now we add the box as a resize_object to win informing that
 * when the size of the win changes so should the box's
 * size. And finally we make it visible.
 
 * @skip win
 * @until visibility_set 

 * Now we create our spinner with the C++ method, this first one will
 * the default spinner.

 * @skipline spinner

 * 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"

 * The function size_hint_weight_set works with spinner the same way
 * as with box, as seem above.

 * @skipline weight_set
 
 * The function @c size_hint_align_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_align_set, that is
 * EFL Evas type function. With this function we set the hints for an
 * object's alignment. The parameters are:
 
 * @li x - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as horizontal alignment hint.

 * @li y - Double, ranging from 0.0 to 1.0 or with the special value
 * EVAS_HINT_FILL, to use as vertical alignment hint.

 * These are hints on how to align an object inside the boundaries of
 * a container/manager. Accepted values are in the 0.0 to 1.0 range,
 * with the special value EVAS_HINT_FILL used to specify "justify" or
 * "fill" by some users. In this case, maximum size hints should be
 * enforced with higher priority, if they are set. Also, any padding
 * hint set on objects should add up to the alignment space on the
 * final scene composition.

 * For the horizontal component, 0.0 means to the left, 1.0 means to
 * the right. Analogously, for the vertical component, 0.0 to the top,
 * 1.0 means to the bottom.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate.

 * @skipline align_set

 * @note Default alignment hint values are 0.5, for both axis.

 * When using the elm::box the packing method of the subobj - spinner
 * in this case - should be defined. There are four possible methods:

 * @li @c pack_start(subobj_) - Add an object to the beginning of the
 * pack list. Pack @c subobj_ into the box obj, placing it first in
 * the list of children objects. The actual position the object will
 * get on screen depends on the layout used. If no custom layout is
 * set, it will be at the top or left, depending if the box is
 * vertical or horizontal, respectively.

 * @li @c pack_end(subobj_) - Add an object at the end of the pack
 * list. Pack @c subobj_ into the box obj, placing it last in the list
 * of children objects. The actual position the object will get on
 * screen depends on the layout used. If no custom layout is set, it
 * will be at the bottom or right, depending if the box is vertical or
 * horizontal, respectively.

 * @li @c pack_before(subobj_, before_) - Adds an object to the box
 * before the indicated object. This will add the @c subobj_ to the
 * box indicated before the object indicated with @c before_. If
 * before is not already in the box, results are undefined. Before
 * means either to the left of the indicated object or above it
 * depending on orientation.
 
 * @li @c pack_after(subobj_, after_) - Adds an object to the box
 * after the indicated object. This will add the @c subobj_ to the box
 * indicated after the object indicated with @c after_. If after is
 * not already in the box, results are undefined. After means either
 * to the right of the indicated object or below it depending on
 * orientation.

 * In this and most examples we use pack_end by choice and
 * practicality. In this part of the code we also make spinner
 * visible.

 * @skip pack_end
 * @until visibility

 * In our second spinner we are altering the format. It will put a
 * text before and after the value, and also format value to display
 * two decimals. As with the first spinner, we create the second with
 * the same C++ method, set the alignment and the weight, choose the
 * packing method and make it visible.
 
 * @skip spinner
 * @until visibility
 
 * 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:

 * @skip spinner
 * @until visibility
 
 * 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.

 * @skip spinner
 * @until visibility
 
 * In the fifth the user won't be allowed to set value directly, i.e., will
 * be obligate change value only using arrows:

 * @skip spinner
 * @until visibility
 
 * 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:

 * @skip spinner
 * @until visibility
 
 * Finally the last widget will exemplify how to listen to widget's
 * signals, <tt> changed </tt> and <tt> delay_changed </tt>.

 * We start the same way as previously, creating spinner, setting
 * alignment and weight, choosing the packing method, making it
 * visible and editable.

 * @skip spinner
 * @until editable

 * Our spinner will output it's value or delay value every time the
 * std::function object is called. In this example we are using @a
 * std::bind to bind the parameters of each lambda function, that
 * captures sp7 by reference and then get it's value or delay value to
 * finally output it.

 * The first function changed, that was declare as auto, will output
 * the new value. For this we need to add it to the
 * @p callback_changed

 * @skip changed
 * @until callback

 * The second function changed, that was also declare as auto, will
 * output the new delay value. For this we need to add it to the @p
 * callback_delay_changed.

 * @skip delay
 * @until callback

 * To learn more consult @ref lambda.

 * 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.

 * Finally we just have to make our window visible. Then run the elm
 * mainloop, starting to handle events and drawing operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * See the full code for this example at @ref spinner_cxx_example.cc .

 * This example will look like this:

 * @image html screenshots/spinner_cxx_example.png
 * @image latex screenshots/spinner_cxx_example.eps width=\textwidth
 * @example spinner_cxx_example.cc
 */

/**
 * @page table_cxx_example_01 Table Example with C++ binding - Homogeneous
 * @dontinclude table_cxx_example_01.cc

 * In this example we add four labels to a homogeneous table that has a padding
 * of 5px between cells.
 
 * The first part consists of including the headers. In this
 * case we are only working with the Elementary C++ binding and thus
 * we need only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set
 
 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * And we also set the autohide state for win, autohide works
 * similarly to @p autodel, automatically handling "delete,request"
 * signals when set to @p true, with the difference that it will hide
 * the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
    
 * Now we construct the elm table and for this we use the C++ method
 * below, setting it's parent.

 * @skipline ::elm::table

 * We then add table as a resize_object to win informing that when the
 * size of the win changes so should the box's size and make it
 * visible.

 * @skip resize
 * @until visibility

 * Next step is to set the padding, in this case 5px and as we chosen
 * for this example homogeneous_set to true.

 * @skip padding
 * @until homogeneous

 * We'll create for each cell on this table a simple elm_lable, using
 * the C++ method below, setting it's parent. Set the text for the
 * labels and make each visible. The parameters for packing the labels
 * in our table will be better explain below.

 * @skip elm::label
 * @until (label3,

 * When using pack in our table we are adding a child to a packing
 * location of the table. The parameters are:

 * pack (evas::object @a subobj,
 *       int @a column,
 *       int @a row,
 *       int @a colspan,
 *       int @a rowspan)
  
 * @li subobj - The subobject to be added to the table 

 * @li column - Column number 

 * @li row - Row number

 * @li colspan - Number of columns that the subobj will occupy

 * @li rowspan - Number of rows that the subobj will occupy
 
 * @note All positioning inside the table is relative to rows and
 * columns, so a value of 0 for @a column and @a row, means the top
 * left cell of the table. And for example, value of 2 for @a colspan and @a
 * rowspan indicates that the subobj will occupy two columns and two rows,
 * thus occupying 4 cells in total.

 * Finally we just have to make our window visible. Then run the elm
 * mainloop, starting to handle events and drawing operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * @See Full code for this example: @ref table_cxx_example_01.cc .
 
 * Our example will look like this:
 
 * @image html screenshots/table_cxx_example_01.png
 * @image latex screenshots/table_cxx_example_01.eps width=\textwidth
 * @example table_cxx_example_01.cc
 */

/**
 * @page table_cxx_example_02 Table Example with C++ binding - Heterogeneous
 * @dontinclude table_cxx_example_02.cc

 * 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 first part consists of including the headers. In this
 * case we are only working with the Elementary C++ binding and thus
 * we need only to include him.
  
 * @skipline Elementary.hh
 
 * @attention If necessary the C and/or the C++ headers should be
 * include here as well.

 * Now we need to actually start the code and set the elm_policy,
 * which defines for a given policy group/identifier a new policy's
 * value, respectively.  In this example the only policy we need to
 * set a value for is @c ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skip EAPI_MAIN
 * @until elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set
 
 * Next step is creating an Elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * And we also set the autohide state for win, autohide works
 * similarly to @p autodel, automatically handling "delete,request"
 * signals when set to @p true, with the difference that it will hide
 * the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.
  
 * Now we construct the elm table and for this we use the C++ method
 * below, passing windows as it's parent.

 * @skipline ::elm::table

 * We then add table as a resize_object to win informing that when the
 * size of the win changes so should the table's size and make it
 * visible. The last configuration for table is to set homogeneous as
 * false.

 * @skip resize
 * @until homogeneous

 * For each cell of this table we are going to create a unique @p
 * evas::rectangle, each with different colors and sizes.

 * Let's see a snip of the code on how we constructed our rectangles
 * and setted the colors.

 * @skip evas
 * @until color

 * @skip evas
 * @until color

 * @skip evas
 * @until color

 * @skip evas
 * @until color

 * For each rectangle we also setted the size_hint_min that hints for
 * an object's minimum size. This is not a size enforcement in any
 * way, it's just a hint that should be used whenever appropriate.

 * @dontinclude table_cxx_example_02.cc
 * @skipline size_hint

 * @skipline size_hint

 * @skipline size_hint

 * @skipline size_hint
 
 * When using pack in our table we are adding a child to a packing
 * location of the table. The parameters are:

 * pack (evas::object @a subobj,
 *       int @a column,
 *       int @a row,
 *       int @a colspan,
 *       int @a rowspan)
  
 * @li subobj - The subobject to be added to the table 

 * @li column - Column number 

 * @li row - Row number

 * @li colspan - Number of columns that the subobj will occupy

 * @li rowspan - Number of rows that the subobj will occupy
 
 * @note All positioning inside the table is relative to rows and
 * columns, so a value of 0 for @a column and @a row, means the top
 * left cell of the table. And for example, value of 2 for @a colspan
 * and @a rowspan indicates that the subobj will occupy two column
 * and two rows, thus occupying 4 cells in total.

 * So for each rectangle we are setting a specific location and how
 * many cells it's occupying, better seem below:

 * @dontinclude table_cxx_example_02.cc
 * @skipline pack

 * @skipline pack

 * @skipline pack

 * @skipline pack 

 * Finally we just have to make our window visible. Then run the elm
 * mainloop, starting to handle events and drawing operations.
 
 * @skip visibility
 * @until ELM_MAIN

 * @See Full code for this example: @ref table_cxx_example_02.cc .
 
 * Our example will look like this:
 
 * @image html screenshots/table_cxx_example_02.png
 * @image latex screenshots/table_cxx_example_02.eps width=\textwidth
 
 * @example table_cxx_example_02.cc
 */

/**
 * @page thumb_cxx_example_01 Thumb - Generating thumbnails with C++ Binding
 * @dontinclude thumb_cxx_example_01.cc 

 * This example shows how to create a simple thumbnail object with
 * Elementary C++ Binding.
 
 * The first part consists of including the headers. In this case we
 * need Elementary C++ binding, iostream and sstream libraries.
  
 * @skip Elementary.hh
 * @until sstream
 
 * @attention All necessary Enlightenment, Elementary, C and/or C++
 * headers should be include here as well.

 * Starting the main code and telling elementary that we need Ethumb
 * to generate the thumbnails:
 
 * @skip EAPI
 * @until elm_need_ethumb
 
 * Then, we use app_info_set to access the image that we are using for
 * this example.
 
 * @skipline app
  
 * Now let's set the elm_policy, which defines for a given policy
 * group/identifier a new policy's value, respectively. In this
 * example the only policy we need to set a value for is @c
 * ELM_POLICY_QUIT, possibles values for it are:

 * @li @p ELM_POLICY_QUIT_NONE: Never quit the application
 * automatically;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_CLOSED: quit when the
 * application's last window is closed;
 
 * @li @p ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN : quit when the
 * application's last window is hidden;
 
 * @skipline elm_policy_set
 
 * As you can see, the policy we chose was to quit when the last win
 * is hidden as opposed to examples with the C bindings where we
 * perpetually set it to quit when last win was closed. This changed
 * was necessary because in C++ binding as the elm mainloop stop
 * running all object are destroyed, references are unreferenced and
 * events are stopped at ELM_MAIN().
  
 * @see For more details consult elm_policy_set

 * Next step is creating an elementary window, in this example we use
 * the C++ binding method with the elm_win_util_standard_add that is a
 * elm_win_legacy function, better explained below. And then we set
 * the autohide state for it.
 
 * @p elm_win_util_standard_add (const char *name, const char *tittle)
 * Adds a window object with standard setup.
 * Parameters:
 
 * @li @p name - The name of the window;

 * @li @p title - The title for the window.

 * This creates a window but also puts in a standard background with
 * @p elm_bg_add(), as well as setting the window title to @p
 * title. The window type created is of type @c ELM_WIN_BASIC, with
 * the @c NULL as the parent widget. Returns the created object or @c
 * NULL on failure.

 * The autohide works similarly to @p autodel, automatically handling
 * "delete,request" signals when set to @p true, with the difference
 * that it will hide the window, instead of destroying it.

 * It is specially designed to work together with @p
 * ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting
 * Elementary's main loop when all the windows are hidden.
 
 * @skip ::elm::win
 * @until autohide_set

 * @note @p autodel and @a autohide are not mutually exclusive. The
 * window will be destructed if both autodel and autohide is set to @p
 * EINA_TRUE or @p true.

 * Creating our thumb and setting it's parent, using C++ method.

 * @skipline thumb

 * For our callbacks we are using lambda type functions to create
 * then, note that all three only show a message, for when our thumb
 * generation is starting, stoping and it's return error.

 * @skip auto
 * @until generate_error

 * @note To learn more about Lambda Function and its use in Elementary
 * consult @ref lambda.

 * Continuing with our thumb, we'll set a size, set it to not be
 * editable, set the file and after that, we can start creating
 * thumbnail objects. They are very similar to image or icon objects:
  
 * @skip size
 * @until reload
 
 * As you can see, the main different function here is 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.
 
 * Finishing with thumb we set the weight hint. To better understand,
 * the function @c size_hint_weight_set for C++ bindings originated
 * from C bindings function evas_object_size_hint_weight_set, that is
 * EFL Evas type function.  With this function we set the hints for an
 * object's weight.
 * The parameters are:

 * @li x - Nonnegative double value to use as horizontal weight hint.

 * @li y - Nonnegative double value to use as vertical weight hint.

 * This is not a size enforcement in any way, it's just a hint that
 * should be used whenever appropriate. This is a hint on how a
 * container object should resize a given child within its area.

 * Containers may adhere to the simpler logic of just expanding the
 * child object's dimensions to fit its own (see the EVAS_HINT_EXPAND
 * helper weight macro in the EFL Evas Documentation) or the complete
 * one of taking each child's weight hint as real weights to how much
 * of its size to allocate for them in each axis. A container is
 * supposed to, after normalizing the weights of its children (with
 * weight hints), distribute the space it has to layout them by those
 * factors – most weighted children get larger in this process than
 * the least ones.

 * @skipline weight_set

 * @note Default weight hint values are 0.0, for both axis.

 * Then we add the thumb as a resize-object to win informing that when
 * the size of the win changes so should the thumb's size. Remember
 * always to set the thumb visibility to true.

 * @skip win
 * @until visibility

 * Now we only have to set the size for our window and make it
 * visible.
 
 * @skip size_set
 * @until visibility_set

 * And finally, start the elm mainloop, starting to handle events and
 * drawing operations.

 * @skip elm_run
 * @until ELM_MAIN

 * The full source code can be found at @ref thumb_cxx_example_01.cc

 * @image latex screenshots/thumb_cxx_example_01.eps width=\textwidth
 * @example thumb_cxx_example_01.cc
 */
