vitorsousa pushed a commit to branch master.

http://git.enlightenment.org/core/efl.git/commit/?id=1422e62f302f2f2f0995b19f98d6f971e39a921f

commit 1422e62f302f2f2f0995b19f98d6f971e39a921f
Author: Lauro Moura <lauromo...@expertisesolutions.com.br>
Date:   Tue Mar 15 18:00:20 2016 -0300

    efl js: Fix naming of manual binding functions.
    
    Also removed references to the discarded manual binding "ecore_js_file".
---
 src/Makefile_Ecore_Js.am                      |   3 +-
 src/bindings/js/ecore_js/Ecore_Js.hh          |   2 +-
 src/bindings/js/ecore_js/ecore_js_animator.cc |  48 +++---
 src/bindings/js/ecore_js/ecore_js_event.cc    |  51 +++----
 src/bindings/js/ecore_js/ecore_js_idle.cc     |  12 +-
 src/bindings/js/ecore_js/ecore_js_init.cc     |  16 +-
 src/bindings/js/ecore_js/ecore_js_job.cc      |   2 +-
 src/bindings/js/ecore_js/ecore_js_mainloop.cc |  20 +--
 src/bindings/js/ecore_js/ecore_js_poller.cc   |  12 +-
 src/bindings/js/ecore_js/ecore_js_throttle.cc |   4 +-
 src/bindings/js/ecore_js/ecore_js_timer.cc    |  10 +-
 src/bindings/js/efl_js/efl_js.cc              |   6 +-
 src/bindings/js/eio_js/Eio_Js.hh              |   2 +-
 src/bindings/js/eio_js/eio_js.cc              | 181 +++++++++++------------
 src/bindings/js/ethumb_js/Ethumb_Js.hh        |   1 +
 src/bindings/js/ethumb_js/ethumb_js_client.cc |  29 ++--
 src/tests/efl_js/benchmark_js_suite.js        |   2 +-
 src/tests/efl_js/ecore_js_suite.js            | 202 +++++++++++++-------------
 src/tests/efl_js/eina_js_containers_suite.js  |   2 +-
 src/tests/efl_js/eina_js_suite.js             |   2 +-
 src/tests/efl_js/eio_js_suite.js              |   4 +-
 src/tests/efl_js/eldbus_js_suite.js           |   2 +-
 src/tests/efl_js/ethumb_js_suite.js           |  10 +-
 src/tests/eolian_js/eolian_js_suite.js        |   2 +-
 24 files changed, 304 insertions(+), 321 deletions(-)

diff --git a/src/Makefile_Ecore_Js.am b/src/Makefile_Ecore_Js.am
index df5ac2f..0c73b99 100644
--- a/src/Makefile_Ecore_Js.am
+++ b/src/Makefile_Ecore_Js.am
@@ -13,7 +13,6 @@ bindings/js/ecore_js/ecore_js_job.hh \
 bindings/js/ecore_js/ecore_js_idle.hh \
 bindings/js/ecore_js/ecore_js_animator.hh \
 bindings/js/ecore_js/ecore_js_poller.hh \
-bindings/js/ecore_js/ecore_js_throttle.hh \
-bindings/js/ecore_js/ecore_js_file.hh
+bindings/js/ecore_js/ecore_js_throttle.hh
 endif
 
diff --git a/src/bindings/js/ecore_js/Ecore_Js.hh 
b/src/bindings/js/ecore_js/Ecore_Js.hh
index 3f877f3..15331aa 100644
--- a/src/bindings/js/ecore_js/Ecore_Js.hh
+++ b/src/bindings/js/ecore_js/Ecore_Js.hh
@@ -5,6 +5,7 @@
 #include <Ecore.hh>
 #include <Ecore_File.h>
 #include <Eina_Js.hh>
+#include <Eo_Js.hh>
 
 #ifdef EAPI
 # undef EAPI
@@ -43,7 +44,6 @@ using 
::efl::eina::js::compatibility_set_pointer_internal_field;
 
 EAPI void register_ecore_animator(v8::Isolate *isolate,v8::Handle<v8::Object> 
exports);
 EAPI void register_ecore_event(v8::Isolate* isolate, v8::Handle<v8::Object> 
exports);
-EAPI void register_ecore_file(v8::Isolate* isolate, v8::Handle<v8::Object> 
exports);
 EAPI void register_ecore_idle(v8::Isolate *isolate,v8::Handle<v8::Object> 
exports);
 EAPI void register_ecore_job(v8::Isolate *isolate,v8::Handle<v8::Object> 
exports);
 EAPI void register_ecore_mainloop(v8::Isolate *isolate,v8::Handle<v8::Object> 
exports);
diff --git a/src/bindings/js/ecore_js/ecore_js_animator.cc 
b/src/bindings/js/ecore_js/ecore_js_animator.cc
index 849e4d7..322db17 100644
--- a/src/bindings/js/ecore_js/ecore_js_animator.cc
+++ b/src/bindings/js/ecore_js/ecore_js_animator.cc
@@ -526,83 +526,75 @@ void register_ecore_animator(v8::Isolate* isolate, 
v8::Handle<v8::Object> export
 {
    register_pos_map_linear(isolate, exports,
                            compatibility_new<v8::String>(isolate,
-                                                     "ECORE_POS_MAP_LINEAR"));
+                                                     "POS_MAP_LINEAR"));
    register_pos_map_accelerate(isolate, exports,
                                compatibility_new<v8::String>(isolate,
-                                                         "ECORE_POS_MAP"
+                                                         "POS_MAP"
                                                          "_ACCELERATE"));
    register_pos_map_decelerate(isolate, exports,
                                compatibility_new<v8::String>(isolate,
-                                                         "ECORE_POS_MAP"
+                                                         "POS_MAP"
                                                          "_DECELERATE"));
    register_pos_map_sinusoidal(isolate, exports,
                                compatibility_new<v8::String>(isolate,
-                                                         "ECORE_POS_MAP"
+                                                         "POS_MAP"
                                                          "_SINUSOIDAL"));
    register_pos_map_accelerate_factor(isolate, exports,
                                       compatibility_new<v8::String>(isolate,
-                                                                "ECORE_POS_MAP"
+                                                                "POS_MAP"
                                                                 "_ACCELERATE"
                                                                 "_FACTOR"));
    register_pos_map_decelerate_factor(isolate, exports,
                                       compatibility_new<v8::String>(isolate,
-                                                                "ECORE_POS_MAP"
+                                                                "POS_MAP"
                                                                 "_DECELERATE"
                                                                 "_FACTOR"));
    register_pos_map_sinusoidal_factor(isolate, exports,
                                       compatibility_new<v8::String>(isolate,
-                                                                "ECORE_POS_MAP"
+                                                                "POS_MAP"
                                                                 "_SINUSOIDAL"
                                                                 "_FACTOR"));
    register_pos_map_divisor_interp(isolate, exports,
                                    compatibility_new<v8::String>(isolate,
-                                                             "ECORE_POS_MAP"
+                                                             "POS_MAP"
                                                              
"_DIVISOR_INTERP"));
    register_pos_map_bounce(isolate, exports,
                            compatibility_new<v8::String>(isolate,
-                                                     "ECORE_POS_MAP_BOUNCE"));
+                                                     "POS_MAP_BOUNCE"));
    register_pos_map_spring(isolate, exports,
                            compatibility_new<v8::String>(isolate,
-                                                     "ECORE_POS_MAP_SPRING"));
+                                                     "POS_MAP_SPRING"));
    register_pos_map_cubic_bezier(isolate, exports,
                                  compatibility_new<v8::String>(isolate,
-                                                           
"ECORE_POS_MAP_CUBIC"
+                                                           "POS_MAP_CUBIC"
                                                            "_BEZIER"));
    register_animator_source_timer(isolate, exports,
                                   compatibility_new<v8::String>(isolate,
-                                                            "ECORE_ANIMATOR"
-                                                            "_SOURCE_TIMER"));
+                                                            "SOURCE_TIMER"));
    register_animator_frametime_set(isolate, exports,
                                    compatibility_new<v8::String>(isolate,
-                                                             "ecore_animator"
-                                                             
"_frametime_set"));
+                                                             "setFrametime"));
    register_animator_frametime_get(isolate, exports,
                                    compatibility_new<v8::String>(isolate,
-                                                             "ecore_animator"
-                                                             
"_frametime_get"));
+                                                             "getFrametime"));
    register_animator_pos_map(isolate, exports,
                              compatibility_new<v8::String>(isolate,
-                                                       "ecore_animator_pos"
-                                                       "_map"));
+                                                       "posMap"));
    register_animator_pos_map_n(isolate, exports,
                                compatibility_new<v8::String>(isolate,
-                                                         
"ecore_animator_pos_map"
-                                                         "_n"));
+                                                         "posMapN"));
    register_animator_source_set(isolate, exports,
                                 compatibility_new<v8::String>(isolate,
-                                                          
"ecore_animator_source"
-                                                          "_set"));
+                                                          "setSource"));
    register_animator_source_get(isolate, exports,
                                 compatibility_new<v8::String>(isolate,
-                                                          
"ecore_animator_source"
-                                                          "_get"));
+                                                          "getSource"));
    register_animator_add(isolate, exports,
                          compatibility_new<v8::String>(isolate,
-                                                   "ecore_animator_add"));
+                                                   "add"));
    register_animator_timeline_add(isolate, exports,
                                   compatibility_new<v8::String>(isolate,
-                                                            "ecore_animator"
-                                                            "_timeline_add"));
+                                                            "addTimeline"));
 }   
       
 } } } // namespace efl { namespace js {
