root/FalconView/trunk/public/fvw_core/GeodataDataSources/LibkmlNetworkLink.cpp @ 2267

// Copyright (c) 1994-2010 Georgia Tech Research Corporation, Atlanta, GA
// This file is part of FalconView(tm).

// FalconView(tm) is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// FalconView(tm) is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License
// along with FalconView(tm).  If not, see <http://www.gnu.org/licenses/>.

// FalconView(tm) is a trademark of Georgia Tech Research Corporation.

// LibkmlNetworkLink.cpp : Implementation of CLibkmlNetworkLink

#include "stdafx.h"
#include "LibkmlNetworkLink.h"
#include "UtilityMethods.h"
#include "LibkmlDataSource.h"
#include "ComErrorObject.h"

// CLibkmlNetworkLink

STDMETHODIMP CLibkmlNetworkLink::get_DataSetCount(LONG* count)
{
   try
   {
      PopulateWrappedDataSourceAsNecessary();
      if (m_wrappedDataSource)
         return m_wrappedDataSource->get_DataSetCount(count);
   }
   catch (...)
   {
      // There is a lot of bad KML out there.  Google Earth ignores it silently.
      // Returning zero here and just logging the problem keeps FalconView from halting
      // the KML loading process.  PopulateWrappedDataSourceAsNecessary() will
      // throw up failed assert messages in debug mode.
      std::string msg("failed to get data set count (something is wrong with this KML?) - returning count of zero");
      CUtilityMethods::WriteStringToFVErrorLog(msg);
   }

   *count = 0;
   return S_OK;
}

