CTLPSST.CPP
//=--------------------------------------------------------------------------=
// CtlPsst.Cpp
//=--------------------------------------------------------------------------=
// Copyright 1995 - 1998 Microsoft Corporation. All Rights Reserved.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//=--------------------------------------------------------------------------=
//
// implementation of persistence interfaces for COleControl.
//
#include "IPServer.H"
#include "CtrlObj.H"
#include "CtlHelp.H"
#include "Util.H"
// this is the name of the stream we'll save our ole controls to.
//
const WCHAR wszCtlSaveStream [] = L"CONTROLSAVESTREAM";
// for ASSERT and FAIL
//
SZTHISFILE
//=--------------------------------------------------------------------------=
// to help with out stream save implementation ...
//
#define STREAMHDR_SIGNATURE 0x12344321 // Signature to identify our format (avoid crashes!)
#define IPROP_END 0xFF // Marker at end of property list
#define MAXAUTOBUF 3800 // Best if < 1 page.
typedef struct tagSTREAMHDR {
DWORD dwSignature; // Signature.
size_t cbWritten; // Number of bytes written
} STREAMHDR;
//=--------------------------------------------------------------------------=
// COleControl persistence interfaces
//=--------------------------------------------------------------------------=
//=--------------------------------------------------------------------------=
// COleControl::Load [IPersistPropertyBag]
//=--------------------------------------------------------------------------=
// IPersistPropertyBag. we've got a property bag, so let's load our properties
// from it.
//
// Parameters:
// IPropertyBag * - [in] pbag from which to read props.
// IErrorLog * - [in] error log to write to
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::Load
(
IPropertyBag *pPropertyBag,
IErrorLog *pErrorLog
)
{
HRESULT hr;
// load in our standard state first. nothing serious here ... currently,
// we've just got two properties, for cx and cy.
//
hr = LoadStandardState(pPropertyBag, pErrorLog);
RETURN_ON_FAILURE(hr);
// now call the user text load function, and get them to load in whatever
// they're interested in.
//
hr = LoadTextState(pPropertyBag, pErrorLog);
return hr;
}
//=--------------------------------------------------------------------------=
// COleControl::Save [IPersistPropertyBag]
//=--------------------------------------------------------------------------=
// given a property bag, save out all the relevant state information.
//
// Parameters:
// IPropertyBag * - [in] property to write to
// BOOL - [in] do we clear the dirty bit?
// BOOL - [in] do we write out default values anyhoo?
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::Save
(
IPropertyBag *pPropertyBag,
BOOL fClearDirty,
BOOL fWriteDefault
)
{
HRESULT hr;
// save out standard state information
//
hr = SaveStandardState(pPropertyBag);
RETURN_ON_FAILURE(hr);
// now call the user function and get them to save out
// all of their properties.
//
hr = SaveTextState(pPropertyBag, fWriteDefault);
RETURN_ON_FAILURE(hr);
// now clear the dirty flag and send out notification that we're
// done.
//
if (fClearDirty)
m_fDirty = FALSE;
if (m_pOleAdviseHolder)
m_pOleAdviseHolder->SendOnSave();
return S_OK;
}
//=--------------------------------------------------------------------------=
// COleControl::GetClassID [IPersistStreamInit]
//=--------------------------------------------------------------------------=
// returns the classid of this mamma
//
// Parameters:
// CLSID * - [out] where to put the clsid
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::GetClassID
(
CLSID *pclsid
)
{
CHECK_POINTER(pclsid);
// copy the thing over
//
*pclsid = CLSIDOFOBJECT(m_ObjectType);
return S_OK;
}
//=--------------------------------------------------------------------------=
// COleControl::IsDirty [IPersistStreamInit]
//=--------------------------------------------------------------------------=
// asks if we're dirty or not. duh.
//
// Output:
// HRESULT - S_OK: dirty, S_FALSE: not dirty
//
// Notes:
//
STDMETHODIMP COleControl::IsDirty
(
void
)
{
return (m_fDirty) ? S_OK : S_FALSE;
}
//=--------------------------------------------------------------------------=
// COleControl::InitNew [IPersistStreamInit]
//=--------------------------------------------------------------------------=
// causes the control to intialize itself with a new bunch of state information
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::InitNew
(
void
)
{
BOOL f;
// call the overridable function to do this work
//
f = InitializeNewState();
return (f) ? S_OK : E_FAIL;
}
//=--------------------------------------------------------------------------=
// COleControl::GetSizeMax [IPersistStreamInit]
//=--------------------------------------------------------------------------=
//
// Parameters:
// ULARGE_INTEGER * - [out]
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::GetSizeMax
(
ULARGE_INTEGER *pulMaxSize
)
{
return E_NOTIMPL;
}
//=--------------------------------------------------------------------------=
// COleControl::Load [IPersistStreamInit]
//=--------------------------------------------------------------------------=
// load from an IStream
//
// Parameters:
// IStream * - [in] stream from which to load
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::Load
(
IStream *pStream
)
{
HRESULT hr;
// first thing to do is read in standard properties the user don't
// persist themselves.
//
hr = LoadStandardState(pStream);
RETURN_ON_FAILURE(hr);
// load in the user properties. this method is one they -have- to implement
// themselves.
//
hr = LoadBinaryState(pStream);
return hr;
}
//=--------------------------------------------------------------------------=
// COleControl::Save [IPersistStreamInit]
//=--------------------------------------------------------------------------=
// saves out our state using streams
//
// Parameters:
// IStream * - [in]
// BOOL - [in] clear dirty bit?
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::Save
(
IStream *pStream,
BOOL fClearDirty
)
{
HRESULT hr;
// use our helper routine that we share with the IStorage persistence
// code.
//
hr = m_SaveToStream(pStream);
RETURN_ON_FAILURE(hr);
// clear out dirty flag [if appropriate] and notify that we're done
// with save.
//
if (fClearDirty)
m_fDirty = FALSE;
if (m_pOleAdviseHolder)
m_pOleAdviseHolder->SendOnSave();
return S_OK;
}
//=--------------------------------------------------------------------------=
// COleControl::InitNew [IPersistStorage]
//=--------------------------------------------------------------------------=
// ipersiststorage version of this. fweee
//
// Parameters:
// IStorage * - [in] we don't use this
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::InitNew
(
IStorage *pStorage
)
{
// we already have an implementation of this [for IPersistStreamInit]
//
return InitNew();
}
//=--------------------------------------------------------------------------=
// COleControl::Load [IPersistStorage]
//=--------------------------------------------------------------------------=
// Ipersiststorage version of this
//
// Parameters:
// IStorage * - [in] DUH.
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::Load(IStorage *pStorage)
{
IStream *pStream;
HRESULT hr;
// we're going to use IPersistStream::Load from the CONTENTS stream.
//
hr = pStorage->OpenStream(wszCtlSaveStream, 0, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
RETURN_ON_FAILURE(hr);
// IPersistStreamInit::Load
//
hr = Load(pStream);
pStream->Release();
return hr;
}
//=--------------------------------------------------------------------------=
// COleControl::Save [IPersistStorage]
//=--------------------------------------------------------------------------=
// save into the contents stream of the given storage object.
//
// Parameters:
// IStorage * - [in] 10 points if you figure it out
// BOOL - [in] is the storage the same as the load storage?
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::Save
(
IStorage *pStorage,
BOOL fSameAsLoad
)
{
IStream *pStream;
HRESULT hr;
// we're just going to save out to the CONTENTES stream.
//
hr = pStorage->CreateStream(wszCtlSaveStream, STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
0, 0, &pStream);
RETURN_ON_FAILURE(hr);
// use our helper routine.
//
hr = m_SaveToStream(pStream);
m_fSaveSucceeded = (FAILED(hr)) ? FALSE : TRUE;
pStream->Release();
return hr;
}
//=--------------------------------------------------------------------------=
// COleControl::SaveCompleted [IPersistStorage]
//=--------------------------------------------------------------------------=
// lets us clear out our flags.
//
// Parameters:
// IStorage * - ignored
//
// Output:
// HRESULT
//
// Notes:
//
STDMETHODIMP COleControl::SaveCompleted
(
IStorage *pStorageNew
)
{
// if our save succeeded, then we can do our post save work.
//
if (m_fSaveSucceeded) {
m_fDirty = FALSE;
if (m_pOleAdviseHolder)
m_pOleAdviseHolder->SendOnSave();
}
return S_OK;
}
//=--------------------------------------------------------------------------=
// COleControl::HandsOffStorage [IPersistStorage]
//=--------------------------------------------------------------------------=
// not interesting
//
// Output:
// S_OK
//
// Notes:
//
STDMETHODIMP COleControl::HandsOffStorage
(
void
)
{
// we don't ever hold on to a storage pointer, so this is remarkably
// uninteresting to us.
//
return S_OK;
}
//=--------------------------------------------------------------------------=
// COleControl::m_SaveToStream [helper: IPersistStreamInit/IPersistStorage]
//=--------------------------------------------------------------------------=
// save ourselves to a stream
//
// Parameters:
// IStream * - figure it out
//
// Output:
// HRESULT
//
// Notes:
//
HRESULT COleControl::m_SaveToStream
(
IStream *pStream
)
{
HRESULT hr;
// save out standard state information that the user has no control
// over
//
hr = SaveStandardState(pStream);
RETURN_ON_FAILURE(hr);
// save out user-specific satte information. they MUST implement this
// function
//
hr = SaveBinaryState(pStream);
return hr;
}
//=--------------------------------------------------------------------------=
// COleControl::LoadStandardState [ helper ]
//=--------------------------------------------------------------------------=
// reads in standard properties that all controls are going to have, using
// text persistence APIs. there is another version for streams.
//
// Parameters:
// IPropertyBag * - [in]
// IErrorLog * - [in]
//
// Output:
// HRESULT
//
// Notes:
//
HRESULT COleControl::LoadStandardState
(
IPropertyBag *pPropertyBag,
IErrorLog *pErrorLog
)
{
VARIANT v;
HRESULT hr;
SIZEL slHiMetric = { 100, 50 };
// currently, our only standard properties are related to size.
// if we can't find them, then we'll just use some defaults.
//
v.vt = VT_I4;
v.lVal = 0;
hr = pPropertyBag->Read(L"_ExtentX", &v, pErrorLog);
if (SUCCEEDED(hr)) slHiMetric.cx = v.lVal;
v.lVal = 0;
hr = pPropertyBag->Read(L"_ExtentY", &v, pErrorLog);
if (SUCCEEDED(hr)) slHiMetric.cy = v.lVal;
HiMetricToPixel(&slHiMetric, &m_Size);
return S_OK;
}
//=--------------------------------------------------------------------------=
// COleControl::LoadStandardState [ helper ]
//=--------------------------------------------------------------------------=
// reads in standard properties that all controls are going to have, using
// stream persistence APIs. there is another version for text.
//
// Parameters:
// IStream * - [in]
//
// Output:
// HRESULT
//
// Notes:
//
HRESULT COleControl::LoadStandardState
(
IStream *pStream
)
{
STREAMHDR stmhdr;
HRESULT hr;
SIZEL slHiMetric;
// look for our header structure, so we can verify stream validity.
//
hr = pStream->Read(&stmhdr, sizeof(STREAMHDR), NULL);
RETURN_ON_FAILURE(hr);
if (stmhdr.dwSignature != STREAMHDR_SIGNATURE)
return E_UNEXPECTED;
// currently, the only standard state we're writing out is
// a SIZEL structure describing the control's size.
//
if (stmhdr.cbWritten != sizeof(m_Size))
return E_UNEXPECTED;
// we like the stream. let's go load in our two properties.
//
hr = pStream->Read(&slHiMetric, sizeof(slHiMetric), NULL);
RETURN_ON_FAILURE(hr);
HiMetricToPixel(&slHiMetric, &m_Size);
return S_OK;
}
//=--------------------------------------------------------------------------=
// COleControl::SaveStandardState [ helper ]
//=--------------------------------------------------------------------------=
// saves out standard properties that we're managing for a control using text
// persistence APIs. there is another version for stream persistence.
//
// Parameters:
// IPropertyBag * - [in]
//
// Output:
// HRESULT
//
// Notes:
//
HRESULT COleControl::SaveStandardState
(
IPropertyBag *pPropertyBag
)
{
HRESULT hr;
VARIANT v;
SIZEL slHiMetric;
// currently, the only standard proprerties we persist are Size related
//
PixelToHiMetric(&m_Size, &slHiMetric);
v.vt = VT_I4;
v.lVal = slHiMetric.cx;
hr = pPropertyBag->Write(L"_ExtentX", &v);
RETURN_ON_FAILURE(hr);
v.lVal = slHiMetric.cy;
hr = pPropertyBag->Write(L"_ExtentY", &v);
return hr;
}
//=--------------------------------------------------------------------------=
// COleControl::SaveStandardState [ helper ]
//=--------------------------------------------------------------------------=
// saves out standard properties that we're managing for a control using stream
// persistence APIs. there is another version for text persistence.
//
// Parameters:
// IStream * - [in]
//
// Output:
// HRESULT
//
// Notes:
//
HRESULT COleControl::SaveStandardState
(
IStream *pStream
)
{
STREAMHDR streamhdr = { STREAMHDR_SIGNATURE, sizeof(SIZEL) };
HRESULT hr;
SIZEL slHiMetric;
// first thing to do is write out our stream hdr structure.
//
hr = pStream->Write(&streamhdr, sizeof(STREAMHDR), NULL);
RETURN_ON_FAILURE(hr);
// the only properties we're currently persisting here are the size
// properties for this control. make sure we do that in HiMetric
//
PixelToHiMetric(&m_Size, &slHiMetric);
hr = pStream->Write(&slHiMetric, sizeof(slHiMetric), NULL);
return hr;
}
//=--------------------------------------------------------------------------=
// COleControl::InitializeNewState [overridable]
//=--------------------------------------------------------------------------=
// the user can override this to initialize variables
//
// Output:
// BOOL - FALSE means couldn't do it.
//
// Notes:
//
BOOL COleControl::InitializeNewState
(
void
)
{
// we find this largely uninteresting
//
return TRUE;
}