//**********************************************************************
// File name: DXFEROBJ.CPP
//
// Implementation file for CDataXferObj, data transfer object
// implementation of IDataObject interface.
//
// Functions:
//
// See DXFEROBJ.H for class definition
//
// Copyright (c) 1992 - 1993 Microsoft Corporation. All rights reserved.
//**********************************************************************
#include "pre.h"
#include <enumfetc.h>
#include <assert.h>
#include "dxferobj.h"
#include "site.h"
//BUGBUG: These should be fetched from real header files
#define CF_HDROP 15
typedef struct _dropfilestruct {
DWORD pFiles;
POINT pt;
BOOL fNC;
BOOL fWide;
} DROPFILESTRUCT;
CLIPFORMAT g_cfEmbeddedObject=RegisterClipboardFormat(CF_EMBEDDEDOBJECT);
CLIPFORMAT g_cfObjectDescriptor=RegisterClipboardFormat(CF_OBJECTDESCRIPTOR);
// List of formats offered by our data transfer object via EnumFormatEtc
static FORMATETC s_arrGetFmtEtcs[] =
{
{ g_cfEmbeddedObject, NULL, DVASPECT_CONTENT, -1, TYMED_ISTORAGE},
{ g_cfObjectDescriptor, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL},
{ CF_METAFILEPICT, NULL, DVASPECT_CONTENT, -1, TYMED_MFPICT}
};
//**********************************************************************
//
// CDataXferObj::Create
//
// Purpose:
//
// Creation routine for CDataXferObj
//
// Parameters:
//
// CSimpleSite FAR *lpSite - Pointer to source CSimpleSite
// this is the container site of the
// source OLE object to be transfered
//
// Return Value:
//
// None
//
// Function Calls:
// Function Location
//
// StgCreateDocfile OLE API
// assert C Runtime
//
// Comments:
// reference count of CDataXferObj will be 0 on return.
//
//********************************************************************
CDataXferObj FAR * CDataXferObj::Create(
CSimpleSite FAR *lpSite,
POINTL FAR* pPointl
)
{
CDataXferObj FAR * lpTemp = new CDataXferObj();
if (!lpTemp)
return NULL;
// create a sub-storage for the object
HRESULT hErr = StgCreateDocfile(
NULL,
STGM_READWRITE | STGM_DIRECT | STGM_SHARE_EXCLUSIVE |
STGM_DELETEONRELEASE,
0,
&lpTemp->m_lpObjStorage);
assert(hErr == NOERROR);
if (hErr != NOERROR)
{
delete lpTemp;
return NULL;
}
// Clone the source object
if (lpSite->m_lpOleObject)
{
// Object is loaded; ask the object to save into the new storage
LPPERSISTSTORAGE pPersistStorage;
if (lpSite->m_lpOleObject->QueryInterface(IID_IPersistStorage,
(LPVOID FAR*)&pPersistStorage) != ResultFromScode(S_OK))
{
/* cannot find interface
*/
return(NULL);
}
assert(pPersistStorage);
if (OleSave(pPersistStorage, lpTemp->m_lpObjStorage, FALSE)
!= ResultFromScode(S_OK))
{
TestDebugOut("Fail in OleSave\n");
}
// pass NULL so that object application won't forget the real stg
if (pPersistStorage->SaveCompleted(NULL) != ResultFromScode(S_OK))
{
TestDebugOut("Fail in IPersistStorage::SaveCompleted\n");
}
pPersistStorage->Release();
}
else
{
// Object not loaded so use cheaper IStorage CopyTo operation
lpSite->m_lpObjStorage->CopyTo(0, NULL, NULL, lpTemp->m_lpObjStorage);
}
if (OleLoad(lpTemp->m_lpObjStorage, IID_IOleObject, NULL,
(LPVOID FAR*)&lpTemp->m_lpOleObject)
!= ResultFromScode(S_OK))
{
/* we cannot load the embedded/linked object into the memory
*/
return(NULL);
}
assert(lpTemp->m_lpOleObject);
lpTemp->m_sizel = lpSite->m_sizel;
if (pPointl)
lpTemp->m_pointl = *pPointl;
else
lpTemp->m_pointl.x = lpTemp->m_pointl.y = 0;
return lpTemp;
}
//**********************************************************************
//
// CDataXferObj::CDataXferObj
//
// Purpose:
//
// Constructor for CDataXferObj
//
// Parameters:
//
// CSimpleDoc FAR *lpDoc - Pointer to CSimpleDoc
//
// Return Value:
//
// None
//
// Function Calls:
// Function Location
//
//
//********************************************************************
CDataXferObj::CDataXferObj (void)
{
// clear the reference count
m_nCount = 0;
m_lpObjStorage = NULL;
m_lpOleObject = NULL;
m_sizel.cx = m_sizel.cy = 0;
m_pointl.x = m_pointl.y = 0;
}
//**********************************************************************
//
// CDataXferObj::~CDataXferObj
//
// Purpose:
//
// Destructor for CDataXferObj
//
// Parameters:
//
// None
//
// Return Value:
//
// None
//
// Function Calls:
// Function Location
//
// TestDebugOut Windows API
// IOleObject::Release Object
// IStorage::Release OLE API
//
//
//********************************************************************
CDataXferObj::~CDataXferObj ()
{
TestDebugOut ("In CDataXferObj's Destructor \r\n");
if (m_lpOleObject)
{
m_lpOleObject->Release();
m_lpOleObject = NULL;
// Release the storage for this object
m_lpObjStorage->Release();
m_lpObjStorage = NULL;
}
}
//**********************************************************************
//
// CDataXferObj::QueryInterface
//
// Purpose:
//
// Used for interface negotiation of the CDataXferObj instance
//
// Parameters:
//
// REFIID riid - A reference to the interface that is
// being queried.
//
// LPVOID FAR* ppvObj - An out parameter to return a pointer to
// the interface.
//
// Return Value:
//
// S_OK - The interface is supported.
// E_NOINTERFACE - The interface is not supported
//
// Function Calls:
// Function Location
//
// TestDebugOut Windows API
// IsEqualIID OLE API
// ResultFromScode OLE API
// CDataXferObj::AddRef DXFEROBJ.CPP
//
//
//********************************************************************
STDMETHODIMP CDataXferObj::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
{
TestDebugOut("In CDataXferObj::QueryInterface\r\n");
if (IsEqualIID( riid, IID_IUnknown) || IsEqualIID(riid, IID_IDataObject))
{
AddRef();
*ppvObj = this;
return NOERROR;
}
// unknown interface requested
*ppvObj = NULL; // must set out pointer parameters to NULL
return ResultFromScode(E_NOINTERFACE);
}
//**********************************************************************
//
// CDataXferObj::AddRef
//
// Purpose:
//
// Increments the reference count of the CDataXferObj instance
//
// Parameters:
//
// None
//
// Return Value:
//
// ULONG - The new reference count of the object
//
// Function Calls:
// Function Location
//
// TestDebugOut Windows API
//
//
//********************************************************************
STDMETHODIMP_(ULONG) CDataXferObj::AddRef()
{
TestDebugOut("In CDataXferObj::AddRef\r\n");
return ++m_nCount;
}
//**********************************************************************
//
// CDataXferObj::Release
//
// Purpose:
//
// Decrements the reference count of the CDataXferObj object
//
// Parameters:
//
// None
//
// Return Value:
//
// ULONG - The new reference count of the object.
//
// Function Calls:
// Function Location
//
// TestDebugOut Windows API
//
//
//********************************************************************
STDMETHODIMP_(ULONG) CDataXferObj::Release()
{
TestDebugOut("In CDataXferObj::Release\r\n");
if (--m_nCount == 0)
{
delete this;
return 0;
}
return m_nCount;
}
/********************************************************************
** This IDataObject implementation is used for data transfer.
**
** The following methods are NOT supported for data transfer:
** IDataObject::SetData -- return E_NOTIMPL
** IDataObject::DAdvise -- return OLE_E_ADVISENOTSUPPORTED
** ::DUnadvise
** ::EnumDAdvise
** IDataObject::GetCanonicalFormatEtc -- return E_NOTIMPL
** (NOTE: must set pformatetcOut->ptd = NULL)
*********************************************************************/
//**********************************************************************
//
// CDataXferObj::QueryGetData
//
// Purpose:
//
// Called to determine if our object supports a particular
// FORMATETC.
//
// Parameters:
//
// LPFORMATETC pformatetc - Pointer to the FORMATETC being queried for.
//
// Return Value:
//
// DV_E_FORMATETC - The FORMATETC is not supported
// S_OK - The FORMATETC is supported.
//
//
// Function Calls:
// Function Location
//
// TestDebugOut Windows API
// ResultFromScode OLE API
//
// Comments:
// we support the following formats:
// "Embedded Object"
// "Object Descriptor"
// CF_METAFILEPICT
//
//********************************************************************
STDMETHODIMP CDataXferObj::QueryGetData (LPFORMATETC pformatetc)
{
SCODE sc = DV_E_FORMATETC;
TestDebugOut("In CDataXferObj::QueryGetData\r\n");
// check the validity of the formatetc.
if ( (pformatetc->cfFormat == g_cfEmbeddedObject) &&
(pformatetc->dwAspect == DVASPECT_CONTENT) &&
(pformatetc->tymed == TYMED_ISTORAGE) )
{
sc = S_OK;
}
else if ( (pformatetc->cfFormat == g_cfObjectDescriptor) &&
(pformatetc->dwAspect == DVASPECT_CONTENT) &&
(pformatetc->tymed == TYMED_HGLOBAL) )
{
sc = S_OK;
}
else if ( (pformatetc->cfFormat == CF_METAFILEPICT) &&
(pformatetc->dwAspect == DVASPECT_CONTENT) &&
(pformatetc->tymed == TYMED_MFPICT) )
{
sc = S_OK;
}
else if ( (pformatetc->cfFormat == CF_HDROP) &&
(pformatetc->dwAspect == DVASPECT_CONTENT) &&
(pformatetc->tymed == TYMED_HGLOBAL) )
{
sc = S_OK;
}
return ResultFromScode(sc);
}
extern BOOL gfUseEmptyEnumerator;
//**********************************************************************
//
// CDataXferObj::EnumFormatEtc
//
// Purpose:
//
// Enumerates the formats that can be used to store data
//
// Parameters:
//
// DWORD dwDirection - format to be enumerated
//
// LPENUMFORMATETC ppenumFormatEtc - where to return the
// instantiated enumerator
//
// Return Value:
//
// S_OK - if the operation is successful
// E_OUTOFMEMORY - if ran out of memory
// E_NOTIMPL - if dwDirection is not supported
//
//
// Function Calls:
// Function Location
//
// TestDebugOut Windows API
// ResultFromScode OLE API
// OleStdEnumFmtEtc_Create OLE2UI
//
//**********************************************************************
STDMETHODIMP CDataXferObj::EnumFormatEtc(
DWORD dwDirection,
LPENUMFORMATETC FAR* ppenumFormatEtc
)
{
SCODE sc = E_NOTIMPL;
TestDebugOut("In CDataXferObj::EnumFormatEtc\r\n");
*ppenumFormatEtc = NULL;
if( gfUseEmptyEnumerator == TRUE )
{
return E_FAIL;
}
if (dwDirection == DATADIR_GET)
{
*ppenumFormatEtc = OleStdEnumFmtEtc_Create(
sizeof(s_arrGetFmtEtcs)/sizeof(s_arrGetFmtEtcs[0]),
s_arrGetFmtEtcs);
if (*ppenumFormatEtc == NULL)
sc = E_OUTOFMEMORY;
else
sc = S_OK;
}
return ResultFromScode(sc);
}
//**********************************************************************
//
// CDataXferObj::GetData
//
// Purpose:
//
// Returns the data in the format specified in pformatetcIn.
//
// Parameters:
//
// LPFORMATETC pformatetcIn - The format requested by the caller
//
// LPSTGMEDIUM pmedium - The medium requested by the caller
//
// Return Value:
//
// DV_E_FORMATETC - Format not supported
// S_OK - Success
//
// Function Calls:
// Function Location
//
// TestDebugOut Windows API
// OleStdGetOleObjectData OLE2UI API
// OleStdGetMetafilePictFromOleObject OLE2UI API
// OleStdGetObjectDescriptorDataFromOleObject OLE2UI API
// ResultFromScode OLE API
// IOleObject::QueryInterface Object
//
// Comments:
// we support GetData for the following formats:
// "Embedded Object"
// "Object Descriptor"
// CF_METAFILEPICT
//
//********************************************************************
STDMETHODIMP CDataXferObj::GetData (
LPFORMATETC pformatetcIn,
LPSTGMEDIUM pmedium
)
{
SCODE sc = DV_E_FORMATETC;
TestDebugOut("In CDataXferObj::GetData\r\n");
// we must set all out pointer parameters to NULL. */
pmedium->tymed = TYMED_NULL;
pmedium->pUnkForRelease = NULL; // we transfer ownership to caller
pmedium->hGlobal = NULL;
// Check the FORMATETC and fill pmedium if valid.
if ( (pformatetcIn->cfFormat == g_cfEmbeddedObject) &&
(pformatetcIn->dwAspect == DVASPECT_CONTENT) &&
(pformatetcIn->tymed == TYMED_ISTORAGE) )
{
LPPERSISTSTORAGE pPersistStorage;
/* render CF_EMBEDDEDOBJECT by asking the object to save
** into a temporary, DELETEONRELEASE IStorage allocated by us.
*/
HRESULT hRes;
if ((hRes=m_lpOleObject->QueryInterface(
IID_IPersistStorage, (LPVOID FAR*)&pPersistStorage))
!= ResultFromScode(S_OK))
{
return(hRes);
}
assert(pPersistStorage);
HRESULT hrErr = OleStdGetOleObjectData(
pPersistStorage,
pformatetcIn,
pmedium,
FALSE /* fUseMemory -- (use file-base stg) */
);
pPersistStorage->Release();
sc = GetScode( hrErr );
}
else if ( (pformatetcIn->cfFormat == g_cfObjectDescriptor) &&
(pformatetcIn->dwAspect == DVASPECT_CONTENT) &&
(pformatetcIn->tymed == TYMED_HGLOBAL) )
{
// render CF_OBJECTDESCRIPTOR data
pmedium->hGlobal = OleStdGetObjectDescriptorDataFromOleObject(
m_lpOleObject,
TEXT("Simple OLE 2.0 Container"), //string to identify source
DVASPECT_CONTENT,
m_pointl,
(LPSIZEL)&m_sizel
);
if (! pmedium->hGlobal)
sc = E_OUTOFMEMORY;
else
{
pmedium->tymed = TYMED_HGLOBAL;
sc = S_OK;
}
}
else if ( (pformatetcIn->cfFormat == CF_METAFILEPICT) &&
(pformatetcIn->dwAspect == DVASPECT_CONTENT) &&
(pformatetcIn->tymed == TYMED_MFPICT) )
{
// render CF_METAFILEPICT by drawing the object into a metafile DC
pmedium->hGlobal = OleStdGetMetafilePictFromOleObject(
m_lpOleObject, DVASPECT_CONTENT, NULL, pformatetcIn->ptd);
if (! pmedium->hGlobal)
sc = E_OUTOFMEMORY;
else
{
pmedium->tymed = TYMED_MFPICT;
sc = S_OK;
}
}
else if ( (pformatetcIn->cfFormat == CF_HDROP) &&
(pformatetcIn->dwAspect == DVASPECT_CONTENT) &&
(pformatetcIn->tymed == TYMED_HGLOBAL) )
{
// testing for Win3.1 style drag drop. If we offer
// CF_HDROP ( basically, a list of filenames) in a data object
// given to OLE DoDragDrop, then DoDragDrop will translate
// OLE drag drop into Win3.1 drag drop for Win3.1 drop targets
ULONG cbFile;
char szFile[256];
DROPFILESTRUCT *pdfs;
char *pfile;
cbFile = GetEnvironmentVariable("SystemRoot", szFile, sizeof(szFile));
if( cbFile == 0 )
{
sc = E_FAIL;
goto errRtn;
}
cbFile += sizeof("\\setup.txt");
strcat(szFile, "\\setup.txt");
pmedium->tymed = TYMED_HGLOBAL;
pmedium->hGlobal = GlobalAlloc( GMEM_DDESHARE,
sizeof(DROPFILESTRUCT) +
cbFile + 3);
if( pmedium->hGlobal )
{
pdfs = (DROPFILESTRUCT *)GlobalLock(pmedium->hGlobal);
if( pdfs )
{
pdfs->pFiles = sizeof(DROPFILESTRUCT);
pfile = (char *)((BYTE *)pdfs) + sizeof(DROPFILESTRUCT);
pdfs->fNC = FALSE;
pdfs->fWide = FALSE;
pdfs->pt.x = 0;
pdfs->pt.y = 0;
strcpy(pfile, szFile);
// double-NULL terminate it
pfile[strlen(pfile)+2] = '\0';
GlobalUnlock(pmedium->hGlobal);
sc = S_OK;
}
else
{
sc = E_OUTOFMEMORY;
}
}
else
{
sc = E_OUTOFMEMORY;
}
}
errRtn:
return ResultFromScode( sc );
}
//**********************************************************************
//
// CDataXferObj::GetDataHere
//
// Purpose:
//
// Called to get a data format in a caller supplied location
//
// Parameters:
//
// LPFORMATETC pformatetc - FORMATETC requested
//
// LPSTGMEDIUM pmedium - Medium to return the data
//
// Return Value:
//
// NOERROR - if OleStdGetOleObjectData success
// DATA_E_FORMATETC - We don't support the requested format
//
// Function Calls:
// Function Location
//
// TestDebugOut Windows API
// OleStdGetOleObjectData OLE2UI API
// IOleObject::QueryInterface Object
//
//
//********************************************************************
STDMETHODIMP CDataXferObj::GetDataHere (
LPFORMATETC pformatetc,
LPSTGMEDIUM pmedium
)
{
SCODE sc = DV_E_FORMATETC;
TestDebugOut("In CDataXferObj::GetDataHere\r\n");
// NOTE: pmedium is an IN parameter. we should NOT set
// pmedium->pUnkForRelease to NULL
// Check the FORMATETC and fill pmedium if valid.
if ( (pformatetc->cfFormat == g_cfEmbeddedObject) &&
(pformatetc->dwAspect == DVASPECT_CONTENT) &&
(pformatetc->tymed == TYMED_ISTORAGE) )
{
LPPERSISTSTORAGE pPersistStorage;
/* render CF_EMBEDDEDOBJECT by asking the object to save
** into the IStorage allocated by the caller.
*/
HRESULT hRes;
if ((hRes=m_lpOleObject->QueryInterface(
IID_IPersistStorage, (LPVOID FAR*)&pPersistStorage))
!= ResultFromScode(S_OK))
{
return(hRes);
}
assert(pPersistStorage);
HRESULT hrErr = OleStdGetOleObjectData(
pPersistStorage, pformatetc, pmedium,0 /*fUseMemory--N/A*/ );
pPersistStorage->Release();
sc = GetScode( hrErr );
}
return ResultFromScode( sc );
}
