root/FalconView/trunk/public/fvw_core/GeodataDataSources/LibkmlDataSource.h @ 2279

// 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.

// LibkmlDataSource.h : Declaration of the CLibkmlDataSource

#pragma once
#include "resource.h"       // main symbols
#include "ComErrorHandler.h"
//#include "GeodataDataSources.h"
#include "kml/dom.h"
#include "kml/engine.h"
#include "InternalObjectRegistry.h"
#include "ComErrorObject.h"

#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA)
#error "Single-threaded COM objects are not properly supported on Windows CE platform, such as the Windows Mobile platforms that do not include full DCOM support. Define _CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA to force ATL to support creating single-thread COM object's and allow use of it's single-threaded COM object implementations. The threading model in your rgs file was set to 'Free' as that is the only threading model supported in non DCOM Windows CE platforms."
#endif


class CKMLImageDataResource;

class CKmlImageCache
{
   std::map<std::string, CKMLImageDataResource*> m_imageCache;
   
public:
   void Insert(const std::string& imageId, CKMLImageDataResource *pResource);
   CKMLImageDataResource* Find(const std::string& imageId);
   void Clear();
};

// CLibkmlDataSource

class ATL_NO_VTABLE CLibkmlDataSource :
    public CComObjectRootEx<CComSingleThreadModel>,
    public CComCoClass<CLibkmlDataSource, &CLSID_LibkmlDataSource>,
    public IDispatchImpl<ILibkmlDataSource, &IID_ILibkmlDataSource, &LIBID_GeodataDataSourcesLib, /*wMajor =*/ 1, /*wMinor =*/ 0>,
    public IDispatchImpl<IRegionatedKMLContainer, &IID_IRegionatedKMLContainer, &LIBID_GeodataDataSourcesLib, /*wMajor =*/ 1, /*wMinor =*/ 0>,
   public IDispatchImpl<IFileDataSource, &__uuidof(IFileDataSource), &LIBID_FvDataSourcesLib, /* wMajor = */ 1, /* wMinor = */ 0>,
   public IDispatchImpl<IFvDataSource, &__uuidof(IFvDataSource), &LIBID_FvDataSourcesLib, /* wMajor = */ 1, /* wMinor = */ 0>,
   public IDispatchImpl<ISymbolFactory, &__uuidof(ISymbolFactory), &LIBID_FvDataSourcesLib, /* wMajor = */ 1, /* wMinor = */ 0>,
   public IDispatchImpl<IFvDataSourceEdit, &__uuidof(IFvDataSourceEdit), &LIBID_FvDataSourcesLib, /* wMajor = */ 1, /* wMinor = */ 0>,
   public IDispatchImpl<IUIState, &__uuidof(IUIState), &LIBID_FvDataSourcesLib, /* wMajor = */ 1, /* wMinor = */ 0>,
   public IDispatchImpl<IFvDataSourceCallback, &__uuidof(IUIState), &LIBID_FvDataSourcesLib, /* wMajor = */ 1, /* wMinor = */ 0>,
   public CComErrorHandler
{
public:
   CLibkmlDataSource() : m_root_element(NULL), m_internalRefs(0), m_factory(NULL), m_b_objectFinalReleased(false),
      m_visible(VARIANT_TRUE), m_expanded(VARIANT_TRUE) {}

   ULONG InternalRefCount() { return m_internalRefs; }

   void __ensure_not_released()
   {
      // for debugging only
      if (m_b_objectFinalReleased)
         THROW_ERROR_MSG2(E_FAIL, "object already released");
   }

DECLARE_REGISTRY_RESOURCEID(IDR_LIBKMLDATASOURCE)

BEGIN_COM_MAP(CLibkmlDataSource)
    COM_INTERFACE_ENTRY(ILibkmlDataSource)
    COM_INTERFACE_ENTRY2(IDispatch, IFileDataSource)
   COM_INTERFACE_ENTRY(IFileDataSource)
   COM_INTERFACE_ENTRY(IFvDataSource)
    COM_INTERFACE_ENTRY(ISupportErrorInfo)
   COM_INTERFACE_ENTRY(IFvDataSourceEdit)
    COM_INTERFACE_ENTRY(ISymbolFactory)
   COM_INTERFACE_ENTRY(IRegionatedKMLContainer)
    COM_INTERFACE_ENTRY(IUIState)
   COM_INTERFACE_ENTRY(IFvDataSourceCallback)
END_COM_MAP()

    DECLARE_PROTECT_FINAL_CONSTRUCT()

    HRESULT FinalConstruct()
    {
      __ensure_not_released();
      // register this object
      m_handle = CInternalObjectRegistry::RegisterObject(this, "CLibkmlDataSource");
        return S_OK;
    }

    void FinalRelease()
    {
      __ensure_not_released();
      CInternalObjectRegistry::UnregisterObject(m_handle);
      m_b_objectFinalReleased = true;

      m_imageCache.Clear();
    }

   ULONG InternalAddRef()
   {
      ULONG refCountAfterAdd = CComObjectRootEx<_ThreadModel>::InternalAddRef();
      return refCountAfterAdd;
   }

   ULONG InternalRelease()
   {
      // see comments in InternalRefAdding implementation
      ULONG refCountAfterRelease = CComObjectRootEx<_ThreadModel>::InternalRelease();
      if (refCountAfterRelease <= m_internalRefs)
         m_root_element = NULL;
      return refCountAfterRelease;
   }

   HRESULT WINAPI InternalQueryInterface(void* pThis, const _ATL_INTMAP_ENTRY* pEntries, REFIID iid, void** ppvObject)
   {
      return CComObjectRootBase::InternalQueryInterface(pThis, pEntries, iid, ppvObject);
   }

public:
   static IUnknown* WrapKMLElement(kmldom::ElementPtr element, kmlengine::KmlFilePtr kml_file, ILibkmlDataSource* rootDS);
   static kmldom::GeometryPtr WrapGeometryInGeometry(IGeometry* geometry, kmldom::KmlFactory* factory);
   static kmldom::PlacemarkPtr WrapFeatureInPlacemark(IFeature* feature, kmldom::KmlFactory* factory);

   static void FireDataSourceChanged(LONG sourceHandle);

   void FetchDataRelativeToDataSource(const char* path, std::string& out_string);
   kmlengine::KmlFilePtr LoadKML(std::string &kml, const char* path);
   void WrapKMLFile(const kmlengine::KmlFilePtr& kml_file);

   void SetKmlFilePath(const std::string& path) { m_kml_file_path = path; }

   // ILibkmlDataSource Methods
public:
   STDMETHOD(raw_InternalRefAdding)();
   STDMETHOD(raw_InternalRefReleasing)();
   STDMETHOD(raw_OpenFromURL)(BSTR url);
   STDMETHOD(get_Handle)(LONG* handle);
   STDMETHOD(get_URL)(BSTR* url);

   // IFileDataSource Methods
public:
   STDMETHOD(raw_Open)(BSTR file);
   STDMETHOD(raw_CheckFile)(BSTR path, VARIANT_BOOL confirmFileExists, VARIANT_BOOL* valid);
   STDMETHOD(raw_CloseFile)();
   STDMETHOD(raw_CreateNewFile)(BSTR file);

   // IFvDataSource Methods
public:
   STDMETHOD(get_DataSetCount)(LONG* count);
   STDMETHOD(raw_GetDataSet)(LONG index, IFvDataSet** dataSet);
   STDMETHOD(get_Name)(BSTR* name);
   STDMETHOD(raw_GetDataSetByName)(BSTR name, IFvDataSet** dataSet);
   STDMETHOD(get_DataSourceCount)(LONG* count);
   STDMETHOD(raw_GetDataSource)(LONG index, IFvDataSource** dataSource);
   STDMETHOD(raw_GetDataSourceByName)(BSTR name, IFvDataSource** dataSource);
   STDMETHOD(raw_Extent2D)(double* minX, double* minY, double* maxX, double* maxY);
   STDMETHOD(get_Description)(BSTR* description);
   STDMETHOD(raw_RegisterForCallbacks)(IFvDataSourceCallback* fvDataSourceCallback);
   STDMETHOD(raw_UnregisterForCallbacks)(IFvDataSourceCallback* fvDataSourceCallback);
   STDMETHOD(raw_CheckConnectString)(BSTR connectString, VARIANT_BOOL* valid);

   // ISymbolFactory Methods
public:
   STDMETHOD(raw_GetImageByIdentifier)(BSTR identifier, VARIANT* imageData);

   // IFvDataSourceCallback Methods
public:
   STDMETHOD(raw_DataSourceChanged)();

   // IFvDataSourceEdit Methods
public:
    STDMETHOD(raw_StartEditing)();
    STDMETHOD(raw_CreateEmptyFeatureDataSet)(BSTR name, BSTR description, IFeatureDataSetEdit** dataSetEdit);
    STDMETHOD(raw_CopyDataSource)(IFvDataSource *dataSource);
    STDMETHOD(raw_FinishEditing)();

   // IRegionatedKMLContainer Methods
public:
    STDMETHOD(raw_SetRegionationParameters)(
      DOUBLE leftLon, DOUBLE bottomLat, DOUBLE rightLon, DOUBLE topLat,
      DOUBLE degreesPerPixelX, DOUBLE degreesPerPixelY);

   // IUIState Methods
public:
   STDMETHOD(get_Visible)(VARIANT_BOOL *visible);
   STDMETHOD(put_Visible)(VARIANT_BOOL visible);
   STDMETHOD(get_Expanded)(VARIANT_BOOL *expanded);
   STDMETHOD(put_Expanded)(VARIANT_BOOL expanded);

private:
   std::string SanitizeKMLString(std::string in_string);

   LONG m_handle;
   IFvDataSourcePtr m_root_element;
   std::string m_kml_file_path; // this may be a file path our a URL, may be NULL if KMZ
   kmlengine::KmzFilePtr m_kmz_file; // populate this if KMZ
   ULONG m_internalRefs;
   CKmlImageCache m_imageCache;
   DATA_SOURCE_CALLBACK_VECTOR m_callbacks;
   bool m_b_objectFinalReleased;
   VARIANT_BOOL m_visible, m_expanded;

   // stuff related to KML edit sessions
   kmldom::KmlFactory* m_factory; // NULL if not in an editing session
   kmldom::DocumentPtr m_document_being_edited; // the <Document> being edited
   std::string m_editing_file_name;
   void CopyDataSourceToDocument(IFvDataSource* dataSource, kmldom::DocumentPtr document);

   // stuff for Easter egg to dump raw KML for problem solving
   static BOOL s_bEnvironmentTested;
   static std::string s_dumpFile;
   static void MaybeDumpKML(std::string& kml);
};

OBJECT_ENTRY_AUTO(__uuidof(LibkmlDataSource), CLibkmlDataSource)