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);
}