diff --git a/src/bindings/js/ecore_js/ecore_js_event.cc 
b/src/bindings/js/ecore_js/ecore_js_event.cc
index a086d98..dbfa10c 100644
--- a/src/bindings/js/ecore_js/ecore_js_event.cc
+++ b/src/bindings/js/ecore_js/ecore_js_event.cc
@@ -690,83 +690,80 @@ void register_ecore_event(v8::Isolate* isolate, 
v8::Handle<v8::Object> exports)
 {
    register_event_none(isolate, exports,
                        compatibility_new<v8::String>(isolate,
-                                                 "ECORE_EVENT_NONE"));
+                                                 "NONE"));
    register_event_signal_user(isolate, exports,
                               compatibility_new<v8::String>
-                              (isolate, "ECORE_EVENT_SIGNAL_USER"));
+                              (isolate, "SIGNAL_USER"));
    register_event_signal_hup(isolate, exports,
                              compatibility_new<v8::String>
-                             (isolate, "ECORE_EVENT_SIGNAL_HUP"));
+                             (isolate, "SIGNAL_HUP"));
    register_event_signal_exit(isolate, exports,
                               compatibility_new<v8::String>
-                              (isolate, "ECORE_EVENT_SIGNAL_EXIT"));
+                              (isolate, "SIGNAL_EXIT"));
    register_event_signal_power(isolate, exports,
                                compatibility_new<v8::String>
-                               (isolate, "ECORE_EVENT_SIGNAL_POWER"));
+                               (isolate, "SIGNAL_POWER"));
    register_event_signal_realtime(isolate, exports,
                                   compatibility_new<v8::String>
-                                  (isolate, "ECORE_EVENT_SIGNAL_REALTIME"));
+                                  (isolate, "SIGNAL_REALTIME"));
    register_event_memory_state(isolate, exports,
                                compatibility_new<v8::String>
-                               (isolate, "ECORE_EVENT_MEMORY_STATE"));
+                               (isolate, "MEMORY_STATE"));
    register_event_power_state(isolate, exports,
                               compatibility_new<v8::String>
-                              (isolate, "ECORE_EVENT_POWER_STATE"));
+                              (isolate, "POWER_STATE"));
    register_event_locale_changed(isolate, exports,
                                  compatibility_new<v8::String>
-                                 (isolate, "ECORE_EVENT_LOCALE_CHANGED"));
+                                 (isolate, "LOCALE_CHANGED"));
    register_event_hostname_changed(isolate, exports,
                                    compatibility_new<v8::String>
-                                   (isolate, "ECORE_EVENT_HOSTNAME_CHANGED"));
+                                   (isolate, "HOSTNAME_CHANGED"));
    register_event_system_timedate_changed(isolate, exports,
                                           compatibility_new<v8::String>
                                           (isolate,
-                                           "ECORE_EVENT_SYSTEM_TIMEDATE"
+                                           "SYSTEM_TIMEDATE"
                                            "_CHANGED"));
    register_event_type_new(isolate, exports,
                            compatibility_new<v8::String>(isolate,
-                                                     "ecore_event_type_new"));
+                                                     "newType"));
    register_event_add(isolate, exports,
-                      compatibility_new<v8::String>(isolate, 
"ecore_event_add"));
+                      compatibility_new<v8::String>(isolate, "add"));
    register_event_handler_add(isolate, exports,
                               compatibility_new<v8::String>
-                              (isolate, "ecore_event_handler_add"));
+                              (isolate, "addHandler"));
    register_event_filter_add(isolate, exports,
                              compatibility_new<v8::String>
-                             (isolate, "ecore_event_filter_add"));
+                             (isolate, "addFilter"));
    register_event_current_type_get(isolate, exports,
                                    compatibility_new<v8::String>
-                                   (isolate, "ecore_event_current_type_get"));
+                                   (isolate, "getCurrentType"));
    register_memory_state_normal(isolate, exports,
                                 compatibility_new<v8::String>
-                                (isolate, "ECORE_MEMORY_STATE_NORMAL"));
+                                (isolate, "MEMORY_STATE_NORMAL"));
    register_memory_state_low(isolate, exports,
                              compatibility_new<v8::String>
-                             (isolate, "ECORE_MEMORY_STATE_LOW"));
+                             (isolate, "MEMORY_STATE_LOW"));
    register_power_state_mains(isolate, exports,
                               compatibility_new<v8::String>
-                              (isolate, "ECORE_POWER_STATE_MAINS"));
+                              (isolate, "POWER_STATE_MAINS"));
    register_power_state_battery(isolate, exports,
                                 compatibility_new<v8::String>
-                                (isolate, "ECORE_POWER_STATE_BATTERY"));
+                                (isolate, "POWER_STATE_BATTERY"));
    register_power_state_low(isolate, exports,
                             compatibility_new<v8::String>(isolate,
-                                                      
"ECORE_POWER_STATE_LOW"));
+                                                      "POWER_STATE_LOW"));
    register_event_signal_user_handler_add(isolate, exports,
                                           compatibility_new<v8::String>
                                           (isolate,
-                                           "ecore_event_signal_user_handler"
-                                           "_add"));
+                                           "addSignalUserHandler"));
    register_event_signal_exit_handler_add(isolate, exports,
                                           compatibility_new<v8::String>
                                           (isolate,
-                                           "ecore_event_signal_exit_handler"
-                                           "_add"));
+                                           "addSignalExitHandler"));
    register_event_signal_realtime_handler_add(isolate, exports,
                                               compatibility_new<v8::String>
                                               (isolate,
-                                               "ecore_event_signal_realtime"
-                                               "_handler_add"));
+                                               "addSignalRealtimeHandler"));
 }
       
 } } } // namespace efl { namespace js {
diff --git a/src/bindings/js/ecore_js/ecore_js_idle.cc 
b/src/bindings/js/ecore_js/ecore_js_idle.cc
index 293cef2..9bad24b 100644
--- a/src/bindings/js/ecore_js/ecore_js_idle.cc
+++ b/src/bindings/js/ecore_js/ecore_js_idle.cc
@@ -276,19 +276,17 @@ EAPI
 void register_ecore_idle(v8::Isolate *isolate,v8::Handle<v8::Object> exports)
 {
    register_idler_add(isolate, exports,
-                      compatibility_new<v8::String>(isolate, 
"ecore_idler_add"));
+                      compatibility_new<v8::String>(isolate, "add"));
    register_idle_enterer_add(isolate, exports,
                              compatibility_new<v8::String>(isolate,
-                                                       "ecore_idle_enterer"
-                                                       "_add"));
+                                                       "addEnterer"));
    register_idle_enterer_before_add(isolate, exports,
                                     compatibility_new<v8::String>(isolate,
-                                                              "ecore_idle"
-                                                              "_enterer_before"
-                                                              "_add"));
+                                                              "addEnterer"
+                                                              "Before"));
    register_idle_exiter_add(isolate, exports,
                             compatibility_new<v8::String>(isolate,
-                                                      
"ecore_idle_exiter_add"));
+                                                      "addExiter"));
 }
 
 } } } // namespace efl { namespace js {
