mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
447 lines
11 KiB
447 lines
11 KiB
/*++
|
|
|
|
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;
|
|
}
|