void EIO_AfterClose(uv_work_t* req) {
NanScope();
CloseBaton* data = static_cast<CloseBaton*>(req->data);
v8::Handle<v8::Value> argv[1];
if(data->errorString[0]) {
argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString));
} else {
argv[0] = NanUndefined();
// We don't have an error, so clean up the write queue for that fd
_WriteQueue *q = qForFD(data->fd);
if (q) {
q->lock();
QueuedWrite &write_queue = q->get();
while (!write_queue.empty()) {
QueuedWrite *del_q = write_queue.next;
NanDisposePersistent(del_q->baton->buffer);
del_q->remove();
}
q->unlock();
deleteQForFD(data->fd);
}
}
data->callback->Call(1, argv);
delete data->callback;
delete data;
delete req;
}
void
DNSSD_API
OnResolve(DNSServiceRef sdRef, DNSServiceFlags flags,
uint32_t interfaceIndex, DNSServiceErrorType errorCode,
const char * fullname, const char * hosttarget, uint16_t port,
uint16_t txtLen, const unsigned char * txtRecord, void * context)
{
NanScope();
ServiceRef * serviceRef = static_cast<ServiceRef*>(context);
Handle<Function> callback = serviceRef->GetCallback();
Handle<Object> this_ = serviceRef->GetThis();
const size_t argc(9);
Local<Value> args[argc];
args[0] = NanObjectWrapHandle(serviceRef);
args[1] = NanNew<Integer>(flags);
args[2] = NanNew<Uint32>(interfaceIndex);
args[3] = NanNew<Integer>(errorCode);
args[4] = stringOrUndefined(fullname);
args[5] = stringOrUndefined(hosttarget);
args[6] = NanNew<Integer>( ntohs(port) );
Local<Object> buffer = NanNewBufferHandle(txtLen);
memcpy(Buffer::Data(buffer), txtRecord, txtLen);
args[7] = buffer;
if (serviceRef->GetContext().IsEmpty()) {
args[8] = NanUndefined();
} else {
args[8] = NanNew<Value>(serviceRef->GetContext());
}
NanMakeCallback(this_, callback, argc, args);
}
Image *Image::New(FIBITMAP* dib) {
NanScope();
Local<Value> arg = NanNew<Integer>(0);
Local<Object> obj = NanNew<FunctionTemplate>(constructor_template)->GetFunction()->NewInstance(1, &arg);
Image *image = ObjectWrap::Unwrap<Image>(obj);
int w,h,pitch;
FREE_IMAGE_TYPE type = FreeImage_GetImageType(dib);
obj->SetInternalField(0, NanNew<External>(dib));
obj->Set(NanNew<String>("width"), NanNew<Integer>(w=FreeImage_GetWidth(dib)));
obj->Set(NanNew<String>("height"), NanNew<Integer>(h=FreeImage_GetHeight(dib)));
obj->Set(NanNew<String>("bpp"), NanNew<Integer>((int)FreeImage_GetBPP(dib)));
obj->Set(NanNew<String>("pitch"), NanNew<Integer>(pitch=FreeImage_GetPitch(dib)));
obj->Set(NanNew<String>("type"), NanNew<Integer>(type));
obj->Set(NanNew<String>("redMask"), NanNew<Integer>((int)FreeImage_GetRedMask(dib)));
obj->Set(NanNew<String>("greenMask"), NanNew<Integer>((int)FreeImage_GetGreenMask(dib)));
obj->Set(NanNew<String>("blueMask"), NanNew<Integer>((int)FreeImage_GetBlueMask(dib)));
BYTE *bits = FreeImage_GetBits(dib);
obj->Set(NanNew<String>("buffer"), NanNewBufferHandle((char*) bits, h * pitch));
return image;
}
void EIO_AfterList(uv_work_t* req) {
NanScope();
ListBaton* data = static_cast<ListBaton*>(req->data);
v8::Handle<v8::Value> argv[2];
if(data->errorString[0]) {
argv[0] = v8::Exception::Error(v8::String::New(data->errorString));
argv[1] = v8::Undefined();
} else {
v8::Local<v8::Array> results = v8::Array::New();
int i = 0;
for(std::list<ListResultItem*>::iterator it = data->results.begin(); it != data->results.end(); ++it, i++) {
v8::Local<v8::Object> item = v8::Object::New();
item->Set(v8::String::New("comName"), v8::String::New((*it)->comName.c_str()));
item->Set(v8::String::New("manufacturer"), v8::String::New((*it)->manufacturer.c_str()));
item->Set(v8::String::New("serialNumber"), v8::String::New((*it)->serialNumber.c_str()));
item->Set(v8::String::New("pnpId"), v8::String::New((*it)->pnpId.c_str()));
item->Set(v8::String::New("locationId"), v8::String::New((*it)->locationId.c_str()));
item->Set(v8::String::New("vendorId"), v8::String::New((*it)->vendorId.c_str()));
item->Set(v8::String::New("productId"), v8::String::New((*it)->productId.c_str()));
results->Set(i, item);
}
argv[0] = v8::Undefined();
argv[1] = results;
}
data->callback->Call(2, argv);
delete data->callback;
for(std::list<ListResultItem*>::iterator it = data->results.begin(); it != data->results.end(); ++it) {
delete *it;
}
delete data;
delete req;
}
void EIO_AfterOpen(uv_work_t* req) {
NanScope();
OpenBaton* data = static_cast<OpenBaton*>(req->data);
v8::Handle<v8::Value> argv[2];
if(data->errorString[0]) {
argv[0] = v8::Exception::Error(v8::String::New(data->errorString));
argv[1] = v8::Undefined();
// not needed for AfterOpenSuccess
delete data->dataCallback;
delete data->errorCallback;
delete data->disconnectedCallback;
} else {
argv[0] = v8::Undefined();
argv[1] = v8::Int32::New(data->result);
AfterOpenSuccess(data->result, data->dataCallback, data->disconnectedCallback, data->errorCallback);
}
data->callback->Call(2, argv);
delete data->callback;
delete data;
delete req;
}
void DecodeBufferWorker::HandleOKCallback () {
NanScope();
Local<v8::Primitive> metadata;
if (_metadata == NULL) {
metadata = NanNull();
} else {
metadata = NanNew<String>(_metadata);
}
Local<Value> argv[] = {
NanNull(),
NanBufferUse(
(char *) _pixbuf,
_width * _height * _channels
),
NanNew<Number>(_width),
NanNew<Number>(_height),
NanNew<Number>(_channels),
NanNew<Boolean>(_trans),
metadata
};
callback->Call(7, argv);
}
void EIO_AfterWatchPort(uv_work_t* req) {
NanScope();
WatchPortBaton* data = static_cast<WatchPortBaton*>(req->data);
if(data->disconnected) {
data->disconnectedCallback->Call(0, NULL);
DisposeWatchPortCallbacks(data);
goto cleanup;
}
if(data->bytesRead > 0) {
v8::Handle<v8::Value> argv[1];
argv[0] = NanNewBufferHandle(data->buffer, data->bytesRead);
data->dataCallback->Call(1, argv);
} else if(data->errorCode > 0) {
if(data->errorCode == ERROR_INVALID_HANDLE && IsClosingHandle((int)data->fd)) {
DisposeWatchPortCallbacks(data);
goto cleanup;
} else {
v8::Handle<v8::Value> argv[1];
argv[0] = v8::Exception::Error(v8::String::New(data->errorString));
data->errorCallback->Call(1, argv);
Sleep(100); // prevent the errors from occurring too fast
}
}
AfterOpenSuccess((int)data->fd, data->dataCallback, data->disconnectedCallback, data->errorCallback);
cleanup:
delete data;
delete req;
}
static
void
DNSSD_API
OnServiceRegistered(DNSServiceRef sdRef, DNSServiceFlags flags,
DNSServiceErrorType errorCode, const char * name,
const char * serviceType, const char * domain, void * context)
{
if ( ! context) return;
NanScope();
ServiceRef * serviceRef = static_cast<ServiceRef*>(context);
Handle<Function> callback = serviceRef->GetCallback();
Handle<Object> this_ = serviceRef->GetThis();
if ( ! callback.IsEmpty() && ! this_.IsEmpty()) {
const size_t argc(7);
Local<Value> args[argc];
args[0] = NanObjectWrapHandle(serviceRef);
args[1] = NanNew<Integer>(flags);
args[2] = NanNew<Integer>(errorCode);
args[3] = stringOrUndefined(name);
args[4] = stringOrUndefined(serviceType);
args[5] = stringOrUndefined(domain);
if (serviceRef->GetContext().IsEmpty()) {
args[6] = NanUndefined();
} else {
args[6] = NanNew<Value>(serviceRef->GetContext());
}
NanMakeCallback(this_, callback, argc, args);
}
}
// Sets up everything for the Logger object when the addon is initialized
void Logger::Initialize(Handle<Object> target) {
NanScope();
Local<FunctionTemplate> lcons = NanNew<FunctionTemplate>(Logger::New);
lcons->InstanceTemplate()->SetInternalFieldCount(1);
lcons->SetClassName(NanNew("Logger"));
// Static methods
NODE_SET_METHOD(lcons->GetFunction(), "getSeverity", Logger::get_severity);
NODE_SET_METHOD(lcons->GetFunction(), "setSeverity", Logger::set_severity);
// Constants
NODE_MAPNIK_DEFINE_CONSTANT(lcons->GetFunction(),"NONE",mapnik::logger::severity_type::none);
NODE_MAPNIK_DEFINE_CONSTANT(lcons->GetFunction(),"ERROR",mapnik::logger::severity_type::error);
NODE_MAPNIK_DEFINE_CONSTANT(lcons->GetFunction(),"DEBUG",mapnik::logger::severity_type::debug);
NODE_MAPNIK_DEFINE_CONSTANT(lcons->GetFunction(),"WARN",mapnik::logger::severity_type::warn);
// What about booleans like:
// ENABLE_STATS
// ENABLE_LOG
// DEFAULT_LOG_SEVERITY
// RENDERING_STATS
// DEBUG
// Not sure if needed...
target->Set(NanNew("Logger"),lcons->GetFunction());
NanAssignPersistent(constructor, lcons);
}
/*
DESCRIPTION
Callback function of Get Connection method
PARAMETERS:
UV queue work block
NOTES:
Connection handle is formed and handed over to JS.
*/
void Oracledb::Async_AfterGetConnection (uv_work_t *req)
{
NanScope();
connectionBaton *connBaton = (connectionBaton*)req->data;
v8::TryCatch tc;
Handle<Value> argv[2];
if( !(connBaton->error).empty() )
{
argv[0] = v8::Exception::Error(NanNew<v8::String>( (connBaton->error).c_str() ));
argv[1] = NanNull();
}
else
{
argv[0] = NanUndefined();
Local<FunctionTemplate> lft = NanNew(Connection::connectionTemplate_s);
Handle<Object> connection = lft->GetFunction()-> NewInstance();
(ObjectWrap::Unwrap<Connection> (connection))->
setConnection( connBaton->dpiconn,
connBaton->oracledb );
argv[1] = connection;
}
Local<Function> callback = NanNew(connBaton->cb);
delete connBaton;
NanMakeCallback( NanGetCurrentContext()->Global(),
callback, 2, argv );
if(tc.HasCaught())
node::FatalException(tc);
}
void PasteWorker::HandleOKCallback () {
NanScope();
Local<Value> argv[] = {
NanNull()
};
callback->Call(1, argv);
}
void HandleOKCallback () {
NanScope();
v8::Local<v8::Object> handle = GetFromPersistent("buffer");
v8::Local<v8::Value> argv[] = { handle };
callback->Call(1, argv);
}
void Init (v8::Handle<v8::Object> target) {
NanScope();
v8::Local<v8::FunctionTemplate> returnString = v8::FunctionTemplate::New(ReturnString);
NanAssignPersistent(v8::FunctionTemplate, returnString_persistent, returnString);
target->Set(
NanSymbol("returnString")
, returnString->GetFunction()
);
v8::Local<v8::FunctionTemplate> returnCString = v8::FunctionTemplate::New(ReturnCString);
NanAssignPersistent(v8::FunctionTemplate, returnCString_persistent, returnCString);
target->Set(
NanSymbol("returnCString")
, returnCString->GetFunction()
);
v8::Local<v8::FunctionTemplate> compareCStringToBuffer = v8::FunctionTemplate::New(CompareCStringToBuffer);
NanAssignPersistent(v8::FunctionTemplate, compareCStringToBuffer_persistent, compareCStringToBuffer);
target->Set(
NanSymbol("compareCStringToBuffer")
, compareCStringToBuffer->GetFunction()
);
v8::Local<v8::FunctionTemplate> compareRawStringToBuffer = v8::FunctionTemplate::New(CompareRawStringToBuffer);
NanAssignPersistent(v8::FunctionTemplate, compareRawStringToBuffer_persistent, compareRawStringToBuffer);
target->Set(
NanSymbol("compareRawStringToBuffer")
, compareRawStringToBuffer->GetFunction()
);
}
static
void
DNSSD_API
OnServiceChanged(DNSServiceRef sdRef, DNSServiceFlags flags,
uint32_t interfaceIndex, DNSServiceErrorType errorCode,
const char * serviceName, const char * serviceType,
const char * replyDomain, void * context)
{
NanScope();
ServiceRef * serviceRef = static_cast<ServiceRef*>(context);
Handle<Function> callback = serviceRef->GetCallback();
Handle<Object> this_ = serviceRef->GetThis();
const size_t argc(8);
Local<Value> args[argc];
args[0] = NanObjectWrapHandle(serviceRef);
args[1] = NanNew<Integer>(flags);
args[2] = NanNew<Uint32>(interfaceIndex);
args[3] = NanNew<Integer>(errorCode);
args[4] = stringOrUndefined(serviceName);
args[5] = stringOrUndefined(serviceType);
args[6] = stringOrUndefined(replyDomain);
if (serviceRef->GetContext().IsEmpty()) {
args[7] = NanUndefined();
} else {
args[7] = NanNew<Value>(serviceRef->GetContext());
}
NanMakeCallback(this_, callback, argc, args);
}
void EIO_AfterUpdate(uv_work_t* req) {
NanScope();
OpenBaton* data = static_cast<OpenBaton*>(req->data);
v8::Handle<v8::Value> argv[2];
if(data->errorString[0]) {
argv[0] = v8::Exception::Error(NanNew<v8::String>(data->errorString));
argv[1] = NanUndefined();
// not needed for AfterOpenSuccess
delete data->dataCallback;
delete data->errorCallback;
delete data->disconnectedCallback;
} else {
argv[0] = NanUndefined();
argv[1] = NanNew<v8::Int32>(data->result);
int fd = argv[1]->ToInt32()->Int32Value();
newQForFD(fd);
AfterOpenSuccess(data->result, data->dataCallback, data->disconnectedCallback, data->errorCallback);
}
data->callback->Call(2, argv);
delete data->platformOptions;
delete data->callback;
delete data;
delete req;
}
int SerializePart(google::protobuf::Message *message, Handle<Object> subj) {
NanScope();
// get a reflection
const Reflection *r = message->GetReflection();
const Descriptor *d = message->GetDescriptor();
// build a list of required properties
vector<string> required;
for (int i = 0; i < d->field_count(); i++) {
const FieldDescriptor *field = d->field(i);
if (field->is_required())
required.push_back(field->name());
}
// build a reflection
// get properties of passed object
Local<Array> properties = subj->GetPropertyNames();
uint32_t len = properties->Length();
// check that all required properties are present
for (uint32_t i = 0; i < required.size(); i++) {
Handle<String> key = String::New(required.at(i).c_str());
if (!subj->Has(key))
return -1;
}
for (uint32_t i = 0; i < len; i++) {
Local<Value> property = properties->Get(i);
Local<String> property_s = property->ToString();
if (*property_s == NULL)
continue;
String::Utf8Value temp(property);
std::string propertyName = std::string(*temp);
const FieldDescriptor *field = d->FindFieldByName(propertyName);
if (field == NULL) continue;
Local<Value> val = subj->Get(property);
if (field->is_repeated()) {
if (!val->IsArray())
continue;
Handle<Array> array = val.As<Array>();
int len = array->Length();
for (int i = 0; i < len; i++)
SerializeField(message, r, field, array->Get(i));
} else {
SerializeField(message, r, field, val);
}
}
return 0;
}
void HandleProgressCallback(const char *data, size_t size) {
NanScope();
v8::Local<v8::Value> argv[] = {
NanNew<v8::Integer>(*reinterpret_cast<int*>(const_cast<char*>(data)))
};
progress->Call(1, argv);
}
void Grid::EIO_AfterEncode(uv_work_t* req)
{
NanScope();
encode_grid_baton_t *closure = static_cast<encode_grid_baton_t *>(req->data);
if (closure->error)
{
// There is no known ways to throw errors in the processing prior
// so simply removing the following from coverage
/* LCOV_EXCL_START */
Local<Value> argv[1] = { NanError(closure->error_name.c_str()) };
NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 1, argv);
/* LCOV_EXCL_END */
}
else
{
// convert key order to proper javascript array
Local<Array> keys_a = NanNew<Array>(closure->key_order.size());
std::vector<std::string>::iterator it;
unsigned int i;
for (it = closure->key_order.begin(), i = 0; it < closure->key_order.end(); ++it, ++i)
{
keys_a->Set(i, NanNew((*it).c_str()));
}
mapnik::grid const& grid_type = *closure->g->get();
// gather feature data
Local<Object> feature_data = NanNew<Object>();
if (closure->add_features) {
node_mapnik::write_features<mapnik::grid>(grid_type,
feature_data,
closure->key_order);
}
// Create the return hash.
Local<Object> json = NanNew<Object>();
Local<Array> grid_array = NanNew<Array>(closure->lines.size());
unsigned array_size = std::ceil(grid_type.width()/static_cast<float>(closure->resolution));
for (unsigned j=0;j<closure->lines.size();++j)
{
node_mapnik::grid_line_type const & line = closure->lines[j];
grid_array->Set(j, NanNew<String>(line.get(),array_size));
}
json->Set(NanNew("grid"), grid_array);
json->Set(NanNew("keys"), keys_a);
json->Set(NanNew("data"), feature_data);
Local<Value> argv[2] = { NanNull(), NanNew(json) };
NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 2, argv);
}
closure->g->Unref();
NanDisposePersistent(closure->cb);
delete closure;
}
OpenBatonPlatformOptions* ParsePlatformOptions(const v8::Local<v8::Object>& options) {
NanScope();
UnixPlatformOptions* result = new UnixPlatformOptions();
result->vmin = options->Get(NanNew<v8::String>("vmin"))->ToInt32()->Int32Value();
result->vtime = options->Get(NanNew<v8::String>("vtime"))->ToInt32()->Int32Value();
return result;
}
static inline NAN_METHOD(register_fonts)
{
NanScope();
try
{
if (args.Length() == 0 || !args[0]->IsString())
{
NanThrowTypeError("first argument must be a path to a directory of fonts");
NanReturnUndefined();
}
bool found = false;
std::vector<std::string> const names_before = mapnik::freetype_engine::face_names();
// option hash
if (args.Length() == 2){
if (!args[1]->IsObject())
{
NanThrowTypeError("second argument is optional, but if provided must be an object, eg. { recurse:Boolean }");
NanReturnUndefined();
}
Local<Object> options = args[1].As<Object>();
if (options->Has(NanNew("recurse")))
{
Local<Value> recurse_opt = options->Get(NanNew("recurse"));
if (!recurse_opt->IsBoolean())
{
NanThrowTypeError("'recurse' must be a Boolean");
NanReturnUndefined();
}
bool recurse = recurse_opt->BooleanValue();
std::string path = TOSTR(args[0]);
found = mapnik::freetype_engine::register_fonts(path,recurse);
}
}
else
{
std::string path = TOSTR(args[0]);
found = mapnik::freetype_engine::register_fonts(path);
}
std::vector<std::string> const& names_after = mapnik::freetype_engine::face_names();
if (names_after.size() == names_before.size())
found = false;
NanReturnValue(NanNew(found));
}
catch (std::exception const& ex)
{
NanThrowError(ex.what());
NanReturnUndefined();
}
}
void extract_options(Local<Object> options, void* cptr, sass_context_wrapper* ctx_w, bool is_file, bool is_sync) {
NanScope();
struct Sass_Context* ctx;
NanAssignPersistent(ctx_w->result, options->Get(NanNew("result"))->ToObject());
if (is_file) {
ctx_w->fctx = (struct Sass_File_Context*) cptr;
ctx = sass_file_context_get_context(ctx_w->fctx);
}
else {
ctx_w->dctx = (struct Sass_Data_Context*) cptr;
ctx = sass_data_context_get_context(ctx_w->dctx);
}
struct Sass_Options* sass_options = sass_context_get_options(ctx);
ctx_w->importer_callback = NULL;
ctx_w->is_sync = is_sync;
if (!is_sync) {
ctx_w->request.data = ctx_w;
// async (callback) style
Local<Function> success_callback = Local<Function>::Cast(options->Get(NanNew("success")));
Local<Function> error_callback = Local<Function>::Cast(options->Get(NanNew("error")));
ctx_w->success_callback = new NanCallback(success_callback);
ctx_w->error_callback = new NanCallback(error_callback);
}
Local<Function> importer_callback = Local<Function>::Cast(options->Get(NanNew("importer")));
if (importer_callback->IsFunction()) {
ctx_w->importer_callback = new NanCallback(importer_callback);
uv_async_init(uv_default_loop(), &ctx_w->async, (uv_async_cb)dispatched_async_uv_callback);
sass_option_set_importer(sass_options, sass_make_importer(sass_importer, ctx_w));
}
if(!is_file) {
sass_option_set_input_path(sass_options, create_string(options->Get(NanNew("file"))));
}
sass_option_set_output_path(sass_options, create_string(options->Get(NanNew("outFile"))));
sass_option_set_image_path(sass_options, create_string(options->Get(NanNew("imagePath"))));
sass_option_set_output_style(sass_options, (Sass_Output_Style)options->Get(NanNew("style"))->Int32Value());
sass_option_set_is_indented_syntax_src(sass_options, options->Get(NanNew("indentedSyntax"))->BooleanValue());
sass_option_set_source_comments(sass_options, options->Get(NanNew("comments"))->BooleanValue());
sass_option_set_omit_source_map_url(sass_options, options->Get(NanNew("omitSourceMapUrl"))->BooleanValue());
sass_option_set_source_map_embed(sass_options, options->Get(NanNew("sourceMapEmbed"))->BooleanValue());
sass_option_set_source_map_contents(sass_options, options->Get(NanNew("sourceMapContents"))->BooleanValue());
sass_option_set_source_map_file(sass_options, create_string(options->Get(NanNew("sourceMap"))));
sass_option_set_include_path(sass_options, create_string(options->Get(NanNew("paths"))));
sass_option_set_precision(sass_options, options->Get(NanNew("precision"))->Int32Value());
}
void ExecuteWorker::HandleOKCallback() {
NanScope();
v8::Local<v8::Value> argv[] = {
NanNull(),
NanNew(json.c_str())
};
callback->Call(2, argv);
};
void SpatialReference::Initialize(Handle<Object> target)
{
NanScope();
Local<FunctionTemplate> lcons = NanNew<FunctionTemplate>(SpatialReference::New);
lcons->InstanceTemplate()->SetInternalFieldCount(1);
lcons->SetClassName(NanNew("SpatialReference"));
NODE_SET_METHOD(lcons, "fromUserInput", fromUserInput);
NODE_SET_METHOD(lcons, "fromWKT", fromWKT);
NODE_SET_METHOD(lcons, "fromProj4", fromProj4);
NODE_SET_METHOD(lcons, "fromEPSG", fromEPSG);
NODE_SET_METHOD(lcons, "fromEPSGA", fromEPSGA);
NODE_SET_METHOD(lcons, "fromESRI", fromESRI);
NODE_SET_METHOD(lcons, "fromWMSAUTO", fromWMSAUTO);
NODE_SET_METHOD(lcons, "fromXML", fromXML);
NODE_SET_METHOD(lcons, "fromURN", fromURN);
NODE_SET_METHOD(lcons, "fromCRSURL", fromCRSURL);
NODE_SET_METHOD(lcons, "fromURL", fromURL);
NODE_SET_METHOD(lcons, "fromMICoordSys", fromMICoordSys);
NODE_SET_PROTOTYPE_METHOD(lcons, "toString", toString);
NODE_SET_PROTOTYPE_METHOD(lcons, "toWKT", exportToWKT);
NODE_SET_PROTOTYPE_METHOD(lcons, "toPrettyWKT", exportToPrettyWKT);
NODE_SET_PROTOTYPE_METHOD(lcons, "toProj4", exportToProj4);
NODE_SET_PROTOTYPE_METHOD(lcons, "toXML", exportToXML);
NODE_SET_PROTOTYPE_METHOD(lcons, "clone", clone);
NODE_SET_PROTOTYPE_METHOD(lcons, "cloneGeogCS", cloneGeogCS);
NODE_SET_PROTOTYPE_METHOD(lcons, "setWellKnownGeogCS", setWellKnownGeogCS);
NODE_SET_PROTOTYPE_METHOD(lcons, "morphToESRI", morphToESRI);
NODE_SET_PROTOTYPE_METHOD(lcons, "morphFromESRI", morphFromESRI);
NODE_SET_PROTOTYPE_METHOD(lcons, "EPSGTreatsAsLatLong", EPSGTreatsAsLatLong);
NODE_SET_PROTOTYPE_METHOD(lcons, "EPSGTreatsAsNorthingEasting", EPSGTreatsAsNorthingEasting);
NODE_SET_PROTOTYPE_METHOD(lcons, "getLinearUnits", getLinearUnits);
NODE_SET_PROTOTYPE_METHOD(lcons, "getAngularUnits", getAngularUnits);
NODE_SET_PROTOTYPE_METHOD(lcons, "isGeocentric", isGeocentric);
NODE_SET_PROTOTYPE_METHOD(lcons, "isProjected", isProjected);
NODE_SET_PROTOTYPE_METHOD(lcons, "isLocal", isLocal);
NODE_SET_PROTOTYPE_METHOD(lcons, "isVectical", isVertical);
NODE_SET_PROTOTYPE_METHOD(lcons, "isCompound", isCompound);
NODE_SET_PROTOTYPE_METHOD(lcons, "isSameGeogCS", isSameGeogCS);
NODE_SET_PROTOTYPE_METHOD(lcons, "isSameVertCS", isSameVertCS);
NODE_SET_PROTOTYPE_METHOD(lcons, "isSame", isSame);
NODE_SET_PROTOTYPE_METHOD(lcons, "getAuthorityName", getAuthorityName);
NODE_SET_PROTOTYPE_METHOD(lcons, "getAuthorityCode", getAuthorityCode);
NODE_SET_PROTOTYPE_METHOD(lcons, "getAttrValue", getAttrValue);
NODE_SET_PROTOTYPE_METHOD(lcons, "autoIdentifyEPSG", autoIdentifyEPSG);
NODE_SET_PROTOTYPE_METHOD(lcons, "validate", validate);
target->Set(NanNew("SpatialReference"), lcons->GetFunction());
NanAssignPersistent(constructor, lcons);
}
static void Init(v8::Handle<v8::Object> exports) {
NanScope();
v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
tpl->SetClassName(NanNew("MyObject"));
tpl->InstanceTemplate()->SetInternalFieldCount(1);
NODE_SET_PROTOTYPE_METHOD(tpl, "getHandle", GetHandle);
NanAssignPersistent(constructor, tpl->GetFunction());
exports->Set(NanNew("MyObject"), tpl->GetFunction());
}
bool Projection::HasInstance(Handle<Value> val)
{
NanScope();
if (!val->IsObject()) return false;
Handle<Object> obj = val.As<Object>();
if (NanNew(constructor)->HasInstance(obj))
return true;
return false;
}
BufferWorker(
NanCallback *callback
, int milliseconds
, v8::Local<v8::Object> &bufferHandle
)
: NanAsyncWorker(callback), milliseconds(milliseconds) {
NanScope();
SaveToPersistent("buffer", bufferHandle);
}
static NAN_METHOD(ClosePort)
{
NanScope();
NodeMidiInput* input = node::ObjectWrap::Unwrap<NodeMidiInput>(args.This());
if (input->in->isPortOpen()) {
input->Unref();
}
input->in->closePort();
uv_close((uv_handle_t*)&input->message_async, NULL);
NanReturnUndefined();
}
static inline NAN_METHOD(available_input_plugins)
{
NanScope();
std::vector<std::string> names = mapnik::datasource_cache::instance().plugin_names();
Local<Array> a = NanNew<Array>(names.size());
for (unsigned i = 0; i < names.size(); ++i)
{
a->Set(i, NanNew(names[i].c_str()));
}
NanReturnValue(a);
}
static inline NAN_METHOD(available_font_faces)
{
NanScope();
std::vector<std::string> const& names = mapnik::freetype_engine::face_names();
Local<Array> a = NanNew<Array>(names.size());
for (unsigned i = 0; i < names.size(); ++i)
{
a->Set(i, NanNew(names[i].c_str()));
}
NanReturnValue(a);
}
void NodeFileSource::Init(v8::Handle<v8::Object> target) {
NanScope();
v8::Local<v8::FunctionTemplate> t = NanNew<v8::FunctionTemplate>(New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(NanNew("FileSource"));
NanAssignPersistent(constructorTemplate, t);
target->Set(NanNew("FileSource"), t->GetFunction());
}
