1757 lines
63 KiB
C++
1757 lines
63 KiB
C++
#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;
|
|
|
|
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, "getPath"),
|
|
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, "pathLength"),
|
|
compatibility_new<Integer>(isolate, info->path_length));
|
|
wrapped_info->Set(compatibility_new<String>(isolate, "nameLength"),
|
|
compatibility_new<Integer>(isolate, info->name_length));
|
|
wrapped_info->Set(compatibility_new<String>(isolate, "nameStart"),
|
|
compatibility_new<Integer>(isolate, info->name_start));
|
|
wrapped_info->Set(compatibility_new<String>(isolate, "type"),
|
|
compatibility_new<Integer>(isolate, info->type));
|
|
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;
|
|
auto eioNamespace = efl::eo::js::get_namespace({"Eio"}, isolate, exports);
|
|
register_init(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "init"));
|
|
register_shutdown(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "shutdown"));
|
|
register_op_file_copy(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "FILE_COPY"));
|
|
register_op_file_move(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "FILE_MOVE"));
|
|
register_op_dir_copy(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "DIR_COPY"));
|
|
register_op_dir_move(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "DIR_MOVE"));
|
|
register_op_unlink(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "UNLINK"));
|
|
register_op_file_getpwnam(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"FILE_GETPWNAM"));
|
|
register_op_file_getgrnam(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"FILE_GETGRNAM"));
|
|
register_file_open(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "openFile"));
|
|
register_monitor_file_created(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"MONITOR_FILE"
|
|
"_CREATED"));
|
|
register_monitor_file_deleted(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"MONITOR_FILE"
|
|
"_DELETED"));
|
|
register_monitor_file_modified(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"MONITOR_FILE"
|
|
"_MODIFIED"));
|
|
register_monitor_file_closed(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"MONITOR_FILE"
|
|
"_CLOSED"));
|
|
register_monitor_directory_created(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate,
|
|
"MONITOR_DIRECTORY_CREATED"));
|
|
register_monitor_directory_deleted(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate,
|
|
"MONITOR_DIRECTORY_DELETED"));
|
|
register_monitor_directory_modified(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate,
|
|
"MONITOR_DIRECTORY_MODIFIED"));
|
|
register_monitor_directory_closed(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate, "MONITOR_DIRECTORY_CLOSED"));
|
|
register_monitor_self_rename(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate, "MONITOR_SELF_RENAME"));
|
|
register_monitor_self_deleted(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate, "MONITOR_SELF_DELETED"));
|
|
register_monitor_error(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"MONITOR_ERROR"));
|
|
register_monitor_add(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "addMonitor"));
|
|
register_event_monitor_file_created_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"addEventMonitorFileCreatedHandler"));
|
|
register_event_monitor_file_deleted_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"addEventMonitorFileDeletedHandler"));
|
|
register_event_monitor_file_modified_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate, "addEventMonitorFileModifiedHandler"));
|
|
register_event_monitor_file_closed_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"addEventMonitorFileClosedHandler"));
|
|
register_event_monitor_directory_created_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate, "addEventMonitorDirectoryCreatedHandler"));
|
|
register_event_monitor_directory_deleted_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate, "addEventMonitorDirectoryDeletedHandler"));
|
|
register_event_monitor_directory_modified_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate, "addEventMonitorDirectoryModifiedHandler"));
|
|
register_event_monitor_directory_closed_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>
|
|
(isolate, "addEventMonitorDirectoryClosedHandler"));
|
|
register_event_monitor_self_rename_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"addEventMonitorSelfRenameHandler"));
|
|
register_event_monitor_self_deleted_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"addEventMonitorSelfDeletedHandler"));
|
|
register_event_monitor_error_handler_add
|
|
(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate,
|
|
"addEventMonitorErrorHandler"));
|
|
register_file_ls(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "lsFile"));
|
|
register_file_chmod(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "chmodFile"));
|
|
register_file_chown(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "chownFile"));
|
|
register_file_unlink(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "unlinkFile"));
|
|
register_file_mkdir(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "mkdirFile"));
|
|
register_file_move(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "moveFile"));
|
|
register_file_copy(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "copyFile"));
|
|
register_dir_move(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "moveDir"));
|
|
register_dir_copy(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "copyDir"));
|
|
register_dir_unlink(isolate, eioNamespace,
|
|
compatibility_new<String>(isolate, "unlinkDir"));
|
|
}
|
|
|
|
} } } // namespace efl { namespace eio { namespace js {
|