Пример #1
0
	void Purge()
	{
		if (!bAbandoned)
		{
			bAbandoned = true;

			WrappedObject.Reset();

			ClearDelegateObjects();

			context_.Reset();
		}
	}
Пример #2
0
void ObjectManager::CheckWeakObjectsAreAlive(const vector<PersistentObjectIdPair>& instances, DirectBuffer& inputBuff, DirectBuffer& outputBuff)
{
	JEnv env;

	for (const auto& poIdPair : instances)
	{
		int javaObjectId = poIdPair.javaObjectId;

		bool success = inputBuff.Write(javaObjectId);

		if (!success)
		{
			int length = inputBuff.Length();
			env.CallStaticVoidMethod(PlatformClass, CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID, (jobject) inputBuff, (jobject) outputBuff, length);
			//
			int *released = outputBuff.GetData();
			for (int i = 0; i < length; i++)
			{
				bool isReleased = *released++ != 0;

				if (isReleased)
				{
					Persistent<Object> *po = instances[i].po;
					po->Reset();
				}
			}
			//
			inputBuff.Reset();
			success = inputBuff.Write(javaObjectId);
			assert(success);
		}
	}
	int size = inputBuff.Size();
	if (size > 0)
	{
		env.CallStaticVoidMethod(PlatformClass, CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID, (jobject) inputBuff, (jobject) outputBuff, size);
		int *released = outputBuff.GetData();
		for (int i = 0; i < size; i++)
		{
			bool isReleased = *released++ != 0;

			if (isReleased)
			{
				Persistent<Object> *po = instances[i].po;
				po->Reset();
			}
		}
	}

}
Пример #3
0
extern "C" void Java_io_neft_Native_renderer_1callAnimationFrame(JNIEnv * env, jobject obj) {
    using namespace renderer;

    // enter isolate
    Isolate* isolate = JS::GetIsolate();
    Locker locker(isolate);
    Isolate::Scope isolate_scope(isolate);
    HandleScope handle_scope(isolate);

    // get local context and enter it
    Local<Context> context = Local<Context>::New(isolate, JS::GetContext());
    Context::Scope context_scope(context);

    // call all registered functions
    const int length = animationFrameCalls.size();
    for (int i = 0; i < length; i++){
        Persistent<Function, CopyablePersistentTraits<Function>> func = animationFrameCalls[i];

        // get local function
        Local<Function> localFunc = Local<Function>::New(isolate, func);

        // call function
        localFunc->Call(context->Global(), 0, NULL);

        // clear persistent
        func.Reset();
    }

    // remove called functions
    animationFrameCalls.erase(animationFrameCalls.begin(), animationFrameCalls.begin() + length);
}
Пример #4
0
void onConnection(const FunctionCallbackInfo<Value> &args) {
    uWS::Server *server = (uWS::Server *) args.Holder()->GetAlignedPointerFromInternalField(0);
    Isolate *isolate = args.GetIsolate();
    Persistent<Function> *connectionCallback = (Persistent<Function> *) args.Holder()->GetAlignedPointerFromInternalField(CONNECTION_CALLBACK);
    connectionCallback->Reset(isolate, Local<Function>::Cast(args[0]));
    server->onConnection([isolate, connectionCallback](uWS::Socket socket) {
        HandleScope hs(isolate);
        Local<Value> argv[] = {wrapSocket(socket, isolate)};
        node::MakeCallback(isolate, isolate->GetCurrentContext()->Global(), Local<Function>::New(isolate, *connectionCallback), 1, argv);
    });
}
Пример #5
0
void Shape::New(const v8::FunctionCallbackInfo<Value>& args)
{
  HandleScope scope;
  Handle<Object> self = args.Holder();
  Shape *shape;

  if (args[0]->IsExternal())
  {
    Local<External> ext = Local<External>::Cast(args[0]);
    void *ptr = ext->Value();
    shape = static_cast<Shape*>(ptr);
    shape->Wrap(args.Holder());
  }
  else
  {
    shapeObj *s = (shapeObj *)msSmallMalloc(sizeof(shapeObj));

    msInitShape(s);
    if(args.Length() >= 1) {
      s->type = args[0]->Int32Value();
    }
    else {
      s->type = MS_SHAPE_NULL;
    }

    shape = new Shape(s);
    shape->Wrap(self);
  }

  /* create the attribute template. should use ObjectWrap in future */
  Handle<ObjectTemplate> attributes_templ = ObjectTemplate::New();
  attributes_templ->SetInternalFieldCount(2);
  attributes_templ->SetNamedPropertyHandler(attributeGetValue,
                                            attributeSetValue);
  Handle<Object> attributes = attributes_templ->NewInstance();
  map<string, int> *attributes_map = new map<string, int>();
  attributes->SetInternalField(0, External::New(attributes_map));
  attributes->SetInternalField(1, External::New(shape->get()->values));  
  attributes->SetHiddenValue(String::New("__parent__"), self);

  if (shape->layer) {
    for (int i=0; i<shape->layer->numitems; ++i) {
      (*attributes_map)[string(shape->layer->items[i])] = i;
    }
  }

  Persistent<Object> pattributes;
  pattributes.Reset(Isolate::GetCurrent(), attributes);
  pattributes.MakeWeak(attributes_map, attributeWeakCallback);
  pattributes.MarkIndependent();

  self->Set(String::New("attributes"), attributes);
}
Пример #6
0
void on(const FunctionCallbackInfo<Value> &args)
{
    lws::Server *server = (lws::Server *) args.Holder()->GetAlignedPointerFromInternalField(0);
    Isolate *isolate = args.GetIsolate();

    String::Utf8Value eventName(args[0]->ToString());
    if (!strncmp(*eventName, "error", eventName.length()) && !server) {
        Local<Function>::Cast(args[1])->Call(Null(isolate), 0, nullptr);
    }
    else if (server && !strncmp(*eventName, "connection", eventName.length())) {
        connectionCallback.Reset(isolate, Local<Function>::Cast(args[1]));
        server->onConnection([isolate](lws::Socket socket) {
            *socket.getUser() = nullptr;
            HandleScope hs(isolate);
            Local<Value> argv[] = {wrapSocket(&socket, isolate)->Clone()};
            Local<Function>::New(isolate, connectionCallback)->Call(Null(isolate), 1, argv);
        });
    }
    else if (server && !strncmp(*eventName, "close", eventName.length())) {
        closeCallback.Reset(isolate, Local<Function>::Cast(args[1]));
        server->onDisconnection([isolate](lws::Socket socket) {
            HandleScope hs(isolate);
            Local<Value> argv[] = {wrapSocket(&socket, isolate)};
            Local<Function>::New(isolate, closeCallback)->Call(Null(isolate), 1, argv);
            delete ((string *) *socket.getUser());
        });
    }
    else if (server && !strncmp(*eventName, "message", eventName.length())) {
        messageCallback.Reset(isolate, Local<Function>::Cast(args[1]));
        server->onMessage([isolate](lws::Socket socket, char *data, size_t length, bool binary) {
            HandleScope hs(isolate);
            Local<Value> argv[] = {wrapSocket(&socket, isolate),
                                   /*ArrayBuffer::New(isolate, data, length)*/
                                   node::Buffer::New(isolate, data, length, [](char *data, void *hint) {}, nullptr).ToLocalChecked(),
                                   Boolean::New(isolate, binary)};
            Local<Function>::New(isolate, messageCallback)->Call(Null(isolate), 3, argv);
        });
    }
}
Пример #7
0
void MySQL::JS_Query(const FunctionCallbackInfo<Value> & args){
	auto mysql = Instance(args.Holder());
	auto mysqlconn = ConnectionInstance(args.Holder());

	string query = JS2STRING(args[0]);

	if (args[1]->IsFunction()){
		Persistent<Function, CopyablePersistentTraits<Function>> func;
		func.Reset(args.GetIsolate(), Local<Function>::Cast(args[1]));
		mysql->QueryAsync(mysqlconn->id, query, func);
		return;
	}
}
Пример #8
0
void onDisconnection(const FunctionCallbackInfo<Value> &args) {
    uWS::Server *server = (uWS::Server *) args.Holder()->GetAlignedPointerFromInternalField(0);
    Isolate *isolate = args.GetIsolate();
    Persistent<Function> *disconnectionCallback = (Persistent<Function> *) args.Holder()->GetAlignedPointerFromInternalField(DISCONNECTION_CALLBACK);
    disconnectionCallback->Reset(isolate, Local<Function>::Cast(args[0]));
    server->onDisconnection([isolate, disconnectionCallback](uWS::Socket socket, int code, char *message, size_t length) {
        HandleScope hs(isolate);
        Local<Value> argv[] = {wrapSocket(socket, isolate),
                               Integer::New(isolate, code),
                               node::Buffer::New(isolate, (char *) message, length, [](char *data, void *hint) {}, nullptr).ToLocalChecked(),
                               getDataV8(socket, isolate)};
        node::MakeCallback(isolate, isolate->GetCurrentContext()->Global(), Local<Function>::New(isolate, *disconnectionCallback), 4, argv);
    });
}
Пример #9
0
void onMessage(const FunctionCallbackInfo<Value> &args) {
    uWS::Server *server = (uWS::Server *) args.Holder()->GetAlignedPointerFromInternalField(0);
    Isolate *isolate = args.GetIsolate();
    Persistent<Function> *messageCallback = (Persistent<Function> *) args.Holder()->GetAlignedPointerFromInternalField(MESSAGE_CALLBACK);
    messageCallback->Reset(isolate, Local<Function>::Cast(args[0]));
    server->onMessage([isolate, messageCallback](uWS::Socket socket, const char *message, size_t length, uWS::OpCode opCode) {
        HandleScope hs(isolate);
        Local<Value> argv[] = {wrapSocket(socket, isolate),
                               node::Buffer::New(isolate, (char *) message, length, [](char *data, void *hint) {}, nullptr).ToLocalChecked(),
                               Boolean::New(isolate, opCode == BINARY),
                               getDataV8(socket, isolate)};
        node::MakeCallback(isolate, isolate->GetCurrentContext()->Global(), Local<Function>::New(isolate, *messageCallback), 4, argv);
    });
}
Пример #10
0
void udeb_setLogger(const Arguments &args) {
  EscapableHandleScope scope(args.GetIsolate());

  if(! udeb_initialized) {
    JSLoggerFunction.Reset(args.GetIsolate(), args[0]->ToObject());
    // JSLoggerFunction.Reset(Function::Cast(* (args[0])));
    // Local<Function> f = Function::Cast(* (args[0]));
    // JSLoggerFunction = Persistent<Function>::New(f);
    udeb_initialized = 1;

    udeb_print("unified_debug.cpp", UDEB_DEBUG, 
               "unified_debug.cpp C++ unified_debug enabled");
  }
  args.GetReturnValue().Set(true);
}
Пример #11
0
Handle<Object> Log::Wrap()
{
	Isolate *isolate = jsCompiler_.GetIsolate();
	HandleScope scope(isolate);

	if (logTemplate.IsEmpty()) {
		Handle<ObjectTemplate> objTemplate = MakeLogTemplate(isolate);
		logTemplate.Reset(isolate, objTemplate);
	}
	Handle<ObjectTemplate> local = Local<ObjectTemplate>::New(isolate, logTemplate);
	Handle<Object> obj = local->NewInstance();
	Handle<External> log_ptr = External::New(this);
	obj->SetInternalField(0, log_ptr);
	return scope.Close(obj);
}
Пример #12
0
void Init(Isolate * isolate)
{
	Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
	tpl->SetClassName(v8::String::NewFromUtf8(isolate, "Transformable"));
	tpl->InstanceTemplate()->SetInternalFieldCount(2);
	Local<ObjectTemplate> proto = tpl->PrototypeTemplate();
//	proto->SetInternalFieldCount(1);
	proto->SetAccessor(v8::String::NewFromUtf8(isolate, "x"), GetX, SetX);
	proto->SetAccessor(v8::String::NewFromUtf8(isolate, "y"), GetY, SetY);
	proto->SetAccessor(v8::String::NewFromUtf8(isolate, "rotation"), GetRotation, SetRotation);
	proto->SetAccessor(v8::String::NewFromUtf8(isolate, "scaleX"), GetScaleX, SetScaleX);
	proto->SetAccessor(v8::String::NewFromUtf8(isolate, "scaleY"), GetScaleY, SetScaleY);
	proto->SetAccessor(v8::String::NewFromUtf8(isolate, "originX"), GetOriginX, SetOriginX);
	proto->SetAccessor(v8::String::NewFromUtf8(isolate, "originY"), GetOriginY, SetOriginY);
	tpl_ref.Reset(isolate, tpl);
}
Пример #13
0
void Main(Local<Object> exports)
{
    Isolate *isolate = exports->GetIsolate();
    Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, constructor);
    tpl->InstanceTemplate()->SetInternalFieldCount(1);

    NODE_SET_PROTOTYPE_METHOD(tpl, "on", on);
    NODE_SET_PROTOTYPE_METHOD(tpl, "send", send);
    NODE_SET_PROTOTYPE_METHOD(tpl, "setUserData", setUserData);
    NODE_SET_PROTOTYPE_METHOD(tpl, "getUserData", getUserData);
    NODE_SET_PROTOTYPE_METHOD(tpl, "getFd", getFd);

    exports->Set(String::NewFromUtf8(isolate, "Server"), tpl->GetFunction());

    Local<ObjectTemplate> socketTemplate = ObjectTemplate::New(isolate);
    socketTemplate->SetInternalFieldCount(2);
    persistentSocket.Reset(isolate, socketTemplate->NewInstance());
}
Пример #14
0
    ~executeBaton() {
        obj = NULL;
        // the StmtObject will free sqlany_stmt
        sqlany_stmt = NULL;
        CLEAN_STRINGS( string_vals );
        CLEAN_STRINGS( colNames );
        CLEAN_NUMS( num_vals );
        CLEAN_NUMS( int_vals );
        CLEAN_NUMS( string_len );
        col_types.clear();
        callback.Reset();

        for( size_t i = 0; i < params.size(); i++ ) {
            if( params[i].value.is_null != NULL ) {
                delete params[i].value.is_null;
                params[i].value.is_null = NULL;
            }
        }
        params.clear();
    }
