//-----------------------------------------------------------------------------
// NMGR_CClientDataExtractor.h
//
//
//  This header containes the template implementation of T_DataExtractor.
//
//  The name of this header will be changing!!!!!!
//
//
//
//
//
//  Copyright (c) 1997-1999 Microsoft Corporation
//-----------------------------------------------------------------------------

#if !defined(__CClientDataExtractor_h)
#define      __CClientDataExtractor_h

#include "SimpleArray.h"

//-----------------------------------------------------------------------------
// template T_DataExtractor
//
//
//  This template class allows you to act as if a pointer to an IDataObject 
//  is the clipboard format that you are trying to extract from the IDataObject.
//  What????
//
//  Ok.  Given that any IDataObject exposes one of more CCF_'s (Clip board formats)
//  you want to ask the IDataObject for a specific CCF_.  Using this template
//  allows you to "auto-magically" handle both the asking of the question
//  "Does this data object support this CCF_?" and the subsequent extraction of 
//  particular clip board format.
//
//  Syntax:
//  
//      T_DataExtractor<__type,CCF_> data;
//  
//  __type  is the actual type of data you hope to extract from the IDataObject
//  CCF_    is the registered clip board format for the given type that you want
//          to extract.
//
//   
//    Examples:  
//      int       :  T_DataExtractor<int,     CCF_INT>          iMyInt;
//      CClass *  :  T_DataExtractor<CClass*, CCF_CCLASSPTR>    pMyClass;
//
//                             

template<typename TNData,const wchar_t* pClipFormat>
class T_DataExtractor
{
    private:
        typedef CSimpleArray<HGLOBAL> HGlobVector;

        IDataObject *       m_pDataObject;      // Wrapped Data Object
        HGlobVector         m_MemoryHandles;    // Memory Allocated

        TNData *            m_pData;            // "Cached" Value

        static UINT         m_nClipFormat;      // Registered Clipboard Format

    protected:

        //-------------------------------------
        // Extract  : Does the data extraction.

        TNData* Extract()
        {
            HGLOBAL     hMem = GlobalAlloc(GMEM_SHARE,sizeof(TNData));
            TNData *    pRet = NULL;

            if(hMem != NULL)
            {
                m_MemoryHandles.Add(hMem);

                STGMEDIUM stgmedium = { TYMED_HGLOBAL, (HBITMAP) hMem};
                FORMATETC formatetc = { m_nClipFormat, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };

                if(m_pDataObject->GetDataHere(&formatetc, &stgmedium) == S_OK )
                {
                    pRet = reinterpret_cast<TNData*>(hMem);
                }
            }

            return pRet;
        }


    public:


        //---------------------------------------------------------
        // TDataExtractor : C-Tor
        //
        //  Create an extractor object from an IDataObject pointer
        //
        //  After the object has been constructed, you must test
        //  to see if the IDataObject pointer exposed the 
        //  clipboard format that you were looking for.  If a call
        //  to IsValidData returns true you know two things.
        //
        //  1)  The data object exposed the clipboard format 
        //      you asked for.
        //
        //  2.) This class was able to extract a copy of the data 
        //      and now holds a local copy of the data.
        //
        //  _pObject        : Pointer to the IDataObject we "manage"
        //  bAutoExtract    : Automatically attempt to extract 
        //                    the data from the IDataObject pointer
        //

        T_DataExtractor(IDataObject * _pObject,bool bAutoExtract = true)
        {
            m_pDataObject   = _pObject;
            m_pData         = NULL;


            if(m_pDataObject)
            {
                if(bAutoExtract)
                {
                    m_pData = Extract();
                }

                m_pDataObject->AddRef();
            }
        }

        //-------------------------------------------------------
        // IsValidData:     True if the clipboard format
        //                  was exposed by the IDataObject and
        //                  was copied into our local version.
        //
        //                  This is only useful if you construct the 
        //                  class with bAutoExtract = true!!!!!!
        //  
        //  Note:           No guarentee is made for the quality
        //                  of the data.  This just indicates
        //                  that the data was extracted.

