1072 lines
31 KiB
C++
1072 lines
31 KiB
C++
/*--------------------------------------------------------------------------*
|
|
*
|
|
* Microsoft Windows
|
|
* Copyright (C) Microsoft Corporation, 1992 - 1999
|
|
*
|
|
* File: siprop.cpp
|
|
*
|
|
* Contents: Implementation file for CSnapInPropertiesRoot, et al
|
|
*
|
|
* History: 04-Nov-99 jeffro Created
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
#include "stdafx.h"
|
|
#include "siprop.h"
|
|
#include "variant.h"
|
|
#include "mtnode.h"
|
|
|
|
|
|
#ifdef DBG
|
|
CTraceTag tagSnapInProps(_T("Snap-in Properties"), _T("Snap-in Properties"));
|
|
#endif
|
|
|
|
|
|
|
|
/*+=========================================================================*/
|
|
/* */
|
|
/* CSnapinPropertyComObject */
|
|
/* */
|
|
/*==========================================================================*/
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinPropertyComObject
|
|
*
|
|
* This is the COM object that exposes the Property object model interface.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
class CSnapinPropertyComObject :
|
|
public CMMCIDispatchImpl<Property>, // the Property interface
|
|
public CTiedComObject<CSnapinProperties>
|
|
{
|
|
typedef CSnapinProperties CMyTiedObject;
|
|
|
|
public:
|
|
BEGIN_MMC_COM_MAP(CSnapinPropertyComObject)
|
|
END_MMC_COM_MAP()
|
|
|
|
public:
|
|
// Property interface
|
|
MMC_METHOD1_PARAM (get_Value, VARIANT* /*pvarValue*/, m_key);
|
|
MMC_METHOD1_PARAM (put_Value, VARIANT /*varValue*/, m_key);
|
|
|
|
STDMETHODIMP get_Name (BSTR* pbstrName)
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinPropertyComObject::get_Name"));
|
|
|
|
/*
|
|
* validate parameters
|
|
*/
|
|
sc = ScCheckPointers (pbstrName);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
/*
|
|
* copy the name
|
|
*/
|
|
*pbstrName = SysAllocString (m_key.data());
|
|
if (*pbstrName == NULL)
|
|
return ((sc = E_OUTOFMEMORY).ToHr());
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
void SetKey (const CSnapinProperties::CPropertyKey& key)
|
|
{ m_key = key; }
|
|
|
|
private:
|
|
CSnapinProperties::CPropertyKey m_key;
|
|
};
|
|
|
|
|
|
/*+=========================================================================*/
|
|
/* */
|
|
/* CSnapinProperties implementation */
|
|
/* */
|
|
/*==========================================================================*/
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::FromInterface
|
|
*
|
|
* Returns a pointer to the CSnapinProperties object that implements
|
|
* the given interface, or NULL if the implementing object is not a
|
|
* CSnapinProperties.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CSnapinProperties* CSnapinProperties::FromInterface (IUnknown* pUnk)
|
|
{
|
|
CSnapinProperties* pProps;
|
|
|
|
/*
|
|
* dynamic_cast will throw if pUnk is junk (i.e. not a real interface
|
|
* pointer and not NULL), so do it in an exception frame.
|
|
*/
|
|
try
|
|
{
|
|
pProps = dynamic_cast<CSnapinProperties*>(pUnk);
|
|
}
|
|
catch (...)
|
|
{
|
|
pProps = NULL;
|
|
}
|
|
|
|
return (pProps);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::Item
|
|
*
|
|
* Returns an interface to a property identified by bstrName, which must
|
|
* be released by the caller. If the collection doesn't contain a property
|
|
* with the given name, a new property with the given name (initialized to
|
|
* VT_EMPTY) is added to the collection.
|
|
*
|
|
* Returns:
|
|
* S_OK the property was successfully returned
|
|
* S_FALSE the property was successfully returned, but didn't
|
|
* exist in the collection beforehand, so a new one
|
|
* was added
|
|
* E_INVALIDARG the property name wasn't valid (i.e. empty) or
|
|
* ppProperty was NULL
|
|
* E_OUTOFMEMORY not enough memory to perform the operation
|
|
* E_UNEXPECTED something dire happened
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
STDMETHODIMP CSnapinProperties::Item (
|
|
BSTR bstrName, /* I:name of property to get */
|
|
PPPROPERTY ppProperty) /* O:interface to property */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::Item"));
|
|
|
|
/*
|
|
* validate the parameters
|
|
*/
|
|
sc = ScCheckPointers (bstrName, ppProperty);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
const std::wstring strName = bstrName;
|
|
if (strName.empty())
|
|
return ((sc = E_INVALIDARG).ToHr());
|
|
|
|
bool fPropWasAdded = false;
|
|
|
|
/*
|
|
* Look up the property. If it's not there yet, add a new one (maybe).
|
|
*/
|
|
if (m_PropMap.find(strName) == m_PropMap.end())
|
|
{
|
|
/*
|
|
* Fail without implicitly adding if we're not attached to a snap-in.
|
|
* This will prevent us from adding properties that weren't
|
|
* registered with AddPropertyName
|
|
*/
|
|
if (m_spSnapinProps != NULL)
|
|
return ((sc = ScFromMMC(MMC_E_UnrecognizedProperty)).ToHr());
|
|
|
|
/*
|
|
* put an empty property in the map with the given name
|
|
*/
|
|
m_PropMap[strName] = CSnapinProperty();
|
|
fPropWasAdded = true;
|
|
}
|
|
|
|
/*
|
|
* get a COM object tied to the new property
|
|
*/
|
|
sc = ScGetPropertyComObject (strName, *ppProperty);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
if (*ppProperty == NULL)
|
|
return ((sc = E_UNEXPECTED).ToHr());
|
|
|
|
/*
|
|
* if we had to add the property, return S_FALSE so the caller can
|
|
* tell (if he cares)
|
|
*/
|
|
if (fPropWasAdded)
|
|
sc = S_FALSE;
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::get_Count
|
|
*
|
|
* Returns the number of properties in the collection in *pCount.
|
|
*
|
|
* Returns:
|
|
*
|
|
* S_OK success
|
|
* E_INVALIDARG pCount is NULL
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
STDMETHODIMP CSnapinProperties::get_Count (
|
|
PLONG pCount) /* O:number of items in the collection */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::get_Count"));
|
|
|
|
/*
|
|
* validate the parameters
|
|
*/
|
|
sc = ScCheckPointers (pCount);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
/*
|
|
* return the number of elements in the property map
|
|
*/
|
|
*pCount = m_PropMap.size();
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::Remove
|
|
*
|
|
* Removes a property from the collection.
|
|
*
|
|
* Returns:
|
|
* S_OK the property was successfully removed
|
|
* S_FALSE the property didn't exist in the collection
|
|
* E_INVALIDARG the property name wasn't valid (i.e. empty)
|
|
* E_UNEXPECTED something dire happened
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
STDMETHODIMP CSnapinProperties::Remove (
|
|
BSTR bstrName) /* I:name of property to remove */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::Remove"));
|
|
Trace (tagSnapInProps, _T("Snap-in Properties"));
|
|
|
|
/*
|
|
* validate the parameters
|
|
*/
|
|
sc = ScCheckPointers (bstrName);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
/*
|
|
* find the item to remove
|
|
*/
|
|
CPropertyIterator itProp = m_PropMap.find (bstrName);
|
|
if (itProp == m_PropMap.end())
|
|
return ((sc = S_FALSE).ToHr());
|
|
|
|
/*
|
|
* see if we can remove it
|
|
*/
|
|
if ( itProp->second.IsInitialized() &&
|
|
(itProp->second.GetFlags() & MMC_PROP_REMOVABLE) == 0)
|
|
return ((sc = ScFromMMC(MMC_E_CannotRemoveProperty)).ToHr());
|
|
|
|
/*
|
|
* Inform snapin before we remove the property about removal.
|
|
*/
|
|
sc = ScNotifyPropertyChange(itProp, itProp->second.GetValue(), MMC_PROPACT_DELETING);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
/*
|
|
* the snap-in approved the change, remove the property
|
|
*/
|
|
m_PropMap.erase (itProp);
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* CSnapinProperties::ScEnumNext
|
|
*
|
|
* PURPOSE: Returns the next Property interface.
|
|
*
|
|
* PARAMETERS:
|
|
* _Position & key :
|
|
* PDISPATCH & pDispatch :
|
|
*
|
|
* RETURNS:
|
|
* SC
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
SC CSnapinProperties::ScEnumNext (CPropertyKey &key, PDISPATCH & pDispatch)
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScEnumNext"));
|
|
Trace (tagSnapInProps, _T("Snap-in Properties"));
|
|
|
|
/*
|
|
* get the next element
|
|
*/
|
|
CPropertyIterator it = IteratorFromKey (key, false);
|
|
|
|
if(it == m_PropMap.end())
|
|
return (sc = S_FALSE); // out of elements.
|
|
|
|
/*
|
|
* get the Properties COM object for this property
|
|
*/
|
|
PropertyPtr spProperty;
|
|
sc = ScGetPropertyComObject (it->first, *&spProperty);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
if (spProperty == NULL)
|
|
return (sc = E_UNEXPECTED);
|
|
|
|
/*
|
|
* return the IDispatch for the object and leave a ref on it for the client
|
|
*/
|
|
pDispatch = spProperty.Detach();
|
|
|
|
// remember the enumeration key for next time
|
|
key = it->first;
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::ScEnumSkip
|
|
*
|
|
* Skips the next celt elements in the properties collection.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::ScEnumSkip (
|
|
unsigned long celt, /* I:number of items to skip */
|
|
unsigned long& celtSkipped, /* O:number of items skipped */
|
|
CPropertyKey& key) /* I/O:enumeration key */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScEnumSkip"));
|
|
Trace (tagSnapInProps, _T("Snap-in Properties"));
|
|
|
|
/*
|
|
* skip the next celt properties
|
|
*/
|
|
CPropertyIterator it = IteratorFromKey (key, false);
|
|
|
|
for (celtSkipped = 0;
|
|
(celtSkipped < celt) && (it != m_PropMap.end());
|
|
++celtSkipped, ++it)
|
|
{
|
|
/*
|
|
* remember the enumeration key for next time
|
|
*/
|
|
key = it->first;
|
|
}
|
|
|
|
/*
|
|
* if we advanced less than the requested number, return S_FALSE
|
|
*/
|
|
if (celtSkipped < celt)
|
|
sc = S_FALSE;
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::ScEnumReset
|
|
*
|
|
* Resets a CPropertyKey so that the next item it will return is the
|
|
* first item in the properties collection.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::ScEnumReset (
|
|
CPropertyKey& key) /* I/O:enumeration key to reset */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScEnumReset"));
|
|
|
|
key.erase();
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::get__NewEnum
|
|
*
|
|
* Creates returns an interface that can be queried for IEnumVARIANT
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
STDMETHODIMP CSnapinProperties::get__NewEnum (IUnknown** ppUnk)
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::get__NewEnum"));
|
|
Trace (tagSnapInProps, _T("Snap-in Properties"));
|
|
|
|
// validate the parameter
|
|
sc = ScCheckPointers (ppUnk);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
*ppUnk = NULL;
|
|
|
|
// typedef the enumerator
|
|
typedef CComObject<CMMCEnumerator<CSnapinProperties, CPropertyKey> > CEnumerator;
|
|
|
|
// create an instance of the enumerator
|
|
CEnumerator *pEnum = NULL;
|
|
sc = CEnumerator::CreateInstance (&pEnum);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
if(!pEnum)
|
|
return ((sc = E_UNEXPECTED).ToHr());
|
|
|
|
// create a connection between the enumerator and ourselves
|
|
sc = ScCreateConnection(*pEnum, *this);
|
|
if(sc)
|
|
return (sc.ToHr());
|
|
|
|
// initialize the position using the Reset function
|
|
sc = ScEnumReset (pEnum->m_position);
|
|
if(sc)
|
|
return (sc.ToHr());
|
|
|
|
// get the IUnknown to return
|
|
sc = pEnum->QueryInterface (IID_IUnknown, (void**) ppUnk);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::IteratorFromKey
|
|
*
|
|
* Returns the iterator in the property map corresponding to the first
|
|
* element following the one designated by key.
|
|
*
|
|
* The caller might be interested in an exact match or the nearest match.
|
|
* The nearest match would be suitable when the key is used in an
|
|
* enumeration. Let's say that the collection consists of "Alpha", "Bravo",
|
|
* and "Charlie". The first request for an item will return "Alpha" and
|
|
* the key will hold "Alpha" (see comments for CPropertyKey). Let's
|
|
* assume that "Alpha" is removed from the collection and then the enumeration
|
|
* continues. We want to return the one after the last one we got back
|
|
* ("Alpha") which would be "Bravo". All is well.
|
|
*
|
|
* An exact match would be required when trying to find a CSnapinProperty
|
|
* for a CSnapinPropertyComObject. The COM object will refer to a specific
|
|
* property, which we want to be sure to find every time. A close match
|
|
* isn't sufficient.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CSnapinProperties::CPropertyIterator
|
|
CSnapinProperties::IteratorFromKey (
|
|
const CPropertyKey& key, /* I:key to convert */
|
|
bool fExactMatch) /* I:match key exactly? */
|
|
{
|
|
CPropertyIterator it;
|
|
|
|
/*
|
|
* need an exact match?
|
|
*/
|
|
if (fExactMatch)
|
|
{
|
|
/*
|
|
* nothing matches an empty key
|
|
*/
|
|
if (key.empty())
|
|
it = m_PropMap.end();
|
|
|
|
/*
|
|
* the key's not empty, look up the property
|
|
*/
|
|
else
|
|
it = m_PropMap.find (key);
|
|
}
|
|
|
|
/*
|
|
* nearest match
|
|
*/
|
|
else
|
|
{
|
|
/*
|
|
* the beginning of the map is nearest an empty key
|
|
*/
|
|
if (key.empty())
|
|
it = m_PropMap.begin();
|
|
|
|
/*
|
|
* otherwise, find the nearest one greater than the key
|
|
*/
|
|
else
|
|
it = m_PropMap.upper_bound (key);
|
|
}
|
|
|
|
|
|
return (it);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::ScInitialize
|
|
*
|
|
* Initializes a CSnapinProperties. This function will return an error if
|
|
* psip is NULL, or if there's an error copying the initial properties.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::ScInitialize (
|
|
ISnapinProperties* psip, /* I:snap-in's ISnapinProperties iface */
|
|
Properties* pInitProps_, /* I:initial properties for the snap-in */
|
|
CMTSnapInNode* pMTSnapInNode) /* I:snap-in these properties belong to */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScInitialize"));
|
|
|
|
/*
|
|
* validate the parameters
|
|
*/
|
|
sc = ScCheckPointers (psip);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
/*
|
|
* pInitProps_ is optional, but if it was given, it should be the
|
|
* one implemented by CSnapinProperties
|
|
*/
|
|
CSnapinProperties* pInitProps = FromInterface (pInitProps_);
|
|
if ((pInitProps_ != NULL) && (pInitProps == NULL))
|
|
return (sc = E_INVALIDARG);
|
|
|
|
/*
|
|
* keep the the snap-in and the snap-in's interface
|
|
*/
|
|
m_pMTSnapInNode = pMTSnapInNode;
|
|
m_spSnapinProps = psip;
|
|
|
|
/*
|
|
* get the names of the properties recognized by the snap-in
|
|
*/
|
|
sc = psip->QueryPropertyNames (this);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
/*
|
|
* If we're reloading a snap-in's properties from the console file,
|
|
* weed out entries that the snap-in registered last time but didn't
|
|
* register this time.
|
|
*/
|
|
if (pInitProps == this)
|
|
{
|
|
CPropertyIterator itProp = m_PropMap.begin();
|
|
|
|
while (itProp != m_PropMap.end())
|
|
{
|
|
/*
|
|
* snap-in registered? keep it
|
|
*/
|
|
if (itProp->second.IsRegisteredBySnapin())
|
|
++itProp;
|
|
|
|
/*
|
|
* snap-in didn't register, toss it
|
|
*/
|
|
else
|
|
itProp = m_PropMap.erase (itProp);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Otherwise, if we got initial properties, find each property
|
|
* that the snap-in registered in set of initial properties and
|
|
* copy them to the snap-in's collection.
|
|
*/
|
|
else if (pInitProps != NULL)
|
|
{
|
|
sc = ScMergeProperties (*pInitProps);
|
|
if (sc)
|
|
return (sc);
|
|
}
|
|
|
|
/*
|
|
* initialize the ISnapinProperties interface
|
|
*/
|
|
sc = psip->Initialize (this);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
/*
|
|
* give the ISnapinProperties its initial property values
|
|
*/
|
|
if (!m_PropMap.empty())
|
|
{
|
|
/*
|
|
* Build an array of CSmartProperty objects to pass to
|
|
* ISnapinProperties::PropertiesChanged. CSmartProperty objects
|
|
* look just like MMC_SNAPIN_PROPERTY structures, but use a
|
|
* CComVariant instead of VARIANT for automatic resource management.
|
|
* See the definition of CSmartProperty.
|
|
*/
|
|
CAutoArrayPtr<CSmartProperty> spInitialProps (
|
|
new (std::nothrow) CSmartProperty[m_PropMap.size()]);
|
|
|
|
if (spInitialProps == NULL)
|
|
return (sc = E_OUTOFMEMORY);
|
|
|
|
CPropertyIterator it = m_PropMap.begin();
|
|
for (int i = 0; it != m_PropMap.end(); ++it, ++i)
|
|
{
|
|
spInitialProps[i].pszPropName = it->first.data();
|
|
spInitialProps[i].varValue = it->second.GetValue();
|
|
spInitialProps[i].eAction = MMC_PROPACT_INITIALIZED;
|
|
}
|
|
|
|
/*
|
|
* we don't want to trace a failure here, so use a local SC
|
|
*/
|
|
SC scLocal = ScNotifyPropertyChange (spInitialProps, m_PropMap.size());
|
|
if (scLocal)
|
|
return (scLocal);
|
|
}
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::ScSetSnapInNode
|
|
*
|
|
* Attaches this properties collection to a CMTSnapInNode.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::ScSetSnapInNode (CMTSnapInNode* pMTSnapInNode)
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScSetSnapInNode"));
|
|
|
|
m_pMTSnapInNode = pMTSnapInNode;
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::ScMergeProperties
|
|
*
|
|
* Merges the properties from another property collection into this one.
|
|
* Only properties that already exist in the destination collection are
|
|
* copied from the source.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::ScMergeProperties (const CSnapinProperties& other)
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScMergeProperties"));
|
|
|
|
/*
|
|
* for each property in the other collection...
|
|
*/
|
|
CConstPropertyIterator itOtherProp;
|
|
|
|
for (itOtherProp = other.m_PropMap.begin();
|
|
(itOtherProp != other.m_PropMap.end()) && !sc.IsError();
|
|
++itOtherProp)
|
|
{
|
|
/*
|
|
* look for a corresponding property in the our set
|
|
*/
|
|
CPropertyIterator itProp = m_PropMap.find (itOtherProp->first);
|
|
|
|
/*
|
|
* if it's in our set, copy its value
|
|
*/
|
|
if (itProp != m_PropMap.end())
|
|
sc = itProp->second.ScSetValue (itOtherProp->second.GetValue());
|
|
}
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::AddPropertyName
|
|
*
|
|
* This method is called by the snap-in from its implementation of
|
|
* ISnapinProperties::QueryPropertyNames to register the properties it
|
|
* recognizes.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
STDMETHODIMP CSnapinProperties::AddPropertyName (
|
|
LPCOLESTR pszPropName, /* I:property name */
|
|
DWORD dwFlags) /* I:flags for this property */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::AddPropertyName"));
|
|
|
|
/*
|
|
* validate the parameters
|
|
*/
|
|
sc = ScCheckPointers (pszPropName);
|
|
if (sc)
|
|
return (sc.ToHr());
|
|
|
|
const std::wstring strName = pszPropName;
|
|
if (strName.empty())
|
|
return ((sc = E_INVALIDARG).ToHr());
|
|
|
|
/*
|
|
* make sure no undocumented flags were passed in
|
|
*/
|
|
if ((dwFlags & ~CSnapinProperty::PublicFlags) != 0)
|
|
return ((sc = E_INVALIDARG).ToHr());
|
|
|
|
/*
|
|
* if the property already exists (from a persisted collection),
|
|
* just update the flags; otherwise add a property with the given
|
|
* name and flags
|
|
*/
|
|
CPropertyIterator itProp = m_PropMap.find (strName);
|
|
|
|
if (itProp != m_PropMap.end())
|
|
itProp->second.InitializeFlags (dwFlags);
|
|
else
|
|
{
|
|
m_PropMap[strName] = CSnapinProperty(dwFlags);
|
|
m_PropMap[strName].SetRegisteredBySnapin();
|
|
}
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::ScNotifyPropertyChange
|
|
*
|
|
* Notifies the snap-in that owns this collection of a change to it's
|
|
* properties. This function delegates the heavy lifting to
|
|
*
|
|
* ScNotifyPropertyChange (CSmartProperty*, ULONG);
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::ScNotifyPropertyChange (
|
|
CPropertyIterator itProp, /* I:changing property */
|
|
const VARIANT& varValue, /* I:if action is remove then this is current value
|
|
else if action is set then this is the proposed value */
|
|
MMC_PROPERTY_ACTION eAction) /* I:what's happening to the prop? */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScNotifyPropertyChange"));
|
|
|
|
ASSERT(eAction == MMC_PROPACT_CHANGING || eAction == MMC_PROPACT_DELETING);
|
|
/*
|
|
* validate the parameters
|
|
*/
|
|
if (itProp == m_PropMap.end())
|
|
return (sc = E_INVALIDARG);
|
|
|
|
/*
|
|
* make sure we're allowed to change the property
|
|
*/
|
|
if ( itProp->second.IsInitialized() &&
|
|
(itProp->second.GetFlags() & MMC_PROP_MODIFIABLE) == 0)
|
|
return (sc = ScFromMMC (MMC_E_CannotChangeProperty));
|
|
|
|
/*
|
|
* if this property change will affect the UI, and the snap-in
|
|
* isn't awake yet, wake him up
|
|
*/
|
|
if ((itProp->second.GetFlags() & MMC_PROP_CHANGEAFFECTSUI) &&
|
|
(m_pMTSnapInNode != NULL) &&
|
|
!m_pMTSnapInNode->IsInitialized())
|
|
{
|
|
sc = m_pMTSnapInNode->Init();
|
|
if (sc)
|
|
return (sc);
|
|
}
|
|
|
|
/*
|
|
* we don't want to trace failures here, so don't assign to sc
|
|
*/
|
|
CSmartProperty SmartProp (itProp->first.data(), varValue, eAction);
|
|
SC scNoTrace = ScNotifyPropertyChange (&SmartProp, 1);
|
|
if (scNoTrace.ToHr() != S_OK)
|
|
return (scNoTrace);
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::ScNotifyPropertyChange
|
|
*
|
|
* Notifies the snap-in that owns this collection of a change to it's
|
|
* properties.
|
|
*
|
|
* The snap-in will return:
|
|
* S_OK change was successful
|
|
* S_FALSE change was ignored
|
|
* E_INVALIDARG a changed property was invalid (e.g. a malformed
|
|
* computer name)
|
|
* E_FAIL a changed property was valid, but couldn't be used
|
|
* (e.g. a valid name for a computer that couldn't be
|
|
* located)
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::ScNotifyPropertyChange (
|
|
CSmartProperty* pProps, /* I:changing props */
|
|
ULONG cProps) /* I:how many are there? */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScNotifyPropertyChange"));
|
|
|
|
/*
|
|
* if we're not connected to a snap-in, short out
|
|
*/
|
|
if (m_spSnapinProps == NULL)
|
|
return (sc);
|
|
|
|
/*
|
|
* validate the parameters
|
|
*/
|
|
sc = ScCheckPointers (pProps, E_UNEXPECTED);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
if (cProps == 0)
|
|
return (sc = E_UNEXPECTED);
|
|
|
|
/*
|
|
* we don't want to trace failures here, so don't assign to sc
|
|
*/
|
|
return (m_spSnapinProps->PropertiesChanged (
|
|
cProps,
|
|
reinterpret_cast<MMC_SNAPIN_PROPERTY*>(pProps)));
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::Scget_Value
|
|
*
|
|
* Returns the value of the property.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::Scget_Value (VARIANT* pvarValue, const CPropertyKey& key)
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::Scget_Value"));
|
|
|
|
/*
|
|
* validate parameters
|
|
*/
|
|
pvarValue = ConvertByRefVariantToByValue (pvarValue);
|
|
sc = ScCheckPointers (pvarValue);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
/*
|
|
* get the iterator for the requested property
|
|
*/
|
|
CPropertyIterator itProp = IteratorFromKey (key, true);
|
|
if (itProp == m_PropMap.end())
|
|
return (sc = E_INVALIDARG);
|
|
|
|
/*
|
|
* give it to the caller
|
|
*/
|
|
const VARIANT& varValue = itProp->second.GetValue();
|
|
sc = VariantCopy (pvarValue, const_cast<VARIANT*>(&varValue));
|
|
if (sc)
|
|
return (sc);
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::Scput_Value
|
|
*
|
|
* Changes the value of the property.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::Scput_Value (VARIANT varValue, const CPropertyKey& key)
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::Scput_Value"));
|
|
|
|
/*
|
|
* convert possible by-ref VARIANT
|
|
*/
|
|
VARIANT* pvarValue = ConvertByRefVariantToByValue (&varValue);
|
|
sc = ScCheckPointers (pvarValue);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
/*
|
|
* make sure this is of the type we can persist
|
|
*/
|
|
if (!CXMLVariant::IsPersistable(pvarValue))
|
|
return (sc = E_INVALIDARG);
|
|
|
|
/*
|
|
* get the iterator for the requested property
|
|
*/
|
|
CPropertyIterator itProp = IteratorFromKey (key, true);
|
|
if (itProp == m_PropMap.end())
|
|
return (sc = E_INVALIDARG);
|
|
|
|
/*
|
|
* Notify the snap-in of the proposed change.
|
|
*/
|
|
sc = ScNotifyPropertyChange (itProp, *pvarValue, MMC_PROPACT_CHANGING);
|
|
if (sc)
|
|
return sc;
|
|
|
|
/*
|
|
* the snap-in approved the change, update the property value
|
|
*/
|
|
sc = itProp->second.ScSetValue (*pvarValue);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::ScGetPropertyComObject
|
|
*
|
|
* Returns a Property interface on a COM object tied to property identified
|
|
* by key. The returned interface is a tear-off interface. The collection
|
|
* will not hold a reference to it, but instead will generate a new object
|
|
* for each request for a Property.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CSnapinProperties::ScGetPropertyComObject (
|
|
const CPropertyKey& key, /* I:the key for this property */
|
|
Property*& rpProperty) /* O:the Property interface */
|
|
{
|
|
DECLARE_SC (sc, _T("CSnapinProperties::ScGetPropertyComObject"));
|
|
|
|
/*
|
|
* create a CSnapinPropertyComObject if necessary
|
|
*/
|
|
CSnapinPropertyComObject* pComObj = NULL;
|
|
typedef CTiedComObjectCreator<CSnapinPropertyComObject> ObjectCreator;
|
|
sc = ObjectCreator::ScCreateAndConnect (*this, pComObj);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
if (pComObj == NULL)
|
|
return (sc = E_UNEXPECTED);
|
|
|
|
/*
|
|
* tell the object what its key is
|
|
*/
|
|
pComObj->SetKey (key);
|
|
|
|
/*
|
|
* put a ref on for the caller (note that the collection will *not*
|
|
* hold a reference to the property)
|
|
*/
|
|
rpProperty = pComObj;
|
|
rpProperty->AddRef();
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::Persist
|
|
*
|
|
* Persists the property collection to/from an XML persistor.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CSnapinProperties::Persist (CPersistor &persistor)
|
|
{
|
|
if (persistor.IsStoring())
|
|
{
|
|
for (CPropertyIterator it = m_PropMap.begin(); it != m_PropMap.end(); ++it)
|
|
{
|
|
if (it->second.GetFlags() & MMC_PROP_PERSIST)
|
|
PersistWorker (persistor, it);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* clear out any existing properties
|
|
*/
|
|
m_PropMap.clear();
|
|
|
|
// let the base class do the job
|
|
// it will call OnNewElement for every element found
|
|
XMLListCollectionBase::Persist(persistor);
|
|
}
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::PersistWorker
|
|
*
|
|
* Persists an individual element of the CPropertyMap to/from an XML
|
|
* persistor. It exists solely to prevent CSnapinProperties::Persist from
|
|
* calling W2CT (which implicitly calls _alloca) in a loop.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CSnapinProperties::PersistWorker (CPersistor& persistor, CPropertyIterator it)
|
|
{
|
|
USES_CONVERSION;
|
|
persistor.Persist (it->second, W2CT(it->first.data()));
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperties::OnNewElement
|
|
*
|
|
* XMLListCollectionBase::Persist will call this method for every element
|
|
* to be read from the persistor.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CSnapinProperties::OnNewElement(CPersistor& persistor)
|
|
{
|
|
/*
|
|
* read the property name
|
|
*/
|
|
std::wstring strName;
|
|
persistor.PersistAttribute (XML_ATTR_SNAPIN_PROP_NAME, strName);
|
|
|
|
/*
|
|
* read the property itself
|
|
*/
|
|
USES_CONVERSION;
|
|
CSnapinProperty prop;
|
|
persistor.Persist (prop, W2CT(strName.data()));
|
|
|
|
/*
|
|
* put the property in the map
|
|
*/
|
|
m_PropMap[strName] = prop;
|
|
}
|
|
|
|
|
|
/*+=========================================================================*/
|
|
/* */
|
|
/* CSnapinProperty implementation */
|
|
/* */
|
|
/*==========================================================================*/
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CSnapinProperty::Persist
|
|
*
|
|
* Persists the property to/from an XML persistor.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CSnapinProperty::Persist (CPersistor &persistor)
|
|
{
|
|
/*
|
|
* persist the value and flags (but not the private ones)
|
|
*/
|
|
DWORD dwFlags;
|
|
|
|
if (persistor.IsStoring())
|
|
dwFlags = m_dwFlags & ~PrivateFlags;
|
|
|
|
persistor.Persist (m_varValue);
|
|
persistor.PersistAttribute (XML_ATTR_SNAPIN_PROP_FLAGS, dwFlags);
|
|
|
|
if (persistor.IsLoading())
|
|
m_dwFlags = dwFlags;
|
|
}
|