Handle<Value> DynamicJpegStack::New(const Arguments &args) { HandleScope scope; if (args.Length() > 1) return VException("One argument max - buffer type."); buffer_type buf_type = BUF_RGB; if (args.Length() == 1) { if (!args[0]->IsString()) return VException("First argument must be a string. Either 'rgb', 'bgr', 'rgba' or 'bgra'."); String::AsciiValue bt(args[0]->ToString()); if (!(str_eq(*bt, "rgb") || str_eq(*bt, "bgr") || str_eq(*bt, "rgba") || str_eq(*bt, "bgra"))) { return VException("Buffer type must be 'rgb', 'bgr', 'rgba' or 'bgra'."); } if (str_eq(*bt, "rgb")) buf_type = BUF_RGB; else if (str_eq(*bt, "bgr")) buf_type = BUF_BGR; else if (str_eq(*bt, "rgba")) buf_type = BUF_RGBA; else if (str_eq(*bt, "bgra")) buf_type = BUF_BGRA; else return VException("Buffer type wasn't 'rgb', 'bgr', 'rgba' or 'bgra'."); } DynamicJpegStack *jpeg = new DynamicJpegStack(buf_type); jpeg->Wrap(args.This()); return args.This(); }
/** * Executes a command. */ Handle<Value> Exec(const Arguments& args) { HandleScope scope; if (args.Length() < 1) { return ThrowException( Exception::TypeError(String::New("First argument must be a string")) ); } Local<String> str = args[0]->ToString(); std::string cmd = FlattenString(str); int result = exec(cmd.c_str()); return scope.Close(Integer::New(result)); }
Handle<Value> DecoderNotifier::Done(const Arguments& args) { HandleScope scope; DecoderNotifier* obj = ObjectWrap::Unwrap<DecoderNotifier>(args.This()); if(args.Length() == 0){ // Process next frame uv_queue_work(uv_default_loop(), &(obj->pBaton->request), AsyncWork, (uv_after_work_cb)AsyncAfter); } return Undefined(); }
Handle< ::v8::Value> GlobalVariable::New(const Arguments& args) { HandleScope scope; if (args.Length()) { REQ_LLVM_MODULE_ARG(0, module); REQ_LLVM_TYPE_ARG(1, type); REQ_UTF8_ARG(2, name); REQ_LLVM_CONST_ARG(3, init); GlobalVariable* val = new GlobalVariable(new ::llvm::GlobalVariable(*module, type, false, llvm::GlobalValue::InternalLinkage, init, *name)); val->Wrap(args.This()); } return args.This(); }
Handle<Value> ALUTLoadMemoryHelloWorldCallback(const Arguments& args) { //if less that nbr of formal parameters then do nothing if (args.Length() < 3) return v8::Undefined(); //get arguments Handle<Array> arg0 = Array::Cast(args[0]); Handle<Array> arg1 = Array::Cast(args[1]); Handle<Array> arg2 = Array::Cast(args[2]); //make call alutLoadMemoryHelloWorld((ALenum*)arg0, (ALsizei*)arg1, (ALfloat*)arg2); return v8::Undefined(); }
Handle<Value> ALUTCreateBufferFromFileImageCallback(const Arguments& args) { //if less that nbr of formal parameters then do nothing if (args.Length() < 2) return v8::Undefined(); //get arguments String::Utf8Value value0(args[0]); char* key0 = *value0; void* arg0 = font_[key0]; //make call alutCreateBufferFromFileImage((const ALvoid*)arg0, (ALsizei)arg1); return v8::Undefined(); }
Handle<Value> ALUTInitWithoutContextCallback(const Arguments& args) { //if less that nbr of formal parameters then do nothing if (args.Length() < 2) return v8::Undefined(); //get arguments Handle<Array> arg0 = Array::Cast(args[0]); String::Utf8Value value1(args[1]); char* arg1 = *value1; //make call alutInitWithoutContext((int*)arg0, (char**)arg1); return v8::Undefined(); }
Handle<Value> Expression::New(const Arguments& args) { HandleScope scope; if (!args.IsConstructCall()) return ThrowException(String::New("Cannot call constructor as function, you need to use 'new' keyword")); if (args[0]->IsExternal()) { //std::clog << "external!\n"; Local<External> ext = Local<External>::Cast(args[0]); void* ptr = ext->Value(); Expression* e = static_cast<Expression*>(ptr); e->Wrap(args.This()); return args.This(); } mapnik::expression_ptr e_ptr; try { if (args.Length() == 1 && args[0]->IsString()){ e_ptr = mapnik::parse_expression(TOSTR(args[0]),"utf8"); } else { return ThrowException(Exception::Error( String::New("invalid arguments: accepts a single argument of string type"))); } } catch (std::exception const& ex) { return ThrowException(Exception::Error( String::New(ex.what()))); } if (e_ptr) { Expression* e = new Expression(); e->Wrap(args.This()); e->this_ = e_ptr; return args.This(); } else { return ThrowException(Exception::Error( String::New("unknown exception happened, please file bug"))); } return Undefined(); }
// メソッドの呼び出し Handle<Value> TJSObject::caller(const Arguments& args) { tTJSVariant self; if (getVariant(self, args.This())) { Handle<Value> ret; // 引数変換 tjs_int argc = args.Length(); tTJSVariant **argv = new tTJSVariant*[argc]; for (tjs_int i=0;i<argc;i++) { argv[i] = new tTJSVariant(); *argv[i] = toVariant(args[i]); } if (self.AsObjectClosureNoAddRef().IsInstanceOf(0, NULL, NULL, L"Class", NULL) == TJS_S_TRUE) { // クラスオブジェクトならコンストラクタ呼び出し iTJSDispatch2 *instance = NULL; tjs_error error; if (TJS_SUCCEEDED(error = self.AsObjectClosureNoAddRef().CreateNew(0, NULL, NULL, &instance, argc, argv, NULL))) { ret = toJSValue(tTJSVariant(instance, instance)); instance->Release(); } else { ret = ERROR_KRKR(error); } } else { // メソッド呼び出し tTJSVariant result; tjs_error error; if (TJS_SUCCEEDED(error = self.AsObjectClosureNoAddRef().FuncCall(0, NULL, NULL, &result, argc, argv, NULL))) { ret = toJSValue(result); } else { ret = ERROR_KRKR(error); } } // 引数解放 if (argv) { for (int i=0;i<argc;i++) { delete argv[i]; } delete[] argv; } return ret; } return ERROR_BADINSTANCE(); }
Handle<Value> TiAppPropertiesObject::_removeProperty(void* /*userContext*/, TiObject* /*caller*/, const Arguments& args) { if (args.Length() < 1) { return ThrowException(String::New(Ti::Msg::Missing_argument)); } if (!args[0]->IsString() && !args[0]->IsStringObject()) { return ThrowException(String::New((string(Ti::Msg::Invalid_argument_expected_) + "String").c_str())); } QString key = QString::fromUtf8(*String::Utf8Value(args[0])); settings.remove(key); return Undefined(); }
Handle<Value> Scene_GetMainComponent(const Arguments& args) { HandleScope handle_scope; Scene* ptr = GetPtr(args.This()); assert(ptr); Component* pComponent = 0; if ((args.Length() == 1) && args[0]->IsUint32()) pComponent = ptr->getMainComponent((tComponentType) args[0]->ToUint32()->Value()); else return ThrowException(String::New("Invalid parameters, valid syntax:\ngetMainComponent(type)")); return handle_scope.Close(toJavaScript(pComponent)); }
Handle<Value> Grid::view(const Arguments& args) { HandleScope scope; if ( (args.Length() != 4) || (!args[0]->IsNumber() && !args[1]->IsNumber() && !args[2]->IsNumber() && !args[3]->IsNumber() )) return ThrowException(Exception::TypeError( String::New("requires 4 integer arguments: x, y, width, height"))); unsigned x = args[0]->IntegerValue(); unsigned y = args[1]->IntegerValue(); unsigned w = args[2]->IntegerValue(); unsigned h = args[3]->IntegerValue(); Grid* g = ObjectWrap::Unwrap<Grid>(args.This()); return scope.Close(GridView::New(g,x,y,w,h)); }
v8::Handle<v8::Value> CompoundShape_GetChildShape(const Arguments& args) { HandleScope handle_scope; if ((args.Length() == 1) && args[0]->IsUint32()) { CompoundShape* ptr = GetPtr(args.This()); assert(ptr); unsigned int index = args[0]->ToUint32()->Value(); if (index < ptr->getNbChildShapes()) return handle_scope.Close(Uint32::New((unsigned int) ptr->getChildShape(index))); } return ThrowException(String::New("Invalid parameters, valid syntax:\ngetChildShape(childIndex)")); }
Handle<Value> ComponentsManager_Create(const Arguments& args) { HandleScope handle_scope; ComponentsManager* ptr = GetPtr(args.This()); assert(ptr); if ((args.Length() == 3) && args[0]->IsString() && args[1]->IsString() && args[2]->IsObject()) { return handle_scope.Close(toJavaScript(ptr->create(*String::AsciiValue(args[0]->ToString()), *String::AsciiValue(args[1]->ToString()), fromJSComponentsList(args[2])))); } return ThrowException(String::New("Invalid parameters, valid syntax:\ncreate(type, name, components_list)")); }
Handle<Value> Nodehun::SpellDictionary::New(const Arguments& args) { HandleScope scope; int argl = args.Length(); if (!args.IsConstructCall()) return ThrowException(Exception::Error(String::New("Use the new operator to create an instance of this object."))); if(argl < 2) return ThrowException(Exception::Error(String::New("Constructor requires two arguments."))); if(!Buffer::HasInstance(args[0])) return ThrowException(Exception::TypeError(String::New("First argument must be a buffer"))); if(!Buffer::HasInstance(args[1])) return ThrowException(Exception::TypeError(String::New("Second argument must be a buffer"))); Nodehun::SpellDictionary *obj = new Nodehun::SpellDictionary(Buffer::Data(args[0].As<Object>()), Buffer::Data(args[1].As<Object>())); obj->Wrap(args.This()); return args.This(); }
Handle<Value> PDFDateDriver::NewInstance(const Arguments& args) { HandleScope scope; if(args.Length() != 1 || !args[0]->IsDate()) { ThrowException(Exception::TypeError(String::New("Wrong arguments. Provide 1 argument which is a date"))); return scope.Close(Undefined()); } const unsigned argc = 1; Handle<Value> argv[argc] = {args[0]}; Local<Object> instance = constructor->NewInstance(argc, argv); return scope.Close(instance); }
Handle<Value> NovaConfigBinding::AddIface(const Arguments& args) { HandleScope scope; NovaConfigBinding* obj = ObjectWrap::Unwrap<NovaConfigBinding>(args.This()); if(args.Length() < 1) { return ThrowException(Exception::TypeError(String::New("Must be invoked with one parameter"))); } std::string pass = cvv8::CastFromJS<std::string>(args[0]); obj->m_conf->AddInterface(pass); return args.This(); }
Handle<Value> HoneydConfigBinding::RenamePortset(const Arguments& args) { HandleScope scope; HoneydConfigBinding* obj = ObjectWrap::Unwrap<HoneydConfigBinding>(args.This()); if(args.Length() != 3) { return ThrowException(Exception::TypeError(String::New("Must be invoked with 3 parameters"))); } std::string oldName = cvv8::CastFromJS<string>(args[0]); std::string newName = cvv8::CastFromJS<string>(args[1]); std::string profile = cvv8::CastFromJS<string>(args[2]); return scope.Close(Boolean::New(obj->m_conf->RenamePortset(profile, oldName, newName))); }
Handle<Value> Signal_Fire(const Arguments& args) { HandleScope handle_scope; Signal* self = GetPtr(args.This()); assert(self); Variant* pValue = 0; if (args.Length() == 1) pValue = fromJSVariant(args[0]); self->fire(pValue); return Handle<Value>(); }
// -------------------------------------------------------- Handle<Value> NodeOpenALStream::Buffer(const Arguments& args) { HandleScope scope; NodeOpenALStream* obj = ObjectWrap::Unwrap<NodeOpenALStream>(args.This()); if (args.Length() < 1) { ThrowException(Exception::TypeError(String::New("Wrong number of arguments"))); return scope.Close( Undefined() ); } Local<Value> buffer = args[0]; size_t size = node::Buffer::Length( buffer->ToObject() ); char* bufferdata = node::Buffer::Data( buffer->ToObject() ); obj->buffer(size, bufferdata); return scope.Close(v8::Undefined()); }
Handle<Value> GLESglGetProgramInfoLogCallback(const Arguments& args) { if (args.Length() != 1) return v8::Undefined(); //get arguments unsigned program = args[0]->Uint32Value(); //query string length int len = 0; glGetProgramiv((GLuint)program, GL_INFO_LOG_LENGTH, &len); char* log = new char[len]; glGetProgramInfoLog((GLuint)program, (GLsizei)len, NULL, log); return String::New(log); }
Handle<Value> GLESglGetProgramivCallback(const Arguments& args) { //if less that nbr of formal parameters then do nothing if (args.Length() != 2) return v8::Undefined(); //get arguments unsigned program = args[0]->Uint32Value(); unsigned pname = args[1]->Uint32Value(); int ans; //TODO(nico): I haven't seen any case where this function might return //an array. glGetProgramiv((GLuint)program, (GLenum)pname, (GLint*) &ans); return Integer::New(ans); }
Handle<Value> GLESglGetShaderSourceCallback(const Arguments& args) { if (args.Length() != 1) return v8::Undefined(); //get arguments unsigned shader = args[0]->Uint32Value(); //query string length int len = 0; glGetShaderiv((GLuint)shader, GL_SHADER_SOURCE_LENGTH, &len); char* log = new char[len]; glGetShaderSource((GLuint)shader, (GLsizei)len, NULL, log); return String::New(log); }
Handle< Value > V8Scope::loadCallback( const Arguments &args ) { Locker l; HandleScope handle_scope; Handle<External> field = Handle<External>::Cast(args.Data()); void* ptr = field->Value(); V8Scope* self = static_cast<V8Scope*>(ptr); Context::Scope context_scope(self->_context); for (int i = 0; i < args.Length(); ++i) { std::string filename(toSTLString(args[i])); if (!self->execFile(filename, false , true , false)) { return v8::ThrowException(v8::String::New((std::string("error loading file: ") + filename).c_str())); } } return v8::True(); }
Handle<Value> alert(const Arguments& args) { bool first = true; string res = ""; for (int i = 0; i < args.Length(); i++) { HandleScope handle_scope; if (first) { first = false; } else { res += " "; } res += value_to_string(args[i]); } LOG4CXX_INFO(webEngine::iLogger::GetLogger(), _T("js::alert: ") << res); return Undefined(); }
Handle<Value> NovaConfigBinding::UseAnyLoopback(const Arguments& args) { HandleScope scope; NovaConfigBinding* obj = ObjectWrap::Unwrap<NovaConfigBinding>(args.This()); if( args.Length() < 1 ) { return ThrowException(Exception::TypeError(String::New("Must be invoked with one parameter"))); } bool def = cvv8::CastFromJS<bool>( args[0] ); obj->m_conf->SetUseAnyLoopback(def); return args.This(); }
Handle<Value> NovaConfigBinding::WriteSetting(const Arguments& args) { HandleScope scope; NovaConfigBinding* obj = ObjectWrap::Unwrap<NovaConfigBinding>(args.This()); if( args.Length() != 2 ) { return ThrowException(Exception::TypeError(String::New("Must be invoked with two parameters"))); } string key = cvv8::CastFromJS<string>( args[0] ); string value = cvv8::CastFromJS<string>( args[1] ); return scope.Close(Boolean::New(obj->m_conf->WriteSetting(key, value))); }
Handle<Value> ImageHashAsync(const Arguments& args) { if (args.Length() < 2 || !args[1]->IsFunction()) { // no callback defined return ThrowException(Exception::Error(String::New("Callback is required and must be an Function."))); } String::Utf8Value str(args[0]); Handle<Function> cb = Handle<Function>::Cast(args[1]); PhashRequest* request = new PhashRequest; request->callback = Persistent<Function>::New(cb); request->file = string(*str); request->request.data = request; uv_queue_work(uv_default_loop(), &request->request, HashWorker, HashAfter); return Undefined(); }
Handle<Value> NovaConfigBinding::SetDoppelInterface(const Arguments& args) { HandleScope scope; if(args.Length() != 1) { return ThrowException(Exception::TypeError(String::New("Must be invoked with one parameter"))); } NovaConfigBinding* obj = ObjectWrap::Unwrap<NovaConfigBinding>(args.This()); std::string difToSet = cvv8::CastFromJS<std::string>(args[0]); obj->m_conf->SetDoppelInterface(difToSet); return args.This(); }
Handle<Value> TiTitaniumObject::_createBuffer(void* userContext, TiObject*, const Arguments& args) { HandleScope handleScope; TiTitaniumObject* obj = (TiTitaniumObject*) userContext; Handle<ObjectTemplate> global = getObjectTemplateFromJsObject(args.Holder()); Handle<Object> result = global->NewInstance(); TiBufferObject* newBuffer = TiBufferObject::createBuffer(obj->objectFactory_); newBuffer->setValue(result); if ((args.Length() > 0) && (args[0]->IsObject())) { Local<Object> settingsObj = Local<Object>::Cast(args[0]); newBuffer->setParametersFromObject(newBuffer, settingsObj); } setTiObjectToJsObject(result, newBuffer); return handleScope.Close(result); }