impidataobject.cpp

基于Intellution开发包的开发的OPC服务器

// ImpIDataObject.cpp
//
//  This file contains the implementation of 
//  the IDataObject interface for groups in the XXX server.
//
//
//	(c) COPYRIGHT 1996-1998, INTELLUTION INC.
// ALL RIGHTS RESERVED
//
//	Functions defined in this module:
//
//			CImpIDataObject::CImpIDataObject()
//			CImpIDataObject::~CImpIDataObject()
//			CImpIDataObject::AddRef()
//			CImpIDataObject::Release()
//			CImpIDataObject::QueryInterface()
//			CImpIDataObject::DAdvise()
//			CImpIDataObject::DUnadvise()
//			CImpIDataObject::GetData()
//			CImpIDataObject::GetDataHere()
//			CImpIDataObject::QueryGetData()
//			CImpIDataObject::GetCanonicalFormatEtc()
//			CImpIDataObject::SetData()
//			CImpIDataObject::EnumFormatEtc()
//			CImpIDataObject::EnumDAdvise()
//
//
//
// Modification Log:
//	Vers		Date     By		Notes
//	----		-------- ---	-----
//	1.00		08/26/97 jra	Created
//	1.3			03/10/98 jra	Modified to be wizard generated and driver specific.
//

#define WIN32_LEAN_AND_MEAN

#include "OpcStdAfx.h"

#include "OPC.h"


/////////////////////////////////////////////////////////////////////////////
// Constructor /Destructor functions
//

////////////////////////////////////////////////////////////////
// CImpIDataObject()
//   Constructor for this Interface
//
////////////////////////////////////////////////////////////////
CImpIDataObject::CImpIDataObject(LPUNKNOWN pUnkOuter)
{
	m_pUnkOuter			= pUnkOuter;
	m_pParentGroup		= (COPCDrvGroup *)pUnkOuter;

	m_dataCallback		= 0;
	m_datatimeCallback	= 0;
	m_writeCallback		= 0;

	m_pdatatimeStm		= NULL;
	m_pdataStm			= NULL;
	m_pwriteStm			= NULL;

	m_data		= RegisterClipboardFormat("OPCSTMFORMATDATA");
	m_datatime	= RegisterClipboardFormat("OPCSTMFORMATDATATIME");
	m_write		= RegisterClipboardFormat("OPCSTMFORMATWRITECOMPLETE");
}


////////////////////////////////////////////////////////////////
// ~CImpIDataObject()
//   Destructor for this Interface
//
////////////////////////////////////////////////////////////////
CImpIDataObject::~CImpIDataObject( void)
{
	m_pParentGroup->m_pCImpIDataObject = NULL;

	// A well behaved client should already have released these:
	//
	if(m_dataCallback)
	{
		m_dataCallback->Release();
	}
	if(m_datatimeCallback)
	{
		m_datatimeCallback->Release();
	}
	if(m_writeCallback)
	{
		m_writeCallback->Release();
	}
}


/////////////////////////////////////////////////////////////////////////////
// IUnknown functions Delegate to Parent
//


////////////////////////////////////////////////////////////////
// AddRef()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG) CImpIDataObject::AddRef(void)
{
	return m_pUnkOuter->AddRef();
}


////////////////////////////////////////////////////////////////
// Release()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP_(ULONG) CImpIDataObject::Release(void)
{
	return m_pUnkOuter->Release();
}


////////////////////////////////////////////////////////////////
// QueryInterface()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP CImpIDataObject::QueryInterface(REFIID		iid, 
											 LPVOID		*ppInterface)
{
	return m_pUnkOuter->QueryInterface(iid, ppInterface);
}



/////////////////////////////////////////////////////////////////////////////
// CImpIDataObject (IDataObject) interface functions
//


