: Width(width), Height(height), MapCellsize(1.0), XmlDoc(NULL), LayerNode(NULL), GroundOverlayNode(NULL),

PlacemarkNode(NULL), GeomNode(NULL),

Items(NULL), NumItems(0), FirstLayer(MS_TRUE), map(NULL), currentLayer(NULL),

mElevationFromAttribute( false ), mElevationAttributeIndex( -1 ), mCurrentElevationValue(0.0)

{

/*private variables*/

pszLayerDescMetadata = NULL;

papszLayerIncludeItems = NULL;

nIncludeItems=0;

papszLayerExcludeItems = NULL;

nExcludeItems=0;

pszLayerNameAttributeMetadata = NULL; /*metadata to use for a name for each feature*/

LineStyle = NULL;

numLineStyle = 0;

xmlNodePtr styleNode;

xmlNodePtr listStyleNode;

/* Create document.*/

XmlDoc = xmlNewDoc(BAD_CAST "1.0");

xmlNodePtr rootNode = xmlNewNode(NULL, BAD_CAST "kml");

/* Name spaces*/

xmlSetNs(rootNode, xmlNewNs(rootNode, BAD_CAST "http://www.opengis.net/kml/2.2", NULL));

xmlDocSetRootElement(XmlDoc, rootNode);

DocNode = xmlNewChild(rootNode, NULL, BAD_CAST "Document", NULL);

styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);

xmlNewProp(styleNode, BAD_CAST "id", BAD_CAST "LayerFolder_check");

listStyleNode = xmlNewChild(styleNode, NULL, BAD_CAST "ListStyle", NULL);

xmlNewChild(listStyleNode, NULL, BAD_CAST "listItemType", BAD_CAST "check");

styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);

xmlNewProp(styleNode, BAD_CAST "id", BAD_CAST "LayerFolder_checkHideChildren");

listStyleNode = xmlNewChild(styleNode, NULL, BAD_CAST "ListStyle", NULL);

xmlNewChild(listStyleNode, NULL, BAD_CAST "listItemType", BAD_CAST "checkHideChildren");

styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);

xmlNewProp(styleNode, BAD_CAST "id", BAD_CAST "LayerFolder_checkOffOnly");

listStyleNode = xmlNewChild(styleNode, NULL, BAD_CAST "ListStyle", NULL);

xmlNewChild(listStyleNode, NULL, BAD_CAST "listItemType", BAD_CAST "checkOffOnly");

styleNode = xmlNewChild(DocNode, NULL, BAD_CAST "Style", NULL);

xmlNewProp(styleNode, BAD_CAST "id", BAD_CAST "LayerFolder_radioFolder");

listStyleNode = xmlNewChild(styleNode, NULL, BAD_CAST "ListStyle", NULL);

xmlNewChild(listStyleNode, NULL, BAD_CAST "listItemType", BAD_CAST "radioFolder");

StyleHashTable = msCreateHashTable();

