#include "mapserver-config.h"

#ifdef USE_KML

#include "mapserver.h"

#include "maperror.h"

#include "mapkmlrenderer.h"

#include "mapio.h"

#include "mapows.h"

#include "cpl_conv.h"

#include "cpl_vsi.h"

#define KML_MAXFEATURES_TODRAW 1000

KmlRenderer::KmlRenderer(int width, int height, outputFormatObj * /*format*/,

}

KmlRenderer::~KmlRenderer() {

if (XmlDoc)

xmlFreeDoc(XmlDoc);

if (StyleHashTable)

msFreeHashTable(StyleHashTable);

if (LineStyle)

msFree(LineStyle);

xmlCleanupParser();

}

imageObj *KmlRenderer::createImage(int, int, outputFormatObj *, colorObj *) {

return NULL;

}

int KmlRenderer::saveImage(imageObj *, FILE *fp, outputFormatObj *format) {

}

void KmlRenderer::processLayer(layerObj *layer, outputFormatObj *format) {

}

char *KmlRenderer::getLayerName(layerObj *layer) {

char stmp[20];

const char *name = NULL;

;

if (!layer)

return NULL;

name = msLookupHashTable(&layer->metadata, "ows_name");

if (name && strlen(name) > 0)

return msStrdup(name);

if (layer->name && strlen(layer->name) > 0)

return msStrdup(layer->name);

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

return msStrdup(stmp);

}

const char *KmlRenderer::getAliasName(layerObj *lp, char *pszItemName,

const char *namespaces) {

const char *pszAlias = NULL;

if (lp && pszItemName && strlen(pszItemName) > 0) {

char szTmp[256];

snprintf(szTmp, sizeof(szTmp), "%s_alias", pszItemName);

pszAlias = msOWSLookupMetadata(&(lp->metadata), namespaces, szTmp);

}

return pszAlias;

}

int KmlRenderer::startNewLayer(imageObj *img, layerObj *layer) {

}

int KmlRenderer::closeNewLayer(imageObj *, layerObj *) {

}

int KmlRenderer::mergeRasterBuffer(imageObj *image, rasterBufferObj *rb) {

}

void KmlRenderer::setupRenderingParams(hashTableObj *layerMetadata) {

}

int KmlRenderer::checkProjection(mapObj *map) {

}

xmlNodePtr KmlRenderer::createPlacemarkNode(xmlNodePtr parentNode,

}

void KmlRenderer::renderLine(imageObj *, shapeObj *p, strokeStyleObj *style) {

}

void KmlRenderer::renderPolygon(imageObj *, shapeObj *p, colorObj *color) {

}

void KmlRenderer::addCoordsNode(xmlNodePtr parentNode, pointObj *pts,

}

void KmlRenderer::renderGlyphs(imageObj *, const textSymbolObj *ts,

}

void KmlRenderer::addAddRenderingSpecifications(xmlNodePtr node) {

}

imageObj *agg2CreateImage(int width, int height, outputFormatObj *format,

colorObj *bg);

int KmlRenderer::createIconImage(char *fileName, symbolObj *symbol,

}

void KmlRenderer::renderSymbol(imageObj *img, double x, double y,

}

void KmlRenderer::renderPixmapSymbol(imageObj *img, double x, double y,

symbolObj *symbol, symbolStyleObj *style) {

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

}

void KmlRenderer::renderVectorSymbol(imageObj *img, double x, double y,

symbolObj *symbol, symbolStyleObj *style) {

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

}

void KmlRenderer::renderEllipseSymbol(imageObj *img, double x, double y,

}

void KmlRenderer::renderTruetypeSymbol(imageObj *img, double x, double y,

}

xmlNodePtr KmlRenderer::createGroundOverlayNode(xmlNodePtr parentNode,

}

void KmlRenderer::startShape(imageObj *, shapeObj *shape) {

}

void KmlRenderer::endShape(imageObj *, shapeObj *) {

}

xmlNodePtr KmlRenderer::getGeomParentNode(const char *geomName) {

}

const char *KmlRenderer::lookupSymbolUrl(imageObj *img, symbolObj *symbol,

symbolStyleObj *symstyle) {

char symbolHexColor[32];

/*

sprintf(symbolHexColor, "%02x%02x%02x%02x", symstyle->style->color.alpha,

symstyle->style->color.blue, symstyle->style->color.green,

symstyle->style->color.red);

snprintf(SymbolName, sizeof(SymbolName), "symbol_%s_%.1f_%s", symbol->name,

symstyle->scale, symbolHexColor);

const char *symbolUrl = msLookupHashTable(StyleHashTable, SymbolName);

if (!symbolUrl) {

char iconFileName[MS_MAXPATHLEN];

char iconUrl[MS_MAXPATHLEN];

if (img->imagepath) {

char *tmpFileName = msTmpFile(NULL, MapPath, img->imagepath, "png");

snprintf(iconFileName, sizeof(iconFileName), "%s", tmpFileName);

msFree(tmpFileName);

} else {

sprintf(iconFileName, "symbol_%s_%.1f.%s", symbol->name, symstyle->scale,

"png");

}

if (createIconImage(iconFileName, symbol, symstyle) != MS_SUCCESS) {

msSetError(MS_IOERR, "Error creating icon file '%s'",

"KmlRenderer::lookupSymbolStyle()", iconFileName);

return NULL;

}

if (img->imageurl)

sprintf(iconUrl, "%s%s.%s", img->imageurl, msGetBasename(iconFileName),

"png");

else

snprintf(iconUrl, sizeof(iconUrl), "%s", iconFileName);

hashObj *hash = msInsertHashTable(StyleHashTable, SymbolName, iconUrl);

symbolUrl = hash->data;

}