diff --git a/src/bindings/js/ecore_js/ecore_js_init.cc 
b/src/bindings/js/ecore_js/ecore_js_init.cc
index ba2b04f..9f1c8cb 100644
--- a/src/bindings/js/ecore_js/ecore_js_init.cc
+++ b/src/bindings/js/ecore_js/ecore_js_init.cc
@@ -63,14 +63,14 @@ void register_ecore(v8::Isolate 
*isolate,v8::Handle<v8::Object> exports)
    efl::ecore::js::register_shutdown(isolate, exports,
                                      
efl::eina::js::compatibility_new<v8::String>
                                      (isolate, "ecore_shutdown"));
-   register_ecore_animator(isolate, exports);
-   register_ecore_event(isolate, exports);
-   register_ecore_idle(isolate, exports);
-   register_ecore_job(isolate, exports);
-   register_ecore_mainloop(isolate, exports);
-   register_ecore_poller(isolate, exports);
-   register_ecore_throttle(isolate, exports);
-   register_ecore_timer(isolate, exports);
+   register_ecore_animator(isolate, efl::eo::js::get_namespace({"Ecore", 
"Animator"}, isolate, exports));
+   register_ecore_event(isolate, efl::eo::js::get_namespace({"Ecore", 
"Event"}, isolate, exports));
+   register_ecore_idle(isolate, efl::eo::js::get_namespace({"Ecore", "Idle"}, 
isolate, exports));
+   register_ecore_job(isolate, efl::eo::js::get_namespace({"Ecore", "Job"}, 
isolate, exports));
+   register_ecore_mainloop(isolate, efl::eo::js::get_namespace({"Ecore", 
"Mainloop"}, isolate, exports));
+   register_ecore_poller(isolate, efl::eo::js::get_namespace({"Ecore", 
"Poller"}, isolate, exports));
+   register_ecore_throttle(isolate, efl::eo::js::get_namespace({"Ecore", 
"Throttle"}, isolate, exports));
+   register_ecore_timer(isolate, efl::eo::js::get_namespace({"Ecore", 
"Timer"}, isolate, exports));
 }
       
 } } } // namespace efl { namespace js {
diff --git a/src/bindings/js/ecore_js/ecore_js_job.cc 
b/src/bindings/js/ecore_js/ecore_js_job.cc
index 4ec438a..6e5f076 100644
--- a/src/bindings/js/ecore_js/ecore_js_job.cc
+++ b/src/bindings/js/ecore_js/ecore_js_job.cc
@@ -77,7 +77,7 @@ EAPI
 void register_ecore_job(v8::Isolate *isolate,v8::Handle<v8::Object> exports)
 {
    register_job_add(isolate, exports,
-                    compatibility_new<v8::String>(isolate, "ecore_job_add"));
+                    compatibility_new<v8::String>(isolate, "add"));
 }
       
 } } } // namespace efl { namespace js {
diff --git a/src/bindings/js/ecore_js/ecore_js_mainloop.cc 
b/src/bindings/js/ecore_js/ecore_js_mainloop.cc
index 180b35f..bc00c8f 100644
--- a/src/bindings/js/ecore_js/ecore_js_mainloop.cc
+++ b/src/bindings/js/ecore_js/ecore_js_mainloop.cc
@@ -172,36 +172,36 @@ void register_ecore_mainloop(v8::Isolate 
*isolate,v8::Handle<v8::Object> exports
 {
    register_callback_cancel(isolate, exports,
                             compatibility_new<v8::String>
-                            (isolate, "ECORE_CALLBACK_CANCEL"));
+                            (isolate, "CALLBACK_CANCEL"));
    register_callback_renew(isolate, exports,
                            compatibility_new<v8::String>
-                           (isolate, "ECORE_CALLBACK_RENEW"));
+                           (isolate, "CALLBACK_RENEW"));
    register_callback_pass_on(isolate, exports,
                              compatibility_new<v8::String>
-                             (isolate, "ECORE_CALLBACK_PASS_ON"));
+                             (isolate, "CALLBACK_PASS_ON"));
    register_callback_done(isolate, exports,
                           compatibility_new<v8::String>
-                          (isolate, "ECORE_CALLBACK_DONE"));
+                          (isolate, "CALLBACK_DONE"));
    register_mainloop_iterate(isolate, exports,
                              compatibility_new<v8::String>
-                             (isolate, "ecore_mainloop_iterate"));
+                             (isolate, "iterate"));
    register_mainloop_iterate_may_block(isolate, exports,
                                        compatibility_new<v8::String>
                                        (isolate,
-                                        "ecore_mainloop_iterate_may_block"));
+                                        "iterateMayBlock"));
    register_mainloop_begin(isolate, exports,
                            compatibility_new<v8::String>
-                           (isolate, "ecore_mainloop_begin"));
+                           (isolate, "begin"));
    register_mainloop_quit(isolate, exports,
                           compatibility_new<v8::String>
-                          (isolate, "ecore_mainloop_quit"));
+                          (isolate, "quit"));
    register_mainloop_animator_ticked_get(isolate, exports,
                                          compatibility_new<v8::String>
                                          (isolate,
-                                          
"ecore_mainlop_animator_ticked_get"));
+                                          "getAnimatorTicked"));
    register_mainloop_nested_get(isolate, exports,
                                 compatibility_new<v8::String>
-                                (isolate, "ecore_mainloop_nested_get"));
+                                (isolate, "getNested"));
 }
   
 } } } // namespace efl { namespace js {
diff --git a/src/bindings/js/ecore_js/ecore_js_poller.cc 
b/src/bindings/js/ecore_js/ecore_js_poller.cc
index e3bfbc8..3a49464 100644
--- a/src/bindings/js/ecore_js/ecore_js_poller.cc
+++ b/src/bindings/js/ecore_js/ecore_js_poller.cc
@@ -172,19 +172,15 @@ EAPI
 void register_ecore_poller(v8::Isolate *isolate,v8::Handle<v8::Object> exports)
 {
    register_poller_core(isolate, exports,
-                        compatibility_new<v8::String>(isolate, 
"ECORE_POLLER_CORE"));
+                        compatibility_new<v8::String>(isolate, "CORE"));
    register_poller_poll_interval_set(isolate, exports,
                                      compatibility_new<v8::String>(isolate,
-                                                               "ecore_poller"
-                                                               "_poll_interval"
-                                                               "_set"));
+                                                               
"setPollInterval"));
    register_poller_poll_interval_get(isolate, exports,
                                      compatibility_new<v8::String>(isolate,
-                                                               "ecore_poller"
-                                                               "_poll_interval"
-                                                               "_get"));
+                                                               
"getPollInterval"));
    register_poller_add(isolate, exports,
-                       compatibility_new<v8::String>(isolate, 
"ecore_poller_add"));
+                       compatibility_new<v8::String>(isolate, "add"));
 }
   
 } } } // namespace efl { namespace js {
diff --git a/src/bindings/js/ecore_js/ecore_js_throttle.cc 
b/src/bindings/js/ecore_js/ecore_js_throttle.cc
index 830a40f..9b184e5 100644
--- a/src/bindings/js/ecore_js/ecore_js_throttle.cc
+++ b/src/bindings/js/ecore_js/ecore_js_throttle.cc
@@ -54,10 +54,10 @@ void register_ecore_throttle(v8::Isolate 
*isolate,v8::Handle<v8::Object> exports
 {
    register_throttle_adjust(isolate, exports,
                             compatibility_new<v8::String>(isolate,
-                                                      
"ecore_throttle_adjust"));
+                                                      "adjust"));
    register_throttle_get(isolate, exports,
                          compatibility_new<v8::String>(isolate,
-                                                   "ecore_throttle_get"));
+                                                   "get"));
 }
       
 } } } // namespace efl { namespace js {
