1462 lines
36 KiB
C++
1462 lines
36 KiB
C++
// Copyright (c) 2000-2000 Microsoft Corporation
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// PropMgr_Impl
|
|
//
|
|
// Property manager server class
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
|
|
|
|
#include "oleacc_p.h"
|
|
|
|
|
|
#include <atlbase.h>
|
|
extern CComModule _Module;
|
|
#include <atlcom.h>
|
|
|
|
|
|
#include "PropMgr_Util.h"
|
|
#include "PropMgr_Impl.h"
|
|
#include "PropMgr_Mem.h"
|
|
|
|
#pragma warning(push, 3)
|
|
#pragma warning(disable: 4530)
|
|
#include <map>
|
|
#include <vector>
|
|
#pragma warning(pop)
|
|
|
|
|
|
#include "debug.h"
|
|
|
|
|
|
/*
|
|
|
|
Format of item record:
|
|
|
|
* size prefix
|
|
|
|
* 'Properties present' bitmask
|
|
Indicates that the property is present for this key
|
|
|
|
* 'Property is a variant' bitmask
|
|
For present properties, indicates whether the property is a VARIANT
|
|
versus an object reference.
|
|
|
|
* 'Property has container scope' bitmask
|
|
Indicates that the property applies to this key, and to all that element's
|
|
simple children.
|
|
|
|
|
|
* Property data: For each property which is present (see 'property present'
|
|
bitmask), there is:
|
|
|
|
either
|
|
|
|
|
|
* a serialized VARIANT
|
|
|
|
or
|
|
|
|
* a serialized/marshalled callback object reference (IAccPropServer)
|
|
|
|
|
|
- depending on whether the 'property is variant' bitmask is set for this property.
|
|
|
|
|
|
|
|
|
|
Variants are serialized as a leading SHORT indicating the type (VT_???), followed by:
|
|
DWORD for I4s,
|
|
DWORD length followed by unicode chars for BSTR
|
|
|
|
A marshalled callback reference is serialized as:
|
|
DWORD for length of marshalled data,
|
|
BYTEs of the marshalled data.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL IsKeyAlive( const BYTE * pKeyData, DWORD dwKeyLen )
|
|
{
|
|
// For the moment, assume it uses either the HWND or HMENU naming scheme.
|
|
// (Later on, if we extend this to allow pluggable namespaces, we'd use something
|
|
// like IAccNamespace::IsKeyAlive() instead.)
|
|
|
|
HWND hwnd;
|
|
if( DecodeHwndKey( pKeyData, dwKeyLen, & hwnd, NULL, NULL ) )
|
|
{
|
|
return IsWindow( hwnd );
|
|
}
|
|
|
|
HMENU hmenu;
|
|
if( DecodeHmenuKey( pKeyData, dwKeyLen, NULL, & hmenu, NULL ) )
|
|
{
|
|
return IsMenu( hmenu );
|
|
}
|
|
|
|
Assert( FALSE );
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
// This is a reference to a key (aka id string) - it does not own or contain
|
|
// the key.
|
|
//
|
|
// When used in the object map, (which contains {AccObjKeyRef, AccInfo*} pairs),
|
|
// m_pKeyData points to the key data in the corresponding AccInfo. This object
|
|
// and the corresponding AccInfo have identical lifetimes.
|
|
//
|
|
// In other cases - for example, when used as a value to look up in the map -
|
|
// m_pKeyData points to an already existing key string - possibly the id string
|
|
// specified by the caller of one of the IAccPropServer methods. In this usage,
|
|
// the AccObjKeyRef is really being used as a temporary adapter to allow the
|
|
// existing string to be used to look up a value in the map.
|
|
class AccObjKeyRef
|
|
{
|
|
const BYTE * m_pKeyData;
|
|
DWORD m_dwKeyLen;
|
|
|
|
// Disable default ctor
|
|
AccObjKeyRef();
|
|
|
|
public:
|
|
|
|
// copy ctor
|
|
AccObjKeyRef( const BYTE * pKeyData, DWORD dwKeyLen )
|
|
: m_pKeyData( pKeyData ),
|
|
m_dwKeyLen( dwKeyLen )
|
|
{
|
|
}
|
|
|
|
// use default member-wise assignment
|
|
|
|
|
|
// Comparisons - used in map lookup
|
|
|
|
bool operator < ( const AccObjKeyRef & x ) const
|
|
{
|
|
if( m_dwKeyLen != x.m_dwKeyLen )
|
|
return m_dwKeyLen < x.m_dwKeyLen;
|
|
|
|
return memcmp( m_pKeyData, x.m_pKeyData, m_dwKeyLen ) < 0;
|
|
}
|
|
|
|
bool operator == ( const AccObjKeyRef & x ) const
|
|
{
|
|
if( m_dwKeyLen != x.m_dwKeyLen )
|
|
return false;
|
|
|
|
return memcmp( m_pKeyData, x.m_pKeyData, m_dwKeyLen ) == 0;
|
|
}
|
|
|
|
bool operator != ( const AccObjKeyRef & x ) const
|
|
{
|
|
return ! operator == ( x );
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct AccInfo
|
|
{
|
|
private:
|
|
|
|
// disable copy ctor
|
|
AccInfo( const AccInfo & x );
|
|
|
|
private:
|
|
|
|
struct PropInfo
|
|
{
|
|
union {
|
|
VARIANT m_var;
|
|
|
|
struct
|
|
{
|
|
BYTE * m_pMarshalData;
|
|
DWORD m_dwMarshalDataLen;
|
|
} m_ServerInfo;
|
|
};
|
|
};
|
|
|
|
|
|
BYTE * m_pKeyData;
|
|
DWORD m_dwKeyLen;
|
|
|
|
|
|
DWORD m_fPropInUseBits;
|
|
DWORD m_fPropIsVariantBits; // 1-bit indicates the property is VARIANT - otherwise it's a IAccPropServer
|
|
DWORD m_fContainerScopeBits; // 1-bit indicates that the property is a IAccPropServer, and should also
|
|
// be used for the children of this node. (annoScope was CONTAINER).
|
|
|
|
PropInfo m_Props[ NUMPROPS ];
|
|
|
|
|
|
HWND m_hwndProp;
|
|
LPTSTR m_pKeyString;
|
|
|
|
BYTE * m_pBlob;
|
|
|
|
|
|
public:
|
|
|
|
AccInfo()
|
|
{
|
|
m_fPropInUseBits = 0;
|
|
m_fPropIsVariantBits = 0;
|
|
m_fContainerScopeBits = 0;
|
|
m_pKeyString = NULL;
|
|
m_hwndProp = NULL;
|
|
m_pBlob = NULL;
|
|
}
|
|
|
|
|
|
~AccInfo()
|
|
{
|
|
ClearBlob();
|
|
|
|
for( int i = 0 ; i < NUMPROPS ; i++ )
|
|
{
|
|
ClearProp( i );
|
|
}
|
|
|
|
delete [ ] m_pKeyData;
|
|
delete [ ] m_pKeyString;
|
|
}
|
|
|
|
|
|
BOOL Init( const BYTE * pKeyData, DWORD dwKeyLen, HWND hwndProp )
|
|
{
|
|
m_pKeyData = new BYTE [ dwKeyLen ];
|
|
if( ! m_pKeyData )
|
|
{
|
|
TraceError( TEXT("AccInfo::Init: new returned NULL") );
|
|
return FALSE;
|
|
}
|
|
memcpy( m_pKeyData, pKeyData, dwKeyLen );
|
|
m_dwKeyLen = dwKeyLen;
|
|
|
|
m_pKeyString = MakeKeyString( pKeyData, dwKeyLen );
|
|
|
|
m_hwndProp = hwndProp;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
const AccObjKeyRef GetKeyRef()
|
|
{
|
|
return AccObjKeyRef( m_pKeyData, m_dwKeyLen );
|
|
}
|
|
|
|
|
|
BOOL SetPropValue (
|
|
int iProp,
|
|
VARIANT * pvarValue )
|
|
{
|
|
ClearProp( iProp );
|
|
|
|
SetBit( & m_fPropIsVariantBits, iProp );
|
|
SetBit( & m_fPropInUseBits, iProp );
|
|
ClearBit( & m_fContainerScopeBits, iProp );
|
|
m_Props[ iProp ].m_var.vt = VT_EMPTY;
|
|
|
|
// We'll accept any type here. It's up to the caller of this to enforce
|
|
// any property-vs-type policies (eg. only allow I4's for ROLE, etc.)
|
|
VariantCopy( & m_Props[ iProp ].m_var, pvarValue );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL SetPropServer (
|
|
int iProp,
|
|
const BYTE * pMarshalData,
|
|
int dwMarshalDataLen,
|
|
AnnoScope annoScope )
|
|
{
|
|
if( dwMarshalDataLen == 0 )
|
|
{
|
|
TraceError( TEXT("AccInfo::SetPropServer: dwMarshalDataLen param = 0") );
|
|
return FALSE;
|
|
}
|
|
|
|
BYTE * pCopyData = new BYTE [ dwMarshalDataLen ];
|
|
if( ! pCopyData )
|
|
{
|
|
TraceError( TEXT("AccInfo::SetPropServer: new returned NULL") );
|
|
return FALSE;
|
|
}
|
|
|
|
ClearProp( iProp );
|
|
|
|
ClearBit( & m_fPropIsVariantBits, iProp );
|
|
SetBit( & m_fPropInUseBits, iProp );
|
|
|
|
if( annoScope == ANNO_CONTAINER )
|
|
{
|
|
SetBit( & m_fContainerScopeBits, iProp );
|
|
}
|
|
else
|
|
{
|
|
ClearBit( & m_fContainerScopeBits, iProp );
|
|
}
|
|
|
|
m_Props[ iProp ].m_ServerInfo.m_dwMarshalDataLen = dwMarshalDataLen;
|
|
memcpy( pCopyData, pMarshalData, dwMarshalDataLen );
|
|
m_Props[ iProp ].m_ServerInfo.m_pMarshalData = pCopyData;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
void ClearProp( int i )
|
|
{
|
|
// Does this property need to be cleared?
|
|
if( IsBitSet( m_fPropInUseBits, i ) )
|
|
{
|
|
// Is it a simple variant, or a callback reference?
|
|
if( IsBitSet( m_fPropIsVariantBits, i ) )
|
|
{
|
|
// Simple variant...
|
|
VariantClear( & m_Props[ i ].m_var );
|
|
}
|
|
else
|
|
{
|
|
BYTE * pMarshalData = m_Props[ i ].m_ServerInfo.m_pMarshalData;
|
|
DWORD dwMarshalDataLen = m_Props[ i ].m_ServerInfo.m_dwMarshalDataLen;
|
|
|
|
// Callback reference...
|
|
Assert( dwMarshalDataLen );
|
|
if( dwMarshalDataLen && pMarshalData )
|
|
{
|
|
// This releases the object reference, byt we have to delete the buffer
|
|
// ourselves...
|
|
ReleaseMarshallData( pMarshalData, dwMarshalDataLen );
|
|
|
|
delete [ ] pMarshalData;
|
|
m_Props[ i ].m_ServerInfo.m_pMarshalData = NULL;
|
|
m_Props[ i ].m_ServerInfo.m_dwMarshalDataLen = 0;
|
|
}
|
|
}
|
|
|
|
ClearBit( & m_fPropInUseBits, i );
|
|
}
|
|
}
|
|
|
|
BOOL IsEmpty()
|
|
{
|
|
return m_fPropInUseBits == 0;
|
|
}
|
|
|
|
|
|
BOOL Alive()
|
|
{
|
|
return IsKeyAlive( m_pKeyData, m_dwKeyLen );
|
|
}
|
|
|
|
|
|
BOOL Sync()
|
|
{
|
|
return UpdateBlob();
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
|
|
BYTE * AllocBlob( SIZE_T cbSize )
|
|
{
|
|
return (BYTE *) Alloc_32BitCompatible( cbSize );
|
|
}
|
|
|
|
void DeallocBlob( BYTE * pBlob )
|
|
{
|
|
Free_32BitCompatible( pBlob );
|
|
}
|
|
|
|
|
|
|
|
void ClearBlob()
|
|
{
|
|
if( m_pBlob )
|
|
{
|
|
RemoveProp( m_hwndProp, m_pKeyString );
|
|
DeallocBlob( m_pBlob );
|
|
m_pBlob = NULL;
|
|
}
|
|
}
|
|
|
|
BOOL UpdateBlob()
|
|
{
|
|
BYTE * pOldBlob = m_pBlob;
|
|
BYTE * pNewBlob = CalcBlob();
|
|
|
|
|
|
// We always update - even if pNewblob is NULL (ie. Calc failed)...
|
|
if( pNewBlob )
|
|
{
|
|
SetProp( m_hwndProp, m_pKeyString, pNewBlob );
|
|
}
|
|
else
|
|
{
|
|
RemoveProp( m_hwndProp, m_pKeyString );
|
|
}
|
|
|
|
if( pOldBlob )
|
|
{
|
|
DeallocBlob( pOldBlob );
|
|
}
|
|
|
|
m_pBlob = pNewBlob;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BYTE * CalcBlob()
|
|
{
|
|
// If there are no properties being used, then we don't need anything at all.
|
|
if( ! m_fPropInUseBits )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// First, measure how much space we need...
|
|
|
|
// three constants...
|
|
SIZE_T dwSize = sizeof( DWORD ) * 4; // size header, m_fPropInUseBits, m_fPropIsVariantBits, m_fContainerScopeBits
|
|
|
|
// for each present property...
|
|
for( int i = 0 ; i < NUMPROPS ; i++ )
|
|
{
|
|
if( IsBitSet( m_fPropInUseBits, i ) )
|
|
{
|
|
if( IsBitSet( m_fPropIsVariantBits, i ) )
|
|
{
|
|
MemStreamMeasure_VARIANT( & dwSize, m_Props[ i ].m_var );
|
|
}
|
|
else
|
|
{
|
|
MemStreamMeasure_DWORD( & dwSize );
|
|
MemStreamMeasure_Binary( & dwSize, m_Props[ i ].m_ServerInfo.m_dwMarshalDataLen );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now allocate space...
|
|
BYTE * pBlob = AllocBlob( dwSize );
|
|
if( ! pBlob )
|
|
{
|
|
TraceError( TEXT("AccInfo::CalcBloc: AllocBlob returned NULL") );
|
|
return NULL;
|
|
}
|
|
|
|
// Finally write the data to the allocated space...
|
|
|
|
MemStream p( pBlob, dwSize );
|
|
|
|
MemStreamWrite_DWORD( p, (DWORD) dwSize );
|
|
MemStreamWrite_DWORD( p, m_fPropInUseBits );
|
|
MemStreamWrite_DWORD( p, m_fPropIsVariantBits );
|
|
MemStreamWrite_DWORD( p, m_fContainerScopeBits );
|
|
|
|
for( int j = 0 ; j < NUMPROPS ; j++ )
|
|
{
|
|
if( IsBitSet( m_fPropInUseBits, j ) )
|
|
{
|
|
if( IsBitSet( m_fPropIsVariantBits, j ) )
|
|
{
|
|
MemStreamWrite_VARIANT( p, m_Props[ j ].m_var );
|
|
}
|
|
else
|
|
{
|
|
MemStreamWrite_DWORD( p, m_Props[ j ].m_ServerInfo.m_dwMarshalDataLen );
|
|
MemStreamWrite_Binary( p, m_Props[ j ].m_ServerInfo.m_pMarshalData, m_Props[ j ].m_ServerInfo.m_dwMarshalDataLen );
|
|
}
|
|
}
|
|
}
|
|
// If we later decide to allow any GUIDs (other than the well-known ones which have indices) as props,
|
|
// we could add them here as GUID/VARIANT pairs.
|
|
|
|
return pBlob;
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
#define HWND_MESSAGE ((HWND)-3)
|
|
|
|
typedef std::map< AccObjKeyRef, AccInfo * > AccInfoMapType;
|
|
|
|
|
|
|
|
|
|
class CPropMgrImpl
|
|
{
|
|
|
|
AccInfoMapType m_Map;
|
|
|
|
BOOL m_fSelfLocked;
|
|
|
|
HWND m_hwnd;
|
|
|
|
int m_ref;
|
|
|
|
static
|
|
CPropMgrImpl * s_pThePropMgrImpl;
|
|
|
|
friend void PropMgrImpl_Uninit();
|
|
|
|
public:
|
|
|
|
CPropMgrImpl()
|
|
: m_fSelfLocked( FALSE ),
|
|
m_hwnd( NULL ),
|
|
m_ref( 1 )
|
|
{
|
|
_Module.Lock();
|
|
}
|
|
|
|
BOOL Init()
|
|
{
|
|
TCHAR szWindowName[ 32 ];
|
|
wsprintf( szWindowName, TEXT("MSAA_DA_%lx"), GetCurrentProcessId() );
|
|
|
|
WNDCLASS wc;
|
|
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = StaticWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = _Module.GetModuleInstance();
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = NULL;
|
|
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = TEXT("MSAA_DA_Class");
|
|
|
|
RegisterClass( & wc );
|
|
|
|
CreateWindow( TEXT("MSAA_DA_Class"),
|
|
szWindowName,
|
|
0,
|
|
0, 0, 128, 128,
|
|
NULL, NULL, _Module.GetModuleInstance(), this );
|
|
|
|
// Make this a message only window. We don't care if it fails, win9x case.
|
|
SetParent( m_hwnd, HWND_MESSAGE );
|
|
|
|
SetTimer( m_hwnd, 1, 5 * 1000, NULL );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
~CPropMgrImpl()
|
|
{
|
|
s_pThePropMgrImpl = NULL;
|
|
|
|
KillTimer( NULL, 1 );
|
|
|
|
if( m_hwnd )
|
|
{
|
|
SetWindowLongPtr( m_hwnd, GWLP_USERDATA, NULL );
|
|
DestroyWindow( m_hwnd );
|
|
}
|
|
|
|
_Module.Unlock();
|
|
}
|
|
|
|
|
|
void AddRef()
|
|
{
|
|
m_ref++;
|
|
}
|
|
|
|
void Release()
|
|
{
|
|
m_ref--;
|
|
if( m_ref == 0 )
|
|
{
|
|
delete this;
|
|
}
|
|
}
|
|
|
|
|
|
static
|
|
CPropMgrImpl * GetThePropMgrImpl()
|
|
{
|
|
if( ! s_pThePropMgrImpl )
|
|
{
|
|
s_pThePropMgrImpl = new CPropMgrImpl();
|
|
if( ! s_pThePropMgrImpl )
|
|
{
|
|
TraceError( TEXT("CPropMgrImpl::GetThePropMgrImpl: new returned NULL") );
|
|
return NULL;
|
|
}
|
|
|
|
if( ! s_pThePropMgrImpl->Init() )
|
|
{
|
|
delete s_pThePropMgrImpl;
|
|
s_pThePropMgrImpl = NULL;
|
|
TraceError( TEXT("CPropMgrImpl::GetThePropMgrImpl: s_pThePropMgrImpl->Init() returned FALSE") );
|
|
return NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We only addref the second and subsequent times that we
|
|
// hand out a pointer.
|
|
// The first time, we use the ref the the object had when it
|
|
// was created.
|
|
// (This static ptr s_pThePropMgrImpl is a weak reference.)
|
|
s_pThePropMgrImpl->AddRef();
|
|
}
|
|
|
|
return s_pThePropMgrImpl;
|
|
}
|
|
|
|
|
|
|
|
|
|
void Clean()
|
|
{
|
|
// Go through the elements in the map...
|
|
|
|
for( AccInfoMapType::iterator i = m_Map.begin() ; i != m_Map.end() ; )
|
|
{
|
|
// check if the key is still valid...
|
|
if( ! i->second->Alive() )
|
|
{
|
|
AccInfoMapType::iterator t = i;
|
|
i++;
|
|
|
|
AccInfo * pInfo = t->second;
|
|
m_Map.erase( t );
|
|
|
|
delete pInfo;
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
|
|
// Unload if necessary
|
|
CheckRef();
|
|
}
|
|
|
|
void ClearAll()
|
|
{
|
|
for( AccInfoMapType::iterator i = m_Map.begin() ; i != m_Map.end() ; )
|
|
{
|
|
AccInfoMapType::iterator t = i;
|
|
i++;
|
|
|
|
AccInfo * pInfo = t->second;
|
|
m_Map.erase( t );
|
|
|
|
delete pInfo;
|
|
}
|
|
|
|
// Unload if necessary
|
|
CheckRef();
|
|
}
|
|
|
|
|
|
void CheckRef()
|
|
{
|
|
if( m_Map.empty() )
|
|
{
|
|
if( m_fSelfLocked )
|
|
{
|
|
m_fSelfLocked = FALSE;
|
|
Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( ! m_fSelfLocked )
|
|
{
|
|
m_fSelfLocked = TRUE;
|
|
AddRef();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
AccInfo * LookupKey( const BYTE * pKeyData, DWORD dwKeyLen, BOOL fCreate )
|
|
{
|
|
AccInfoMapType::iterator i;
|
|
|
|
AccObjKeyRef keyref( pKeyData, dwKeyLen );
|
|
|
|
i = m_Map.find( keyref );
|
|
|
|
if( i == m_Map.end() || i->first != keyref )
|
|
{
|
|
// insert...
|
|
if( fCreate )
|
|
{
|
|
AccInfo * pInfo = new AccInfo;
|
|
if( ! pInfo )
|
|
{
|
|
TraceError( TEXT("CPropMgrImpl::LookupKey: new returned NULL") );
|
|
return NULL;
|
|
}
|
|
|
|
// If the key is associated with a HWND, use that; otherwise attach the key to our own window.
|
|
HWND hwndProp;
|
|
if( ! DecodeHwndKey( pKeyData, dwKeyLen, & hwndProp, NULL, NULL ) )
|
|
{
|
|
hwndProp = m_hwnd;
|
|
}
|
|
|
|
pInfo->Init( pKeyData, dwKeyLen, hwndProp );
|
|
|
|
m_Map.insert( std::make_pair( pInfo->GetKeyRef(), pInfo ) );
|
|
|
|
// make sure we're locked...
|
|
CheckRef();
|
|
|
|
return pInfo;
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return i->second;
|
|
}
|
|
}
|
|
|
|
void RemoveEntry( AccInfo * pInfo )
|
|
{
|
|
m_Map.erase( pInfo->GetKeyRef() );
|
|
|
|
// if we're empty, we can unlock the module...
|
|
CheckRef();
|
|
}
|
|
|
|
|
|
HRESULT ValidateArray( const void * pvStart, int cLen, int elsize, LPCTSTR pMethodName, LPCTSTR pPtrName, LPCTSTR pLenName )
|
|
{
|
|
// Parameter checking...
|
|
|
|
if( ! pvStart )
|
|
{
|
|
TraceParam( TEXT("%s: %s is NULL"), pMethodName, pPtrName );
|
|
return E_POINTER;
|
|
}
|
|
if( cLen <= 0 )
|
|
{
|
|
TraceParam( TEXT("%s: %s is <= 0"), pMethodName, pLenName );
|
|
return E_INVALIDARG;
|
|
}
|
|
if( IsBadReadPtr( pvStart, cLen * elsize ) )
|
|
{
|
|
TraceParam( TEXT("%s: %s/%s points to non-readable memory"), pMethodName, pPtrName, pLenName );
|
|
return E_POINTER;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
HRESULT SetPropValue( const BYTE * pKeyData,
|
|
DWORD dwKeyLen,
|
|
MSAAPROPID idProp,
|
|
VARIANT * pvarValue )
|
|
{
|
|
// Parameter checking...
|
|
|
|
HRESULT hr = ValidateArray( pKeyData, dwKeyLen, sizeof(BYTE), TEXT("SetPropValue"), TEXT("pKeyData"), TEXT("dwKeyLen") );
|
|
if( hr != S_OK )
|
|
return hr;
|
|
|
|
if( pvarValue == NULL )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::SetPropValue: pvarValue is NULL") );
|
|
return E_POINTER;
|
|
}
|
|
|
|
|
|
|
|
AccInfo * pInfo = LookupKey( pKeyData, dwKeyLen, TRUE );
|
|
Assert( pInfo );
|
|
if( ! pInfo )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::SetPropValue: key not found") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
int idxProp = IndexFromProp( idProp );
|
|
if( idxProp == -1 )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::SetPropValue: unknown prop") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
// check type...
|
|
if( pvarValue->vt != g_PropInfo[ idxProp ].m_Type )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::SetPropValue: incorrect type for property") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
// Do we support setting this property directly?
|
|
// (Some can be returned via callbacks only, not set directly)
|
|
if( ! g_PropInfo[ idxProp ].m_fSupportSetValue )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::SetPropValue: prop does not support direct set") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if( ! pInfo->SetPropValue( idxProp, pvarValue ) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
pInfo->Sync();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT ClearProps( const BYTE * pKeyData,
|
|
DWORD dwKeyLen,
|
|
const MSAAPROPID * paProps,
|
|
int cProps )
|
|
{
|
|
// Parameter checking...
|
|
|
|
HRESULT hr = ValidateArray( pKeyData, dwKeyLen, sizeof(BYTE), TEXT("ClearProps"), TEXT("pKeyData"), TEXT("dwKeyLen") );
|
|
if( hr != S_OK )
|
|
return hr;
|
|
|
|
hr = ValidateArray( paProps, cProps, sizeof(MSAAPROPID), TEXT("ClearProps"), TEXT("paProps"), TEXT("cProps") );
|
|
if( hr != S_OK )
|
|
return hr;
|
|
|
|
|
|
|
|
AccInfo * pInfo = LookupKey( pKeyData, dwKeyLen, FALSE );
|
|
Assert( pInfo );
|
|
if( ! pInfo )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::SetPropValue: key not found") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
BOOL fUnknownProp = FALSE;
|
|
|
|
for( int i = 0 ; i < cProps ; i++ )
|
|
{
|
|
int idxProp = IndexFromProp( paProps[ i ] );
|
|
if( idxProp == -1 )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::ClearProps: unknown prop") );
|
|
fUnknownProp = TRUE;
|
|
// Continue and clear the other props that we do recognize...
|
|
}
|
|
else
|
|
{
|
|
pInfo->ClearProp( idxProp );
|
|
}
|
|
}
|
|
|
|
pInfo->Sync();
|
|
|
|
if( pInfo->IsEmpty() )
|
|
{
|
|
RemoveEntry( pInfo );
|
|
}
|
|
|
|
return fUnknownProp ? E_INVALIDARG : S_OK;
|
|
}
|
|
|
|
|
|
HRESULT SetPropServer( const BYTE * pKeyData,
|
|
DWORD dwKeyLen,
|
|
|
|
const MSAAPROPID * paProps,
|
|
int cProps,
|
|
|
|
const BYTE * pMarshalData,
|
|
int dwMarshalDataLen,
|
|
|
|
AnnoScope annoScope )
|
|
{
|
|
|
|
// Parameter checking...
|
|
|
|
HRESULT hr = ValidateArray( pKeyData, dwKeyLen, sizeof(BYTE), TEXT("SetPropServer"), TEXT("pKeyData"), TEXT("dwKeyLen") );
|
|
if( hr != S_OK )
|
|
return hr;
|
|
|
|
hr = ValidateArray( paProps, cProps, sizeof(MSAAPROPID), TEXT("SetPropServer"), TEXT("paProps"), TEXT("cProps") );
|
|
if( hr != S_OK )
|
|
return hr;
|
|
|
|
|
|
AccInfo * pInfo = LookupKey( pKeyData, dwKeyLen, TRUE );
|
|
Assert( pInfo );
|
|
if( ! pInfo )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::SetPropValue: key not found") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
// TODO - make this two-pass - validate props first,
|
|
// add them later - to make this atomic.
|
|
// (either all or none of the props should be registered)
|
|
for( int i = 0 ; i < cProps ; i++ )
|
|
{
|
|
int idxProp = IndexFromProp( paProps[ i ] );
|
|
if( idxProp == -1 )
|
|
{
|
|
TraceParam( TEXT("CPropMgrImpl::SetPropServer: unknown prop") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if( ! pInfo->SetPropServer( idxProp, pMarshalData, dwMarshalDataLen, annoScope ) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
|
|
pInfo->Sync();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
LRESULT WndProc( HWND hwnd,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
if( uMsg == WM_TIMER )
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
return DefWindowProc( hwnd, uMsg, wParam, lParam );
|
|
}
|
|
|
|
static
|
|
LRESULT CALLBACK StaticWndProc( HWND hwnd,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
CPropMgrImpl * pThis = (CPropMgrImpl *) GetWindowLongPtr( hwnd, GWLP_USERDATA );
|
|
if( pThis )
|
|
{
|
|
return pThis->WndProc( hwnd, uMsg, wParam, lParam );
|
|
}
|
|
else if( uMsg == WM_NCCREATE )
|
|
{
|
|
LPCREATESTRUCT lpcs = (LPCREATESTRUCT) lParam;
|
|
pThis = (CPropMgrImpl *)lpcs->lpCreateParams;
|
|
SetWindowLongPtr( hwnd, GWLP_USERDATA, (DWORD_PTR) pThis );
|
|
pThis->m_hwnd = hwnd;
|
|
return pThis->WndProc( hwnd, uMsg, wParam, lParam );
|
|
}
|
|
|
|
return DefWindowProc( hwnd, uMsg, wParam, lParam );
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
CPropMgrImpl * CPropMgrImpl::s_pThePropMgrImpl = NULL;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// If all annotated windows disappear before the app shuts down, or if all
|
|
// annotations are cleared, then everything gets cleaned up nicely.
|
|
//
|
|
// However, if CoUninitialize is called while controls are still annotated,
|
|
// we will need to explicitly clean up before COM unloads our dll.
|
|
//
|
|
// (If we don't, then (a) we leak memory, and (b) the DA window will
|
|
// still receive WM_TIMER messages to a wndproc that has been unloaded
|
|
// causin ga fault.)
|
|
//
|
|
// This is called from DLLMain's PROCESS_DETACH.
|
|
|
|
void PropMgrImpl_Uninit()
|
|
{
|
|
// Check if there is a Mgr in the first place...
|
|
CPropMgrImpl * pTheMgr = CPropMgrImpl::s_pThePropMgrImpl;
|
|
|
|
// No mgr - nothing to clean up.
|
|
if( ! pTheMgr )
|
|
return;
|
|
|
|
// AddRef it, to keep it alive while we're using it.
|
|
pTheMgr->AddRef();
|
|
|
|
// Clear all properties
|
|
pTheMgr->ClearAll();
|
|
|
|
// This release will cause the mgr to delete itself, since it is now empty.
|
|
pTheMgr->Release();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CPropMgr::CPropMgr()
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::CPropMgr") );
|
|
|
|
m_pMgrImpl = CPropMgrImpl::GetThePropMgrImpl();
|
|
if( ! m_pMgrImpl )
|
|
{
|
|
TraceError( TEXT("CPropMgr::CPropMgr: CPropMgrImpl::GetThePropMgrImpl returned NULL") );
|
|
}
|
|
}
|
|
|
|
|
|
CPropMgr::~CPropMgr()
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::~CPropMgr") );
|
|
|
|
if( m_pMgrImpl )
|
|
{
|
|
m_pMgrImpl->Release();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::SetPropValue (
|
|
const BYTE * pIDString,
|
|
DWORD dwIDStringLen,
|
|
|
|
MSAAPROPID idProp,
|
|
VARIANT var
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::SetPropValue") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
return m_pMgrImpl->SetPropValue( pIDString, dwIDStringLen, idProp, & var );
|
|
}
|
|
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::SetPropServer (
|
|
const BYTE * pIDString,
|
|
DWORD dwIDStringLen,
|
|
|
|
const MSAAPROPID * paProps,
|
|
int cProps,
|
|
|
|
IAccPropServer * pServer,
|
|
AnnoScope annoScope
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::SetPropServer"), TEXT("cProps=%d"), cProps );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
|
|
const BYTE * pData;
|
|
DWORD dwDataLen;
|
|
MarshalState mstate;
|
|
|
|
// We use strong table marshalling to keep the object alive until we free it.
|
|
// (Ownership is actually transferred to the property manager, which will release it when
|
|
// either the property is cleared explicity, or after the HWND dies and it gets swept away.)
|
|
HRESULT hr = MarshalInterface( IID_IAccPropServer, pServer, MSHCTX_LOCAL, MSHLFLAGS_TABLESTRONG,
|
|
& pData, & dwDataLen, & mstate );
|
|
if( FAILED( hr ) )
|
|
{
|
|
TraceErrorHR( hr, TEXT("CPropMgr::SetPropServer: MarshalInterface failed") );
|
|
return hr;
|
|
}
|
|
|
|
|
|
hr = m_pMgrImpl->SetPropServer( pIDString, dwIDStringLen, paProps, cProps, pData, dwDataLen, annoScope );
|
|
|
|
MarshalInterfaceDone( & mstate );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::ClearProps (
|
|
const BYTE * pIDString,
|
|
DWORD dwIDStringLen,
|
|
|
|
const MSAAPROPID * paProps,
|
|
int cProps
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::ClearProps"), TEXT("cProps=%d"), cProps );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
return m_pMgrImpl->ClearProps( pIDString, dwIDStringLen, paProps, cProps );
|
|
}
|
|
|
|
|
|
// Quick OLEACC/HWND-based functionality
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::SetHwndProp (
|
|
HWND hwnd,
|
|
DWORD idObject,
|
|
DWORD idChild,
|
|
MSAAPROPID idProp,
|
|
VARIANT var
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::SetHwndProp") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
BYTE HwndKey [ HWNDKEYSIZE ];
|
|
MakeHwndKey( HwndKey, hwnd, idObject, idChild );
|
|
|
|
return m_pMgrImpl->SetPropValue( HwndKey, HWNDKEYSIZE, idProp, & var );
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::SetHwndPropStr (
|
|
HWND hwnd,
|
|
DWORD idObject,
|
|
DWORD idChild,
|
|
MSAAPROPID idProp,
|
|
LPCWSTR str
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::SetHwndPropStr") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
// Need to convert the LPCWSTR to a BSTR before we can put it into a variant...
|
|
VARIANT var;
|
|
var.vt = VT_BSTR;
|
|
var.bstrVal = SysAllocString( str );
|
|
if( ! var.bstrVal )
|
|
{
|
|
TraceError( TEXT("CPropMgr::SetHwndPropStr: SysAllocString failed") );
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
BYTE HwndKey [ HWNDKEYSIZE ];
|
|
MakeHwndKey( HwndKey, hwnd, idObject, idChild );
|
|
|
|
HRESULT hr = m_pMgrImpl->SetPropValue( HwndKey, HWNDKEYSIZE, idProp, & var );
|
|
SysFreeString( var.bstrVal );
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::SetHwndPropServer (
|
|
HWND hwnd,
|
|
DWORD idObject,
|
|
DWORD idChild,
|
|
|
|
const MSAAPROPID * paProps,
|
|
int cProps,
|
|
|
|
IAccPropServer * pServer,
|
|
AnnoScope annoScope
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::SetHwndPropServer") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
BYTE HwndKey [ HWNDKEYSIZE ];
|
|
MakeHwndKey( HwndKey, hwnd, idObject, idChild );
|
|
|
|
return SetPropServer( HwndKey, HWNDKEYSIZE, paProps, cProps, pServer, annoScope );
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::ClearHwndProps (
|
|
HWND hwnd,
|
|
DWORD idObject,
|
|
DWORD idChild,
|
|
|
|
const MSAAPROPID * paProps,
|
|
int cProps
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::ClearHwndProps") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
BYTE HwndKey [ HWNDKEYSIZE ];
|
|
MakeHwndKey( HwndKey, hwnd, idObject, idChild );
|
|
|
|
return ClearProps( HwndKey, HWNDKEYSIZE, paProps, cProps );
|
|
}
|
|
|
|
|
|
|
|
// Methods for composing/decomposing a HWND-based key...
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::ComposeHwndIdentityString (
|
|
HWND hwnd,
|
|
DWORD idObject,
|
|
DWORD idChild,
|
|
|
|
BYTE ** ppIDString,
|
|
DWORD * pdwIDStringLen
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::ComposeHwndIdentityString") );
|
|
|
|
*ppIDString = NULL;
|
|
*pdwIDStringLen = 0;
|
|
|
|
BYTE * pKeyData = (BYTE *)CoTaskMemAlloc( HWNDKEYSIZE );
|
|
if( ! pKeyData )
|
|
{
|
|
TraceError( TEXT("CPropMgr::ComposeHwndIdentityString: CoTaskMemAlloc failed") );
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
MakeHwndKey( pKeyData, hwnd, idObject, idChild );
|
|
|
|
*ppIDString = pKeyData;
|
|
*pdwIDStringLen = HWNDKEYSIZE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::DecomposeHwndIdentityString (
|
|
const BYTE * pIDString,
|
|
DWORD dwIDStringLen,
|
|
|
|
HWND * phwnd,
|
|
DWORD * pidObject,
|
|
DWORD * pidChild
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::DecomposeHwndIdentityString") );
|
|
|
|
if( ! DecodeHwndKey( pIDString, dwIDStringLen, phwnd, pidObject, pidChild ) )
|
|
{
|
|
TraceParam( TEXT("CPropMgr::DecomposeHwndIdentityString: not a valid HWND id string") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
// Quick OLEACC/HMENU-based functionality
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::SetHmenuProp (
|
|
HMENU hmenu,
|
|
DWORD idChild,
|
|
MSAAPROPID idProp,
|
|
VARIANT var
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::SetHmenuProp") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
BYTE HmenuKey [ HMENUKEYSIZE ];
|
|
MakeHmenuKey( HmenuKey, GetCurrentProcessId(), hmenu, idChild );
|
|
|
|
return m_pMgrImpl->SetPropValue( HmenuKey, HMENUKEYSIZE, idProp, & var );
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::SetHmenuPropStr (
|
|
HMENU hmenu,
|
|
DWORD idChild,
|
|
MSAAPROPID idProp,
|
|
LPCWSTR str
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::SetHmenuPropStr") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
// Need to convert the LPCWSTR to a BSTR before we can put it into a variant...
|
|
VARIANT var;
|
|
var.vt = VT_BSTR;
|
|
var.bstrVal = SysAllocString( str );
|
|
if( ! var.bstrVal )
|
|
{
|
|
TraceError( TEXT("CPropMgr::SetHmenuPropStr: SysAllocString failed") );
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
BYTE HmenuKey [ HMENUKEYSIZE ];
|
|
MakeHmenuKey( HmenuKey, GetCurrentProcessId(), hmenu, idChild );
|
|
|
|
HRESULT hr = m_pMgrImpl->SetPropValue( HmenuKey, HMENUKEYSIZE, idProp, & var );
|
|
SysFreeString( var.bstrVal );
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::SetHmenuPropServer (
|
|
HMENU hmenu,
|
|
DWORD idChild,
|
|
|
|
const MSAAPROPID * paProps,
|
|
int cProps,
|
|
|
|
IAccPropServer * pServer,
|
|
AnnoScope annoScope
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::SetHmenuPropServer") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
BYTE HmenuKey [ HMENUKEYSIZE ];
|
|
MakeHmenuKey( HmenuKey, GetCurrentProcessId(), hmenu, idChild );
|
|
|
|
return SetPropServer( HmenuKey, HMENUKEYSIZE, paProps, cProps, pServer, annoScope );
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::ClearHmenuProps (
|
|
HMENU hmenu,
|
|
DWORD idChild,
|
|
|
|
const MSAAPROPID * paProps,
|
|
int cProps
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::ClearHmenuProps") );
|
|
|
|
if( ! m_pMgrImpl )
|
|
return E_FAIL;
|
|
|
|
BYTE HmenuKey [ HMENUKEYSIZE ];
|
|
MakeHmenuKey( HmenuKey, GetCurrentProcessId(), hmenu, idChild );
|
|
|
|
return ClearProps( HmenuKey, HMENUKEYSIZE, paProps, cProps );
|
|
}
|
|
|
|
|
|
// Methods for composing/decomposing a HMENU-based key...
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::ComposeHmenuIdentityString (
|
|
HMENU hmenu,
|
|
DWORD idChild,
|
|
|
|
BYTE ** ppIDString,
|
|
DWORD * pdwIDStringLen
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::ComposeHmenuIdentityString") );
|
|
|
|
*ppIDString = NULL;
|
|
*pdwIDStringLen = 0;
|
|
|
|
BYTE * pKeyData = (BYTE *)CoTaskMemAlloc( HMENUKEYSIZE );
|
|
if( ! pKeyData )
|
|
{
|
|
TraceError( TEXT("CPropMgr::ComposeHmenuIdentityString: CoTaskMemAlloc failed") );
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
MakeHmenuKey( pKeyData, GetCurrentProcessId(), hmenu, idChild );
|
|
|
|
*ppIDString = pKeyData;
|
|
*pdwIDStringLen = HMENUKEYSIZE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE
|
|
CPropMgr::DecomposeHmenuIdentityString (
|
|
const BYTE * pIDString,
|
|
DWORD dwIDStringLen,
|
|
|
|
HMENU * phmenu,
|
|
DWORD * pidChild
|
|
)
|
|
{
|
|
IMETHOD( TEXT("CPropMgr::DecomposeHmenuIdentityString") );
|
|
|
|
if( ! DecodeHmenuKey( pIDString, dwIDStringLen, NULL, phmenu, pidChild ) )
|
|
{
|
|
TraceParam( TEXT("CPropMgr::DecomposeHmenuIdentityString: not a valid HMENU id string") );
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|