8 files changed, 407 insertions, 130 deletions

diff --git a/src/Makefile_Edje.am b/src/Makefile_Edje.am
index f6dd2f7..989df6d 100644
--- a/src/Makefile_Edje.am
+++ b/src/Makefile_Edje.am
@@ -51,6 +51,7 @@ EDJE_COMMON_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
 -DPACKAGE_DATA_DIR=\"$(datadir)/edje\" \
 -DPACKAGE_BUILD_DIR=\"$(abs_top_builddir)\" \
 -DPACKAGE_SRC_DIR=\"$(abs_top_srcdir)\" \
+@EDJE_LUA_CFLAGS@ \
 @EDJE_CFLAGS@
 
 installed_edjemainheadersdir = $(includedir)/edje-@VMAJ@
@@ -97,7 +98,7 @@ lib/edje/edje_containers.c
 
 
 lib_edje_libedje_la_CPPFLAGS = -I$(top_builddir)/src/lib/efl $(EDJE_COMMON_CPPFLAGS)
-lib_edje_libedje_la_LIBADD = @EDJE_LIBS@
+lib_edje_libedje_la_LIBADD = @EDJE_LIBS@ @EDJE_LUA_LIBS@
 lib_edje_libedje_la_DEPENDENCIES = @EDJE_INTERNAL_LIBS@
 lib_edje_libedje_la_LDFLAGS = @EFL_LTLIBRARY_FLAGS@
 
diff --git a/src/lib/edje/edje_calc.c b/src/lib/edje/edje_calc.c
index e5f022d..66b1cee 100644
--- a/src/lib/edje/edje_calc.c
+++ b/src/lib/edje/edje_calc.c
@@ -3357,7 +3357,8 @@ static Eina_Bool
 _edje_physics_world_geometry_check(EPhysics_World *world)
 {
    Evas_Coord w, h, d;
-   ephysics_world_render_geometry_get(world, NULL, NULL, NULL, &w, &h, &d);
+   if (!EPH_LOAD()) return EINA_FALSE;
+   EPH_CALL(ephysics_world_render_geometry_get)(world, NULL, NULL, NULL, &w, &h, &d);
    return w && h && d;
 }
 
@@ -3365,14 +3366,17 @@ static void
 _edje_physics_body_props_update(Edje *ed, Edje_Real_Part *ep, Edje_Calc_Params *pf,
                                 Eina_Bool pos_update)
 {
-   ephysics_body_linear_movement_enable_set(ep->body,
-                                            pf->physics->mov_freedom.lin.x,
-                                            pf->physics->mov_freedom.lin.y,
-                                            pf->physics->mov_freedom.lin.z);
-   ephysics_body_angular_movement_enable_set(ep->body,
-                                             pf->physics->mov_freedom.ang.x,
-                                             pf->physics->mov_freedom.ang.y,
-                                             pf->physics->mov_freedom.ang.z);
+   if (!EPH_LOAD()) return;
+   EPH_CALL(ephysics_body_linear_movement_enable_set)
+     (ep->body,
+      pf->physics->mov_freedom.lin.x,
+      pf->physics->mov_freedom.lin.y,
+      pf->physics->mov_freedom.lin.z);
+   EPH_CALL(ephysics_body_angular_movement_enable_set)
+     (ep->body,
+      pf->physics->mov_freedom.ang.x,
+      pf->physics->mov_freedom.ang.y,
+      pf->physics->mov_freedom.ang.z);
 
    /* Boundaries geometry and mass shouldn't be changed */
    if (ep->part->physics_body < EDJE_PART_PHYSICS_BODY_BOUNDARY_TOP)
@@ -3381,62 +3385,65 @@ _edje_physics_body_props_update(Edje *ed, Edje_Real_Part *ep, Edje_Calc_Params *
 
         if (pos_update)
           {
-             ephysics_body_move(ep->body,
-                                ed->x + pf->final.x,
-                                ed->y + pf->final.y,
-                                pf->physics->z);
+             EPH_CALL(ephysics_body_move)
+               (ep->body,
+                ed->x + pf->final.x,
+                ed->y + pf->final.y,
+                pf->physics->z);
              ep->x = pf->final.x;
              ep->y = pf->final.y;
              ep->w = pf->final.w;
              ep->h = pf->final.h;
           }
 
-        ephysics_body_geometry_get(ep->body, &x, &y, &z, &w, &h, &d);
+        EPH_CALL(ephysics_body_geometry_get)(ep->body, &x, &y, &z, &w, &h, &d);
         if ((d) && (d != pf->physics->depth))
-          ephysics_body_resize(ep->body, w, h, pf->physics->depth);
+          EPH_CALL(ephysics_body_resize)(ep->body, w, h, pf->physics->depth);
         if (z != pf->physics->z)
-          ephysics_body_move(ep->body, x, y, pf->physics->z);
+          EPH_CALL(ephysics_body_move)(ep->body, x, y, pf->physics->z);
 
-        ephysics_body_material_set(ep->body, pf->physics->material);
+        EPH_CALL(ephysics_body_material_set)(ep->body, pf->physics->material);
         if (!pf->physics->material)
           {
              if (pf->physics->density)
-               ephysics_body_density_set(ep->body, pf->physics->density);
+               EPH_CALL(ephysics_body_density_set)(ep->body, pf->physics->density);
              else
-               ephysics_body_mass_set(ep->body, pf->physics->mass);
+               EPH_CALL(ephysics_body_mass_set)(ep->body, pf->physics->mass);
           }
 
         if ((ep->part->physics_body == EDJE_PART_PHYSICS_BODY_SOFT_BOX) ||
             (ep->part->physics_body == EDJE_PART_PHYSICS_BODY_SOFT_SPHERE) ||
             (ep->part->physics_body == EDJE_PART_PHYSICS_BODY_SOFT_CYLINDER) ||
             (ep->part->physics_body == EDJE_PART_PHYSICS_BODY_CLOTH))
-          ephysics_body_soft_body_hardness_set(ep->body,
-                                               pf->physics->hardness * 100);
+          EPH_CALL(ephysics_body_soft_body_hardness_set)
+            (ep->body, pf->physics->hardness * 100);
      }
 
    if (!pf->physics->material)
      {
-        ephysics_body_restitution_set(ep->body, pf->physics->restitution);
-        ephysics_body_friction_set(ep->body, pf->physics->friction);
+        EPH_CALL(ephysics_body_restitution_set)(ep->body, pf->physics->restitution);
+        EPH_CALL(ephysics_body_friction_set)(ep->body, pf->physics->friction);
      }
 
-   ephysics_body_damping_set(ep->body, pf->physics->damping.linear,
-                             pf->physics->damping.angular);
-   ephysics_body_sleeping_threshold_set(ep->body, pf->physics->sleep.linear,
-                                        pf->physics->sleep.angular);
-   ephysics_body_light_set(ep->body, pf->physics->light_on);
-   ephysics_body_back_face_culling_set(ep->body, pf->physics->backcull);
+   EPH_CALL(ephysics_body_damping_set)(ep->body, pf->physics->damping.linear,
+                                       pf->physics->damping.angular);
+   EPH_CALL(ephysics_body_sleeping_threshold_set)(ep->body, pf->physics->sleep.linear,
+                                                  pf->physics->sleep.angular);
+   EPH_CALL(ephysics_body_light_set)(ep->body, pf->physics->light_on);
+   EPH_CALL(ephysics_body_back_face_culling_set)(ep->body, pf->physics->backcull);
 }
 
 static void
 _edje_physics_body_update_cb(void *data, EPhysics_Body *body, void *event_info EINA_UNUSED)
 {
    Edje_Real_Part *rp = data;
-   Edje *ed = ephysics_body_data_get(body);
+   Edje *ed;
 
-   ephysics_body_geometry_get(body, &(rp->x), &(rp->y), NULL,
-                              &(rp->w), &(rp->h), NULL);
-   ephysics_body_evas_object_update(body);
+   if (!EPH_LOAD()) return;
+   ed = EPH_CALL(ephysics_body_data_get(body));
+   EPH_CALL(ephysics_body_geometry_get)(body, &(rp->x), &(rp->y), NULL,
+                                        &(rp->w), &(rp->h), NULL);
+   EPH_CALL(ephysics_body_evas_object_update)(body);
    ed->dirty = EINA_TRUE;
 }
 