diff --git a/src/bindings/js/ecore_js/ecore_js_timer.cc 
b/src/bindings/js/ecore_js/ecore_js_timer.cc
index f22100c..08c52d8 100644
--- a/src/bindings/js/ecore_js/ecore_js_timer.cc
+++ b/src/bindings/js/ecore_js/ecore_js_timer.cc
@@ -216,17 +216,15 @@ void register_ecore_timer(v8::Isolate 
*isolate,v8::Handle<v8::Object> exports)
 {
    register_timer_precision_get(isolate, exports,
                                 compatibility_new<v8::String>(isolate,
-                                                          
"ecore_timer_precision"
-                                                          "_get"));
+                                                          "getPrecision"));
    register_timer_precision_set(isolate, exports,
                                 compatibility_new<v8::String>(isolate,
-                                                          
"ecore_timer_precision"
-                                                          "_set"));
+                                                          "setPrecision"));
    register_timer_add(isolate, exports,
-                      compatibility_new<v8::String>(isolate, 
"ecore_timer_add"));
+                      compatibility_new<v8::String>(isolate, "add"));
    register_timer_loop_add(isolate, exports,
                            compatibility_new<v8::String>(isolate,
-                                                     "ecore_timer_loop_add"));
+                                                     "addLoop"));
 }
 
 } } } // namespace efl { namespace ecore { namespace js {
diff --git a/src/bindings/js/efl_js/efl_js.cc b/src/bindings/js/efl_js/efl_js.cc
index 227766d..b2f8e32 100644
--- a/src/bindings/js/efl_js/efl_js.cc
+++ b/src/bindings/js/efl_js/efl_js.cc
@@ -40,6 +40,7 @@ EAPI void eina_value_register(v8::Handle<v8::Object>, 
v8::Isolate* isolate);
 EAPI void register_ecore_mainloop(v8::Handle<v8::Object> global, v8::Isolate* 
isolate);
 
 namespace ecore {
+EAPI void register_animator(v8::Handle<v8::Object> global, v8::Isolate* 
isolate);
 EAPI void register_exe(v8::Handle<v8::Object> global, v8::Isolate* isolate);
 EAPI void register_idler(v8::Handle<v8::Object> global, v8::Isolate* isolate);
 EAPI void register_ecore(v8::Isolate* isolate, v8::Handle<v8::Object> exports);
@@ -154,10 +155,10 @@ EAPI void init(v8::Handle<v8::Object> exports)
         eina_log_register(exports, v8::Isolate::GetCurrent());
         eina_value_register(exports, v8::Isolate::GetCurrent());
         register_ecore_mainloop(exports, v8::Isolate::GetCurrent());
-        efl::ecore::js::register_ecore(v8::Isolate::GetCurrent(), exports);
         efl::eio::js::register_eio(v8::Isolate::GetCurrent(), exports);
         efl::eldbus::js::register_eldbus(v8::Isolate::GetCurrent(), exports);
         efl::ethumb::js::register_ethumb(v8::Isolate::GetCurrent(), exports);
+        ecore::register_animator(exports, v8::Isolate::GetCurrent());
         ecore::register_exe(exports, v8::Isolate::GetCurrent());
         ecore::register_idler(exports, v8::Isolate::GetCurrent());
         ecore::idle::register_enterer(exports, v8::Isolate::GetCurrent());
@@ -180,6 +181,9 @@ EAPI void init(v8::Handle<v8::Object> exports)
         register_ecore_audio_out_pulse(exports, v8::Isolate::GetCurrent());
         register_ecore_audio_out_sndfile(exports, v8::Isolate::GetCurrent());
 #endif
+        // Manual ecore binding initialized last to allow extension of 
namespace
+        // created by eolian.
+        efl::ecore::js::register_ecore(v8::Isolate::GetCurrent(), exports);
         efl::register_control(exports, v8::Isolate::GetCurrent());
         efl::register_file(exports, v8::Isolate::GetCurrent());
         efl::register_image(exports, v8::Isolate::GetCurrent());
diff --git a/src/bindings/js/eio_js/Eio_Js.hh b/src/bindings/js/eio_js/Eio_Js.hh
index e379229..dce7db2 100644
--- a/src/bindings/js/eio_js/Eio_Js.hh
+++ b/src/bindings/js/eio_js/Eio_Js.hh
@@ -5,7 +5,7 @@
 #include <Ecore.h>
 
 #include <Eina.hh>
-
+#include <Eo_Js.hh>
 #include <Eina_Js.hh>
 
 #ifdef EAPI
diff --git a/src/bindings/js/eio_js/eio_js.cc b/src/bindings/js/eio_js/eio_js.cc
index 8441247..7fafe8b 100644
--- a/src/bindings/js/eio_js/eio_js.cc
+++ b/src/bindings/js/eio_js/eio_js.cc
@@ -167,7 +167,7 @@ static v8::Local<v8::Object> wrap_monitor(Eio_Monitor 
*monitor,
 
     ret->Set(compatibility_new<String>(isolate, "del"),
              compatibility_new<FunctionTemplate>(isolate, del)->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "path_get"),
+    ret->Set(compatibility_new<String>(isolate, "getPath"),
              compatibility_new<FunctionTemplate>(isolate, path_get)
              ->GetFunction());
 
@@ -226,11 +226,11 @@ v8::Local<v8::Object> wrap_eina_file_direct_info(const 
Eina_File_Direct_Info*
 
     auto wrapped_info = compatibility_new<Object>(isolate);
 
-    wrapped_info->Set(compatibility_new<String>(isolate, "path_length"),
+    wrapped_info->Set(compatibility_new<String>(isolate, "pathLength"),
                       compatibility_new<Integer>(isolate, info->path_length));
-    wrapped_info->Set(compatibility_new<String>(isolate, "mame_length"),
+    wrapped_info->Set(compatibility_new<String>(isolate, "nameLength"),
                       compatibility_new<Integer>(isolate, info->name_length));
-    wrapped_info->Set(compatibility_new<String>(isolate, "name_start"),
+    wrapped_info->Set(compatibility_new<String>(isolate, "nameStart"),
                       compatibility_new<Integer>(isolate, info->name_start));
     wrapped_info->Set(compatibility_new<String>(isolate, "type"),
                       compatibility_new<Integer>(isolate, info->type));
@@ -1623,134 +1623,135 @@ EAPI
 void register_eio(v8::Isolate* isolate, v8::Handle<v8::Object> exports)
 {
    using v8::String;
-   register_init(isolate, exports,
-                 compatibility_new<String>(isolate, "eio_init"));
-   register_shutdown(isolate, exports,
-                     compatibility_new<String>(isolate, "eio_shutdown"));
-   register_op_file_copy(isolate, exports,
-                         compatibility_new<String>(isolate, "EIO_FILE_COPY"));
-   register_op_file_move(isolate, exports,
-                         compatibility_new<String>(isolate, "EIO_FILE_MOVE"));
-   register_op_dir_copy(isolate, exports,
-                        compatibility_new<String>(isolate, "EIO_DIR_COPY"));
-   register_op_dir_move(isolate, exports,
-                        compatibility_new<String>(isolate, "EIO_DIR_MOVE"));
-   register_op_unlink(isolate, exports,
-                      compatibility_new<String>(isolate, "EIO_LINK"));
-   register_op_file_getpwnam(isolate, exports,
+   auto eioNamespace = efl::eo::js::get_namespace({"Eio"}, isolate, exports);
+   register_init(isolate, eioNamespace,
+                 compatibility_new<String>(isolate, "init"));
+   register_shutdown(isolate, eioNamespace,
+                     compatibility_new<String>(isolate, "shutdown"));
+   register_op_file_copy(isolate, eioNamespace,
+                         compatibility_new<String>(isolate, "FILE_COPY"));
+   register_op_file_move(isolate, eioNamespace,
+                         compatibility_new<String>(isolate, "FILE_MOVE"));
+   register_op_dir_copy(isolate, eioNamespace,
+                        compatibility_new<String>(isolate, "DIR_COPY"));
+   register_op_dir_move(isolate, eioNamespace,
+                        compatibility_new<String>(isolate, "DIR_MOVE"));
+   register_op_unlink(isolate, eioNamespace,
+                      compatibility_new<String>(isolate, "UNLINK"));
+   register_op_file_getpwnam(isolate, eioNamespace,
                              compatibility_new<String>(isolate,
-                                                       "EIO_FILE_GETPWNAM"));
-   register_op_file_getgrnam(isolate, exports,
+                                                       "FILE_GETPWNAM"));
+   register_op_file_getgrnam(isolate, eioNamespace,
                              compatibility_new<String>(isolate,
-                                                       "EIO_FILE_GETGRNAM"));
-   register_file_open(isolate, exports,
-                      compatibility_new<String>(isolate, "eio_file_open"));
-   register_monitor_file_created(isolate, exports,
+                                                       "FILE_GETGRNAM"));
+   register_file_open(isolate, eioNamespace,
+                      compatibility_new<String>(isolate, "openFile"));
+   register_monitor_file_created(isolate, eioNamespace,
                                  compatibility_new<String>(isolate,
-                                                           "EIO_MONITOR_FILE"
+                                                           "MONITOR_FILE"
                                                            "_CREATED"));
-   register_monitor_file_deleted(isolate, exports,
+   register_monitor_file_deleted(isolate, eioNamespace,
                                  compatibility_new<String>(isolate,
-                                                           "EIO_MONITOR_FILE"
+                                                           "MONITOR_FILE"
                                                            "_DELETED"));
-   register_monitor_file_modified(isolate, exports,
+   register_monitor_file_modified(isolate, eioNamespace,
                                   compatibility_new<String>(isolate,
-                                                            "EIO_MONITOR_FILE"
+                                                            "MONITOR_FILE"
                                                             "_MODIFIED"));
-   register_monitor_file_closed(isolate, exports,
+   register_monitor_file_closed(isolate, eioNamespace,
                                 compatibility_new<String>(isolate,
-                                                          "EIO_MONITOR_FILE"
+                                                          "MONITOR_FILE"
                                                           "_CLOSED"));
-   register_monitor_directory_created(isolate, exports,
+   register_monitor_directory_created(isolate, eioNamespace,
                                       compatibility_new<String>
                                       (isolate,
-                                       "EIO_MONITOR_DIRECTORY_CREATED"));
-   register_monitor_directory_deleted(isolate, exports,
+                                       "MONITOR_DIRECTORY_CREATED"));
+   register_monitor_directory_deleted(isolate, eioNamespace,
                                       compatibility_new<String>
                                       (isolate,
-                                       "EIO_MONITOR_DIRECTORY_DELETED"));
-   register_monitor_directory_modified(isolate, exports,
+                                       "MONITOR_DIRECTORY_DELETED"));
+   register_monitor_directory_modified(isolate, eioNamespace,
                                        compatibility_new<String>
                                        (isolate,
-                                        "EIO_MONITOR_DIRECTORY_MODIFIED"));
-   register_monitor_directory_closed(isolate, exports,
+                                        "MONITOR_DIRECTORY_MODIFIED"));
+   register_monitor_directory_closed(isolate, eioNamespace,
                                      compatibility_new<String>
-                                     (isolate, 
"EIO_MONITOR_DIRECTORY_CLOSED"));
-   register_monitor_self_rename(isolate, exports,
+                                     (isolate, "MONITOR_DIRECTORY_CLOSED"));
+   register_monitor_self_rename(isolate, eioNamespace,
                                 compatibility_new<String>
-                                (isolate, "EIO_MONITOR_SELF_RENAME"));
-   register_monitor_self_deleted(isolate, exports,
+                                (isolate, "MONITOR_SELF_RENAME"));
+   register_monitor_self_deleted(isolate, eioNamespace,
                                  compatibility_new<String>
-                                 (isolate, "EIO_MONITOR_SELF_DELETED"));
-   register_monitor_error(isolate, exports,
+                                 (isolate, "MONITOR_SELF_DELETED"));
+   register_monitor_error(isolate, eioNamespace,
                           compatibility_new<String>(isolate,
-                                                    "EIO_MONITOR_ERROR"));
-   register_monitor_add(isolate, exports,
-                        compatibility_new<String>(isolate, "eio_monitor_add"));
+                                                    "MONITOR_ERROR"));
+   register_monitor_add(isolate, eioNamespace,
+                        compatibility_new<String>(isolate, "addMonitor"));
    register_event_monitor_file_created_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>(isolate,
-                                "eio_event_monitor_file_created_handler_add"));
+                                "addEventMonitorFileCreatedHandler"));
    register_event_monitor_file_deleted_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>(isolate,
-                                "eio_event_monitor_file_deleted_handler_add"));
+                                "addEventMonitorFileDeletedHandler"));
    register_event_monitor_file_modified_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>
