644 lines
14 KiB
C++
644 lines
14 KiB
C++
|
// Copyright (C) 1996-1997 Microsoft Corporation. All rights reserved.
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// implementation of persistence interfaces for COleControl.
|
|||
|
|
//
|
|||
|
|
#include "header.h"
|
|||
|
|
#include "internet.h"
|
|||
|
|
|
|||
|
|
#include "CtlHelp.H"
|
|||
|
|
|
|||
|
|
// this is the name of the stream we'll save our ole controls to.
|
|||
|
|
//
|
|||
|
|
const WCHAR wszCtlSaveStream [] = L"CONTROLSAVESTREAM";
|
|||
|
|
|
|||
|
|
#ifndef _DEBUG
|
|||
|
|
#undef THIS_FILE
|
|||
|
|
static const char THIS_FILE[] = __FILE__;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
//=--------------------------------------------------------------------------=
|
|||
|
|
// 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
|
|||
|
|
|
|||
|
|
HRESULT COleControl::m_SaveToStream ( IStream *pStream )
|
|||
|
|
{
|
|||
|
|
return SaveStandardState(pStream);
|
|||
|
|
|
|||
|
|
#if 0
|
|||
|
|
01-Sep-1997 [ralphw] We don't save binary state
|
|||
|
|
|
|||
|
|
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;
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//=--------------------------------------------------------------------------=
|
|||
|
|
// 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"Width", &v, pErrorLog);
|
|||
|
|
if (SUCCEEDED(hr)) slHiMetric.cx = v.lVal;
|
|||
|
|
|
|||
|
|
v.lVal = 0;
|
|||
|
|
hr = pPropertyBag->Read(L"Height", &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"Width", &v);
|
|||
|
|
RETURN_ON_FAILURE(hr);
|
|||
|
|
|
|||
|
|
v.lVal = slHiMetric.cy;
|
|||
|
|
|
|||
|
|
hr = pPropertyBag->Write(L"Height", &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;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|