@@ -3447,63 +3454,64 @@ _edje_physics_body_add(Edje *ed, Edje_Real_Part *rp, EPhysics_World *world)
    Edje_Physics_Face *pface;
    Eina_List *l;
 
+   if (!EPH_LOAD()) return;
    switch (rp->part->physics_body)
      {
       case EDJE_PART_PHYSICS_BODY_RIGID_BOX:
-        rp->body = ephysics_body_box_add(world);
+        rp->body = EPH_CALL(ephysics_body_box_add)(world);
         break;
 
       case EDJE_PART_PHYSICS_BODY_RIGID_SPHERE:
-        rp->body = ephysics_body_sphere_add(world);
+        rp->body = EPH_CALL(ephysics_body_sphere_add)(world);
         break;
 
       case EDJE_PART_PHYSICS_BODY_RIGID_CYLINDER:
-        rp->body = ephysics_body_cylinder_add(world);
+        rp->body = EPH_CALL(ephysics_body_cylinder_add)(world);
         break;
 
       case EDJE_PART_PHYSICS_BODY_SOFT_BOX:
-        rp->body = ephysics_body_soft_box_add(world);
+        rp->body = EPH_CALL(ephysics_body_soft_box_add)(world);
         break;
 
       case EDJE_PART_PHYSICS_BODY_SOFT_SPHERE:
-        rp->body = ephysics_body_soft_sphere_add(world, 0);
+        rp->body = EPH_CALL(ephysics_body_soft_sphere_add)(world, 0);
         break;
 
       case EDJE_PART_PHYSICS_BODY_SOFT_CYLINDER:
-        rp->body = ephysics_body_soft_cylinder_add(world);
+        rp->body = EPH_CALL(ephysics_body_soft_cylinder_add)(world);
         break;
 
       case EDJE_PART_PHYSICS_BODY_CLOTH:
-        rp->body = ephysics_body_cloth_add(world, 0, 0);
+        rp->body = EPH_CALL(ephysics_body_cloth_add)(world, 0, 0);
         break;
 
       case EDJE_PART_PHYSICS_BODY_BOUNDARY_TOP:
-        rp->body = ephysics_body_top_boundary_add(world);
+        rp->body = EPH_CALL(ephysics_body_top_boundary_add)(world);
         resize = EINA_FALSE;
         break;
 
       case EDJE_PART_PHYSICS_BODY_BOUNDARY_BOTTOM:
-        rp->body = ephysics_body_bottom_boundary_add(world);
+        rp->body = EPH_CALL(ephysics_body_bottom_boundary_add)(world);
         resize = EINA_FALSE;
         break;
 
       case EDJE_PART_PHYSICS_BODY_BOUNDARY_RIGHT:
-        rp->body = ephysics_body_right_boundary_add(world);
+        rp->body = EPH_CALL(ephysics_body_right_boundary_add)(world);
         resize = EINA_FALSE;
         break;
 
       case EDJE_PART_PHYSICS_BODY_BOUNDARY_LEFT:
-        rp->body = ephysics_body_left_boundary_add(world);
+        rp->body = EPH_CALL(ephysics_body_left_boundary_add)(world);
         resize = EINA_FALSE;
         break;
 
       case EDJE_PART_PHYSICS_BODY_BOUNDARY_FRONT:
-        rp->body = ephysics_body_front_boundary_add(world);
+        rp->body = EPH_CALL(ephysics_body_front_boundary_add)(world);
         resize = EINA_FALSE;
         break;
 
       case EDJE_PART_PHYSICS_BODY_BOUNDARY_BACK:
-        rp->body = ephysics_body_back_boundary_add(world);
+        rp->body = EPH_CALL(ephysics_body_back_boundary_add)(world);
         resize = EINA_FALSE;
         break;
 
@@ -3525,15 +3533,15 @@ _edje_physics_body_add(Edje *ed, Edje_Real_Part *rp, EPhysics_World *world)
 
         edje_object_file_set(edje_obj, ed->path, pface->source);
         evas_object_resize(edje_obj, 1, 1);
-        ephysics_body_face_evas_object_set(rp->body, pface->type,
-                                           edje_obj, EINA_FALSE);
+        EPH_CALL(ephysics_body_face_evas_object_set)(rp->body, pface->type,
+                                                     edje_obj, EINA_FALSE);
         rp->body_faces = eina_list_append(rp->body_faces, edje_obj);
      }
 