////////////////////////////////////////////////////////////////
// IDataObject::DAdvise()
//
////////////////////////////////////////////////////////////////      
STDMETHODIMP CImpIDataObject::DAdvise(FORMATETC			*pfe,
									  DWORD				advf,
									  IAdviseSink		*pAdvSink,
									  DWORD				*pdwConnection) 
{
	HRESULT		hr;
	IAdviseSink	*pIAdviseSink = NULL;


	// Make sure we didn;t get any bad pointers
	//
	if(NULL == pdwConnection)
	{
		return E_POINTER;
	}
	if(NULL == pAdvSink)
	{
		return E_POINTER;
	}
	if(NULL == pfe)
	{
		return E_POINTER;
	}

	// Figure out what type of connection he wants
	//
	if(pfe->cfFormat == m_data)
	{
		// if already in use, return error
		// Else connect it up
		//
		if(m_dataCallback)
		{
			return CONNECT_E_ADVISELIMIT;
		}
		
		// Query into the client for our own copy of the IAdviseSink.
		//
		hr = pAdvSink->QueryInterface(IID_IAdviseSink, (LPVOID *)&pIAdviseSink);
		if(FAILED(hr))
		{
			return hr;
		}
	
		// Put the interface pointer into a stream object. This is needed for
		// the Apartment threading model for OLE.
		//
		hr = CoMarshalInterThreadInterfaceInStream(IID_IAdviseSink,
												   pIAdviseSink, 
												   &m_pdataStm);
		if(FAILED(hr))
		{
			return hr;
		}

		// Set pointer to allow callbacks
		//
		m_dataCallback = pIAdviseSink;

		// Save over the callers flags in the group. Currently we only
		// support ADVF_PRIMEFIRST.
		//
		m_pParentGroup->m_dwAdvfDataFlags = advf;

	}
	else if(pfe->cfFormat == m_datatime)
	{
		// if already in use, return error
		// Else connect it up
		//
		if(m_datatimeCallback)
		{
			return CONNECT_E_ADVISELIMIT;
		}

		// Query into the client for our own copy of the IAdviseSink.
		//
		hr = pAdvSink->QueryInterface(IID_IAdviseSink, (LPVOID *)&pIAdviseSink);
		if(FAILED(hr))
		{
			return hr;
		}

		// Put the interface pointer into a stream object. This is needed for
		// the Apartment threading model for OLE.
		//
		hr = CoMarshalInterThreadInterfaceInStream(IID_IAdviseSink,
												   pIAdviseSink, 
												   &m_pdatatimeStm);
		if(FAILED(hr))
		{
			return hr;
		}

		// Set pointer to allow callbacks
		//
		m_datatimeCallback = pIAdviseSink;

		// Save over the callers flags in the group. Currently we only
		// support ADVF_PRIMEFIRST.
		//
		m_pParentGroup->m_dwAdvfDataTimeFlags = advf;

	} 
	else if(pfe->cfFormat == m_write)
	{
		// if already in use, return error
		// Else connect it up
		//
		if(m_writeCallback)
		{
			return CONNECT_E_ADVISELIMIT;
		}

		// Query into the client for our own copy of the IAdviseSink.
		//
		hr = pAdvSink->QueryInterface(IID_IAdviseSink, (LPVOID *)&pIAdviseSink);
		if(FAILED(hr))
		{
			return hr;
		}

		// Put the interface pointer into a stream object. This is needed for
		// the Apartment threading model for OLE.
		//
		hr = CoMarshalInterThreadInterfaceInStream(IID_IAdviseSink,
												   pIAdviseSink, 
												   &m_pwriteStm);
		if(FAILED(hr))
		{
			return hr;
		}

		// Set pointer to allow callbacks
		//
		m_writeCallback = pIAdviseSink;

	}
	else
	{
		// Bad stream format
		//
		return DV_E_FORMATETC;
	}

	// Cookie used to indicate connection type
	//
	*pdwConnection = pfe->cfFormat;

	return S_OK;
}

////////////////////////////////////////////////////////////////
// IDataObject::DUnadvise()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP CImpIDataObject::DUnadvise(DWORD dwConnection) 
{
	// Figure out what type of connection it is
	//
	if((UINT)dwConnection == m_data)
	{
		// if already in use, return error
		// Else connect it up
		//
		if(!m_dataCallback)
		{
			return OLE_E_NOCONNECTION;
		}
		m_dataCallback->Release();
		m_dataCallback = 0;

		// Clear any pending advf flags.
		//
		m_pParentGroup->m_dwAdvfDataFlags = 0;
	} 
	else if((UINT)dwConnection == m_datatime)
	{
		// if already in use, return error
		// Else connect it up
		//
		if(!m_datatimeCallback)
		{
			return OLE_E_NOCONNECTION;
		}
		m_datatimeCallback->Release();
		m_datatimeCallback = 0;

		// Clear any pending advf flags.
		//
		m_pParentGroup->m_dwAdvfDataTimeFlags = 0;
	} 
	else if((UINT)dwConnection == m_write)
	{
		// if already in use, return error
		// Else connect it up
		//
		if(!m_writeCallback)
		{
			return OLE_E_NOCONNECTION;
		}
		m_writeCallback->Release();
		m_writeCallback = 0;
	}
	else
	{
		// Bad stream format
		//
		return OLE_E_NOCONNECTION;
	}

	return S_OK;
}
        
////////////////////////////////////////////////////////////////
// IDataObject::GetData()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP CImpIDataObject::GetData(FORMATETC			*pformatetcIn,
									  STGMEDIUM			*pmedium) 
{
	return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////
// IDataObject::GetDataHere()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP CImpIDataObject::GetDataHere(FORMATETC		*pformatetc,
										  STGMEDIUM		*pmedium) 
{
	return E_NOTIMPL;
}



////////////////////////////////////////////////////////////////
// IDataObject::QueryGetData()
//
////////////////////////////////////////////////////////////////      
STDMETHODIMP CImpIDataObject::QueryGetData(FORMATETC *pformatetc) 
{
	return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////
// IDataObject::GetCanonicalFormatEtc()
//
////////////////////////////////////////////////////////////////       
STDMETHODIMP CImpIDataObject::GetCanonicalFormatEtc(FORMATETC	*pformatectIn,
													FORMATETC	*pformatetcOut) 
{
	return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////
// IDataObject::SetData()
//
////////////////////////////////////////////////////////////////      
STDMETHODIMP CImpIDataObject::SetData(FORMATETC			*pformatetc,
									  STGMEDIUM			*pmedium,
									  BOOL				fRelease) 
{
	return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////
// IDataObject::EnumFormatEtc()
//
////////////////////////////////////////////////////////////////      
STDMETHODIMP CImpIDataObject::EnumFormatEtc(DWORD				dwDirection,
											IEnumFORMATETC		**ppenumFormatEtc) 
{
	return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////
// IDataObject::EnumDAdvise()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP CImpIDataObject::EnumDAdvise(IEnumSTATDATA **ppenumAdvise) 
{
	return E_NOTIMPL;
}