/**
 * @page Examples Examples
 *
 * Here is a page with examples.
 *
 * @li @ref tutorial_ephysics_bouncing_ball
 * @li @ref tutorial_ephysics_delete_body
 */

/**
 * @page tutorial_ephysics_bouncing_ball EPhysics - Bouncing Ball
 *
 * The purpose of this example is to show how to write an simple application -
 * as the name suggests - with a small ball bouncing on the ground and
 * responding to users events by making it jump - applying a central impulse on
 * it.
 *
 * We'll guide you on defining a EPhysics world, defining its render geometry
 * and the physics limiting boundaries, you'll learn how to add EPhysics bodies
 * and how to associate it to evas objects.  We also explain how to change
 * restitution and friction properties. We see how to apply central impulse on
 * a EPhysics_Body by implementing an elementary input event callback and
 * calling the proper function.
 *
 * @section test-structure A test struct
 * @dontinclude ephysics_test.h
 *
 * While in this example we'll be working with a struct to hold some objects in
 * our code. For clarity sake we present you the struct declaration in the
 * following block.
 *
 *
 * @skip struct _Test_Data
 * @until };
 *
 * @section world-new World Initialization 
 * @dontinclude test_bouncing_ball.c
 *
 * Calling ephysics_world_new()
 * will create a new physics world with its collision configuration, constraint
 * solver, broadphase interface and dispatcher.
 *
 * The default gravity is set to -9.81. It's possible to stop a running world
 * but its default status is running. Take a look at
 * ephysics_world_running_set() for further informations about world running
 * status.
 *
 * @skipline ephysics_world_new
 *
 * @section render-geometry Render geometry
 *
 * By setting the render geometry you tell ephysics the dimensions of rendered
 * area to be take on account by default updates.
 *
 * By default it starts with null x, y, width and height. Initially there's no
 * physics limits but - as we'll see later in this example - boundaries can be
 * added by issuing either ephysics_body_top_boundary_add(),
 * ephysics_body_bottom_boundary_add(), ephysics_body_left_boundary_add() and
 * ephysics_body_right_boundary_add().
 *
 * While setting the worlds render geometry the first parameter is our just
 * created world, the following parameters indicate the x, y, width and height
 * of our area of interest.
 *
 * @skipline ephysics_world_render_geometry_set
 *
 * @section boundaries Adding boundaries
 *
 * Boundaries are physics limits added by EPhysics which you can use to limit
 * the area where your objects can move around. Bear in mind that those
 * boundaries are created by EPhysics taking in account the render geometry you
 * have previously defined by calling ephysics_world_render_geometry_set().
 *
 * In our example we start by adding a bottom boundary. This EPhysics_Body
 * represents a physics limit under the world render geometry.
 *
 * The second line states the restitution factor for that bottom boundary, and
 * the third line its friction. These changes will make our ball to bounce
 * whenever it hits the ground.
 *
 * @skip ephysics_body_bottom_boundary_add
 * @until ephysics_body_friction_set 
 *
 * Then we add a right boundary limiting the physics world on the left side, we
 * also change its restitution and friction factors but with a smaller value,
 * we don't want to make it bounce as much as it is when hits the ground. 
 *
 * @skip ephysics_body_right_boundary_add
 * @until ephysics_body_friction_set 
 *
 * We also add a left boundary taking the same considerations for right
 * boundary.
 *
 * @skip ephysics_body_left_boundary_add
 * @until ephysics_body_friction_set 
 *
 * One of this examples requirements is to make the ball jump after a specific
 * user event, so the ball can suffer an impulse for any direction.
 *
 * With an upper impulse we don't want our ball to fly all over there, we want
 * to limit its upper movements, it's intended to limit the ball movement
 * within a box, it should not leave the render geometry area, for that purpose
 * we must define a top boundary. 
 *
 * @skipline ephysics_body_top_boundary_add
 * @dontinclude test_bouncing_ball.c
 *
 * @section world-populate Adding a ball
 *
 * Since we have defined the physics limits with our boundaries it's time to
 * add some fun. Here we add a ball as an elementary image widget and tell
 * ephysics about it.
 *
 * After setting the file that will be used as the image's source of our elm
 * image we move it to the center of render geometry and resize it to 70x70
 * pixels and show it.
 *
 * @skip elm_image_add
 * @until evas_object_show
 *
 * The evas object is just set and we must tell EPhysics about it, creating the
 * EPhysics_Body representing our ball and associating it to the just created
 * evas object.
 *
 * Once the ball has been moved to the center of render geometry it should
 * start falling after associating it to the EPhysics_Body. By default its mass
 * is initially set to 1 kilo, but it can be changed by calling
 * ephysics_body_mass_set(). Bear in mind that if you change its mass to 0
 * kilos it becomes a static body and will not move at all, the body will
 * remain fixed in the initial position.
 *
 * In the following code the first line adds a circle body, then we associate
 * the evas object to EPhysics_Body, EPhysics will map every changes on physics
 * object simulation to its evas object. Some restitution and friction factors
 * are added as well.
 *
 * @skip ephysics_body_circle_add
 * @until ephysics_body_friction_set
 *
 * @section jumping-ball Making it jump
 *
 * The next step is to give us the ability to make our ball to jump - actually
 * apply some impulse whenever a key has been pressed. Then we add a elementary
 * input callback to the window widget.
 *
 * @skipline elm_object_event_callback_add
 *
 * @dontinclude test_bouncing_ball.c
 *
 * The jumping callback implementation consists on handling only key up events
 * and discarding any other input event we get. We're interested on keyboard
 * events only. All the operations done in the following lines are done on
 * sphere EPhysics_Body previously created.
 *
 * We mainly use the ephysics_body_central_impulse_apply() function. This
 * function applies an inpulse on the center of a body.
 *
 * Once pressed \<Up> key it applies a central impulse of 0 kilos on X axis and
 * 10 kilos on Y - so the ball is forced up. 
 *
 * If \<Down> key has been pressed we apply an impulse of 0 kilos on X axis and
 * -10 on Y - here the ball is forced down. 
 *
 * In the case of \<Right> key pressing it's applied an impulse of 10 kilos on X
 * axis and 0 kilos on Y - which applies a force to the right side. But if the
 * key being pressed is \<Left> the opposite is done, and an impulse of -10
 * kilos is applied on X and 0 kilos on Y - and the ball is forced to the left.
 *
 * @skip _on_keydown
 * @until }
 *
 * Here we finish the very simple bouncing ball example. The full source code
 * can be found at @ref test_bouncing_ball_c.
 *
 */

