Source/WebKit: Patch by Jonas M. Gastal <jgastal@profusion.mobi> on 2011-08-23
authordemarchi@webkit.org <demarchi@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 23 Aug 2011 21:01:52 +0000 (21:01 +0000)
committerdemarchi@webkit.org <demarchi@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 23 Aug 2011 21:01:52 +0000 (21:01 +0000)
Reviewed by Antonio Gomes.

[EFL] Exporting JavaScript objects for EFL port
https://bugs.webkit.org/show_bug.cgi?id=43446

This patch allows to export objects to JavaScript API,
just like qt does, but it uses the netscape api
to do the convertion to javascript object.

* CMakeLists.txt:
Adding necessary files for the patch.

Source/WebKit/efl: [EFL] Exporting JavaScript objects for EFL port
https://bugs.webkit.org/show_bug.cgi?id=43446

Patch by Jonas M. Gastal <jgastal@profusion.mobi> on 2011-08-23
Reviewed by Antonio Gomes.

This patch allows to export objects to JavaScript API,
just like qt does, but it uses the netscape api
to do the convertion to javascript object.

* CMakeLists.txt:
* WebCoreSupport/FrameLoaderClientEfl.cpp:
(WebCore::FrameLoaderClientEfl::dispatchDidClearWindowObjectInWorld):
* ewk/EWebKit.h:
* ewk/ewk_js.cpp: Added.
(ewk_js_variant_to_npvariant):
(ewk_js_npvariant_to_variant):
(ewk_js_property_has):
(ewk_js_property_get):
(ewk_js_property_set):
(ewk_js_property_remove):
(ewk_js_properties_enumerate):
(ewk_js_method_has):
(ewk_js_method_invoke):
(ewk_js_class_new):
(ewk_js_class_free):
(ewk_js_object_new):
(ewk_js_object_free):
(ewk_js_object_properties_get):
(ewk_js_object_name_get):
(ewk_js_variant_free):
* ewk/ewk_js.h: Added.
* ewk/ewk_main.cpp:
(ewk_init):
* ewk/ewk_private.h:
* ewk/ewk_view.cpp:
(ewk_view_js_window_object_clear):
(ewk_view_js_object_add):
* ewk/ewk_view.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@93637 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebKit/CMakeLists.txt
Source/WebKit/ChangeLog
Source/WebKit/efl/CMakeListsEfl.txt
Source/WebKit/efl/ChangeLog
Source/WebKit/efl/WebCoreSupport/FrameLoaderClientEfl.cpp
Source/WebKit/efl/ewk/EWebKit.h
Source/WebKit/efl/ewk/ewk_js.cpp [new file with mode: 0644]
Source/WebKit/efl/ewk/ewk_js.h [new file with mode: 0644]
Source/WebKit/efl/ewk/ewk_private.h
Source/WebKit/efl/ewk/ewk_view.cpp
Source/WebKit/efl/ewk/ewk_view.h