-   ephysics_body_evas_object_set(rp->body, rp->object, resize);
-   ephysics_body_event_callback_add(rp->body, EPHYSICS_CALLBACK_BODY_UPDATE,
-                                    _edje_physics_body_update_cb, rp);
-   ephysics_body_data_set(rp->body, ed);
+   EPH_CALL(ephysics_body_evas_object_set)(rp->body, rp->object, resize);
+   EPH_CALL(ephysics_body_event_callback_add)(rp->body, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                              _edje_physics_body_update_cb, rp);
+   EPH_CALL(ephysics_body_data_set)(rp->body, ed);
 }
 
 #endif
diff --git a/src/lib/edje/edje_embryo.c b/src/lib/edje/edje_embryo.c
index a246499..f7eeab6 100644
--- a/src/lib/edje/edje_embryo.c
+++ b/src/lib/edje/edje_embryo.c
@@ -4197,32 +4197,36 @@ _edje_embryo_fn_physics_components_get(Embryo_Program *ep, Embryo_Cell *params,
 static Embryo_Cell
 _edje_embryo_fn_physics_impulse(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_set(
-            ep, params, ephysics_body_central_impulse_apply);
+            ep, params, EPH_CALL(ephysics_body_central_impulse_apply));
 }
 
 /* physics_torque_impulse(part_id, Float:x, Float:y, Float:z) */
 static Embryo_Cell
 _edje_embryo_fn_physics_torque_impulse(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_set(
-            ep, params, ephysics_body_torque_impulse_apply);
+            ep, params, EPH_CALL(ephysics_body_torque_impulse_apply));
 }
 
 /* physics_force(part_id, Float:x, Float:y, Float:z) */
 static Embryo_Cell
 _edje_embryo_fn_physics_force(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_set(
-            ep, params, ephysics_body_central_force_apply);
+            ep, params, EPH_CALL(ephysics_body_central_force_apply));
 }
 
 /* physics_torque(part_id, Float:x, Float:y, Float:z) */
 static Embryo_Cell
 _edje_embryo_fn_physics_torque(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_set(
-            ep, params, ephysics_body_torque_apply);
+            ep, params, EPH_CALL(ephysics_body_torque_apply));
 }
 
 /* physics_clear_forces(part_id) */
@@ -4235,13 +4239,14 @@ _edje_embryo_fn_physics_clear_forces(Embryo_Program *ep, Embryo_Cell *params)
 
    CHKPARAM(1);
 
+   if (!EPH_LOAD()) return 0;
    ed = embryo_program_data_get(ep);
    part_id = params[1];
    if (part_id < 0) return 0;
 
    rp = ed->table_parts[part_id % ed->table_parts_size];
    if ((rp) && (rp->body))
-     ephysics_body_forces_clear(rp->body);
+     EPH_CALL(ephysics_body_forces_clear)(rp->body);
 
    return 0;
 }
@@ -4250,48 +4255,54 @@ _edje_embryo_fn_physics_clear_forces(Embryo_Program *ep, Embryo_Cell *params)
 static Embryo_Cell
 _edje_embryo_fn_physics_get_forces(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_get(
-            ep, params, ephysics_body_forces_get);
+            ep, params, EPH_CALL(ephysics_body_forces_get));
 }
 
 /* physics_get_torques(part_id, &Float:x, &Float:y, &Float:z) */
 static Embryo_Cell
 _edje_embryo_fn_physics_get_torques(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_get(
-            ep, params, ephysics_body_torques_get);
+            ep, params, EPH_CALL(ephysics_body_torques_get));
 }
 
 /* physics_set_velocity(part_id, Float:x, Float:y, Float:z) */
 static Embryo_Cell
 _edje_embryo_fn_physics_set_velocity(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_set(
-            ep, params, ephysics_body_linear_velocity_set);
+            ep, params, EPH_CALL(ephysics_body_linear_velocity_set));
 }
 
 /* physics_get_velocity(part_id, &Float:x, &Float:y, &Float:z) */
 static Embryo_Cell
 _edje_embryo_fn_physics_get_velocity(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_get(
-            ep, params, ephysics_body_linear_velocity_get);
+            ep, params, EPH_CALL(ephysics_body_linear_velocity_get));
 }
 
 /* physics_set_ang_velocity(part_id, Float:x, Float:y, Float:z) */
 static Embryo_Cell
 _edje_embryo_fn_physics_set_ang_velocity(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_set(
-            ep, params, ephysics_body_angular_velocity_set);
+            ep, params, EPH_CALL(ephysics_body_angular_velocity_set));
 }
 
 /* physics_get_ang_velocity(part_id, &Float:x, &Float:y, &Float:z) */
 static Embryo_Cell
 _edje_embryo_fn_physics_get_ang_velocity(Embryo_Program *ep, Embryo_Cell *params)
 {
+   if (!EPH_LOAD()) return 0;
    return _edje_embryo_fn_physics_components_get(
-            ep, params, ephysics_body_angular_velocity_get);
+            ep, params, EPH_CALL(ephysics_body_angular_velocity_get));
 }
 
 /* physics_stop(part_id) */
