Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 15067) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 15068) @@ -664,58 +664,59 @@ ./modules/KMLOverlayx/KMLOverlayx.h\ ./modules/KMLOverlayx/KMLOverlayx.cpp\ - ./classes/KML/KML_Attribute.cpp\ - ./classes/KML/KML_Attribute.h\ - ./classes/KML/KML_Comment.cpp\ - ./classes/KML/KML_Comment.h\ - ./classes/KML/KML_ColorStyle.cpp\ - ./classes/KML/KML_ColorStyle.h\ - ./classes/KML/KML_Container.cpp\ - ./classes/KML/KML_Container.h\ - ./classes/KML/KML_Document.cpp\ - ./classes/KML/KML_Document.h\ - ./classes/KML/KML_Feature.cpp\ - ./classes/KML/KML_Feature.h\ - ./classes/KML/KML_File.cpp\ - ./classes/KML/KML_File.h\ - ./classes/KML/KML_Folder.cpp\ - ./classes/KML/KML_Folder.h\ - ./classes/KML/KML_Geometry.cpp\ - ./classes/KML/KML_Geometry.h\ - ./classes/KML/KML_GroundOverlay.cpp\ - ./classes/KML/KML_GroundOverlay.h\ - ./classes/KML/KML_Icon.cpp\ - ./classes/KML/KML_Icon.h\ - ./classes/KML/KML_LatLonBox.cpp\ - ./classes/KML/KML_LatLonBox.h\ - ./classes/KML/KML_LinearRing.cpp\ - ./classes/KML/KML_LinearRing.h\ - ./classes/KML/KML_LineString.cpp\ - ./classes/KML/KML_LineString.h\ - ./classes/KML/KML_LineStyle.cpp\ - ./classes/KML/KML_LineStyle.h\ - ./classes/KML/KML_MultiGeometry.cpp\ - ./classes/KML/KML_MultiGeometry.h\ - ./classes/KML/KML_Object.cpp\ - ./classes/KML/KML_Object.h\ - ./classes/KML/KML_Overlay.cpp\ - ./classes/KML/KML_Overlay.h\ - ./classes/KML/KML_Point.cpp\ - ./classes/KML/KML_Point.h\ - ./classes/KML/KML_Placemark.cpp\ - ./classes/KML/KML_Placemark.h\ - ./classes/KML/KML_Polygon.cpp\ - ./classes/KML/KML_Polygon.h\ - ./classes/KML/KML_PolyStyle.cpp\ - ./classes/KML/KML_PolyStyle.h\ - ./classes/KML/KML_Style.cpp\ - ./classes/KML/KML_Style.h\ - ./classes/KML/KML_StyleSelector.cpp\ - ./classes/KML/KML_StyleSelector.h\ - ./classes/KML/KML_SubStyle.cpp\ - ./classes/KML/KML_SubStyle.h\ - ./classes/KML/KML_Unknown.cpp\ - ./classes/KML/KML_Unknown.h\ - ./classes/KML/KMLFileReadUtils.cpp\ - ./classes/KML/KMLFileReadUtils.h + ./kml/kmlobjects.h\ + ./kml/KML_Attribute.cpp\ + ./kml/KML_Attribute.h\ + ./kml/KML_Comment.cpp\ + ./kml/KML_Comment.h\ + ./kml/KML_ColorStyle.cpp\ + ./kml/KML_ColorStyle.h\ + ./kml/KML_Container.cpp\ + ./kml/KML_Container.h\ + ./kml/KML_Document.cpp\ + ./kml/KML_Document.h\ + ./kml/KML_Feature.cpp\ + ./kml/KML_Feature.h\ + ./kml/KML_File.cpp\ + ./kml/KML_File.h\ + ./kml/KML_Folder.cpp\ + ./kml/KML_Folder.h\ + ./kml/KML_Geometry.cpp\ + ./kml/KML_Geometry.h\ + ./kml/KML_GroundOverlay.cpp\ + ./kml/KML_GroundOverlay.h\ + ./kml/KML_Icon.cpp\ + ./kml/KML_Icon.h\ + ./kml/KML_LatLonBox.cpp\ + ./kml/KML_LatLonBox.h\ + ./kml/KML_LinearRing.cpp\ + ./kml/KML_LinearRing.h\ + ./kml/KML_LineString.cpp\ + ./kml/KML_LineString.h\ + ./kml/KML_LineStyle.cpp\ + ./kml/KML_LineStyle.h\ + ./kml/KML_MultiGeometry.cpp\ + ./kml/KML_MultiGeometry.h\ + ./kml/KML_Object.cpp\ + ./kml/KML_Object.h\ + ./kml/KML_Overlay.cpp\ + ./kml/KML_Overlay.h\ + ./kml/KML_Point.cpp\ + ./kml/KML_Point.h\ + ./kml/KML_Placemark.cpp\ + ./kml/KML_Placemark.h\ + ./kml/KML_Polygon.cpp\ + ./kml/KML_Polygon.h\ + ./kml/KML_PolyStyle.cpp\ + ./kml/KML_PolyStyle.h\ + ./kml/KML_Style.cpp\ + ./kml/KML_Style.h\ + ./kml/KML_StyleSelector.cpp\ + ./kml/KML_StyleSelector.h\ + ./kml/KML_SubStyle.cpp\ + ./kml/KML_SubStyle.h\ + ./kml/KML_Unknown.cpp\ + ./kml/KML_Unknown.h\ + ./kml/KMLFileReadUtils.cpp\ + ./kml/KMLFileReadUtils.h #}}} #Petsc sources {{{ Index: /issm/trunk-jpl/src/c/classes/classes.h =================================================================== --- /issm/trunk-jpl/src/c/classes/classes.h (revision 15067) +++ /issm/trunk-jpl/src/c/classes/classes.h (revision 15068) @@ -46,32 +46,4 @@ #include "./Elements/TriaRef.h" -/*KML parsing objects: */ -#include "./KML/KML_Attribute.h" -#include "./KML/KML_Comment.h" -#include "./KML/KML_ColorStyle.h" -#include "./KML/KML_Container.h" -#include "./KML/KML_Document.h" -#include "./KML/KML_Feature.h" -#include "./KML/KML_File.h" -#include "./KML/KML_Folder.h" -#include "./KML/KML_Geometry.h" -#include "./KML/KML_GroundOverlay.h" -#include "./KML/KML_Icon.h" -#include "./KML/KML_LatLonBox.h" -#include "./KML/KML_LinearRing.h" -#include "./KML/KML_LineString.h" -#include "./KML/KML_LineStyle.h" -#include "./KML/KML_MultiGeometry.h" -#include "./KML/KML_Object.h" -#include "./KML/KML_Overlay.h" -#include "./KML/KML_Point.h" -#include "./KML/KML_Placemark.h" -#include "./KML/KML_Polygon.h" -#include "./KML/KML_PolyStyle.h" -#include "./KML/KML_Style.h" -#include "./KML/KML_StyleSelector.h" -#include "./KML/KML_SubStyle.h" -#include "./KML/KML_Unknown.h" -#include "./KML/KMLFileReadUtils.h" /*Option parsing objects: */ Index: /issm/trunk-jpl/src/c/datastructures/datastructures.h =================================================================== --- /issm/trunk-jpl/src/c/datastructures/datastructures.h (revision 15068) +++ /issm/trunk-jpl/src/c/datastructures/datastructures.h (revision 15068) @@ -0,0 +1,11 @@ +/* \file datastructures.h + * \brief: header file for all datastructures routines. + */ + +#ifndef _DATA_STRUCTURES_H_ +#define _DATA_STRUCTURES_H_ + +#include "./DataSet.h" +#include "./Object.h" + +#endif Index: /issm/trunk-jpl/src/c/kml/CMakeLists.txt =================================================================== --- /issm/trunk-jpl/src/c/kml/CMakeLists.txt (revision 15068) +++ /issm/trunk-jpl/src/c/kml/CMakeLists.txt (revision 15068) @@ -0,0 +1,34 @@ +# Subdirectories {{{ +# }}} +# Include Directory {{{ +include_directories(AFTER $ENV{ISSM_DIR}/src/c/classes/objects/KML) +# }}} +# KML_SOURCES {{{ +set(KML_SOURCES $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Attribute.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_ColorStyle.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Comment.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Container.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Document.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Feature.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_File.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Folder.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Geometry.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_GroundOverlay.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Icon.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_LatLonBox.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_LinearRing.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_LineString.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_LineStyle.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_MultiGeometry.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Object.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Overlay.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Placemark.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Point.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Polygon.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_PolyStyle.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Style.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_StyleSelector.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_SubStyle.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KML_Unknown.cpp + $ENV{ISSM_DIR}/src/c/classes/objects/KML/KMLFileReadUtils.cpp PARENT_SCOPE) +# }}} Index: /issm/trunk-jpl/src/c/kml/KMLFileReadUtils.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KMLFileReadUtils.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KMLFileReadUtils.cpp (revision 15068) @@ -0,0 +1,719 @@ +/*!\file KMLFileUtils.cpp + * \brief: utilities for kml file reading. + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "../kml/kmlobjects.h" +#include "../shared/shared.h" +/*}}}*/ + +/*FUNCTION KMLFileToken(FILE* fid,int* pncom=NULL,char*** ppcom=NULL) {{{*/ +char* KMLFileToken(FILE* fid, + int* pncom=NULL,char*** ppcom=NULL){ + +/* get the next token (tag or field) in the file */ + + bool inew=1,itag=0,ifield=0; + int c; + int ibuf=0,buflen=1024,bufblk=1024; + char *buffer=NULL,*bufferc=NULL,**pcom2=NULL; + + buffer=xNew(buflen); + buffer[0]='\0'; + +/* read kml file character-by-character */ + +// note that fgets includes newline +// fgets(buffer,buflen,fid); + + while ((c=getc(fid)) != EOF) { + /* ignore leading blanks */ + if (inew && isspace(c)) + continue; + + /* distinguish between tag or field */ + if (!itag && !ifield) { + + /* distinguish between tag or comment */ + if (c == '<') { + ungetc(c,fid); + if (!(bufferc=KMLFileTokenComment(fid))) { + c=getc(fid); + itag=1; + } + else { + if (pncom && ppcom) { + (*pncom)++; + pcom2=xNew(*pncom); + memcpy(pcom2,*ppcom,(*pncom-1)*sizeof(char*)); + xDelete(*ppcom); + *ppcom=pcom2; + pcom2=NULL; +// *ppcom=(char **) xrealloc(*ppcom,*pncom*sizeof(char*)); + (*ppcom)[*pncom-1]=bufferc; + } + else + xDelete(bufferc); + inew=1; + continue; + } + } + else + ifield=1; + inew=0; + KMLFileTokenBuffer(&buffer,&ibuf,&buflen, + c, + bufblk); + } + + /* accumulate tag, not including newlines */ + else if (itag) { + if (c != '\n') { + inew=0; + KMLFileTokenBuffer(&buffer,&ibuf,&buflen, + c, + bufblk); + if (c == '>') + break; + } + else + inew=1; + } + + /* accumulate field, including newlines */ + else if (ifield) { + /* distinguish between another tag or comment */ + if (c == '<') { + ungetc(c,fid); + if (!(bufferc=KMLFileTokenComment(fid))) + break; + else + if (pncom && ppcom) { + (*pncom)++; + pcom2=xNew(*pncom); + memcpy(pcom2,*ppcom,(*pncom-1)*sizeof(char*)); + xDelete(*ppcom); + *ppcom=pcom2; + pcom2=NULL; +// *ppcom=(char **) xrealloc(*ppcom,*pncom*sizeof(char*)); + (*ppcom)[*pncom-1]=bufferc; + } + else + xDelete(bufferc); + } + else { + inew=0; + KMLFileTokenBuffer(&buffer,&ibuf,&buflen, + c, + bufblk); + if (c == '\n') + inew=1; + } + } + + } + +/* remove trailing blanks or newline */ + + while (ibuf > 0) + if (isspace(buffer[ibuf-1])) + ibuf--; + else { + buffer[ibuf]='\0'; + break; + } + +// if (itag) +// _pprintLine_("tag buffer (length=" << ibuf << "):"); +// else if (ifield) +// _pprintLine_("field buffer (length=" << ibuf << "):"); +// _pprintLine_(buffer); + + if (!ibuf) + xDelete(buffer); + + return(buffer); +} +/*}}}*/ +/*FUNCTION KMLFileTokenComment(FILE* fid) {{{*/ +char* KMLFileTokenComment(FILE* fid){ + +/* check for comment in the file and read it */ + + bool inew=1; + int i; + int c; + int ibuf=0,buflen=1024,bufblk=1024; + char* buffer=NULL; + + buffer=xNew(buflen); + buffer[0]='\0'; + +/* read kml file character-by-character */ + + while ((c=getc(fid)) != EOF) { + /* ignore leading blanks */ + if (inew && isspace(c)) + continue; + + inew=0; + KMLFileTokenBuffer(&buffer,&ibuf,&buflen, + c, + bufblk); + + /* check for comment */ + if (ibuf <= 4) { + if ((ibuf == 1 && buffer[0] != '<') || + (ibuf == 2 && buffer[1] != '!') || + (ibuf == 3 && buffer[2] != '-') || + (ibuf == 4 && buffer[3] != '-')) { + for (i=ibuf-1; i>=0; i--) + ungetc(buffer[i],fid); + xDelete(buffer); + return(buffer); + } + } + + /* accumulate comment, including newlines */ + else + if (buffer[ibuf-3]=='-' && buffer[ibuf-2]=='-' && buffer[ibuf-1]=='>') + break; + } + +/* remove trailing blanks or newline */ + + while (ibuf > 0) + if (isspace(buffer[ibuf-1])) + ibuf--; + else { + buffer[ibuf]='\0'; + break; + } + +// _pprintLine_("comment buffer (length=" << ibuf << "):"); +// _pprintLine_(buffer); + + if (!ibuf) + xDelete(buffer); + + return(buffer); +} +/*}}}*/ +/*FUNCTION KMLFileTokenBuffer {{{*/ +void KMLFileTokenBuffer(char** pbuffer,int* pibuf,int* pbuflen, + int c, + int bufblk){ + +/* add the specified character to the token buffer */ + + char* buffer2=NULL; + +/* check buffer length and realloc if necessary */ + + if (*pibuf+2 > *pbuflen) { + *pbuflen+=bufblk; + buffer2=xNew(*pbuflen); + memcpy(buffer2,*pbuffer,(*pbuflen-bufblk)*sizeof(char)); + xDelete(*pbuffer); + *pbuffer=buffer2; + buffer2=NULL; +// *pbuffer=(char *) xrealloc(*pbuffer,*pbuflen*sizeof(char)); + } + +/* add character and terminator */ + + (*pbuffer)[(*pibuf)++]=c; + (*pbuffer)[ *pibuf ]='\0'; + + return; +} +/*}}}*/ +/*FUNCTION KMLFileTagName {{{*/ +char* KMLFileTagName(char* pname, + char* ktag){ + + return(KMLFileTagName(pname,NULL,0, + ktag)); +} +/*}}}*/ +/*FUNCTION KMLFileTagName {{{*/ +char* KMLFileTagName(char* pname,int *m,int maxlen, + char* ktag){ + +/* for the given tag buffer, read and store the name */ + + char* ktagi; + char* ktokn; + + if (strncmp(&ktag[0],"<" ,1) || strncmp(&ktag[strlen(ktag)-1],">",1)) + _error_("KMLFileTagName -- Missing tag delimiters in " << ktag << ".\n"); + +/* strtok modifies ktag, so work on copy */ + + ktagi=xNew(strlen(ktag)+1); + memcpy(ktagi,ktag,(strlen(ktag)+1)*sizeof(char)); + +/* skip opening delimeter and find subsequent blank or closing delimiter */ + + ktokn=strtok(ktagi,"< >"); +// _pprintLine_("KMLFileTagName -- initial token=\"" << ktokn << "\"."); + + if (!pname) { + if (maxlen) + pname=xNew(maxlen +1); + else + pname=xNew(strlen(ktokn)+1); + } + + if (maxlen && (maxlen < strlen(ktokn))) { + _pprintLine_("KMLFileTagName -- string field too short for " << ktag << "."); + _pprintLine_("KMLFileTagName -- \"" << ktokn << "\" truncated to " << maxlen << " characters."); + strncpy(pname,ktokn,maxlen); + } + else + memcpy(pname,ktokn,(strlen(ktokn)+1)*sizeof(char)); + + xDelete(ktagi); + + if (m) + *m=strlen(pname); + + return(pname); +} +/*}}}*/ +/*FUNCTION KMLFileTagAttrib {{{*/ +int KMLFileTagAttrib(KML_Object* kobj, + char* ktag){ + +/* for the given tag buffer, read and store the attributes */ + + char* ktagi; + char* ktokn; + char* ktokv; + char quote[]={'\"','\0'}; + int isolo=0; + +/* strtok modifies ktag, so work on copy */ + + ktagi=xNew(strlen(ktag)+1); + memcpy(ktagi,ktag,(strlen(ktag)+1)*sizeof(char)); + +/* loop through tag to find all attributes */ + + /* return first non blank and move past subsequent blank */ + ktokn=strtok(ktagi," "); +// _pprintLine_("KMLFileTagAttrib -- initial token=\"" << ktokn << "\"."); + + /* return next non " =?/>" and move past subsequent " =?/>" */ + while (ktokn=strtok(NULL," =?/>")) { + + /* return next non quote and move past subsequent quote */ + ktokv=strtok(NULL,quote); +// _pprintLine_("KMLFileTagAttrib -- attribute " << ktokn << "=\"" << ktokv << "\"."); + +/* add the attribute to the dataset */ + + if (kobj) + kobj->AddAttrib(ktokn,ktokv); + } + + xDelete(ktagi); + +/* check for xml declaration, dtd declaration, or solo tag */ + + if ((!strncmp(&ktag[0],"",2)) || + (!strncmp(&ktag[0],"",1)) || + (!strncmp(&ktag[0],"<" ,1) && !strncmp(&ktag[strlen(ktag)-2],"/>",2))) + isolo=1; +// _pprintLine_("KMLFileTagAttrib -- isolo=" << isolo << "."); + + return(isolo); +} +/*}}}*/ +/*FUNCTION KMLFileTokenParse {{{*/ +int KMLFileTokenParse(int* pival, + char* ktag, + FILE* fid){ + + char* kstr; + +/* get next token and convert to appropriate format */ + + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] == '<')) + _error_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n"); + + sscanf(kstr,"%d",pival); + xDelete(kstr); + +/* get additional token and compare to closing tag */ + + if (ktag) + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] != '<') || + (kstr[1] != '/') || + (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1))) + {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");} + else + xDelete(kstr); + +// _pprintLine_("KMLFileTokenParse -- " << ktag << "=" << *pival << "."); + + return(0); +} +/*}}}*/ +/*FUNCTION KMLFileTokenParse {{{*/ +int KMLFileTokenParse(bool* pbval, char* ktag, FILE* fid){ + + int ival; + char* kstr; + +/* get next token and convert to appropriate format */ + + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] == '<')) + {_error_("KMLFileTokenParse -- Missing bool field for " << ktag << ".\n");} + + sscanf(kstr,"%d",&ival); + *pbval=(bool)ival; + xDelete(kstr); + +/* get additional token and compare to closing tag */ + + if (ktag) + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] != '<') || + (kstr[1] != '/') || + (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1))) + {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");} + else + xDelete(kstr); + +// _pprintLine_("KMLFileTokenParse -- " << ktag << "=" << (*pbval ? "true" : "false") << "."); + + return(0); +} +/*}}}*/ +/*FUNCTION KMLFileTokenParse {{{*/ +char* KMLFileTokenParse(char* pstr, + char* ktag, + FILE* fid){ + + return(KMLFileTokenParse(pstr,NULL,0, + ktag, + fid)); +} +/*}}}*/ +/*FUNCTION KMLFileTokenParse {{{*/ +char* KMLFileTokenParse(char* pstr,int *m,int maxlen, + char* ktag, + FILE* fid){ + + char* kstr; + +/* get next token and allocate if necessary */ + + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] == '<')) + _error_("KMLFileTokenParse -- Missing string field for " << ktag << ".\n"); + + if (!pstr) { + if (maxlen) + pstr=xNew(maxlen +1); + else + pstr=xNew(strlen(kstr)+1); + } + + if (maxlen && (maxlen < strlen(kstr))) { + _pprintLine_("KMLFileTokenParse -- string field too short for " << ktag << "."); + _pprintLine_("KMLFileTokenParse -- \"" << kstr << "\" truncated to " << maxlen << " characters."); + strncpy(pstr,kstr,maxlen); + } + else + memcpy(pstr,kstr,(strlen(kstr)+1)*sizeof(char)); + + xDelete(kstr); + + if (m) + *m=strlen(pstr); + +/* get additional token and compare to closing tag */ + + if (ktag) + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] != '<') || + (kstr[1] != '/') || + (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1))) + {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");} + else + xDelete(kstr); + +// _pprintLine_("KMLFileTokenParse -- " << ktag << "=\"" << pstr << "\"."); + + return(pstr); +} +/*}}}*/ +/*FUNCTION KMLFileTokenParse {{{*/ +int KMLFileTokenParse(float* pfval, + char* ktag, + FILE* fid){ + + char* kstr; + +/* get next token and convert to appropriate format */ + + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] == '<')) + {_error_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n");} + + sscanf(kstr,"%g",pfval); + xDelete(kstr); + +/* get additional token and compare to closing tag */ + + if (ktag) + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] != '<') || + (kstr[1] != '/') || + (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1))) + {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");} + else + xDelete(kstr); + +// _pprintLine_("KMLFileTokenParse -- " << ktag << "=" << *pfval << "."); + + return(0); +} +/*}}}*/ +/*FUNCTION KMLFileTokenParse {{{*/ +int KMLFileTokenParse(double* pdval, + char* ktag, + FILE* fid){ + + char* kstr; + +/* get next token and convert to appropriate format */ + + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] == '<')) + _error_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n"); + + sscanf(kstr,"%lg",pdval); + xDelete(kstr); + +/* get additional token and compare to closing tag */ + + if (ktag) + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] != '<') || + (kstr[1] != '/') || + (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1))) + {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");} + else + xDelete(kstr); + +// _pprintLine_("KMLFileTokenParse -- " << ktag << "=" << *pdval << "."); + + return(0); +} +/*}}}*/ +/*FUNCTION KMLFileTokenParse {{{*/ +int KMLFileTokenParse(double **pdval,int* m,int maxlen, + char* ktag, + FILE* fid){ + + int i=-1; + char* kstr; + char* ktok; + double* dval2=NULL; + char delim[]={' ',',','\f','\n','\r','\t','\v','\0'}; + +/* get next token and allocate if necessary */ + + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] == '<')) + _error_("KMLFileTokenParse -- Missing double [m] field for " << ktag << ".\n"); + + if (!*pdval) + if (maxlen) + *pdval=xNew(maxlen ); + else + *pdval=xNew((strlen(kstr)+1)/2); + +/* loop through string to get all values */ + + ktok=strtok(kstr,delim); + while (ktok) { + i++; + if (maxlen && (maxlen < i+1)) + _error_("KMLFileTokenParse -- Double [m] field too short for " << ktag << ".\n"); + sscanf(ktok,"%lg",&((*pdval)[i])); + ktok=strtok(NULL,delim); + } + xDelete(kstr); + + if (!maxlen) + dval2=xNew(i+1); + memcpy(dval2,*pdval,(i+1)*sizeof(double)); + xDelete(*pdval); + *pdval=dval2; + dval2=NULL; +// *pdval=(double *) xrealloc(*pdval,(i+1)*sizeof(double)); + + if (m) + *m=i+1; + +/* get additional token and compare to closing tag */ + + if (ktag) + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] != '<') || + (kstr[1] != '/') || + (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1))) + {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");} + else + xDelete(kstr); + +// _pprintLine_("KMLFileTokenParse -- " << ktag << "=..."); +// for (j=0; j<=i; j++) +// _pprintLine_(" [" << j << "]: " << (*pdval)[j] << "g"); + + return(0); +} +/*}}}*/ +/*FUNCTION KMLFileTokenParse {{{*/ +int KMLFileTokenParse(double **pdval,int* m,int n,int maxlen, + char* ktag, + FILE* fid){ + + int i=-1,j=-1; + char* kstr; + char* ktok; + double* dval2=NULL; + char delim[]={' ',',','\f','\n','\r','\t','\v','\0'}; + +/* get next token and allocate if necessary */ + + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] == '<')) + _error_("KMLFileTokenParse -- Missing double [m x n] field for " << ktag << ".\n"); + + if (!*pdval) + if (maxlen) + *pdval=xNew(maxlen*n ); + else + *pdval=xNew((strlen(kstr)+1)/2); + +/* loop through string to get all values */ + + ktok=strtok(kstr,delim); + while (ktok) { + i++; + if (maxlen && (maxlen*n < i+1)) + _error_("KMLFileTokenParse -- Double [m x n] field too short for " << ktag << ".\n"); + j=(j+1) % n; + sscanf(ktok,"%lg",&((*pdval)[i])); + ktok=strtok(NULL,delim); + } + xDelete(kstr); + + if (!maxlen) + dval2=xNew((i+1)*n); + memcpy(dval2,*pdval,((i+1)*n)*sizeof(double)); + xDelete(*pdval); + *pdval=dval2; + dval2=NULL; +// *pdval=(double *) xrealloc(*pdval,((i+1)*n)*sizeof(double)); + + if (m) + *m=((i+1)+(n-1))/n; + + if ((i+1) % n) + _pprintLine_("KMLFileTokenParse -- Double [m x n] field for " << ktag << " does not have multiple of n values."); + +/* get additional token and compare to closing tag */ + + if (ktag) + if (!(kstr=KMLFileToken(fid, + NULL,NULL)) || + (kstr[0] != '<') || + (kstr[1] != '/') || + (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1))) + {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");} + else + xDelete(kstr); + +// _pprintLine_("KMLFileTokenParse -- " << ktag << "=..."); +// for (j=0; j<=i; j++) +// _pprintLine_(" [" << j << "]: " << (*pdval)[j] << "g"); + + return(0); +} +/*}}}*/ +/*FUNCTION KMLFileTagSkip {{{*/ +int KMLFileTagSkip(char* ktag, + FILE* fid){ + + char* kstr; + +/* note that tags of the same type can be nested inside each other, so for each + opening tag, must find corresponding closing tag */ + + _pprintLine_("KMLFileTagSkip -- input tag " << ktag << "."); + +/* if next token is a closing tag, compare to input */ + + while (kstr=KMLFileToken(fid, + NULL,NULL)) { + if ((kstr[0] == '<') && + (kstr[1] == '/') && + (!strncmp(&(kstr[2]),&(ktag[1]),(strcspn(ktag," >")-1)/sizeof(char)))) { + _pprintLine_("KMLFileTagSkip -- closing tag " << kstr << "."); + xDelete(kstr); + return(0); + } + +/* if next token is an opening tag, call recursively */ + + else if ((kstr[0] == '<') && + (kstr[1] != '/')) { + _pprintLine_("KMLFileTagSkip -- opening tag " << kstr << "."); + KMLFileTagSkip(kstr, + fid); + } + +/* if next token is a closing tag, error out */ + + else if ((kstr[0] == '<') && + (kstr[1] == '/')) { + _error_("KMLFileTagSkip -- Unexpected closing tag " << kstr << ".\n"); + } + + xDelete(kstr); + } + + _error_("KMLFileTokenParse -- Corresponding closing tag for " << ktag << " not found.\n"); + + return(0); +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KMLFileReadUtils.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KMLFileReadUtils.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KMLFileReadUtils.h (revision 15068) @@ -0,0 +1,31 @@ +/*!\file: KMLFileReadUtils.h + * \brief: header file for kml file reading utilities. + */ + +#ifndef _KMLFILEREADUTILS_H +#define _KMLFILEREADUTILS_H + +/*Headers:{{{*/ +#include "../shared/shared.h" +#include "../datastructures/datastructures.h" +class KML_Object; +/*}}}*/ + +/* local prototypes: */ +char* KMLFileToken(FILE* fid, int* pncom,char*** ppcom); +char* KMLFileTokenComment(FILE* fid); +void KMLFileTokenBuffer(char** pbuffer,int* pibuf,int* pbuflen, int c, int bufblk); +char* KMLFileTagName(char* pname, char* ktag); +char* KMLFileTagName(char* pname,int *m,int maxlen, char* ktag); +int KMLFileTagAttrib(KML_Object* kobj, char* ktag); +int KMLFileTokenParse(int* pival, char* ktag, FILE* fid); +int KMLFileTokenParse(bool* pbval, char* ktag, FILE* fid); +char* KMLFileTokenParse(char* pstr, char* ktag, FILE* fid); +char* KMLFileTokenParse(char* pstr,int *m,int maxlen, char* ktag, FILE* fid); +int KMLFileTokenParse(float* pfval, char* ktag, FILE* fid); +int KMLFileTokenParse(double* pdval, char* ktag, FILE* fid); +int KMLFileTokenParse(double **pdval,int* m,int maxlen, char* ktag, FILE* fid); +int KMLFileTokenParse(double **pdval,int* m,int n,int maxlen, char* ktag, FILE* fid); +int KMLFileTagSkip(char* ktag, FILE* fid); + +#endif /* _KMLFILEREADUTILS_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Attribute.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Attribute.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Attribute.cpp (revision 15068) @@ -0,0 +1,128 @@ +/*!\file KML_Attribute.cpp + * \brief: implementation of the kml_attribute object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Attribute.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Attribute::KML_Attribute(){{{*/ +KML_Attribute::KML_Attribute(){ + + name =NULL; + value =NULL; + +} +/*}}}*/ +/*FUNCTION KML_Attribute::~KML_Attribute(){{{*/ +KML_Attribute::~KML_Attribute(){ + + if (name ) xDelete(name); + if (value ) xDelete(value); + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Attribute::Echo {{{*/ +void KML_Attribute::Echo(){ + + int i; + bool flag=true; + + if(flag) _pprintString_(" "); + for (i=0;i<10-strlen(name);i++) + if(flag) _pprintString_(" "); + if(flag) _pprintLine_(name << ": \"" << value << "\""); + + return; +} +/*}}}*/ +/*FUNCTION KML_Attribute::DeepEcho {{{*/ +void KML_Attribute::DeepEcho(){ + + char indent[81]=""; + + KML_Attribute::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Attribute::DeepEcho {{{*/ +void KML_Attribute::DeepEcho(const char* indent){ + + int i; + bool flag=true; + + if(flag) _pprintString_(indent << " "); + for (i=0;i<10-strlen(name);i++) + if(flag) _pprintString_(" "); + if(flag) _pprintLine_(name << ": \"" << value << "\""); + + return; +} +/*}}}*/ +/*FUNCTION KML_Attribute::Write {{{*/ +void KML_Attribute::Write(FILE* filout,const char* indent){ + +// attributes always written in keyword line of kml_object + + fprintf(filout,"%s%s=\"%s\"",indent,name,value); + + return; +} +/*}}}*/ +/*FUNCTION KML_Attribute::Read {{{*/ +void KML_Attribute::Read(FILE* fid,char* kstr){ + +// attributes always read in keyword line of kml_object + + ; + + return; +} +/*}}}*/ +/*FUNCTION KML_Attribute::Alloc {{{*/ +void KML_Attribute::Alloc(const char* namei,const char* valuei){ + + name =xNew(strlen(namei )+1); + memcpy(name,namei,(strlen(namei)+1)*sizeof(char)); + + value=xNew(strlen(valuei)+1); + memcpy(value,valuei,(strlen(valuei)+1)*sizeof(char)); + + return; +} +/*}}}*/ +/*FUNCTION KML_Attribute::Add {{{*/ +void KML_Attribute::Add(DataSet* attrib){ + + attrib->AddObject((Object*)this); + + return; +} +/*}}}*/ +/*FUNCTION KML_Attribute::Get {{{*/ +void KML_Attribute::Get(char** pvalueo,char* deflt){ + + if (!value || !strlen(value)) { + *pvalueo=xNew(strlen(deflt)+1); + memcpy(*pvalueo,deflt,(strlen(deflt)+1)*sizeof(char)); + } + else { + *pvalueo=xNew(strlen(value)+1); + memcpy(*pvalueo,value,(strlen(value)+1)*sizeof(char)); + } + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Attribute.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Attribute.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Attribute.h (revision 15068) @@ -0,0 +1,41 @@ +/*! \file KML_Attribute.h + * \brief: header file for kml_attribute object + */ + +#ifndef _KML_ATTRIBUTE_H_ +#define _KML_ATTRIBUTE_H_ + +/*Headers:{{{*/ +#include "../shared/shared.h" +#include "../datastructures/datastructures.h" +/*}}}*/ + +class KML_Attribute: public Object { + + public: + + char* name; + char* value; + + /*KML_Attribute constructors, destructors {{{*/ + KML_Attribute(); + ~KML_Attribute(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + virtual void Echo(); + virtual void DeepEcho(); + virtual void DeepEcho(const char* indent); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + + /*virtual functions: */ + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void Alloc(const char* namei,const char* valuei); + void Add(DataSet* attrib); + void Get(char** pvalueo,char* deflt); + +}; +#endif /* _KML_ATTRIBUTE_H */ Index: /issm/trunk-jpl/src/c/kml/KML_ColorStyle.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_ColorStyle.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_ColorStyle.cpp (revision 15068) @@ -0,0 +1,106 @@ +/*!\file KML_ColorStyle.cpp + * \brief: implementation of the kml_colorstyle abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_ColorStyle.h" +#include "./KML_SubStyle.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_ColorStyle::KML_ColorStyle(){{{*/ +KML_ColorStyle::KML_ColorStyle(){ + + strcpy(color ,"ffffffff"); + strcpy(colormode ,"normal"); + +} +/*}}}*/ +/*FUNCTION KML_ColorStyle::~KML_ColorStyle(){{{*/ +KML_ColorStyle::~KML_ColorStyle(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_ColorStyle::Echo {{{*/ +void KML_ColorStyle::Echo(){ + + bool flag=true; + + KML_SubStyle::Echo(); + + if(flag) _pprintLine_(" color: " << color); + if(flag) _pprintLine_(" colormode: " << colormode); + + return; +} +/*}}}*/ +/*FUNCTION KML_ColorStyle::DeepEcho {{{*/ +void KML_ColorStyle::DeepEcho(){ + + char indent[81]=""; + + KML_ColorStyle::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_ColorStyle::DeepEcho {{{*/ +void KML_ColorStyle::DeepEcho(const char* indent){ + + bool flag=true; + + KML_SubStyle::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " color: " << color); + if(flag) _pprintLine_(indent << " colormode: " << colormode); +} +/*}}}*/ +/*FUNCTION KML_ColorStyle::Write {{{*/ +void KML_ColorStyle::Write(FILE* filout,const char* indent){ + + KML_SubStyle::Write(filout,indent); + + if (color && strlen(color)) + fprintf(filout,"%s %s\n",indent,color); + if (colormode && strlen(colormode)) + fprintf(filout,"%s %s\n",indent,colormode); + + return; +} +/*}}}*/ +/*FUNCTION KML_ColorStyle::Read {{{*/ +void KML_ColorStyle::Read(FILE* fid,char* kstr){ + +/* process field within opening and closing tags */ + + if (!strncmp(kstr,"")) + KMLFileTokenParse( color ,NULL,KML_COLORSTYLE_COLOR_LENGTH, kstr, fid); + else if (!strcmp(kstr,"")) + KMLFileTokenParse( colormode ,NULL,KML_COLORSTYLE_COLORMODE_LENGTH, kstr, fid); + + else if (!strncmp(kstr,"<",1)) + KML_SubStyle::Read(fid,kstr); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_ColorStyle.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_ColorStyle.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_ColorStyle.h (revision 15068) @@ -0,0 +1,41 @@ +/*! \file KML_ColorStyle.h + * \brief: header file for kml_colorstyle abstract object + */ + +#ifndef _KML_COLORSTYLE_H_ +#define _KML_COLORSTYLE_H_ + +#define KML_COLORSTYLE_COLOR_LENGTH 8 +#define KML_COLORSTYLE_COLORMODE_LENGTH 6 + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_SubStyle.h" +/*}}}*/ + +class KML_ColorStyle: public KML_SubStyle { + + public: + + char color[KML_COLORSTYLE_COLOR_LENGTH+1]; + char colormode[KML_COLORSTYLE_COLORMODE_LENGTH+1]; + + /*KML_ColorStyle constructors, destructors {{{*/ + KML_ColorStyle(); + ~KML_ColorStyle(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + void Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_COLORSTYLE_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Comment.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Comment.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Comment.cpp (revision 15068) @@ -0,0 +1,113 @@ +/*!\file KML_Comment.cpp + * \brief: implementation of the kml_comment object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Comment.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Comment::KML_Comment(){{{*/ +KML_Comment::KML_Comment(){ + + value =NULL; + +} +/*}}}*/ +/*FUNCTION KML_Comment::~KML_Comment(){{{*/ +KML_Comment::~KML_Comment(){ + + if (value ) xDelete(value); + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Comment::Echo {{{*/ +void KML_Comment::Echo(){ + + bool flag=true; + + if(flag) _pprintString_(" "); + if(flag) _pprintLine_(value); + + return; +} +/*}}}*/ +/*FUNCTION KML_Comment::DeepEcho {{{*/ +void KML_Comment::DeepEcho(){ + + char indent[81]=""; + + KML_Comment::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Comment::DeepEcho {{{*/ +void KML_Comment::DeepEcho(const char* indent){ + + bool flag=true; + + if(flag) _pprintString_(indent << " "); + if(flag) _pprintLine_(value); + + return; +} +/*}}}*/ +/*FUNCTION KML_Comment::Write {{{*/ +void KML_Comment::Write(FILE* filout,const char* indent){ + + if (strncmp(&value[0] ,"" ,3)) + fprintf(filout,"%s-->\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Comment::Read {{{*/ +void KML_Comment::Read(FILE* fid,char* kstr){ + +// comments always read as part of KMLFileToken + + ; + + return; +} +/*}}}*/ +/*FUNCTION KML_Comment::Alloc {{{*/ +void KML_Comment::Alloc(const char* valuei){ + + value=xNew(strlen(valuei)+1); + memcpy(value,valuei,(strlen(valuei)+1)*sizeof(char)); + + return; +} +/*}}}*/ +/*FUNCTION KML_Comment::Add {{{*/ +void KML_Comment::Add(DataSet* commnt){ + + commnt->AddObject((Object*)this); + + return; +} +/*}}}*/ +/*FUNCTION KML_Comment::Get {{{*/ +void KML_Comment::Get(char** pvalueo){ + + *pvalueo=xNew(strlen(value)+1); + memcpy(*pvalueo,value,(strlen(value)+1)*sizeof(char)); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Comment.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Comment.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Comment.h (revision 15068) @@ -0,0 +1,42 @@ +/*! \file KML_Comment.h + * \brief: header file for kml_comment object + */ + +#ifndef _KML_COMMENT_H_ +#define _KML_COMMENT_H_ + +/*Headers:{{{*/ +#include "../shared/shared.h" +#include "../datastructures/datastructures.h" +class DataSet; +/*}}}*/ + +class KML_Comment: public Object { + + public: + + char* name; + char* value; + + /*KML_Comment constructors, destructors {{{*/ + KML_Comment(); + ~KML_Comment(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + virtual void Echo(); + virtual void DeepEcho(); + virtual void DeepEcho(const char* indent); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + + /*virtual functions: */ + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void Alloc(const char* valuei); + void Add(DataSet* commnt); + void Get(char** pvalueo); + +}; +#endif /* _KML_COMMENT_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Container.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Container.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Container.cpp (revision 15068) @@ -0,0 +1,168 @@ +/*!\file KML_Container.cpp + * \brief: implementation of the kml_container abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Placemark.h" +#include "./KML_Document.h" +#include "./KML_GroundOverlay.h" +#include "./KML_Folder.h" +#include "./KML_Object.h" +#include "./KML_Container.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Container::KML_Container(){{{*/ +KML_Container::KML_Container(){ + + feature =new DataSet; + +} +/*}}}*/ +/*FUNCTION KML_Container::~KML_Container(){{{*/ +KML_Container::~KML_Container(){ + + if (feature) { + delete feature; + feature =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Container::Echo {{{*/ +void KML_Container::Echo(){ + + bool flag=true; + + KML_Feature::Echo(); + + if(flag) _pprintLine_(" feature: (size=" << feature->Size() << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Container::DeepEcho {{{*/ +void KML_Container::DeepEcho(){ + + char indent[81]=""; + + KML_Container::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Container::DeepEcho {{{*/ +void KML_Container::DeepEcho(const char* indent){ + + int i; + char indent2[81]; + bool flag=true; + + KML_Feature::DeepEcho(indent); + +/* loop over the features for the container */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + if (feature->Size()) + for (i=0; iSize(); i++) { + if(flag) _pprintLine_(indent << " feature: -------- begin [" << i << "] --------"); + ((KML_Feature *)feature->GetObjectByOffset(i))->DeepEcho(indent2); + if(flag) _pprintLine_(indent << " feature: -------- end [" << i << "] --------"); + } + else + if(flag) _pprintLine_(indent << " feature: [empty]"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Container::Write {{{*/ +void KML_Container::Write(FILE* filout,const char* indent){ + + int i; + char indent2[81]; + + KML_Feature::Write(filout,indent); + +/* loop over the features for the container */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + + strcat(indent2," "); + + for (i=0; iSize(); i++) + ((KML_Feature *)feature->GetObjectByOffset(i))->Write(filout,indent2); + + return; +} +/*}}}*/ +/*FUNCTION KML_Container::Read {{{*/ +void KML_Container::Read(FILE* fid,char* kstr){ + + KML_Object* kobj; + +/* process field within opening and closing tags */ + + if (!strncmp(kstr,"(kstr); + return; + } + else if (!strncmp(kstr,"Read(fid,kstr); + feature ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + feature ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + feature ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + feature ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"<",1)) + KML_Feature::Read(fid,kstr); + + return; +} +/*}}}*/ +/*FUNCTION KML_Container::WriteExp {{{*/ +void KML_Container::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + int i; + +/* loop over the features for the container */ + + for (i=0; iSize(); i++) + ((KML_Object *)feature->GetObjectByOffset(i))->WriteExp(fid,nstr,sgn,cm,sp); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Container.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Container.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Container.h (revision 15068) @@ -0,0 +1,38 @@ +/*! \file KML_Container.h + * \brief: header file for kml_container abstract object + */ + +#ifndef _KML_CONTAINER_H_ +#define _KML_CONTAINER_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Feature.h" +class DataSet; +/*}}}*/ + +class KML_Container: public KML_Feature { + + public: + + DataSet* feature; + + /*KML_Container constructors, destructors {{{*/ + KML_Container(); + ~KML_Container(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_CONTAINER_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Document.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Document.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Document.cpp (revision 15068) @@ -0,0 +1,122 @@ +/*!\file KML_Document.cpp + * \brief: implementation of the kml_document object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Document.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Document::KML_Document(){{{*/ +KML_Document::KML_Document(){ + + ; + +} +/*}}}*/ +/*FUNCTION KML_Document::~KML_Document(){{{*/ +KML_Document::~KML_Document(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Document::Echo {{{*/ +void KML_Document::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Document:"); + KML_Container::Echo(); + + return; +} +/*}}}*/ +/*FUNCTION KML_Document::DeepEcho {{{*/ +void KML_Document::DeepEcho(){ + + char indent[81]=""; + + KML_Document::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Document::DeepEcho {{{*/ +void KML_Document::DeepEcho(const char* indent){ + + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Document:"); + KML_Container::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Document::Write {{{*/ +void KML_Document::Write(FILE* filout,const char* indent){ + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Container::Write(filout,indent); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Document::Read {{{*/ +void KML_Document::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Document.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Document.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Document.h (revision 15068) @@ -0,0 +1,35 @@ +/*! \file KML_Document.h + * \brief: header file for kml_document object + */ + +#ifndef _KML_DOCUMENT_H_ +#define _KML_DOCUMENT_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Container.h" +class KML_Feature; +/*}}}*/ + +class KML_Document: public KML_Container { + + public: + + /*KML_Document constructors, destructors {{{*/ + KML_Document(); + ~KML_Document(); + /*}}}*/ + /*Object virtual functions definitions:{{{ */ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_DOCUMENT_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Feature.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Feature.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Feature.cpp (revision 15068) @@ -0,0 +1,185 @@ +/*!\file KML_Feature.cpp + * \brief: implementation of the kml_feature abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "../shared/shared.h" +/*}}}*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Feature.h" +#include "./KML_Style.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Feature::KML_Feature(){{{*/ +KML_Feature::KML_Feature(){ + + memcpy(name,"",(strlen("")+1)*sizeof(char)); + + visibility=true; + open =false; + memcpy(snippet,"",(strlen("")+1)*sizeof(char)); + memcpy(descript,"",(strlen("")+1)*sizeof(char)); + memcpy(styleurl,"",(strlen("")+1)*sizeof(char)); + style =new DataSet; + +} +/*}}}*/ +/*FUNCTION KML_Feature::~KML_Feature(){{{*/ +KML_Feature::~KML_Feature(){ + + if (style) { + delete style; + style =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Feature::Echo {{{*/ +void KML_Feature::Echo(){ + + bool flag=true; + + KML_Object::Echo(); + + if(flag) _pprintLine_(" name: \"" << name << "\""); + if(flag) _pprintLine_(" visibility: " << (visibility ? "true" : "false")); + if(flag) _pprintLine_(" open: " << (open ? "true" : "false")); + if(flag) _pprintLine_(" snippet: \"" << snippet << "\""); + if(flag) _pprintLine_(" descript: \"" << descript << "\""); + if(flag) _pprintLine_(" styleurl: \"" << styleurl << "\""); + if(flag) _pprintLine_(" style: (size=" << style->Size() << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Feature::DeepEcho {{{*/ +void KML_Feature::DeepEcho(){ + + char indent[81]=""; + + KML_Feature::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Feature::DeepEcho {{{*/ +void KML_Feature::DeepEcho(const char* indent){ + + int i; + char indent2[81]; + bool flag=true; + + KML_Object::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " name: \"" << name << "\""); + if(flag) _pprintLine_(indent << " visibility: " << (visibility ? "true" : "false")); + if(flag) _pprintLine_(indent << " open: " << (open ? "true" : "false")); + if(flag) _pprintLine_(indent << " snippet: \"" << snippet << "\""); + if(flag) _pprintLine_(indent << " descript: \"" << descript << "\""); + if(flag) _pprintLine_(indent << " styleurl: \"" << styleurl << "\""); + +/* loop over any styles for the feature */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + if (style->Size()) + for (i=0; iSize(); i++) { + if(flag) _pprintLine_(indent << " style: -------- begin [" << i << "] --------"); + ((KML_Style *)style->GetObjectByOffset(i))->DeepEcho(indent2); + if(flag) _pprintLine_(indent << " style: -------- end [" << i << "] --------"); + } + else + if(flag) _pprintLine_(indent << " style: [empty]"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Feature::Write {{{*/ +void KML_Feature::Write(FILE* filout,const char* indent){ + + int i; + char indent2[81]; + + KML_Object::Write(filout,indent); + + if (name && strlen(name)) + fprintf(filout,"%s %s\n",indent,name); + fprintf(filout,"%s %d\n",indent,(visibility ? 1 : 0)); + fprintf(filout,"%s %d\n",indent,(open ? 1 : 0)); + if (snippet && strlen(snippet)) + fprintf(filout,"%s %s\n",indent,snippet); + if (descript && strlen(descript)) + fprintf(filout,"%s %s\n",indent,descript); + if (styleurl && strlen(styleurl)) + fprintf(filout,"%s %s\n",indent,styleurl); + +/* loop over any styles for the feature */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + + strcat(indent2," "); + + for (i=0; iSize(); i++) + ((KML_Style *)style->GetObjectByOffset(i))->Write(filout,indent2); + + return; +} +/*}}}*/ +/*FUNCTION KML_Feature::Read {{{*/ +void KML_Feature::Read(FILE* fid,char* kstr){ + + KML_Object* kobj; + +/* process field within opening and closing tags */ + + if (!strncmp(kstr,"Read(fid,kstr); + style ->AddObject((Object*)kobj); + } + + else if (!strcmp(kstr,"")) + KMLFileTokenParse( name ,NULL,KML_FEATURE_NAME_LENGTH, kstr, fid); + else if (!strcmp(kstr,"")) + KMLFileTokenParse(&visibility, kstr, fid); + else if (!strcmp(kstr,"")) + KMLFileTokenParse(&open , kstr, fid); + else if (!strncmp(kstr,"")) + KMLFileTokenParse( descript ,NULL,KML_FEATURE_DESCRIPT_LENGTH, kstr, fid); + else if (!strcmp(kstr,"")) + KMLFileTokenParse( styleurl ,NULL,KML_FEATURE_STYLEURL_LENGTH, kstr, fid); + + else if (!strncmp(kstr,"<",1)) + KML_Object::Read(fid,kstr); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Feature.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Feature.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Feature.h (revision 15068) @@ -0,0 +1,49 @@ +/*! \file KML_Feature.h + * \brief: header file for kml_feature abstract object + */ + +#ifndef _KML_FEATURE_H_ +#define _KML_FEATURE_H_ + +#define KML_FEATURE_NAME_LENGTH 80 +#define KML_FEATURE_SNIPPET_LENGTH 160 +#define KML_FEATURE_DESCRIPT_LENGTH 3200 +#define KML_FEATURE_STYLEURL_LENGTH 80 + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Object.h" +class KML_Style; +class DataSet; +/*}}}*/ + +class KML_Feature: public KML_Object { + + public: + + char name[KML_FEATURE_NAME_LENGTH+1]; + bool visibility; + bool open; + char snippet[KML_FEATURE_SNIPPET_LENGTH+1]; + char descript[KML_FEATURE_DESCRIPT_LENGTH+1]; + char styleurl[KML_FEATURE_STYLEURL_LENGTH+1]; + DataSet* style; + + /*KML_Feature constructors, destructors {{{*/ + KML_Feature(); + ~KML_Feature(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_FEATURE_H */ Index: /issm/trunk-jpl/src/c/kml/KML_File.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_File.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_File.cpp (revision 15068) @@ -0,0 +1,136 @@ +/*!\file KML_File.cpp + * \brief: implementation of the kml_file object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_File.h" +#include "./KML_Object.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_File::KML_File(){{{*/ +KML_File::KML_File(){ + + ; + +} +/*}}}*/ +/*FUNCTION KML_File::~KML_File(){{{*/ +KML_File::~KML_File(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_File::Echo {{{*/ +void KML_File::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_File:"); + KML_Object::Echo(); + + return; +} +/*}}}*/ +/*FUNCTION KML_File::DeepEcho {{{*/ +void KML_File::DeepEcho(){ + + char indent[81]=""; + + KML_File::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_File::DeepEcho {{{*/ +void KML_File::DeepEcho(const char* indent){ + + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_File:"); + KML_Object::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_File::Write {{{*/ +void KML_File::Write(FILE* filout,const char* indent){ + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Object::Write(filout,indent); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_File::Read {{{*/ +void KML_File::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ +/*FUNCTION KML_File::WriteExp {{{*/ +void KML_File::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + int i; + +/* loop over the kml objects for the file */ + + for (i=0; iSize(); i++) + ((KML_Object *)kmlobj->GetObjectByOffset(i))->WriteExp(fid,nstr,sgn,cm,sp); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_File.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_File.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_File.h (revision 15068) @@ -0,0 +1,37 @@ +/*! \file KML_File.h + * \brief: header file for kml_file object + */ + +#ifndef _KML_FILE_H_ +#define _KML_FILE_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" + +#include "./KML_Feature.h" +class DataSet; +/*}}}*/ + +class KML_File: public KML_Object { + + public: + + /*KML_File constructors, destructors {{{*/ + KML_File(); + ~KML_File(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_FILE_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Folder.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Folder.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Folder.cpp (revision 15068) @@ -0,0 +1,122 @@ +/*!\file KML_Folder.cpp + * \brief: implementation of the kml_folder object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Folder.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Folder::KML_Folder(){{{*/ +KML_Folder::KML_Folder(){ + + ; + +} +/*}}}*/ +/*FUNCTION KML_Folder::~KML_Folder(){{{*/ +KML_Folder::~KML_Folder(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Folder::Echo {{{*/ +void KML_Folder::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Folder:"); + KML_Container::Echo(); + + return; +} +/*}}}*/ +/*FUNCTION KML_Folder::DeepEcho {{{*/ +void KML_Folder::DeepEcho(){ + + char indent[81]=""; + + KML_Folder::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Folder::DeepEcho {{{*/ +void KML_Folder::DeepEcho(const char* indent){ + + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Folder:"); + KML_Container::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Folder::Write {{{*/ +void KML_Folder::Write(FILE* filout,const char* indent){ + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Container::Write(filout,indent); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Folder::Read {{{*/ +void KML_Folder::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Folder.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Folder.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Folder.h (revision 15068) @@ -0,0 +1,35 @@ +/*! \file KML_Folder.h + * \brief: header file for kml_folder object + */ + +#ifndef _KML_FOLDER_H_ +#define _KML_FOLDER_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Container.h" +class KML_Feature; +/*}}}*/ + +class KML_Folder: public KML_Container { + + public: + + /*KML_Folder constructors, destructors {{{*/ + KML_Folder(); + ~KML_Folder(); + /*}}}*/ + /*Object virtual functions definitions:{{{ */ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_FOLDER_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Geometry.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Geometry.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Geometry.cpp (revision 15068) @@ -0,0 +1,86 @@ +/*!\file KML_Geometry.cpp + * \brief: implementation of the kml_geometry abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Geometry.h" +#include "./KML_Object.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Geometry::KML_Geometry(){{{*/ +KML_Geometry::KML_Geometry(){ + + ; + +} +/*}}}*/ +/*FUNCTION KML_Geometry::~KML_Geometry(){{{*/ +KML_Geometry::~KML_Geometry(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Geometry::Echo {{{*/ +void KML_Geometry::Echo(){ + + this->KML_Object::Echo(); + + return; +} +/*}}}*/ +/*FUNCTION KML_Geometry::DeepEcho {{{*/ +void KML_Geometry::DeepEcho(){ + + char indent[81]=""; + + KML_Geometry::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Geometry::DeepEcho {{{*/ +void KML_Geometry::DeepEcho(const char* indent){ + + this->KML_Object::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Geometry::Write {{{*/ +void KML_Geometry::Write(FILE* filout,const char* indent){ + + KML_Object::Write(filout,indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Geometry::Read {{{*/ +void KML_Geometry::Read(FILE* fid,char* kstr){ + +/* process field within opening and closing tags */ + + if (!strncmp(kstr," +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Object.h" +#include "./KML_LatLonBox.h" +#include "./KML_GroundOverlay.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_GroundOverlay::KML_GroundOverlay(){{{*/ +KML_GroundOverlay::KML_GroundOverlay(){ + + altitude = 0.; + memcpy(altmode,"clampToGround",(strlen("clampToGround")+1)*sizeof(char)); + + llbox =NULL; + +} +/*}}}*/ +/*FUNCTION KML_GroundOverlay::~KML_GroundOverlay(){{{*/ +KML_GroundOverlay::~KML_GroundOverlay(){ + + if (llbox) { + delete llbox; + llbox =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_GroundOverlay::Echo {{{*/ +void KML_GroundOverlay::Echo(){ + + _printLine_("KML_GroundOverlay:"); + KML_Overlay::Echo(); + + _printLine_(" altitude: " << altitude); + _printLine_(" altmode: " << altmode); + _printLine_(" llbox: " << llbox); +} +/*}}}*/ +/*FUNCTION KML_GroundOverlay::DeepEcho {{{*/ +void KML_GroundOverlay::DeepEcho(){ + + char indent[81]=""; + + KML_GroundOverlay::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_GroundOverlay::DeepEcho {{{*/ +void KML_GroundOverlay::DeepEcho(const char* indent){ + + char indent2[81]; + + _printLine_(indent << "KML_GroundOverlay:"); + KML_Overlay::DeepEcho(indent); + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + _printLine_(indent<<" altitude: " << altitude); + _printLine_(indent<<" altmode: " << altmode); + if (llbox) + llbox->DeepEcho(indent2); + else + _printLine_(indent<<" llbox: " << llbox); +} +/*}}}*/ +/*FUNCTION KML_GroundOverlay::Write {{{*/ +void KML_GroundOverlay::Write(FILE* filout,const char* indent){ + + char indent2[81]; + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Overlay::Write(filout,indent); + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + + strcat(indent2," "); + + fprintf(filout,"%s %0.16g\n",indent,altitude); + fprintf(filout,"%s %s\n",indent,altmode); + if (llbox) + llbox->Write(filout,indent2); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_GroundOverlay::Read {{{*/ +void KML_GroundOverlay::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse(&altitude , + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse( altmode ,NULL,KML_GROUNDOVERLAY_ALTMODE_LENGTH, + kstri, + fid); + else if (!strncmp(kstri,"Read(fid,kstri); + } + + else if (!strncmp(kstri,"<",1)) + KML_Overlay::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_GroundOverlay.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_GroundOverlay.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_GroundOverlay.h (revision 15068) @@ -0,0 +1,41 @@ +/*! \file KML_GroundOverlay.h + * \brief: header file for kml_groundoverlay object + */ + +#ifndef _KML_GROUNDOVERLAY_H_ +#define _KML_GROUNDOVERLAY_H_ + +#define KML_GROUNDOVERLAY_ALTMODE_LENGTH 18 + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Overlay.h" +class KML_LatLonBox; +/*}}}*/ + +class KML_GroundOverlay: public KML_Overlay { + + public: + + double altitude; + char altmode[KML_GROUNDOVERLAY_ALTMODE_LENGTH+1]; + KML_LatLonBox* llbox; + + /*KML_GroundOverlay constructors, destructors {{{*/ + KML_GroundOverlay(); + ~KML_GroundOverlay(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_GROUNDOVERLAY_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Icon.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Icon.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Icon.cpp (revision 15068) @@ -0,0 +1,178 @@ +/*!\file KML_Icon.cpp + * \brief: implementation of the kml_feature abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Icon.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Icon::KML_Icon(){{{*/ +KML_Icon::KML_Icon(){ + + strcpy(href ,""); + strcpy(refmode ,"onChange"); + refint = 4.; + strcpy(vrefmode ,"never"); + vreftime = 4.; + vboundsc = 1.; + strcpy(vformat ,""); + strcpy(hquery ,""); + +} +/*}}}*/ +/*FUNCTION KML_Icon::~KML_Icon(){{{*/ +KML_Icon::~KML_Icon(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Icon::Echo {{{*/ +void KML_Icon::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Icon:"); + KML_Object::Echo(); + + if(flag) _pprintLine_(" href: \"" << href << "\""); + if(flag) _pprintLine_(" refmode: \"" << refmode << "\""); + if(flag) _pprintLine_(" refint: " << refint); + if(flag) _pprintLine_(" vrefmode: \"" << vrefmode << "\""); + if(flag) _pprintLine_(" vreftime: " << vreftime); + if(flag) _pprintLine_(" vboundsc: " << vboundsc); + if(flag) _pprintLine_(" vformat: \"" << vformat << "\""); + if(flag) _pprintLine_(" hquery: \"" << hquery << "\""); + + return; +} +/*}}}*/ +/*FUNCTION KML_Icon::DeepEcho {{{*/ +void KML_Icon::DeepEcho(){ + + char indent[81]=""; + + KML_Icon::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Icon::DeepEcho {{{*/ +void KML_Icon::DeepEcho(const char* indent){ + + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Icon:"); + KML_Object::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " href: \"" << href << "\""); + if(flag) _pprintLine_(indent << " refmode: \"" << refmode << "\""); + if(flag) _pprintLine_(indent << " refint: " << refint); + if(flag) _pprintLine_(indent << " vrefmode: \"" << vrefmode << "\""); + if(flag) _pprintLine_(indent << " vreftime: " << vreftime); + if(flag) _pprintLine_(indent << " vboundsc: " << vboundsc); + if(flag) _pprintLine_(indent << " vformat: \"" << vformat << "\""); + if(flag) _pprintLine_(indent << " hquery: \"" << hquery << "\""); + + return; +} +/*}}}*/ +/*FUNCTION KML_Icon::Write {{{*/ +void KML_Icon::Write(FILE* filout,const char* indent){ + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Object::Write(filout,indent); + + if (href && strlen(href)) + fprintf(filout,"%s %s\n",indent,href); + if (refmode && strlen(refmode)) + fprintf(filout,"%s %s\n",indent,refmode); + fprintf(filout,"%s %g\n",indent,refint); + if (vrefmode && strlen(vrefmode)) + fprintf(filout,"%s %s\n",indent,vrefmode); + fprintf(filout,"%s %g\n",indent,vreftime); + fprintf(filout,"%s %g\n",indent,vboundsc); + if (vformat && strlen(vformat)) + fprintf(filout,"%s %s\n",indent,vformat); + if (hquery && strlen(hquery)) + fprintf(filout,"%s %s\n",indent,hquery); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Icon::Read {{{*/ +void KML_Icon::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse( href ,NULL,KML_ICON_HREF_LENGTH, kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse( refmode ,NULL,KML_ICON_REFMODE_LENGTH, kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&refint , kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse( vrefmode ,NULL,KML_ICON_VREFMODE_LENGTH, kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&vreftime , kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&vboundsc , kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse( vformat ,NULL,KML_ICON_VFORMAT_LENGTH, kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse( hquery ,NULL,KML_ICON_HQUERY_LENGTH, kstri, fid); + + else if (!strncmp(kstri,"<",1)) + KML_Object::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Icon.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Icon.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Icon.h (revision 15068) @@ -0,0 +1,49 @@ +/*! \file KML_Icon.h + * \brief: header file for kml_icon object + */ + +#ifndef _KML_ICON_H_ +#define _KML_ICON_H_ + +#define KML_ICON_HREF_LENGTH 800 +#define KML_ICON_REFMODE_LENGTH 10 +#define KML_ICON_VREFMODE_LENGTH 9 +#define KML_ICON_VFORMAT_LENGTH 800 +#define KML_ICON_HQUERY_LENGTH 800 + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Object.h" +/*}}}*/ + +class KML_Icon: public KML_Object { + + public: + + char href[KML_ICON_HREF_LENGTH+1]; + char refmode[KML_ICON_REFMODE_LENGTH+1]; + float refint; + char vrefmode[KML_ICON_VREFMODE_LENGTH+1]; + float vreftime; + float vboundsc; + char vformat[KML_ICON_VFORMAT_LENGTH+1]; + char hquery[KML_ICON_HQUERY_LENGTH+1]; + + /*KML_Icon constructors, destructors {{{*/ + KML_Icon(); + ~KML_Icon(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_ICON_H */ Index: /issm/trunk-jpl/src/c/kml/KML_LatLonBox.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_LatLonBox.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_LatLonBox.cpp (revision 15068) @@ -0,0 +1,157 @@ +/*!\file KML_LatLonBox.cpp + * \brief: implementation of the kml_feature abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_LatLonBox.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_LatLonBox::KML_LatLonBox(){{{*/ +KML_LatLonBox::KML_LatLonBox(){ + + north = 0.; + south = 0.; + east = 0.; + west = 0.; + rotation = 0.; + +} +/*}}}*/ +/*FUNCTION KML_LatLonBox::~KML_LatLonBox(){{{*/ +KML_LatLonBox::~KML_LatLonBox(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_LatLonBox::Echo {{{*/ +void KML_LatLonBox::Echo(){ + + _printLine_("KML_LatLonBox:"); + KML_Object::Echo(); + + _printLine_(" north: " << north); + _printLine_(" south: " << south); + _printLine_(" east: " << east); + _printLine_(" west: " << west); + _printLine_(" rotation: " << rotation); +} +/*}}}*/ +/*FUNCTION KML_LatLonBox::DeepEcho {{{*/ +void KML_LatLonBox::DeepEcho(){ + + char indent[81]=""; + + KML_LatLonBox::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_LatLonBox::DeepEcho {{{*/ +void KML_LatLonBox::DeepEcho(const char* indent){ + + _printLine_(indent << "KML_LatLonBox:"); + KML_Object::DeepEcho(indent); + + _printLine_(" north: " << north); + _printLine_(" south: " << south); + _printLine_(" east: " << east); + _printLine_(" west: " << west); + _printLine_(" rotation: " << rotation); +} +/*}}}*/ +/*FUNCTION KML_LatLonBox::Write {{{*/ +void KML_LatLonBox::Write(FILE* filout,const char* indent){ + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Object::Write(filout,indent); + + fprintf(filout,"%s %0.16g\n",indent,north); + fprintf(filout,"%s %0.16g\n",indent,south); + fprintf(filout,"%s %0.16g\n",indent,east); + fprintf(filout,"%s %0.16g\n",indent,west); + fprintf(filout,"%s %0.16g\n",indent,rotation); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_LatLonBox::Read {{{*/ +void KML_LatLonBox::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse(&north , + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&south , + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&east , + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&west , + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&rotation , + kstri, + fid); + + else if (!strncmp(kstri,"<",1)) + KML_Object::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_LatLonBox.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_LatLonBox.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_LatLonBox.h (revision 15068) @@ -0,0 +1,40 @@ +/*! \file KML_LatLonBox.h + * \brief: header file for kml_latlonbox object + */ + +#ifndef _KML_LATLONBOX_H_ +#define _KML_LATLONBOX_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Object.h" +/*}}}*/ + +class KML_LatLonBox: public KML_Object { + + public: + + double north; + double south; + double east; + double west; + double rotation; + + /*KML_LatLonBox constructors, destructors {{{*/ + KML_LatLonBox(); + ~KML_LatLonBox(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_LATLONBOX_H */ Index: /issm/trunk-jpl/src/c/kml/KML_LineString.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_LineString.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_LineString.cpp (revision 15068) @@ -0,0 +1,232 @@ +/*!\file KML_LineString.cpp + * \brief: implementation of the kml_linestring object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_LineString.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +#include "../modules/Ll2xyx/Ll2xyx.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_LineString::KML_LineString(){{{*/ +KML_LineString::KML_LineString(){ + + extrude =false; + tessellate=false; + memcpy(altmode,"clampToGround",(strlen("clampToGround")+1)*sizeof(char)); + + ncoord =0; + coords =NULL; + +} +/*}}}*/ +/*FUNCTION KML_LineString::~KML_LineString(){{{*/ +KML_LineString::~KML_LineString(){ + + if (coords) xDelete(coords); + + coords =NULL; + ncoord =0; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_LineString::Echo {{{*/ +void KML_LineString::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_LineString:"); + KML_Geometry::Echo(); + + if(flag) _pprintLine_(" extrude: " << (extrude ? "true" : "false")); + if(flag) _pprintLine_(" tessellate: " << (tessellate ? "true" : "false")); + if(flag) _pprintLine_(" altmode: \"" << altmode << "\""); + if(flag) _pprintLine_(" coords: (ncoord=" << ncoord << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_LineString::DeepEcho {{{*/ +void KML_LineString::DeepEcho(){ + + char indent[81]=""; + + KML_LineString::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_LineString::DeepEcho {{{*/ +void KML_LineString::DeepEcho(const char* indent){ + + int i; + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_LineString:"); + KML_Geometry::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " extrude: " << (extrude ? "true" : "false")); + if(flag) _pprintLine_(indent << " tessellate: " << (tessellate ? "true" : "false")); + if(flag) _pprintLine_(indent << " altmode: \"" << altmode << "\""); + if(flag) _pprintLine_(indent << " coords: (ncoord=" << ncoord << ")"); + for (i=0; i\n"); + WriteCommnt(filout,indent); + + KML_Geometry::Write(filout,indent); + + fprintf(filout,"%s %d\n",indent,(extrude ? 1 : 0)); + fprintf(filout,"%s %d\n",indent,(tessellate ? 1 : 0)); + fprintf(filout,"%s %s\n",indent,altmode); + fprintf(filout,"%s \n",indent); + +/* loop over the coordinates for the linestring */ + + for (i=0; i\n",indent); + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_LineString::Read {{{*/ +void KML_LineString::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse(&extrude , + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&tessellate, + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse( altmode ,NULL,KML_LINESTRING_ALTMODE_LENGTH, + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&coords ,&ncoord ,0, + kstri, + fid); + + else if (!strncmp(kstri,"<",1)) + KML_Geometry::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ +/*FUNCTION KML_LineString::WriteExp {{{*/ +void KML_LineString::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + int i; + double *lat,*lon,*x,*y; + char nstr2[81]; + +/* extract latitude and longitude into vectors */ + + lat=xNew(ncoord); + lon=xNew(ncoord); + for (i=0; i(ncoord); + y =xNew(ncoord); + if (sgn) { + Ll2xyx(x,y,lat,lon,ncoord,sgn,cm,sp); + } + else { + memcpy(x,lon,ncoord*sizeof(IssmDouble)); + memcpy(y,lat,ncoord*sizeof(IssmDouble)); + } + +/* write header */ + + memcpy(nstr2,nstr,(strlen(nstr)+1)*sizeof(char)); + + for (i=0; i(y); + xDelete(x); + xDelete(lon); + xDelete(lat); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_LineString.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_LineString.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_LineString.h (revision 15068) @@ -0,0 +1,43 @@ +/*! \file KML_LineString.h + * \brief: header file for kml_linestring object + */ + +#ifndef _KML_LINESTRING_H_ +#define _KML_LINESTRING_H_ + +#define KML_LINESTRING_ALTMODE_LENGTH 18 + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Geometry.h" +/*}}}*/ + +class KML_LineString: public KML_Geometry { + + public: + + bool extrude; + bool tessellate; + char altmode[KML_LINESTRING_ALTMODE_LENGTH+1]; + int ncoord; + double *coords; + + /*KML_LineString constructors, destructors {{{*/ + KML_LineString(); + ~KML_LineString(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_LINESTRING_H */ Index: /issm/trunk-jpl/src/c/kml/KML_LineStyle.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_LineStyle.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_LineStyle.cpp (revision 15068) @@ -0,0 +1,133 @@ +/*!\file KML_LineStyle.cpp + * \brief: implementation of the kml_linestyle object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_LineStyle.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_LineStyle::KML_LineStyle(){{{*/ +KML_LineStyle::KML_LineStyle(){ + + width =1.; + +} +/*}}}*/ +/*FUNCTION KML_LineStyle::~KML_LineStyle(){{{*/ +KML_LineStyle::~KML_LineStyle(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_LineStyle::Echo {{{*/ +void KML_LineStyle::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_LineStyle:"); + KML_ColorStyle::Echo(); + + if(flag) _pprintLine_(" width: " << width); + + return; +} +/*}}}*/ +/*FUNCTION KML_LineStyle::DeepEcho {{{*/ +void KML_LineStyle::DeepEcho(){ + + char indent[81]=""; + + KML_LineStyle::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_LineStyle::DeepEcho {{{*/ +void KML_LineStyle::DeepEcho(const char* indent){ + + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_LineStyle:"); + KML_ColorStyle::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " width: " << width); + + return; +} +/*}}}*/ +/*FUNCTION KML_LineStyle::Write {{{*/ +void KML_LineStyle::Write(FILE* filout,const char* indent){ + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_ColorStyle::Write(filout,indent); + + fprintf(filout,"%s %g\n",indent,width); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_LineStyle::Read {{{*/ +void KML_LineStyle::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse(&width , + kstri, + fid); + + else if (!strncmp(kstri,"<",1)) + KML_ColorStyle::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_LineStyle.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_LineStyle.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_LineStyle.h (revision 15068) @@ -0,0 +1,36 @@ +/*! \file KML_LineStyle.h + * \brief: header file for kml_linestyle object + */ + +#ifndef _KML_LINESTYLE_H_ +#define _KML_LINESTYLE_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_ColorStyle.h" +/*}}}*/ + +class KML_LineStyle: public KML_ColorStyle { + + public: + + float width; + + /*KML_LineStyle constructors, destructors {{{*/ + KML_LineStyle(); + ~KML_LineStyle(); + /*}}}*/ + /*Object virtual functions definitions:{{{ */ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_LINESTYLE_H */ Index: /issm/trunk-jpl/src/c/kml/KML_LinearRing.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_LinearRing.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_LinearRing.cpp (revision 15068) @@ -0,0 +1,226 @@ +/*!\file KML_LinearRing.cpp + * \brief: implementation of the kml_linearring object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_LinearRing.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +#include "../modules/Ll2xyx/Ll2xyx.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_LinearRing::KML_LinearRing(){{{*/ +KML_LinearRing::KML_LinearRing(){ + + extrude =false; + tessellate=false; + memcpy(altmode,"clampToGround",(strlen("clampToGround")+1)*sizeof(char)); + + ncoord =0; + coords =NULL; + +} +/*}}}*/ +/*FUNCTION KML_LinearRing::~KML_LinearRing(){{{*/ +KML_LinearRing::~KML_LinearRing(){ + + if (coords) xDelete(coords); + + coords =NULL; + ncoord =0; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_LinearRing::Echo {{{*/ +void KML_LinearRing::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_LinearRing:"); + KML_Geometry::Echo(); + + if(flag) _pprintLine_(" extrude: " << (extrude ? "true" : "false")); + if(flag) _pprintLine_(" tessellate: " << (tessellate ? "true" : "false")); + if(flag) _pprintLine_(" altmode: \"" << altmode << "\""); + if(flag) _pprintLine_(" coords: (ncoord=" << ncoord << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_LinearRing::DeepEcho {{{*/ +void KML_LinearRing::DeepEcho(){ + + char indent[81]=""; + + KML_LinearRing::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_LinearRing::DeepEcho {{{*/ +void KML_LinearRing::DeepEcho(const char* indent){ + + int i; + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_LinearRing:"); + KML_Geometry::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " extrude: " << (extrude ? "true" : "false")); + if(flag) _pprintLine_(indent << " tessellate: " << (tessellate ? "true" : "false")); + if(flag) _pprintLine_(indent << " altmode: \"" << altmode << "\""); + if(flag) _pprintLine_(indent << " coords: (ncoord=" << ncoord << ")"); + for (i=0; i\n"); + WriteCommnt(filout,indent); + + KML_Geometry::Write(filout,indent); + + fprintf(filout,"%s %d\n",indent,(extrude ? 1 : 0)); + fprintf(filout,"%s %d\n",indent,(tessellate ? 1 : 0)); + fprintf(filout,"%s %s\n",indent,altmode); + fprintf(filout,"%s \n",indent); + +/* loop over the coordinates for the linearring */ + + for (i=0; i\n",indent); + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_LinearRing::Read {{{*/ +void KML_LinearRing::Read(FILE* fid,char* kstr){ + + char *kstri = NULL; + int ncom = 0; + char **pcom = NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this,kstr)) return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid,&ncom,&pcom)){ + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse(&extrude,kstri,fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&tessellate,kstri,fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(altmode,NULL,KML_LINEARRING_ALTMODE_LENGTH,kstri,fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&coords,&ncoord,3,0,kstri,fid); + else if (!strncmp(kstri,"<",1)) + KML_Geometry::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for(ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ +/*FUNCTION KML_LinearRing::WriteExp {{{*/ +void KML_LinearRing::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + int i; + double *lat,*lon,*x,*y; + char nstr2[81]; + +/* extract latitude and longitude into vectors */ + + lat=xNew(ncoord); + lon=xNew(ncoord); + for (i=0; i(ncoord); + y =xNew(ncoord); + if (sgn) { + Ll2xyx(x,y,lat,lon,ncoord,sgn,cm,sp); + } + else { + memcpy(x,lon,ncoord*sizeof(IssmDouble)); + memcpy(y,lat,ncoord*sizeof(IssmDouble)); + } + +/* write header */ + + memcpy(nstr2,nstr,(strlen(nstr)+1)*sizeof(char)); + + for (i=0; i(y); + xDelete(x); + xDelete(lon); + xDelete(lat); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_LinearRing.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_LinearRing.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_LinearRing.h (revision 15068) @@ -0,0 +1,43 @@ +/*! \file KML_LinearRing.h + * \brief: header file for kml_linearring object + */ + +#ifndef _KML_LINEARRING_H_ +#define _KML_LINEARRING_H_ + +#define KML_LINEARRING_ALTMODE_LENGTH 18 + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Geometry.h" +/*}}}*/ + +class KML_LinearRing: public KML_Geometry { + + public: + + bool extrude; + bool tessellate; + char altmode[KML_LINEARRING_ALTMODE_LENGTH+1]; + int ncoord; + double *coords; + + /*KML_LinearRing constructors, destructors {{{*/ + KML_LinearRing(); + ~KML_LinearRing(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_LINEARRING_H */ Index: /issm/trunk-jpl/src/c/kml/KML_MultiGeometry.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_MultiGeometry.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_MultiGeometry.cpp (revision 15068) @@ -0,0 +1,204 @@ +/*!\file KML_MultiGeometry.cpp + * \brief: implementation of the kml_multigeometry object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Object.h" +#include "./KML_Point.h" +#include "./KML_Polygon.h" +#include "./KML_LineString.h" +#include "./KML_LinearRing.h" +#include "./KMLFileReadUtils.h" +#include "./KML_MultiGeometry.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_MultiGeometry::KML_MultiGeometry(){{{*/ +KML_MultiGeometry::KML_MultiGeometry(){ + + geometry =new DataSet; + +} +/*}}}*/ +/*FUNCTION KML_MultiGeometry::~KML_MultiGeometry(){{{*/ +KML_MultiGeometry::~KML_MultiGeometry(){ + + if (geometry) { + delete geometry; + geometry =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_MultiGeometry::Echo {{{*/ +void KML_MultiGeometry::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Multigeometry:"); + KML_Geometry::Echo(); + + if(flag) _pprintLine_(" geometry: (size=" << geometry->Size() << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_MultiGeometry::DeepEcho {{{*/ +void KML_MultiGeometry::DeepEcho(){ + + char indent[81]=""; + + KML_MultiGeometry::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_MultiGeometry::DeepEcho {{{*/ +void KML_MultiGeometry::DeepEcho(const char* indent){ + + int i; + char indent2[81]; + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Multigeometry:"); + KML_Geometry::DeepEcho(indent); + +/* loop over the geometry elements for the multigeometry */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + if (geometry->Size()) + for (i=0; iSize(); i++) { + if(flag) _pprintLine_(indent << " geometry: -------- begin [" << i << "] --------"); + ((KML_Geometry *)geometry->GetObjectByOffset(i))->DeepEcho(indent2); + if(flag) _pprintLine_(indent << " geometry: -------- end [" << i << "] --------"); + } + else + if(flag) _pprintLine_(indent << " geometry: [empty]"); + + return; +} +/*}}}*/ +/*FUNCTION KML_MultiGeometry::Write {{{*/ +void KML_MultiGeometry::Write(FILE* filout,const char* indent){ + + int i; + char indent2[81]; + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Geometry::Write(filout,indent); + +/* loop over the geometry elements for the multigeometry */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + + strcat(indent2," "); + + for (i=0; iSize(); i++) + ((KML_Geometry *)geometry->GetObjectByOffset(i))->Write(filout,indent2); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_MultiGeometry::Read {{{*/ +void KML_MultiGeometry::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + KML_Object* kobj; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"<",1)) + KML_Geometry::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ +/*FUNCTION KML_MultiGeometry::WriteExp {{{*/ +void KML_MultiGeometry::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + int i; + +/* loop over the geometry elements for the multigeometry */ + + for (i=0; iSize(); i++) + ((KML_Object *)geometry->GetObjectByOffset(i))->WriteExp(fid,nstr,sgn,cm,sp); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_MultiGeometry.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_MultiGeometry.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_MultiGeometry.h (revision 15068) @@ -0,0 +1,39 @@ +/*! \file KML_MultiGeometry.h + * \brief: header file for kml_multigeometry object + */ + +#ifndef _KML_MULTIGEOMETRY_H_ +#define _KML_MULTIGEOMETRY_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Geometry.h" +class KML_Geometry; +class DataSet; +/*}}}*/ + +class KML_MultiGeometry: public KML_Geometry { + + public: + + DataSet* geometry; + + /*KML_MultiGeometry constructors, destructors {{{*/ + KML_MultiGeometry(); + ~KML_MultiGeometry(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_MULTIGEOMETRY_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Object.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Object.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Object.cpp (revision 15068) @@ -0,0 +1,398 @@ +/*!\file KML_Object.cpp + * \brief: implementation of the kml_object abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Object.h" +#include "./KML_Attribute.h" +#include "./KML_Comment.h" +#include "./KML_Unknown.h" +#include "./KML_LatLonBox.h" +#include "./KML_Icon.h" +#include "./KML_MultiGeometry.h" +#include "./KML_Document.h" +#include "./KML_LinearRing.h" +#include "./KML_LineStyle.h" +#include "./KML_LineString.h" +#include "./KML_PolyStyle.h" +#include "./KML_Polygon.h" +#include "./KML_Point.h" +#include "./KML_GroundOverlay.h" +#include "./KML_Placemark.h" +#include "./KML_Folder.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Object::KML_Object(){{{*/ +KML_Object::KML_Object(){ + + attrib =new DataSet; + commnt =new DataSet; + kmlobj =new DataSet; + +} +/*}}}*/ +/*FUNCTION KML_Object::~KML_Object(){{{*/ +KML_Object::~KML_Object(){ + + if (attrib) { + delete attrib; + attrib =NULL; + } + if (commnt) { + delete commnt; + commnt =NULL; + } + if (kmlobj) { + delete kmlobj; + kmlobj =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Object::Echo {{{*/ +void KML_Object::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_(" attrib: (size=" << attrib->Size() << ")"); + if(flag) _pprintLine_(" commnt: (size=" << commnt->Size() << ")"); + if(flag) _pprintLine_(" kmlobj: (size=" << kmlobj->Size() << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::DeepEcho {{{*/ +void KML_Object::DeepEcho(){ + + char indent[81]=""; + + KML_Object::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::DeepEcho {{{*/ +void KML_Object::DeepEcho(const char* indent){ + + int i; + char indent2[81]; + bool flag=true; + +/* loop over the attributes for the object */ + + if (attrib->Size()) + for (i=0; iSize(); i++) { + ((KML_Attribute *)attrib->GetObjectByOffset(i))->DeepEcho(indent); + } + else + if(flag) _pprintLine_(indent << " attrib: [empty]"); + +/* loop over the comments for the object */ + + if (commnt->Size()) + for (i=0; iSize(); i++) { + ((KML_Comment *)commnt->GetObjectByOffset(i))->DeepEcho(indent); + } + else + if(flag) _pprintLine_(indent << " commnt: [empty]"); + +/* loop over the unknown objects for the object */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + if (kmlobj->Size()) + for (i=0; iSize(); i++) { + if(flag) _pprintLine_(indent << " kmlobj: -------- begin [" << i << "] --------"); + ((KML_Unknown *)kmlobj->GetObjectByOffset(i))->DeepEcho(indent2); + if(flag) _pprintLine_(indent << " kmlobj: -------- end [" << i << "] --------"); + } + else + if(flag) _pprintLine_(indent << " kmlobj: [empty]"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::Write {{{*/ +void KML_Object::Write(FILE* filout,const char* indent){ + + int i; + char indent2[81]; + +// attributes always written in keyword line of derived classes +// comments always written after keyword line of derived classes + +/* loop over the unknown objects for the object */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + if (kmlobj->Size()) + for (i=0; iSize(); i++) { + ((KML_Unknown *)kmlobj->GetObjectByOffset(i))->Write(filout,indent2); + } + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::Read {{{*/ +void KML_Object::Read(FILE* fid,char* kstr){ + + KML_Object* kobj; + +/* process field within opening and closing tags */ + + if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + +// else if (!strncmp(kstr,"Read(fid,kstr); +// kmlobj ->AddObject((Object*)kobj); +// } + +// else if (!strncmp(kstr,"Read(fid,kstr); +// kmlobj ->AddObject((Object*)kobj); +// } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstr,"Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + +// else if (!strncmp(kstr,"Read(fid,kstr); +// kmlobj ->AddObject((Object*)kobj); +// } + +// else if (!strncmp(kstr,"Read(fid,kstr); +// kmlobj ->AddObject((Object*)kobj); +// } + + else if (!strncmp(kstr,"<",1)) { + _pprintLine_("KML_Object::Read -- Unrecognized opening tag " << kstr << "."); +// KMLFileTagSkip(kstr, +// fid); + kobj=(KML_Object*)new KML_Unknown(); + kobj->Read(fid,kstr); + kmlobj ->AddObject((Object*)kobj); + } + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::WriteExp {{{*/ +void KML_Object::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + ; + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::AddAttrib {{{*/ +void KML_Object::AddAttrib(const char* name,const char* value){ + + KML_Attribute* katt=NULL; + + katt=new KML_Attribute(); + katt->Alloc(name,value); + katt->Add(attrib); + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::FindAttrib {{{*/ +void KML_Object::FindAttrib(char** pvalue,char* name,char* deflt){ + + int i; + KML_Attribute* katt=NULL; + +/* loop over any attributes for the object */ + + if (attrib->Size()) + for (i=0; iSize(); i++) + if (!strcmp(((KML_Attribute *)attrib->GetObjectByOffset(i))->name,name)) { + katt=(KML_Attribute *)attrib->GetObjectByOffset(i); + break; + } + +/* if found, get the value; otherwise use the default */ + + if (katt) + katt->Get(pvalue,deflt); + else { + *pvalue=xNew(strlen(deflt)+1); + memcpy(*pvalue,deflt,(strlen(deflt)+1)*sizeof(char)); + } + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::WriteAttrib {{{*/ +void KML_Object::WriteAttrib(FILE* filout,const char* indent){ + +// attributes always written in keyword line of kml_object + +/* loop over any attributes for the object */ + + if (attrib->Size()) + for (int i=0; iSize(); i++) + ((KML_Attribute *)attrib->GetObjectByOffset(i))->Write(filout,indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::AddCommnt {{{*/ +void KML_Object::AddCommnt(int ncom,char** pcom){ + + int i; + KML_Comment* kcom=NULL; + + for (i=0; iAlloc(pcom[i]); + kcom->Add(commnt); + } + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::AddCommnt {{{*/ +void KML_Object::AddCommnt(char* value){ + + KML_Comment* kcom=NULL; + + kcom=new KML_Comment(); + kcom->Alloc(value); + kcom->Add(commnt); + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::FindCommnt {{{*/ +void KML_Object::FindCommnt(char** pvalue,int inum){ + + KML_Comment* kcom=NULL; + +/* loop over any comments for the object */ + + if (inum <= commnt->Size()) + kcom=(KML_Comment *)commnt->GetObjectByOffset(inum-1); + +/* if found, get the value; otherwise use the NULL */ + + if (kcom) + kcom->Get(pvalue); + + return; +} +/*}}}*/ +/*FUNCTION KML_Object::WriteCommnt {{{*/ +void KML_Object::WriteCommnt(FILE* filout,const char* indent){ + + int i; + +// comments always written after keyword line of kml_object + +/* loop over any comments for the object */ + + if (commnt->Size()) + for (i=0; iSize(); i++) + ((KML_Comment *)commnt->GetObjectByOffset(i))->Write(filout,indent); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Object.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Object.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Object.h (revision 15068) @@ -0,0 +1,47 @@ +/*! \file KML_Object.h + * \brief: header file for kml_object abstract object + */ + +#ifndef _KML_OBJECT_H_ +#define _KML_OBJECT_H_ + +/*Headers:{{{*/ +#include "../shared/shared.h" +#include "../datastructures/datastructures.h" +/*}}}*/ + +class KML_Object: public Object { + + public: + + DataSet* attrib; + DataSet* commnt; + DataSet* kmlobj; + + /*KML_Object constructors, destructors {{{*/ + KML_Object(); + ~KML_Object(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + virtual void Echo(); + virtual void DeepEcho(); + virtual void DeepEcho(const char* indent); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + + /*virtual functions: */ + virtual void Write(FILE* fid,const char* indent)=0; + virtual void Read(FILE* fid,char* kstr)=0; + virtual void WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp); + virtual void AddAttrib(const char* name,const char* value); + virtual void FindAttrib(char** pvalue,char* name,char* deflt); + virtual void WriteAttrib(FILE* fid,const char* indent); + virtual void AddCommnt(int ncom,char** pcom); + virtual void AddCommnt(char* value); + virtual void FindCommnt(char** pvalue,int inum); + virtual void WriteCommnt(FILE* fid,const char* indent); + +}; +#endif /* _KML_OBJECT_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Overlay.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Overlay.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Overlay.cpp (revision 15068) @@ -0,0 +1,132 @@ +/*!\file KML_Overlay.cpp + * \brief: implementation of the kml_overlay abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KMLFileReadUtils.h" +#include "./KML_Overlay.h" +#include "./KML_Icon.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Overlay::KML_Overlay(){{{*/ +KML_Overlay::KML_Overlay(){ + + strcpy(color ,"ffffffff"); + memcpy(color,"ffffffff",(strlen("ffffffff")+1)*sizeof(char)); + + draword = 0; + icon =NULL; + +} +/*}}}*/ +/*FUNCTION KML_Overlay::~KML_Overlay(){{{*/ +KML_Overlay::~KML_Overlay(){ + + if (icon) { + delete icon; + icon =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Overlay::Echo {{{*/ +void KML_Overlay::Echo(){ + + KML_Feature::Echo(); + _pprintLine_(" color: \"" << color << "\""); + _pprintLine_(" draword: " << draword); + _pprintLine_(" icon: " << icon); +} +/*}}}*/ +/*FUNCTION KML_Overlay::DeepEcho {{{*/ +void KML_Overlay::DeepEcho(){ + + char indent[81]=""; + + KML_Overlay::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Overlay::DeepEcho {{{*/ +void KML_Overlay::DeepEcho(const char* indent){ + + char indent2[81]; + KML_Feature::DeepEcho(indent); + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + _pprintLine_(indent << " color: " << color); + _pprintLine_(indent << " draword: " << draword); + if (icon) + icon->DeepEcho(indent2); + else + _pprintLine_(indent << " icon: " << icon); +} +/*}}}*/ +/*FUNCTION KML_Overlay::Write {{{*/ +void KML_Overlay::Write(FILE* filout,const char* indent){ + + char indent2[81]; + + KML_Feature::Write(filout,indent); + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + + strcat(indent2," "); + + if (color && strlen(color)) + fprintf(filout,"%s %s\n",indent,color); + fprintf(filout,"%s %d\n",indent,draword); + if (icon) + icon->Write(filout,indent2); + + return; +} +/*}}}*/ +/*FUNCTION KML_Overlay::Read {{{*/ +void KML_Overlay::Read(FILE* fid,char* kstr){ + +/* process field within opening and closing tags */ + + if (!strncmp(kstr,"(kstr); + return; + } + else if (!strncmp(kstr,"")) + KMLFileTokenParse( color ,NULL,KML_OVERLAY_COLOR_LENGTH, + kstr, + fid); + else if (!strcmp(kstr,"")) + KMLFileTokenParse(&draword , + kstr, + fid); + + else if (!strncmp(kstr,"Read(fid,kstr); + } + + else if (!strncmp(kstr,"<",1)) + KML_Feature::Read(fid,kstr); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Overlay.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Overlay.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Overlay.h (revision 15068) @@ -0,0 +1,41 @@ +/*! \file KML_Overlay.h + * \brief: header file for kml_overlay abstract object + */ + +#ifndef _KML_OVERLAY_H_ +#define _KML_OVERLAY_H_ + +#define KML_OVERLAY_COLOR_LENGTH 8 + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Feature.h" +class KML_Icon; +/*}}}*/ + +class KML_Overlay: public KML_Feature { + + public: + + char color[KML_OVERLAY_COLOR_LENGTH+1]; + int draword; + KML_Icon* icon; + + /*KML_Overlay constructors, destructors {{{*/ + KML_Overlay(); + ~KML_Overlay(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_OVERLAY_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Placemark.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Placemark.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Placemark.cpp (revision 15068) @@ -0,0 +1,212 @@ +/*!\file KML_Placemark.cpp + * \brief: implementation of the kml_placemark object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KMLFileReadUtils.h" +#include "./KML_Geometry.h" +#include "./KML_Point.h" +#include "./KML_LineString.h" +#include "./KML_Polygon.h" +#include "./KML_MultiGeometry.h" +#include "./KML_LinearRing.h" +#include "./KML_Placemark.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Placemark::KML_Placemark(){{{*/ +KML_Placemark::KML_Placemark(){ + + geometry =new DataSet; + +} +/*}}}*/ +/*FUNCTION KML_Placemark::~KML_Placemark(){{{*/ +KML_Placemark::~KML_Placemark(){ + + if (geometry) { + delete geometry; + geometry =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Placemark::Echo {{{*/ +void KML_Placemark::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Placemark:"); + KML_Feature::Echo(); + + if(flag) _pprintLine_(" geometry: (size=" << geometry->Size() << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Placemark::DeepEcho {{{*/ +void KML_Placemark::DeepEcho(){ + + char indent[81]=""; + + KML_Placemark::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Placemark::DeepEcho {{{*/ +void KML_Placemark::DeepEcho(const char* indent){ + + int i; + char indent2[81]; + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Placemark:"); + KML_Feature::DeepEcho(indent); + +/* loop over the geometry elements for the placemark */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + if (geometry->Size()) + for (i=0; iSize(); i++) { + if(flag) _pprintLine_(indent << " geometry: -------- begin [" << i << "] --------"); + ((KML_Geometry *)geometry->GetObjectByOffset(i))->DeepEcho(indent2); + if(flag) _pprintLine_(indent << " geometry: -------- end [" << i << "] --------"); + } + else + if(flag) _pprintLine_(indent << " geometry: [empty]"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Placemark::Write {{{*/ +void KML_Placemark::Write(FILE* filout,const char* indent){ + + int i; + char indent2[81]; + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Feature::Write(filout,indent); + +/* loop over the geometry elements for the placemark */ + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + + strcat(indent2," "); + + for (i=0; iSize(); i++) + ((KML_Geometry *)geometry->GetObjectByOffset(i))->Write(filout,indent2); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Placemark::Read {{{*/ +void KML_Placemark::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + KML_Object* kobj; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + geometry ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstri,"<",1)) + KML_Feature::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ +/*FUNCTION KML_Placemark::WriteExp {{{*/ +void KML_Placemark::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + int i; + char nstr2[81]; + +/* loop over the geometry elements for the placemark */ + + for (i=0; iSize(); i++) { + if (strlen(nstr)) + sprintf(nstr2,"%s %s",nstr,name); + else + sprintf(nstr2,"%s",name); + + ((KML_Object *)geometry->GetObjectByOffset(i))->WriteExp(fid,nstr2,sgn,cm,sp); + } + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Placemark.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Placemark.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Placemark.h (revision 15068) @@ -0,0 +1,39 @@ +/*! \file KML_Placemark.h + * \brief: header file for kml_placemark object + */ + +#ifndef _KML_PLACEMARK_H_ +#define _KML_PLACEMARK_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Feature.h" +class KML_Geometry; +class DataSet; +/*}}}*/ + +class KML_Placemark: public KML_Feature { + + public: + + DataSet* geometry; + + /*KML_Placemark constructors, destructors {{{*/ + KML_Placemark(); + ~KML_Placemark(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_PLACEMARK_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Point.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Point.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Point.cpp (revision 15068) @@ -0,0 +1,195 @@ +/*!\file KML_Point.cpp + * \brief: implementation of the kml_point object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Point.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +#include "../modules/Ll2xyx/Ll2xyx.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Point::KML_Point(){{{*/ +KML_Point::KML_Point(){ + + extrude =false; + memcpy(altmode,"clampToGround",(strlen("clampToGround")+1)*sizeof(char)); + + coords[0] = 0.; + coords[1] = 0.; + coords[2] = 0.; + +} +/*}}}*/ +/*FUNCTION KML_Point::~KML_Point(){{{*/ +KML_Point::~KML_Point(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Point::Echo {{{*/ +void KML_Point::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Point:"); + KML_Geometry::Echo(); + + if(flag) _pprintLine_(" extrude: " << (extrude ? "true" : "false")); + if(flag) _pprintLine_(" altmode: \"" << altmode << "\""); + if(flag) _pprintLine_(" coords: (" << coords[0] << "," << coords[1] << "," << coords[2] << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Point::DeepEcho {{{*/ +void KML_Point::DeepEcho(){ + + char indent[81]=""; + + KML_Point::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Point::DeepEcho {{{*/ +void KML_Point::DeepEcho(const char* indent){ + + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Point:"); + KML_Geometry::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " extrude: " << (extrude ? "true" : "false")); + if(flag) _pprintLine_(indent << " altmode: \"" << altmode << "\""); + if(flag) _pprintLine_(indent << " coords: (" << coords[0] << "," << coords[1] << "," << coords[2] << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Point::Write {{{*/ +void KML_Point::Write(FILE* filout,const char* indent){ + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Geometry::Write(filout,indent); + + fprintf(filout,"%s %d\n",indent,(extrude ? 1 : 0)); + fprintf(filout,"%s %s\n",indent,altmode); + fprintf(filout,"%s %0.16g,%0.16g,%0.16g\n", + indent,coords[0],coords[1],coords[2]); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Point::Read {{{*/ +void KML_Point::Read(FILE* fid,char* kstr){ + + double* pcoords=&coords[0]; + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse(&extrude , kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse( altmode ,NULL,KML_POINT_ALTMODE_LENGTH, kstri, fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&pcoords ,NULL,3, kstri, fid); + + else if (!strncmp(kstri,"<",1)) + KML_Geometry::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ +/*FUNCTION KML_Point::WriteExp {{{*/ +void KML_Point::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + int i; + double lat,lon,x,y; + char nstr2[81]; + +/* extract latitude and longitude */ + + lon=coords[0]; + lat=coords[1]; + +/* convert latitude and longitude to x and y */ + + if (sgn) { + Ll2xyx(&x,&y,&lat,&lon,1,sgn,cm,sp); + } + else { + memcpy(&x,&lon,1*sizeof(IssmDouble)); + memcpy(&y,&lat,1*sizeof(IssmDouble)); + } + +/* write header */ + + memcpy(nstr2,nstr,(strlen(nstr)+1)*sizeof(char)); + + for (i=0; i +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Object.h" +#include "./KML_ColorStyle.h" +#include "./KML_PolyStyle.h" +#include "./KMLFileReadUtils.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_PolyStyle::KML_PolyStyle(){{{*/ +KML_PolyStyle::KML_PolyStyle(){ + + fill =true; + outline =true; + +} +/*}}}*/ +/*FUNCTION KML_PolyStyle::~KML_PolyStyle(){{{*/ +KML_PolyStyle::~KML_PolyStyle(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_PolyStyle::Echo {{{*/ +void KML_PolyStyle::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_PolyStyle:"); + KML_ColorStyle::Echo(); + + if(flag) _pprintLine_(" fill: " << fill); + if(flag) _pprintLine_(" outline: " << outline); + + return; +} +/*}}}*/ +/*FUNCTION KML_PolyStyle::DeepEcho {{{*/ +void KML_PolyStyle::DeepEcho(){ + + char indent[81]=""; + + KML_PolyStyle::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_PolyStyle::DeepEcho {{{*/ +void KML_PolyStyle::DeepEcho(const char* indent){ + + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_PolyStyle:"); + KML_ColorStyle::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " fill: " << fill); + if(flag) _pprintLine_(indent << " outline: " << outline); + + return; +} +/*}}}*/ +/*FUNCTION KML_PolyStyle::Write {{{*/ +void KML_PolyStyle::Write(FILE* filout,const char* indent){ + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_ColorStyle::Write(filout,indent); + + fprintf(filout,"%s %d\n",indent,fill); + fprintf(filout,"%s %d\n",indent,outline); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_PolyStyle::Read {{{*/ +void KML_PolyStyle::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse(&fill , + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&outline , + kstri, + fid); + + else if (!strncmp(kstri,"<",1)) + KML_ColorStyle::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_PolyStyle.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_PolyStyle.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_PolyStyle.h (revision 15068) @@ -0,0 +1,37 @@ +/*! \file KML_PolyStyle.h + * \brief: header file for kml_polystyle object + */ + +#ifndef _KML_POLYSTYLE_H_ +#define _KML_POLYSTYLE_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_ColorStyle.h" +/*}}}*/ + +class KML_PolyStyle: public KML_ColorStyle { + + public: + + int fill; + int outline; + + /*KML_PolyStyle constructors, destructors {{{*/ + KML_PolyStyle(); + ~KML_PolyStyle(); + /*}}}*/ + /*Object virtual functions definitions:{{{ */ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_POLYSTYLE_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Polygon.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Polygon.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Polygon.cpp (revision 15068) @@ -0,0 +1,294 @@ +/*!\file KML_Polygon.cpp + * \brief: implementation of the kml_polygon object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_LinearRing.h" +#include "./KMLFileReadUtils.h" +#include "./KML_Polygon.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Polygon::KML_Polygon(){{{*/ +KML_Polygon::KML_Polygon(){ + + extrude =false; + tessellate=false; + memcpy(altmode,"clampToGround",(strlen("clampToGround")+1)*sizeof(char)); + + outer =new DataSet; + inner =new DataSet; + +} +/*}}}*/ +/*FUNCTION KML_Polygon::~KML_Polygon(){{{*/ +KML_Polygon::~KML_Polygon(){ + + if (inner) { + delete inner; + inner =NULL; + } + + if (outer) { + delete outer; + outer =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Polygon::Echo {{{*/ +void KML_Polygon::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Polygon:"); + KML_Geometry::Echo(); + + if(flag) _pprintLine_(" extrude: " << (extrude ? "true" : "false")); + if(flag) _pprintLine_(" tessellate: " << (tessellate ? "true" : "false")); + if(flag) _pprintLine_(" altmode: \"" << altmode << "\""); + if(flag) _pprintLine_(" outer: (size=" << outer->Size() << ")"); + if(flag) _pprintLine_(" inner: (size=" << inner->Size() << ")"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Polygon::DeepEcho {{{*/ +void KML_Polygon::DeepEcho(){ + + char indent[81]=""; + + KML_Polygon::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Polygon::DeepEcho {{{*/ +void KML_Polygon::DeepEcho(const char* indent){ + + int i; + char indent2[81]; + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Polygon:"); + KML_Geometry::DeepEcho(indent); + + if(flag) _pprintLine_(indent << " extrude: " << (extrude ? "true" : "false")); + if(flag) _pprintLine_(indent << " tessellate: " << (tessellate ? "true" : "false")); + if(flag) _pprintLine_(indent << " altmode: \"" << altmode << "\""); + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + + if (outer->Size()) + for (i=0; iSize(); i++) { + if(flag) _pprintLine_(indent << " outer: -------- begin [" << i << "] --------"); + ((KML_LinearRing *)outer->GetObjectByOffset(i))->DeepEcho(indent2); + if(flag) _pprintLine_(indent << " outer: -------- end [" << i << "] --------"); + } + else + if(flag) _pprintLine_(indent << " outer: [empty]"); + + if (inner->Size()) + for (i=0; iSize(); i++) { + if(flag) _pprintLine_(indent << " inner: -------- begin [" << i << "] --------"); + ((KML_LinearRing *)inner->GetObjectByOffset(i))->DeepEcho(indent2); + if(flag) _pprintLine_(indent << " inner: -------- end [" << i << "] --------"); + } + else + if(flag) _pprintLine_(indent << " inner: [empty]"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Polygon::Write {{{*/ +void KML_Polygon::Write(FILE* filout,const char* indent){ + + int i; + char indent4[81]; + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_Geometry::Write(filout,indent); + + fprintf(filout,"%s %d\n",indent,(extrude ? 1 : 0)); + fprintf(filout,"%s %d\n",indent,(tessellate ? 1 : 0)); + fprintf(filout,"%s %s\n",indent,altmode); + + memcpy(indent4,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent4," "); + +/* check outer boundary for the polygon */ + + fprintf(filout,"%s \n",indent); + if (outer->Size()) + ((KML_LinearRing *)outer->GetObjectByOffset(0))->Write(filout,indent4); + fprintf(filout,"%s \n",indent); + +/* loop over any inner boundaries for the polygon */ + + for (i=0; iSize(); i++) { + fprintf(filout,"%s \n",indent); + ((KML_LinearRing *)inner->GetObjectByOffset(i))->Write(filout,indent4); + fprintf(filout,"%s \n",indent); + } + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Polygon::Read {{{*/ +void KML_Polygon::Read(FILE* fid,char* kstr){ + + char* kstri; + char* kstrj; + int ncom=0; + char** pcom=NULL; + KML_Object* kobj; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"")) + KMLFileTokenParse(&extrude , + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse(&tessellate, + kstri, + fid); + else if (!strcmp(kstri,"")) + KMLFileTokenParse( altmode ,NULL,KML_POLYGON_ALTMODE_LENGTH, + kstri, + fid); + + else if (!strcmp(kstri,"")) + +/* loop over and process fields within outer boundary */ + + while (kstrj=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstrj,"(kstrj); + break; + } + else if (!strncmp(kstrj,"Read(fid,kstrj); + outer ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstrj,"<",1)) + KML_Geometry::Read(fid,kstrj); + + xDelete(kstrj); + } + + else if (!strcmp(kstri,"")) + +/* loop over and process fields within inner boundaries */ + + while (kstrj=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstrj,"(kstrj); + break; + } + else if (!strncmp(kstrj,"Read(fid,kstrj); + inner ->AddObject((Object*)kobj); + } + + else if (!strncmp(kstrj,"<",1)) + KML_Geometry::Read(fid,kstrj); + + xDelete(kstrj); + } + + else if (!strncmp(kstri,"<",1)) + KML_Geometry::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ +/*FUNCTION KML_Polygon::WriteExp {{{*/ +void KML_Polygon::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){ + + int i; + char nstr2[81]; + +/* check outer boundary for the polygon */ + + if (outer->Size()) { + if (strlen(nstr)) + sprintf(nstr2,"%s (outer)",nstr); + else + sprintf(nstr2,"(outer)"); + + ((KML_LinearRing *)outer->GetObjectByOffset(0))->WriteExp(fid,nstr2,sgn,cm,sp); + } + +/* loop over any inner boundaries for the polygon */ + + for (i=0; iSize(); i++) { + if (strlen(nstr)) + sprintf(nstr2,"%s (inner %d of %d)",nstr,i+1,inner->Size()); + else + sprintf(nstr2,"(inner %d of %d)",i+1,inner->Size()); + + ((KML_LinearRing *)inner->GetObjectByOffset(i))->WriteExp(fid,nstr2,sgn,cm,sp); + } + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Polygon.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Polygon.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Polygon.h (revision 15068) @@ -0,0 +1,45 @@ +/*! \file KML_Polygon.h + * \brief: header file for kml_polygon object + */ + +#ifndef _KML_POLYGON_H_ +#define _KML_POLYGON_H_ + +#define KML_POLYGON_ALTMODE_LENGTH 18 + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Geometry.h" +class KML_LinearRing; +class DataSet; +/*}}}*/ + +class KML_Polygon: public KML_Geometry { + + public: + + bool extrude; + bool tessellate; + char altmode[KML_POLYGON_ALTMODE_LENGTH+1]; + DataSet* outer; + DataSet* inner; + + /*KML_Polygon constructors, destructors {{{*/ + KML_Polygon(); + ~KML_Polygon(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + void WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_POLYGON_H */ Index: /issm/trunk-jpl/src/c/kml/KML_Style.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Style.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Style.cpp (revision 15068) @@ -0,0 +1,237 @@ +/*!\file KML_Style.cpp + * \brief: implementation of the kml_style object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KMLFileReadUtils.h" +#include "./KML_LineStyle.h" +#include "./KML_PolyStyle.h" +#include "./KML_Style.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Style::KML_Style(){{{*/ +KML_Style::KML_Style(){ + + icon =NULL; + label =NULL; + line =NULL; + poly =NULL; + balloon =NULL; + list =NULL; + +} +/*}}}*/ +/*FUNCTION KML_Style::~KML_Style(){{{*/ +KML_Style::~KML_Style(){ + + if (list) { +// delete list; + list =NULL; + } + if (balloon) { +// delete balloon; + balloon =NULL; + } + if (poly) { + delete poly; + poly =NULL; + } + if (line) { + delete line; + line =NULL; + } + if (label) { +// delete label; + label =NULL; + } + if (icon) { +// delete icon; + icon =NULL; + } + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Style::Echo {{{*/ +void KML_Style::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Style:"); + KML_StyleSelector::Echo(); + + if(flag) _pprintLine_(" icon: " << icon); + if(flag) _pprintLine_(" label: " << label); + if(flag) _pprintLine_(" line: " << line); + if(flag) _pprintLine_(" poly: " << poly); + if(flag) _pprintLine_(" balloon: " << balloon); + if(flag) _pprintLine_(" list: " << list); + + return; +} +/*}}}*/ +/*FUNCTION KML_Style::DeepEcho {{{*/ +void KML_Style::DeepEcho(){ + + char indent[81]=""; + + KML_Style::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Style::DeepEcho {{{*/ +void KML_Style::DeepEcho(const char* indent){ + + char indent2[81]; + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Style:"); + KML_StyleSelector::DeepEcho(indent); + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + strcat(indent2," "); + +// if (icon) +// icon->DeepEcho(indent2); +// else + if(flag) _pprintLine_(indent << " icon: " << icon); +// if (label) +// label->DeepEcho(indent2); +// else + if(flag) _pprintLine_(indent << " label: " << label); + if (line) + line->DeepEcho(indent2); + else + if(flag) _pprintLine_(indent << " line: " << line); + if (poly) + poly->DeepEcho(indent2); + else + if(flag) _pprintLine_(indent << " poly: " << poly); +// if (balloon) +// balloon->DeepEcho(indent2); +// else + if(flag) _pprintLine_(indent << " balloon: " << balloon); +// if (list) +// list->DeepEcho(indent2); +// else + if(flag) _pprintLine_(indent << " list: " << list); + + return; +} +/*}}}*/ +/*FUNCTION KML_Style::Write {{{*/ +void KML_Style::Write(FILE* filout,const char* indent){ + + char indent2[81]; + + fprintf(filout,"%s\n"); + WriteCommnt(filout,indent); + + KML_StyleSelector::Write(filout,indent); + + memcpy(indent2,indent,(strlen(indent)+1)*sizeof(char)); + + strcat(indent2," "); + +// if (icon) +// icon->Write(filout,indent2); +// if (label) +// label->Write(filout,indent2); + if (line) + line->Write(filout,indent2); + if (poly) + poly->Write(filout,indent2); +// if (balloon) +// balloon->Write(filout,indent2); +// if (list) +// list->Write(filout,indent2); + + fprintf(filout,"%s\n",indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Style::Read {{{*/ +void KML_Style::Read(FILE* fid,char* kstr){ + + char* kstri; + int ncom=0; + char** pcom=NULL; + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { + if (!strncmp(kstri,"(kstri); + break; + } + else if (!strncmp(kstri,"Read(fid,kstri); +// } + +// else if (!strncmp(kstri,"Read(fid,kstri); +// } + + else if (!strncmp(kstri,"Read(fid,kstri); + } + + else if (!strncmp(kstri,"Read(fid,kstri); + } + +// else if (!strncmp(kstri,"Read(fid,kstri); +// } + +// else if (!strncmp(kstri,"Read(fid,kstri); +// } + + else if (!strncmp(kstri,"<",1)) + KML_StyleSelector::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Style.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Style.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Style.h (revision 15068) @@ -0,0 +1,43 @@ +/*! \file KML_Style.h + * \brief: header file for kml_style object + */ + +#ifndef _KML_STYLE_H_ +#define _KML_STYLE_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_StyleSelector.h" +class KML_LineStyle; +class KML_PolyStyle; +/*}}}*/ + +class KML_Style: public KML_StyleSelector { + + public: + + void* icon; + void* label; + KML_LineStyle* line; + KML_PolyStyle* poly; + void* balloon; + void* list; + + /*KML_Style constructors, destructors {{{*/ + KML_Style(); + ~KML_Style(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_STYLE_H */ Index: /issm/trunk-jpl/src/c/kml/KML_StyleSelector.cpp =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_StyleSelector.cpp (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_StyleSelector.cpp (revision 15068) @@ -0,0 +1,86 @@ +/*!\file KML_StyleSelector.cpp + * \brief: implementation of the kml_styleselector abstract object + */ + +/*Headers:*/ +/*{{{*/ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_Object.h" +#include "./KML_StyleSelector.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_StyleSelector::KML_StyleSelector(){{{*/ +KML_StyleSelector::KML_StyleSelector(){ + + ; + +} +/*}}}*/ +/*FUNCTION KML_StyleSelector::~KML_StyleSelector(){{{*/ +KML_StyleSelector::~KML_StyleSelector(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_StyleSelector::Echo {{{*/ +void KML_StyleSelector::Echo(){ + + KML_Object::Echo(); + + return; +} +/*}}}*/ +/*FUNCTION KML_StyleSelector::DeepEcho {{{*/ +void KML_StyleSelector::DeepEcho(){ + + char indent[81]=""; + + KML_StyleSelector::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_StyleSelector::DeepEcho {{{*/ +void KML_StyleSelector::DeepEcho(const char* indent){ + + KML_Object::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_StyleSelector::Write {{{*/ +void KML_StyleSelector::Write(FILE* filout,const char* indent){ + + KML_Object::Write(filout,indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_StyleSelector::Read {{{*/ +void KML_StyleSelector::Read(FILE* fid,char* kstr){ + +/* process field within opening and closing tags */ + + if (!strncmp(kstr," +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KML_SubStyle.h" +#include "./KML_Object.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_SubStyle::KML_SubStyle(){{{*/ +KML_SubStyle::KML_SubStyle(){ + + ; + +} +/*}}}*/ +/*FUNCTION KML_SubStyle::~KML_SubStyle(){{{*/ +KML_SubStyle::~KML_SubStyle(){ + + ; + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_SubStyle::Echo {{{*/ +void KML_SubStyle::Echo(){ + + KML_Object::Echo(); + + return; +} +/*}}}*/ +/*FUNCTION KML_SubStyle::DeepEcho {{{*/ +void KML_SubStyle::DeepEcho(){ + + char indent[81]=""; + + KML_SubStyle::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_SubStyle::DeepEcho {{{*/ +void KML_SubStyle::DeepEcho(const char* indent){ + + KML_Object::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_SubStyle::Write {{{*/ +void KML_SubStyle::Write(FILE* filout,const char* indent){ + + KML_Object::Write(filout,indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_SubStyle::Read {{{*/ +void KML_SubStyle::Read(FILE* fid,char* kstr){ + +/* process field within opening and closing tags */ + + if (!strncmp(kstr," +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./KMLFileReadUtils.h" +#include "./KML_Unknown.h" +#include "../shared/shared.h" +/*}}}*/ + +/*Constructors/destructor/copy*/ +/*FUNCTION KML_Unknown::KML_Unknown(){{{*/ +KML_Unknown::KML_Unknown(){ + + name =NULL; + value =NULL; + +} +/*}}}*/ +/*FUNCTION KML_Unknown::~KML_Unknown(){{{*/ +KML_Unknown::~KML_Unknown(){ + + if (name ) xDelete(name); + if (value ) xDelete(value); + +} +/*}}}*/ + +/*Other*/ +/*FUNCTION KML_Unknown::Echo {{{*/ +void KML_Unknown::Echo(){ + + bool flag=true; + + if(flag) _pprintLine_("KML_Unknown " << name << ":"); + KML_Object::Echo(); + + if (value ) + if(flag) _pprintLine_(" value: \"" << value << "\""); + else + if(flag) _pprintLine_(" value: [none]"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Unknown::DeepEcho {{{*/ +void KML_Unknown::DeepEcho(){ + + char indent[81]=""; + + KML_Unknown::DeepEcho(indent); + + return; +} +/*}}}*/ +/*FUNCTION KML_Unknown::DeepEcho {{{*/ +void KML_Unknown::DeepEcho(const char* indent){ + + char* valuei; + char* vtoken; + char nl[]={'\n','\0'}; + bool flag=true; + + if(flag) _pprintLine_(indent << "KML_Unknown " << name << ":"); + KML_Object::DeepEcho(indent); + + if (value ) { + valuei=xNew(strlen(value)+1); + memcpy(valuei,value,(strlen(value)+1)*sizeof(char)); + + vtoken=strtok(valuei,nl); + if(flag) _pprintString_(indent << " value: \"" << vtoken); + + while (vtoken=strtok(NULL,nl)) + if(flag) _pprintString_("\n" << indent << " " << vtoken); + if(flag) _pprintLine_("\""); + + xDelete(valuei); + } + else + if(flag) _pprintLine_(indent << " value: [none]"); + + return; +} +/*}}}*/ +/*FUNCTION KML_Unknown::Write {{{*/ +void KML_Unknown::Write(FILE* filout,const char* indent){ + + char* valuei; + char* vtoken; + char nl[]={'\n','\0'}; + + fprintf(filout,"%s<%s",indent,name); + WriteAttrib(filout," "); + fprintf(filout,">\n"); + WriteCommnt(filout,indent); + + if (value ) { + valuei=xNew(strlen(value)+1); + memcpy(valuei,value,(strlen(value)+1)*sizeof(char)); + + vtoken=strtok(valuei,nl); + fprintf(filout,"%s %s\n",indent,vtoken); + + while (vtoken=strtok(NULL,nl)) + fprintf(filout,"%s %s\n",indent,vtoken); + + xDelete(valuei); + } + + KML_Object::Write(filout,indent); + + fprintf(filout,"%s\n",indent,name); + + return; +} +/*}}}*/ +/*FUNCTION KML_Unknown::Read {{{*/ +void KML_Unknown::Read(FILE* fid,char* kstr){ + + char* kstri; + char* value2=NULL; + int ncom=0; + char** pcom=NULL; + char nl[]={'\n','\0'}; + +/* get object name */ + + name=KMLFileTagName(NULL, + kstr); +// _pprintLine_("KML_Unknown::Read -- opening name=" << name << "."); + +/* get object attributes and check for solo tag */ + + if (KMLFileTagAttrib(this, + kstr)) + return; + +/* loop over and process fields within opening and closing tags */ + + while (kstri=KMLFileToken(fid, + &ncom,&pcom)) { +// _pprintLine_("KML_Unknown::Read -- kstri=" << kstri << "."); + if (!strncmp(&kstri[0],"(kstri); + break; + } + else if (!strncmp(kstri,"(strlen(value)+1+strlen(kstri)+1); + memcpy(value2,value,(strlen(value)+1)*sizeof(char)); + xDelete(value); + value=value2; + value2=NULL; +// value=(char *) xrealloc(value,(strlen(value)+1+strlen(kstri)+1)*sizeof(char)); + strcat(value,nl); + strcat(value,kstri); + } + else { + value=xNew(strlen(kstri)+1); + memcpy(value,kstri,(strlen(kstri)+1)*sizeof(char)); + } + } + + else if (!strncmp(kstri,"<",1)) + KML_Object::Read(fid,kstri); + + xDelete(kstri); + } + + this->AddCommnt(ncom,pcom); + + for (ncom; ncom>0; ncom--) + xDelete(pcom[ncom-1]); + xDelete(pcom); + + return; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/kml/KML_Unknown.h =================================================================== --- /issm/trunk-jpl/src/c/kml/KML_Unknown.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/KML_Unknown.h (revision 15068) @@ -0,0 +1,37 @@ +/*! \file KML_Unknown.h + * \brief: header file for kml_unknown object + */ + +#ifndef _KML_UNKNOWN_H_ +#define _KML_UNKNOWN_H_ + +/*Headers:*/ +/*{{{*/ +#include "../shared/shared.h" +#include "./KML_Object.h" +/*}}}*/ + +class KML_Unknown: public KML_Object { + + public: + + char* name; + char* value; + + /*KML_Unknown constructors, destructors {{{*/ + KML_Unknown(); + ~KML_Unknown(); + /*}}}*/ + /*Object virtual functions definitions:{{{*/ + void Echo(); + void DeepEcho(); + void DeepEcho(const char* indent); + void Write(FILE* fid,const char* indent); + void Read(FILE* fid,char* kstr); + int Id(){_error_("Not implemented yet.");}; + int ObjectEnum(){_error_("Not implemented yet.");}; + Object* copy(){_error_("Not implemented yet.");}; + /*}}}*/ + +}; +#endif /* _KML_UNKNOWN_H */ Index: /issm/trunk-jpl/src/c/kml/kmlobjects.h =================================================================== --- /issm/trunk-jpl/src/c/kml/kmlobjects.h (revision 15068) +++ /issm/trunk-jpl/src/c/kml/kmlobjects.h (revision 15068) @@ -0,0 +1,37 @@ +/* \file kmlobjects.h + * \brief: prototype header for all kml related objects. + */ + +#ifndef KML_OBJECTS_H_ +#define KML_OBJECTS_H_ + +/*KML parsing objects: */ +#include "./KML_Attribute.h" +#include "./KML_Comment.h" +#include "./KML_ColorStyle.h" +#include "./KML_Container.h" +#include "./KML_Document.h" +#include "./KML_Feature.h" +#include "./KML_File.h" +#include "./KML_Folder.h" +#include "./KML_Geometry.h" +#include "./KML_GroundOverlay.h" +#include "./KML_Icon.h" +#include "./KML_LatLonBox.h" +#include "./KML_LinearRing.h" +#include "./KML_LineString.h" +#include "./KML_LineStyle.h" +#include "./KML_MultiGeometry.h" +#include "./KML_Object.h" +#include "./KML_Overlay.h" +#include "./KML_Point.h" +#include "./KML_Placemark.h" +#include "./KML_Polygon.h" +#include "./KML_PolyStyle.h" +#include "./KML_Style.h" +#include "./KML_StyleSelector.h" +#include "./KML_SubStyle.h" +#include "./KML_Unknown.h" +#include "./KMLFileReadUtils.h" + +#endif Index: /issm/trunk-jpl/src/c/modules/Exp2Kmlx/Exp2Kmlx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/Exp2Kmlx/Exp2Kmlx.cpp (revision 15067) +++ /issm/trunk-jpl/src/c/modules/Exp2Kmlx/Exp2Kmlx.cpp (revision 15068) @@ -5,4 +5,5 @@ #include "./Exp2Kmlx.h" #include "../../shared/shared.h" +#include "../../kml/kmlobjects.h" #include "../../toolkits/toolkits.h" #include "../Xy2llx/Xy2llx.h" Index: /issm/trunk-jpl/src/c/modules/KMLFileReadx/KMLFileReadx.h =================================================================== --- /issm/trunk-jpl/src/c/modules/KMLFileReadx/KMLFileReadx.h (revision 15067) +++ /issm/trunk-jpl/src/c/modules/KMLFileReadx/KMLFileReadx.h (revision 15068) @@ -7,5 +7,5 @@ #include /* DBL_MAX */ -#include "../../classes/classes.h" +#include "../../kml/kmlobjects.h" /* local prototypes: */ Index: /issm/trunk-jpl/src/c/modules/KMLMeshWritex/KMLMeshWritex.h =================================================================== --- /issm/trunk-jpl/src/c/modules/KMLMeshWritex/KMLMeshWritex.h (revision 15067) +++ /issm/trunk-jpl/src/c/modules/KMLMeshWritex/KMLMeshWritex.h (revision 15068) @@ -7,5 +7,5 @@ #include /* DBL_MAX */ -#include "../../classes/classes.h" +#include "../../kml/kmlobjects.h" /* local prototypes: */ Index: /issm/trunk-jpl/src/c/modules/KMLOverlayx/KMLOverlayx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/KMLOverlayx/KMLOverlayx.cpp (revision 15067) +++ /issm/trunk-jpl/src/c/modules/KMLOverlayx/KMLOverlayx.cpp (revision 15068) @@ -5,4 +5,5 @@ #include "../../shared/shared.h" #include "../../toolkits/toolkits.h" +#include "../../kml/kmlobjects.h" void KMLOverlayx(int* ierror,