Пример #15
0
/* Execute a javascript file */
static Handle<Value> msV8ExecuteScript(const char *path, int throw_exception = MS_FALSE)
{
  char fullpath[MS_MAXPATHLEN];
  map<string, Persistent<Script> >::iterator it;
  Isolate *isolate = Isolate::GetCurrent();
  V8Context *v8context = (V8Context*)isolate->GetData();

  /* construct the path */
  msBuildPath(fullpath, v8context->paths.top().c_str(), path);
  char *filepath = msGetPath((char*)fullpath);
  v8context->paths.push(filepath);
  free(filepath);

  Handle<Script> script;
  it = v8context->scripts.find(fullpath);
  if (it == v8context->scripts.end()) {
    Handle<Value> source = msV8ReadFile(v8context, fullpath);
    Handle<String> script_name = String::New(msStripPath((char*)path));
    script = msV8CompileScript(source->ToString(), script_name);
    if (script.IsEmpty()) {
      v8context->paths.pop();
      if (throw_exception) {
        return ThrowException(String::New("Error compiling script"));
      }
    }
    /* cache the compiled script */
    Persistent<Script> pscript;
    pscript.Reset(isolate, script);
    v8context->scripts[fullpath] = pscript;
  } else {
    script = v8context->scripts[fullpath];
  }

  Handle<Value> result = msV8RunScript(script);
  v8context->paths.pop();
  if (result.IsEmpty() && throw_exception) {
    return ThrowException(String::New("Error running script"));
  }

  return result;
}
Пример #16
0
void executeAfter( uv_work_t *req )
/*********************************/
{
    Isolate *isolate = Isolate::GetCurrent();
    HandleScope scope( isolate );
    executeBaton *baton = static_cast<executeBaton*>( req->data );
    Persistent<Value> ResultSet;
    fillResult( baton, ResultSet );
    ResultSet.Reset();

    scoped_lock	lock( baton->obj->conn_mutex );

    if( baton->sqlany_stmt != NULL && baton->prepared_stmt ) {
        if( api.initialized ) {
            api.sqlany_free_stmt( baton->sqlany_stmt );
        }
        baton->sqlany_stmt = NULL;
    }

    delete baton;
    delete req;
}
Пример #17
0
void MySQL::JS_Connect(const FunctionCallbackInfo<Value> & args){
	auto mysql = Instance(args.Holder());
	auto mysqlconn = ConnectionInstance(args.Holder());
	
	string host = JS2STRING(args[0]);
	string user = JS2STRING(args[1]);
	string password = JS2STRING(args[2]);
	string database = JS2STRING(args[3]);

	if (args[4]->IsFunction()){
		Persistent<Function,CopyablePersistentTraits<Function>> func;
		func.Reset(args.GetIsolate(), Local<Function>::Cast(args[4]));

		thread( [mysql, mysqlconn, host, user, password, database,func](){
			mysql_thread_init();
			std::lock_guard<std::mutex> lock{ mysqlconn->lock };
			mysql->ConnectAsync(mysqlconn->id, host, user, password, database,func);
			mysql_thread_end();
		}).detach();
	}
	else {
		if (mysql_real_connect(
			mysqlconn->mysql,
			host.c_str(),
			user.c_str(),
			password.c_str(),
			database.c_str(),
			0,
			NULL,
			0) == NULL){
			sjs::logger::error("MySQL Connect Error: %s", mysql_error(mysqlconn->mysql));
			args.GetReturnValue().Set(false);
			return;
		}
	}
	args.GetReturnValue().Set(true);
}
Пример #18
0
void Main(Local<Object> exports) {
    Isolate *isolate = exports->GetIsolate();
    Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, ::Server);
    tpl->InstanceTemplate()->SetInternalFieldCount(4);

    NODE_SET_PROTOTYPE_METHOD(tpl, "onConnection", onConnection);
    NODE_SET_PROTOTYPE_METHOD(tpl, "onMessage", onMessage);
    NODE_SET_PROTOTYPE_METHOD(tpl, "onDisconnection", onDisconnection);
    NODE_SET_PROTOTYPE_METHOD(tpl, "close", close);
    NODE_SET_PROTOTYPE_METHOD(tpl, "broadcast", broadcast);
    NODE_SET_PROTOTYPE_METHOD(tpl, "upgrade", upgrade);
    NODE_SET_PROTOTYPE_METHOD(tpl, "transfer", transfer);

    NODE_SET_PROTOTYPE_METHOD(tpl, "setData", setData);
    NODE_SET_PROTOTYPE_METHOD(tpl, "getData", getData);
    NODE_SET_PROTOTYPE_METHOD(tpl, "send", send);
    NODE_SET_PROTOTYPE_METHOD(tpl, "getAddress", getAddress);

    exports->Set(String::NewFromUtf8(isolate, "Server"), tpl->GetFunction());

    Local<ObjectTemplate> ticketTemplate = ObjectTemplate::New(isolate);
    ticketTemplate->SetInternalFieldCount(2);
    persistentTicket.Reset(isolate, ticketTemplate->NewInstance());
}
Пример #19
0
 ~connectBaton() {
     obj = NULL;
     sqlca = NULL;
     callback.Reset();
 }