@@ -4304,13 +4315,14 @@ _edje_embryo_fn_physics_stop(Embryo_Program *ep, Embryo_Cell *params)
 
    CHKPARAM(1);
 
+   if (!EPH_LOAD()) return 0;
    ed = embryo_program_data_get(ep);
    part_id = params[1];
    if (part_id < 0) return 0;
 
    rp = ed->table_parts[part_id % ed->table_parts_size];
    if ((rp) && (rp->body))
-     ephysics_body_stop(rp->body);
+     EPH_CALL(ephysics_body_stop)(rp->body);
 
    return 0;
 }
@@ -4325,6 +4337,7 @@ _edje_embryo_fn_physics_set_rotation(Embryo_Program *ep, Embryo_Cell *params)
 
    CHKPARAM(5);
 
+   if (!EPH_LOAD()) return 0;
    ed = embryo_program_data_get(ep);
    part_id = params[1];
    if (part_id < 0) return 0;
@@ -4340,9 +4353,9 @@ _edje_embryo_fn_physics_set_rotation(Embryo_Program *ep, Embryo_Cell *params)
         y = (double)EMBRYO_CELL_TO_FLOAT(params[4]);
         z = (double)EMBRYO_CELL_TO_FLOAT(params[5]);
 
-        ephysics_quaternion_set(&quat, x, y, z, w);
-        ephysics_quaternion_normalize(&quat);
-        ephysics_body_rotation_set(rp->body, &quat);
+        EPH_CALL(ephysics_quaternion_set)(&quat, x, y, z, w);
+        EPH_CALL(ephysics_quaternion_normalize)(&quat);
+        EPH_CALL(ephysics_body_rotation_set)(rp->body, &quat);
      }
 
    return 0;
@@ -4358,6 +4371,7 @@ _edje_embryo_fn_physics_get_rotation(Embryo_Program *ep, Embryo_Cell *params)
 
    CHKPARAM(5);
 
+   if (!EPH_LOAD()) return 0;
    ed = embryo_program_data_get(ep);
    part_id = params[1];
    if (part_id < 0) return 0;
@@ -4368,8 +4382,8 @@ _edje_embryo_fn_physics_get_rotation(Embryo_Program *ep, Embryo_Cell *params)
         EPhysics_Quaternion quat;
         double w, x, y, z;
 
-        ephysics_body_rotation_get(rp->body, &quat);
-        ephysics_quaternion_get(&quat, &x, &y, &z, &w);
+        EPH_CALL(ephysics_body_rotation_get)(rp->body, &quat);
+        EPH_CALL(ephysics_quaternion_get)(&quat, &x, &y, &z, &w);
 
         SETFLOAT(w, params[2]);
         SETFLOAT(x, params[3]);
diff --git a/src/lib/edje/edje_load.c b/src/lib/edje/edje_load.c
index 89683a5..0d43704 100644
--- a/src/lib/edje/edje_load.c
+++ b/src/lib/edje/edje_load.c
@@ -503,9 +503,8 @@ static void
 _edje_physics_world_update_cb(void *data, EPhysics_World *world EINA_UNUSED, void *event_info EINA_UNUSED)
 {
    Edje *edje = data;
-   _edje_recalc_do(edje);
+   if (EPH_LOAD()) _edje_recalc_do(edje);
 }
-
 #endif
 
 int
