/* {{{ proto int saveWebImage()
Writes image to temp directory. Returns image URL. */
PHP_METHOD(imageObj, saveWebImage)
{
zval *zobj = getThis();
php_image_object *php_image;
char *imageFile = NULL;
char *imageFilename = NULL;
char path[MS_MAXPATHLEN];
char *imageUrlFull = NULL;
PHP_MAPSCRIPT_ERROR_HANDLING(TRUE);
if (zend_parse_parameters_none() == FAILURE) {
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
return;
}
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
php_image = (php_image_object *) zend_object_store_get_object(zobj TSRMLS_CC);
imageFilename = msTmpFilename(php_image->image->format->extension);
imageFile = msBuildPath(path, php_image->image->imagepath, imageFilename);
if (msSaveImage(NULL, php_image->image, imageFile) != MS_SUCCESS)
{
mapscript_throw_mapserver_exception("Failed writing image to %s" TSRMLS_CC, imageFile);
return;
}
imageUrlFull = msBuildPath(path, php_image->image->imageurl, imageFilename);
msFree(imageFilename);
RETURN_STRING(imageUrlFull, 1);
}
/*
** Little helper function to allow us to build symbol files on-the-fly
** from just a file name.
**
** Returns the symbol index or -1 if it could not be added.
*/
int msAddImageSymbol(symbolSetObj *symbolset, char *filename)
{
char szPath[MS_MAXPATHLEN];
symbolObj *symbol=NULL;
if(!symbolset) {
msSetError(MS_SYMERR, "Symbol structure unallocated.", "msAddImageSymbol()");
return(-1);
}
if(!filename || strlen(filename) == 0) return(-1);
/* Allocate/init memory for new symbol if needed */
if (msGrowSymbolSet(symbolset) == NULL)
return -1;
symbol = symbolset->symbol[symbolset->numsymbols];
#ifdef USE_CURL
if (strncasecmp(filename, "http", 4) == 0) {
char *tmpfullfilename = NULL;
char *tmpfilename = NULL;
char *tmppath = NULL;
int status = 0;
char szPath[MS_MAXPATHLEN];
int bCheckLocalCache = MS_TRUE;
tmppath = msTmpPath(NULL, NULL, NULL);
if (tmppath) {
tmpfilename = msEncodeUrl(filename);
tmpfullfilename = msBuildPath(szPath, tmppath, tmpfilename);
if (tmpfullfilename) {
/*use the url for now as a caching mechanism*/
if (msHTTPGetFile(filename, tmpfullfilename, &status, -1, bCheckLocalCache, 0) == MS_SUCCESS) {
symbol->imagepath = msStrdup(tmpfullfilename);
symbol->full_pixmap_path = msStrdup(tmpfullfilename);
}
}
msFree(tmpfilename);
msFree(tmppath);
}
}
#endif
/*if the http did not work, allow it to be treated as a file*/
if (!symbol->full_pixmap_path) {
if(symbolset->map) {
symbol->full_pixmap_path = msStrdup(msBuildPath(szPath, symbolset->map->mappath, filename));
} else {
symbol->full_pixmap_path = msStrdup(msBuildPath(szPath, NULL, filename));
}
symbol->imagepath = msStrdup(filename);
}
symbol->name = msStrdup(filename);
symbol->type = MS_SYMBOL_PIXMAP;
return(symbolset->numsymbols++);
}
int msDBFJoinConnect(layerObj *layer, joinObj *join)
{
int i;
char szPath[MS_MAXPATHLEN];
msDBFJoinInfo *joininfo;
if(join->joininfo) return(MS_SUCCESS); /* already open */
if ( msCheckParentPointer(layer->map,"map")==MS_FAILURE )
return MS_FAILURE;
/* allocate a msDBFJoinInfo struct */
joininfo = (msDBFJoinInfo *) malloc(sizeof(msDBFJoinInfo));
if(!joininfo) {
msSetError(MS_MEMERR, "Error allocating XBase table info structure.", "msDBFJoinConnect()");
return(MS_FAILURE);
}
/* initialize any members that won't get set later on in this function */
joininfo->target = NULL;
joininfo->nextrecord = 0;
join->joininfo = joininfo;
/* open the XBase file */
if((joininfo->hDBF = msDBFOpen( msBuildPath3(szPath, layer->map->mappath, layer->map->shapepath, join->table), "rb" )) == NULL) {
if((joininfo->hDBF = msDBFOpen( msBuildPath(szPath, layer->map->mappath, join->table), "rb" )) == NULL) {
msSetError(MS_IOERR, "(%s)", "msDBFJoinConnect()", join->table);
return(MS_FAILURE);
}
}
/* get "to" item index */
if((joininfo->toindex = msDBFGetItemIndex(joininfo->hDBF, join->to)) == -1) {
msSetError(MS_DBFERR, "Item %s not found in table %s.", "msDBFJoinConnect()", join->to, join->table);
return(MS_FAILURE);
}
/* get "from" item index */
for(i=0; i<layer->numitems; i++) {
if(strcasecmp(layer->items[i],join->from) == 0) { /* found it */
joininfo->fromindex = i;
break;
}
}
if(i == layer->numitems) {
msSetError(MS_JOINERR, "Item %s not found in layer %s.", "msDBFJoinConnect()", join->from, layer->name);
return(MS_FAILURE);
}
/* finally store away the item names in the XBase table */
join->numitems = msDBFGetFieldCount(joininfo->hDBF);
join->items = msDBFGetItems(joininfo->hDBF);
if(!join->items) return(MS_FAILURE);
return(MS_SUCCESS);
}
/* msSetErrorFile()
**
** Set output target, ready to write to it, open file if necessary
**
** If pszRelToPath != NULL then we will try to make the value relative to
** this path if it is not absolute already and it's not one of the special
** values (stderr, stdout, windowsdebug)
**
** Returns MS_SUCCESS/MS_FAILURE
*/
int msSetErrorFile(const char *pszErrorFile, const char *pszRelToPath)
{
char extended_path[MS_MAXPATHLEN];
debugInfoObj *debuginfo = msGetDebugInfoObj();
if (strcmp(pszErrorFile, "stderr") != 0 &&
strcmp(pszErrorFile, "stdout") != 0 &&
strcmp(pszErrorFile, "windowsdebug") != 0) {
/* Try to make the path relative */
if(msBuildPath(extended_path, pszRelToPath, pszErrorFile) == NULL)
return MS_FAILURE;
pszErrorFile = extended_path;
}
if (debuginfo && debuginfo->errorfile && pszErrorFile &&
strcmp(debuginfo->errorfile, pszErrorFile) == 0) {
/* Nothing to do, already writing to the right place */
return MS_SUCCESS;
}
/* Close current output file if any */
msCloseErrorFile();
/* NULL or empty target will just close current output and return */
if (pszErrorFile == NULL || *pszErrorFile == '\0')
return MS_SUCCESS;
if (strcmp(pszErrorFile, "stderr") == 0) {
debuginfo->fp = stderr;
debuginfo->errorfile = msStrdup(pszErrorFile);
debuginfo->debug_mode = MS_DEBUGMODE_STDERR;
} else if (strcmp(pszErrorFile, "stdout") == 0) {
debuginfo->fp = stdout;
debuginfo->errorfile = msStrdup(pszErrorFile);
debuginfo->debug_mode = MS_DEBUGMODE_STDOUT;
} else if (strcmp(pszErrorFile, "windowsdebug") == 0) {
#ifdef _WIN32
debuginfo->errorfile = msStrdup(pszErrorFile);
debuginfo->fp = NULL;
debuginfo->debug_mode = MS_DEBUGMODE_WINDOWSDEBUG;
#else
msSetError(MS_MISCERR, "'MS_ERRORFILE windowsdebug' is available only on Windows platforms.", "msSetErrorFile()");
return MS_FAILURE;
#endif
} else {
debuginfo->fp = fopen(pszErrorFile, "a");
if (debuginfo->fp == NULL) {
msSetError(MS_MISCERR, "Failed to open MS_ERRORFILE %s", "msSetErrorFile()", pszErrorFile);
return MS_FAILURE;
}
debuginfo->errorfile = msStrdup(pszErrorFile);
debuginfo->debug_mode = MS_DEBUGMODE_FILE;
}
return MS_SUCCESS;
}
/* Execute a javascript file */
static Handle<Value> msV8ExecuteScript(const char *path, int throw_exception = MS_FALSE)
{
char fullpath[MS_MAXPATHLEN];
map<string, Persistent<Script> >::iterator it;
Isolate *isolate = Isolate::GetCurrent();
V8Context *v8context = (V8Context*)isolate->GetData();
/* construct the path */
msBuildPath(fullpath, v8context->paths.top().c_str(), path);
char *filepath = msGetPath((char*)fullpath);
v8context->paths.push(filepath);
free(filepath);
Handle<Script> script;
it = v8context->scripts.find(fullpath);
if (it == v8context->scripts.end()) {
Handle<Value> source = msV8ReadFile(v8context, fullpath);
Handle<String> script_name = String::New(msStripPath((char*)path));
script = msV8CompileScript(source->ToString(), script_name);
if (script.IsEmpty()) {
v8context->paths.pop();
if (throw_exception) {
return ThrowException(String::New("Error compiling script"));
}
}
/* cache the compiled script */
Persistent<Script> pscript;
pscript.Reset(isolate, script);
v8context->scripts[fullpath] = pscript;
} else {
script = v8context->scripts[fullpath];
}
Handle<Value> result = msV8RunScript(script);
v8context->paths.pop();
if (result.IsEmpty() && throw_exception) {
return ThrowException(String::New("Error running script"));
}
return result;
}
int msUVRASTERLayerGetExtent(layerObj *layer, rectObj *extent)
{
char szPath[MS_MAXPATHLEN];
mapObj *map = layer->map;
double adfGeoTransform[6];
int nXSize, nYSize;
GDALDatasetH hDS;
shapefileObj *tileshpfile;
int tilelayerindex = -1;
CPLErr eErr = CE_Failure;
char *decrypted_path;
if( (!layer->data || strlen(layer->data) == 0)
&& layer->tileindex == NULL) {
/* should we be issuing a specific error about not supporting
extents for tileindexed raster layers? */
return MS_FAILURE;
}
if( map == NULL )
return MS_FAILURE;
/* If the layer use a tileindex, return the extent of the tileindex shapefile/referenced layer */
if (layer->tileindex) {
tilelayerindex = msGetLayerIndex(map, layer->tileindex);
if(tilelayerindex != -1) /* does the tileindex reference another layer */
return msLayerGetExtent(GET_LAYER(map, tilelayerindex), extent);
else {
tileshpfile = (shapefileObj *) malloc(sizeof(shapefileObj));
MS_CHECK_ALLOC(tileshpfile, sizeof(shapefileObj), MS_FAILURE);
if(msShapefileOpen(tileshpfile, "rb", msBuildPath3(szPath, map->mappath, map->shapepath, layer->tileindex), MS_TRUE) == -1)
if(msShapefileOpen(tileshpfile, "rb", msBuildPath(szPath, map->mappath, layer->tileindex), MS_TRUE) == -1)
return MS_FAILURE;
*extent = tileshpfile->bounds;
msShapefileClose(tileshpfile);
free(tileshpfile);
return MS_SUCCESS;
}
}
msTryBuildPath3(szPath, map->mappath, map->shapepath, layer->data);
decrypted_path = msDecryptStringTokens( map, szPath );
msAcquireLock( TLOCK_GDAL );
if( decrypted_path ) {
hDS = GDALOpen(decrypted_path, GA_ReadOnly );
msFree( decrypted_path );
} else
hDS = NULL;
if( hDS != NULL ) {
nXSize = GDALGetRasterXSize( hDS );
nYSize = GDALGetRasterYSize( hDS );
eErr = GDALGetGeoTransform( hDS, adfGeoTransform );
GDALClose( hDS );
}
msReleaseLock( TLOCK_GDAL );
if( hDS == NULL || eErr != CE_None ) {
return MS_FAILURE;
}
/* If this appears to be an ungeoreferenced raster than flip it for
mapservers purposes. */
if( adfGeoTransform[5] == 1.0 && adfGeoTransform[3] == 0.0 ) {
adfGeoTransform[5] = -1.0;
adfGeoTransform[3] = nYSize;
}
extent->minx = adfGeoTransform[0];
extent->maxy = adfGeoTransform[3];
extent->maxx = adfGeoTransform[0] + nXSize * adfGeoTransform[1];
extent->miny = adfGeoTransform[3] + nYSize * adfGeoTransform[5];
return MS_SUCCESS;
}
/*
* generic function for drawing a legend icon. (added for bug #2348)
* renderer specific drawing functions shouldn't be called directly, but through
* this function
*/
int msDrawLegendIcon(mapObj *map, layerObj *lp, classObj *theclass,
int width, int height, imageObj *image, int dstX, int dstY)
{
int i, type, hasmarkersymbol;
double offset;
shapeObj box, zigzag;
pointObj marker;
char szPath[MS_MAXPATHLEN];
styleObj outline_style;
imageObj *image_draw = image;
int originalopacity = lp->opacity;
rendererVTableObj *renderer;
outputFormatObj *transFormat = NULL, *altFormat=NULL;
const char *alternativeFormatString = NULL;
if(!MS_RENDERER_PLUGIN(image->format)) {
msSetError(MS_MISCERR,"unsupported image format","msDrawLegendIcon()");
return MS_FAILURE;
}
alternativeFormatString = msLayerGetProcessingKey(lp, "RENDERER");
if (MS_RENDERER_PLUGIN(image_draw->format) && alternativeFormatString!=NULL &&
(altFormat= msSelectOutputFormat(map, alternativeFormatString))) {
msInitializeRendererVTable(altFormat);
image_draw = msImageCreate(image->width, image->height,
altFormat, image->imagepath, image->imageurl, map->resolution, map->defresolution, &map->imagecolor);
renderer = MS_IMAGE_RENDERER(image_draw);
} else {
renderer = MS_IMAGE_RENDERER(image_draw);
if (lp->opacity > 0 && lp->opacity < 100) {
if (!renderer->supports_transparent_layers) {
image_draw = msImageCreate(image->width, image->height,
image->format, image->imagepath, image->imageurl, map->resolution, map->defresolution, NULL);
if (!image_draw) {
msSetError(MS_MISCERR, "Unable to initialize temporary transparent image.",
"msDrawLegendIcon()");
return (MS_FAILURE);
}
/* set opacity to full, as the renderer should be rendering a fully opaque image */
lp->opacity=100;
}
}
}
if(renderer->supports_clipping && MS_VALID_COLOR(map->legend.outlinecolor)) {
/* keep GD specific code here for now as it supports clipping */
rectObj clip;
clip.maxx = dstX + width - 1;
clip.maxy = dstY + height -1;
clip.minx = dstX;
clip.miny = dstY;
renderer->setClip(image_draw,clip);
}
/* initialize the box used for polygons and for outlines */
box.line = (lineObj *)msSmallMalloc(sizeof(lineObj));
box.numlines = 1;
box.line[0].point = (pointObj *)msSmallMalloc(sizeof(pointObj)*5);
box.line[0].numpoints = 5;
box.line[0].point[0].x = dstX + 0.5;
box.line[0].point[0].y = dstY + 0.5;
box.line[0].point[1].x = dstX + width - 0.5;
box.line[0].point[1].y = dstY + 0.5;
box.line[0].point[2].x = dstX + width - 0.5;
box.line[0].point[2].y = dstY + height - 0.5;
box.line[0].point[3].x = dstX + 0.5;
box.line[0].point[3].y = dstY + height - 0.5;
box.line[0].point[4].x = box.line[0].point[0].x;
box.line[0].point[4].y = box.line[0].point[0].y;
box.line[0].numpoints = 5;
/* if the class has a keyimage, treat it as a point layer
* (the keyimage will be treated there) */
if(theclass->keyimage != NULL) {
type = MS_LAYER_POINT;
} else {
/* some polygon layers may be better drawn using zigzag if there is no fill */
type = lp->type;
if(type == MS_LAYER_POLYGON) {
type = MS_LAYER_LINE;
for(i=0; i<theclass->numstyles; i++) {
if(MS_VALID_COLOR(theclass->styles[i]->color)) { /* there is a fill */
type = MS_LAYER_POLYGON;
break;
}
}
}
}
/*
** now draw the appropriate color/symbol/size combination
*/
switch(type) {
case MS_LAYER_ANNOTATION:
marker.x = dstX + MS_NINT(width / 2.0);
marker.y = dstY + MS_NINT(height / 2.0);
hasmarkersymbol = 0;
for(i=0; i<theclass->numstyles; i++) {
if (theclass->styles[i]->symbol < map->symbolset.numsymbols && theclass->styles[i]->symbol > 0) {
hasmarkersymbol = 1;
break;
}
}
if (hasmarkersymbol) {
for(i=0; i<theclass->numstyles; i++)
msDrawMarkerSymbol(&map->symbolset, image_draw, &marker, theclass->styles[i], lp->scalefactor);
} else if (theclass->labels && theclass->numlabels > 0) {
labelObj *label = theclass->labels[0]; /* use the first label definition */
double lsize = label->size;
double langle = label->angle;
int lpos = label->position;
int loffsetx = label->offsetx;
int loffsety = label->offsety;
label->offsetx = 0;
label->offsety = 0;
label->angle = 0;
label->position = MS_CC;
if (label->type == MS_TRUETYPE) label->size = height;
msDrawLabel(map, image_draw, marker, (char*)"Az", label,1.0);
label->size = lsize;
label->position = lpos;
label->angle = langle;
label->offsetx = loffsetx;
label->offsety = loffsety;
}
break;
case MS_LAYER_POINT:
marker.x = dstX + MS_NINT(width / 2.0);
marker.y = dstY + MS_NINT(height / 2.0);
if(theclass->keyimage != NULL) {
int symbolNum;
styleObj imgStyle;
symbolObj *symbol=NULL;
symbolNum = msAddImageSymbol(&(map->symbolset), msBuildPath(szPath, map->mappath, theclass->keyimage));
if(symbolNum == -1) {
msSetError(MS_GDERR, "Failed to open legend key image", "msCreateLegendIcon()");
return(MS_FAILURE);
}
symbol = map->symbolset.symbol[symbolNum];
initStyle(&imgStyle);
/*set size so that symbol will be scaled properly #3296*/
if (width/symbol->sizex < height/symbol->sizey)
imgStyle.size = symbol->sizey*(width/symbol->sizex);
else
imgStyle.size = symbol->sizey*(height/symbol->sizey);
if (imgStyle.size > imgStyle.maxsize)
imgStyle.maxsize = imgStyle.size;
imgStyle.symbol = symbolNum;
msDrawMarkerSymbol(&map->symbolset,image_draw,&marker,&imgStyle,lp->scalefactor);
/* TO DO: we may want to handle this differently depending on the relative size of the keyimage */
} else {
for(i=0; i<theclass->numstyles; i++)
msDrawMarkerSymbol(&map->symbolset, image_draw, &marker, theclass->styles[i], lp->scalefactor);
}
break;
case MS_LAYER_LINE:
offset = 1;
/* To set the offset, we only check the size/width parameter of the first style */
if (theclass->numstyles > 0) {
if (theclass->styles[0]->symbol > 0 && theclass->styles[0]->symbol < map->symbolset.numsymbols &&
map->symbolset.symbol[theclass->styles[0]->symbol]->type != MS_SYMBOL_SIMPLE)
offset = theclass->styles[0]->size/2;
else
offset = theclass->styles[0]->width/2;
}
zigzag.line = (lineObj *)msSmallMalloc(sizeof(lineObj));
zigzag.numlines = 1;
zigzag.line[0].point = (pointObj *)msSmallMalloc(sizeof(pointObj)*4);
zigzag.line[0].numpoints = 4;
zigzag.line[0].point[0].x = dstX + offset;
zigzag.line[0].point[0].y = dstY + height - offset;
zigzag.line[0].point[1].x = dstX + MS_NINT(width / 3.0) - 1;
zigzag.line[0].point[1].y = dstY + offset;
zigzag.line[0].point[2].x = dstX + MS_NINT(2.0 * width / 3.0) - 1;
zigzag.line[0].point[2].y = dstY + height - offset;
zigzag.line[0].point[3].x = dstX + width - offset;
zigzag.line[0].point[3].y = dstY + offset;
for(i=0; i<theclass->numstyles; i++)
msDrawLineSymbol(&map->symbolset, image_draw, &zigzag, theclass->styles[i], lp->scalefactor);
free(zigzag.line[0].point);
free(zigzag.line);
break;
case MS_LAYER_CIRCLE:
case MS_LAYER_RASTER:
case MS_LAYER_CHART:
case MS_LAYER_POLYGON:
for(i=0; i<theclass->numstyles; i++)
msDrawShadeSymbol(&map->symbolset, image_draw, &box, theclass->styles[i], lp->scalefactor);
break;
default:
return MS_FAILURE;
break;
} /* end symbol drawing */
/* handle an outline if necessary */
if(MS_VALID_COLOR(map->legend.outlinecolor)) {
initStyle(&outline_style);
outline_style.color = map->legend.outlinecolor;
msDrawLineSymbol(&map->symbolset, image_draw, &box, &outline_style, 1.0);
/* reset clipping rectangle */
if(renderer->supports_clipping)
renderer->resetClip(image_draw);
}
if (altFormat) {
rendererVTableObj *renderer = MS_IMAGE_RENDERER(image);
rendererVTableObj *altrenderer = MS_IMAGE_RENDERER(image_draw);
rasterBufferObj rb;
memset(&rb,0,sizeof(rasterBufferObj));
altrenderer->getRasterBufferHandle(image_draw,&rb);
renderer->mergeRasterBuffer(image,&rb,lp->opacity*0.01,0,0,0,0,rb.width,rb.height);
/*
* hack to work around bug #3834: if we have use an alternate renderer, the symbolset may contain
* symbols that reference it. We want to remove those references before the altFormat is destroyed
* to avoid a segfault and/or a leak, and so the the main renderer doesn't pick the cache up thinking
* it's for him.
*/
for(i=0; i<map->symbolset.numsymbols; i++) {
if (map->symbolset.symbol[i]!=NULL) {
symbolObj *s = map->symbolset.symbol[i];
if(s->renderer == altrenderer) {
altrenderer->freeSymbol(s);
s->renderer = NULL;
}
}
}
msFreeImage(image_draw);
} else if(image != image_draw) {
rendererVTableObj *renderer = MS_IMAGE_RENDERER(image_draw);
rasterBufferObj rb;
memset(&rb,0,sizeof(rasterBufferObj));
lp->opacity = originalopacity;
renderer->getRasterBufferHandle(image_draw,&rb);
renderer->mergeRasterBuffer(image,&rb,lp->opacity*0.01,0,0,0,0,rb.width,rb.height);
msFreeImage(image_draw);
/* deref and possibly free temporary transparent output format. */
msApplyOutputFormat( &transFormat, NULL, MS_NOOVERRIDE, MS_NOOVERRIDE, MS_NOOVERRIDE );
}
free(box.line[0].point);
free(box.line);
return MS_SUCCESS;
}
/*
* generic function for drawing a legend icon. (added for bug #2348)
* renderer specific drawing functions shouldn't be called directly, but through
* this function
*/
int msDrawLegendIcon(mapObj *map, layerObj *lp, classObj *theclass,
int width, int height, imageObj *image, int dstX, int dstY,
int scale_independant, class_hittest *hittest)
{
int i, type, hasmarkersymbol, ret=MS_SUCCESS;
double offset;
double polygon_contraction = 0.5; /* used to account for the width of a polygon's outline */
shapeObj box, zigzag;
lineObj box_line,zigzag_line;
pointObj box_point[5], zigzag_point[4];
pointObj marker;
char szPath[MS_MAXPATHLEN];
styleObj outline_style;
imageObj *image_draw = image;
int originalopacity = lp->opacity;
rendererVTableObj *renderer;
outputFormatObj *transFormat = NULL, *altFormat=NULL;
const char *alternativeFormatString = NULL;
if(!MS_RENDERER_PLUGIN(image->format)) {
msSetError(MS_MISCERR,"unsupported image format","msDrawLegendIcon()");
return MS_FAILURE;
}
alternativeFormatString = msLayerGetProcessingKey(lp, "RENDERER");
if (MS_RENDERER_PLUGIN(image_draw->format) && alternativeFormatString!=NULL &&
(altFormat= msSelectOutputFormat(map, alternativeFormatString))) {
msInitializeRendererVTable(altFormat);
image_draw = msImageCreate(image->width, image->height,
altFormat, image->imagepath, image->imageurl, map->resolution, map->defresolution, &map->imagecolor);
renderer = MS_IMAGE_RENDERER(image_draw);
} else {
renderer = MS_IMAGE_RENDERER(image_draw);
if (lp->opacity > 0 && lp->opacity < 100) {
if (!renderer->supports_transparent_layers) {
image_draw = msImageCreate(image->width, image->height,
image->format, image->imagepath, image->imageurl, map->resolution, map->defresolution, NULL);
if (!image_draw) {
msSetError(MS_MISCERR, "Unable to initialize temporary transparent image.",
"msDrawLegendIcon()");
return (MS_FAILURE);
}
/* set opacity to full, as the renderer should be rendering a fully opaque image */
lp->opacity=100;
}
}
}
if(renderer->supports_clipping && MS_VALID_COLOR(map->legend.outlinecolor)) {
/* keep GD specific code here for now as it supports clipping */
rectObj clip;
clip.maxx = dstX + width - 1;
clip.maxy = dstY + height -1;
clip.minx = dstX;
clip.miny = dstY;
renderer->setClip(image_draw,clip);
}
/* if the class has a keyimage, treat it as a point layer
* (the keyimage will be treated there) */
if(theclass->keyimage != NULL) {
type = MS_LAYER_POINT;
} else {
/* some polygon layers may be better drawn using zigzag if there is no fill */
type = lp->type;
if(type == MS_LAYER_POLYGON) {
type = MS_LAYER_LINE;
for(i=0; i<theclass->numstyles; i++) {
if(MS_VALID_COLOR(theclass->styles[i]->color)) { /* there is a fill */
type = MS_LAYER_POLYGON;
}
if(MS_VALID_COLOR(theclass->styles[i]->outlinecolor)) { /* there is an outline */
polygon_contraction = MS_MAX(polygon_contraction, theclass->styles[i]->width / 2.0);
}
}
}
}
/* initialize the box used for polygons and for outlines */
box.line = &box_line;
box.numlines = 1;
box.line[0].point = box_point;
box.line[0].numpoints = 5;
box.line[0].point[0].x = dstX + polygon_contraction;
box.line[0].point[0].y = dstY + polygon_contraction;
box.line[0].point[1].x = dstX + width - polygon_contraction;
box.line[0].point[1].y = dstY + polygon_contraction;
box.line[0].point[2].x = dstX + width - polygon_contraction;
box.line[0].point[2].y = dstY + height - polygon_contraction;
box.line[0].point[3].x = dstX + polygon_contraction;
box.line[0].point[3].y = dstY + height - polygon_contraction;
box.line[0].point[4].x = box.line[0].point[0].x;
box.line[0].point[4].y = box.line[0].point[0].y;
/*
** now draw the appropriate color/symbol/size combination
*/
switch(type) {
case MS_LAYER_POINT:
marker.x = dstX + MS_NINT(width / 2.0);
marker.y = dstY + MS_NINT(height / 2.0);
if(theclass->keyimage != NULL) {
int symbolNum;
styleObj imgStyle;
symbolObj *symbol=NULL;
for(symbolNum=0; symbolNum<theclass->numstyles; symbolNum++)
symbolNum = msAddImageSymbol(&(map->symbolset), msBuildPath(szPath, map->mappath, theclass->keyimage));
if(symbolNum == -1) {
msSetError(MS_IMGERR, "Failed to open legend key image", "msCreateLegendIcon()");
return(MS_FAILURE);
}
symbol = map->symbolset.symbol[symbolNum];
initStyle(&imgStyle);
/*set size so that symbol will be scaled properly #3296*/
if (width/symbol->sizex < height/symbol->sizey)
imgStyle.size = symbol->sizey*(width/symbol->sizex);
else
imgStyle.size = symbol->sizey*(height/symbol->sizey);
if (imgStyle.size > imgStyle.maxsize)
imgStyle.maxsize = imgStyle.size;
imgStyle.symbol = symbolNum;
ret = msDrawMarkerSymbol(map ,image_draw,&marker,&imgStyle,lp->scalefactor * image_draw->resolutionfactor);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
/* TO DO: we may want to handle this differently depending on the relative size of the keyimage */
} else {
for(i=0; i<theclass->numstyles; i++) {
if(!scale_independant && map->scaledenom > 0) {
styleObj *lp = theclass->styles[i];
if((lp->maxscaledenom > 0) && (map->scaledenom > lp->maxscaledenom)) continue;
if((lp->minscaledenom > 0) && (map->scaledenom <= lp->minscaledenom)) continue;
}
if(hittest && hittest->stylehits[i].status == 0) continue;
ret = msDrawMarkerSymbol(map, image_draw, &marker, theclass->styles[i], lp->scalefactor * image->resolutionfactor);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
}
}
break;
case MS_LAYER_LINE:
offset = 1;
/* To set the offset, we only check the size/width parameter of the first style */
if (theclass->numstyles > 0) {
if (theclass->styles[0]->symbol > 0 && theclass->styles[0]->symbol < map->symbolset.numsymbols &&
map->symbolset.symbol[theclass->styles[0]->symbol]->type != MS_SYMBOL_SIMPLE)
offset = theclass->styles[0]->size/2;
else
offset = theclass->styles[0]->width/2;
}
zigzag.line = &zigzag_line;
zigzag.numlines = 1;
zigzag.line[0].point = zigzag_point;
zigzag.line[0].numpoints = 4;
zigzag.line[0].point[0].x = dstX + offset;
zigzag.line[0].point[0].y = dstY + height - offset;
zigzag.line[0].point[1].x = dstX + MS_NINT(width / 3.0) - 1;
zigzag.line[0].point[1].y = dstY + offset;
zigzag.line[0].point[2].x = dstX + MS_NINT(2.0 * width / 3.0) - 1;
zigzag.line[0].point[2].y = dstY + height - offset;
zigzag.line[0].point[3].x = dstX + width - offset;
zigzag.line[0].point[3].y = dstY + offset;
for(i=0; i<theclass->numstyles; i++) {
if(!scale_independant && map->scaledenom > 0) {
styleObj *lp = theclass->styles[i];
if((lp->maxscaledenom > 0) && (map->scaledenom > lp->maxscaledenom)) continue;
if((lp->minscaledenom > 0) && (map->scaledenom <= lp->minscaledenom)) continue;
}
if(hittest && hittest->stylehits[i].status == 0) continue;
if (theclass->styles[i]->_geomtransform.type == MS_GEOMTRANSFORM_NONE ||
theclass->styles[i]->_geomtransform.type == MS_GEOMTRANSFORM_LABELPOINT ||
theclass->styles[i]->_geomtransform.type == MS_GEOMTRANSFORM_LABELPOLY) {
ret = msDrawLineSymbol(map, image_draw, &zigzag, theclass->styles[i], lp->scalefactor * image_draw->resolutionfactor);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
}
else {
ret = msDrawTransformedShape(map, image_draw, &zigzag, theclass->styles[i], lp->scalefactor * image_draw->resolutionfactor);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
}
}
break;
case MS_LAYER_CIRCLE:
case MS_LAYER_RASTER:
case MS_LAYER_CHART:
case MS_LAYER_POLYGON:
for(i=0; i<theclass->numstyles; i++) {
if(!scale_independant && map->scaledenom > 0) {
styleObj *lp = theclass->styles[i];
if((lp->maxscaledenom > 0) && (map->scaledenom > lp->maxscaledenom)) continue;
if((lp->minscaledenom > 0) && (map->scaledenom <= lp->minscaledenom)) continue;
}
if(hittest && hittest->stylehits[i].status == 0) continue;
if (theclass->styles[i]->_geomtransform.type == MS_GEOMTRANSFORM_NONE ||
theclass->styles[i]->_geomtransform.type == MS_GEOMTRANSFORM_LABELPOINT ||
theclass->styles[i]->_geomtransform.type == MS_GEOMTRANSFORM_LABELPOLY) {
ret = msDrawShadeSymbol(map, image_draw, &box, theclass->styles[i], lp->scalefactor * image_draw->resolutionfactor);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
}
else {
ret = msDrawTransformedShape(map, image_draw, &box,
theclass->styles[i], lp->scalefactor);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
}
}
break;
default:
return MS_FAILURE;
break;
} /* end symbol drawing */
/* handle label styles */
for(i=0; i<theclass->numlabels; i++) {
labelObj *l = theclass->labels[i];
if(!scale_independant && map->scaledenom > 0) {
if(msScaleInBounds(map->scaledenom, l->minscaledenom, l->maxscaledenom)) {
int j;
for(j=0; j<l->numstyles; j++) {
styleObj *s = l->styles[j];
marker.x = dstX + MS_NINT(width / 2.0);
marker.y = dstY + MS_NINT(height / 2.0);
if(s->_geomtransform.type == MS_GEOMTRANSFORM_LABELPOINT) {
ret = msDrawMarkerSymbol(map, image_draw, &marker, s, lp->scalefactor);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
}
}
}
}
}
/* handle "pure" text layers, i.e. layers with no symbology */
hasmarkersymbol = 0;
if(theclass->numstyles == 0) {
for(i=0; i<theclass->numlabels; i++) {
labelObj *l = theclass->labels[i];
if(!scale_independant && map->scaledenom > 0) {
if(msScaleInBounds(map->scaledenom, l->minscaledenom, l->maxscaledenom)) {
int j;
for(j=0; j<l->numstyles; j++) {
styleObj *s = l->styles[j];
if(s->_geomtransform.type == MS_GEOMTRANSFORM_LABELPOINT) {
hasmarkersymbol = 1;
}
}
}
}
}
} else {
hasmarkersymbol = 1;
}
if(!hasmarkersymbol && theclass->numlabels>0) {
textSymbolObj ts;
pointObj textstartpt;
marker.x = dstX + MS_NINT(width / 2.0);
marker.y = dstY + MS_NINT(height / 2.0);
initTextSymbol(&ts);
msPopulateTextSymbolForLabelAndString(&ts,theclass->labels[0],msStrdup("Az"),lp->scalefactor*image_draw->resolutionfactor,image_draw->resolutionfactor, duplicate_always);
ts.label->size = height - 1;
ret = msComputeTextPath(map,&ts);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
textstartpt = get_metrics(&marker,MS_CC,ts.textpath,0,0,0,0,NULL);
ret = msDrawTextSymbol(map,image_draw, textstartpt, &ts);
freeTextSymbol(&ts);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
}
/* handle an outline if necessary */
if(MS_VALID_COLOR(map->legend.outlinecolor)) {
initStyle(&outline_style);
outline_style.color = map->legend.outlinecolor;
ret = msDrawLineSymbol(map, image_draw, &box, &outline_style, image_draw->resolutionfactor);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
/* reset clipping rectangle */
if(renderer->supports_clipping)
renderer->resetClip(image_draw);
}
if (altFormat) {
rendererVTableObj *renderer = MS_IMAGE_RENDERER(image);
rendererVTableObj *altrenderer = MS_IMAGE_RENDERER(image_draw);
rasterBufferObj rb;
memset(&rb,0,sizeof(rasterBufferObj));
ret = altrenderer->getRasterBufferHandle(image_draw,&rb);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
ret = renderer->mergeRasterBuffer(image,&rb,lp->opacity*0.01,0,0,0,0,rb.width,rb.height);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
/*
* hack to work around bug #3834: if we have use an alternate renderer, the symbolset may contain
* symbols that reference it. We want to remove those references before the altFormat is destroyed
* to avoid a segfault and/or a leak, and so the the main renderer doesn't pick the cache up thinking
* it's for him.
*/
for(i=0; i<map->symbolset.numsymbols; i++) {
if (map->symbolset.symbol[i]!=NULL) {
symbolObj *s = map->symbolset.symbol[i];
if(s->renderer == altrenderer) {
altrenderer->freeSymbol(s);
s->renderer = NULL;
}
}
}
} else if(image != image_draw) {
rendererVTableObj *renderer = MS_IMAGE_RENDERER(image_draw);
rasterBufferObj rb;
memset(&rb,0,sizeof(rasterBufferObj));
lp->opacity = originalopacity;
ret = renderer->getRasterBufferHandle(image_draw,&rb);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
ret = renderer->mergeRasterBuffer(image,&rb,lp->opacity*0.01,0,0,0,0,rb.width,rb.height);
if(UNLIKELY(ret == MS_FAILURE)) goto legend_icon_cleanup;
/* deref and possibly free temporary transparent output format. */
msApplyOutputFormat( &transFormat, NULL, MS_NOOVERRIDE, MS_NOOVERRIDE, MS_NOOVERRIDE );
}
legend_icon_cleanup:
if(image != image_draw) {
msFreeImage(image_draw);
}
return ret;
}
int msLoadFontSet(fontSetObj *fontset, mapObj *map)
{
FILE *stream;
char buffer[MS_BUFFER_LENGTH];
char alias[64], file1[MS_PATH_LENGTH], file2[MS_PATH_LENGTH];
char *path;
char szPath[MS_MAXPATHLEN];
int i;
int bFullPath = 0;
if(fontset->numfonts != 0) /* already initialized */
return(0);
if(!fontset->filename)
return(0);
fontset->map = (mapObj *)map;
path = msGetPath(fontset->filename);
/* fontset->fonts = msCreateHashTable(); // create font hash */
/* if(!fontset->fonts) { */
/* msSetError(MS_HASHERR, "Error initializing font hash.", "msLoadFontSet()"); */
/* return(-1); */
/* } */
stream = fopen( msBuildPath(szPath, fontset->map->mappath, fontset->filename), "r");
if(!stream) {
msSetError(MS_IOERR, "Error opening fontset %s.", "msLoadFontset()",
fontset->filename);
return(-1);
}
i = 0;
while(fgets(buffer, MS_BUFFER_LENGTH, stream)) { /* while there's something to load */
if(buffer[0] == '#' || buffer[0] == '\n' || buffer[0] == '\r' || buffer[0] == ' ')
continue; /* skip comments and blank lines */
sscanf(buffer,"%s %s", alias, file1);
if (!(*file1) || !(*alias) || (strlen(file1) <= 0))
continue;
bFullPath = 0;
#if defined(_WIN32) && !defined(__CYGWIN__)
if (file1[0] == '\\' || (strlen(file1) > 1 && (file1[1] == ':')))
bFullPath = 1;
#else
if(file1[0] == '/')
bFullPath = 1;
#endif
if(bFullPath) { /* already full path */
msInsertHashTable(&(fontset->fonts), alias, file1);
} else {
snprintf(file2, sizeof(file2), "%s%s", path, file1);
/* msInsertHashTable(fontset->fonts, alias, file2); */
/*
** msBuildPath is use here, but if we have to save the fontset file
** the msBuildPath must be done everywhere the fonts are used and
** removed here.
*/
msInsertHashTable(&(fontset->fonts), alias,
msBuildPath(szPath, fontset->map->mappath, file2));
}
i++;
}
fontset->numfonts = i;
fclose(stream); /* close the file */
free(path);
return(0);
}
int msCSVJoinConnect(layerObj *layer, joinObj *join)
{
int i;
FILE *stream;
char szPath[MS_MAXPATHLEN];
msCSVJoinInfo *joininfo;
char buffer[MS_BUFFER_LENGTH];
if(join->joininfo) return(MS_SUCCESS); /* already open */
if ( msCheckParentPointer(layer->map,"map")==MS_FAILURE )
return MS_FAILURE;
/* allocate a msCSVJoinInfo struct */
if((joininfo = (msCSVJoinInfo *) malloc(sizeof(msCSVJoinInfo))) == NULL) {
msSetError(MS_MEMERR, "Error allocating CSV table info structure.", "msCSVJoinConnect()");
return(MS_FAILURE);
}
/* initialize any members that won't get set later on in this function */
joininfo->target = NULL;
joininfo->nextrow = 0;
join->joininfo = joininfo;
/* open the CSV file */
if((stream = fopen( msBuildPath3(szPath, layer->map->mappath, layer->map->shapepath, join->table), "r" )) == NULL) {
if((stream = fopen( msBuildPath(szPath, layer->map->mappath, join->table), "r" )) == NULL) {
msSetError(MS_IOERR, "(%s)", "msCSVJoinConnect()", join->table);
return(MS_FAILURE);
}
}
/* once through to get the number of rows */
joininfo->numrows = 0;
while(fgets(buffer, MS_BUFFER_LENGTH, stream) != NULL) joininfo->numrows++;
rewind(stream);
if((joininfo->rows = (char ***) malloc(joininfo->numrows*sizeof(char **))) == NULL) {
msSetError(MS_MEMERR, "Error allocating rows.", "msCSVJoinConnect()");
return(MS_FAILURE);
}
/* load the rows */
i = 0;
while(fgets(buffer, MS_BUFFER_LENGTH, stream) != NULL) {
msStringTrimEOL(buffer);
joininfo->rows[i] = msStringSplitComplex(buffer, ",", &(join->numitems), MS_ALLOWEMPTYTOKENS);
i++;
}
fclose(stream);
/* get "from" item index */
for(i=0; i<layer->numitems; i++) {
if(strcasecmp(layer->items[i],join->from) == 0) { /* found it */
joininfo->fromindex = i;
break;
}
}
if(i == layer->numitems) {
msSetError(MS_JOINERR, "Item %s not found in layer %s.", "msCSVJoinConnect()", join->from, layer->name);
return(MS_FAILURE);
}
/* get "to" index (for now the user tells us which column, 1..n) */
joininfo->toindex = atoi(join->to) - 1;
if(joininfo->toindex < 0 || joininfo->toindex > join->numitems) {
msSetError(MS_JOINERR, "Invalid column index %s.", "msCSVJoinConnect()", join->to);
return(MS_FAILURE);
}
/* store away the column names (1..n) */
if((join->items = (char **) malloc(sizeof(char *)*join->numitems)) == NULL) {
msSetError(MS_MEMERR, "Error allocating space for join item names.", "msCSVJoinConnect()");
return(MS_FAILURE);
}
for(i=0; i<join->numitems; i++) {
join->items[i] = (char *) malloc(8); /* plenty of space */
sprintf(join->items[i], "%d", i+1);
}
return(MS_SUCCESS);
}
int loadSymbolSet(symbolSetObj *symbolset, mapObj *map)
{
int status=1;
char szPath[MS_MAXPATHLEN], *pszSymbolPath=NULL;
int foundSymbolSetToken=MS_FALSE;
int token;
if(!symbolset) {
msSetError(MS_SYMERR, "Symbol structure unallocated.", "loadSymbolSet()");
return(-1);
}
symbolset->map = (mapObj *)map;
if(!symbolset->filename) return(0);
/*
** Open the file
*/
if((msyyin = fopen(msBuildPath(szPath, symbolset->map->mappath, symbolset->filename), "r")) == NULL) {
msSetError(MS_IOERR, "(%s)", "loadSymbolSet()", symbolset->filename);
return(-1);
}
pszSymbolPath = msGetPath(szPath);
msyystate = MS_TOKENIZE_FILE; /* restore lexer state to INITIAL, and do return comments */
msyylex(); /* sets things up, but doesn't process any tokens */
msyylineno = 0; /* reset line counter */
msyyrestart(msyyin); /* flush the scanner - there's a better way but this works for now */
/*
** Read the symbol file
*/
for(;;) {
token = msyylex();
if(!foundSymbolSetToken && token != SYMBOLSET) {
msSetError(MS_IDENTERR, "First token must be SYMBOLSET, this doesn't look like a symbol file.", "msLoadSymbolSet()");
return(-1);
}
switch(token) {
case(END):
case(EOF):
status = 0;
break;
case(SYMBOL):
/* Allocate/init memory for new symbol if needed */
if (msGrowSymbolSet(symbolset) == NULL) {
status = -1;
} else if((loadSymbol((symbolset->symbol[symbolset->numsymbols]), pszSymbolPath) == -1))
status = -1;
else
symbolset->numsymbols++;
break;
case(SYMBOLSET):
foundSymbolSetToken = MS_TRUE;
break;
default:
msSetError(MS_IDENTERR, "Parsing error near (%s):(line %d)", "loadSymbolSet()", msyystring_buffer, msyylineno);
status = -1;
} /* end switch */
if(status != 1) break;
} /* end for */
fclose(msyyin);
msyyin = NULL;
free(pszSymbolPath);
return(status);
}
int loadSymbol(symbolObj *s, char *symbolpath)
{
int done=MS_FALSE;
char szPath[MS_MAXPATHLEN];
initSymbol(s);
for(;;) {
switch(msyylex()) {
case(ANCHORPOINT):
if(getDouble(&(s->anchorpoint_x)) == -1) return MS_FAILURE;
if(getDouble(&(s->anchorpoint_y)) == -1) return MS_FAILURE;
if(s->anchorpoint_x<0 || s->anchorpoint_x>1 || s->anchorpoint_y<0 || s->anchorpoint_y>1) {
msSetError(MS_SYMERR, "ANCHORPOINT must be between 0 and 1", "loadSymbol()");
return(-1);
}
break;
case(ANTIALIAS):
if((s->antialias = getSymbol(2,MS_TRUE,MS_FALSE)) == -1)
return(-1);
break;
case(CHARACTER):
if(getString(&s->character) == MS_FAILURE) return(-1);
break;
case(END): /* do some error checking */
if((s->type == MS_SYMBOL_SVG) && (s->imagepath == NULL)) {
msSetError(MS_SYMERR, "Symbol of type SVG has no file path specified.", "loadSymbol()");
return(-1);
}
if((s->type == MS_SYMBOL_PIXMAP) && (s->full_pixmap_path == NULL)) {
msSetError(MS_SYMERR, "Symbol of type PIXMAP has no image data.", "loadSymbol()");
return(-1);
}
if(((s->type == MS_SYMBOL_ELLIPSE) || (s->type == MS_SYMBOL_VECTOR)) && (s->numpoints == 0)) {
msSetError(MS_SYMERR, "Symbol of type VECTOR or ELLIPSE has no point data.", "loadSymbol()");
return(-1);
}
if(s->type == MS_SYMBOL_VECTOR) {
double minx = s->points[0].x;
double miny = s->points[0].y;
/* should only negative points be shifted? (#4116)*/
int shiftpositive = ((s->anchorpoint_x!=0.5)||(s->anchorpoint_y!=0.5));
int i;
for(i=1; i<s->numpoints; i++) {
if(s->points[i].x != -99 && s->points[i].y != -99) {
if(s->points[i].x<minx) minx = s->points[i].x;
if(s->points[i].y<miny) miny = s->points[i].y;
}
}
if(minx<0 || miny<0 || (shiftpositive && (minx!=0 || miny!=0))) {
for(i=0; i<s->numpoints; i++) {
if(s->points[i].x != -99 && s->points[i].y != -99) {
s->points[i].x -= minx;
s->points[i].y -= miny;
}
}
s->sizex -= minx;
s->sizey -= miny;
}
}
return(0);
break;
case(EOF):
msSetError(MS_EOFERR, NULL, "loadSymbol()");
return(-1);
break;
case(FILLED):
if((s->filled = getSymbol(2,MS_TRUE,MS_FALSE)) == -1)
return(-1);
break;
case(FONT):
if(getString(&s->font) == MS_FAILURE) return(-1);
break;
case(IMAGE):
if(msyylex() != MS_STRING) { /* get image location from next token */
msSetError(MS_TYPEERR, "Parsing error near (%s):(line %d)", "loadSymbol()", msyystring_buffer, msyylineno);
return(-1);
}
s->full_pixmap_path = msStrdup(msBuildPath(szPath, symbolpath, msyystring_buffer));
/* Set imagepath */
s->imagepath = msStrdup(msyystring_buffer);
break;
case(NAME):
if(getString(&s->name) == MS_FAILURE) return(-1);
break;
case(POINTS):
done = MS_FALSE;
s->sizex = 0;
s->sizey = 0;
for(;;) {
switch(msyylex()) {
case(END):
done = MS_TRUE;
break;
case(MS_NUMBER):
s->points[s->numpoints].x = atof(msyystring_buffer); /* grab the x */
if(getDouble(&(s->points[s->numpoints].y)) == -1) return(-1); /* grab the y */
if(s->points[s->numpoints].x!=-99) {
s->sizex = MS_MAX(s->sizex, s->points[s->numpoints].x);
s->sizey = MS_MAX(s->sizey, s->points[s->numpoints].y);
}
s->numpoints++;
break;
default:
msSetError(MS_TYPEERR, "Parsing error near (%s):(line %d)", "loadSymbol()", msyystring_buffer, msyylineno);
return(-1);
}
if(done == MS_TRUE)
break;
}
break;
case(TRANSPARENT):
s->transparent = MS_TRUE;
if(getInteger(&(s->transparentcolor)) == -1) return(-1);
break;
case(TYPE):
if((s->type = getSymbol(8,MS_SYMBOL_VECTOR,MS_SYMBOL_ELLIPSE,MS_SYMBOL_PIXMAP,MS_SYMBOL_SIMPLE,MS_TRUETYPE,MS_SYMBOL_HATCH,MS_SYMBOL_SVG)) == -1)
return(-1);
if(s->type == MS_TRUETYPE) /* TrueType keyword is valid several place in map files and symbol files, this simplifies the lexer */
s->type = MS_SYMBOL_TRUETYPE;
break;
default:
msSetError(MS_IDENTERR, "Parsing error near (%s):(line %d)", "loadSymbol()", msyystring_buffer, msyylineno);
return(-1);
} /* end switch */
} /* end for */
}