STDMETHODIMP CLibkmlNetworkLink::raw_GetDataSet(LONG index, IFvDataSet** dataSet)
{
   TRY_BLOCK
   {
      PopulateWrappedDataSourceAsNecessary();
      if (m_wrappedDataSource)
         return m_wrappedDataSource->raw_GetDataSet(index, dataSet);
      return E_FAIL;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::get_Name(BSTR* name)
{
   TRY_BLOCK
   {
      if (m_networkLink->has_name())
      {
         *name = _bstr_t(m_networkLink->get_name().c_str()).Detach();
      }
      else
      {
         PopulateWrappedDataSourceAsNecessary();
         if (m_wrappedDataSource)
            return m_wrappedDataSource->get_Name(name);
         *name = _bstr_t("<NetworkLink>").Detach();
      }

      return S_OK;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::raw_GetDataSetByName(BSTR name, IFvDataSet** dataSet)
{
   TRY_BLOCK
   {
      PopulateWrappedDataSourceAsNecessary();
      if (m_wrappedDataSource)
         return m_wrappedDataSource->raw_GetDataSetByName(name, dataSet);
      return E_FAIL;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::get_DataSourceCount(LONG* count)
{
   try
   {
      PopulateWrappedDataSourceAsNecessary();
      if (m_wrappedDataSource)
         return m_wrappedDataSource->get_DataSourceCount(count);
   }
   catch (...)
   {
      // There is a lot of bad KML out there.  Google Earth ignores it silently.
      // Returning zero here and just logging the problem keeps FalconView from halting
      // the KML loading process.  PopulateWrappedDataSourceAsNecessary() will
      // throw up failed assert messages in debug mode.
      std::string msg("failed to get data source count (something is wrong with this KML?) - returning count of zero");
      CUtilityMethods::WriteStringToFVErrorLog(msg);
   }

   *count = 0;
   return S_OK;
}

STDMETHODIMP CLibkmlNetworkLink::raw_GetDataSource(LONG index, IFvDataSource** dataSource)
{
   TRY_BLOCK
   {
      PopulateWrappedDataSourceAsNecessary();
      if (m_wrappedDataSource)
         return m_wrappedDataSource->raw_GetDataSource(index, dataSource);
      return E_FAIL;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::raw_GetDataSourceByName(BSTR name, IFvDataSource** dataSource)
{
   TRY_BLOCK
   {
      PopulateWrappedDataSourceAsNecessary();
      if (m_wrappedDataSource)
         return m_wrappedDataSource->raw_GetDataSourceByName(name, dataSource);
      return E_FAIL;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::get_Handle(LONG* handle)
{
   *handle = m_handle;
   return S_OK;
}

STDMETHODIMP CLibkmlNetworkLink::raw_GetImageByIdentifier(BSTR identifier, VARIANT* imageData)
{
   TRY_BLOCK
   {
      PopulateWrappedDataSourceAsNecessary();

      if (m_wrappedDataSource)
      {
         ISymbolFactoryPtr symbolFactory = m_wrappedDataSource;
         if (symbolFactory)
            return symbolFactory->raw_GetImageByIdentifier(identifier, imageData);
      }

      ISymbolFactoryPtr symbol_factory = m_rootDS;
      return symbol_factory->raw_GetImageByIdentifier(identifier, imageData);
   }
   CATCH_BLOCK_RET
}

void CLibkmlNetworkLink::AssociateWithLibkmlNetworkLink(kmldom::NetworkLinkPtr networkLink, ILibkmlDataSource* rootDS)
{
   rootDS->InternalRefAdding(); // see comments in InternalRefAdding implementation
   m_rootDS = rootDS;
   m_networkLink = networkLink;
}

void CLibkmlNetworkLink::PopulateWrappedDataSourceAsNecessary()
{
   // call from within a TRY_BLOCK

   // This object lightly wraps a data source that is opened from the network link.  If there is no data source opened from the network link,
   // this object just returns whatever may be on the <NetworkLink> element that it represents.

   try
   {
      if (!m_wrappedDataSource && m_networkLink->has_link())
      {
         // If the regionation parameters have been set and the feature is active,
         // then we'll skip it.  Note that, if the regionation parameters have not been set
         // then an element is not considered active in this case.  (If the network link does not
         // have a <Region> tag, it is loaded regardless.)

         // if the given feature does not have a region, then find the youngest ancestor that does
         kmldom::FeaturePtr feature = kmldom::AsFeature(m_networkLink);
         while (feature != NULL && feature->has_region() == false)
            feature = kmldom::AsFeature(CUtilityMethods::GetAncestorOfType(feature, kmldom::Type_Feature));

         if ( feature == NULL // feature is null if not regionated
              || (m_degreesPerPixelX >= 0 && m_degreesPerPixelY >= 0
                  && CUtilityMethods::KMLFeatureInRegion(m_networkLink, m_leftLon,
                                                         m_bottomLat, m_rightLon, m_topLat,
                                                         m_degreesPerPixelX, m_degreesPerPixelY)))
         {
            // get the base URL
            IFvDataSourcePtr dataSource(CLSID_LibkmlDataSource);
            ILibkmlDataSourcePtr libkmlDataSource = dataSource;
            kmldom::LinkPtr link = m_networkLink->get_link();
            std::string url = CUtilityMethods::ResolveURI((char*)m_rootDS->URL, (char*)link->get_href().c_str());

            // if the link has a <viewFormat> tag, honor it
            if (CUtilityMethods::LooksLikeHttp(url.c_str()) && link->has_viewformat())
            {
               // JVO TODO: test across antemeridian, on rotated map

               std::string viewformat = link->get_viewformat();

               const size_t SIZE = 30;
               char buf[SIZE];

               sprintf_s(buf, SIZE, "%f", (m_rightLon - m_leftLon) / 2);
               CUtilityMethods::ReplaceAllInString(viewformat, "[lookatLon]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[lookatTerrainLon]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[cameraLon]", buf);

               sprintf_s(buf, SIZE, "%f", (m_topLat - m_bottomLat) / 2);
               CUtilityMethods::ReplaceAllInString(viewformat, "[lookatLat]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[lookatTerrainLat]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[cameraLat]", buf);

               sprintf_s(buf, SIZE, "%f", m_leftLon);
               CUtilityMethods::ReplaceAllInString(viewformat, "[bboxWest]", buf);

               sprintf_s(buf, SIZE, "%f", m_bottomLat);
               CUtilityMethods::ReplaceAllInString(viewformat, "[bboxSouth]", buf);

               sprintf_s(buf, SIZE, "%f", m_rightLon);
               CUtilityMethods::ReplaceAllInString(viewformat, "[bboxEast]", buf);

               sprintf_s(buf, SIZE, "%f", m_topLat);
               CUtilityMethods::ReplaceAllInString(viewformat, "[bboxNorth]", buf);

               // elements below set to "0" (zero)
               buf[0] = '0';
               buf[1] = 0;
               CUtilityMethods::ReplaceAllInString(viewformat, "[lookatRange]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[lookatTilt]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[lookatHeading]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[lookatTerrainAlt]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[cameraAlt]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[horizFov]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[vertFov]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[horizPixels]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[vertPixels]", buf);
               CUtilityMethods::ReplaceAllInString(viewformat, "[terrainEnabled]", buf);

               // append the view format string
               if (url.at(url.length() - 1) != '&')
                  url.append("&");
               url.append(viewformat);
            }

            // populate the data source from the URL
            long handle = libkmlDataSource->GetHandle();
            CLibkmlDataSource* ds = (CLibkmlDataSource*)CInternalObjectRegistry::GetObject(handle);
            std::string kml_data;
            ds->FetchDataRelativeToDataSource(url.c_str(), kml_data);
            ds->LoadKML(kml_data, url.c_str());

            m_wrappedDataSource = dataSource.Detach();

            // register for callbacks on the wrapped data source so that changes notices get fired to anything registered
            // for callbacks on the root data source
            dataSource = libkmlDataSource; // reassociate the smart pointer after Detach()
            dataSource->RegisterForCallbacks(this);

            // indicate to the root data source that something has changed
            if (!m_bFirstAttemptToLoad)
               CLibkmlDataSource::FireDataSourceChanged(m_rootDS->Handle);
         }
      }
   }
   catch (...)
   {
      m_wrappedDataSource = NULL;
      THROW_ERROR_MSG2(E_FAIL, "exception in CLibkmlNetworkLink::PopulateWrappedDataSourceAsNecessary()");
   }

   m_bFirstAttemptToLoad = FALSE;
}

STDMETHODIMP CLibkmlNetworkLink::raw_Extent2D(double* minX, double* minY, double* maxX, double* maxY)
{
   TRY_BLOCK
   {
      PopulateWrappedDataSourceAsNecessary();
      if (m_wrappedDataSource)
         return m_wrappedDataSource->raw_Extent2D(minX, minY, maxX, maxY);
      return E_FAIL;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::get_Description(BSTR* description)
{
   TRY_BLOCK
   {
      if (m_networkLink->has_description())
      {
         *description = _bstr_t(m_networkLink->get_description().c_str()).Detach();
      }
      else
      {
         PopulateWrappedDataSourceAsNecessary();
         if (m_wrappedDataSource)
            return m_wrappedDataSource->get_Description(description);
         *description = _bstr_t("A KML <NetworkLink>.").Detach();
      }

      return S_OK;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::raw_RegisterForCallbacks(IFvDataSourceCallback* fvDataSourceCallback)
{
   TRY_BLOCK
   {
      IFvDataSourcePtr rootDS = m_rootDS;
      return rootDS->RegisterForCallbacks(fvDataSourceCallback);;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::raw_UnregisterForCallbacks(IFvDataSourceCallback* fvDataSourceCallback)
{
   TRY_BLOCK
   {
      IFvDataSourcePtr rootDS = m_rootDS;
      return rootDS->UnregisterForCallbacks(fvDataSourceCallback);;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::raw_SetRegionationParameters(
   DOUBLE leftLon, DOUBLE bottomLat, DOUBLE rightLon, DOUBLE topLat,
   DOUBLE degreesPerPixelX, DOUBLE degreesPerPixelY)
{
   TRY_BLOCK
   {
      // save the parameters
      m_leftLon = leftLon;
      m_bottomLat = bottomLat;
      m_rightLon = rightLon;
      m_topLat = topLat;
      m_degreesPerPixelX = degreesPerPixelX;
      m_degreesPerPixelY = degreesPerPixelY;

      // repopulate the wrapped data source (this may fire a data source changed notification)
      PopulateWrappedDataSourceAsNecessary();

      // pass the parameters on to any wrapped data source
      IRegionatedKMLContainerPtr regionatedKMLContainer = m_wrappedDataSource;
      if (regionatedKMLContainer)
         regionatedKMLContainer->SetRegionationParameters(leftLon, bottomLat, rightLon, topLat, degreesPerPixelX, degreesPerPixelY);

      return S_OK;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP CLibkmlNetworkLink::raw_DataSourceChanged()
{
   CLibkmlDataSource::FireDataSourceChanged(m_rootDS->Handle);
   return S_OK;
}

STDMETHODIMP CLibkmlNetworkLink::raw_CheckConnectString(BSTR connectString, VARIANT_BOOL* valid)
{
   return E_NOTIMPL;
}

STDMETHODIMP CLibkmlNetworkLink::get_Visible(VARIANT_BOOL *visible)
{
   *visible = m_visible;
   return S_OK;
}

STDMETHODIMP CLibkmlNetworkLink::put_Visible(VARIANT_BOOL visible)
{
   m_visible = visible;
   return S_OK;
}

STDMETHODIMP CLibkmlNetworkLink::get_Expanded(VARIANT_BOOL *expanded)
{
   *expanded = m_expanded;
   return S_OK;
}

STDMETHODIMP CLibkmlNetworkLink::put_Expanded(VARIANT_BOOL expanded)
{
   m_expanded = expanded;
   return S_OK;
}