Handle<Value> ImageView::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 << "image view external!\n"; Local<External> ext = Local<External>::Cast(args[0]); void* ptr = ext->Value(); ImageView* im = static_cast<ImageView*>(ptr); im->Wrap(args.This()); return args.This(); } else { return ThrowException(String::New("Cannot create this object from Javascript")); } return Undefined(); }
Handle<Value> NodeSandbox::node_new(const Arguments& args) { HandleScope scope; if (args.IsConstructCall()) { SandboxWrapper* wrap = new SandboxWrapper(); wrap->Wrap(args.This()); wrap->nodeThis = wrap->handle_; node::MakeCallback (wrap->nodeThis, "_init", 0, nullptr); wrap->nodeThis->SetAccessor (String::NewSymbol ("debuggerOnCrash"), NodeSandbox::node_getDebugOnCrash, NodeSandbox::node_setDebugOnCrash); wrap->sbox->addIPC (std::unique_ptr<NodeIPC> (new NodeIPC (STDOUT_FILENO, wrap->handle_))); wrap->sbox->addIPC (std::unique_ptr<NodeIPC> (new NodeIPC (STDERR_FILENO, wrap->handle_))); return args.This(); } else { Local<Value> argv[1] = { args[0] }; return scope.Close(s_constructor->NewInstance(1, argv)); } }
/* ECMAScript constructor */ Handle<Value> Viewport::New(const Arguments& args) { HandleScope scope; if (!args.IsConstructCall()) { return ThrowException(Exception::TypeError( String::New("Use the new operator to create instances of this object.")) ); } // Creates a new instance object of this type and wraps it. Viewport* obj = new Viewport(); obj->Wrap(args.This()); /* Initializing sub-objects */ Local<Object> ScrollableObject = Scrollable::New(MX_SCROLLABLE(obj->_actor)); args.Holder()->Set(String::NewSymbol("scroll"), ScrollableObject); return scope.Close(args.This()); }
Handle<Value> ItemObject::constructor(const Arguments &args) { HandleScope handleScope; // Make sure the constructor is called with the new keyword if (!args.IsConstructCall()) { Local<String> message = String::New("Cannot call constructor as a function"); return ThrowException(Exception::SyntaxError(message)); } // Instantiate a new ScriptTemplate ItemObject *itemObject = new ItemObject(); Local<Object> itemInstance = itemObject->createInstance(); itemInstance->SetInternalField(0, External::New(itemObject)); return handleScope.Close(itemInstance); }
Handle<Value> Palette::New(const Arguments& args) { HandleScope scope; if (!args.IsConstructCall()) { return ThrowException(String::New("Cannot call constructor as function, you need to use 'new' keyword")); } std::string palette; rgba_palette::palette_type type = rgba_palette::PALETTE_RGBA; if (args.Length() >= 1) { if (args[0]->IsString()) { String::AsciiValue obj(args[0]->ToString()); palette = std::string(*obj, obj.length()); } else if (node::Buffer::HasInstance(args[0])) { Local<Object> obj = args[0]->ToObject(); palette = std::string(node::Buffer::Data(obj), node::Buffer::Length(obj)); } } if (args.Length() >= 2) { if (args[1]->IsString()) { std::string obj = *String::Utf8Value(args[1]->ToString()); if (obj == "rgb") type = rgba_palette::PALETTE_RGB; else if (obj == "act") type = rgba_palette::PALETTE_ACT; } } if (!palette.length()) { return ThrowException(Exception::TypeError( String::New("First parameter must be a palette string"))); } Palette* p = new Palette(palette, type); if (!p->palette()->valid()) { delete p; return ThrowException(Exception::TypeError(String::New("Invalid palette length"))); } else { p->Wrap(args.This()); return args.This(); } }
Handle<Value> Image::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(); Image* im = static_cast<Image*>(ptr); im->Wrap(args.This()); return args.This(); } try { if (args.Length() == 2) { if (!args[0]->IsNumber() || !args[1]->IsNumber()) return ThrowException(Exception::Error( String::New("Image 'width' and 'height' must be a integers"))); Image* im = new Image(args[0]->IntegerValue(),args[1]->IntegerValue()); im->Wrap(args.This()); return args.This(); } else { return ThrowException(Exception::Error( String::New("please provide Image width and height"))); } } catch (std::exception const& ex) { return ThrowException(Exception::Error( String::New(ex.what()))); } return Undefined(); }
Handle<Value> MSOutputFormat::New(const Arguments &args) { HandleScope scope; MSOutputFormat *obj; if (!args.IsConstructCall()) { return ThrowException(String::New("Cannot call constructor as function, you need to use 'new' keyword")); } if (args[0]->IsExternal()) { Local<External> ext = Local<External>::Cast(args[0]); void* ptr = ext->Value(); obj = static_cast<MSOutputFormat*>(ptr); obj->Wrap(args.This()); return args.This(); } REQ_STR_ARG(0, driver); REQ_STR_ARG(1, name); outputFormatObj *format = msCreateDefaultOutputFormat(NULL, *driver, *name); /* in the case of unsupported formats, msCreateDefaultOutputFormat should return NULL */ if (!format) { msSetError(MS_MISCERR, "Unsupported format driver: %s", "outputFormatObj()", *driver); return args.This(); } msInitializeRendererVTable(format); /* Else, continue */ format->refcount++; format->inmapfile = MS_TRUE; obj = new MSOutputFormat(format); obj->Wrap(args.This()); return args.This(); }
Handle<Value> Tail::New(const Arguments& args) { HandleScope scope; assert(args.IsConstructCall()); Tail* tail_instance = new Tail(); tail_instance->Wrap(args.This()); if (!args[0]->IsString()) return ThrowException(Exception::TypeError(String::New("Argument 1 must be a String"))); if (!args[1]->IsString()) tail_instance->separator = "\n"; else { String::Utf8Value v8separator(args[1]->ToString()); tail_instance->separator = std::string(*v8separator, v8separator.length()); } String::Utf8Value filename(args[0]); ifstream fp(*filename, ios::binary); fp.seekg(0, ios::end); tail_instance->last_position = fp.tellg(); fp.close(); tail_instance->_event_handle.data = reinterpret_cast<void*>(tail_instance); tail_instance->Ref(); int r = uv_fs_event_init(uv_default_loop(), &tail_instance->_event_handle, *filename, OnEvent, 0); if (r == 0){ tail_instance->ontail = false; } else node::SetErrno(uv_last_error(uv_default_loop())); return args.This(); }
// Create a context (new op) Handle<Value> GNContext::New(const Arguments& args) { HandleScope scope; if (args.IsConstructCall()) { // new obj GNContext* ctx = new GNContext(); getdns_return_t r = getdns_context_create(&ctx->context_, 1); if (r != GETDNS_RETURN_GOOD) { // Failed to create an underlying context delete ctx; ThrowException(Exception::Error(String::New("Unable to create GNContext."))); } // Apply options if needed if (args.Length() > 0) { // could throw an TryCatch try_catch; ctx->applyOptions(args[0]); if (try_catch.HasCaught()) { // Need to bail delete ctx; try_catch.ReThrow(); return scope.Close(Undefined()); } } // Attach the context to node bool attached = GNUtil::attachContextToNode(ctx->context_); if (!attached) { // Bail delete ctx; ThrowException(Exception::Error(String::New("Unable to attach to Node."))); return scope.Close(Undefined()); } ctx->Wrap(args.This()); return args.This(); } else { ThrowException(Exception::Error(String::New("Must use new."))); } return scope.Close(Undefined()); }
Handle<Value> Projection::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.Length() > 0 || !args[0]->IsString()) { return ThrowException(Exception::TypeError( String::New("please provide a proj4 intialization string"))); } try { Projection* p = new Projection(TOSTR(args[0])); p->Wrap(args.This()); return args.This(); } catch (const mapnik::proj_init_error & ex ) { return ThrowException(Exception::Error( String::New(ex.what()))); } }
Handle<Value> Point::New(const Arguments& args) { HandleScope scope; Point *f; OGRPoint *geom; double x = 0, y = 0, z = 0; if (!args.IsConstructCall()) { return NODE_THROW("Cannot call constructor as function, you need to use 'new' keyword"); } if (args[0]->IsExternal()) { Local<External> ext = Local<External>::Cast(args[0]); void* ptr = ext->Value(); f = static_cast<Point *>(ptr); } else { NODE_ARG_DOUBLE_OPT(0, "x", x); NODE_ARG_DOUBLE_OPT(1, "y", y); NODE_ARG_DOUBLE_OPT(2, "z", z); if (args.Length() == 1) { return NODE_THROW("Point constructor must be given 0, 2, or 3 arguments"); } if (args.Length() == 3) { geom = new OGRPoint(x, y, z); } else { geom = new OGRPoint(x, y); } f = new Point(geom); } f->Wrap(args.This()); return args.This(); }
Handle<Value> ZipFile::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.Length() != 1 || !args[0]->IsString()) return ThrowException(Exception::TypeError( String::New("first argument must be a path to a zipfile"))); std::string input_file = TOSTR(args[0]); struct zip *za; int err; char errstr[1024]; if ((za = zip_open(input_file.c_str(), 0, &err)) == NULL) { zip_error_to_str(errstr, sizeof(errstr), err, errno); std::stringstream s; s << "cannot open file: " << input_file << " error: " << errstr << "\n"; return ThrowException(Exception::Error( String::New(s.str().c_str()))); } ZipFile* zf = new ZipFile(input_file); int num = zip_get_num_files(za); zf->names_.reserve(num); int i = 0; for (i = 0; i < num; i++) { struct zip_stat st; zip_stat_index(za, i, 0, &st); zf->names_.push_back(st.name); } zf->archive_ = za; zf->Wrap(args.This()); return args.This(); }
Handle<Value> Resolver::New(const Arguments& args) { HandleScope scope; if (!args.IsConstructCall()) { return ThrowException(Exception::TypeError( String::New("Use the new operator to create instances of this object.")) ); } if (args.Length() < 2) { return ThrowException(Exception::TypeError( String::New("First argument must be a string, second a boolean"))); } Resolver* obj = new Resolver(); String::Utf8Value name(args[0]->ToString()); obj->name_ = std::string(*name); obj->resolver_ = new O3SResolver(obj->name_, false); if (obj->resolver_) { while (!obj->resolver_->getDico()) { std::cout<<"Waiting for dico..."<<std::endl; Poco::Thread::sleep(1000); } obj->Wrap(args.This()); Local<Function> cb = Local<Function>::Cast(args[2]); const unsigned argc = 1; Local<Value> argv[argc] = { args.This() }; cb->Call(Context::GetCurrent()->Global(), argc, argv); return args.This(); } return Undefined(); }
Handle<Value> FingerprintWrap::NewInstance(const Arguments& args) { HandleScope scope; if (!args.IsConstructCall()) return ThrowException(Exception::TypeError( String::New("Use the new operator to create instances of this object."))); FingerprintWrap* fp = new FingerprintWrap( std::string(*String::AsciiValue(args[0]->ToString())).c_str(), args[1]->Int32Value(), args[2]->Int32Value(), args[3]->Int32Value(), args[4]->Int32Value()); fp->Wrap(args.This()); libtorrent::fingerprint* fp_ = FingerprintWrap::Unwrap(args.This()); args.This()->Set(String::NewSymbol("name"), String::New( fp_->name)); args.This()->Set(String::NewSymbol("major_version"), Integer::New(fp_->major_version)); args.This()->Set(String::NewSymbol("minor_version"), Integer::New(fp_->minor_version)); args.This()->Set(String::NewSymbol("revision_version"), Integer::New(fp_->revision_version)); args.This()->Set(String::NewSymbol("tag_version"), Integer::New(fp_->tag_version)); return scope.Close(args.This()); };
Handle<Value> Nodehun::SpellDictionary::New(const Arguments& args) { HandleScope scope; int argl = args.Length(); if (!args.IsConstructCall()) return ThrowException(Exception::TypeError(String::New("Use the new operator to create instances of this object."))); if(argl < 1 || !args[0]->IsString()) return ThrowException(Exception::TypeError(String::New("First argument must be a string."))); String::Utf8Value arg0(args[0]->ToString()); Nodehun::SpellDictionary * obj; if(argl == 1 || argl > 1 && !args[1]->IsString()){ obj = new Nodehun::SpellDictionary(*arg0); if(!obj->pathsExist) return ThrowException(Exception::TypeError(String::New("No such dictionary exists."))); } else { String::Utf8Value arg1(args[1]->ToString()); obj = new Nodehun::SpellDictionary(*arg0,*arg1); if(!obj->pathsExist) return ThrowException(Exception::TypeError(String::New("There was an error compiling either the affix or dictionary file you passed. Perhaps one or both of them is invalid."))); } obj->Wrap(args.This()); return args.This(); }
Handle<Value> Datasource::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(); Datasource* d = static_cast<Datasource*>(ptr); if (d->datasource_->type() == mapnik::datasource::Raster) { args.This()->Set(String::NewSymbol("type"), String::NewSymbol("raster"), static_cast<v8::PropertyAttribute>(v8::ReadOnly|v8::DontDelete)); } else { args.This()->Set(String::NewSymbol("type"), String::NewSymbol("vector"), static_cast<v8::PropertyAttribute>(v8::ReadOnly|v8::DontDelete)); } d->Wrap(args.This()); return args.This(); } if (args.Length() != 1){ return ThrowException(Exception::TypeError( String::New("accepts only one argument, an object of key:value datasource options"))); } if (!args[0]->IsObject()) return ThrowException(Exception::TypeError( String::New("Must provide an object, eg {type: 'shape', file : 'world.shp'}"))); Local<Object> options = args[0]->ToObject(); mapnik::parameters params; Local<Array> names = options->GetPropertyNames(); unsigned int i = 0; unsigned int a_length = names->Length(); while (i < a_length) { Local<Value> name = names->Get(i)->ToString(); Local<Value> value = options->Get(name); // TODO - don't treat everything as strings params[TOSTR(name)] = TOSTR(value); i++; } mapnik::datasource_ptr ds; try { #if MAPNIK_VERSION >= 200200 ds = mapnik::datasource_cache::instance().create(params); #else ds = mapnik::datasource_cache::instance()->create(params); #endif } catch (std::exception const& ex) { return ThrowException(Exception::Error( String::New(ex.what()))); } if (ds) { if (ds->type() == mapnik::datasource::Raster) { args.This()->Set(String::NewSymbol("type"), String::NewSymbol("raster"), static_cast<v8::PropertyAttribute>(v8::ReadOnly|v8::DontDelete)); } else { args.This()->Set(String::NewSymbol("type"), String::NewSymbol("vector"), static_cast<v8::PropertyAttribute>(v8::ReadOnly|v8::DontDelete)); } Datasource* d = new Datasource(); d->Wrap(args.This()); d->datasource_ = ds; return args.This(); } return Undefined(); }
Handle<Value> JSDatasource::New(const Arguments& args) { 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(); JSDatasource* d = static_cast<JSDatasource*>(ptr); d->Wrap(args.This()); return args.This(); } if (!args.Length() == 2){ return ThrowException(Exception::TypeError( String::New("two argument required: an object of key:value datasource options and a callback function for features"))); } if (!args[0]->IsObject()) return ThrowException(Exception::TypeError( String::New("Must provide an object, eg {extent: '-180,-90,180,90'}"))); Local<Object> options = args[0]->ToObject(); // function callback if (!args[args.Length()-1]->IsFunction()) return ThrowException(Exception::TypeError( String::New("last argument must be a callback function"))); // TODO - maybe validate in js? bool bind=true; if (options->Has(String::New("bind"))) { Local<Value> bind_opt = options->Get(String::New("bind")); if (!bind_opt->IsBoolean()) return ThrowException(Exception::TypeError( String::New("'bind' must be a Boolean"))); bind = bind_opt->BooleanValue(); } mapnik::parameters params; params["type"] = "js"; Local<Array> names = options->GetPropertyNames(); uint32_t i = 0; uint32_t a_length = names->Length(); while (i < a_length) { Local<Value> name = names->Get(i)->ToString(); Local<Value> value = options->Get(name); params[TOSTR(name)] = TOSTR(value); i++; } mapnik::datasource_ptr ds; try { ds = mapnik::datasource_ptr(new js_datasource(params,bind,args[args.Length()-1])); } catch (const std::exception & ex) { return ThrowException(Exception::Error( String::New(ex.what()))); } catch (...) { return ThrowException(Exception::Error( String::New("unknown exception happened, please file bug"))); } if (ds) { JSDatasource* d = new JSDatasource(); d->Wrap(args.This()); d->ds_ptr_ = ds; return args.This(); } return Undefined(); }
Handle<Value> Query::New(Arguments const& args) { HandleScope scope; if (!args.IsConstructCall()) { return ThrowException(Exception::Error(String::New("Cannot call constructor as function, you need to use 'new' keyword"))); } try { if (args.Length() != 1) { return ThrowException(Exception::TypeError(String::New("please provide an object of options for the first argument"))); } if (!args[0]->IsObject()) { return ThrowException(Exception::TypeError(String::New("first argument must be an object"))); } Local<Object> obj = args[0]->ToObject(); if (obj->IsNull() || obj->IsUndefined()) { return ThrowException(Exception::TypeError(String::New("first arg must be an object"))); } if (!obj->Has(String::New("coordinates"))) { return ThrowException(Exception::TypeError(String::New("must provide a coordinates property"))); } Local<Value> coordinates = obj->Get(String::New("coordinates")); if (!coordinates->IsArray()) { return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs"))); } // Handle scenario in which caller explicitly specified service std::string service; if (obj->Has(String::New("service"))) { Local<Value> serviceValue = obj->Get(String::New("service")); v8::String::Utf8Value serviceUtf8Value(serviceValue->ToString()); service = std::string(*serviceUtf8Value); } // Handle 'nearest', otherwise assume 'viaroute' service. if (service == "nearest" || service == "locate") { Local<Array> coordinates_array = Local<Array>::Cast(coordinates); if (coordinates_array->Length() != 1) { return ThrowException(Exception::TypeError(String::New("coordinates array should only have one lat/long pair for 'nearest' or 'locate' queries"))); } Local<Value> coordinate = coordinates_array->Get(0); if (!coordinate->IsArray()) { return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs"))); } Local<Array> coordinate_array = Local<Array>::Cast(coordinate); if (coordinate_array->Length() != 2) { return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs"))); } Query* q = new Query(); q->this_->service = service; q->this_->coordinates.push_back( FixedPointCoordinate(coordinate_array->Get(0)->NumberValue()*COORDINATE_PRECISION, coordinate_array->Get(1)->NumberValue()*COORDINATE_PRECISION)); q->Wrap(args.This()); return args.This(); } Local<Array> coordinates_array = Local<Array>::Cast(coordinates); if (coordinates_array->Length() < 2) { return ThrowException(Exception::TypeError(String::New("at least two coordinates must be provided"))); } Query* q = new Query(); q->this_->zoomLevel = 18; //no generalization q->this_->printInstructions = false; //turn by turn instructions q->this_->alternateRoute = true; //get an alternate route, too q->this_->geometry = true; //retrieve geometry of route q->this_->compression = true; //polyline encoding q->this_->checkSum = UINT_MAX; //see wiki q->this_->service = "viaroute"; //that's routing q->this_->outputFormat = "json"; q->this_->jsonpParameter = ""; //set for jsonp wrapping q->this_->language = ""; //unused atm if (obj->Has(String::New("alternateRoute"))) { q->this_->alternateRoute = obj->Get(String::New("alternateRoute"))->BooleanValue(); } if (obj->Has(String::New("checksum"))) { q->this_->checkSum = static_cast<unsigned>(obj->Get(String::New("checksum"))->Uint32Value()); } if (obj->Has(String::New("zoomLevel"))) { q->this_->zoomLevel = static_cast<short>(obj->Get(String::New("zoomLevel"))->Int32Value()); } if (obj->Has(String::New("printInstructions"))) { q->this_->printInstructions = obj->Get(String::New("printInstructions"))->BooleanValue(); } if (obj->Has(String::New("jsonpParameter"))) { q->this_->jsonpParameter = *v8::String::Utf8Value(obj->Get(String::New("jsonpParameter"))); } if (obj->Has(String::New("hints"))) { Local<Value> hints = obj->Get(String::New("hints")); if (!hints->IsArray()) { return ThrowException(Exception::TypeError(String::New("hints must be an array of strings/null"))); } Local<Array> hints_array = Local<Array>::Cast(hints); for (uint32_t i = 0; i < hints_array->Length(); ++i) { Local<Value> hint = hints_array->Get(i); if (hint->IsString()) { q->this_->hints.push_back(*v8::String::Utf8Value(hint)); } else if(hint->IsNull()){ q->this_->hints.push_back(""); }else{ return ThrowException(Exception::TypeError(String::New("hint must be null or string"))); } } } for (uint32_t i = 0; i < coordinates_array->Length(); ++i) { Local<Value> coordinate = coordinates_array->Get(i); if (!coordinate->IsArray()) { return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs"))); } Local<Array> coordinate_array = Local<Array>::Cast(coordinate); if (coordinate_array->Length() != 2) { return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs"))); } q->this_->coordinates.push_back( FixedPointCoordinate(coordinate_array->Get(0)->NumberValue()*COORDINATE_PRECISION, coordinate_array->Get(1)->NumberValue()*COORDINATE_PRECISION)); } q->Wrap(args.This()); return args.This(); } catch (std::exception const& ex) { return ThrowException(Exception::TypeError(String::New(ex.what()))); } return Undefined(); }
Handle<Value> MSRect::New(const Arguments &args) { HandleScope scope; MSRect *obj; double t; if (!args.IsConstructCall()) { return ThrowException(String::New("Cannot call constructor as function, you need to use 'new' keyword")); } if (args[0]->IsExternal()) { Local<External> ext = Local<External>::Cast(args[0]); void* ptr = ext->Value(); obj = static_cast<MSRect*>(ptr); obj->Wrap(args.This()); return args.This(); } rectObj *rect = (rectObj *)calloc(1, sizeof(rectObj)); if(!rect) { return args.This(); } if (args.Length() == 0) { rect->minx = -1; rect->miny = -1; rect->maxx = -1; rect->maxy = -1; } else if (args.Length() == 1) { Local<Object> argObj; if (!args[0]->IsObject()) { THROW_ERROR(TypeError, "single argument constructor requires a Rect object"); } argObj = args[0]->ToObject(); if (argObj->IsNull() || argObj->IsUndefined() || !MSRect::constructor->HasInstance(argObj)) { THROW_ERROR(TypeError, "single argument to Rect constructor must be a Rect object"); } MSRect *inRect = ObjectWrap::Unwrap<MSRect>(argObj); memcpy(rect, inRect->this_, sizeof(rectObj)); } else if (args.Length() == 4) { REQ_DOUBLE_ARG(0, minx); REQ_DOUBLE_ARG(1, miny); REQ_DOUBLE_ARG(2, maxx); REQ_DOUBLE_ARG(3, maxy); /* coerce correct extent */ if (minx > maxx) { t = maxx; maxx = minx; minx = t; } if (miny > maxy) { t = maxy; maxy = miny; miny = t; } rect->minx = minx; rect->miny = miny; rect->maxx = maxx; rect->maxy = maxy; } else { THROW_ERROR(Error, "Rect objects take 0, 1 or 4 arguments."); } obj = new MSRect(rect); obj->owner = true; obj->Wrap(args.This()); return args.This(); }
Handle<Value> Query::New(Arguments const& args) { HandleScope scope; if (!args.IsConstructCall()) { return ThrowException(Exception::Error(String::New("Cannot call constructor as function, you need to use 'new' keyword"))); } try { if (args.Length() != 1) { return ThrowException(Exception::TypeError(String::New("please provide an object of options for the first argument"))); } if (!args[0]->IsObject()) { return ThrowException(Exception::TypeError(String::New("first argument must be an object"))); } Local<Object> obj = args[0]->ToObject(); if (obj->IsNull() || obj->IsUndefined()) { return ThrowException(Exception::TypeError(String::New("first arg must be an object"))); } if (!obj->Has(String::NewSymbol("coordinates"))) { return ThrowException(Exception::TypeError(String::New("must provide a coordinates property"))); } Local<Value> coordinates = obj->Get(String::New("coordinates")); if (!coordinates->IsArray()) { return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs"))); } Local<Array> coordinates_array = Local<Array>::Cast(coordinates); if (coordinates_array->Length() < 2) { return ThrowException(Exception::TypeError(String::New("at least two coordinates must be provided"))); } Query* q = new Query(); q->this_->zoomLevel = 18; //no generalization q->this_->printInstructions = true; //turn by turn instructions q->this_->alternateRoute = true; //get an alternate route, too q->this_->geometry = true; //retrieve geometry of route q->this_->compression = true; //polyline encoding q->this_->checkSum = UINT_MAX; //see wiki q->this_->service = "viaroute"; //that's routing q->this_->outputFormat = "json"; q->this_->jsonpParameter = ""; //set for jsonp wrapping q->this_->language = ""; //unused atm if (obj->Has(String::NewSymbol("alternateRoute"))) { q->this_->alternateRoute = obj->Get(String::New("alternateRoute"))->BooleanValue(); } for (uint32_t i = 0; i < coordinates_array->Length(); ++i) { Local<Value> coordinate = coordinates_array->Get(i); if (!coordinate->IsArray()) { return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs"))); } Local<Array> coordinate_array = Local<Array>::Cast(coordinate); if (coordinate_array->Length() != 2) { return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs"))); } q->this_->coordinates.push_back( FixedPointCoordinate(coordinate_array->Get(0)->NumberValue()*COORDINATE_PRECISION, coordinate_array->Get(1)->NumberValue()*COORDINATE_PRECISION)); } q->Wrap(args.This()); return args.This(); } catch (std::exception const& ex) { return ThrowException(Exception::TypeError(String::New(ex.what()))); } return Undefined(); }
Handle<Value> Datasource::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(); Datasource* d = static_cast<Datasource*>(ptr); d->Wrap(args.This()); return args.This(); } if (!args.Length() == 1){ return ThrowException(Exception::TypeError( String::New("accepts only one argument, an object of key:value datasource options"))); } if (!args[0]->IsObject()) return ThrowException(Exception::TypeError( String::New("must provide an object, eg {type: 'shape', file : 'world.shp'}"))); Local<Object> options = args[0]->ToObject(); // TODO - maybe validate in js? bool bind=true; if (options->Has(String::New("bind"))) { Local<Value> bind_opt = options->Get(String::New("bind")); if (!bind_opt->IsBoolean()) return ThrowException(Exception::TypeError( String::New("'bind' must be a Boolean"))); bind = bind_opt->BooleanValue(); } mapnik::parameters params; Local<Array> names = options->GetPropertyNames(); uint32_t i = 0; uint32_t a_length = names->Length(); while (i < a_length) { Local<Value> name = names->Get(i)->ToString(); Local<Value> value = options->Get(name); params[TOSTR(name)] = TOSTR(value); i++; } mapnik::datasource_ptr ds; try { ds = mapnik::datasource_cache::create(params, bind); } catch (const mapnik::config_error & ex ) { return ThrowException(Exception::Error( String::New(ex.what()))); } catch (const mapnik::datasource_exception & ex ) { return ThrowException(Exception::Error( String::New(ex.what()))); } catch (const std::runtime_error & ex ) { return ThrowException(Exception::Error( String::New(ex.what()))); } catch (const std::exception & ex) { return ThrowException(Exception::Error( String::New(ex.what()))); } catch (...) { return ThrowException(Exception::Error( String::New("unknown exception happened, please file bug"))); } if (ds) { Datasource* d = new Datasource(); d->Wrap(args.This()); d->datasource_ = ds; return args.This(); } return Undefined(); }
Handle<Value> Grid::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(); Grid* g = static_cast<Grid*>(ptr); g->Wrap(args.This()); return args.This(); } if (args.Length() >= 2) { if (!args[0]->IsNumber() || !args[1]->IsNumber()) return ThrowException(Exception::TypeError( String::New("Grid 'width' and 'height' must be a integers"))); // defaults std::string key("__id__"); unsigned int resolution = 1; if (args.Length() >= 3) { if (!args[2]->IsObject()) return ThrowException(Exception::TypeError( String::New("optional third arg must be an options object"))); Local<Object> options = args[2]->ToObject(); if (options->Has(String::New("key"))) { Local<Value> bind_opt = options->Get(String::New("key")); if (!bind_opt->IsString()) return ThrowException(Exception::TypeError( String::New("optional arg 'key' must be an string"))); key = TOSTR(bind_opt); } // TODO - remove, deprecated if (options->Has(String::New("resolution"))) { Local<Value> bind_opt = options->Get(String::New("resolution")); if (!bind_opt->IsNumber()) return ThrowException(Exception::TypeError( String::New("optional arg 'resolution' must be an string"))); resolution = bind_opt->IntegerValue(); } } Grid* g = new Grid(args[0]->IntegerValue(),args[1]->IntegerValue(),key,resolution); g->Wrap(args.This()); return args.This(); } else { return ThrowException(Exception::Error( String::New("please provide Grid width and height"))); } return Undefined(); }
Handle<Value> Color::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(); Color* c = static_cast<Color*>(ptr); c->Wrap(args.This()); return args.This(); } color_ptr c_p; try { if (args.Length() == 1 && args[0]->IsString()){ c_p = boost::make_shared<mapnik::color>(TOSTR(args[0])); } else if (args.Length() == 3) { int r = args[0]->IntegerValue(); int g = args[1]->IntegerValue(); int b = args[2]->IntegerValue(); c_p = boost::make_shared<mapnik::color>(r,g,b); } else if (args.Length() == 4) { int r = args[0]->IntegerValue(); int g = args[1]->IntegerValue(); int b = args[2]->IntegerValue(); int a = args[3]->IntegerValue(); c_p = boost::make_shared<mapnik::color>(r,g,b,a); } else { return ThrowException(Exception::Error( String::New("invalid arguments: colors can be created from a string, integer r,g,b values, or integer r,g,b,a values"))); } // todo allow int,int,int and int,int,int,int contructor } catch (std::exception const& ex) { return ThrowException(Exception::Error( String::New(ex.what()))); } catch (...) { return ThrowException(Exception::Error( String::New("unknown exception happened, please file bug"))); } if (c_p) { Color* c = new Color(); c->Wrap(args.This()); c->this_ = c_p; return args.This(); } else { return ThrowException(Exception::Error( String::New("unknown exception happened, please file bug"))); } return Undefined(); }