root/FalconView/trunk/public/fvw_core/WMSMapSetup/WMSDescriptor.cpp @ 2220

#include "StdAfx.h"
#include "WMSDescriptor.h"
#include "..\Common\ComErrorObject.h"

WMSDescriptor::WMSDescriptor(void)
{
}

WMSDescriptor::~WMSDescriptor(void)
{
}

bool WMSDescriptor::WriteVariant(std::string Path, VARIANT v)
{


   std::istringstream iss(Path);
   std::string token;

   getline(iss, token, '/');
   MSXML6::IXMLDOMNodePtr pNode = spElement->selectSingleNode(_bstr_t(token.c_str()));
   if (!pNode)
   {
      MSXML6::IXMLDOMElementPtr pNextNode = spXMLDOMDocument->createElement(_bstr_t(token.c_str())); //Create first child element
      pNode = spElement->appendChild(pNextNode);
   }


   while(getline(iss, token, '/'))
   {
      MSXML6::IXMLDOMNodePtr pNextNode = pNode->selectSingleNode(_bstr_t(token.c_str()));
      if (!pNextNode)
      {
         MSXML6::IXMLDOMElementPtr pNextNode = spXMLDOMDocument->createElement(_bstr_t(token.c_str())); //Create first child element
         pNode = pNode->appendChild(pNextNode);
      }
      else
      {
         pNode = pNextNode;
      }
   }
   HRESULT hr = pNode->put_nodeTypedValue(v);
   return (S_OK == hr);

}


// Read the GDAL XML description of a WMS Server
int WMSDescriptor::ReadXML(std::string FileName)
{

   CO_CREATE(spXMLDOMDocument, __uuidof(MSXML6::DOMDocument60));

    try
    {
        spXMLDOMDocument->async = VARIANT_FALSE;
        //pXMLDom->validateOnParse = VARIANT_FALSE;
        spXMLDOMDocument->resolveExternals = VARIANT_FALSE;
        if(spXMLDOMDocument->load(FileName.c_str()) == VARIANT_TRUE)
        {
           spElement = spXMLDOMDocument->GetdocumentElement();
           if (!spElement)
           {
              return -1;
           }
            m_UpperLeftX   = ReadDoubleValue(L"DataWindow/UpperLeftX",-180.0);
            m_UpperLeftY   = ReadDoubleValue(L"DataWindow/UpperLeftY",90.0);
            m_LowerRightX  = ReadDoubleValue(L"DataWindow/LowerRightX",180.0);
            m_LowerRightY  = ReadDoubleValue(L"DataWindow/LowerRightY",-90.0);
            m_TileLevel    = ReadIntValue(L"DataWindow/TileLevel",0);
            m_TileCountX   = ReadIntValue(L"DataWindow/TileCountX",0);
            m_TileCountY   = ReadIntValue(L"DataWindow/TileCountY",0);
            m_TileSizeX    = ReadIntValue(L"BlockSizeX",1024);
            m_TileSizeY    = ReadIntValue(L"BlockSizeY",1024);
            m_OverviewCount= ReadIntValue(L"OverViewCount");
            m_lImageSizeX  = ReadIntValue(L"DataWindow/SizeX"); 
            m_lImageSizeY  = ReadIntValue(L"DataWindow/SizeY");
 
            m_ServerType   = ReadAttribute(L"Service",L"name");            
            m_ServerURL    = ReadStringValue(L"Service/ServerUrl");           
            m_CachePath    = ReadStringValue(L"Cache/Path",L"");

            if (0==m_ServerType.compare("TMS"))
            {
               m_ImageFormat  = ReadStringValue(L"Service/Format",L"jpg");
               m_Version      = ReadStringValue(L"Service/Version",L"1.0.0");
               m_Layers    = ReadStringValue(L"Service/Layer");
            }
            else
            {
               m_ImageFormat  = ReadStringValue(L"Service/ImageFormat",L"image/jpeg");
               m_Version      = ReadStringValue(L"Service/Version",L"1.1.1");
               if (0==m_ServerType.compare("WMS"))
               {
                  m_Layers    = ReadStringValue(L"Service/Layers");
                  if (0==m_Version.compare("1.1.1"))
                  {
                     m_SRS          = ReadStringValue(L"Service/SRS",L"EPSG:4326"); 
                  }
                  else
                  {
                     m_SRS          = ReadStringValue(L"Service/CRS",L"CRS:83");
                  }
               }
            }
            m_Projection   = ReadStringValue(L"Projection",L"EPSG:4326");


        }
        else
        {
            // Failed to load xml
           std::string msg;
           msg = std::string("Failed to load ") + FileName; 
           msg +=std::string(spXMLDOMDocument->parseError->Getreason());
           THROW_ERROR_MSG2(E_FAIL,msg.c_str());
           return -1;
        }
    }
    catch(_com_error errorObject)
    {
        ATLTRACE("Exception thrown, HRESULT: 0x%08x", errorObject.Error());
        return -1;
    }
   return 0;
}