-      (isolate, "eio_event_monitor_file_modified_handler_add"));
+      (isolate, "addEventMonitorFileModifiedHandler"));
    register_event_monitor_file_closed_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>(isolate,
-                                "eio_event_monitor_file_closed_handler_add"));
+                                "addEventMonitorFileClosedHandler"));
    register_event_monitor_directory_created_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>
-      (isolate, "eio_event_monitor_directory_created_handler_add"));
+      (isolate, "addEventMonitorDirectoryCreatedHandler"));
    register_event_monitor_directory_deleted_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>
-      (isolate, "eio_event_monitor_directory_deleted_handler_add"));
+      (isolate, "addEventMonitorDirectoryDeletedHandler"));
    register_event_monitor_directory_modified_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>
-      (isolate, "eio_event_monitor_directory_modified_handler_add"));
+      (isolate, "addEventMonitorDirectoryModifiedHandler"));
    register_event_monitor_directory_closed_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>
-      (isolate, "eio_event_monitor_directory_closed_handler_add"));
+      (isolate, "addEventMonitorDirectoryClosedHandler"));
    register_event_monitor_self_rename_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>(isolate,
-                                "eio_event_monitor_self_rename_handler_add"));
+                                "addEventMonitorSelfRenameHandler"));
    register_event_monitor_self_deleted_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>(isolate,
-                                "eio_event_monitor_self_deleted_handler_add"));
+                                "addEventMonitorSelfDeletedHandler"));
    register_event_monitor_error_handler_add
-     (isolate, exports,
+     (isolate, eioNamespace,
       compatibility_new<String>(isolate,
-                                "eio_event_monitor_error_handler_add"));
-   register_file_ls(isolate, exports,
-                    compatibility_new<String>(isolate, "eio_file_ls"));
-   register_file_chmod(isolate, exports,
-                       compatibility_new<String>(isolate, "eio_file_chmod"));
-   register_file_chown(isolate, exports,
-                       compatibility_new<String>(isolate, "eio_file_chown"));
-   register_file_unlink(isolate, exports,
-                        compatibility_new<String>(isolate, "eio_file_unlink"));
-   register_file_mkdir(isolate, exports,
-                       compatibility_new<String>(isolate, "eio_file_mkdir"));
-   register_file_move(isolate, exports,
-                      compatibility_new<String>(isolate, "eio_file_move"));
-   register_file_copy(isolate, exports,
-                      compatibility_new<String>(isolate, "eio_file_copy"));
-   register_dir_move(isolate, exports,
-                     compatibility_new<String>(isolate, "eio_dir_move"));
-   register_dir_copy(isolate, exports,
-                     compatibility_new<String>(isolate, "eio_dir_copy"));
-   register_dir_unlink(isolate, exports,
-                       compatibility_new<String>(isolate, "eio_dir_unlink"));
+                                "addEventMonitorErrorHandler"));
+   register_file_ls(isolate, eioNamespace,
+                    compatibility_new<String>(isolate, "lsFile"));
+   register_file_chmod(isolate, eioNamespace,
+                       compatibility_new<String>(isolate, "chmodFile"));
+   register_file_chown(isolate, eioNamespace,
+                       compatibility_new<String>(isolate, "chownFile"));
+   register_file_unlink(isolate, eioNamespace,
+                        compatibility_new<String>(isolate, "unlinkFile"));
+   register_file_mkdir(isolate, eioNamespace,
+                       compatibility_new<String>(isolate, "mkdirFile"));
+   register_file_move(isolate, eioNamespace,
+                      compatibility_new<String>(isolate, "moveFile"));
+   register_file_copy(isolate, eioNamespace,
+                      compatibility_new<String>(isolate, "copyFile"));
+   register_dir_move(isolate, eioNamespace,
+                     compatibility_new<String>(isolate, "moveDir"));
+   register_dir_copy(isolate, eioNamespace,
+                     compatibility_new<String>(isolate, "copyDir"));
+   register_dir_unlink(isolate, eioNamespace,
+                       compatibility_new<String>(isolate, "unlinkDir"));
 }
       
 } } } // namespace efl { namespace eio { namespace js {
diff --git a/src/bindings/js/ethumb_js/Ethumb_Js.hh 
b/src/bindings/js/ethumb_js/Ethumb_Js.hh
index 3945970..b45b555 100644
--- a/src/bindings/js/ethumb_js/Ethumb_Js.hh
+++ b/src/bindings/js/ethumb_js/Ethumb_Js.hh
@@ -5,6 +5,7 @@
 
 #include <Eina_Js.hh>
 #include <Ethumb_Client.h>