index cee9456..b65d1bd 100644 (file)
@@ -5,6 +5,7 @@ SET(WebKit_INCLUDE_DIRECTORIES
     "${WEBCORE_DIR}/bindings/js"
     "${WEBCORE_DIR}/bindings"
     "${WEBCORE_DIR}/bridge"
+    "${WEBCORE_DIR}/bridge/c"
     "${WEBCORE_DIR}/bridge/jsc"
     "${WEBCORE_DIR}/css"
     "${WEBCORE_DIR}/dom"
index 45cd765..a6953a1 100644 (file)
@@ -1,3 +1,17 @@
+2011-08-23  Jonas M. Gastal <jgastal@profusion.mobi>
+
+        Reviewed by Antonio Gomes.
+
+        [EFL] Exporting JavaScript objects for EFL port
+        https://bugs.webkit.org/show_bug.cgi?id=43446
+
+        This patch allows to export objects to JavaScript API,
+        just like qt does, but it uses the netscape api
+        to do the convertion to javascript object.
+
+        * CMakeLists.txt:
+        Adding necessary files for the patch.
+
 2011-08-05  Anders Carlsson  <andersca@apple.com>
 
         Remove PluginHalter
index d5ae3fe..910dc9d 100644 (file)
@@ -80,6 +80,7 @@ LIST(APPEND WebKit_SOURCES
     efl/ewk/ewk_view_single.c
     efl/ewk/ewk_view_tiled.c
     efl/ewk/ewk_window_features.cpp
+    efl/ewk/ewk_js.cpp
 )
 
 LIST(APPEND WebKit_LIBRARIES
index 551564c..af4d3ae 100755 (executable)
@@ -1,3 +1,44 @@
+2011-08-23  Jonas M. Gastal <jgastal@profusion.mobi>
+
+        [EFL] Exporting JavaScript objects for EFL port
+        https://bugs.webkit.org/show_bug.cgi?id=43446
+
+        Reviewed by Antonio Gomes.
+
+        This patch allows to export objects to JavaScript API,
+        just like qt does, but it uses the netscape api
+        to do the convertion to javascript object.
+
+        * CMakeLists.txt:
+        * WebCoreSupport/FrameLoaderClientEfl.cpp:
+        (WebCore::FrameLoaderClientEfl::dispatchDidClearWindowObjectInWorld):
+        * ewk/EWebKit.h:
+        * ewk/ewk_js.cpp: Added.
+        (ewk_js_variant_to_npvariant):
+        (ewk_js_npvariant_to_variant):
+        (ewk_js_property_has):
+        (ewk_js_property_get):
+        (ewk_js_property_set):
+        (ewk_js_property_remove):
+        (ewk_js_properties_enumerate):
+        (ewk_js_method_has):
+        (ewk_js_method_invoke):
+        (ewk_js_class_new):
+        (ewk_js_class_free):
+        (ewk_js_object_new):
+        (ewk_js_object_free):
+        (ewk_js_object_properties_get):
+        (ewk_js_object_name_get):
+        (ewk_js_variant_free):
+        * ewk/ewk_js.h: Added.
+        * ewk/ewk_main.cpp:
+        (ewk_init):
+        * ewk/ewk_private.h:
+        * ewk/ewk_view.cpp:
+        (ewk_view_js_window_object_clear):
+        (ewk_view_js_object_add):
+        * ewk/ewk_view.h:
+
 2011-08-23  Raphael Kubo da Costa  <kubo@profusion.mobi>
 
         [EFL] Do not treat valid cases in ewk_frame_child_add() as failures.
index 7da99ce..5470a46 100644 (file)
@@ -440,6 +440,10 @@ void FrameLoaderClientEfl::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*
     event.frame = m_frame;
 
     evas_object_smart_callback_call(m_view, "window,object,cleared", &event);
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+    ewk_view_js_window_object_clear(m_view, m_frame);
+#endif
 }
 
 void FrameLoaderClientEfl::documentElementAvailable()
index a5c0346..3f794fb 100644 (file)
@@ -34,6 +34,7 @@
 #include "ewk_cookies.h"
 #include "ewk_frame.h"
 #include "ewk_history.h"
+#include "ewk_js.h"
 #include "ewk_main.h"
 #include "ewk_network.h"
 #include "ewk_settings.h"
diff --git a/Source/WebKit/efl/ewk/ewk_js.cpp b/Source/WebKit/efl/ewk/ewk_js.cpp
new file mode 100644 (file)
index 0000000..62b3aa4
--- /dev/null
@@ -0,0 +1,741 @@
+/*
+    Copyright (C) 2011 ProFUSION embedded systems
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+#include "ewk_js.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NP_jsobject.h"
+#include "ewk_private.h"
+#include "npruntime.h"
+#include "npruntime_impl.h"
+#include <string.h>
+
+#define EINA_MAGIC_CHECK_OR_RETURN(o, ...) \
+    if (!EINA_MAGIC_CHECK(obj, EWK_JS_OBJECT_MAGIC)) { \
+       EINA_MAGIC_FAIL(obj, EWK_JS_OBJECT_MAGIC); \
+       return __VA_ARGS__; \
+    }
+
+struct _Ewk_JS_Class {
+    const Ewk_JS_Class_Meta* meta;
+    Eina_Hash* methods; // Key=NPIdentifier(name), value=pointer to meta->methods.
+    Eina_Hash* properties; // Key=NPIdentifier(name), value=pointer to meta->properties.
+    Ewk_JS_Default default_prop;
+};
+
+static Eina_Bool ewk_js_npvariant_to_variant(Ewk_JS_Variant* data, const NPVariant* result);
+
+static Eina_Bool ewk_js_variant_to_npvariant(const Ewk_JS_Variant* data, NPVariant* result)
+{
+    EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
+    EINA_SAFETY_ON_NULL_RETURN_VAL(result, EINA_FALSE);
+    char* string_value;
+
+    switch (data->type) {
+    case EWK_JS_VARIANT_VOID:
+        VOID_TO_NPVARIANT(*result);
+        break;
+    case EWK_JS_VARIANT_NULL:
+        NULL_TO_NPVARIANT(*result);
+        break;
+    case EWK_JS_VARIANT_INT32:
+        INT32_TO_NPVARIANT(data->value.i, *result);
+        break;
+    case EWK_JS_VARIANT_DOUBLE:
+        DOUBLE_TO_NPVARIANT(data->value.d, *result);
+        break;
+    case EWK_JS_VARIANT_STRING:
+        string_value = strdup(data->value.s);
+        if (string_value)
+            STRINGZ_TO_NPVARIANT(string_value, *result);
+        else
+            return EINA_FALSE;
+        break;
+    case EWK_JS_VARIANT_BOOL:
+        BOOLEAN_TO_NPVARIANT(data->value.b, *result);
+        break;
+    case EWK_JS_VARIANT_OBJECT:
+        OBJECT_TO_NPVARIANT(reinterpret_cast<NPObject*>(data->value.o), *result);
+        break;
+    default:
+        return EINA_FALSE;
+    }
+
+    return EINA_TRUE;
+}
+
+// These methods are used by NPAI, thats the reason to use bool instead of Eina_Bool.
+static bool ewk_js_property_has(NPObject* np_obj, NPIdentifier name)
+{
+    Ewk_JS_Object* obj = reinterpret_cast<Ewk_JS_Object*>(np_obj);
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(np_obj, false);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, false);
+
+    if (!_NPN_IdentifierIsString(name)) {
+        ERR("int NPIdentifier is not supported.");
+        return false;
+    }
+
+    char* prop_name = _NPN_UTF8FromIdentifier(name);
+    bool fail = eina_hash_find(obj->properties, prop_name); // FIXME: should search methods too?
+    free(prop_name);
+
+    return fail;
+}
+
+static bool ewk_js_property_get(NPObject* np_obj, NPIdentifier name, NPVariant* result)
+{
+    Ewk_JS_Object* obj = reinterpret_cast<Ewk_JS_Object*>(np_obj);
+    Ewk_JS_Variant* value;
+    Ewk_JS_Property* prop;
+    bool fail = false;
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(np_obj, false);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, false);
+
+    if (!_NPN_IdentifierIsString(name)) {
+        ERR("int NPIdentifier is not supported.");
+        return false;
+    }
+
+    value = static_cast<Ewk_JS_Variant*>(malloc(sizeof(Ewk_JS_Variant)));
+    if (!value) {
+        ERR("Could not allocate memory for ewk_js_variant");
+        return false;
+    }
+
+    prop = static_cast<Ewk_JS_Property*>(eina_hash_find(obj->cls->properties, name));
+    if (prop && prop->get) { // Class has property and property has getter.
+        fail = prop->get(obj, prop->name, value);
+        if (!fail)
+            fail = ewk_js_variant_to_npvariant(value, result);
+    } else if (obj->cls->default_prop.get) { // Default getter exists.
+        fail = obj->cls->default_prop.get(obj, prop->name, value);
+        if (!fail)
+            fail = ewk_js_variant_to_npvariant(value, result);
+    } else { // Fallback to objects hash map.
+        char* prop_name = _NPN_UTF8FromIdentifier(name);
+        free(value);
+        value = static_cast<Ewk_JS_Variant*>(eina_hash_find(obj->properties, prop_name));
+        free(prop_name);
+        if (value)
+            return ewk_js_variant_to_npvariant(value, result);
+    }
+
+    free(value);
+    return fail;
+}
+
+static bool ewk_js_property_set(NPObject* np_obj, NPIdentifier name, const NPVariant* np_value)
+{
+    Ewk_JS_Object* obj = reinterpret_cast<Ewk_JS_Object*>(np_obj);
+    Ewk_JS_Variant* value;
+    Ewk_JS_Property* prop;
+    bool fail = false;
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(np_obj, false);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, false);
+
+    if (!_NPN_IdentifierIsString(name)) {
+        ERR("int NPIdentifier is not supported.");
+        return fail;
+    }
+
+    value = static_cast<Ewk_JS_Variant*>(malloc(sizeof(Ewk_JS_Variant)));
+    if (!value) {
+        ERR("Could not allocate memory for ewk_js_variant");
+        return false;
+    }
+
+    ewk_js_npvariant_to_variant(value, np_value);
+    char* prop_name = _NPN_UTF8FromIdentifier(name);
+    prop = static_cast<Ewk_JS_Property*>(eina_hash_find(obj->cls->properties, prop_name));
+    if (prop && prop->set)
+        fail = prop->set(obj, prop->name, value); // Class has property and property has setter.
+    else if (obj->cls->default_prop.set)
+        fail = obj->cls->default_prop.set(obj, prop_name, value); // Default getter exists.
+    else { // Fallback to objects hash map.
+        void* old = eina_hash_set(obj->properties, prop_name, value);
+        free(old);
+        fail = true;
+    }
+
+    free(prop_name);
+    return fail;
+}
+
+static bool ewk_js_property_remove(NPObject* np_obj, NPIdentifier name)
+{
+    Ewk_JS_Object* obj = reinterpret_cast<Ewk_JS_Object*>(np_obj);
+    Ewk_JS_Property* prop;
+    bool fail = false;
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(np_obj, false);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, false);
+
+    if (!_NPN_IdentifierIsString(name)) {
+        ERR("int NPIdentifier is not supported.");
+        return fail;
+    }
+
+    char* prop_name = _NPN_UTF8FromIdentifier(name);
+    prop = static_cast<Ewk_JS_Property*>(eina_hash_find(obj->cls->properties, prop_name));
+    if (prop && prop->del)
+        fail = prop->del(obj, prop->name); // Class has property and property has getter.
+    else if (obj->cls->default_prop.del)
+        fail = obj->cls->default_prop.del(obj, prop_name);
+    else
+        fail = eina_hash_del(obj->properties, prop_name, 0);
+
+    free(prop_name);
+    return fail;
+}
+
+static bool ewk_js_properties_enumerate(NPObject* np_obj, NPIdentifier** value, uint32_t* count)
+{
+    Ewk_JS_Object* obj = reinterpret_cast<Ewk_JS_Object*>(np_obj);
+    Eina_Iterator* it;
+    char* key;
+    int i = 0;
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(np_obj, false);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, false);
+
+    *count = eina_hash_population(obj->properties);
+    *value = static_cast<NPIdentifier*>(malloc(sizeof(NPIdentifier) * *count));
+    if (!*value) {
+        ERR("Could not allocate memory for NPIdentifier");
+        return false;
+    }
+
+    it = eina_hash_iterator_key_new(obj->properties);
+    EINA_ITERATOR_FOREACH(it, key)
+        (*value)[i++] = _NPN_GetStringIdentifier(key);
+
+    eina_iterator_free(it);
+    return true;
+}
+
+static bool ewk_js_method_has(NPObject* np_obj, NPIdentifier name)
+{
+    Ewk_JS_Object* obj = reinterpret_cast<Ewk_JS_Object*>(np_obj);
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(np_obj, false);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, false);
+
+    if (!_NPN_IdentifierIsString(name)) {
+        ERR("int NPIdentifier is not supported.");
+        return false;
+    }
+    return eina_hash_find(obj->cls->methods, name); // Returns pointer if found(true), 0(false) otherwise.
+}
+
+static bool ewk_js_method_invoke(NPObject* np_obj, NPIdentifier name, const NPVariant* np_args, uint32_t np_arg_count, NPVariant* result)
+{
+    Ewk_JS_Object* obj = reinterpret_cast<Ewk_JS_Object*>(np_obj);
+    Ewk_JS_Method* method;
+    Ewk_JS_Variant* args;
+    Ewk_JS_Variant* ret_val;
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(np_obj, false);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, false);
+
+    if (!_NPN_IdentifierIsString(name)) {
+        ERR("int NPIdentifier is not supported.");
+        return false;
+    }
+
+    method = static_cast<Ewk_JS_Method*>(eina_hash_find(obj->cls->methods, name));
+    if (!method)
+        return false;
+
+    args = static_cast<Ewk_JS_Variant*>(malloc(sizeof(Ewk_JS_Variant)  *np_arg_count));
+    if (!args) {
+        ERR("Could not allocate memory for ewk_js_variant");
+        return false;
+    }
+
+    for (uint32_t i = 0; i < np_arg_count; i++)
+        ewk_js_npvariant_to_variant(&args[i], &np_args[i]);
+    ret_val = method->invoke(obj, args, np_arg_count);
+    ewk_js_variant_to_npvariant(ret_val, result);
+
+    ewk_js_variant_free(ret_val);
+
+    return true;
+}
+
+static Eina_Bool ewk_js_npobject_property_get(Ewk_JS_Object* obj, const char* name, Ewk_JS_Variant* value)
+{
+    NPIdentifier id = _NPN_GetStringIdentifier(name);
+    NPVariant var;
+    bool fail = _NPN_GetProperty(0, reinterpret_cast<NPObject*>(obj), id, &var);
+    if (!fail)
+        fail = ewk_js_npvariant_to_variant(value, &var);
+    return fail;
+}
+
+static Eina_Bool ewk_js_npobject_property_set(Ewk_JS_Object* obj, const char* name, const Ewk_JS_Variant* value)
+{
+    NPIdentifier id = _NPN_GetStringIdentifier(name);
+    NPVariant var;
+    bool fail = ewk_js_variant_to_npvariant(value, &var);
+    if (fail)
+        fail = _NPN_SetProperty(0, reinterpret_cast<NPObject*>(obj), id, &var);
+    return fail;
+}
+
+static Eina_Bool ewk_js_npobject_property_del(Ewk_JS_Object* obj, const char* name)
+{
+    NPIdentifier id = _NPN_GetStringIdentifier(name);
+    return _NPN_RemoveProperty(0, reinterpret_cast<NPObject*>(obj), id);
+}
+
+static void ewk_js_property_free(Ewk_JS_Property* prop)
+{
+    free(const_cast<char*>(prop->name));
+    if (prop->value.type == EWK_JS_VARIANT_STRING)
+        free(prop->value.value.s);
+    else if (prop->value.type == EWK_JS_VARIANT_OBJECT)
+        ewk_js_object_free(prop->value.value.o);
+    free(prop);
+}
+
+/**
+ * Create a Ewk_JS_Class to be used in @a ewk_js_object_new.
+ *
+ * @param meta @a Ewk_JS_Class_Meta that describes the class to be created.
+ *
+ * @return The Ewk_JS_Class created.
+ */
+Ewk_JS_Class* ewk_js_class_new(const Ewk_JS_Class_Meta* meta)
+{
+    Ewk_JS_Class* cls;
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(meta, 0);
+
+    cls = static_cast<Ewk_JS_Class*>(malloc(sizeof(Ewk_JS_Class)));
+    if (!cls) {
+        ERR("Could not allocate memory for ewk_js_class");
+        return 0;
+    }
+
+    cls->meta = meta;
+    cls->default_prop = meta->default_prop;
+
+    // Don't free methods since they point to meta class methods(will be freed when meta class is freed).
+    cls->methods = eina_hash_pointer_new(0);
+    for (int i = 0; meta->methods && meta->methods[i].name; i++) {
+        NPIdentifier id = _NPN_GetStringIdentifier(meta->methods[i].name);
+        eina_hash_add(cls->methods, id, &meta->methods[i]);
+    }
+
+    // Don't free properties since they point to meta class properties(will be freed when meta class is freed).
+    cls->properties = eina_hash_pointer_new(0);
+    for (int i = 0; meta->properties && meta->properties[i].name; i++) {
+        NPIdentifier id = _NPN_GetStringIdentifier(meta->properties[i].name);
+        eina_hash_add(cls->properties, id, &meta->properties[i]);
+    }
+
+    return cls;
+}
+
+/**
+ * Release resources allocated by @a cls.
+ *
+ * @param cls @a Ewk_JS_Class to be released.
+ */
+void ewk_js_class_free(Ewk_JS_Class* cls)
+{
+    EINA_SAFETY_ON_NULL_RETURN(cls);
+    eina_hash_free(cls->methods);
+    eina_hash_free(cls->properties);
+    free(cls);
+}
+
+static NPClass EWK_NPCLASS = {
+    NP_CLASS_STRUCT_VERSION,
+    0, // NPAllocateFunctionPtr
+    0, // NPDeallocateFunctionPtr
+    0, // NPInvalidateFunctionPtr
+    ewk_js_method_has, // NPHasMethodFunctionPtr
+    ewk_js_method_invoke, // NPInvokeFunctionPtr
+    0, // NPInvokeDefaultFunctionPtr
+    ewk_js_property_has, // NPHasPropertyFunctionPtr
+    ewk_js_property_get, // NPGetPropertyFunctionPtr
+    ewk_js_property_set, // NPSetPropertyFunctionPtr
+    ewk_js_property_remove, // NPRemovePropertyFunctionPtr
+    ewk_js_properties_enumerate, // NPEnumerationFunctionPtr
+    0 // NPConstructFunction
+};
+
+static Ewk_JS_Object* ewk_js_npobject_to_object(NPObject* np_obj)
+{
+    NPIdentifier* values;
+    uint32_t np_props_count;
+    Ewk_JS_Class* cls;
+    Ewk_JS_Object* obj;
+    Eina_Iterator* it;
+    Ewk_JS_Property* prop;
+    JavaScriptObject* jso;
+
+    if (EINA_MAGIC_CHECK(reinterpret_cast<Ewk_JS_Object*>(np_obj), EWK_JS_OBJECT_MAGIC))
+        return reinterpret_cast<Ewk_JS_Object*>(np_obj);
+
+    if (!_NPN_Enumerate(0, np_obj, &values, &np_props_count))
+        return 0;
+
+    cls = static_cast<Ewk_JS_Class*>(malloc(sizeof(Ewk_JS_Class)));
+    if (!cls) {
+        ERR("Could not allocate memory for ewk_js_class");
+        return 0;
+    }
+
+    cls->meta = 0;
+    Ewk_JS_Default def = {
+        ewk_js_npobject_property_set,
+        ewk_js_npobject_property_get,
+        ewk_js_npobject_property_del
+    };
+    cls->default_prop = def;
+    cls->methods = eina_hash_pointer_new(0);
+    cls->properties = eina_hash_pointer_new(reinterpret_cast<Eina_Free_Cb>(ewk_js_property_free));
+    for (uint32_t i = 0; i < np_props_count; i++) {
+        if (_NPN_HasProperty(0, np_obj, values[i])) {
+            NPVariant var;
+            Ewk_JS_Property* prop = static_cast<Ewk_JS_Property*>(calloc(sizeof(Ewk_JS_Property), 1));
+            if (!prop) {
+                ERR("Could not allocate memory for ewk_js_property");
+                goto error;
+            }
+
+            _NPN_GetProperty(0, np_obj, values[i], &var);
+            ewk_js_npvariant_to_variant(&(prop->value), &var);
+            prop->name = _NPN_UTF8FromIdentifier(values[i]);
+            eina_hash_add(cls->properties, values[i], prop);
+        }
+    }
+
+    // Can't use ewk_js_object_new(cls) because it expects cls->meta to exist.
+    obj = static_cast<Ewk_JS_Object*>(malloc(sizeof(Ewk_JS_Object)));
+    if (!obj) {
+        ERR("Could not allocate memory for ewk_js_object");
+        goto error;
+    }
+
+    free(values);
+    EINA_MAGIC_SET(obj, EWK_JS_OBJECT_MAGIC);
+    obj->name = 0;
+    obj->cls = cls;
+    obj->view = 0;
+
+    jso = reinterpret_cast<JavaScriptObject*>(np_obj);
+    if (!strcmp("Array", jso->imp->className().ascii().data()))
+        obj->type = EWK_JS_OBJECT_ARRAY;
+    else if (!strcmp("Function", jso->imp->className().ascii().data()))
+        obj->type = EWK_JS_OBJECT_FUNCTION;
+    else
+        obj->type = EWK_JS_OBJECT_OBJECT;
+
+    if (eina_hash_population(cls->properties) < 25)
+        obj->properties = eina_hash_string_small_new(0);
+    else
+        obj->properties = eina_hash_string_superfast_new(0);
+
+    it = eina_hash_iterator_data_new(cls->properties);
+    EINA_ITERATOR_FOREACH(it, prop) {
+        const char* key = prop->name;
+        Ewk_JS_Variant* value = &prop->value;
+        eina_hash_add(obj->properties, key, value);
+    }
+
+    eina_iterator_free(it);
+    obj->base = *reinterpret_cast<JavaScriptObject*>(np_obj);
+
+    return obj;
+
+error:
+    ewk_js_class_free(cls);
+    free(values);
+    return 0;
+}
+
+static Eina_Bool ewk_js_npvariant_to_variant(Ewk_JS_Variant* data, const NPVariant* result)
+{
+    int sz;
+    EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
+    EINA_SAFETY_ON_NULL_RETURN_VAL(result, EINA_FALSE);
+    switch (result->type) {
+    case NPVariantType_Void:
+        data->type = EWK_JS_VARIANT_VOID;
+        data->value.o = 0;
+        break;
+    case NPVariantType_Null:
+        data->type = EWK_JS_VARIANT_NULL;
+        data->value.o = 0;
+        break;
+    case NPVariantType_Int32:
+        data->type = EWK_JS_VARIANT_INT32;
+        data->value.i = NPVARIANT_TO_INT32(*result);
+        break;
+    case NPVariantType_Double:
+        data->type = EWK_JS_VARIANT_DOUBLE;
+        data->value.d = NPVARIANT_TO_DOUBLE(*result);
+        break;
+    case NPVariantType_String:
+        sz = NPVARIANT_TO_STRING(*result).UTF8Length;
+        data->value.s = static_cast<char*>(malloc(sizeof(char) * (sz + 1)));
+        if (!data->value.s)
+            return EINA_FALSE;
+        memcpy(data->value.s, NPVARIANT_TO_STRING(*result).UTF8Characters, sz);
+        data->value.s[sz] = '\0';
+        data->type = EWK_JS_VARIANT_STRING;
+        break;
+    case NPVariantType_Bool:
+        data->type = EWK_JS_VARIANT_BOOL;
+        data->value.b = NPVARIANT_TO_BOOLEAN(*result);
+        break;
+    case NPVariantType_Object:
+        data->type = EWK_JS_VARIANT_OBJECT;
+        data->value.o = ewk_js_npobject_to_object(NPVARIANT_TO_OBJECT(*result));
+        break;
+    default:
+        return EINA_FALSE;
+    }
+
+    return EINA_TRUE;
+}
+
+Ewk_JS_Object* ewk_js_object_new(const Ewk_JS_Class_Meta* meta_cls)
+{
+    Ewk_JS_Object* obj;
+
+    EINA_SAFETY_ON_NULL_RETURN_VAL(meta_cls, 0);
+
+    obj = static_cast<Ewk_JS_Object*>(malloc(sizeof(Ewk_JS_Object)));
+    if (!obj) {
+        ERR("Could not allocate memory for ewk_js_object");
+        return 0;
+    }
+
+    EINA_MAGIC_SET(obj, EWK_JS_OBJECT_MAGIC);
+    obj->cls = ewk_js_class_new(meta_cls);
+    obj->view = 0;
+    obj->name = 0;
+    obj->type = EWK_JS_OBJECT_OBJECT;
+
+    if (eina_hash_population(obj->cls->properties) < 25)
+        obj->properties = eina_hash_string_small_new(reinterpret_cast<Eina_Free_Cb>(ewk_js_variant_free));
+    else
+        obj->properties = eina_hash_string_superfast_new(reinterpret_cast<Eina_Free_Cb>(ewk_js_variant_free));
+
+    for (int i = 0; obj->cls->meta->properties && obj->cls->meta->properties[i].name; i++) {
+        Ewk_JS_Property prop = obj->cls->meta->properties[i];
+        const char* key = obj->cls->meta->properties[i].name;
+        Ewk_JS_Variant* value = static_cast<Ewk_JS_Variant*>(malloc(sizeof(Ewk_JS_Variant)));
+        if (!value) {
+            ERR("Could not allocate memory for ewk_js_variant");
+            goto error;
+        }
+        if (prop.get)
+            prop.get(obj, key, value);
+        else {
+            value->type = prop.value.type;
+            switch (value->type) {
+            case EWK_JS_VARIANT_VOID:
+            case EWK_JS_VARIANT_NULL:
+                value->value.o = 0;
+                break;
+            case EWK_JS_VARIANT_STRING:
+                value->value.s = strdup(prop.value.value.s);
+                break;
+            case EWK_JS_VARIANT_BOOL:
+                value->value.b = prop.value.value.b;
+                break;
+            case EWK_JS_VARIANT_INT32:
+                value->value.i = prop.value.value.i;
+                break;
+            case EWK_JS_VARIANT_DOUBLE:
+                value->value.d = prop.value.value.d;
+                break;
+            case EWK_JS_VARIANT_OBJECT:
+                value->value.o = prop.value.value.o;
+                break;
+            }
+        }
+        eina_hash_add(obj->properties, key, value);
+    }
+
+    obj->base.object.referenceCount = 1;
+    obj->base.object._class = &EWK_NPCLASS;
+    return obj;
+
+error:
+    ewk_js_object_free(obj);
+    return 0;
+}
+
+void ewk_js_object_free(Ewk_JS_Object* obj)
+{
+    EINA_SAFETY_ON_NULL_RETURN(obj);
+    EINA_MAGIC_CHECK_OR_RETURN(obj);
+    Eina_Bool script_obj = !obj->cls->meta;
+
+    eina_hash_free(obj->properties);
+    eina_stringshare_del(obj->name);
+
+    ewk_js_class_free(const_cast<Ewk_JS_Class*>(obj->cls));
+
+    EINA_MAGIC_SET(obj, EINA_MAGIC_NONE);
+
+    if (script_obj)
+        free(obj);
+}
+
+Eina_Hash* ewk_js_object_properties_get(const Ewk_JS_Object* obj)
+{
+    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, 0);
+    return obj->properties;
+}
+
+const char* ewk_js_object_name_get(const Ewk_JS_Object* obj)
+{
+    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, 0);
+    return obj->name;
+}
+
+Eina_Bool ewk_js_object_invoke(Ewk_JS_Object* obj, Ewk_JS_Variant* args, int arg_count, Ewk_JS_Variant* result)
+{
+    NPVariant* np_args;
+    NPVariant np_result;
+    bool fail = EINA_FALSE;
+
+    EINA_MAGIC_CHECK_OR_RETURN(obj, EINA_FALSE);
+    if (ewk_js_object_type_get(obj) != EWK_JS_OBJECT_FUNCTION)
+        return EINA_FALSE;
+    if (arg_count)
+        EINA_SAFETY_ON_NULL_RETURN_VAL(args, EINA_FALSE);
+
+    np_args = static_cast<NPVariant*>(malloc(sizeof(NPVariant)  *arg_count));
+    if (!np_args) {
+        ERR("Could not allocate memory to method arguments");
+        return EINA_FALSE;
+    }
+
+    for (int i = 0; i < arg_count; i++)
+        if (!ewk_js_variant_to_npvariant(&args[i], &np_args[i]))
+            goto end;
+
+    if (!(fail = _NPN_InvokeDefault(0, reinterpret_cast<NPObject*>(obj), np_args, arg_count, &np_result)))
+        goto end;
+    if (result)
+        fail = ewk_js_npvariant_to_variant(result, &np_result);
+
+end:
+    free(np_args);
+    return fail;
+}
+
+Ewk_JS_Object_Type ewk_js_object_type_get(Ewk_JS_Object* obj)
+{
+    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EWK_JS_OBJECT_OBJECT);
+    EINA_MAGIC_CHECK_OR_RETURN(obj, EWK_JS_OBJECT_OBJECT);
+
+    return obj->type;
+}
+
+void ewk_js_object_type_set(Ewk_JS_Object* obj, Ewk_JS_Object_Type type)
+{
+    EINA_SAFETY_ON_NULL_RETURN(obj);
+    EINA_MAGIC_CHECK_OR_RETURN(obj);
+
+    obj->type = type;
+}
+
+void ewk_js_variant_free(Ewk_JS_Variant* var)
+{
+    EINA_SAFETY_ON_NULL_RETURN(var);
+    if (var->type == EWK_JS_VARIANT_STRING)
+        free(var->value.s);
+    else if (var->type == EWK_JS_VARIANT_OBJECT)
+        ewk_js_object_free(var->value.o);
+    free(var);
+}
+
+void ewk_js_variant_array_free(Ewk_JS_Variant* var, int count)
+{
+    EINA_SAFETY_ON_NULL_RETURN(var);
+    for (int i = 0; i < count; i++) {
+        if (var[i].type == EWK_JS_VARIANT_STRING)
+            free(var[i].value.s);
+        else if (var[i].type == EWK_JS_VARIANT_OBJECT)
+            ewk_js_object_free(var[i].value.o);
+    }
+    free(var);
+}
+
+#else
+
+Eina_Hash* ewk_js_object_properties_get(const Ewk_JS_Object* obj)
+{
+    return 0;
+}
+
+const char* ewk_js_object_name_get(const Ewk_JS_Object* obj)
+{
+    return 0;
+}
+
+void ewk_js_variant_free(Ewk_JS_Variant* var)
+{
+}
+
+void ewk_js_variant_array_free(Ewk_JS_Variant* var, int count)
+{
+}
+
+Ewk_JS_Object* ewk_js_object_new(const Ewk_JS_Class_Meta* meta_cls)
+{
+    return 0;
+}
+
+void ewk_js_object_free(Ewk_JS_Object* obj)
+{
+}
+
+Eina_Bool ewk_js_object_invoke(Ewk_JS_Object* obj, Ewk_JS_Variant* args, int arg_count, Ewk_JS_Variant* result)
+{
+    return EINA_FALSE;
+}
+
+Ewk_JS_Object_Type ewk_js_object_type_get(Ewk_JS_Object* obj)
+{
+    return EWK_JS_OBJECT_INVALID;
+}
+
+void ewk_js_object_type_set(Ewk_JS_Object* obj, Ewk_JS_Object_Type type)
+{
+}
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff --git a/Source/WebKit/efl/ewk/ewk_js.h b/Source/WebKit/efl/ewk/ewk_js.h
new file mode 100644 (file)
index 0000000..c0ea018
--- /dev/null
@@ -0,0 +1,189 @@
+/*
+    Copyright (C) 2011 ProFUSION embedded systems
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#ifndef ewk_js_h
+#define ewk_js_h
+
+#include <Eina.h>
+#include <Evas.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define EWK_JS_CLASS_META_VERSION 0
+
+typedef struct _Ewk_JS_Object Ewk_JS_Object;
+typedef struct _Ewk_JS_Class_Meta Ewk_JS_Class_Meta;
+typedef struct _Ewk_JS_Variant Ewk_JS_Variant;
+typedef struct _Ewk_JS_Method Ewk_JS_Method;
+typedef struct _Ewk_JS_Property Ewk_JS_Property;
+typedef struct _Ewk_JS_Default Ewk_JS_Default;
+typedef Eina_Bool (*Ewk_JS_Set_Cb)(Ewk_JS_Object *obj, const char *name, const Ewk_JS_Variant *value);
+typedef Eina_Bool (*Ewk_JS_Get_Cb)(Ewk_JS_Object *obj, const char *name, Ewk_JS_Variant *value);
+typedef Eina_Bool (*Ewk_JS_Del_Cb)(Ewk_JS_Object *obj, const char *name);
+typedef Ewk_JS_Variant* (*Ewk_JS_Invoke_Cb)(Ewk_JS_Object *obj, Ewk_JS_Variant *args, int argCount);
+
+typedef enum {
+    EWK_JS_VARIANT_VOID,
+    EWK_JS_VARIANT_NULL,
+    EWK_JS_VARIANT_BOOL,
+    EWK_JS_VARIANT_INT32,
+    EWK_JS_VARIANT_DOUBLE,
+    EWK_JS_VARIANT_STRING,
+    EWK_JS_VARIANT_OBJECT
+} Ewk_JS_Variant_Type;
+
+typedef enum {
+    EWK_JS_OBJECT_OBJECT,
+    EWK_JS_OBJECT_ARRAY,
+    EWK_JS_OBJECT_FUNCTION,
+    EWK_JS_OBJECT_INVALID
+} Ewk_JS_Object_Type;
+
+struct _Ewk_JS_Variant {
+    Ewk_JS_Variant_Type type;
+    union {
+        Eina_Bool b;
+        int i;
+        double d;
+        char *s;
+        Ewk_JS_Object *o;
+    } value;
+};
+
+struct _Ewk_JS_Method {
+    const char *name;
+    Ewk_JS_Invoke_Cb invoke;
+};
+
+struct _Ewk_JS_Property {
+    const char *name;
+    Ewk_JS_Set_Cb set;
+    Ewk_JS_Get_Cb get;
+    Ewk_JS_Del_Cb del;
+    Ewk_JS_Variant value;
+};
+
+struct _Ewk_JS_Default {
+    Ewk_JS_Set_Cb set;
+    Ewk_JS_Get_Cb get;
+    Ewk_JS_Del_Cb del;
+};
+
+struct _Ewk_JS_Class_Meta {
+    unsigned int version; // define
+    const Ewk_JS_Method *methods; // null terminated array
+    const Ewk_JS_Property *properties; // null terminated array
+    Ewk_JS_Default default_prop;
+};
+
+/**
+ * Gets Eina_Hash with object's properties.
+ *
+ * @param obj Object whose properties are wanted.
+ *
+ * @return object's properties.
+ */
+EAPI Eina_Hash *ewk_js_object_properties_get(const Ewk_JS_Object *obj);
+
+/**
+ * Gets name of the object.
+ *
+ * @param obj Object whose name is wanted.
+ *
+ * @return name of object.
+ */
+
+EAPI const char *ewk_js_object_name_get(const Ewk_JS_Object *obj);
+
+/**
+ * Release resources allocated by @a var.
+ *
+ * @param var @a Ewk_JS_Variant to be release
+ */
+EAPI void ewk_js_variant_free(Ewk_JS_Variant *var);
+
+/**
+ * Release resources allocated by @a var.
+ *
+ * @param var @a Ewk_JS_Variant to be release
+ * @param count @a size of array
+ */
+EAPI void ewk_js_variant_array_free(Ewk_JS_Variant *var, int count);
+
+/**
+ * Create a Ewk_JS_Object to be used in @a ewk_view_js_object_add. The Meta class's
+ * methods and properties are not modified but references to it are kept as long
+ * as the object created from it lives. All properties created here
+ * will be added to the object hash of properties. Properties using default_prop's
+ * get/set/del methods should also be added to the objects hash(see:
+ * @a ewk_js_object_properties_get). Methods must free the arguments they receive(see:
+ * @a ewk_js_variang_array_free).
+ *
+ *
+ * @param cls @a Ewk_JS_Class that describes the object to be created.
+ *
+ * @return The Ewk_JS_Object created.
+ */
+EAPI Ewk_JS_Object *ewk_js_object_new(const Ewk_JS_Class_Meta *meta_cls);
+
+/**
+ * Release resources allocated by @a obj.
+ *
+ * @param obj @a Ewk_JS_Object to be released.
+ */
+EAPI void ewk_js_object_free(Ewk_JS_Object *obj);
+
+/**
+ * Calls the function this object represents.
+ *
+ * @param obj Object that represents function.
+ * @param args Arguments to be passed to function.
+ * @param arg_count Number of arguments.
+ * @param result Return value of the invoked function.
+ *
+ * @return @c EINA_TRUE if function was executed, @c EINA_FALSE if function was not executed.
+ */
+EAPI Eina_Bool ewk_js_object_invoke(Ewk_JS_Object *obj, Ewk_JS_Variant *args, int arg_count, Ewk_JS_Variant *result);
+
+/**
+ * Returns the type this object represents.
+ *
+ * @param obj Object
+ *
+ * @return @c EWK_JS_OBJECT if it is an object, @c EWK_JS_ARRAY if it is an array and
+ * @c EWK_JS_FUNCTION if it is a function.
+ */
+EAPI Ewk_JS_Object_Type ewk_js_object_type_get(Ewk_JS_Object *obj);
+
+/**
+ * Sets the type this object represents.
+ *
+ * @param obj Object
+ * @param type Type
+ *
+ */
+EAPI void ewk_js_object_type_set(Ewk_JS_Object *obj, Ewk_JS_Object_Type type);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // ewk_js_h
index 5c44b26..3d62284 100644 (file)
 #include "BackForwardListImpl.h"
 #include "EWebKit.h"
 #include "Frame.h"