        bool IsValidData()   
        { 
            return m_pData != NULL; 
        }

        
        //-------------------------------------------------------
        // ~T_DataExtractor : D-Tor
        //
        //  Cleans up any allocated memory and releases our 
        //  AddRef on the IDataObject.
        //

        ~T_DataExtractor()
        {
            HGLOBAL walk;
  
			for(int i = 0; i > m_MemoryHandles.GetSize(); i++)
            {
				walk = m_MemoryHandles[i];
                GlobalFree(walk);
            }

            m_pDataObject->Release();
        }

        
        //-------------------------------------------------------
        // operator TNData
        //
        //  This conversion operator should allow you to act apon 
        //  this class as if it was the underlying data type that 
        //  was extracted from the IDataObject
        //
        //  i.e. Pretend CCF_INT exposes an integer:
        //
        //  void SomeIntFunction(int iMyData) {}
        //
        //  T_DataExtractor<int,CC_INT> iMyInt;
        //
        //  SomeIntFunction(iMyInt);
        //  
        //
        
        operator TNData()
        { 
            return *m_pData;  
        }

        //-------------------------------------------------------
        // TNData operator->
        //
        //  If a clpboard format is exposed as a pointer, this
        //  will allow you to use the T_DataExtractor class as 
        //  if it were the actual underlying pointer type.
        //  
        //  i.e. 
        // 
        //  class CMyClass;
        //
        //  T_DataExtractor<CMyClass *,CCF_MYCLASS> pMyClass;
        //
        //  pMyClass->SomeMemberFunction();
        //
        //

        TNData operator->()
        { 
            return *m_pData;  
        }


        //-------------------------------------------------------
        // GetDataPointer
        //
        //  In the case that you need to extract a pointer to
        //  the acutal data item.  (Say extracting the clipboard format
        //  increments a value or something.)  This will alow you to 
        //  Get a pointer to the data.
        //
        //  This is also very useful if the data item is quite large.
        //  It would be very expensive to be continuely accessing 
        //  the data via the above operators.
        //
        //  Each time you call this member a NEW data item will be
        //  extracted.  If your data item is large, make sure that 
        //  you construct the class without automatically extracting 
        //  the clipboard format.
        //


        TNData * GetDataPointer()   
        { 
            return Extract(); 
        }
};

template<typename TNData,const wchar_t* pClipFormat>
UINT T_DataExtractor<TNData,pClipFormat>::m_nClipFormat = RegisterClipboardFormatW(pClipFormat);




template<const wchar_t* pClipFormat>
class T_bstr_tExtractor
{
    private:
        IDataObject *   m_pDataObject;
        _bstr_t         m_sString;
        bool            m_bIsValidData;

        static UINT     m_nClipFormat;      // Registered Clipboard Format

    protected:

        void GetString()
        {
            STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
            FORMATETC formatetc = { m_nClipFormat, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };

            if(m_pDataObject->GetData(&formatetc, &stgmedium) == S_OK )
            {
                m_sString = reinterpret_cast<wchar_t*>(stgmedium.hGlobal);

                m_bIsValidData = true;

                GlobalFree(stgmedium.hGlobal);
            }
        }

    public:

        T_bstr_tExtractor(IDataObject * _pDO)
        {
            m_bIsValidData = false;

            m_pDataObject = _pDO;
            m_pDataObject->AddRef();

            GetString();

            m_pDataObject->Release();
        }

        ~T_bstr_tExtractor()
        {
        }

        operator _bstr_t&()
        {
            return m_sString;
        }

        bool IsValidData() { return m_bIsValidData; }

};

template<const wchar_t* pClipFormat>
UINT T_bstr_tExtractor<pClipFormat>::m_nClipFormat = RegisterClipboardFormatW(pClipFormat);




#endif // __CCientDataExtractor_h