@@ -546,10 +545,13 @@ _edje_object_file_set_internal(Evas_Object *obj, const Eina_File *file, const ch
 
 #ifdef HAVE_EPHYSICS
    /* clear physics world  / shutdown ephysics */
-   if ((ed->collection) && (ed->collection->physics_enabled))
+   if ((ed->collection) && (ed->collection->physics_enabled) && (ed->world))
      {
-        ephysics_world_del(ed->world);
-        ephysics_shutdown();
+        if (EPH_LOAD())
+          {
+             EPH_CALL(ephysics_world_del)(ed->world);
+             EPH_CALL(ephysics_shutdown)();
+          }
      }
 #endif
 
@@ -606,17 +608,20 @@ _edje_object_file_set_internal(Evas_Object *obj, const Eina_File *file, const ch
              if (ed->collection->physics_enabled)
 #ifdef HAVE_EPHYSICS
                {
-                  ephysics_init();
-                  ed->world = ephysics_world_new();
-                  ephysics_world_event_callback_add(
-                    ed->world, EPHYSICS_CALLBACK_WORLD_UPDATE,
-                    _edje_physics_world_update_cb, ed);
-                  ephysics_world_rate_set(ed->world,
-                                          ed->collection->physics.world.rate);
-                  ephysics_world_gravity_set(
-                    ed->world, ed->collection->physics.world.gravity.x,
-                    ed->collection->physics.world.gravity.y,
-                    ed->collection->physics.world.gravity.z);
+                  if (EPH_LOAD())
+                    {
+                       EPH_CALL(ephysics_init)();
+                       ed->world = EPH_CALL(ephysics_world_new)();
+                       EPH_CALL(ephysics_world_event_callback_add)
+                         (ed->world, EPHYSICS_CALLBACK_WORLD_UPDATE,
+                          _edje_physics_world_update_cb, ed);
+                       EPH_CALL(ephysics_world_rate_set)
+                         (ed->world, ed->collection->physics.world.rate);
+                       EPH_CALL(ephysics_world_gravity_set)
+                         (ed->world, ed->collection->physics.world.gravity.x,
+                          ed->collection->physics.world.gravity.y,
+                          ed->collection->physics.world.gravity.z);
+                    }
                }
 #else
                ERR("Edje compiled without support to physics.");
diff --git a/src/lib/edje/edje_main.c b/src/lib/edje/edje_main.c
index 13809e6..ee7ecd2 100644
--- a/src/lib/edje/edje_main.c
+++ b/src/lib/edje/edje_main.c
@@ -21,6 +21,11 @@ static const Edje_Calc_Params_Physics default_calc_physics = {
    0.0, 0.0, 0.0, 0.0, 0.0, { 0.0, 0.0 }, { 0.0, 0.0 }, 0, 0, { { 0, 0, 0 }, { 0, 0, 0 } }, 0, 0, 0, 0
 };
 
+#ifdef HAVE_EPHYSICS
+static void _edje_ephysics_clear(void);
+#endif
+
+
 /*============================================================================*
 *                                   API                                      *
 *============================================================================*/
@@ -199,6 +204,10 @@ _edje_shutdown_core(void)
      ecore_imf_shutdown();
 #endif
 
+#ifdef HAVE_EPHYSICS
+   _edje_ephysics_clear();
+#endif
+
    efreet_shutdown();
    evas_shutdown();
    eet_shutdown();
@@ -315,3 +324,131 @@ _edje_need_imf(void)
 #endif
 }
 
+#ifdef HAVE_EPHYSICS
+Edje_Ephysics *_edje_ephysics = NULL;
+
+Eina_Bool
+_edje_ephysics_load(void)
+{
+   if (_edje_ephysics)
+     {
+        if (!_edje_ephysics->mod)
+          {
+             ERR("Cannot find libpulse!");
+             return EINA_FALSE;
+          }
+        return EINA_TRUE;
+     }
+   ERR("PHYYYYYYYYYYYYYYZIKS");
+   _edje_ephysics = calloc(1, sizeof(Edje_Ephysics));
+   if (!_edje_ephysics) return EINA_FALSE;
+# define LOAD(x)                                        \
+   if (!_edje_ephysics->mod) {                          \
+      if ((_edje_ephysics->mod = eina_module_new(x))) { \
+         if (!eina_module_load(_edje_ephysics->mod)) {  \
+            eina_module_free(_edje_ephysics->mod);      \
+            _edje_ephysics->mod = NULL;                 \
+         }                                              \
+      }                                                 \
+   }
+# if defined(_WIN32) || defined(__CYGWIN__)
+   LOAD("libephysics-1.dll");
+   LOAD("libephysics.dll");
+# elif defined(__APPLE__) && defined(__MACH__)
+   LOAD("libephysics.1.dylib");
+   LOAD("libephysics.1.so");
+   LOAD("libephysics.so.1");
+# else
+   LOAD("libephysics.so.1");
+# endif
+# undef LOAD
+   if (!_edje_ephysics->mod) return EINA_FALSE;
+# define SYM(x) \
+   if (!(_edje_ephysics->x = eina_module_symbol_get(_edje_ephysics->mod, #x))) { \
+      ERR("libpulse - cannot find %s", #x); \
+      goto err; \
+   }
+   SYM(ephysics_init);
+   SYM(ephysics_shutdown);
+   SYM(ephysics_world_new);
+   SYM(ephysics_world_del);
+   SYM(ephysics_world_event_callback_add)
+   SYM(ephysics_world_rate_set)
+   SYM(ephysics_world_gravity_set)
+   SYM(ephysics_world_render_geometry_set);
+   SYM(ephysics_world_render_geometry_get);
+   SYM(ephysics_quaternion_set)
+   SYM(ephysics_quaternion_get)
+   SYM(ephysics_quaternion_normalize)
+   SYM(ephysics_body_box_add)
+   SYM(ephysics_body_sphere_add)
+   SYM(ephysics_body_cylinder_add)
+   SYM(ephysics_body_soft_box_add)
+   SYM(ephysics_body_soft_sphere_add)
+   SYM(ephysics_body_soft_cylinder_add)
+   SYM(ephysics_body_cloth_add)
+   SYM(ephysics_body_top_boundary_add)
+   SYM(ephysics_body_bottom_boundary_add)
+   SYM(ephysics_body_right_boundary_add)
+   SYM(ephysics_body_left_boundary_add)
+   SYM(ephysics_body_front_boundary_add)
+   SYM(ephysics_body_back_boundary_add)
+   SYM(ephysics_body_central_impulse_apply)
+   SYM(ephysics_body_torque_impulse_apply)
+   SYM(ephysics_body_central_force_apply)
+   SYM(ephysics_body_torque_apply)
+   SYM(ephysics_body_forces_clear)
+   SYM(ephysics_body_linear_velocity_set)
+   SYM(ephysics_body_angular_velocity_set)
+   SYM(ephysics_body_stop)
+   SYM(ephysics_body_rotation_set)
+   SYM(ephysics_body_forces_get)
+   SYM(ephysics_body_torques_get)
+   SYM(ephysics_body_linear_velocity_get)
+   SYM(ephysics_body_angular_velocity_get)
+   SYM(ephysics_body_linear_movement_enable_set)
+   SYM(ephysics_body_angular_movement_enable_set)
+   SYM(ephysics_body_move)
+   SYM(ephysics_body_geometry_get)
+   SYM(ephysics_body_resize)
+   SYM(ephysics_body_material_set)
+   SYM(ephysics_body_density_set)
+   SYM(ephysics_body_mass_set)
+   SYM(ephysics_body_soft_body_hardness_set)
+   SYM(ephysics_body_restitution_set)
+   SYM(ephysics_body_friction_set)
+   SYM(ephysics_body_damping_set)
+   SYM(ephysics_body_sleeping_threshold_set)
+   SYM(ephysics_body_light_set)
+   SYM(ephysics_body_back_face_culling_set)
+   SYM(ephysics_body_evas_object_update)
+   SYM(ephysics_body_face_evas_object_set)
+   SYM(ephysics_body_evas_object_set)
+   SYM(ephysics_body_event_callback_add)
+   SYM(ephysics_body_data_set)
+   SYM(ephysics_body_data_get)
+   SYM(ephysics_body_rotation_get)
+#undef SYM
+   return EINA_TRUE;
+err:
+   if (_edje_ephysics->mod)
+     {
+        eina_module_free(_edje_ephysics->mod);
+        _edje_ephysics->mod = NULL;
+     }
+   return EINA_FALSE;
+}
+
+static void
+_edje_ephysics_clear(void)
+{
+   if (_edje_ephysics)
+     {
+        if (_edje_ephysics->mod)
+          eina_module_free(_edje_ephysics->mod);
+        free(_edje_ephysics);
+        _edje_ephysics = NULL;
+     }
+}
+#endif
+
diff --git a/src/lib/edje/edje_private.h b/src/lib/edje/edje_private.h
index fd53254..daf3041 100644
--- a/src/lib/edje/edje_private.h
+++ b/src/lib/edje/edje_private.h
@@ -3279,6 +3279,85 @@ Edje_Vector_Data * _edje_ref_vector_data(Edje *ed, int svg_id);
 
 EAPI void _edje_svg_node_free(Svg_Node *node);
 
+#ifdef HAVE_EPHYSICS
+Eina_Bool _edje_ephysics_load(void);
+
+typedef struct _Edje_Ephysics Edje_Ephysics;
+
+struct _Edje_Ephysics
+{
+   Eina_Module *mod;
+
+   int (*ephysics_init) (void);
+   int (*ephysics_shutdown) (void);
+   EPhysics_World *(*ephysics_world_new) (void);
+   void (*ephysics_world_del) (EPhysics_World *world);
+   void (*ephysics_world_event_callback_add) (EPhysics_World *world, EPhysics_Callback_World_Type type, EPhysics_World_Event_Cb func, const void *data);
+   void (*ephysics_world_rate_set) (EPhysics_World *world, double rate);
+   void (*ephysics_world_gravity_set) (EPhysics_World *world, double gx, double gy, double gz);
+   void (*ephysics_world_render_geometry_set) (EPhysics_World *world, Evas_Coord x, Evas_Coord y, Evas_Coord z, Evas_Coord w, Evas_Coord h, Evas_Coord d);
+   void (*ephysics_world_render_geometry_get) (const EPhysics_World *world, Evas_Coord *x, Evas_Coord *y, Evas_Coord *z, Evas_Coord *w, Evas_Coord *h, Evas_Coord *d);
+   void (*ephysics_quaternion_set) (EPhysics_Quaternion *quat, double x, double y, double z, double w);
+   void (*ephysics_quaternion_get) (const EPhysics_Quaternion *quat, double *x, double *y, double *z, double *w);
+   void (*ephysics_quaternion_normalize) (EPhysics_Quaternion *quat);
+   EPhysics_Body *(*ephysics_body_box_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_sphere_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_cylinder_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_soft_box_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_soft_sphere_add) (EPhysics_World *world, int granularity);
+   EPhysics_Body *(*ephysics_body_soft_cylinder_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_cloth_add) (EPhysics_World *world, unsigned short rows, unsigned short columns);
+   EPhysics_Body *(*ephysics_body_top_boundary_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_bottom_boundary_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_right_boundary_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_left_boundary_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_front_boundary_add) (EPhysics_World *world);
+   EPhysics_Body *(*ephysics_body_back_boundary_add) (EPhysics_World *world);
+   void (*ephysics_body_central_impulse_apply) (EPhysics_Body *body, double x, double y, double z);
+   void (*ephysics_body_torque_impulse_apply) (EPhysics_Body *body, double pitch, double yaw, double roll);
+   void (*ephysics_body_central_force_apply) (EPhysics_Body *body, double x, double y, double z);
+   void (*ephysics_body_torque_apply) (EPhysics_Body *body, double torque_x, double torque_y, double torque_z);
+   void (*ephysics_body_forces_clear) (EPhysics_Body *body);
+   void (*ephysics_body_linear_velocity_set) (EPhysics_Body *body, double x, double y, double z);
+   void (*ephysics_body_angular_velocity_set) (EPhysics_Body *body, double x, double y, double z);
+   void (*ephysics_body_stop) (EPhysics_Body *body);
+   void (*ephysics_body_rotation_set) (EPhysics_Body *body, EPhysics_Quaternion *quat);
+   void (*ephysics_body_forces_get) (const EPhysics_Body *body, double *x, double *y, double *z);
+   void (*ephysics_body_torques_get) (const EPhysics_Body *body, double *x, double *y, double *z);
+   void (*ephysics_body_linear_velocity_get) (const EPhysics_Body *body, double *x, double *y, double *z);
+   void (*ephysics_body_angular_velocity_get) (const EPhysics_Body *body, double *x, double *y, double *z);
+   void (*ephysics_body_linear_movement_enable_set) (EPhysics_Body *body, Eina_Bool enable_x, Eina_Bool enable_y, Eina_Bool enable_z);
+   void (*ephysics_body_angular_movement_enable_set) (EPhysics_Body *body, Eina_Bool enable_x, Eina_Bool enable_y, Eina_Bool enable_z);
+   void (*ephysics_body_move) (EPhysics_Body *body, Evas_Coord x, Evas_Coord y, Evas_Coord z);
+   void (*ephysics_body_geometry_get) (const EPhysics_Body *body, Evas_Coord *x, Evas_Coord *y, Evas_Coord *z, Evas_Coord *w, Evas_Coord *h, Evas_Coord *d);
+   void (*ephysics_body_resize) (EPhysics_Body *body, Evas_Coord w, Evas_Coord h, Evas_Coord d);
+   void (*ephysics_body_material_set) (EPhysics_Body *body, EPhysics_Body_Material material);
+   void (*ephysics_body_density_set) (EPhysics_Body *body, double density);
+   void (*ephysics_body_mass_set) (EPhysics_Body *body, double mass);
+   void (*ephysics_body_soft_body_hardness_set) (EPhysics_Body *body, double hardness);
+   void (*ephysics_body_restitution_set) (EPhysics_Body *body, double restitution);
+   void (*ephysics_body_friction_set) (EPhysics_Body *body, double friction);
+   void (*ephysics_body_damping_set) (EPhysics_Body *body, double linear_damping, double angular_damping);
+   void (*ephysics_body_sleeping_threshold_set) (EPhysics_Body *body, double linear_threshold, double angular_threshold);
+   void (*ephysics_body_light_set) (EPhysics_Body *body, Eina_Bool enable);
+   void (*ephysics_body_back_face_culling_set) (EPhysics_Body *body, Eina_Bool enable);
+   void (*ephysics_body_evas_object_update) (EPhysics_Body *body);
+   void (*ephysics_body_face_evas_object_set) (EPhysics_Body *body, EPhysics_Body_Face face, Evas_Object *evas_obj, Eina_Bool use_obj_pos);
+   void (*ephysics_body_evas_object_set) (EPhysics_Body *body, Evas_Object *evas_obj, Eina_Bool use_obj_pos);
+   void (*ephysics_body_event_callback_add) (EPhysics_Body *body, EPhysics_Callback_Body_Type type, EPhysics_Body_Event_Cb func, const void *data);
+   void (*ephysics_body_data_set) (EPhysics_Body *body, void *data);
+   void *(*ephysics_body_data_get) (const EPhysics_Body *body);
+   EPhysics_Quaternion *(*ephysics_body_rotation_get) (const EPhysics_Body *body, EPhysics_Quaternion *rotation);
+};
+
+extern Edje_Ephysics *_edje_ephysics;
+#define EPH_LOAD() _edje_ephysics_load()
+#define EPH_CALL(x) _edje_ephysics->x
+
+#endif
+
+
+
 #ifdef HAVE_LIBREMIX
 #include <remix/remix.h>
 #endif
diff --git a/src/lib/edje/edje_program.c b/src/lib/edje/edje_program.c
index 99ac484..3aa1a76 100644
--- a/src/lib/edje/edje_program.c
+++ b/src/lib/edje/edje_program.c
@@ -1074,79 +1074,106 @@ low_mem_current:
 
 #ifdef HAVE_EPHYSICS
       case EDJE_ACTION_TYPE_PHYSICS_IMPULSE:
-        if (!_edje_physics_action_set(ed, pr, ephysics_body_central_impulse_apply))
-          goto break_prog;
+        if (EPH_LOAD())
+          {
+             if (!_edje_physics_action_set(ed, pr, EPH_CALL(ephysics_body_central_impulse_apply)))
+               goto break_prog;
+          }
         break;
 
       case EDJE_ACTION_TYPE_PHYSICS_TORQUE_IMPULSE:
-        if (!_edje_physics_action_set(ed, pr, ephysics_body_torque_impulse_apply))
-          goto break_prog;
+        if (EPH_LOAD())
+          {
+             if (!_edje_physics_action_set(ed, pr, EPH_CALL(ephysics_body_torque_impulse_apply)))
+               goto break_prog;
+          }
         break;
 
       case EDJE_ACTION_TYPE_PHYSICS_FORCE:
-        if (!_edje_physics_action_set(ed, pr, ephysics_body_central_force_apply))
-          goto break_prog;
+        if (EPH_LOAD())
+          {
+             if (!_edje_physics_action_set(ed, pr, EPH_CALL(ephysics_body_central_force_apply)))
+               goto break_prog;
+          }
         break;
 
       case EDJE_ACTION_TYPE_PHYSICS_TORQUE:
-        if (!_edje_physics_action_set(ed, pr, ephysics_body_torque_apply))
-          goto break_prog;
+        if (EPH_LOAD())
+          {
+             if (!_edje_physics_action_set(ed, pr, EPH_CALL(ephysics_body_torque_apply)))
+               goto break_prog;
+          }
         break;
 
       case EDJE_ACTION_TYPE_PHYSICS_FORCES_CLEAR:
-        if (_edje_block_break(ed))
-          goto break_prog;
-        EINA_LIST_FOREACH(pr->targets, l, pt)
+        if (EPH_LOAD())
           {
-             if (pt->id >= 0)
+             if (_edje_block_break(ed))
+               goto break_prog;
+             EINA_LIST_FOREACH(pr->targets, l, pt)
                {
-                  rp = ed->table_parts[pt->id % ed->table_parts_size];
-                  if ((rp) && (rp->body))
-                    ephysics_body_forces_clear(rp->body);
+                  if (pt->id >= 0)
+                    {
+                       rp = ed->table_parts[pt->id % ed->table_parts_size];
+                       if ((rp) && (rp->body))
+                         EPH_CALL(ephysics_body_forces_clear)(rp->body);
+                    }
                }
           }
         break;
 
       case EDJE_ACTION_TYPE_PHYSICS_VEL_SET:
-        if (!_edje_physics_action_set(ed, pr, ephysics_body_linear_velocity_set))
-          goto break_prog;
+        if (EPH_LOAD())
+          {
+             if (!_edje_physics_action_set(ed, pr, EPH_CALL(ephysics_body_linear_velocity_set)))
+               goto break_prog;
+          }
         break;
 
       case EDJE_ACTION_TYPE_PHYSICS_ANG_VEL_SET:
-        if (!_edje_physics_action_set(ed, pr, ephysics_body_angular_velocity_set))
-          goto break_prog;
+        if (EPH_LOAD())
+          {
+             if (!_edje_physics_action_set(ed, pr, EPH_CALL(ephysics_body_angular_velocity_set)))
+               goto break_prog;
+          }
         break;
 
       case EDJE_ACTION_TYPE_PHYSICS_STOP:
-        if (_edje_block_break(ed))
-          goto break_prog;
-        EINA_LIST_FOREACH(pr->targets, l, pt)
+        if (EPH_LOAD())
           {
-             if (pt->id >= 0)
+             if (_edje_block_break(ed))
+               goto break_prog;
+             EINA_LIST_FOREACH(pr->targets, l, pt)
                {
-                  rp = ed->table_parts[pt->id % ed->table_parts_size];
-                  if ((rp) && (rp->body))
-                    ephysics_body_stop(rp->body);
+                  if (pt->id >= 0)
+                    {
+                       rp = ed->table_parts[pt->id % ed->table_parts_size];
+                       if ((rp) && (rp->body))
+                         EPH_CALL(ephysics_body_stop)(rp->body);
+                    }
                }
           }
         break;
 
       case EDJE_ACTION_TYPE_PHYSICS_ROT_SET:
-        if (_edje_block_break(ed))
-          goto break_prog;
-        EINA_LIST_FOREACH(pr->targets, l, pt)
+        if (EPH_LOAD())
           {
-             if (pt->id >= 0)
+             if (_edje_block_break(ed))
+               goto break_prog;
+             EINA_LIST_FOREACH(pr->targets, l, pt)
                {
-                  rp = ed->table_parts[pt->id % ed->table_parts_size];
-                  if ((rp) && (rp->body))
+                  if (pt->id >= 0)
                     {
-                       EPhysics_Quaternion quat;
-                       ephysics_quaternion_set(&quat, pr->physics.x,
-                                               pr->physics.y, pr->physics.z,
-                                               pr->physics.w);
-                       ephysics_quaternion_normalize(&quat);
-                       ephysics_body_rotation_set(rp->body, &quat);
+                       rp = ed->table_parts[pt->id % ed->table_parts_size];
+                       if ((rp) && (rp->body))
+                         {
+                            EPhysics_Quaternion quat;
+                            EPH_CALL(ephysics_quaternion_set)(&quat, pr->physics.x,
+                                                              pr->physics.y, pr->physics.z,
+                                                              pr->physics.w);
+                            EPH_CALL(ephysics_quaternion_normalize)(&quat);
+                            EPH_CALL(ephysics_body_rotation_set)(rp->body, &quat);
+                         }
                     }
                }
           }
diff --git a/src/lib/edje/edje_smart.c b/src/lib/edje/edje_smart.c
index dff5823..03fda4c 100644
--- a/src/lib/edje/edje_smart.c
+++ b/src/lib/edje/edje_smart.c
@@ -156,10 +156,13 @@ _edje_object_efl_canvas_group_group_del(Eo *obj, Edje *ed)
    if (_edje_lua_script_only(ed)) _edje_lua_script_only_shutdown(ed);
 #ifdef HAVE_EPHYSICS
    /* clear physics world  / shutdown ephysics */
-   if ((ed->collection) && (ed->collection->physics_enabled))
+   if ((ed->collection) && (ed->collection->physics_enabled) && (ed->world))
      {
-        ephysics_world_del(ed->world);
-        ephysics_shutdown();
+        if (EPH_LOAD())
+          {
+             EPH_CALL(ephysics_world_del)(ed->world);
+             EPH_CALL(ephysics_shutdown)();
+          }
      }
 #endif
    if (ed->persp) edje_object_perspective_set(obj, NULL);
@@ -272,9 +275,12 @@ _edje_object_efl_canvas_group_group_resize(Eo *obj EINA_UNUSED, Edje *ed, Evas_C
    ed->h = h;
 #ifdef HAVE_EPHYSICS
    if ((ed->collection) && (ed->world))
-     ephysics_world_render_geometry_set(
-       ed->world, ed->x, ed->y, ed->collection->physics.world.z,
-       ed->w, ed->h, ed->collection->physics.world.depth);
+     {
+        if (EPH_LOAD())
+          EPH_CALL(ephysics_world_render_geometry_set)
+            (ed->world, ed->x, ed->y, ed->collection->physics.world.z,
+             ed->w, ed->h, ed->collection->physics.world.depth);
+     }
 #endif
 #ifdef EDJE_CALC_CACHE
    ed->all_part_change = EINA_TRUE;