+#include <Eo_Js.hh>
 
 #ifdef EAPI
 # undef EAPI
diff --git a/src/bindings/js/ethumb_js/ethumb_js_client.cc 
b/src/bindings/js/ethumb_js/ethumb_js_client.cc
index 50aaee3..541538b 100644
--- a/src/bindings/js/ethumb_js/ethumb_js_client.cc
+++ b/src/bindings/js/ethumb_js/ethumb_js_client.cc
@@ -417,32 +417,32 @@ v8::Local<v8::Object> wrap_ethumb_client(Ethumb_Client 
*client,
     ret->Set(compatibility_new<String>(isolate, "disconnect"),
              compatibility_new<FunctionTemplate>(isolate, disconnect)
              ->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "on_server_die_callback_set"),
+    ret->Set(compatibility_new<String>(isolate, "setOnServerDieCallback"),
              compatibility_new<FunctionTemplate>(isolate,
                                                  on_server_die_callback_set)
              ->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "file_set"),
+    ret->Set(compatibility_new<String>(isolate, "setFile"),
              compatibility_new<FunctionTemplate>(isolate, file_set)
              ->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "file_get"),
+    ret->Set(compatibility_new<String>(isolate, "getFile"),
              compatibility_new<FunctionTemplate>(isolate, file_get)
              ->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "file_free"),
+    ret->Set(compatibility_new<String>(isolate, "freeFile"),
              compatibility_new<FunctionTemplate>(isolate, file_free)
              ->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "thumb_exists"),
+    ret->Set(compatibility_new<String>(isolate, "existsThumb"),
              compatibility_new<FunctionTemplate>(isolate, thumb_exists)
              ->GetFunction());
     ret->Set(compatibility_new<String>(isolate, "generate"),
              compatibility_new<FunctionTemplate>(isolate, generate)
              ->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "generate_cancel"),
+    ret->Set(compatibility_new<String>(isolate, "cancelGenerate"),
              compatibility_new<FunctionTemplate>(isolate, generate_cancel)
              ->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "generate_cancel_all"),
+    ret->Set(compatibility_new<String>(isolate, "cancelAllGenerate"),
              compatibility_new<FunctionTemplate>(isolate, generate_cancel_all)
              ->GetFunction());
-    ret->Set(compatibility_new<String>(isolate, "thumb_async_get"),
+    ret->Set(compatibility_new<String>(isolate, "getThumbAsync"),
              compatibility_new<FunctionTemplate>(isolate, thumb_async_get)
              ->GetFunction());
 
@@ -557,15 +557,16 @@ EAPI
 void register_ethumb(v8::Isolate *isolate, v8::Handle<v8::Object> exports)
 {
    using v8::String;
-   register_client_init(isolate, exports,
+   auto ethumbNamespace = efl::eo::js::get_namespace({"Ethumb"}, isolate, 
exports);
+   register_client_init(isolate, ethumbNamespace,
                         compatibility_new<String>(isolate,
-                                                  "ethumb_client_init"));
-   register_client_shutdown(isolate, exports,
+                                                  "initClient"));
+   register_client_shutdown(isolate, ethumbNamespace,
                             compatibility_new<String>(isolate,
-                                                      
"ethumb_client_shutdown"));
-   register_client_connect(isolate, exports,
+                                                      "shutdownClient"));
+   register_client_connect(isolate, ethumbNamespace,
                            compatibility_new<String>(isolate,
-                                                     "ethumb_client_connect"));
+                                                     "connectClient"));
 }
       
 } } } // namespace efl { namespace ethumb { namespace js {
diff --git a/src/tests/efl_js/benchmark_js_suite.js 
b/src/tests/efl_js/benchmark_js_suite.js
index b3a5d7c..fc1de01 100755
--- a/src/tests/efl_js/benchmark_js_suite.js
+++ b/src/tests/efl_js/benchmark_js_suite.js
@@ -26,7 +26,7 @@ if(typeof process !== 'undefined')
         if (process.argv.indexOf("--verbose") != -1)
             console.info.apply(null, arguments);
     };