// Write the DOM to the specified XML file
HRESULT WMSDescriptor::WriteXML(std::string FileName)
{
   if (!spElement)
   {
      return E_FAIL;
   }
   WriteDoubleValue(std::string("DataWindow/UpperLeftX"),m_UpperLeftX);
   WriteDoubleValue(std::string("DataWindow/UpperLeftY"),m_UpperLeftY);
   WriteDoubleValue(std::string("DataWindow/LowerRightX"),m_LowerRightX);
   WriteDoubleValue(std::string("DataWindow/LowerRightY"),m_LowerRightY);
   if (m_TileLevel)WriteIntValue(std::string("DataWindow/TileLevel"),m_TileLevel);
   if (m_TileCountX) WriteIntValue(std::string("DataWindow/TileCountX"),m_TileCountX);
   if (m_TileCountY) WriteIntValue(std::string("DataWindow/TileCountY"),m_TileCountY);
   WriteIntValue(std::string("BlockSizeX"),m_TileSizeX);
   WriteIntValue(std::string("BlockSizeY"),m_TileSizeY);
   if (m_OverviewCount) WriteIntValue(std::string("OverViewCount"),m_OverviewCount);
   if(m_lImageSizeX) WriteIntValue(std::string("DataWindow/SizeX"),m_lImageSizeX); 
   if(m_lImageSizeY) WriteIntValue(std::string("DataWindow/SizeY"),m_lImageSizeY);
   WriteAttribute(std::string("Service"),std::string("name"),m_ServerType);            
   WriteStringValue(std::string("Service/ServerUrl"),m_ServerURL);

   if(0!=m_CachePath.compare(std::string(""))) WriteStringValue(std::string("Cache/Path"),m_CachePath);

   WriteStringValue(std::string("Projection"),m_Projection);
   if (0==m_ServerType.compare(std::string("TMS")))
   {
      if (0!=m_Layers.compare(std::string("")))
      {
         WriteStringValue(std::string("Service/Layer"),m_Layers);
      }
      WriteStringValue(std::string("Service/Format"),m_ImageFormat);
      WriteStringValue(std::string("Service/Version"),m_Version);   
   }
   else
   {
      WriteStringValue(std::string("Service/ImageFormat"),m_ImageFormat);
      WriteStringValue(std::string("Service/Version"),m_Version);
      if (0==m_ServerType.compare(std::string("WMS")))
      {
         if (0!=m_Layers.compare(std::string("")))
         {
            WriteStringValue(std::string("Service/Layers"),m_Layers);
         }
         if (0==m_Version.compare(std::string("1.1.1")))
         {
            WriteStringValue(std::string("Service/SRS"),m_SRS);     
         }
         else
         {
            WriteStringValue(std::string("Service/CRS"),m_SRS); 
         }
      }
   }

   return spXMLDOMDocument->save(FileName.c_str());

}