|
|
/*++
Copyright (C) 1993-1999 Microsoft Corporation
Module Name:
iperstor.cpp
Abstract:
Implementation of the IPersistStorage interface exposed on the Polyline object.
--*/
#include "polyline.h"
#include "unkhlpr.h"
#include "unihelpr.h"
#include "utils.h"
/*
* CImpIPersistStorage interface implementation */
CImpIPersistStorage::CImpIPersistStorage(PCPolyline pObj , LPUNKNOWN pUnkOuter) { m_cRef=0; m_pObj=pObj; m_pUnkOuter=pUnkOuter; m_psState=PSSTATE_UNINIT; return; }
CImpIPersistStorage::~CImpIPersistStorage(void) { return; }
IMPLEMENT_CONTAINED_IUNKNOWN(CImpIPersistStorage)
/*
* CImpIPersistStorage::GetClassID * * Purpose: * Returns the CLSID of the object represented by this interface. * * Parameters: * pClsID LPCLSID in which to store our CLSID. * * Return Value: * HRESULT NOERROR on success, error code otherwise. */
STDMETHODIMP CImpIPersistStorage::GetClassID(LPCLSID pClsID) { //----------------------------------------------------------------
// THE OLECONT.EXE test container call this in the UNINIT state!
// Go ahead and return the ClsID.
//-----------------------------------------------------------------
// if (PSSTATE_UNINIT==m_psState)
// return ResultFromScode(E_UNEXPECTED);
*pClsID=m_pObj->m_clsID; return NOERROR;}
/*
* CImpIPersistStorage::IsDirty * * Purpose: * Tells the caller if we have made changes to this object since * it was loaded or initialized new. * * Parameters: * None * * Return Value: * HRESULT Contains S_OK if we ARE dirty, S_FALSE if * NOT dirty. * */
STDMETHODIMP CImpIPersistStorage::IsDirty(void) { if (PSSTATE_UNINIT==m_psState) return ResultFromScode(E_UNEXPECTED);
return ResultFromScode(m_pObj->m_fDirty ? S_OK : S_FALSE); }
/*
* CImpIPersistStorage::InitNew * * Purpose: * Provides the object with the IStorage to hold on to while the * object is running. Here we initialize the structure of the * storage and AddRef it for incremental access. This function will * only be called once in the object's lifetime in lieu of Load. * * Parameters: * pIStorage LPSTORAGE for the object. * * Return Value: * HRESULT NOERROR or a general error value. */
STDMETHODIMP CImpIPersistStorage::InitNew(LPSTORAGE pIStorage) { HRESULT hr;
USES_CONVERSION
if (PSSTATE_UNINIT!=m_psState) return ResultFromScode(E_UNEXPECTED);
if (NULL==pIStorage) return ResultFromScode(E_POINTER);
/*
* The rules of IPersistStorage mean we hold onto the IStorage * and pre-create anything we'd need in Save(...,TRUE) for * low-memory situations. For us this means creating our * "CONTENTS" stream and holding onto that IStream as * well as the IStorage here (requiring an AddRef call). */
hr=pIStorage->CreateStream(SZSTREAM, STGM_DIRECT | STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE , 0, 0, &m_pObj->m_pIStream);
if (FAILED(hr)) return hr;
//We expect that the client has called WriteClassStg
WriteFmtUserTypeStg(pIStorage, m_pObj->m_cf, T2W(ResourceString(IDS_USERTYPE)));
m_pObj->m_pIStorage=pIStorage; pIStorage->AddRef();
m_psState=PSSTATE_SCRIBBLE;
//Initialize the cache as needed.
m_pObj->m_pDefIPersistStorage->InitNew(pIStorage); return NOERROR; }
/*
* CImpIPersistStorage::Load * * Purpose: * Instructs the object to load itself from a previously saved * IStorage that was handled by Save in another object lifetime. * This function will only be called once in the object's lifetime * in lieu of InitNew. The object should hold on to pIStorage here * for incremental access and low-memory saves in Save. * * Parameters: * pIStorage LPSTORAGE from which to load. * * Return Value: * HRESULT NOERROR or a general error value. */
STDMETHODIMP CImpIPersistStorage::Load(LPSTORAGE pIStorage){ LPSTREAM pIStream; HRESULT hr;
if (PSSTATE_UNINIT!=m_psState) return ResultFromScode(E_UNEXPECTED);
if (NULL==pIStorage) return ResultFromScode(E_POINTER);
//We don't check CLSID to remain compatible with other chapters.
hr=pIStorage->OpenStream(SZSTREAM, 0, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pIStream);
if (FAILED(hr)) return ResultFromScode(STG_E_READFAULT);
// Load graph data from stream
hr = m_pObj->m_pCtrl->LoadFromStream(pIStream);
if (FAILED(hr)) { pIStream->Release(); return hr; }
/*
* We don't call pIStream->Release here because we may need * it for a low-memory save in Save. We also need to * hold onto a copy of pIStorage, meaning AddRef. */ m_pObj->m_pIStream = pIStream;
m_pObj->m_pIStorage = pIStorage; pIStorage->AddRef();
m_psState=PSSTATE_SCRIBBLE;
//We also need to tell the cache to load cached graphics
m_pObj->m_pDefIPersistStorage->Load(pIStorage); return NOERROR; }
/*
* CImpIPersistStorage::Save * * Purpose: * Saves the data for this object to an IStorage which may * or may not be the same as the one previously passed to * Load, indicated with fSameAsLoad. After this call we may * not write into the storage again until SaveCompleted is * called, although we may still read. * * Parameters: * pIStorage LPSTORAGE in which to save our data. * fSameAsLoad BOOL indicating if this is the same pIStorage * that was passed to Load. If TRUE, then the * object should write whatever it has *without * *using any extra memory* as this may be a low * memory save attempt. That means that you must * not try to open or create streams. If FALSE * you need to regenerate your whole storage * structure, being sure to also release any * pointers held from InitNew and Load. * * Return Value: * HRESULT NOERROR or a general error value. */
STDMETHODIMP CImpIPersistStorage::Save(LPSTORAGE pIStorage , BOOL fSameAsLoad) { LPSTREAM pIStream; HRESULT hr;
USES_CONVERSION
// Permit call in UNINIT state, if not SameAsLoad
if (PSSTATE_UNINIT == m_psState && fSameAsLoad) return ResultFromScode(E_POINTER);
//Must have an IStorage if we're not in SameAsLoad
if (NULL==pIStorage && !fSameAsLoad) return ResultFromScode(E_POINTER);
/*
* If we're saving to a new storage, create a new stream. * If fSameAsLoad it TRUE, then we write to the * stream we already allocated. We should NOT depends on * pIStorage with fSameAsLoad is TRUE. */ if (fSameAsLoad) { LARGE_INTEGER li;
/*
* Use pre-allocated streams to avoid failures due * to low-memory conditions. Be sure to reset the * stream pointer if you used this stream before!! */ pIStream=m_pObj->m_pIStream; LISet32(li, 0); pIStream->Seek(li, STREAM_SEEK_SET, NULL);
//This matches the Release below.
pIStream->AddRef(); } else { hr=pIStorage->CreateStream(SZSTREAM, STGM_DIRECT | STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE , 0, 0, &pIStream);
if (FAILED(hr)) return hr;
//Only do this with new storages.
WriteFmtUserTypeStg(pIStorage, m_pObj->m_cf, T2W(ResourceString(IDS_USERTYPE))); }
// Write graph info to stream
hr = m_pObj->m_pCtrl->SaveToStream(pIStream); pIStream->Release();
if (FAILED(hr)) return hr;
m_psState=PSSTATE_ZOMBIE;
// Clear the dirty flag if storage is the same.
if (fSameAsLoad) m_pObj->m_fDirty = FALSE;
//We also need to tell the cache to save cached graphics
m_pObj->m_pDefIPersistStorage->Save(pIStorage, fSameAsLoad); return NOERROR; }
/*
* CImpIPersistStorage::SaveCompleted * * Purpose: * Notifies the object that the storage in pIStorage has been * completely saved now. This is called when the user of this * object wants to save us in a completely new storage, and if * we normally hang on to the storage we have to reinitialize * ourselves here for this new one that is now complete. * * Parameters: * pIStorage LPSTORAGE of the new storage in which we live. * * Return Value: * HRESULT NOERROR or a general error value. */
STDMETHODIMP CImpIPersistStorage::SaveCompleted(LPSTORAGE pIStorage) { HRESULT hr; LPSTREAM pIStream;
//Must be called in no-scribble or hands-off state
if (!(PSSTATE_ZOMBIE==m_psState || PSSTATE_HANDSOFF==m_psState)) return ResultFromScode(E_UNEXPECTED);
//If we're coming from Hands-Off, we'd better get a storage
if (NULL==pIStorage && PSSTATE_HANDSOFF==m_psState) return ResultFromScode(E_UNEXPECTED);
/*
* If pIStorage is NULL, then we don't need to do anything * since we already have all the pointers we need for Save. * Otherwise we have to release any held pointers and * reinitialize them from pIStorage. */
if (NULL!=pIStorage) { hr=pIStorage->OpenStream(SZSTREAM, 0, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0 , &pIStream);
if (FAILED(hr)) return hr;
if (NULL!=m_pObj->m_pIStream) m_pObj->m_pIStream->Release();
m_pObj->m_pIStream=pIStream;
if (NULL!=m_pObj->m_pIStorage) m_pObj->m_pIStorage->Release();
m_pObj->m_pIStorage=pIStorage; m_pObj->m_pIStorage->AddRef(); }
//Change state back to scribble.
m_psState=PSSTATE_SCRIBBLE;
m_pObj->m_pDefIPersistStorage->SaveCompleted(pIStorage); return NOERROR; }
/*
* CImpIPersistStorage::HandsOffStorage * * Purpose: * Instructs the object that another agent is interested in having * total access to the storage we might be hanging on to from * InitNew or SaveCompleted. In this case we must release our hold * and await another call to SaveCompleted before we have a hold * again. Therefore we cannot read or write after this call until * SaveCompleted. * * Situations where this might happen arise in compound document * scenarios where this object might be in-place active but the * application wants to rename and commit the root storage. * Therefore we are asked to close our hold, let the container * party on the storage, then call us again later to tell us the * new storage we can hold. * * Parameters: * None * * Return Value: * HRESULT NOERROR or a general error value. */
STDMETHODIMP CImpIPersistStorage::HandsOffStorage(void) { /*
* Must come from scribble or no-scribble. A repeated call * to HandsOffStorage is an unexpected error (bug in client). */ if (PSSTATE_UNINIT==m_psState || PSSTATE_HANDSOFF==m_psState) return ResultFromScode(E_UNEXPECTED);
//Release held pointers
if (NULL!=m_pObj->m_pIStream) { m_pObj->m_pIStream->Release(); m_pObj->m_pIStream=NULL; }
if (NULL!=m_pObj->m_pIStorage) { m_pObj->m_pIStorage->Release(); m_pObj->m_pIStorage=NULL; }
m_psState=PSSTATE_HANDSOFF;
m_pObj->m_pDefIPersistStorage->HandsOffStorage(); return NOERROR; }
|