{

/* -------------------------------------------------------------------- */

/* Write out the document. */

/* -------------------------------------------------------------------- */

int bufSize = 0;

xmlChar *buf = NULL;

msIOContext *context = NULL;

int chunkSize = 4096;

int bZip = MS_FALSE;

if( msIO_needBinaryStdout() == MS_FAILURE )

return MS_FAILURE;

xmlDocDumpFormatMemoryEnc(XmlDoc, &buf, &bufSize, "UTF-8", 1);

if (format && format->driver && strcasecmp(format->driver, "kmz") == 0) {

bZip = MS_TRUE;

}

if (bZip) {

VSILFILE *fpZip;

int bytes_read;

char buffer[1024];

char *zip_filename =NULL;

void *hZip=NULL;

zip_filename = msTmpFile(NULL, NULL, "/vsimem/kmlzip/", "kmz" );

hZip = CPLCreateZip( zip_filename, NULL );

CPLCreateFileInZip( hZip, "mapserver.kml", NULL );

for (int i=0; i<bufSize; i+=chunkSize) {

int size = chunkSize;

if (i + size > bufSize)

size = bufSize - i;

CPLWriteFileInZip( hZip, buf+i, size);

}

CPLCloseFileInZip( hZip );

CPLCloseZip( hZip );

context = msIO_getHandler(fp);

fpZip = VSIFOpenL( zip_filename, "r" );

while( (bytes_read = VSIFReadL( buffer, 1, sizeof(buffer), fpZip )) > 0 ) {

if (context)

msIO_contextWrite(context, buffer, bytes_read);

else

msIO_fwrite( buffer, 1, bytes_read, fp );

}

VSIFCloseL( fpZip );

msFree( zip_filename);

xmlFree(buf);

return(MS_SUCCESS);

}

context = msIO_getHandler(fp);

for (int i=0; i<bufSize; i+=chunkSize) {

int size = chunkSize;

if (i + size > bufSize)

size = bufSize - i;

if (context)

msIO_contextWrite(context, buf+i, size);

else

msIO_fwrite(buf+i, 1, size, fp);

}

xmlFree(buf);

return(MS_SUCCESS);

{

int i;

const char *asRaster = NULL;

int nMaxFeatures = -1;

const char *pszTmp;

char szTmp[10];

if (!layer)

return;

/*turn of labelcache*/

layer->labelcache = MS_OFF;

/*if there are labels we want the coordinates to

for(i=0; i<layer->numclasses; i++)

if(layer->_class[i]->numlabels > 0) layer->_class[i]->labels[0]->position = MS_XY;

/*we do not want to draw multiple styles.

for(i=0; i<layer->numclasses; i++) {

while (layer->_class[i]->numstyles > 1)

msDeleteStyle(layer->_class[i], layer->_class[i]->numstyles-1);

}

/*if layer has a metadata KML_OUTPUTASRASTER set to true, add a processing directive

asRaster = msLookupHashTable(&layer->metadata, "kml_outputasraster");

if (!asRaster)

asRaster = msLookupHashTable(&(layer->map->web.metadata), "kml_outputasraster");

if (asRaster && (strcasecmp(asRaster, "true") == 0 ||

strcasecmp(asRaster, "yes") == 0))

msLayerAddProcessing(layer, "RENDERER=png24");

/*set a maxfeaturestodraw, if not already set*/

pszTmp = msLookupHashTable(&layer->metadata, "maxfeaturestodraw");

if (pszTmp)

nMaxFeatures = atoi(pszTmp);

else {

pszTmp = msLookupHashTable(&layer->map->web.metadata, "maxfeaturestodraw");

if (pszTmp)

nMaxFeatures = atoi(pszTmp);

}

if (nMaxFeatures < 0 && format)

nMaxFeatures = atoi(msGetOutputFormatOption( format, "maxfeaturestodraw", "-1"));

if (nMaxFeatures < 0 && format) {

snprintf(szTmp, sizeof(szTmp), "%d", KML_MAXFEATURES_TODRAW);

msSetOutputFormatOption( format, "maxfeaturestodraw", szTmp);

}

{

char *layerName=NULL;

const char *value=NULL;

LayerNode = xmlNewNode(NULL, BAD_CAST "Folder");

layerName = getLayerName(layer);

xmlNewChild(LayerNode, NULL, BAD_CAST "name", BAD_CAST layerName);

msFree(layerName);

const char *layerVisibility = layer->status != MS_OFF ? "1" : "0";

xmlNewChild(LayerNode, NULL, BAD_CAST "visibility", BAD_CAST layerVisibility);

const char *layerDsiplayFolder = msLookupHashTable(&(layer->metadata), "kml_folder_display");

if (layerDsiplayFolder == NULL)

layerDsiplayFolder = msLookupHashTable(&(layer->map->web.metadata), "kml_folder_display");

if (!layerDsiplayFolder || strlen(layerDsiplayFolder)<=0) {

xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_check");

}

else {

if (strcasecmp(layerDsiplayFolder, "checkHideChildren") == 0)

xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_checkHideChildren");

else if (strcasecmp(layerDsiplayFolder, "checkOffOnly") == 0)

xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_checkOffOnly");

else if (strcasecmp(layerDsiplayFolder, "radioFolder") == 0)

xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_radioFolder");

else

xmlNewChild(LayerNode, NULL, BAD_CAST "styleUrl", BAD_CAST "#LayerFolder_check");

}

/*Init few things on the first layer*/

if (FirstLayer) {

FirstLayer = MS_FALSE;

map = layer->map;

if (layer->map->mappath)

snprintf(MapPath, sizeof(MapPath), "%s", layer->map->mappath);

/*First rendered layer - check mapfile projection*/

checkProjection(layer->map);

/*check for image path and image url*/

if (layer->map->debug && (layer->map->web.imageurl == NULL || layer->map->web.imagepath == NULL))

msDebug("KmlRenderer::startNewLayer: imagepath and imageurl should be set in the web object\n");

/*map rect for ground overlay*/

MapExtent = layer->map->extent;

MapCellsize = layer->map->cellsize;

BgColor = layer->map->imagecolor;

xmlNewChild(DocNode, NULL, BAD_CAST "name", BAD_CAST layer->map->name);

aggFormat = msSelectOutputFormat( layer->map, "png24");

aggFormat->transparent = MS_TRUE;

}

currentLayer = layer;

if (!msLayerIsOpen(layer)) {

if (msLayerOpen(layer) != MS_SUCCESS) {

msSetError(MS_MISCERR, "msLayerOpen failed", "KmlRenderer::startNewLayer" );

return MS_FAILURE;

}

}

/*pre process the layer to set things that make sense for kml output*/

if (img)

processLayer(layer, img->format);

else

processLayer(layer, NULL);

if (msLookupHashTable(&layer->metadata, "kml_description"))

pszLayerDescMetadata = msLookupHashTable(&layer->metadata, "kml_description");

else if (msLookupHashTable(&layer->metadata, "ows_description"))

pszLayerDescMetadata = msLookupHashTable(&layer->metadata, "ows_description");

value=msLookupHashTable(&layer->metadata, "kml_include_items");

if (!value)

value=msLookupHashTable(&layer->metadata, "ows_include_items");

if (value)

papszLayerIncludeItems = msStringSplit(value, ',', &nIncludeItems);

value=msLookupHashTable(&layer->metadata, "kml_exclude_items");

if (!value)

value=msLookupHashTable(&layer->metadata, "ows_exclude_items");

if (value)

papszLayerExcludeItems = msStringSplit(value, ',', &nExcludeItems);

if (msLookupHashTable(&layer->metadata, "kml_name_item"))

pszLayerNameAttributeMetadata = msLookupHashTable(&layer->metadata, "kml_name_item");

/*get all attributes*/

if(msLayerWhichItems(layer, MS_TRUE, NULL) != MS_SUCCESS) {

return MS_FAILURE;

}

NumItems = layer->numitems;

if (NumItems) {

Items = (char **)msSmallCalloc(NumItems, sizeof(char *));

for (int i=0; i<NumItems; i++)

Items[i] = msStrdup(layer->items[i]);

}

const char* elevationAttribute = msLookupHashTable(&layer->metadata, "kml_elevation_attribute");

if( elevationAttribute ) {

mElevationFromAttribute = true;

for( int i = 0; i < layer->numitems; ++i ) {

if( strcasecmp( layer->items[i], elevationAttribute ) == 0 ) {

mElevationAttributeIndex = i;

}

}

}

setupRenderingParams(&layer->metadata);

return MS_SUCCESS;

{

flushPlacemark();

xmlAddChild(DocNode, LayerNode);

if(Items) {

msFreeCharArray(Items, NumItems);

Items = NULL;

NumItems = 0;

}

if (pszLayerDescMetadata)

pszLayerDescMetadata = NULL;

if (pszLayerNameAttributeMetadata)

pszLayerNameAttributeMetadata = NULL;

if (papszLayerIncludeItems && nIncludeItems>0)

msFreeCharArray(papszLayerIncludeItems, nIncludeItems);

papszLayerIncludeItems=NULL;

if (papszLayerExcludeItems && nExcludeItems>0)

msFreeCharArray(papszLayerExcludeItems, nExcludeItems);

papszLayerExcludeItems=NULL;

return MS_SUCCESS;

{

assert(rb && rb->type == MS_BUFFER_BYTE_RGBA);

char *tmpFileName = NULL;

char *tmpUrl = NULL;

FILE *tmpFile = NULL;

tmpFileName = msTmpFile(NULL, MapPath, image->imagepath, "png");

tmpFile = fopen(tmpFileName,"wb");

if (tmpFile) {

if (!aggFormat->vtable)

msInitializeRendererVTable(aggFormat);

msSaveRasterBuffer(map,rb,tmpFile,aggFormat);

tmpUrl = msStrdup( image->imageurl);

tmpUrl = msStringConcatenate(tmpUrl, (char *)(msGetBasename(tmpFileName)));

tmpUrl = msStringConcatenate(tmpUrl, ".png");

createGroundOverlayNode(LayerNode, tmpUrl, currentLayer);

msFree(tmpFileName);

msFree(tmpUrl);

fclose(tmpFile);

return MS_SUCCESS;

} else {

msSetError(MS_IOERR,"Failed to create file for kml overlay","KmlRenderer::mergeRasterBuffer()");

return MS_FAILURE;

}

{

AltitudeMode = 0;

Extrude = 0;

Tessellate = 0;

const char *altitudeModeVal = msLookupHashTable(layerMetadata, "kml_altitudeMode");

if (altitudeModeVal) {

if(strcasecmp(altitudeModeVal, "absolute") == 0)

AltitudeMode = absolute;

else if(strcasecmp(altitudeModeVal, "relativeToGround") == 0)

AltitudeMode = relativeToGround;

else if(strcasecmp(altitudeModeVal, "clampToGround") == 0)

AltitudeMode = clampToGround;

}

const char *extrudeVal = msLookupHashTable(layerMetadata, "kml_extrude");

if (altitudeModeVal) {

Extrude = atoi(extrudeVal);

}

const char *tessellateVal = msLookupHashTable(layerMetadata, "kml_tessellate");

if (tessellateVal) {

Tessellate = atoi(tessellateVal);

}

{

projectionObj *projection= &map->projection;

if (projection && projection->numargs > 0 && msProjIsGeographicCRS(projection)) {

return MS_SUCCESS;

} else {

char epsg_string[100];

rectObj sRect;

projectionObj out;

/* for layer the do not have any projection set, set them with the current map

if (projection && projection->numargs > 0) {

layerObj *lp = NULL;

int i =0;

char *pszMapProjectString = msGetProjectionString(projection);

if (pszMapProjectString) {

for(i=0; i<map->numlayers; i++) {

lp = GET_LAYER(map, i);

if (lp->projection.numargs == 0 && lp->transform == MS_TRUE) {

msFreeProjection(&lp->projection);

msLoadProjectionString(&lp->projection, pszMapProjectString);

}

}

msFree(pszMapProjectString);

}

}

strcpy(epsg_string, "epsg:4326" );

msInitProjection(&out);

msProjectionInheritContextFrom(&out, projection);

msLoadProjectionString(&out, epsg_string);

sRect = map->extent;

msProjectRect(projection, &out, &sRect);

msFreeProjectionExceptContext(projection);

msLoadProjectionString(projection, epsg_string);

/*change also units and extents*/

map->extent = sRect;

map->units = MS_DD;

if (map->debug)

msDebug("KmlRenderer::checkProjection: Mapfile projection set to epsg:4326\n");

return MS_SUCCESS;

}

{

xmlNodePtr placemarkNode = xmlNewChild(parentNode, NULL, BAD_CAST "Placemark", NULL);

/*always add a name. It will be replaced by a text value if available*/

char tmpid[100];

char *stmp=NULL, *layerName=NULL;

if (CurrentShapeName && strlen(CurrentShapeName)>0) {

xmlNewChild(placemarkNode, NULL, BAD_CAST "name", BAD_CAST CurrentShapeName);

} else {

sprintf(tmpid, ".%d", CurrentShapeIndex);

layerName = getLayerName(currentLayer);

stmp = msStringConcatenate(stmp, layerName);

stmp = msStringConcatenate(stmp, tmpid);

xmlNewChild(placemarkNode, NULL, BAD_CAST "name", BAD_CAST stmp);

}

msFree(layerName);

msFree(stmp);

if (styleUrl)

xmlNewChild(placemarkNode, NULL, BAD_CAST "styleUrl", BAD_CAST styleUrl);

return placemarkNode;

{

if (p->numlines == 0)

return;

if (PlacemarkNode == NULL)

PlacemarkNode = createPlacemarkNode(LayerNode, NULL);

if (!PlacemarkNode)

return;

addLineStyleToList(style);

SymbologyFlag[Line] = 1;

/*p->index > CurrentDrawnShapeIndexneed to be reviewd. Added since the hight

if (CurrentDrawnShapeIndex == -1 || p->index > CurrentDrawnShapeIndex) {

xmlNodePtr geomNode = getGeomParentNode("LineString");

addAddRenderingSpecifications(geomNode);

addCoordsNode(geomNode, p->line[0].point, p->line[0].numpoints);

/* more than one line => MultiGeometry*/

if (p->numlines > 1) {

geomNode = getGeomParentNode("LineString"); // returns MultiGeom Node

for (int i=1; i<p->numlines; i++) {

xmlNodePtr lineStringNode = xmlNewChild(geomNode, NULL, BAD_CAST "LineString", NULL);

addAddRenderingSpecifications(lineStringNode);

addCoordsNode(lineStringNode, p->line[i].point, p->line[i].numpoints);

}

}

CurrentDrawnShapeIndex = p->index;

}

{

if (PlacemarkNode == NULL)

PlacemarkNode = createPlacemarkNode(LayerNode, NULL);

if (!PlacemarkNode)

return;

memcpy(&PolygonColor, color, sizeof(colorObj));

SymbologyFlag[Polygon] = 1;

if (p->index != CurrentDrawnShapeIndex) {

xmlNodePtr geomParentNode = getGeomParentNode("Polygon");

for (int i=0; i<p->numlines; i++) {

xmlNodePtr bdryNode = NULL;

if (i==0) /* __TODO__ check ring order*/

bdryNode = xmlNewChild(geomParentNode, NULL, BAD_CAST "outerBoundaryIs", NULL);

else

bdryNode = xmlNewChild(geomParentNode, NULL, BAD_CAST "innerBoundaryIs", NULL);

xmlNodePtr ringNode = xmlNewChild(bdryNode, NULL, BAD_CAST "LinearRing", NULL);

addAddRenderingSpecifications(ringNode);

addCoordsNode(ringNode, p->line[i].point, p->line[i].numpoints);

}

CurrentDrawnShapeIndex = p->index;

}

{

char lineBuf[128];

xmlNodePtr coordsNode = xmlNewChild(parentNode, NULL, BAD_CAST "coordinates", NULL);

xmlNodeAddContent(coordsNode, BAD_CAST "\n");

for (int i=0; i<numPts; i++) {

if( mElevationFromAttribute ) {

sprintf(lineBuf, "\t%.8f,%.8f,%.8f\n", pts[i].x, pts[i].y, mCurrentElevationValue);

} else if (AltitudeMode == relativeToGround || AltitudeMode == absolute) {

sprintf(lineBuf, "\t%.8f,%.8f,%.8f\n", pts[i].x, pts[i].y, pts[i].z);

} else

sprintf(lineBuf, "\t%.8f,%.8f\n", pts[i].x, pts[i].y);

xmlNodeAddContent(coordsNode, BAD_CAST lineBuf);

}

xmlNodeAddContent(coordsNode, BAD_CAST "\t");

{

if( ts->annotext == NULL || ts->textpath->numglyphs == 0 )

return;

if (PlacemarkNode == NULL)

PlacemarkNode = createPlacemarkNode(LayerNode, NULL);

if (!PlacemarkNode)

return;

memcpy(&LabelColor, clr, sizeof(colorObj));

SymbologyFlag[Label] = 1;

/*there is alaws a default name (layer.shapeid). Replace it*/

for (xmlNodePtr node = PlacemarkNode->children; node; node = node->next) {

if (node->type != XML_ELEMENT_NODE)

continue;

if (strcmp((char *)node->name, "name") == 0) {

xmlNodeSetContent(node, BAD_CAST ts->annotext);

break;

}

}

/*xmlNewChild(PlacemarkNode, NULL, BAD_CAST "name", BAD_CAST text);*/

xmlNodePtr geomNode = getGeomParentNode("Point");

addAddRenderingSpecifications(geomNode);

pointObj pt;

pt.x = ts->textpath->glyphs[0].pnt.x;

pt.y = ts->textpath->glyphs[0].pnt.y;

pt.z = 0.0;

addCoordsNode(geomNode, &pt, 1);

{

/*

if (Extrude)

xmlNewChild(node, NULL, BAD_CAST "extrude", BAD_CAST "1");

if (Tessellate)

xmlNewChild(node, NULL, BAD_CAST "tessellate", BAD_CAST "1");

if (AltitudeMode == absolute)

xmlNewChild(node, NULL, BAD_CAST "altitudeMode", BAD_CAST "absolute");

else if (AltitudeMode == relativeToGround)

xmlNewChild(node, NULL, BAD_CAST "altitudeMode", BAD_CAST "relativeToGround");

else if (AltitudeMode == clampToGround)

xmlNewChild(node, NULL, BAD_CAST "altitudeMode", BAD_CAST "clampToGround");

{

pointObj p;

int status;

imageObj *tmpImg = NULL;

tmpImg = agg2CreateImage((int)(symbol->sizex*symstyle->scale),

(int)(symbol->sizey*symstyle->scale),

aggFormat, NULL);

tmpImg->format = aggFormat;

if (!aggFormat->vtable)

msInitializeRendererVTable(aggFormat);

p.x = symbol->sizex * symstyle->scale / 2;

p.y = symbol->sizey *symstyle->scale / 2;

p.z = 0.0;

status = msDrawMarkerSymbol(map,tmpImg, &p, symstyle->style, 1);

if( status != MS_SUCCESS )

return status;

return msSaveImage(map, tmpImg, fileName);

{

if (PlacemarkNode == NULL)

PlacemarkNode = createPlacemarkNode(LayerNode, NULL);

if (!PlacemarkNode)

return;

snprintf(SymbolUrl, sizeof(SymbolUrl), "%s", lookupSymbolUrl(img, symbol, style));

SymbologyFlag[Symbol] = 1;

xmlNodePtr geomNode = getGeomParentNode("Point");

addAddRenderingSpecifications(geomNode);

pointObj pt;

pt.x = x;

pt.y = y;

pt.z = 0.0;

addCoordsNode(geomNode, &pt, 1);

symbolStyleObj *style)

{

renderSymbol(img, x, y, symbol, style);

symbolStyleObj *style)

{

renderSymbol(img, x, y, symbol, style);

symbolStyleObj *style)

{

renderSymbol(img, x, y, symbol, style);

symbolStyleObj *style)

{

renderSymbol(img, x, y, symbol, style);

{

/*

char layerHexColor[32];

xmlNodePtr groundOverlayNode = xmlNewChild(parentNode, NULL, BAD_CAST "GroundOverlay", NULL);

char *layerName = getLayerName(layer);

xmlNewChild(groundOverlayNode, NULL, BAD_CAST "name", BAD_CAST layerName);

if (layer->compositer && layer->compositer->opacity > 0 && layer->compositer->opacity < 100) {

sprintf(layerHexColor, "%02xffffff", (unsigned int)MS_NINT(layer->compositer->opacity*2.55));

xmlNewChild(groundOverlayNode, NULL, BAD_CAST "color", BAD_CAST layerHexColor);

} else

xmlNewChild(groundOverlayNode, NULL, BAD_CAST "color", BAD_CAST "ffffffff");

char stmp[20];

sprintf(stmp, "%d",layer->index);

xmlNewChild(groundOverlayNode, NULL, BAD_CAST "drawOrder", BAD_CAST stmp);

if (imageHref) {

xmlNodePtr iconNode = xmlNewChild(groundOverlayNode, NULL, BAD_CAST "Icon", NULL);

xmlNewChild(iconNode, NULL, BAD_CAST "href", BAD_CAST imageHref);

}

char crdStr[64];

rectObj mapextent;

if (map->gt.need_geotransform == MS_TRUE)

mapextent = currentLayer->map->saved_extent;

else

mapextent = currentLayer->map->extent;

xmlNodePtr latLonBoxNode = xmlNewChild(groundOverlayNode, NULL, BAD_CAST "LatLonBox", NULL);

sprintf(crdStr, "%.8f", mapextent.maxy);

xmlNewChild(latLonBoxNode, NULL, BAD_CAST "north", BAD_CAST crdStr);

sprintf(crdStr, "%.8f", mapextent.miny);

xmlNewChild(latLonBoxNode, NULL, BAD_CAST "south", BAD_CAST crdStr);

sprintf(crdStr, "%.8f", mapextent.minx);

xmlNewChild(latLonBoxNode, NULL, BAD_CAST "west", BAD_CAST crdStr);

sprintf(crdStr, "%.8f", mapextent.maxx);

xmlNewChild(latLonBoxNode, NULL, BAD_CAST "east", BAD_CAST crdStr);

xmlNewChild(latLonBoxNode, NULL, BAD_CAST "rotation", BAD_CAST "0.0");

return groundOverlayNode;

{

if (PlacemarkNode)

flushPlacemark();

CurrentShapeIndex=-1;

CurrentDrawnShapeIndex = -1;

CurrentShapeName=NULL;

/*should be done at endshape but the plugin architecture does not call endshape yet*/

if(LineStyle) {

msFree(LineStyle);

LineStyle = NULL;

numLineStyle = 0;

}

CurrentShapeIndex = shape->index;

if (pszLayerNameAttributeMetadata) {

for (int i=0; i<currentLayer->numitems; i++) {

if (strcasecmp(currentLayer->items[i], pszLayerNameAttributeMetadata) == 0 && shape->values[i]) {

CurrentShapeName = msStrdup(shape->values[i]);

break;

}

}

}

PlacemarkNode = NULL;

GeomNode = NULL;

DescriptionNode = createDescriptionNode(shape);

if( mElevationFromAttribute && shape->numvalues > mElevationAttributeIndex &&

mElevationAttributeIndex >= 0 && shape->values[mElevationAttributeIndex]) {

mCurrentElevationValue = atof( shape->values[mElevationAttributeIndex] );

}

memset(SymbologyFlag, 0, NumSymbologyFlag);

{

CurrentShapeIndex = -1;

if (CurrentShapeName)

msFree(CurrentShapeName);

CurrentShapeName = NULL;

{

/*we do not need a multi-geometry for point layers*/

if (currentLayer->type != MS_LAYER_POINT && currentLayer->type != MS_LAYER_ANNOTATION && GeomNode) {

/*placemark geometry already defined, we need multigeometry node*/

xmlNodePtr multiGeomNode = xmlNewNode(NULL, BAD_CAST "MultiGeometry");

xmlAddChild(multiGeomNode, GeomNode);

GeomNode = multiGeomNode;

xmlNodePtr geomNode = xmlNewChild(multiGeomNode, NULL, BAD_CAST geomName, NULL);

return geomNode;

} else {

GeomNode = xmlNewNode(NULL, BAD_CAST geomName);

return GeomNode;

}