JSBool WrapObject(JSContext *cx, JSObject *scope, jsval v, jsval *vp) { // This might be redundant if called from XPC_SJOW_Construct, but it should // be cheap in that case. JSObject *objToWrap = UnsafeUnwrapSecurityWrapper(cx, JSVAL_TO_OBJECT(v)); if (!objToWrap || JS_TypeOfValue(cx, OBJECT_TO_JSVAL(objToWrap)) == JSTYPE_XML) { return ThrowException(NS_ERROR_INVALID_ARG, cx); } // Prevent script created Script objects from ever being wrapped // with XPCSafeJSObjectWrapper, and never let the eval function // object be directly wrapped. if (objToWrap->getClass() == &js_ScriptClass || (JS_ObjectIsFunction(cx, objToWrap) && JS_GetFunctionFastNative(cx, JS_ValueToFunction(cx, v)) == XPCWrapper::sEvalNative)) { return ThrowException(NS_ERROR_INVALID_ARG, cx); } XPCWrappedNativeScope *xpcscope = XPCWrappedNativeScope::FindInJSObjectScope(cx, scope); NS_ASSERTION(xpcscope, "what crazy scope are we in?"); XPCWrappedNative *wrappedNative; WrapperType type = xpcscope->GetWrapperFor(cx, objToWrap, SJOW, &wrappedNative); // NB: We allow XOW here because we're as restrictive as it is (and we know // we're same origin here). if (type != NONE && type != XOW && !(type & SJOW)) { return ThrowException(NS_ERROR_INVALID_ARG, cx); } SLIM_LOG_WILL_MORPH(cx, objToWrap); if (IS_SLIM_WRAPPER(objToWrap) && !MorphSlimWrapper(cx, objToWrap)) { return ThrowException(NS_ERROR_FAILURE, cx); } XPCWrappedNative *wn = XPCWrappedNative::GetWrappedNativeOfJSObject(cx, objToWrap); if (wn) { CheckWindow(wn); } JSObject *wrapperObj = JS_NewObjectWithGivenProto(cx, js::Jsvalify(&SJOWClass), nsnull, scope); if (!wrapperObj) { // JS_NewObjectWithGivenProto already threw. return JS_FALSE; } *vp = OBJECT_TO_JSVAL(wrapperObj); if (!JS_SetReservedSlot(cx, wrapperObj, XPCWrapper::sWrappedObjSlot, OBJECT_TO_JSVAL(objToWrap)) || !JS_SetReservedSlot(cx, wrapperObj, XPCWrapper::sFlagsSlot, JSVAL_ZERO)) { return JS_FALSE; } return JS_TRUE; }
Handle<Value> ExampleProxy::setMessage(const Arguments& args) { LOGD(TAG, "setMessage()"); HandleScope scope; JNIEnv *env = titanium::JNIScope::getEnv(); if (!env) { return titanium::JSException::GetJNIEnvironmentError(); } static jmethodID methodID = NULL; if (!methodID) { methodID = env->GetMethodID(ExampleProxy::javaClass, "setMessage", "(Ljava/lang/String;)V"); if (!methodID) { const char *error = "Couldn't find proxy method 'setMessage' with signature '(Ljava/lang/String;)V'"; LOGE(TAG, error); return titanium::JSException::Error(error); } } titanium::Proxy* proxy = titanium::Proxy::unwrap(args.Holder()); if (args.Length() < 1) { char errorStringBuffer[100]; sprintf(errorStringBuffer, "setMessage: Invalid number of arguments. Expected 1 but got %d", args.Length()); return ThrowException(Exception::Error(String::New(errorStringBuffer))); } jvalue jArguments[1]; if (!args[0]->IsNull()) { Local<Value> arg_0 = args[0]; jArguments[0].l = titanium::TypeConverter::jsValueToJavaString(env, arg_0); } else { jArguments[0].l = NULL; } jobject javaProxy = proxy->getJavaObject(); env->CallVoidMethodA(javaProxy, methodID, jArguments); if (!JavaObject::useGlobalRefs) { env->DeleteLocalRef(javaProxy); } env->DeleteLocalRef(jArguments[0].l); if (env->ExceptionCheck()) { titanium::JSException::fromJavaException(); env->ExceptionClear(); } return v8::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::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(); }
// @TODO: convert this to EIO. It's currently doing all the work in the main // thread, and just provides an async interface. Handle<Value> Grid::encode(const Arguments& args) // format, resolution { HandleScope scope; Grid* g = ObjectWrap::Unwrap<Grid>(args.This()); // defaults std::string format("utf"); unsigned int resolution = 4; bool add_features = true; // accept custom format if (args.Length() >= 1){ if (!args[0]->IsString()) return ThrowException(Exception::TypeError( String::New("first arg, 'format' must be a string"))); format = TOSTR(args[0]); } // options hash if (args.Length() >= 2) { if (!args[1]->IsObject()) return ThrowException(Exception::TypeError( String::New("optional second arg must be an options object"))); Local<Object> options = args[1]->ToObject(); 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("'resolution' must be an Integer"))); resolution = bind_opt->IntegerValue(); } if (options->Has(String::New("features"))) { Local<Value> bind_opt = options->Get(String::New("features")); if (!bind_opt->IsBoolean()) return ThrowException(Exception::TypeError( String::New("'features' must be an Boolean"))); add_features = bind_opt->BooleanValue(); } } // ensure callback is a function if (!args[args.Length()-1]->IsFunction()) return ThrowException(Exception::TypeError( String::New("last argument must be a callback function"))); Local<Function> callback = Local<Function>::Cast(args[args.Length()-1]); try { Local<Array> grid_array = Array::New(); std::vector<mapnik::grid::lookup_type> key_order; node_mapnik::grid2utf<mapnik::grid>(*g->get(),grid_array,key_order,resolution); // convert key order to proper javascript array Local<Array> keys_a = Array::New(key_order.size()); std::vector<std::string>::iterator it; unsigned int i; for (it = key_order.begin(), i = 0; it < key_order.end(); ++it, ++i) { keys_a->Set(i, String::New((*it).c_str())); } // gather feature data Local<Object> feature_data = Object::New(); if (add_features) { node_mapnik::write_features<mapnik::grid>(*g->get(), feature_data, key_order ); } // Create the return hash. Local<Object> json = Object::New(); json->Set(String::NewSymbol("grid"), grid_array); json->Set(String::NewSymbol("keys"), keys_a); json->Set(String::NewSymbol("data"), feature_data); TryCatch try_catch; Local<Value> argv[2] = { Local<Value>::New(Null()), Local<Value>::New(json) }; callback->Call(Context::GetCurrent()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } } catch (std::exception & ex) { Local<Value> argv[1] = { Exception::Error(String::New(ex.what())) }; callback->Call(Context::GetCurrent()->Global(), 1, argv); } return scope.Close(Undefined()); }
Handle<Value> ViewProxy::setMapType(const Arguments& args) { LOGD(TAG, "setMapType()"); HandleScope scope; JNIEnv *env = titanium::JNIScope::getEnv(); if (!env) { return titanium::JSException::GetJNIEnvironmentError(); } static jmethodID methodID = NULL; if (!methodID) { methodID = env->GetMethodID(ViewProxy::javaClass, "setMapType", "(I)V"); if (!methodID) { const char *error = "Couldn't find proxy method 'setMapType' with signature '(I)V'"; LOGE(TAG, error); return titanium::JSException::Error(error); } } titanium::Proxy* proxy = titanium::Proxy::unwrap(args.Holder()); if (args.Length() < 1) { char errorStringBuffer[100]; sprintf(errorStringBuffer, "setMapType: Invalid number of arguments. Expected 1 but got %d", args.Length()); return ThrowException(Exception::Error(String::New(errorStringBuffer))); } jvalue jArguments[1]; if ((titanium::V8Util::isNaN(args[0]) && !args[0]->IsUndefined()) || args[0]->ToString()->Length() == 0) { const char *error = "Invalid value, expected type Number."; LOGE(TAG, error); return titanium::JSException::Error(error); } if (!args[0]->IsNull()) { Local<Number> arg_0 = args[0]->ToNumber(); jArguments[0].i = titanium::TypeConverter::jsNumberToJavaInt(env, arg_0); } else { jArguments[0].i = NULL; } jobject javaProxy = proxy->getJavaObject(); env->CallVoidMethodA(javaProxy, methodID, jArguments); if (!JavaObject::useGlobalRefs) { env->DeleteLocalRef(javaProxy); } if (env->ExceptionCheck()) { titanium::JSException::fromJavaException(); env->ExceptionClear(); } return v8::Undefined(); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d P W P I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ReadPWPImage reads a Seattle Film Works multi-image file and returns % it. It allocates the memory necessary for the new Image structure and % returns a pointer to the new image. % % The format of the ReadPWPImage method is: % % Image *ReadPWPImage(const ImageInfo *image_info,ExceptionInfo *exception) % % A description of each parameter follows: % % o image: Method ReadPWPImage returns a pointer to the image after % reading. A null image is returned if there is a memory shortage or % if the image cannot be read. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o exception: return any errors or warnings in this structure. % % */ static Image *ReadPWPImage(const ImageInfo *image_info,ExceptionInfo *exception) { FILE *file; Image *image, *next_image, *pwp_image; ImageInfo *clone_info; int c; MonitorHandler handler; register Image *p; register unsigned long i; size_t count; unsigned char magick[MaxTextExtent]; unsigned int status; unsigned long filesize; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=(Image *) NULL; pwp_image=AllocateImage(image_info); status=OpenBlob(image_info,pwp_image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,pwp_image); count=ReadBlob(pwp_image,5,(char *) magick); if ((count == 0) || (LocaleNCompare((char *) magick,"SFW95",5) != 0)) ThrowReaderException(CorruptImageError,ImproperImageHeader,pwp_image); clone_info=CloneImageInfo(image_info); clone_info->blob=(void *) NULL; clone_info->length=0; for ( ; ; ) { for (c=ReadBlobByte(pwp_image); c != EOF; c=ReadBlobByte(pwp_image)) { for (i=0; i < 17; i++) magick[i]=magick[i+1]; magick[17]=(unsigned char) c; if (LocaleNCompare((char *) (magick+12),"SFW94A",6) == 0) break; } if (c == EOF) break; if (LocaleNCompare((char *) (magick+12),"SFW94A",6) != 0) { ThrowReaderException(CorruptImageError,ImproperImageHeader,pwp_image); } /* Dump SFW image to a temporary file. */ file=AcquireTemporaryFileStream(clone_info->filename,BinaryFileIOMode); if (file == (FILE *) NULL) { char filename[MaxTextExtent]; (void) strcpy(filename,clone_info->filename); DestroyImageInfo(clone_info); ThrowReaderTemporaryFileException(filename); } (void) fwrite("SFW94A",1,6,file); filesize=(65535L*magick[2]+256L*magick[1]+magick[0]) & 0xFFFFFFFF; for (i=0; i < filesize; i++) { if ((c=ReadBlobByte(pwp_image)) == EOF) break; (void) fputc(c,file); } (void) fclose(file); if (c == EOF) break; handler=SetMonitorHandler((MonitorHandler) NULL); next_image=ReadImage(clone_info,exception); (void) LiberateTemporaryFile(clone_info->filename); (void) SetMonitorHandler(handler); if (next_image == (Image *) NULL) break; FormatString(next_image->filename,"slide_%02ld.sfw",next_image->scene); if (image == (Image *) NULL) image=next_image; else { /* Link image into image list. */ for (p=image; p->next != (Image *) NULL; p=p->next); next_image->previous=p; next_image->scene=p->scene+1; p->next=next_image; } if (image_info->subrange != 0) if (next_image->scene >= (image_info->subimage+image_info->subrange-1)) break; if (!MagickMonitorFormatted(TellBlob(pwp_image),GetBlobSize(image), &image->exception,LoadImagesText, image->filename)) break; } DestroyImageInfo(clone_info); CloseBlob(pwp_image); DestroyImage(pwp_image); if (EOFBlob(image)) ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, image->filename); CloseBlob(image); return(image); }
Handle<Value> Grid::encode(const Arguments& args) // format, resolution { HandleScope scope; Grid* g = ObjectWrap::Unwrap<Grid>(args.This()); // defaults std::string format("utf"); unsigned int resolution = 4; bool add_features = true; // accept custom format if (args.Length() >= 1){ if (!args[0]->IsString()) return ThrowException(Exception::TypeError( String::New("first arg, 'format' must be a string"))); format = TOSTR(args[0]); } // options hash if (args.Length() >= 2) { if (!args[1]->IsObject()) return ThrowException(Exception::TypeError( String::New("optional second arg must be an options object"))); Local<Object> options = args[1]->ToObject(); 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("'resolution' must be an Integer"))); resolution = bind_opt->IntegerValue(); } if (options->Has(String::New("features"))) { Local<Value> bind_opt = options->Get(String::New("features")); if (!bind_opt->IsBoolean()) return ThrowException(Exception::TypeError( String::New("'features' must be an Boolean"))); add_features = bind_opt->BooleanValue(); } } // ensure callback is a function if (!args[args.Length()-1]->IsFunction()) return ThrowException(Exception::TypeError( String::New("last argument must be a callback function"))); Local<Function> callback = Local<Function>::Cast(args[args.Length()-1]); encode_grid_baton_t *closure = new encode_grid_baton_t(); closure->request.data = closure; closure->g = g; closure->format = format; closure->error = false; closure->resolution = resolution; closure->add_features = add_features; closure->cb = Persistent<Function>::New(Handle<Function>::Cast(callback)); // todo - reserve lines size? uv_queue_work(uv_default_loop(), &closure->request, EIO_Encode, EIO_AfterEncode); g->Ref(); return Undefined(); }
void CScript_LayoutPseudoModel::Script_LayoutPseudoModel_HWXY( CFXJSE_Arguments* pArguments, XFA_LAYOUTMODEL_HWXY layoutModel) { int32_t iLength = pArguments->GetLength(); if (iLength < 1 || iLength > 3) { const FX_WCHAR* methodName = nullptr; switch (layoutModel) { case XFA_LAYOUTMODEL_H: methodName = L"h"; break; case XFA_LAYOUTMODEL_W: methodName = L"w"; break; case XFA_LAYOUTMODEL_X: methodName = L"x"; break; case XFA_LAYOUTMODEL_Y: methodName = L"y"; break; } ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, methodName); return; } CXFA_Node* pNode = nullptr; CFX_WideString wsUnit(L"pt"); int32_t iIndex = 0; if (iLength >= 1) { pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0)); } if (iLength >= 2) { CFX_ByteString bsUnit = pArguments->GetUTF8String(1); if (!bsUnit.IsEmpty()) { wsUnit = CFX_WideString::FromUTF8(bsUnit.AsStringC()); } } if (iLength >= 3) { iIndex = pArguments->GetInt32(2); } if (!pNode) { return; } CXFA_LayoutProcessor* pDocLayout = m_pDocument->GetDocLayout(); if (!pDocLayout) { return; } CFX_RectF rtRect; CXFA_Measurement measure; CXFA_LayoutItem* pLayoutItem = pDocLayout->GetLayoutItem(pNode); if (!pLayoutItem) { return; } while (iIndex > 0 && pLayoutItem) { pLayoutItem = pLayoutItem->GetNext(); iIndex--; } CFXJSE_Value* pValue = pArguments->GetReturnValue(); if (!pLayoutItem) { pValue->SetFloat(0); return; } pLayoutItem->GetRect(rtRect, TRUE); switch (layoutModel) { case XFA_LAYOUTMODEL_H: measure.Set(rtRect.height, XFA_UNIT_Pt); break; case XFA_LAYOUTMODEL_W: measure.Set(rtRect.width, XFA_UNIT_Pt); break; case XFA_LAYOUTMODEL_X: measure.Set(rtRect.left, XFA_UNIT_Pt); break; case XFA_LAYOUTMODEL_Y: measure.Set(rtRect.top, XFA_UNIT_Pt); break; } XFA_UNIT unit = measure.GetUnit(wsUnit.AsStringC()); FX_FLOAT fValue = measure.ToUnit(unit); fValue = FXSYS_round(fValue * 1000) / 1000.0f; if (pValue) pValue->SetFloat(fValue); }
void CScript_HostPseudoModel::Print(CFXJSE_Arguments* pArguments) { if (!m_pDocument->GetScriptContext()->IsRunAtClient()) { return; } int32_t iLength = pArguments->GetLength(); if (iLength != 8) { ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"print"); return; } CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); if (!pNotify) { return; } CXFA_FFDoc* hDoc = pNotify->GetHDOC(); uint32_t dwOptions = 0; FX_BOOL bShowDialog = TRUE; if (iLength >= 1) { bShowDialog = pArguments->GetInt32(0) == 0 ? FALSE : TRUE; } if (bShowDialog) { dwOptions |= XFA_PRINTOPT_ShowDialog; } int32_t nStartPage = 0; if (iLength >= 2) { nStartPage = pArguments->GetInt32(1); } int32_t nEndPage = 0; if (iLength >= 3) { nEndPage = pArguments->GetInt32(2); } FX_BOOL bCanCancel = TRUE; if (iLength >= 4) { bCanCancel = pArguments->GetInt32(3) == 0 ? FALSE : TRUE; } if (bCanCancel) { dwOptions |= XFA_PRINTOPT_CanCancel; } FX_BOOL bShrinkPage = TRUE; if (iLength >= 5) { bShrinkPage = pArguments->GetInt32(4) == 0 ? FALSE : TRUE; } if (bShrinkPage) { dwOptions |= XFA_PRINTOPT_ShrinkPage; } FX_BOOL bAsImage = TRUE; if (iLength >= 6) { bAsImage = pArguments->GetInt32(5) == 0 ? FALSE : TRUE; } if (bAsImage) { dwOptions |= XFA_PRINTOPT_AsImage; } FX_BOOL bReverseOrder = TRUE; if (iLength >= 7) { bAsImage = pArguments->GetInt32(5) == 0 ? FALSE : TRUE; } bReverseOrder = pArguments->GetInt32(6) == 0 ? FALSE : TRUE; if (bReverseOrder) { dwOptions |= XFA_PRINTOPT_ReverseOrder; } FX_BOOL bPrintAnnot = TRUE; if (iLength >= 8) { bPrintAnnot = pArguments->GetInt32(7) == 0 ? FALSE : TRUE; } if (bPrintAnnot) { dwOptions |= XFA_PRINTOPT_PrintAnnot; } pNotify->GetDocEnvironment()->Print(hDoc, nStartPage, nEndPage, dwOptions); }
/* * Class: com_sun_star_comp_beans_LocalOfficeWindow * Method: getNativeWindow * Signature: ()J */ JNIEXPORT jlong JNICALL Java_com_sun_star_comp_beans_LocalOfficeWindow_getNativeWindow (JNIEnv * env, jobject obj_this) { jboolean result; jint lock; JAWT awt; JAWT_DrawingSurface* ds; JAWT_DrawingSurfaceInfo* dsi; JAWT_Win32DrawingSurfaceInfo* dsi_win; HDC hdc; HWND hWnd; LONG hFuncPtr; /* Get the AWT */ awt.version = JAWT_VERSION_1_3; result = JAWT_GetAWT(env, &awt); if (result == JNI_FALSE) ThrowException(env, "java/lang/RuntimeException", "JAWT_GetAWT failed"); /* Get the drawing surface */ if ((ds = awt.GetDrawingSurface(env, obj_this)) == NULL) return 0L; /* Lock the drawing surface */ lock = ds->Lock(ds); if ( (lock & JAWT_LOCK_ERROR) != 0) ThrowException(env, "java/lang/RuntimeException", "Could not get AWT drawing surface."); /* Get the drawing surface info */ dsi = ds->GetDrawingSurfaceInfo(ds); /* Get the platform-specific drawing info */ dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo; hdc = dsi_win->hdc; hWnd = dsi_win->hwnd; /* Free the drawing surface info */ ds->FreeDrawingSurfaceInfo(dsi); /* Unlock the drawing surface */ ds->Unlock(ds); /* Free the drawing surface */ awt.FreeDrawingSurface(ds); /* Register own window procedure Do it one times only! Otherwhise multiple instances will be registered and calls on such construct produce a stack overflow. */ if (GetProp( hWnd, OLD_PROC_KEY )==0) { hFuncPtr = SetWindowLong( hWnd, GWL_WNDPROC, (DWORD)OpenOfficeWndProc ); SetProp( hWnd, OLD_PROC_KEY, (HANDLE)hFuncPtr ); } return ((jlong)hWnd); }
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(); }
//-------------------------------------------------------------------------------------------------- parseTree::Token_t* Lexer_t::Pull ( parseTree::Token_t::Type_t type ///< The type of token to pull from the file. ) //-------------------------------------------------------------------------------------------------- { parseTree::Token_t* tokenPtr = new parseTree::Token_t(type, filePtr, line, column); switch (type) { case parseTree::Token_t::END_OF_FILE: if (nextChar != EOF) { ThrowException("Expected end-of-file, but found '" + std::string(&nextChar) + "'."); } break; case parseTree::Token_t::OPEN_CURLY: PullConstString(tokenPtr, "{"); break; case parseTree::Token_t::CLOSE_CURLY: PullConstString(tokenPtr, "}"); break; case parseTree::Token_t::OPEN_PARENTHESIS: PullConstString(tokenPtr, "("); break; case parseTree::Token_t::CLOSE_PARENTHESIS: PullConstString(tokenPtr, ")"); break; case parseTree::Token_t::COLON: PullConstString(tokenPtr, ":"); break; case parseTree::Token_t::EQUALS: PullConstString(tokenPtr, "="); break; case parseTree::Token_t::DOT: PullConstString(tokenPtr, "."); break; case parseTree::Token_t::STAR: PullConstString(tokenPtr, "*"); break; case parseTree::Token_t::ARROW: PullConstString(tokenPtr, "->"); break; case parseTree::Token_t::WHITESPACE: PullWhitespace(tokenPtr); break; case parseTree::Token_t::COMMENT: PullComment(tokenPtr); break; case parseTree::Token_t::FILE_PERMISSIONS: PullFilePermissions(tokenPtr); break; case parseTree::Token_t::SERVER_IPC_OPTION: PullServerIpcOption(tokenPtr); break; case parseTree::Token_t::CLIENT_IPC_OPTION: PullClientIpcOption(tokenPtr); break; case parseTree::Token_t::ARG: PullArg(tokenPtr); break; case parseTree::Token_t::FILE_PATH: PullFilePath(tokenPtr); break; case parseTree::Token_t::FILE_NAME: PullFileName(tokenPtr); break; case parseTree::Token_t::NAME: PullName(tokenPtr); break; case parseTree::Token_t::GROUP_NAME: PullGroupName(tokenPtr); break; case parseTree::Token_t::IPC_AGENT: PullIpcAgentName(tokenPtr); break; case parseTree::Token_t::INTEGER: PullInteger(tokenPtr); break; case parseTree::Token_t::SIGNED_INTEGER: PullSignedInteger(tokenPtr); break; case parseTree::Token_t::BOOLEAN: PullBoolean(tokenPtr); break; case parseTree::Token_t::FLOAT: PullFloat(tokenPtr); break; case parseTree::Token_t::STRING: PullString(tokenPtr); break; } return tokenPtr; }
void WHTDongle::GetInputReportRaw(void* buffer, int report_size) { if (HidD_GetInputReport(hDevice, buffer, report_size) != TRUE) ThrowException(L"HidD_GetInputReport", ((uint8_t*) buffer)[0]); }
void WHTDongle::SetFeatureReportRaw(const void* buffer, int report_size) { if (HidD_SetFeature(hDevice, (PVOID) buffer, report_size) != TRUE) ThrowException(L"HidD_SetFeature", ((uint8_t*) buffer)[0]); }
static void BindLocalSocketToName(JNIEnv* env, jobject obj, int sd, const char* name) { struct sockaddr_un address; // Name length const size_t nameLength = strlen(name); // Path length is initiall equal to name length size_t pathLength = nameLength; // If name is not starting with a slash it is // in the abstract namespace bool abstractNamespace = ('/' != name[0]); // Abstract namespace requires having the first // byte of the path to be the zero byte, update // the path length to include the zero byte if (abstractNamespace) { pathLength++; } // Check the path length if (pathLength > sizeof(address.sun_path)) { // Throw an exception with error number ThrowException(env, "java/io/IOException", "Name is too big."); } else { // Clear the address bytes memset(&address, 0, sizeof(address)); address.sun_family = PF_LOCAL; // Socket path char* sunPath = address.sun_path; // First byte must be zero to use the abstract namespace if (abstractNamespace) { *sunPath++ = '\0'; } // Append the local name strcpy(sunPath, name); // Address length socklen_t addressLength = (offsetof(struct sockaddr_un, sun_path)) + pathLength; // Unlink if the socket name is already binded unlink(address.sun_path); // Bind socket LOGI("Binding to local name %s%s.", (abstractNamespace) ? "(null)" : "", name); int so_reuseaddr = 1; setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &so_reuseaddr, sizeof so_reuseaddr); if (-1 == bind(sd, (struct sockaddr*) &address, addressLength)) { // Throw an exception with error number ThrowErrnoException(env, "java/io/IOException", errno); } } }
Handle<Value> Feature::addAttributes(const Arguments& args) { HandleScope scope; Feature* fp = node::ObjectWrap::Unwrap<Feature>(args.This()); if (args.Length() > 0 ) { Local<Value> val = args[0]; if (val->IsNull() || val->IsUndefined()) { return ThrowException(Exception::TypeError(String::New("object expected"))); } else { Local<Object> attr = val->ToObject(); try { Local<Array> names = attr->GetPropertyNames(); unsigned int i = 0; unsigned int a_length = names->Length(); boost::scoped_ptr<mapnik::transcoder> tr(new mapnik::transcoder("utf8")); while (i < a_length) { Local<Value> name = names->Get(i)->ToString(); Local<Value> value = attr->Get(name); if (value->IsString()) { mapnik::value_unicode_string ustr = tr->transcode(TOSTR(value)); #if MAPNIK_VERSION >= 200100 fp->get()->put_new(TOSTR(name),ustr); #else boost::put(*fp->get(),TOSTR(name),ustr); #endif } else if (value->IsNumber()) { double num = value->NumberValue(); // todo - round if (num == value->IntegerValue()) { #if MAPNIK_VERSION >= 200100 fp->get()->put_new(TOSTR(name),static_cast<node_mapnik::value_integer>(value->IntegerValue())); #else boost::put(*fp->get(),TOSTR(name),static_cast<int>(value->IntegerValue())); #endif } else { double dub_val = value->NumberValue(); #if MAPNIK_VERSION >= 200100 fp->get()->put_new(TOSTR(name),dub_val); #else boost::put(*fp->get(),TOSTR(name),dub_val); #endif } } else if (value->IsNull()) { #if MAPNIK_VERSION >= 200100 fp->get()->put_new(TOSTR(name),mapnik::value_null()); #else boost::put(*fp->get(),TOSTR(name),mapnik::value_null()); #endif } else { std::clog << "unhandled type for property: " << TOSTR(name) << "\n"; } i++; } } catch (std::exception const& ex ) { return ThrowException(Exception::Error( String::New(ex.what()))); } } } return Undefined(); }
static void ConnectToLocalAddress(JNIEnv* env, jobject obj, int sd, const char * name) { struct sockaddr_un address; // Connecting to given name adress LOGI("Connecting to %s", name); // Name length const size_t nameLength = strlen(name); // Path length is initiall equal to name length size_t pathLength = nameLength; // If name is not starting with a slash it is // in the abstract namespace bool abstractNamespace = ('/' != name[0]); // Abstract namespace requires having the first // byte of the path to be the zero byte, update // the path length to include the zero byte if (abstractNamespace) { pathLength++; } // Check the path length if (pathLength > sizeof(address.sun_path)) { // Throw an exception with error number ThrowException(env, "java/io/IOException", "Name is too big."); } else { // Clear the address bytes memset(&address, 0, sizeof(address)); address.sun_family = PF_LOCAL; // Socket path char* sunPath = address.sun_path; // First byte must be zero to use the abstract namespace if (abstractNamespace) { *sunPath++ = '\0'; } // Append the local name strcpy(sunPath, name); // Address length socklen_t addressLength = (offsetof(struct sockaddr_un, sun_path)) + pathLength; if (-1 == connect(sd, (struct sockaddr*) &address, addressLength)) { // Throw an exception with error number ThrowErrnoException(env, "java/io/IOException", errno); } } }
Handle<Value> MemoryDatasource::add(const Arguments& args) { HandleScope scope; if ((args.Length() != 1) || !args[0]->IsObject()) { return ThrowException(Exception::Error( String::New("accepts one argument: an object including x and y (or wkt) and properties"))); } MemoryDatasource* d = node::ObjectWrap::Unwrap<MemoryDatasource>(args.This()); Local<Object> obj = args[0]->ToObject(); if (obj->Has(String::New("wkt")) || (obj->Has(String::New("x")) && obj->Has(String::New("y")))) { if (obj->Has(String::New("wkt"))) return ThrowException(Exception::Error( String::New("wkt not yet supported"))); Local<Value> x = obj->Get(String::New("x")); Local<Value> y = obj->Get(String::New("y")); if (!x->IsUndefined() && x->IsNumber() && !y->IsUndefined() && y->IsNumber()) { mapnik::geometry_type * pt = new mapnik::geometry_type(MAPNIK_POINT); pt->move_to(x->NumberValue(),y->NumberValue()); #if MAPNIK_VERSION >= 200100 mapnik::context_ptr ctx = MAPNIK_MAKE_SHARED<mapnik::context_type>(); mapnik::feature_ptr feature(mapnik::feature_factory::create(ctx,d->feature_id_)); #else mapnik::feature_ptr feature(mapnik::feature_factory::create(d->feature_id_)); #endif ++(d->feature_id_); feature->add_geometry(pt); if (obj->Has(String::New("properties"))) { Local<Value> props = obj->Get(String::New("properties")); if (props->IsObject()) { Local<Object> p_obj = props->ToObject(); Local<Array> names = p_obj->GetPropertyNames(); unsigned int i = 0; unsigned int a_length = names->Length(); while (i < a_length) { Local<Value> name = names->Get(i)->ToString(); // if name in q.property_names() ? Local<Value> value = p_obj->Get(name); if (value->IsString()) { mapnik::value_unicode_string ustr = d->tr_->transcode(TOSTR(value)); #if MAPNIK_VERSION >= 200100 feature->put_new(TOSTR(name),ustr); #else boost::put(*feature,TOSTR(name),ustr); #endif } else if (value->IsNumber()) { double num = value->NumberValue(); // todo - round if (num == value->IntegerValue()) { #if MAPNIK_VERSION >= 200100 feature->put_new(TOSTR(name),static_cast<node_mapnik::value_integer>(value->IntegerValue())); #else boost::put(*feature,TOSTR(name),static_cast<int>(value->IntegerValue())); #endif } else { double dub_val = value->NumberValue(); #if MAPNIK_VERSION >= 200100 feature->put_new(TOSTR(name),dub_val); #else boost::put(*feature,TOSTR(name),dub_val); #endif } } else if (value->IsNull()) { #if MAPNIK_VERSION >= 200100 feature->put_new(TOSTR(name),mapnik::value_null()); #else boost::put(*feature,TOSTR(name),mapnik::value_null()); #endif } else { std::clog << "unhandled type for property: " << TOSTR(name) << "\n"; } i++; } } } mapnik::memory_datasource *cache = dynamic_cast<mapnik::memory_datasource *>(d->datasource_.get()); cache->push(feature); } } return scope.Close(False()); }
Handle<Value> MemoryDatasource::add(const Arguments& args) { HandleScope scope; if ((args.Length() != 1) || !args[0]->IsObject()) { return ThrowException(Exception::Error( String::New("accepts one argument: an object including x and y (or wkt) and properties"))); } MemoryDatasource* d = ObjectWrap::Unwrap<MemoryDatasource>(args.This()); Local<Object> obj = args[0]->ToObject(); if (obj->Has(String::New("wkt")) || (obj->Has(String::New("x")) && obj->Has(String::New("y")))) { if (obj->Has(String::New("wkt"))) return ThrowException(Exception::Error( String::New("wkt not yet supported"))); Local<Value> x = obj->Get(String::New("x")); Local<Value> y = obj->Get(String::New("y")); if (!x->IsUndefined() && x->IsNumber() && !y->IsUndefined() && y->IsNumber()) { mapnik::geometry_type * pt = new mapnik::geometry_type(mapnik::Point); pt->move_to(x->NumberValue(),y->NumberValue()); mapnik::feature_ptr feature(new mapnik::Feature(d->feature_id_)); ++(d->feature_id_); feature->add_geometry(pt); if (obj->Has(String::New("properties"))) { Local<Value> props = obj->Get(String::New("properties")); if (props->IsObject()) { Local<Object> p_obj = props->ToObject(); Local<Array> names = p_obj->GetPropertyNames(); uint32_t i = 0; uint32_t a_length = names->Length(); while (i < a_length) { Local<Value> name = names->Get(i)->ToString(); // if name in q.property_names() ? Local<Value> value = p_obj->Get(name); if (value->IsString()) { UnicodeString ustr = d->tr_->transcode(TOSTR(value)); boost::put(*feature,TOSTR(name),ustr); } else if (value->IsNumber()) { double num = value->NumberValue(); // todo - round if (num == value->IntegerValue()) { int integer = value->IntegerValue(); boost::put(*feature,TOSTR(name),integer); } else { double dub_val = value->NumberValue(); boost::put(*feature,TOSTR(name),dub_val); } } else { std::clog << "unhandled type for property: " << TOSTR(name) << "\n"; } i++; } } } mapnik::memory_datasource *cache = dynamic_cast<mapnik::memory_datasource *>(d->datasource_.get()); cache->push(feature); } } return scope.Close(Boolean::New(false)); }
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> Grid::encodeSync(const Arguments& args) // format, resolution { HandleScope scope; Grid* g = ObjectWrap::Unwrap<Grid>(args.This()); // defaults std::string format("utf"); unsigned int resolution = 4; bool add_features = true; // accept custom format if (args.Length() >= 1){ if (!args[0]->IsString()) return ThrowException(Exception::TypeError( String::New("first arg, 'format' must be a string"))); format = TOSTR(args[0]); } // options hash if (args.Length() >= 2) { if (!args[1]->IsObject()) return ThrowException(Exception::TypeError( String::New("optional second arg must be an options object"))); Local<Object> options = args[1]->ToObject(); 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("'resolution' must be an Integer"))); resolution = bind_opt->IntegerValue(); } if (options->Has(String::New("features"))) { Local<Value> bind_opt = options->Get(String::New("features")); if (!bind_opt->IsBoolean()) return ThrowException(Exception::TypeError( String::New("'features' must be an Boolean"))); add_features = bind_opt->BooleanValue(); } } try { Local<Array> grid_array = Array::New(); std::vector<mapnik::grid::lookup_type> key_order; node_mapnik::grid2utf<mapnik::grid>(*g->get(),grid_array,key_order,resolution); // convert key order to proper javascript array Local<Array> keys_a = Array::New(key_order.size()); std::vector<std::string>::iterator it; unsigned int i; for (it = key_order.begin(), i = 0; it < key_order.end(); ++it, ++i) { keys_a->Set(i, String::New((*it).c_str())); } // gather feature data Local<Object> feature_data = Object::New(); if (add_features) { node_mapnik::write_features<mapnik::grid>(*g->get(), feature_data, key_order ); } // Create the return hash. Local<Object> json = Object::New(); json->Set(String::NewSymbol("grid"), grid_array); json->Set(String::NewSymbol("keys"), keys_a); json->Set(String::NewSymbol("data"), feature_data); return json; } catch (std::exception & ex) { return ThrowException(Exception::Error( String::New(ex.what()))); } }
v8::Handle<v8::Value> IRBuilder::New(const v8::Arguments& args) { return ThrowException(Exception::Error(String::New("IRBuilder is not meant to be instantiated."))); }
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(); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d T I M I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ReadTIMImage reads a PSX TIM image file and returns it. It % allocates the memory necessary for the new Image structure and returns a % pointer to the new image. % % Contributed by [email protected]. % % The format of the ReadTIMImage method is: % % Image *ReadTIMImage(const ImageInfo *image_info,ExceptionInfo *exception) % % A description of each parameter follows: % % o image: Method ReadTIMImage returns a pointer to the image after % reading. A null image is returned if there is a memory shortage or % if the image cannot be read. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o exception: return any errors or warnings in this structure. % % */ static Image *ReadTIMImage(const ImageInfo *image_info,ExceptionInfo *exception) { typedef struct _TIMInfo { unsigned long id, flag; } TIMInfo; TIMInfo tim_info; Image *image; int bits_per_pixel, has_clut; long y; register IndexPacket *indexes; register long x; register PixelPacket *q; register long i; register unsigned char *p; unsigned char *tim_data, *tim_pixels; unsigned short word; unsigned int status; size_t bytes_per_line, image_size; unsigned long height, pixel_mode, width; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); /* Determine if this is a TIM file. */ tim_info.id=ReadBlobLSBLong(image); do { /* Verify TIM identifier. */ if (tim_info.id != 0x00000010) ThrowReaderException(CorruptImageError,ImproperImageHeader,image); tim_info.flag=ReadBlobLSBLong(image); has_clut=!!(tim_info.flag & (1 << 3)); pixel_mode=tim_info.flag & 0x07; switch ((int) pixel_mode) { case 0: bits_per_pixel=4; break; case 1: bits_per_pixel=8; break; case 2: bits_per_pixel=16; break; case 3: bits_per_pixel=24; break; default: bits_per_pixel=4; break; } image->depth=8; if (has_clut) { unsigned char *tim_colormap; /* Read TIM raster colormap. */ (void)ReadBlobLSBLong(image); (void)ReadBlobLSBShort(image); (void)ReadBlobLSBShort(image); /* width= */ (void)ReadBlobLSBShort(image); /* height= */ (void)ReadBlobLSBShort(image); if (!AllocateImageColormap(image,pixel_mode == 1 ? 256 : 16)) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed, image); tim_colormap=MagickAllocateMemory(unsigned char *,image->colors*2); if (tim_colormap == (unsigned char *) NULL) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed, image); (void) ReadBlob(image,2*image->colors,(char *) tim_colormap); p=tim_colormap; for (i=0; i < (long) image->colors; i++) { word=(*p++); word|=(unsigned short) (*p++ << 8U); image->colormap[i].blue=ScaleCharToQuantum(ScaleColor5to8((word >> 10U) & 0x1fU)); image->colormap[i].green=ScaleCharToQuantum(ScaleColor5to8((word >> 5U) & 0x1fU)); image->colormap[i].red=ScaleCharToQuantum(ScaleColor5to8(word & 0x1fU)); } MagickFreeMemory(tim_colormap); } /* Read image data. */ (void) ReadBlobLSBLong(image); (void) ReadBlobLSBShort(image); (void) ReadBlobLSBShort(image); if (EOFBlob(image)) ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image); width=ReadBlobLSBShort(image); height=ReadBlobLSBShort(image); image_size=MagickArraySize(2,MagickArraySize(width,height)); bytes_per_line=MagickArraySize(width,2); width=(unsigned long)(MagickArraySize(width,16))/bits_per_pixel; /* Initialize image structure. */ image->columns=width; image->rows=height; if (image_info->ping && (image_info->subrange != 0)) if (image->scene >= (image_info->subimage+image_info->subrange-1)) break; if (CheckImagePixelLimits(image, exception) != MagickPass) ThrowReaderException(ResourceLimitError,ImagePixelLimitExceeded,image); tim_data=MagickAllocateMemory(unsigned char *,image_size); if (tim_data == (unsigned char *) NULL) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); (void) ReadBlob(image,image_size,(char *) tim_data); tim_pixels=tim_data; /* Convert TIM raster image to pixel packets. */ switch (bits_per_pixel) { case 4: { /* Convert PseudoColor scanline. */ for (y=(long) image->rows-1; y >= 0; y--) { q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=AccessMutableIndexes(image); p=tim_pixels+y*bytes_per_line; for (x=0; x < ((long) image->columns-1); x+=2) { indexes[x]=(*p) & 0xf; indexes[x+1]=(*p >> 4) & 0xf; p++; } if ((image->columns % 2) != 0) { indexes[x]=(*p >> 4) & 0xf; p++; } if (!SyncImagePixelsEx(image,exception)) break; if (QuantumTick(y,image->rows)) { status=MagickMonitorFormatted(image->rows-y-1,image->rows, exception,LoadImageText, image->filename, image->columns,image->rows); if (status == False) break; } } break; } case 8: { /* Convert PseudoColor scanline. */ for (y=(long) image->rows-1; y >= 0; y--) { q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=AccessMutableIndexes(image); p=tim_pixels+y*bytes_per_line; for (x=0; x < (long) image->columns; x++) indexes[x]=(*p++); if (!SyncImagePixelsEx(image,exception)) break; if (QuantumTick(y,image->rows)) { status=MagickMonitorFormatted(image->rows-y-1,image->rows, exception,LoadImageText, image->filename, image->columns,image->rows); if (status == False) break; } } break; } case 16: { /* Convert DirectColor scanline. */ for (y=(long) image->rows-1; y >= 0; y--) { p=tim_pixels+y*bytes_per_line; q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { word=(*p++); word|=(*p++ << 8); q->blue=ScaleCharToQuantum(ScaleColor5to8((word >> 10) & 0x1f)); q->green=ScaleCharToQuantum(ScaleColor5to8((word >> 5) & 0x1f)); q->red=ScaleCharToQuantum(ScaleColor5to8(word & 0x1f)); q++; } if (!SyncImagePixelsEx(image,exception)) break; if (QuantumTick(y,image->rows)) { status=MagickMonitorFormatted(image->rows-y-1,image->rows, exception,LoadImageText, image->filename, image->columns,image->rows); if (status == False) break; } } break; } case 24: { /* Convert DirectColor scanline. */ for (y=(long) image->rows-1; y >= 0; y--) { p=tim_pixels+y*bytes_per_line; q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { q->red=ScaleCharToQuantum(*p++); q->green=ScaleCharToQuantum(*p++); q->blue=ScaleCharToQuantum(*p++); q++; } if (!SyncImagePixelsEx(image,exception)) break; if (QuantumTick(y,image->rows)) { status=MagickMonitorFormatted(image->rows-y-1,image->rows, exception,LoadImageText, image->filename, image->columns,image->rows); if (status == False) break; } } break; } default: ThrowReaderException(CorruptImageError,ImproperImageHeader,image) } if (image->storage_class == PseudoClass) (void) SyncImage(image); MagickFreeMemory(tim_pixels); if (EOFBlob(image)) { ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, image->filename); break; } /* Proceed to next image. */ tim_info.id=ReadBlobLSBLong(image); if (tim_info.id == 0x00000010) { /* Allocate next image structure. */ AllocateNextImage(image_info,image); if (image->next == (Image *) NULL) { DestroyImageList(image); return((Image *) NULL); } image=SyncNextImageInList(image); status=MagickMonitorFormatted(TellBlob(image),GetBlobSize(image), exception,LoadImagesText, image->filename); if (status == False) break; } } while (tim_info.id == 0x00000010);
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> Get(const Arguments &args) { HandleScope scope; FIXED_INFO *pFixedInfo; ULONG ulOutBufLen; DWORD dwRetVal; IP_ADDR_STRING *pDNS; pFixedInfo = (FIXED_INFO *) MALLOC(sizeof (FIXED_INFO)); if (pFixedInfo == NULL) { ThrowException(Exception::Error(String::New("Error allocating memory"))); return scope.Close(Undefined()); } ulOutBufLen = sizeof (FIXED_INFO); // Make an initial call to GetAdaptersInfo to get // the necessary size into the ulOutBufLen variable if (GetNetworkParams(pFixedInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) { FREE(pFixedInfo); pFixedInfo = (FIXED_INFO *) MALLOC(ulOutBufLen); if (pFixedInfo == NULL) { ThrowException(Exception::Error(String::New("Error allocating memory"))); return scope.Close(Undefined()); } } if (dwRetVal = GetNetworkParams(pFixedInfo, &ulOutBufLen) == NO_ERROR) { Local<Object> r = Object::New(); r->Set(String::NewSymbol("hostName"), String::NewSymbol(pFixedInfo->HostName)); r->Set(String::NewSymbol("domainName"), String::NewSymbol(pFixedInfo->DomainName)); Local<Array> dns = Array::New(); //dns-> uint32_t i = 0; dns->Set(i++, String::NewSymbol(pFixedInfo->DnsServerList.IpAddress.String)); pDNS = pFixedInfo->DnsServerList.Next; while (pDNS) { dns->Set(i++, String::NewSymbol(pDNS->IpAddress.String)); pDNS = pDNS->Next; } r->Set(String::NewSymbol("dnsServers"), dns); r->Set(String::NewSymbol("dnsEnabled"), Boolean::New(pFixedInfo->EnableDns)); r->Set(String::NewSymbol("nodeType"), Number::New(pFixedInfo->NodeType)); r->Set(String::NewSymbol("domain"), String::NewSymbol(pFixedInfo->DomainName)); r->Set(String::NewSymbol("arpProxyEnabled"), Boolean::New(pFixedInfo->EnableProxy)); r->Set(String::NewSymbol("routingEnabled"), Boolean::New(pFixedInfo->EnableRouting)); r->Set(String::NewSymbol("dhcpScope"), String::NewSymbol(pFixedInfo->ScopeId)); if (pFixedInfo) FREE(pFixedInfo); return scope.Close(r); } else { if (pFixedInfo) FREE(pFixedInfo); ThrowException(Exception::TypeError(String::New("GetNetworkParams failed with error " + dwRetVal))); return scope.Close(Undefined()); } if (pFixedInfo) FREE(pFixedInfo); return scope.Close(Undefined()); }
void Layer::set_prop(Local<String> property, Local<Value> value, const AccessorInfo& info) { HandleScope scope; Layer* l = ObjectWrap::Unwrap<Layer>(info.Holder()); std::string a = TOSTR(property); if (a == "name") { if (!value->IsString()) { ThrowException(Exception::Error( String::New("'name' must be a string"))); } else { l->layer_->set_name(TOSTR(value)); } } else if (a == "srs") { if (!value->IsString()) { ThrowException(Exception::Error( String::New("'srs' must be a string"))); } else { l->layer_->set_srs(TOSTR(value)); } } else if (a == "styles") { if (!value->IsArray()) ThrowException(Exception::Error( String::New("Must provide an array of style names"))); else { Local<Array> a = Local<Array>::Cast(value->ToObject()); // todo - how to check if cast worked? uint32_t i = 0; uint32_t a_length = a->Length(); while (i < a_length) { l->layer_->add_style(TOSTR(a->Get(i))); i++; } } } else if (a == "datasource") { Local<Object> obj = value->ToObject(); if (value->IsNull() || value->IsUndefined()) { ThrowException(Exception::TypeError(String::New("mapnik.Datasource or mapnik.JSDatasource instance expected"))); } else { if (Datasource::constructor->HasInstance(obj)) { JSDatasource *d = ObjectWrap::Unwrap<JSDatasource>(obj); // TODO - addLayer should be add_layer in mapnik l->layer_->set_datasource(d->get()); } else if (JSDatasource::constructor->HasInstance(obj)) { JSDatasource *d = ObjectWrap::Unwrap<JSDatasource>(obj); // TODO - addLayer should be add_layer in mapnik l->layer_->set_datasource(d->get()); } else { ThrowException(Exception::TypeError(String::New("mapnik.Datasource or mapnik.JSDatasource instance expected"))); } } } }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d S C T I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ReadSCTImage reads a Scitex image file and returns it. It allocates % the memory necessary for the new Image structure and returns a pointer to % the new image. % % The format of the ReadSCTImage method is: % % Image *ReadSCTImage(const ImageInfo *image_info,ExceptionInfo *exception) % % A description of each parameter follows: % % o image: Method ReadSCTImage returns a pointer to the image after % reading. A null image is returned if there is a memory shortage or % if the image cannot be read. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o exception: return any errors or warnings in this structure. % % */ static Image *ReadSCTImage(const ImageInfo *image_info,ExceptionInfo *exception) { char buffer[768], magick[2]; Image *image; long y; register long x; register PixelPacket *q; int c; unsigned int status; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); /* Read control block. */ do { if (ReadBlob(image,80,(char *) buffer) != 80) break; if (ReadBlob(image,2,(char *) magick) != 2) break; if ((LocaleNCompare((char *) magick,"CT",2) != 0) && (LocaleNCompare((char *) magick,"LW",2) != 0) && (LocaleNCompare((char *) magick,"BM",2) != 0) && (LocaleNCompare((char *) magick,"PG",2) != 0) && (LocaleNCompare((char *) magick,"TX",2) != 0)) ThrowReaderException(CorruptImageError,ImproperImageHeader,image); if ((LocaleNCompare((char *) magick,"LW",2) == 0) || (LocaleNCompare((char *) magick,"BM",2) == 0) || (LocaleNCompare((char *) magick,"PG",2) == 0) || (LocaleNCompare((char *) magick,"TX",2) == 0)) ThrowReaderException(CoderError,OnlyContinuousTonePictureSupported,image); if (ReadBlob(image,174,(char *) buffer) != 174) break; if (ReadBlob(image,768,(char *) buffer) != 768) break; /* Read parameter block. */ if (ReadBlob(image,32,(char *) buffer) != 32) break; if (ReadBlob(image,14,(char *) buffer) != 14) break; image->rows=MagickAtoL(buffer) & 0x7FFFFFFF; if (ReadBlob(image,14,(char *) buffer) != 14) break; image->columns=MagickAtoL(buffer) & 0x7FFFFFFF; if (ReadBlob(image,196,(char *) buffer) != 196) break; if (ReadBlob(image,768,(char *) buffer) != 768) break; image->colorspace=CMYKColorspace; } while (0); if (EOFBlob(image)) ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image); if (image_info->ping) { CloseBlob(image); return(image); } if (CheckImagePixelLimits(image, exception) != MagickPass) ThrowReaderException(ResourceLimitError,ImagePixelLimitExceeded,image); /* Convert SCT raster image to pixel packets. */ for (y=0; y < (long) image->rows; y++) { q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { if ((c = ReadBlobByte(image)) == EOF) break; q->red=(Quantum) (MaxRGB-ScaleCharToQuantum(c)); q++; } if ((image->columns % 2) != 0) if (ReadBlobByte(image) == EOF) /* pad */ break; q=GetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { if ((c = ReadBlobByte(image)) == EOF) break; q->green=(Quantum) (MaxRGB-ScaleCharToQuantum(c)); q++; } if ((image->columns % 2) != 0) if (ReadBlobByte(image) == EOF) /* pad */ break; q=GetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { if ((c = ReadBlobByte(image)) == EOF) break; q->blue=(Quantum) (MaxRGB-ScaleCharToQuantum(c)); q++; } if ((image->columns % 2) != 0) if (ReadBlobByte(image) == EOF) /* pad */ break; q=GetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { if ((c = ReadBlobByte(image)) == EOF) break; q->opacity=(Quantum) (MaxRGB-ScaleCharToQuantum(c)); q++; } if (!SyncImagePixelsEx(image,exception)) break; if ((image->columns % 2) != 0) if (ReadBlobByte(image) == EOF) /* pad */ break; if (QuantumTick(y,image->rows)) if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText, image->filename, image->columns,image->rows)) break; if (EOFBlob(image)) break; } if (EOFBlob(image)) ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, image->filename); CloseBlob(image); return(image); }
// Returns whether the currently executing code is allowed to access // the wrapper. Uses nsIPrincipal::Subsumes. // |cx| must be the top context on the context stack. // If the subject is allowed to access the object returns NS_OK. If not, // returns NS_ERROR_DOM_PROP_ACCESS_DENIED, returns another error code on // failure. nsresult CanAccessWrapper(JSContext *cx, JSObject *outerObj, JSObject *wrappedObj, JSBool *privilegeEnabled) { // Fast path: If the wrapper and the wrapped object have the same global // object (or if the wrapped object is a outer for the same inner that // the wrapper is parented to), then we don't need to do any more work. if (privilegeEnabled) { *privilegeEnabled = JS_FALSE; } if (outerObj) { JSObject *outerParent = outerObj->getParent(); JSObject *innerParent = wrappedObj->getParent(); if (!innerParent) { innerParent = wrappedObj; OBJ_TO_INNER_OBJECT(cx, innerParent); if (!innerParent) { return NS_ERROR_FAILURE; } } else { innerParent = JS_GetGlobalForObject(cx, innerParent); } if (outerParent == innerParent) { return NS_OK; } } // TODO bug 508928: Refactor this with the XOW security checking code. // Get the subject principal from the execution stack. nsIScriptSecurityManager *ssm = XPCWrapper::GetSecurityManager(); if (!ssm) { ThrowException(NS_ERROR_NOT_INITIALIZED, cx); return NS_ERROR_NOT_INITIALIZED; } JSStackFrame *fp = nsnull; nsIPrincipal *subjectPrin = ssm->GetCxSubjectPrincipalAndFrame(cx, &fp); if (!subjectPrin) { ThrowException(NS_ERROR_FAILURE, cx); return NS_ERROR_FAILURE; } PRBool isSystem = PR_FALSE; nsresult rv = ssm->IsSystemPrincipal(subjectPrin, &isSystem); NS_ENSURE_SUCCESS(rv, rv); if (privilegeEnabled) { *privilegeEnabled = JS_FALSE; } nsCOMPtr<nsIPrincipal> objectPrin; rv = ssm->GetObjectPrincipal(cx, wrappedObj, getter_AddRefs(objectPrin)); if (NS_FAILED(rv)) { return rv; } NS_ASSERTION(objectPrin, "Object didn't have principals?"); // Micro-optimization: don't call into caps if we know the answer. if (subjectPrin == objectPrin) { return NS_OK; } // Now, we have our two principals, compare them! PRBool subsumes; rv = subjectPrin->Subsumes(objectPrin, &subsumes); if (NS_SUCCEEDED(rv) && !subsumes) { // We're about to fail, but make a last effort to see if // UniversalXPConnect was enabled anywhere else on the stack. rv = ssm->IsCapabilityEnabled("UniversalXPConnect", &isSystem); if (NS_SUCCEEDED(rv) && isSystem) { rv = NS_OK; if (privilegeEnabled) { *privilegeEnabled = JS_TRUE; } } else { rv = NS_ERROR_DOM_PROP_ACCESS_DENIED; } } return rv; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d V I C A R I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ReadVICARImage reads a VICAR image file and returns it. It % allocates the memory necessary for the new Image structure and returns a % pointer to the new image. % % The format of the ReadVICARImage method is: % % Image *ReadVICARImage(const ImageInfo *image_info, % ExceptionInfo *exception) % % A description of each parameter follows: % % o image: Method ReadVICARImage returns a pointer to the image after % reading. A null image is returned if there is a memory shortage or if % the image cannot be read. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o exception: return any errors or warnings in this structure. % % */ static Image *ReadVICARImage(const ImageInfo *image_info, ExceptionInfo *exception) { char keyword[MaxTextExtent], value[MaxTextExtent]; Image *image; int c, y; long count; unsigned char *scanline; unsigned int status, value_expected; unsigned long length; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); /* Decode image header. */ c=ReadBlobByte(image); count=1; if (c == EOF) { DestroyImage(image); return((Image *) NULL); } length=0; image->columns=0; image->rows=0; while (isgraph(c) && ((image->columns == 0) || (image->rows == 0))) { if (!isalnum(c)) { c=ReadBlobByte(image); count++; } else { register char *p; /* Determine a keyword and its value. */ p=keyword; do { if ((p-keyword) < (MaxTextExtent-1)) *p++=c; c=ReadBlobByte(image); count++; } while (isalnum(c) || (c == '_')); *p='\0'; value_expected=False; while (isspace(c) || (c == '=')) { if (c == '=') value_expected=True; c=ReadBlobByte(image); count++; } if (value_expected == False) continue; p=value; while (isalnum(c)) { if ((p-value) < (MaxTextExtent-1)) *p++=c; c=ReadBlobByte(image); count++; } *p='\0'; /* Assign a value to the specified keyword. */ if (LocaleCompare(keyword,"Label_RECORDS") == 0) length=MagickAtoL(value); if (LocaleCompare(keyword,"LBLSIZE") == 0) length=MagickAtoL(value); if (LocaleCompare(keyword,"RECORD_BYTES") == 0) image->columns= MagickAtoL(value); if (LocaleCompare(keyword,"NS") == 0) image->columns= MagickAtoL(value); if (LocaleCompare(keyword,"LINES") == 0) image->rows= MagickAtoL(value); if (LocaleCompare(keyword,"NL") == 0) image->rows= MagickAtoL(value); } while (isspace(c)) { c=ReadBlobByte(image); count++; } } while (count < (long) length) { c=ReadBlobByte(image); count++; } if ((image->columns == 0) || (image->rows == 0)) ThrowReaderException(CorruptImageError,NegativeOrZeroImageSize,image); image->depth=8; if (!AllocateImageColormap(image,256)) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); if (image_info->ping) { CloseBlob(image); return(image); } /* Read VICAR pixels. */ scanline=MagickAllocateMemory(unsigned char *,image->columns); if (scanline == (unsigned char *) NULL) ThrowReaderException(CorruptImageError,UnableToReadImageData,image); for (y=0; y < (long) image->rows; y++) { if (!SetImagePixels(image,0,y,image->columns,1)) break; (void) ReadBlob(image,image->columns,scanline); (void) ImportImagePixelArea(image,GrayQuantum,image->depth,scanline,0,0); if (!SyncImagePixels(image)) break; if (QuantumTick(y,image->rows)) if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText, image->filename, image->columns,image->rows)) break; } MagickFreeMemory(scanline); if (EOFBlob(image)) ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, image->filename); CloseBlob(image); return(image); }