//	ImpIPersistFile.cpp
//
//  This file contains the implementation of 
//  the IPersistFile interface for the XXX server.
//
//
//	(c) COPYRIGHT 1996-1998, INTELLUTION INC.
// ALL RIGHTS RESERVED
//
//
//	Functions defined in this module:
//
//			CImpIPersistFile::CImpIPersistFile()
//			CImpIPersistFile::~CImpIPersistFile()
//			CImpIPersistFile::AddRef()
//			CImpIPersistFile::Release()
//			CImpIPersistFile::QueryInterface()
//			CImpIPersistFile::GetClassID()
//			CImpIPersistFile::IsDirty()
//			CImpIPersistFile::Load()
//			CImpIPersistFile::Save()
//			CImpIPersistFile::SaveCompleted()
//			CImpIPersistFile::GetCurFile()
//
//
//
// Modification Log:
//	Vers	Date     By		Notes
//	----	-------- ---	-----
//	1.0		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"


extern TCHAR	*g_tszAcronym;
extern IMalloc	*pIMalloc;
extern HRESULT GetServerClassID(CLSID *pClassID);

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

////////////////////////////////////////////////////////////////
// CImpIPersistFile()
//
// Constructor for this Interface
//
////////////////////////////////////////////////////////////////
CImpIPersistFile::CImpIPersistFile(LPUNKNOWN pUnkOuter)
{
	m_pUnkOuter		= pUnkOuter;
	m_pParentServer	= (COPCDrvServer *)pUnkOuter;
}



////////////////////////////////////////////////////////////////
// ~CImpIPersistFile()
//
// Destructor for this Interface
//
////////////////////////////////////////////////////////////////
CImpIPersistFile::~CImpIPersistFile(void)
{
	m_pParentServer->m_pCImpIPersistFile = NULL;
}


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

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


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


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


/////////////////////////////////////////////////////////////////////////////
// CImpIPersistFile (IPersisFile) interface functions
//


////////////////////////////////////////////////////////////////
// CImpIPersistFile::GetClassID()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP	CImpIPersistFile::GetClassID(CLSID *pClassID)
{
	// Simply return the class ID defined in DLLMAIN.cpp
	return GetServerClassID(pClassID);
}


////////////////////////////////////////////////////////////////
// CImpIPersistFile::IsDirty()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP	CImpIPersistFile::IsDirty(void)
{
	// We currently don't have a way to determine the dirty bit in
	// the I/O server, so we can play it safe and return that it
	// needs to be saved.
	//
	return S_OK;
}

        
////////////////////////////////////////////////////////////////
// CImpIPersistFile::Load()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP	CImpIPersistFile::Load(LPCOLESTR	pszFileName,
									   DWORD		dwMode)
{
	if (NULL == pszFileName)
	{
		return E_INVALIDARG;
	}


	HRESULT	hr = S_OK;
	CString szFileName	= pszFileName;
	BSTR	bszFileName = szFileName.AllocSysString();

	if (NULL == bszFileName)
	{
		return E_OUTOFMEMORY;
	}

	// Make sure this file is the correct format
	//
	int nIndex;
	if (-1 != (nIndex = szFileName.FindOneOf(".")))
	{
		CString	szExtension = szFileName.Mid(nIndex + 1);
		if (szExtension != g_tszAcronym)
		{
			return OPC_E_INVALIDCONFIGFILE;
		}
	}

	// Open the file in the server.
	//
	if (FAILED(m_pParentServer->m_pIDriver->FileOpen(bszFileName)))
	{
		hr = E_FAIL;
	}
	SysFreeString(bszFileName);

	return hr;
}

        
////////////////////////////////////////////////////////////////
// CImpIPersistFile::Save()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP	CImpIPersistFile::Save(LPCOLESTR	pszFileName,
									   BOOL			bRemember)
{
	if (NULL == pszFileName)
	{
		return E_INVALIDARG;
	}

	HRESULT	hr = S_OK;
	CString	szFileName = pszFileName;
	BSTR	bszFileName = szFileName.AllocSysString();

	if (NULL == bszFileName)
	{
		return E_OUTOFMEMORY;
	}

	// Do the save in the server
	//
	if (FAILED(m_pParentServer->m_pIDriver->FileSaveAs(bszFileName)))
	{
		hr = E_FAIL;
	}
	SysFreeString(bszFileName);

	// If the client wants this to be the new default file, then set it as such
	//
	if (bRemember)
	{
		if (FAILED(m_pParentServer->m_pIDriver->put_DefaultConfigFileName(bszFileName)))
		{
			hr = E_FAIL;
		}
	}

	return hr;
}

        
////////////////////////////////////////////////////////////////
// CImpIPersistFile::SaveCompleted()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP	CImpIPersistFile::SaveCompleted(LPCOLESTR pszFileName)
{
	return S_OK;
}

        
////////////////////////////////////////////////////////////////
// CImpIPersistFile::GetCurFile()
//
////////////////////////////////////////////////////////////////
STDMETHODIMP	CImpIPersistFile::GetCurFile(LPOLESTR *ppszFileName)
{
	BSTR		bszFileName;
	CString		szFileName;
	int			nLength = 0;
	HRESULT		hr = S_OK;


	if ((NULL == ppszFileName) || (NULL == pIMalloc))
	{
		return E_FAIL;
	}

	// Call the I/O server for the config name that is currently loaded.
	//
	if (FAILED(m_pParentServer->m_pIDriver->get_FullConfigFileName(&bszFileName)))
	{
		hr = E_FAIL;
	}

	// Get the string as a CString and free the BSTR memory.
	//
	szFileName	= bszFileName;
	nLength		= szFileName.GetLength();
	SysFreeString(bszFileName);

	// Allocate our memory using the default task allocator.
	// Then initialize and copy the CString's buffer to be returned to the caller.
	//
	*ppszFileName = (OLECHAR *)pIMalloc->Alloc(sizeof(OLECHAR) * (nLength + 1));
	memset(*ppszFileName, NULL, sizeof(OLECHAR) * (nLength + 1));
	mbstowcs(*ppszFileName, szFileName.GetBuffer(nLength + 1), nLength);
	szFileName.ReleaseBuffer();
	return hr;
}