+#include "NP_jsobject.h"
 #include "Page.h"
 #include "Settings.h"
 #include "Widget.h"
+#include "ewk_js.h"
 #include "ewk_logging.h"
 #include "ewk_util.h"
 
@@ -47,6 +49,21 @@ extern "C" {
 // If defined, ewk will do type checking to ensure objects are of correct type
 #define EWK_TYPE_CHECK 1
 
+#if ENABLE(NETSCAPE_PLUGIN_API)
+#define EWK_JS_OBJECT_MAGIC 0x696969
+
+typedef struct _Ewk_JS_Class Ewk_JS_Class;
+struct _Ewk_JS_Object {
+    JavaScriptObject base;
+    const char *name;
+    const Ewk_JS_Class *cls;
+    Eina_Hash *properties;
+    Evas_Object *view; // ewk_view: check if this object has already been added to another ewk_view
+    Ewk_JS_Object_Type type;
+    EINA_MAGIC;
+};
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
 // forward declarations
 namespace WebCore {
 struct PopupMenuClient;
@@ -121,6 +138,10 @@ void ewk_view_download_request(Evas_Object *o, Ewk_Download *download);
 void ewk_view_editor_client_contents_changed(Evas_Object *o);
 void ewk_view_editor_client_selection_changed(Evas_Object *o);
 
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void ewk_view_js_window_object_clear(Evas_Object *o, Evas_Object *frame);
+#endif
+
 int ewk_util_dpi_get(void);
 void ewk_util_javascript_gc_collect();
 void ewk_util_javascript_gc_alternate_thread_collect(Eina_Bool waitUntilDone);
index 820b843..c81cf0f 100644 (file)
@@ -23,6 +23,7 @@
 #include "ewk_view.h"
 
 #include "BackForwardListImpl.h"
+#include "Bridge.h"
 #include "Chrome.h"
 #include "ChromeClientEfl.h"
 #include "ContextMenuController.h"
 #include "HTMLNames.h"
 #include "InspectorClientEfl.h"
 #include "IntSize.h"
+#include "JSDOMBinding.h"
+#include "JSDOMWindow.h"
+#include "JSLock.h"
 #include "PlatformMouseEvent.h"
 #include "PopupMenuClient.h"
 #include "ProgressTracker.h"
 #include "RenderTheme.h"
+#include "c_instance.h"
 #include "ewk_private.h"
 
 #include <Ecore.h>
@@ -3390,6 +3395,18 @@ void ewk_view_download_request(Evas_Object *o, Ewk_Download *download)
 
 /**
  * @internal
+ * Reports the JS window object was cleared.
+ *
+ * @param o view.
+ * @param frame the frame.
+ */
+void ewk_view_js_window_object_clear(Evas_Object *o, Evas_Object *frame)
+{
+    evas_object_smart_callback_call(o, "js,windowobject,clear", frame);
+}
+
+/**
+ * @internal
  * Reports the viewport has changed.
  *
  * @param arguments viewport argument.
@@ -3539,6 +3556,40 @@ Eina_Bool ewk_view_navigation_policy_decision(Evas_Object *o, Ewk_Frame_Resource
     return sd->api->navigation_policy_decision(sd, request);
 }
 
+Eina_Bool ewk_view_js_object_add(Evas_Object *o, Ewk_JS_Object *obj, const char *obj_name)
+{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+    if (obj->view) // object has already been added to another ewk_view
+        return EINA_FALSE;
+    obj->name = eina_stringshare_add(obj_name);
+    EWK_VIEW_SD_GET_OR_RETURN(o, sd, EINA_FALSE);
+    EWK_VIEW_PRIV_GET_OR_RETURN(sd, priv, EINA_FALSE);
+
+    JSC::JSLock lock(JSC::SilenceAssertionsOnly);
+    WebCore::JSDOMWindow *window = toJSDOMWindow(priv->main_frame, WebCore::mainThreadNormalWorld());
+    JSC::Bindings::RootObject *root;
+    root = priv->main_frame->script()->bindingRootObject();
+
+    if (!window) {
+        ERR("Warning: couldn't get window object");
+        return EINA_FALSE;
+    }
+
+    JSC::ExecState* exec = window->globalExec();
+
+    obj->view = o;
+    JSC::JSObject *runtimeObject = (JSC::JSObject*)JSC::Bindings::CInstance::create((NPObject*)obj, root)->createRuntimeObject(exec);
+    JSC::Identifier id = JSC::Identifier(exec, obj_name);
+
+    JSC::PutPropertySlot slot;
+    window->put(exec, id, runtimeObject, slot);
+    return EINA_TRUE;
+#else
+    return EINA_FALSE;
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+}
+
+
 /**
  * @internal
  * Reports that the contents have resized. The ewk_view calls contents_resize,
index 8c2baca..c675ed4 100644 (file)
@@ -40,6 +40,7 @@
  *  - "icon,received", void: main frame received an icon.
  *  - "inputmethod,changed", Eina_Bool: reports that input method was changed and
  *    it gives a boolean value whether it's enabled or not as an argument.
+ *  - "js,windowobject,clear", void: Report that the JS window object has been cleared.
  *  - "link,hover,in", const char *link[2]: reports mouse is over a link.
  *    It gives the url in link[0] and link's title in link[1] as an argument.
  *  - "link,hover,out", void: reports mouse moved out from a link.
@@ -85,6 +86,7 @@
 
 #include "ewk_frame.h"
 #include "ewk_history.h"
+#include "ewk_js.h"
 #include "ewk_window_features.h"
 
 #include <Evas.h>
@@ -2175,6 +2177,18 @@ EAPI Eina_Bool ewk_view_mode_set(Evas_Object *o, Ewk_View_Mode view_mode);
  * @see ewk_view_mode_set()
  */
 EAPI Ewk_View_Mode ewk_view_mode_get(Evas_Object *o);
+
+/**
+ * Creates a JS object named @a obj_name as property of the window object. This should be called on a callback connectedto the
+ * js,windowobject,clear signal.
+ *
+ * @param o view.
+ * @param obj object that will be added(see: @a ewk_js_object_new).
+ * @param obj_name name of the object.
+ *
+ * @return @c EINA_TRUE if object was added, @c EINA_FALSE if not.
+ */
+EAPI Eina_Bool ewk_view_js_object_add(Evas_Object *o, Ewk_JS_Object *obj, const char *obj_name);
 #ifdef __cplusplus
 }
 #endif