Пример #20
0
void MySQL::QueryAsync(int id, string query, Persistent<Function, CopyablePersistentTraits<Function>> callback){
	

	// We need to do this or for some reason it loses its persistence and goes out of scope :(
	Persistent<Function, CopyablePersistentTraits<Function>> cb;
	cb.Reset(isolate, callback);

	thread( [this, id, cb, query](){
		mysql_thread_init();
		std::lock_guard<std::mutex> lock{ connections[id]->lock };
		MYSQL* msql = connections[id]->mysql;
		if (!isConnected(msql)){
			sjs::logger::error("MYSQL Error: Not connected");
		} else {
			mysql_query(msql, query.c_str());

			unsigned int err_no = mysql_errno(msql);
			if (err_no){
				sjs::logger::error("MYSQL Query Error: %s", mysql_error(msql));
				V8PCONTEXT(isolate, context);

				TryCatch try_catch;

				Local<String> err = String::NewFromUtf8(isolate, mysql_error(msql));
				Local<Value> argv[1] = { err };
				Local<Function> func = Local<Function>::New(isolate, cb);
				func->Call(func, 1, argv);
				if (try_catch.HasCaught()){
					Utils::PrintException(&try_catch);
				}
				mysql_thread_end();
				return;
			}

			MYSQL_RES *result = mysql_store_result(msql);

			if (result == NULL){

				// No error and result was null meaning it wasn't a SELECT type statement
				my_ulonglong affected = mysql_affected_rows(msql);
				my_ulonglong insert_id = mysql_insert_id(msql);


				V8PCONTEXT(isolate, context);
				TryCatch try_catch;
				JS_Object jsresult(isolate);

				jsresult.Set("insertId", insert_id);
				jsresult.Set("affectedRows", affected);

				Local<Value> empty = Undefined(isolate);
				Local<Value> argv[2] = { empty, jsresult.get() };

				Local<Function> func = Local<Function>::New(isolate, cb);


				func->Call(func, 2, argv);
				if (try_catch.HasCaught()){
					Utils::PrintException(&try_catch);
				}


			}
			else {
				int num_fields = mysql_num_fields(result);

				MYSQL_ROW row;
				MYSQL_FIELD *field;

				vector<string> fields;


				V8PCONTEXT(isolate, context);
				TryCatch try_catch;
				Local<Array> jsrows = Array::New(isolate, 0);
				Local<Array> jsfields = Array::New(isolate, num_fields);

				for (int j = 0; j < num_fields; j++){
					field = mysql_fetch_field_direct(result, j);
					fields.push_back(field->name);
					jsfields->Set(j, String::NewFromUtf8(isolate, field->name));
				}

				int row_count = 0;
				while ((row = mysql_fetch_row(result))){
					JS_Object jsrow(isolate);
					for (int i = 0; i < num_fields; i++){

						if (row[i] == NULL) jsrow.SetNull(fields[i]);
						else jsrow.Set(fields[i], string(row[i]));

					}

					jsrows->Set(row_count++, jsrow.get());
				}

				Local<Value> empty = Undefined(isolate);
				Local<Value> argv[3] = { empty, jsrows, jsfields };

				Local<Function> func = Local<Function>::New(isolate, cb);

				func->Call(func, 3, argv);
				if (try_catch.HasCaught()){
					Utils::PrintException(&try_catch);
				}

				mysql_free_result(result);

			}
		}
		mysql_thread_end();
	}).detach();
}
Пример #21
0
void Finalize()
{
	tpl_ref.Reset();
}
Пример #22
0
 ~dropBaton() {
     obj = NULL;
     callback.Reset();
 }
