aboutsummaryrefslogtreecommitdiffstats
path: root/src/bindings/eio_js/eio_js.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/bindings/eio_js/eio_js.cc')
-rw-r--r--src/bindings/eio_js/eio_js.cc1756
1 files changed, 1756 insertions, 0 deletions
diff --git a/src/bindings/eio_js/eio_js.cc b/src/bindings/eio_js/eio_js.cc
new file mode 100644
index 0000000000..8441247e63
--- /dev/null
+++ b/src/bindings/eio_js/eio_js.cc
@@ -0,0 +1,1756 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <Eio_Js.hh>
+
+namespace efl { namespace eio { namespace js {
+
+using ::efl::eina::js::compatibility_new;
+using ::efl::eina::js::compatibility_return_type;
+using ::efl::eina::js::compatibility_callback_info_type;
+using ::efl::eina::js::compatibility_return;
+using ::efl::eina::js::compatibility_get_pointer_internal_field;
+using ::efl::eina::js::compatibility_set_pointer_internal_field;
+
+namespace {
+
+Eio_File* extract_eio_file(v8::Local<v8::Object> object)
+{
+ return compatibility_get_pointer_internal_field<Eio_File*>(object, 0);
+}
+
+v8::Local<v8::Object> wrap_eio_file(Eio_File *file, v8::Isolate *isolate)
+{
+ using v8::String;
+ using v8::Boolean;
+ using v8::ObjectTemplate;
+ using v8::FunctionTemplate;
+
+ auto obj_tpl = compatibility_new<ObjectTemplate>(isolate);
+ obj_tpl->SetInternalFieldCount(1);
+ auto ret = obj_tpl->NewInstance();
+
+ auto cancel = [](compatibility_callback_info_type info)
+ -> compatibility_return_type {
+ if (info.Length() != 0)
+ return compatibility_return();
+
+ auto isolate = info.GetIsolate();
+
+ auto ret = eio_file_cancel(extract_eio_file(info.This()));
+ return compatibility_return(compatibility_new<Boolean>(isolate, ret),
+ info);
+ };
+
+ auto check = [](compatibility_callback_info_type info)
+ -> compatibility_return_type {
+ if (info.Length() != 0)
+ return compatibility_return();
+
+ auto isolate = info.GetIsolate();
+
+ auto ret = eio_file_check(extract_eio_file(info.This()));
+ return compatibility_return(compatibility_new<Boolean>(isolate, ret),
+ info);
+ };
+
+ ret->Set(compatibility_new<String>(isolate, "cancel"),
+ compatibility_new<FunctionTemplate>(isolate, cancel)
+ ->GetFunction());
+ ret->Set(compatibility_new<String>(isolate, "check"),
+ compatibility_new<FunctionTemplate>(isolate, check)
+ ->GetFunction());
+
+ compatibility_set_pointer_internal_field(ret, 0, file);
+
+ return ret;
+}
+
+static Eina_File* extract_eina_file(v8::Local<v8::Object> object)
+{
+ return compatibility_get_pointer_internal_field<Eina_File*>(object, 0);
+}
+
+static v8::Local<v8::Object> wrap_eina_file(Eina_File *file,
+ v8::Isolate *isolate)
+{
+ using v8::String;
+ using v8::ObjectTemplate;
+ using v8::Object;
+ using v8::FunctionTemplate;
+ using v8::WeakCallbackData;
+
+ auto obj_tpl = compatibility_new<ObjectTemplate>(isolate);
+ obj_tpl->SetInternalFieldCount(1);
+ auto ret = obj_tpl->NewInstance();
+
+ /* TODO:
+
+ Eina_File only handle files open in read-only mode. Althought there
+ aren't many useful functions exposed to a JavaScript binding, the exposed
+ `file->fd` can be used to expose a few read operations found in
+ `<cstdio>`.
+ */
+
+ auto close = [](compatibility_callback_info_type info)
+ -> compatibility_return_type {
+ if (info.Length() != 0)
+ return compatibility_return();
+
+ auto o = info.This();
+
+ auto file = extract_eina_file(o);
+ if (!file)
+ return compatibility_return();
+
+ eina_file_close(file);
+ compatibility_set_pointer_internal_field<void*>(o, 0, nullptr);
+ return compatibility_return();
+ };
+
+ ret->Set(compatibility_new<String>(isolate, "close"),
+ compatibility_new<FunctionTemplate>(isolate, close)
+ ->GetFunction());
+
+ compatibility_set_pointer_internal_field(ret, 0, file);
+
+ auto on_gc = [ret]() {
+ auto file = extract_eina_file(ret);
+
+ if (file) {
+ eina_file_close(file);
+ compatibility_set_pointer_internal_field<void*>(ret, 0, nullptr);
+ }
+ };
+
+ efl::eina::js::make_weak(isolate, ret, on_gc);
+
+ return ret;
+}
+
+static Eio_Monitor* extract_monitor(v8::Local<v8::Object> object)
+{
+ return compatibility_get_pointer_internal_field<Eio_Monitor*>(object, 0);
+}
+
+static v8::Local<v8::Object> wrap_monitor(Eio_Monitor *monitor,
+ v8::Isolate *isolate)
+{
+ using v8::String;
+ using v8::ObjectTemplate;
+ using v8::FunctionTemplate;
+
+ auto obj_tpl = compatibility_new<ObjectTemplate>(isolate);
+ obj_tpl->SetInternalFieldCount(1);
+ auto ret = obj_tpl->NewInstance();
+
+ auto del = [](compatibility_callback_info_type info)
+ -> compatibility_return_type {
+ if (info.Length() != 0)
+ return compatibility_return();
+
+ eio_monitor_del(extract_monitor(info.This()));
+ return compatibility_return();
+ };
+
+ auto path_get = [](compatibility_callback_info_type info)
+ -> compatibility_return_type {
+ if (info.Length() != 0)
+ return compatibility_return();
+
+ auto ret = eio_monitor_path_get(extract_monitor(info.This()));
+ return compatibility_return(compatibility_new<String>(info.GetIsolate(),
+ ret),
+ info);
+ };
+
+ ret->Set(compatibility_new<String>(isolate, "del"),
+ compatibility_new<FunctionTemplate>(isolate, del)->GetFunction());
+ ret->Set(compatibility_new<String>(isolate, "path_get"),
+ compatibility_new<FunctionTemplate>(isolate, path_get)
+ ->GetFunction());
+
+ compatibility_set_pointer_internal_field(ret, 0, monitor);
+
+ return ret;
+}
+
+static Ecore_Event_Handler *extract_event_handler(v8::Local<v8::Object> object)
+{
+ return compatibility_get_pointer_internal_field<Ecore_Event_Handler*>
+ (object, 0);
+}
+
+static v8::Local<v8::Object> wrap_event_handler(Ecore_Event_Handler *handler,
+ v8::Isolate *isolate)
+{
+ using v8::String;
+ using v8::ObjectTemplate;
+ using v8::FunctionTemplate;
+ using v8::Value;
+
+ auto obj_tpl = compatibility_new<ObjectTemplate>(isolate);
+ obj_tpl->SetInternalFieldCount(1);
+ auto ret = obj_tpl->NewInstance();
+
+ auto del = [](compatibility_callback_info_type info)
+ -> compatibility_return_type {
+ if (info.Length() != 0)
+ return compatibility_return();
+
+ auto p = ecore_event_handler_del(extract_event_handler(info.This()));
+
+ auto per = static_cast<efl::eina::js::global_ref<Value>*>(p);
+ per->dispose();
+ delete per;
+ return compatibility_return();
+ };
+
+ ret->Set(compatibility_new<String>(isolate, "del"),
+ compatibility_new<FunctionTemplate>(isolate, del)->GetFunction());
+
+ compatibility_set_pointer_internal_field(ret, 0, handler);
+
+ return ret;
+}
+
+static
+v8::Local<v8::Object> wrap_eina_file_direct_info(const Eina_File_Direct_Info*
+ info,
+ v8::Isolate *isolate)
+{
+ using v8::Object;
+ using v8::String;
+ using v8::Integer;
+
+ auto wrapped_info = compatibility_new<Object>(isolate);
+
+ wrapped_info->Set(compatibility_new<String>(isolate, "path_length"),
+ compatibility_new<Integer>(isolate, info->path_length));
+ wrapped_info->Set(compatibility_new<String>(isolate, "mame_length"),
+ compatibility_new<Integer>(isolate, info->name_length));
+ wrapped_info->Set(compatibility_new<String>(isolate, "name_start"),
+ compatibility_new<Integer>(isolate, info->name_start));
+ wrapped_info->Set(compatibility_new<String>(isolate, "type"),
+ compatibility_new<Integer>(isolate, info->type));
+ wrapped_info->Set(compatibility_new<String>(isolate, "path"),
+ compatibility_new<String>(isolate, info->path));
+
+ return wrapped_info;
+}
+
+EAPI
+void register_init(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ using v8::FunctionTemplate;
+
+ auto init = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 0)
+ return compatibility_return();
+
+ auto isolate = args.GetIsolate();
+ auto ret = eio_init();
+ return compatibility_return(compatibility_new<Integer>(isolate, ret),
+ args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, init)
+ ->GetFunction());
+}
+
+EAPI
+void register_shutdown(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ using v8::FunctionTemplate;
+
+ auto shutdown = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 0)
+ return compatibility_return();
+
+ auto isolate = args.GetIsolate();
+ auto ret = eio_shutdown();
+ return compatibility_return(compatibility_new<Integer>(isolate, ret),
+ args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, shutdown)
+ ->GetFunction());
+}
+
+EAPI
+void register_op_file_copy(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name, compatibility_new<Integer>(isolate, EIO_FILE_COPY));
+}
+
+EAPI
+void register_op_file_move(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name, compatibility_new<Integer>(isolate, EIO_FILE_MOVE));
+}
+
+EAPI
+void register_op_dir_copy(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name, compatibility_new<Integer>(isolate, EIO_DIR_COPY));
+}
+
+EAPI
+void register_op_dir_move(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name, compatibility_new<Integer>(isolate, EIO_DIR_MOVE));
+}
+
+EAPI
+void register_op_unlink(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name, compatibility_new<Integer>(isolate, EIO_UNLINK));
+}
+
+EAPI
+void register_op_file_getpwnam(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name, compatibility_new<Integer>(isolate, EIO_FILE_GETPWNAM));
+}
+
+EAPI
+void register_op_file_getgrnam(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name, compatibility_new<Integer>(isolate, EIO_FILE_GETGRNAM));
+}
+
+EAPI
+void register_file_open(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ using v8::Value;
+ using v8::String;
+ using v8::FunctionTemplate;
+ using v8::Function;
+ using v8::Handle;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 4 || !args[0]->IsString() || !args[1]->IsBoolean()
+ || !args[2]->IsFunction() || !args[3]->IsFunction())
+ return compatibility_return();
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]);
+ cb_data[0] = persistent_t(isolate, args[2]);
+ cb_data[1] = persistent_t(isolate, args[3]);
+
+ auto open_cb = [](void *data, Eio_File *handler, Eina_File *file) {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrap_eina_file(file, isolate)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] persistent;
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 1);
+ };
+
+ auto ret = eio_file_open(*String::Utf8Value(args[0]),
+ args[1]->BooleanValue(), open_cb, error_cb,
+ cb_data.release());
+
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_monitor_file_created(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate, EIO_MONITOR_FILE_CREATED));
+}
+
+EAPI
+void register_monitor_file_deleted(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate, EIO_MONITOR_FILE_DELETED));
+}
+
+EAPI
+void register_monitor_file_modified(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate, EIO_MONITOR_FILE_MODIFIED));
+}
+
+EAPI
+void register_monitor_file_closed(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate, EIO_MONITOR_FILE_CLOSED));
+}
+
+EAPI
+void register_monitor_directory_created(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate,
+ EIO_MONITOR_DIRECTORY_CREATED));
+}
+
+EAPI
+void register_monitor_directory_deleted(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate,
+ EIO_MONITOR_DIRECTORY_DELETED));
+}
+
+EAPI
+void register_monitor_directory_modified(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate,
+ EIO_MONITOR_DIRECTORY_MODIFIED));
+}
+
+EAPI
+void register_monitor_directory_closed(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate,
+ EIO_MONITOR_DIRECTORY_CLOSED));
+}
+
+EAPI
+void register_monitor_self_rename(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate, EIO_MONITOR_SELF_RENAME));
+}
+
+EAPI
+void register_monitor_self_deleted(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate, EIO_MONITOR_SELF_DELETED));
+}
+
+EAPI
+void register_monitor_error(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ global->Set(name,
+ compatibility_new<Integer>(isolate, EIO_MONITOR_ERROR));
+}
+
+EAPI
+void register_monitor_add(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 1 || !args[0]->IsString())
+ return compatibility_return();
+
+ auto isolate = args.GetIsolate();
+ auto ret = eio_monitor_add(*String::Utf8Value(args[0]));
+ return compatibility_return(wrap_monitor(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+template<int &wanted_event>
+static
+void register_monitor_event_handler_add(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::Integer;
+ using v8::String;
+ using v8::Value;
+ using v8::Object;
+ using v8::Function;
+ using v8::Handle;
+ using v8::Local;
+ using v8::FunctionTemplate;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 1 || !args[0]->IsFunction())
+ return compatibility_return();
+
+ auto isolate = args.GetIsolate();
+
+ auto p = new efl::eina::js::global_ref<Value>(isolate, args[0]);
+
+ auto cb = [](void *d, int type, void *event) -> Eina_Bool {
+ auto p = reinterpret_cast<efl::eina::js::global_ref<Value>*>(d);
+ auto e = reinterpret_cast<Eio_Monitor_Event*>(event);
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ auto o = p->handle();
+ auto wrapped_event = compatibility_new<Object>(isolate);
+
+ wrapped_event->Set(compatibility_new<String>(isolate, "monitor"),
+ wrap_monitor(e->monitor, isolate));
+ wrapped_event->Set(compatibility_new<String>(isolate, "filename"),
+ compatibility_new<String>(isolate, e->filename));
+
+ Handle<Value> args[2]{
+ compatibility_new<Integer>(isolate, type),
+ wrapped_event
+ };
+
+ auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ auto bret = ret->IsBoolean() && ret->BooleanValue();
+
+ return bret ? EINA_TRUE : EINA_FALSE;
+ };
+
+ auto ret = ecore_event_handler_add(wanted_event, cb, p);
+ return compatibility_return(wrap_event_handler(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void
+register_event_monitor_file_created_handler_add(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_FILE_CREATED>
+ (isolate, global, name);
+}
+
+EAPI
+void
+register_event_monitor_file_deleted_handler_add(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_FILE_DELETED>
+ (isolate, global, name);
+}
+
+EAPI
+void
+register_event_monitor_file_modified_handler_add(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_FILE_MODIFIED>
+ (isolate, global, name);
+}
+
+EAPI
+void
+register_event_monitor_file_closed_handler_add(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_FILE_CLOSED>
+ (isolate, global, name);
+}
+
+EAPI
+void register_event_monitor_directory_created_handler_add
+(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_DIRECTORY_CREATED>
+ (isolate, global, name);
+}
+
+EAPI
+void register_event_monitor_directory_deleted_handler_add
+(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_DIRECTORY_DELETED>
+ (isolate, global, name);
+}
+
+EAPI
+void register_event_monitor_directory_modified_handler_add
+(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_DIRECTORY_MODIFIED>
+ (isolate, global, name);
+}
+
+EAPI
+void register_event_monitor_directory_closed_handler_add
+(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_DIRECTORY_CLOSED>
+ (isolate, global, name);
+}
+
+EAPI
+void
+register_event_monitor_self_rename_handler_add(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_SELF_RENAME>
+ (isolate, global, name);
+}
+
+EAPI
+void
+register_event_monitor_self_deleted_handler_add(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_SELF_DELETED>
+ (isolate, global, name);
+}
+
+EAPI
+void
+register_event_monitor_error_handler_add(v8::Isolate *isolate,
+ v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ return register_monitor_event_handler_add<EIO_MONITOR_ERROR>
+ (isolate, global, name);
+}
+
+EAPI
+void register_file_ls(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsFunction()
+ || !args[2]->IsFunction() || !args[3]->IsFunction()
+ || !args[4]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[4]);
+ cb_data[0] = persistent_t(isolate, args[1]);
+ cb_data[1] = persistent_t(isolate, args[2]);
+ cb_data[2] = persistent_t(isolate, args[3]);
+ cb_data[3] = persistent_t(isolate, args[4]);
+
+ auto filter_cb = [](void *data, Eio_File *handler, const char *file)
+ -> Eina_Bool {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<String>(isolate, file)
+ };
+
+ auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ auto bret = ret->IsBoolean() && ret->BooleanValue();
+ return bret ? EINA_TRUE : EINA_FALSE;
+ };
+ auto main_cb = [](void *data, Eio_File *handler, const char *file) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<String>(isolate, file)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ };
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 2;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] (persistent - 2);
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 3;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 3);
+ };
+
+ auto ret = eio_file_ls(*String::Utf8Value(args[0]), filter_cb, main_cb,
+ done_cb, error_cb, cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_file_chmod(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 4 || !args[0]->IsString() || !args[1]->IsNumber()
+ || !args[2]->IsFunction() || !args[3]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]);
+ cb_data[0] = persistent_t(isolate, args[2]);
+ cb_data[1] = persistent_t(isolate, args[3]);
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] persistent;
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 1);
+ };
+
+ auto ret = eio_file_chmod(*String::Utf8Value(args[0]),
+ args[1]->IntegerValue(), done_cb, error_cb,
+ cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_file_chown(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsString()
+ || !args[2]->IsString() || !args[3]->IsFunction()
+ || !args[4]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]);
+ cb_data[0] = persistent_t(isolate, args[3]);
+ cb_data[1] = persistent_t(isolate, args[4]);
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] persistent;
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 1);
+ };
+
+ auto ret = eio_file_chown(*String::Utf8Value(args[0]),
+ *String::Utf8Value(args[1]),
+ *String::Utf8Value(args[2]), done_cb,
+ error_cb,
+ cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_file_unlink(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 3 || !args[0]->IsString() || !args[1]->IsFunction()
+ || !args[2]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]);
+ cb_data[0] = persistent_t(isolate, args[1]);
+ cb_data[1] = persistent_t(isolate, args[2]);
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] persistent;
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 1);
+ };
+
+ auto ret = eio_file_unlink(*String::Utf8Value(args[0]), done_cb,
+ error_cb, cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_file_mkdir(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 4 || !args[0]->IsString() || !args[1]->IsNumber()
+ || !args[2]->IsString() || !args[3]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]);
+ cb_data[0] = persistent_t(isolate, args[2]);
+ cb_data[1] = persistent_t(isolate, args[3]);
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] persistent;
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 1);
+ };
+
+ auto ret = eio_file_mkdir(*String::Utf8Value(args[0]),
+ args[1]->IntegerValue(), done_cb, error_cb,
+ cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_file_move(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::Number;
+ using v8::Object;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsString()
+ || !args[2]->IsFunction() || !args[3]->IsFunction()
+ || !args[4]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[3]);
+ cb_data[0] = persistent_t(isolate, args[2]);
+ cb_data[1] = persistent_t(isolate, args[3]);
+ cb_data[2] = persistent_t(isolate, args[4]);
+ auto progress_cb = [](void *data, Eio_File *handler,
+ const Eio_Progress *info) {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ auto wrapped_info = compatibility_new<Object>(isolate);
+
+ wrapped_info->Set(compatibility_new<String>(isolate, "op"),
+ compatibility_new<Integer>(isolate, info->op));
+ wrapped_info->Set(compatibility_new<String>(isolate, "current"),
+ compatibility_new<Integer>(isolate,
+ info->current));
+ wrapped_info->Set(compatibility_new<String>(isolate, "max"),
+ compatibility_new<Integer>(isolate, info->max));
+ wrapped_info->Set(compatibility_new<String>(isolate, "percent"),
+ compatibility_new<Number>(isolate,
+ info->percent));
+ wrapped_info->Set(compatibility_new<String>(isolate, "source"),
+ compatibility_new<String>(isolate, info->source));
+ wrapped_info->Set(compatibility_new<String>(isolate, "dest"),
+ compatibility_new<String>(isolate, info->dest));
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrapped_info
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ };
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] (persistent - 1);
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 2;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 2);
+ };
+
+ auto ret = eio_file_move(*String::Utf8Value(args[0]),
+ *String::Utf8Value(args[1]),
+ progress_cb, done_cb, error_cb,
+ cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_file_copy(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::Number;
+ using v8::Object;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsString()
+ || !args[2]->IsFunction() || !args[3]->IsFunction()
+ || !args[4]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[3]);
+ cb_data[0] = persistent_t(isolate, args[2]);
+ cb_data[1] = persistent_t(isolate, args[3]);
+ cb_data[2] = persistent_t(isolate, args[4]);
+ auto progress_cb = [](void *data, Eio_File *handler,
+ const Eio_Progress *info) {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ auto wrapped_info = compatibility_new<Object>(isolate);
+
+ wrapped_info->Set(compatibility_new<String>(isolate, "op"),
+ compatibility_new<Integer>(isolate, info->op));
+ wrapped_info->Set(compatibility_new<String>(isolate, "current"),
+ compatibility_new<Integer>(isolate,
+ info->current));
+ wrapped_info->Set(compatibility_new<String>(isolate, "max"),
+ compatibility_new<Integer>(isolate, info->max));
+ wrapped_info->Set(compatibility_new<String>(isolate, "percent"),
+ compatibility_new<Number>(isolate,
+ info->percent));
+ wrapped_info->Set(compatibility_new<String>(isolate, "source"),
+ compatibility_new<String>(isolate, info->source));
+ wrapped_info->Set(compatibility_new<String>(isolate, "dest"),
+ compatibility_new<String>(isolate, info->dest));
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrapped_info
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ };
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] (persistent - 1);
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 2;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 2);
+ };
+
+ auto ret = eio_file_copy(*String::Utf8Value(args[0]),
+ *String::Utf8Value(args[1]),
+ progress_cb, done_cb, error_cb,
+ cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_dir_move(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::Number;
+ using v8::Object;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 6 || !args[0]->IsString() || !args[1]->IsString()
+ || !args[2]->IsFunction() || !args[3]->IsFunction()
+ || !args[4]->IsFunction() || !args[5]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[4]);
+ cb_data[0] = persistent_t(isolate, args[2]);
+ cb_data[1] = persistent_t(isolate, args[3]);
+ cb_data[2] = persistent_t(isolate, args[4]);
+ cb_data[3] = persistent_t(isolate, args[5]);
+ auto filter_cb = [](void *data, Eio_File *handler,
+ const Eina_File_Direct_Info *info) -> Eina_Bool {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrap_eina_file_direct_info(info, isolate)
+ };
+
+ auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ auto bret = ret->IsBoolean() && ret->BooleanValue();
+ return bret ? EINA_TRUE : EINA_FALSE;
+ };
+ auto progress_cb = [](void *data, Eio_File *handler,
+ const Eio_Progress *info) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ auto wrapped_info = compatibility_new<Object>(isolate);
+
+ wrapped_info->Set(compatibility_new<String>(isolate, "op"),
+ compatibility_new<Integer>(isolate, info->op));
+ wrapped_info->Set(compatibility_new<String>(isolate, "current"),
+ compatibility_new<Integer>(isolate,
+ info->current));
+ wrapped_info->Set(compatibility_new<String>(isolate, "max"),
+ compatibility_new<Integer>(isolate, info->max));
+ wrapped_info->Set(compatibility_new<String>(isolate, "percent"),
+ compatibility_new<Number>(isolate,
+ info->percent));
+ wrapped_info->Set(compatibility_new<String>(isolate, "source"),
+ compatibility_new<String>(isolate, info->source));
+ wrapped_info->Set(compatibility_new<String>(isolate, "dest"),
+ compatibility_new<String>(isolate, info->dest));
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrapped_info
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ };
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 2;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] (persistent - 2);
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 3;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 3);
+ };
+
+ auto ret = eio_dir_move(*String::Utf8Value(args[0]),
+ *String::Utf8Value(args[1]), filter_cb,
+ progress_cb, done_cb, error_cb,
+ cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_dir_copy(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::Number;
+ using v8::Object;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 6 || !args[0]->IsString() || !args[1]->IsString()
+ || !args[2]->IsFunction() || !args[3]->IsFunction()
+ || !args[4]->IsFunction() || !args[5]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[4]);
+ cb_data[0] = persistent_t(isolate, args[2]);
+ cb_data[1] = persistent_t(isolate, args[3]);
+ cb_data[2] = persistent_t(isolate, args[4]);
+ cb_data[3] = persistent_t(isolate, args[5]);
+ auto filter_cb = [](void *data, Eio_File *handler,
+ const Eina_File_Direct_Info *info) -> Eina_Bool {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrap_eina_file_direct_info(info, isolate)
+ };
+
+ auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ auto bret = ret->IsBoolean() && ret->BooleanValue();
+ return bret ? EINA_TRUE : EINA_FALSE;
+ };
+ auto progress_cb = [](void *data, Eio_File *handler,
+ const Eio_Progress *info) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ auto wrapped_info = compatibility_new<Object>(isolate);
+
+ wrapped_info->Set(compatibility_new<String>(isolate, "op"),
+ compatibility_new<Integer>(isolate, info->op));
+ wrapped_info->Set(compatibility_new<String>(isolate, "current"),
+ compatibility_new<Integer>(isolate,
+ info->current));
+ wrapped_info->Set(compatibility_new<String>(isolate, "max"),
+ compatibility_new<Integer>(isolate, info->max));
+ wrapped_info->Set(compatibility_new<String>(isolate, "percent"),
+ compatibility_new<Number>(isolate,
+ info->percent));
+ wrapped_info->Set(compatibility_new<String>(isolate, "source"),
+ compatibility_new<String>(isolate, info->source));
+ wrapped_info->Set(compatibility_new<String>(isolate, "dest"),
+ compatibility_new<String>(isolate, info->dest));
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrapped_info
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ };
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 2;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] (persistent - 2);
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 3;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 3);
+ };
+
+ auto ret = eio_dir_copy(*String::Utf8Value(args[0]),
+ *String::Utf8Value(args[1]), filter_cb,
+ progress_cb, done_cb, error_cb,
+ cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+EAPI
+void register_dir_unlink(v8::Isolate *isolate, v8::Handle<v8::Object> global,
+ v8::Handle<v8::String> name)
+{
+ using v8::String;
+ using v8::Integer;
+ using v8::Number;
+ using v8::Object;
+ using v8::FunctionTemplate;
+ using v8::Handle;
+ using v8::Value;
+ using v8::Function;
+ using std::unique_ptr;
+
+ typedef efl::eina::js::global_ref<Value> persistent_t;
+
+ auto f = [](compatibility_callback_info_type args)
+ -> compatibility_return_type {
+ if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsFunction()
+ || !args[2]->IsFunction() || !args[3]->IsFunction()
+ || !args[4]->IsFunction()) {
+ return compatibility_return();
+ }
+
+ auto isolate = args.GetIsolate();
+
+ auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[4]);
+ cb_data[0] = persistent_t(isolate, args[1]);
+ cb_data[1] = persistent_t(isolate, args[2]);
+ cb_data[2] = persistent_t(isolate, args[3]);
+ cb_data[3] = persistent_t(isolate, args[4]);
+ auto filter_cb = [](void *data, Eio_File *handler,
+ const Eina_File_Direct_Info *info) -> Eina_Bool {
+ auto persistent = reinterpret_cast<persistent_t*>(data);
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrap_eina_file_direct_info(info, isolate)
+ };
+
+ auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ auto bret = ret->IsBoolean() && ret->BooleanValue();
+ return bret ? EINA_TRUE : EINA_FALSE;
+ };
+ auto progress_cb = [](void *data, Eio_File *handler,
+ const Eio_Progress *info) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 1;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ auto wrapped_info = compatibility_new<Object>(isolate);
+
+ wrapped_info->Set(compatibility_new<String>(isolate, "op"),
+ compatibility_new<Integer>(isolate, info->op));
+ wrapped_info->Set(compatibility_new<String>(isolate, "current"),
+ compatibility_new<Integer>(isolate,
+ info->current));
+ wrapped_info->Set(compatibility_new<String>(isolate, "max"),
+ compatibility_new<Integer>(isolate, info->max));
+ wrapped_info->Set(compatibility_new<String>(isolate, "percent"),
+ compatibility_new<Number>(isolate,
+ info->percent));
+ wrapped_info->Set(compatibility_new<String>(isolate, "source"),
+ compatibility_new<String>(isolate, info->source));
+ wrapped_info->Set(compatibility_new<String>(isolate, "dest"),
+ compatibility_new<String>(isolate, info->dest));
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ wrapped_info
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+ };
+ auto done_cb = [](void *data, Eio_File *handler) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 2;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args = wrap_eio_file(handler, isolate);
+
+ Function::Cast(*o)->Call(o->ToObject(), 1, &args);
+
+ delete[] (persistent - 2);
+ };
+ auto error_cb = [](void *data, Eio_File *handler, int error) {
+ auto persistent = reinterpret_cast<persistent_t*>(data) + 3;
+ auto o = persistent->handle();
+
+ auto isolate = v8::Isolate::GetCurrent();
+
+ Handle<Value> args[2] = {
+ wrap_eio_file(handler, isolate),
+ compatibility_new<Integer>(isolate, error)
+ };
+
+ Function::Cast(*o)->Call(o->ToObject(), 2, args);
+
+ delete[] (persistent - 3);
+ };
+
+ auto ret = eio_dir_unlink(*String::Utf8Value(args[0]), filter_cb,
+ progress_cb, done_cb, error_cb,
+ cb_data.release());
+ return compatibility_return(wrap_eio_file(ret, isolate), args);
+ };
+
+ global->Set(name,
+ compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
+}
+
+}
+
+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,
+ compatibility_new<String>(isolate,
+ "EIO_FILE_GETPWNAM"));
+ register_op_file_getgrnam(isolate, exports,
+ 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,
+ compatibility_new<String>(isolate,
+ "EIO_MONITOR_FILE"
+ "_CREATED"));
+ register_monitor_file_deleted(isolate, exports,
+ compatibility_new<String>(isolate,
+ "EIO_MONITOR_FILE"
+ "_DELETED"));
+ register_monitor_file_modified(isolate, exports,
+ compatibility_new<String>(isolate,
+ "EIO_MONITOR_FILE"
+ "_MODIFIED"));
+ register_monitor_file_closed(isolate, exports,
+ compatibility_new<String>(isolate,
+ "EIO_MONITOR_FILE"
+ "_CLOSED"));
+ register_monitor_directory_created(isolate, exports,
+ compatibility_new<String>
+ (isolate,
+ "EIO_MONITOR_DIRECTORY_CREATED"));
+ register_monitor_directory_deleted(isolate, exports,
+ compatibility_new<String>
+ (isolate,
+ "EIO_MONITOR_DIRECTORY_DELETED"));
+ register_monitor_directory_modified(isolate, exports,
+ compatibility_new<String>
+ (isolate,
+ "EIO_MONITOR_DIRECTORY_MODIFIED"));
+ register_monitor_directory_closed(isolate, exports,
+ compatibility_new<String>
+ (isolate, "EIO_MONITOR_DIRECTORY_CLOSED"));
+ register_monitor_self_rename(isolate, exports,
+ compatibility_new<String>
+ (isolate, "EIO_MONITOR_SELF_RENAME"));
+ register_monitor_self_deleted(isolate, exports,
+ compatibility_new<String>
+ (isolate, "EIO_MONITOR_SELF_DELETED"));
+ register_monitor_error(isolate, exports,
+ compatibility_new<String>(isolate,
+ "EIO_MONITOR_ERROR"));
+ register_monitor_add(isolate, exports,
+ compatibility_new<String>(isolate, "eio_monitor_add"));
+ register_event_monitor_file_created_handler_add
+ (isolate, exports,
+ compatibility_new<String>(isolate,
+ "eio_event_monitor_file_created_handler_add"));
+ register_event_monitor_file_deleted_handler_add
+ (isolate, exports,
+ compatibility_new<String>(isolate,
+ "eio_event_monitor_file_deleted_handler_add"));
+ register_event_monitor_file_modified_handler_add
+ (isolate, exports,
+ compatibility_new<String>
+ (isolate, "eio_event_monitor_file_modified_handler_add"));
+ register_event_monitor_file_closed_handler_add
+ (isolate, exports,
+ compatibility_new<String>(isolate,
+ "eio_event_monitor_file_closed_handler_add"));
+ register_event_monitor_directory_created_handler_add
+ (isolate, exports,
+ compatibility_new<String>
+ (isolate, "eio_event_monitor_directory_created_handler_add"));
+ register_event_monitor_directory_deleted_handler_add
+ (isolate, exports,
+ compatibility_new<String>
+ (isolate, "eio_event_monitor_directory_deleted_handler_add"));
+ register_event_monitor_directory_modified_handler_add
+ (isolate, exports,
+ compatibility_new<String>
+ (isolate, "eio_event_monitor_directory_modified_handler_add"));
+ register_event_monitor_directory_closed_handler_add
+ (isolate, exports,
+ compatibility_new<String>
+ (isolate, "eio_event_monitor_directory_closed_handler_add"));
+ register_event_monitor_self_rename_handler_add
+ (isolate, exports,
+ compatibility_new<String>(isolate,
+ "eio_event_monitor_self_rename_handler_add"));
+ register_event_monitor_self_deleted_handler_add
+ (isolate, exports,
+ compatibility_new<String>(isolate,
+ "eio_event_monitor_self_deleted_handler_add"));
+ register_event_monitor_error_handler_add
+ (isolate, exports,
+ 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"));
+}
+
+} } } // namespace efl { namespace eio { namespace js {