/**
 * @page test_bouncing_ball_c test_bouncing_ball.c
 *
 * @section ephysics-test-h ephysics_test.h
 * @include ephysics_test.h
 *
 * @section test-bouncing-ball-c test_bouncing_ball.c
 * @dontinclude test.c
 * @skip test_clean
 * @until }
 *
 * @skip test_data_new
 * @until }
 *
 * @skip test_win_add
 * @until }
 *
 * @include test_bouncing_ball.c
 *
 *
 * @example test_bouncing_ball.c
 */

/**
 * @page ephysics_logo_c ephysics_logo.c
 *
 * @section ephysics-logo-c ephysics_logo.c
 * @include ephysics_logo.c
 *
 * @example ephysics_logo.c
 */

/**
 * @page tutorial_ephysics_delete_body EPhysics - Delete Body
 *
 * The purpose of this example is to demonstrate the EPhysics Callbacks usage -
 * The code adds two balls, one with impulse and the second with a collision
 * detection callback, to delete the body.
 *
 * For this example we'll have an EPhysics_World and two basic EPhysics_Bodys,
 * we'll apply an impulse in one of then and the other will be stopped
 * "waiting" for a collision.
 *
 * The basic concepts like - initializing an EPhysics_World, render geometry,
 * physics limiting boundaries, add an EPhysics_Body, associate it to evas
 * objects, change restitution, friction and impulse properties, were already
 * covered in
 * @ref tutorial_ephysics_bouncing_ball
 *
 * @section add-callbacks Adding Callbacks
 * @dontinclude test_delete.c
 *
 * Calling ephysics_body_event_callback_add()
 * registers a callback to a given EPhysics_Body event type.
 *
 * We'll use two types:
 *
 * @ref EPHYSICS_CALLBACK_BODY_DEL : called when a body deletion has been issued
 * and just before the deletion actually happens. In other words, to know that
 * body has been marked for
 * deletion. Typically to free some data associated with the body.
 *
 * @skipline ephysics_body_event_callback_add(sphere_body1,
 * @skip EPHYSICS_CALLBACK_BODY_DEL
 * @until );
 *
 * The callback function will receive the collision_data and free some data
 * associated with the body.
 *
 * @dontinclude test_delete.c
 *
 * @skip _del_cb(void *data,
 * @until }
 *
 * @ref EPHYSICS_CALLBACK_BODY_COLLISION : called just after the collision has
 * been actually processed by the physics engine. In other words, to be notified
 * about a collision between two physical bodies.
 *
 * @skip ephysics_body_event_callback_add(collision_data->sphere,
 * @until );
 *
 * The callback function will get the collision body and check if its body is
 * equal to which we want to delete.
 *
 * @dontinclude test_delete.c
 *
 * @skip _collision_cb(void *data,
 * @until }
 *
 * See
 * @ref _EPhysics_Callback_Body_Type
 * for more event types.
 *
 * Here we finish the example. The full source code can be found at
 * @ref test_delete_c.
 *
 */
 
 /**
 * @page test_delete_c test_delete.c
 *
 * @section ephysics-test-h ephysics_test.h
 * @include ephysics_test.h
 *
 * @section test-delete-c test_delete.c
 * @dontinclude test.c
 * @skip test_clean
 * @until }
 *
 * @skip test_win_add
 * @until }
 *
 * @include test_delete.c
 *
 * @example test_delete.c
 */