Пример #23
0
/* static */
void V8Runtime::collectWeakRef(Persistent<Value> ref, void *parameter)
{
	jobject v8Object = (jobject) parameter;
	ref.Reset();
	JNIScope::getEnv()->DeleteGlobalRef(v8Object);
}
Пример #24
0
	Local<Object> Initialize(Local<Context> context)
	{
		isolate_ = context->GetIsolate();
		context_.Reset(isolate_, context);

		auto out = Object::New(isolate_);

		auto add = [](const FunctionCallbackInfo<Value>& info) {
			for (;;)
			{
				auto payload = reinterpret_cast<FJavascriptDelegate*>(Local<External>::Cast(info.Data())->Value());
				if (info.Length() == 1)
				{
					auto func = Local<Function>::Cast(info[0]);
					if (!func.IsEmpty())
					{
						payload->Add(func);
						break;
					}
				}

				UE_LOG(Javascript, Log, TEXT("Invalid argument for delegate"));
				break;
			}
		};

		auto remove = [](const FunctionCallbackInfo<Value>& info) {
			for (;;)
			{
				auto payload = reinterpret_cast<FJavascriptDelegate*>(Local<External>::Cast(info.Data())->Value());
				if (info.Length() == 1)
				{
					auto func = Local<Function>::Cast(info[0]);
					if (!func.IsEmpty())
					{
						payload->Remove(func);
						break;
					}
				}

				UE_LOG(Javascript, Log, TEXT("Invalid argument for delegate"));
				break;
			}
		};

		auto clear = [](const FunctionCallbackInfo<Value>& info) {
			auto payload = reinterpret_cast<FJavascriptDelegate*>(Local<External>::Cast(info.Data())->Value());
			payload->Clear();			
		};

		auto toJSON = [](const FunctionCallbackInfo<Value>& info) {
			auto payload = reinterpret_cast<FJavascriptDelegate*>(Local<External>::Cast(info.Data())->Value());

			uint32_t Index = 0;			
			auto arr = Array::New(info.GetIsolate(), payload->DelegateObjects.Num());
			const bool bIsMulticastDelegate = payload->Property->IsA(UMulticastDelegateProperty::StaticClass());

			for (auto DelegateObject : payload->DelegateObjects)
			{
				auto JavascriptFunction = payload->functions.Find(DelegateObject->UniqueId);
				if (JavascriptFunction)
				{
					auto function = Local<Function>::New(info.GetIsolate(), *JavascriptFunction);
					if (!bIsMulticastDelegate)
					{
						info.GetReturnValue().Set(function);
						return;
					}
					
					arr->Set(Index++, function);
				}
			}

			if (!bIsMulticastDelegate)
			{
				info.GetReturnValue().Set(Null(info.GetIsolate()));
			}
			else
			{
				info.GetReturnValue().Set(arr);
			}			
		};

		auto data = External::New(isolate_, this);

		out->Set(V8_KeywordString(isolate_, "Add"), Function::New(isolate_, add, data));
		out->Set(V8_KeywordString(isolate_, "Remove"), Function::New(isolate_, remove, data));
		out->Set(V8_KeywordString(isolate_, "Clear"), Function::New(isolate_, clear, data));
		out->Set(V8_KeywordString(isolate_, "toJSON"), Function::New(isolate_, toJSON, data));

		WrappedObject.Reset(isolate_, out);

		return out;
	}