-    exit = efl.ecore_mainloop_quit;
+    exit = efl.Ecore.Mainloop.quit;
 }
 else
 {
diff --git a/src/tests/efl_js/ecore_js_suite.js 
b/src/tests/efl_js/ecore_js_suite.js
index 8534304..85630af 100755
--- a/src/tests/efl_js/ecore_js_suite.js
+++ b/src/tests/efl_js/ecore_js_suite.js
@@ -12,7 +12,6 @@ if(typeof process !== 'undefined')
 {
     console.log('running from nodejs');
     console.log('path', process.env.NODE_PATH);
-    console.log("teste1");
 
     efl = require('efl');
     assert(efl != null, "could not load efl node module");
@@ -27,7 +26,7 @@ if(typeof process !== 'undefined')
         if (process.argv.indexOf("--verbose") != -1)
             console.info.apply(null, arguments);
     };
-    exit = efl.ecore_mainloop_quit;
+    exit = efl.Ecore.Mainloop.quit;
 }
 else
 {
@@ -73,51 +72,50 @@ function abs(n) {
 var TOLERANCE = 0.0001;
 // end ecore preamble
 
-start_test("timers", function () {
+start_test("ecore timers", function () {
     var p = 2.5;
-    efl.ecore_timer_precision_set(p);
-    assert(abs(efl.ecore_timer_precision_get() - p) < TOLERANCE);
+    efl.Ecore.Timer.setPrecision(p);
+    assert(abs(efl.Ecore.Timer.getPrecision() - p) < TOLERANCE);
     
     p = 0.5;
-    efl.ecore_timer_precision_set(p);
-    assert(abs(efl.ecore_timer_precision_get() - p) < TOLERANCE);
+    efl.Ecore.Timer.setPrecision(p);
+    assert(abs(efl.Ecore.Timer.getPrecision() - p) < TOLERANCE);
     
     var ncalls = 0;
 
     captured = false;
-    efl.ecore_timer_add(1, function() {
-        print_info('ecore_timer_add handler');
+    efl.Ecore.Timer.add(1, function() {
         ++ncalls;
         if (ncalls != 4)
             return true;
         
         captured = true;
-        efl.ecore_job_add(efl.ecore_mainloop_quit);
+        efl.Ecore.Job.add(efl.Ecore.Mainloop.quit);
         return false;
     });
 
-    efl.ecore_mainloop_begin();
+    efl.Ecore.Mainloop.begin();
     assert(captured);
 
     ncalls = 0;
     captured = false;
 
-    efl.ecore_timer_loop_add(1, function() {
+    efl.Ecore.Timer.addLoop(1, function() {
         ++ncalls;
         if (ncalls != 4)
             return true;
 
         captured = true;
-        efl.ecore_job_add(efl.ecore_mainloop_quit);
+        efl.Ecore.Job.add(efl.Ecore.Mainloop.quit);
         return false;
     });
 
-    efl.ecore_mainloop_begin();
+    efl.Ecore.Mainloop.begin();
     assert(captured);
 
     captured = false;
 
-    var timer = efl.ecore_timer_add(1, function() {
+    var timer = efl.Ecore.Timer.add(1, function() {
         captured = true;
         return false;
     });
@@ -134,65 +132,79 @@ start_test("timers", function () {
 
     timer.del();
 
-    efl.ecore_timer_add(2, function() {
-        efl.ecore_job_add(efl.ecore_mainloop_quit);
+    efl.Ecore.Timer.add(2, function() {
+        efl.Ecore.Job.add(efl.Ecore.Mainloop.quit);
         return false;
     });
 
-    efl.ecore_mainloop_begin();
+    efl.Ecore.Mainloop.begin();
     assert(captured === false);
 });
 
 // Ecore event
 start_test("ecore event", function () {
-    var myevent = efl.ecore_event_type_new();
+    var myevent = efl.Ecore.Event.newType();
 
     captured = [0, 0, 0]
 
-    var handler1 = efl.ecore_event_handler_add(myevent, function(event) {
-        assert(efl.ecore_event_current_type_get() === myevent);
+    var handler1 = efl.Ecore.Event.addHandler(myevent, function(event) {
+        print_info("CALLBACK_PASS_ON pre assert");
+        assert(efl.Ecore.Event.getCurrentType() === myevent);
         assert(event === myevent);
         captured[0] += 1;
-        return efl.ECORE_CALLBACK_PASS_ON;
+        print_info("CALLBACK_PASS_ON post assert");
+        return efl.Ecore.Mainloop.CALLBACK_PASS_ON;
     });
 
-    var handler2 = efl.ecore_event_handler_add(myevent, function(event) {
-        assert(efl.ecore_event_current_type_get() === myevent);
+    var handler2 = efl.Ecore.Event.addHandler(myevent, function(event) {
+        print_info("CALLBACK_DONE #1 pre assert");
+        assert(efl.Ecore.Event.getCurrentType() === myevent);
         assert(event === myevent);
         captured[1] += 1;
-        return efl.ECORE_CALLBACK_DONE;
+        print_info("CALLBACK_DONE #1 post assert");
+        return efl.Ecore.Mainloop.CALLBACK_DONE;
     });
 
-    var handler3 = efl.ecore_event_handler_add(myevent, function(event) {
-        assert(efl.ecore_event_current_type_get() === myevent);
+    var handler3 = efl.Ecore.Event.addHandler(myevent, function(event) {
+        print_info("CALLBACK_DONE #2 pre assert");
+        assert(efl.Ecore.Event.getCurrentType() === myevent);
         assert(event === myevent);
         captured[2] += 1;
-        return efl.ECORE_CALLBACK_DONE;
+        print_info("CALLBACK_DONE #2 post assert");
+        return efl.Ecore.Mainloop.CALLBACK_DONE;
     });
 
-    efl.ecore_timer_add(1, function() {
-        efl.ecore_event_add(myevent);
+    efl.Ecore.Timer.add(1, function() {
+        efl.Ecore.Event.add(myevent);
+        print_info("Timer.add(1, callback) before assert");
         assert(captured[0] === 0 && captured[1] === 0 && captured[2] === 0);
-        efl.ecore_timer_add(1, function() {
+        print_info("Timer.add(1, callback) after assert");
+        efl.Ecore.Timer.add(1, function() {
+            print_info("inner Timer.add(1, callback) before assert");
             assert(captured[0] === 1 && captured[1] === 1 && captured[2] === 
0);
+            print_info("inner Timer.add(1, callback) after assert");
             handler1.del();
-            efl.ecore_event_add(myevent);
-            efl.ecore_event_add(myevent);
-            efl.ecore_event_add(myevent).del();
-            efl.ecore_timer_add(1, function() {
+            efl.Ecore.Event.add(myevent);
+            efl.Ecore.Event.add(myevent);
+            efl.Ecore.Event.add(myevent).del();
+            efl.Ecore.Timer.add(1, function() {
+                print_info("twice inner Timer.add(1, callback) before assert");
                 assert(captured[0] === 1 && captured[1] === 3 && captured[2] 
=== 0);
-                efl.ecore_mainloop_quit();
+                print_info("twice inner Timer.add(1, callback) after assert");
+                efl.Ecore.Mainloop.quit();
             });
         });
     });
 
-    efl.ecore_mainloop_begin();
+    efl.Ecore.Mainloop.begin();
 
-    efl.ecore_event_add(myevent);
-    efl.ecore_event_add(myevent);
-    efl.ecore_event_add(myevent);
+    efl.Ecore.Event.add(myevent);
+    efl.Ecore.Event.add(myevent);
+    efl.Ecore.Event.add(myevent);
 
-    var filter = efl.ecore_event_filter_add(function() {
+    print_info("will add filter");
+
+    var filter = efl.Ecore.Event.addFilter(function() {
         return {count: 0};
     }, function(loop_data, event) {
         assert(event === myevent);
@@ -201,17 +213,17 @@ start_test("ecore event", function () {
         return c != 0;
     }, function(loop_data) {});
     
-    efl.ecore_timer_add(1, efl.ecore_mainloop_quit);
-    efl.ecore_mainloop_begin();
+    efl.Ecore.Timer.add(1, efl.Ecore.Mainloop.quit);
+    efl.Ecore.Mainloop.begin();
     assert(captured[1] === 5);
     filter.del();
 
-    efl.ecore_event_add(myevent);
-    efl.ecore_event_add(myevent);
-    efl.ecore_event_add(myevent);
+    efl.Ecore.Event.add(myevent);
+    efl.Ecore.Event.add(myevent);
+    efl.Ecore.Event.add(myevent);
     
-    efl.ecore_timer_add(1, efl.ecore_mainloop_quit);
-    efl.ecore_mainloop_begin();
+    efl.Ecore.Timer.add(1, efl.Ecore.Mainloop.quit);
+    efl.Ecore.Mainloop.begin();
     assert(captured[1] === 8);
 
     handler2.del();
@@ -222,22 +234,22 @@ start_test("ecore event", function () {
 start_test("ecore jobs", function () {
     captured = false;
 
-    efl.ecore_job_add(function() {
+    efl.Ecore.Job.add(function() {
         captured = true;
-        efl.ecore_mainloop_quit();
+        efl.Ecore.Mainloop.quit();
     });
 
     assert(captured === false);
-    efl.ecore_mainloop_begin();
+    efl.Ecore.Mainloop.begin();
     assert(captured === true);
 
     captured = false;
-    var job = efl.ecore_job_add(function() {
+    var job = efl.Ecore.Job.add(function() {
         captured = true;
     });
-    efl.ecore_job_add(efl.ecore_mainloop_quit);
+    efl.Ecore.Job.add(efl.Ecore.Mainloop.quit);
     job.del();
-    efl.ecore_mainloop_begin();
+    efl.Ecore.Mainloop.begin();
     assert(captured === false);
 });
 
@@ -246,92 +258,76 @@ start_test("ecore idle", function () {
     var counter = 1;
     captured = [0, 0, 0, 0, 0];
 
-    efl.ecore_idler_add(function() {
-        print_info('ecore idle handler 1');
+    efl.Ecore.Idle.add(function() {
         captured[0] = counter;
         counter += 1;
-        efl.ecore_job_add(function() { print_info('ecore job handler 1'); });
-        return efl.ECORE_CALLBACK_DONE;
+        efl.Ecore.Job.add(function() { print_info('ecore job handler 1'); });
+        return efl.Ecore.Mainloop.CALLBACK_DONE;
     });
 
-    print_info('ecore idle 1');
-
-    efl.ecore_idle_enterer_add(function() {
-        print_info('ecore idle handler 2');
+    efl.Ecore.Idle.addEnterer(function() {
         captured[1] = counter;
         counter += 1;
-        return efl.ECORE_CALLBACK_DONE;
+        return efl.Ecore.Mainloop.CALLBACK_DONE;
     });
 
-    print_info('ecore idle 2');
-
-    efl.ecore_idle_enterer_add(function() {
-        print_info('ecore idle handler 3');
+    efl.Ecore.Idle.addEnterer(function() {
         captured[2] = counter;
         counter += 1;
-        return efl.ECORE_CALLBACK_DONE;
+        return efl.Ecore.Mainloop.CALLBACK_DONE;
     });
 
-    print_info('ecore idle 3');
-
-    efl.ecore_idle_enterer_before_add(function() {
-        print_info('ecore idle handler 4');
+    efl.Ecore.Idle.addEntererBefore(function() {
         captured[3] = counter;
         counter += 1;
-        return efl.ECORE_CALLBACK_DONE;
+        return efl.Ecore.Mainloop.CALLBACK_DONE;
     });
 
-    print_info('ecore idle 4');
-
-    efl.ecore_idle_exiter_add(function() {
-        print_info('ecore idle handler 5');
+    efl.Ecore.Idle.addExiter(function() {
         captured[4] = counter;
         counter += 1;
-        efl.ecore_mainloop_quit();
-        return efl.ECORE_CALLBACK_DONE;
+        efl.Ecore.Mainloop.quit();
+        return efl.Ecore.Mainloop.CALLBACK_DONE;
     });
 
-    print_info('ecore idle 5');
-
-    efl.ecore_mainloop_begin();
-
-    print_info('ecore idle 6');
+    efl.Ecore.Mainloop.begin();
 
-    assert(captured[0] === 4, "ecore_idler_add test");
-    assert(captured[1] === 2, "ecore_idle_enterer_add test");
-    assert(captured[2] === 3, "ecore_idle_enterer_add test two");
-    assert(captured[3] === 1, "ecore_idle_enterer_before_add test");
-    assert(captured[4] === 5, "ecore_idle_exiter_add test");
+    assert(captured[0] === 4, "Ecore.Idle.add test");
+    assert(captured[1] === 2, "Ecore.Idle.addEnterer test");
+    assert(captured[2] === 3, "Ecore.Idle.addEnterer test two");
+    assert(captured[3] === 1, "Ecore.Idle.addEntererBefore test");
+    assert(captured[4] === 5, "Ecore.Idle.addExiter test");
 });
 
 // Ecore animator
 start_test("ecore animator", function () {
-    efl.ecore_animator_frametime_set(1);
-    assert(efl.ecore_animator_frametime_get() === 1);
-    efl.ecore_animator_frametime_set(1 / 50);
-    assert(efl.ecore_animator_frametime_get() === (1 / 50));
+    efl.Ecore.Animator.setFrametime(1);
+    assert(efl.Ecore.Animator.getFrametime() === 1);
+    efl.Ecore.Animator.setFrametime(1 / 50);
+    assert(efl.Ecore.Animator.getFrametime() === (1 / 50));
 
-    assert(efl.ecore_animator_pos_map(0.5, efl.ECORE_POS_MAP_LINEAR, 0, 0)
+    assert(efl.Ecore.Animator.posMap(0.5, efl.Ecore.Animator.POS_MAP_LINEAR, 
0, 0)
            === 0.5);
 
-    efl.ecore_animator_source_set(efl.ECORE_ANIMATOR_SOURCE_CUSTOM);
+    efl.Ecore.Animator.setSource(efl.Ecore.Animator.SOURCE_TIMER);
+    assert(efl.Ecore.Animator.getSource() === efl.Ecore.Animator.SOURCE_TIMER);
 });
 
 // Ecore poller
 start_test("ecore poller", function () {
-    efl.ecore_poller_poll_interval_set(efl.ECORE_POLLER_CORE, 42);
-    assert(efl.ecore_poller_poll_interval_get(efl.ECORE_POLLER_CORE) === 42);
-    efl.ecore_poller_poll_interval_set(efl.ECORE_POLLER_CORE, 2);
-    assert(efl.ecore_poller_poll_interval_get(efl.ECORE_POLLER_CORE) === 2);
+    efl.Ecore.Poller.setPollInterval(efl.Ecore.Poller.CORE, 42);
+    assert(efl.Ecore.Poller.getPollInterval(efl.Ecore.Poller.CORE) === 42);
+    efl.Ecore.Poller.setPollInterval(efl.Ecore.Poller.CORE, 2);
+    assert(efl.Ecore.Poller.getPollInterval(efl.Ecore.Poller.CORE) === 2);
 });
 
 start_test("ecore throttle", function () {
     // Ecore throttle
 
-    efl.ecore_throttle_adjust(3);
-    assert(efl.ecore_throttle_get() === 3);
-    efl.ecore_throttle_adjust(-3);
-    assert(efl.ecore_throttle_get() === 0);
+    efl.Ecore.Throttle.adjust(3);
+    assert(efl.Ecore.Throttle.get() === 3);
+    efl.Ecore.Throttle.adjust(-3);
+    assert(efl.Ecore.Throttle.get() === 0);
 });
 
 // footer
diff --git a/src/tests/efl_js/eina_js_containers_suite.js 
b/src/tests/efl_js/eina_js_containers_suite.js
index f4f6bf3..4abb8af 100755
--- a/src/tests/efl_js/eina_js_containers_suite.js
+++ b/src/tests/efl_js/eina_js_containers_suite.js
@@ -27,7 +27,7 @@ if(typeof process !== 'undefined')
         if (process.argv.indexOf("--verbose") != -1)
             console.info.apply(null, arguments);
     };
-    exit = efl.ecore_mainloop_quit;
+    exit = efl.Ecore.Mainloop.quit;
 }
 else
 {
diff --git a/src/tests/efl_js/eina_js_suite.js 
b/src/tests/efl_js/eina_js_suite.js
index 811e1f6..95aabfb 100755
--- a/src/tests/efl_js/eina_js_suite.js
+++ b/src/tests/efl_js/eina_js_suite.js
@@ -27,7 +27,7 @@ if(typeof process !== 'undefined')
         if (process.argv.indexOf("--verbose") != -1)
             console.info.apply(null, arguments);
     };
-    exit = efl.ecore_mainloop_quit;
+    exit = efl.Ecore.Mainloop.quit;
 }
 else
 {
diff --git a/src/tests/efl_js/eio_js_suite.js b/src/tests/efl_js/eio_js_suite.js
index 01eb09c..bef83cf 100755
--- a/src/tests/efl_js/eio_js_suite.js
+++ b/src/tests/efl_js/eio_js_suite.js
@@ -27,7 +27,7 @@ if(typeof process !== 'undefined')
         if (process.argv.indexOf("--verbose") != -1)
             console.info.apply(null, arguments);
     };
-    exit = efl.ecore_mainloop_quit;
+    exit = efl.Ecore.Mainloop.quit;
 }
 else
 {
@@ -66,7 +66,7 @@ function start_test(test_name, test_func) {
 
 // Eio tests
 start_test('test constants', function () {
-    assert(typeof(efl.EIO_FILE_COPY) === 'number');
+    assert(typeof(efl.Eio.FILE_COPY) === 'number');
 });
 // TODO: more tests
 
diff --git a/src/tests/efl_js/eldbus_js_suite.js 
b/src/tests/efl_js/eldbus_js_suite.js
index 3086907..d57fbfe 100755
--- a/src/tests/efl_js/eldbus_js_suite.js
+++ b/src/tests/efl_js/eldbus_js_suite.js
@@ -27,7 +27,7 @@ if(typeof process !== 'undefined')
         if (process.argv.indexOf("--verbose") != -1)
             console.info.apply(null, arguments);
     };
-    exit = efl.ecore_mainloop_quit;
+    exit = efl.Ecore.Mainloop.quit;
 }
 else
 {
diff --git a/src/tests/efl_js/ethumb_js_suite.js 
b/src/tests/efl_js/ethumb_js_suite.js
index 5dd78fc..33bf33d 100755
--- a/src/tests/efl_js/ethumb_js_suite.js
+++ b/src/tests/efl_js/ethumb_js_suite.js
@@ -27,7 +27,7 @@ if(typeof process !== 'undefined')
         if (process.argv.indexOf("--verbose") != -1)
             console.info.apply(null, arguments);
     };
-    exit = efl.ecore_mainloop_quit;
+    exit = efl.Ecore.Mainloop.quit;
 }
 else
 {
@@ -47,7 +47,7 @@ suite_fail = []; // Will store the name of the failures
 
 // Basic test function //
 function start_test(test_name, test_func) {
-  print("[ RUN         ]  ethumb_js_suite: " + test_name);
+  print("[ RUN         ]  Ethumb.js_suite: " + test_name);
   var test_result = true;
   try {
     test_func();
@@ -56,7 +56,7 @@ function start_test(test_name, test_func) {
     test_result = false;
     print_error("Error: ", e, e.stack);
   }
-  print("[        " + (test_result ? "PASS" : "FAIL") + " ]  ethumb_js_suite: 
" + test_name);
+  print("[        " + (test_result ? "PASS" : "FAIL") + " ]  Ethumb.js_suite: 
" + test_name);
   if (test_result)
     suite_ok += 1;
   else
@@ -64,7 +64,7 @@ function start_test(test_name, test_func) {
 }
 // end Preamble
 
-efl.ethumb_client_init();
+efl.Ethumb.initClient();
 
 // Ethumb tests
 
@@ -72,7 +72,7 @@ start_test('dummy test', function () {
     assert(true);
 });
 
-efl.ethumb_client_shutdown();
+efl.Ethumb.shutdownClient();
 
 // footer
 
diff --git a/src/tests/eolian_js/eolian_js_suite.js 
b/src/tests/eolian_js/eolian_js_suite.js
index 44c4b5a..9c66dba 100755
--- a/src/tests/eolian_js/eolian_js_suite.js
+++ b/src/tests/eolian_js/eolian_js_suite.js
@@ -27,7 +27,7 @@ if(typeof process !== 'undefined')
         if (process.argv.indexOf("--verbose") != -1)
             console.info.apply(null, arguments);
     };
-    exit = efl.ecore_mainloop_quit;
+    exit = efl.Ecore.Mainloop.quit;
 }
 else
 {

-- 


Reply via email to