Пример #25
0
 ~prepareBaton() {
     obj = NULL;
     callback.Reset();
     StmtObj.Reset();
 }
Пример #26
0
void Setup(const FunctionCallbackInfo<Value>& args) {
	Isolate * isolate = args.GetIsolate();
  // Save a persistent handle to this object for later use in Mutate
	persist.Reset(isolate, args[0]->ToObject());
}
Пример #27
0
void UiWindow::InvokeEventCallback(Isolate* isolate, WindowEventData* data) {
    WINDOW_EVENT evt = data->Evt;

    Local<Object> hndl = handle();
    Local<Function> emitFn = Local<Function>::New(isolate, _emitFn);

    if (evt == WINDOW_EVENT_READY) {
        Handle<Value> argv[] = { String::NewFromUtf8(isolate, "ready") };
        emitFn->Call(hndl, 1, argv);
    }
    else if (evt == WINDOW_EVENT_CLOSING) {
        if (!_shouldClose) {
            auto closeArg = Object::New(isolate);
            Handle<Value> argv[] = { String::NewFromUtf8(isolate, "closing"), closeArg };
            auto result = emitFn->Call(hndl, 2, argv);
            result->BooleanValue();
            _shouldClose = !closeArg->Get(String::NewFromUtf8(isolate, "cancel"))->BooleanValue();
        }
        if (_shouldClose) {
            Close();
        }
    }
    else if (evt == WINDOW_EVENT_CLOSED) {
        Handle<Value> argv[] = { String::NewFromUtf8(isolate, "closed") };
        emitFn->Call(hndl, 1, argv);
    }
    else if (evt == WINDOW_EVENT_RESIZE) {
        Handle<Value> argv[] = { String::NewFromUtf8(isolate, "resize"),
            Int32::New(isolate, (int)data->Arg1), Int32::New(isolate, (int)data->Arg2) };
        emitFn->Call(hndl, 3, argv);
    }
    else if (evt == WINDOW_EVENT_STATE) {
        Handle<Value> argv[] = { String::NewFromUtf8(isolate, "state"), Int32::New(isolate, (int)data->Arg1) };
        emitFn->Call(hndl, 2, argv);
    }
    else if (evt == WINDOW_EVENT_MOVE) {
        Handle<Value> argv[] = { String::NewFromUtf8(isolate, "move"),
            Int32::New(isolate, (int)data->Arg1), Int32::New(isolate, (int)data->Arg2) };
        emitFn->Call(hndl, 3, argv);
    }
    else if (evt == WINDOW_EVENT_DOCUMENT_COMPLETE) {
        Handle<Value> argv[] = { String::NewFromUtf8(isolate, "documentComplete") };
        emitFn->Call(hndl, 1, argv);
    }
    else if (evt == WINDOW_EVENT_MENU) {
        UiMenu* menu = (UiMenu*)data->Arg1;
        Handle<Value> argId = menu->Id ? (Handle<Value>)*menu->Id : (Handle<Value>)Null(isolate);
        Handle<Value> argTitle = menu->Title ? (Handle<Value>)*menu->Title : (Handle<Value>)Null(isolate);
        Handle<Value> argv[] = { String::NewFromUtf8(isolate, "menu"), argId, argTitle };
        emitFn->Call(hndl, 3, argv);
        if (!menu->Callback.IsEmpty()) {
            Local<Function> fn = Local<Function>::New(isolate, menu->Callback);
            Handle<Value> callbackArgv[] = { argId, argTitle };
            fn->Call(hndl, 2, callbackArgv);
        }
    }
    else if (evt == WINDOW_EVENT_MESSAGE) {
        Utf8String* msg = (Utf8String*)data->Arg1;
        auto callback = (void*)data->Arg2;
        if (!_onMessageFn.IsEmpty()) {
            auto onMessage = Local<Function>::New(isolate, _onMessageFn);
            Handle<Value> argv[] = { JsonParse(*msg) };
            auto result = onMessage->Call(hndl, 1, argv);
            if (callback) {
                TryCatch tc;
                result = JsonStringify(result);
                Utf8String* resultStr = new Utf8String(result);
                Utf8String* errorStr = NULL;
                if (tc.HasCaught())
                    errorStr = new Utf8String(tc.Exception()->ToString());
                this->MsgCallback(callback, resultStr, errorStr);
            }
        }
        delete msg;
    }
    else if (evt == WINDOW_EVENT_MESSAGE_CALLBACK) {
        Persistent<Function>* callback = (Persistent<Function>*)data->Arg1;
        Utf8String* result = (Utf8String*)data->Arg2;
        Utf8String* error = (Utf8String*)data->Arg3;
        if (callback) {
            auto callbackFn = Local<Function>::New(isolate, *callback);
            Handle<Value> argv[] = { Null(isolate), Null(isolate) };
            if (result)
                argv[0] = JsonParse(*result);
            if (error)
                argv[0] = *error;
            callbackFn->Call(hndl, 2, argv);
            callback->Reset();
            delete callback;
        }
        if (result)
            delete result;
        if (error)
            delete error;
    }
    else if (evt == WINDOW_EVENT_SELECT_FILE) {
        auto params = (WindowOpenFileParams*)data->Arg1;
        auto result = (Utf8String**)data->Arg2;
        Handle<Value> callbackResult;
        if (result) {
            auto len = 0;
            for (len = 0; result[len]; ) {
                len++;
            }
            auto resArr = Array::New(isolate, len);
            callbackResult = resArr;
            for (auto i = 0; result[i]; i++) {
                resArr->Set(i, *result[i]);
                delete result[i];
            }
            delete[] result;
        } else {
            callbackResult = (Handle<Value>)Null(isolate);
        }
        if (!params->Complete.IsEmpty()) {
            auto callbackFn = Local<Function>::New(isolate, params->Complete);
            Handle<Value> argv[] = { callbackResult };
            callbackFn->Call(hndl, 1, argv);
        }
        delete params;
    }
}