Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
ptutil.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 26k
Category:

Windows Kernel

Development Platform:

Visual C++

ptutil.cpp：Code Content
  1. //-------------------------------------------------------------------------//
  2. //
  3. // PTutil.cpp
  4. //
  5. //-------------------------------------------------------------------------//
  6. #include "pch.h"
  7. #include "PTutil.h"
  8. #include "PTserver.h"
  10. #define SAFE_SYSFREESTRING( bstr )  if((bstr)){ SysFreeString((bstr)); (bstr)=NULL; }
  11. #define SAFE_COPYSYSSTRING( dest, src )  if((src)){ (dest)=SysAllocString((src)); }
  13. //-------------------------------------------------------------------------//
  14. //  Property Folder ID definitions
  15. //  HACKHACK: These should go in shlguid
  17. // {19469210-75DE-11d2-BE77-00A0C9A83DA1}
  18. static const PFID PFID_Description =
  19.     { 0x19469210, 0x75de, 0x11d2, { 0xbe, 0x77, 0x0, 0xa0, 0xc9, 0xa8, 0x3d, 0xa1 } };
  21. // {19469211-75DE-11d2-BE77-00A0C9A83DA1}
  22. static const PFID PFID_Origin =
  23. { 0x19469211, 0x75de, 0x11d2, { 0xbe, 0x77, 0x0, 0xa0, 0xc9, 0xa8, 0x3d, 0xa1 } };
  25. // {19469212-75DE-11d2-BE77-00A0C9A83DA1}
  26. static const PFID PFID_ImageProperties =
  27. { 0x19469212, 0x75de, 0x11d2, { 0xbe, 0x77, 0x0, 0xa0, 0xc9, 0xa8, 0x3d, 0xa1 } };
  29. // {19469213-75DE-11d2-BE77-00A0C9A83DA1}
  30. static const PFID PFID_AudioProperties =
  31. { 0x19469213, 0x75de, 0x11d2, { 0xbe, 0x77, 0x0, 0xa0, 0xc9, 0xa8, 0x3d, 0xa1 } };
  33. // {19469214-75DE-11d2-BE77-00A0C9A83DA1}
  34. static const PFID PFID_VideoProperties =
  35. { 0x19469214, 0x75de, 0x11d2, { 0xbe, 0x77, 0x0, 0xa0, 0xc9, 0xa8, 0x3d, 0xa1 } };
  37. // {19469214-75DE-11d2-BE77-00A0C9A83DA1}
  38. static const PFID PFID_MidiProperties =
  39. { 0x19469215, 0x75de, 0x11d2, { 0xbe, 0x77, 0x0, 0xa0, 0xc9, 0xa8, 0x3d, 0xa1 } };
  41. // {4C927CBB-7994-11d2-BE78-00A0C9A83DA1}
  42. static const PFID PFID_FaxProperties = 
  43. { 0x4c927cbb, 0x7994, 0x11d2, { 0xbe, 0x78, 0x0, 0xa0, 0xc9, 0xa8, 0x3d, 0xa1 } };
  45. //-------------------------------------------------------------------------//
  46. LPWSTR WINAPI StrA2W( UINT nCodePage, LPWSTR pwsz, LPCSTR pasz, int cch )
  47. {
  48.     ASSERT(pwsz != NULL);
  49.     ASSERT(pasz != NULL);
  51.     pwsz[0] = '';
  52.     MultiByteToWideChar( nCodePage, 0, pasz, -1, pwsz, cch );
  53.     return pwsz;
  54. }
  56. //-------------------------------------------------------------------------//
  57. LPSTR WINAPI StrW2A( UINT nCodePage, LPSTR pasz, LPCWSTR pwsz, int cch )
  58. {
  59.     ASSERT(pasz != NULL);
  60.     ASSERT(pwsz != NULL);
  62.     pasz[0] = '';
  63.     WideCharToMultiByte( nCodePage, 0, pwsz, -1, pasz, cch, NULL, NULL ) ;
  64.     return pasz ;
  65. }
  67. //-------------------------------------------------------------------------//
  68. BOOL WINAPI StrRoundTripsW( UINT nCodePage, LPCWSTR pwsz )
  69. {
  70.     ASSERT( pwsz );
  71.     
  72.     int    cch = lstrlenW( pwsz ) ;
  73.     CHAR*  paszTest = (CHAR*) alloca( sizeof(CHAR)  * (cch+1) ) ;
  74.     WCHAR* pwszTest = (WCHAR*)alloca( sizeof(WCHAR) * (cch+1) ) ;
  76.     StrA2W( nCodePage, 
  77.             pwszTest,
  78.             StrW2A( nCodePage, paszTest, pwsz, cch ),
  79.             cch ) ;
  81.     return 0 == memcmp( pwsz, pwszTest, cch * sizeof(WCHAR) ) ;
  82. }
  84. //-------------------------------------------------------------------------//
  85. BOOL WINAPI StrRoundTripsA( UINT nCodePage, LPCSTR pasz )
  86. {
  87.     ASSERT( pwsz );
  88.     
  89.     int    cch = lstrlenA( pasz ) ;
  90.     CHAR*  paszTest = (CHAR*)alloca( sizeof(CHAR)  * (cch+1) ) ;
  91.     WCHAR* pwszTest = (WCHAR*)alloca( sizeof(WCHAR) * (cch+1) ) ;
  93.     StrW2A( nCodePage,
  94.             paszTest,
  95.             StrA2W( nCodePage, pwszTest, pasz, cch ),
  96.             cch ) ;
  98.     return 0 == memcmp( pasz, paszTest, cch * sizeof(CHAR) ) ;
  99. }
  101. //-------------------------------------------------------------------------//
  102. void InitPropFolderItem( struct tagPROPFOLDERITEM* pItem )
  103. {
  104.     if( pItem )
  105.     {
  106.         memset( pItem, 0, sizeof(*pItem) ) ;
  107.         pItem->cbStruct = sizeof(*pItem) ;
  108.         pItem->pfid     = PFID_NULL ;
  109.         pItem->iOrder   = -1 ;
  110.     }
  111. }
  113. //-------------------------------------------------------------------------//
  114. void ClearPropFolderItem( struct tagPROPFOLDERITEM* pItem )
  115. {
  116.     if( IsValidPropFolderItem( pItem ) )
  117.     {
  118.         SAFE_SYSFREESTRING( pItem->bstrName ) ;
  119.         SAFE_SYSFREESTRING( pItem->bstrDisplayName ) ;
  120.         SAFE_SYSFREESTRING( pItem->bstrQtip ) ;
  121.         InitPropFolderItem( pItem ) ;
  122.     }
  123. }
  125. //-------------------------------------------------------------------------//
  126. BOOL CopyPropFolderItem( struct tagPROPFOLDERITEM* pDest, const struct tagPROPFOLDERITEM* pSrc )
  127. {
  128.     if( !( pDest && IsValidPropFolderItem( pDest ) && IsValidPropFolderItem( pSrc ) ) )
  129.     {
  130.         ASSERT( FALSE ) ; // invalid arg (pDest) or unitialized dest or src.
  131.         return FALSE ;
  132.     }
  133.     ClearPropFolderItem( pDest ) ;
  134.     
  135.     *pDest = *pSrc ;
  136.     SAFE_COPYSYSSTRING( pDest->bstrName, pSrc->bstrName ) ;
  137.     SAFE_COPYSYSSTRING( pDest->bstrDisplayName, pSrc->bstrDisplayName ) ;
  138.     SAFE_COPYSYSSTRING( pDest->bstrQtip, pSrc->bstrQtip ) ;
  139.     return TRUE ;
  140. }
  142. //-------------------------------------------------------------------------//
  143. BOOL IsValidPropFolderItem( const struct tagPROPFOLDERITEM* pItem )
  144. {
  145.     return pItem!=NULL && pItem->cbStruct==sizeof(*pItem) ;
  146. }
  148. //-------------------------------------------------------------------------//
  149. void InitPropertyItem( struct tagPROPERTYITEM* pItem )
  150. {
  151.     if( pItem )
  152.     {
  153.         memset( pItem, 0, sizeof(*pItem) ) ;
  154.         pItem->cbStruct = sizeof(*pItem) ;
  155.         pItem->pfid     = PFID_NULL ;
  156.         pItem->iOrder   = -1 ;
  157.     }
  158. }
  160. //-------------------------------------------------------------------------//
  161. void ClearPropertyItem( struct tagPROPERTYITEM* pItem )
  162. {
  163.     if( IsValidPropertyItem( pItem ) )
  164.     {
  165.         SAFE_SYSFREESTRING( pItem->bstrName ) ;
  166.         SAFE_SYSFREESTRING( pItem->bstrDisplayName ) ;
  167.         SAFE_SYSFREESTRING( pItem->bstrQtip ) ;
  168.         PropVariantClear( &pItem->val ) ;
  169.     }
  170.     InitPropertyItem( pItem ) ;
  171. }
  173. //-------------------------------------------------------------------------//
  174. BOOL CopyPropertyItem( struct tagPROPERTYITEM* pDest, const struct tagPROPERTYITEM* pSrc )
  175. {
  176.     if( !( pDest && IsValidPropertyItem( pSrc ) && IsValidPropertyItem( pDest ) ) )
  177.     {
  178.         ASSERT( FALSE ) ;// invalid arg (pDest) or unitialized source, dest.
  179.         return FALSE ;
  180.     }
  181.     ClearPropertyItem( pDest ) ;
  182.         
  183.     *pDest = *pSrc ;
  184.     SAFE_COPYSYSSTRING( pDest->bstrName, pSrc->bstrName ) ;
  185.     SAFE_COPYSYSSTRING( pDest->bstrDisplayName, pSrc->bstrDisplayName ) ;
  186.     SAFE_COPYSYSSTRING( pDest->bstrQtip, pSrc->bstrQtip ) ;
  187.     PropVariantInit( &pDest->val ) ;
  188.     PropVariantCopy( &pDest->val, &pSrc->val ) ;
  189.     return TRUE ;
  190. }
  192. //-------------------------------------------------------------------------//
  193. BOOL IsValidPropertyItem( const struct tagPROPERTYITEM* pItem )
  194. {
  195.     return pItem!=NULL && pItem->cbStruct==sizeof(*pItem) ;
  196. }
  199. //-------------------------------------------------------------------------//
  200. void InitBasicPropertyItem( struct tagBASICPROPITEM* pItem )
  201. {
  202.     if( pItem )
  203.     {
  204.         memset( pItem, 0, sizeof(*pItem) ) ;
  205.         pItem->cbStruct = sizeof(*pItem) ;
  206.     }
  207. }
  209. //-------------------------------------------------------------------------//
  210. void ClearBasicPropertyItem( struct tagBASICPROPITEM* pItem )
  211. {
  212.     if( IsValidBasicPropertyItem( pItem ) )
  213.     {
  214.         PropVariantClear( &pItem->val ) ;
  215.     }
  216.     InitBasicPropertyItem( pItem ) ;
  217. }
  219. //-------------------------------------------------------------------------//
  220. BOOL CopyBasicPropertyItem( struct tagBASICPROPITEM* pDest, const struct tagBASICPROPITEM* pSrc )
  221. {
  222.     if( !( pDest && IsValidBasicPropertyItem( pSrc ) && IsValidBasicPropertyItem( pDest ) ) )
  223.     {
  224.         ASSERT( FALSE ) ;// invalid arg (pDest) or unitialized source, dest.
  225.         return FALSE ;
  226.     }
  227.     ClearBasicPropertyItem( pDest ) ;
  228.         
  229.     *pDest = *pSrc ;
  230.     PropVariantInit( &pDest->val ) ;
  231.     PropVariantCopy( &pDest->val, &pSrc->val ) ;
  232.     return TRUE ;
  233. }
  235. //-------------------------------------------------------------------------//
  236. BOOL IsValidBasicPropertyItem( const struct tagBASICPROPITEM* pItem )
  237. {
  238.     return pItem!=NULL && pItem->cbStruct==sizeof(*pItem) ;
  239. }
  241. //-------------------------------------------------------------------------//
  242. void InitPropVariantDisplay( struct tagPROPVARIANT_DISPLAY* pItem )
  243. {
  244.     if( pItem )
  245.     {
  246.         PropVariantInit( &pItem->val ) ;
  247.         pItem->bstrDisplay = NULL ;
  248.     }
  249. }
  251. //-------------------------------------------------------------------------//
  252. BOOL CopyPropVariantDisplay( struct tagPROPVARIANT_DISPLAY* pDest, const struct tagPROPVARIANT_DISPLAY* pSrc )
  253. {
  254.     if( pDest && pSrc )
  255.     {
  256.         ClearPropVariantDisplay( pDest ) ;
  257.         PropVariantCopy( &pDest->val, &pSrc->val ) ;
  259.         if( pSrc->bstrDisplay )
  260.             pDest->bstrDisplay =  SysAllocString( pSrc->bstrDisplay ) ;
  261.         
  262.         return TRUE ;
  263.     }
  264.     return FALSE ;
  265. }
  267. //-------------------------------------------------------------------------//
  268. void ClearPropVariantDisplay( struct tagPROPVARIANT_DISPLAY* pItem )
  269. {
  270.     if( pItem )
  271.     {
  272.         PropVariantClear( &pItem->val ) ;
  273.         if( pItem->bstrDisplay )
  274.             SysFreeString( pItem->bstrDisplay ) ;
  275.         InitPropVariantDisplay( pItem ) ;
  276.     }
  277. }
  279. //-------------------------------------------------------------------------//
  280. BOOL PTCheckWriteAccessA( LPCSTR pszFile )
  281. {
  282.     //  Test write access.
  283.     HANDLE hFile = CreateFileA( pszFile, GENERIC_WRITE|GENERIC_READ, FILE_SHARE_READ, NULL,
  284.                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OPEN_NO_RECALL, NULL );
  285.     if( INVALID_HANDLE_VALUE != hFile )
  286.     {
  287.         CloseHandle( hFile );
  288.         return TRUE;
  289.     }
  290.     return FALSE;
  291. }
  293. //-------------------------------------------------------------------------//
  294. BOOL PTCheckWriteAccessW( LPCWSTR pwszFile )
  295. {
  296.     //  Test write access.
  297.     HANDLE hFile = CreateFileW( pwszFile, GENERIC_WRITE|GENERIC_READ, FILE_SHARE_READ, NULL,
  298.                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OPEN_NO_RECALL, NULL );
  299.     if( INVALID_HANDLE_VALUE != hFile )
  300.     {
  301.         CloseHandle( hFile );
  302.         return TRUE;
  303.     }
  304.     return FALSE;
  305. }
  307. //-------------------------------------------------------------------------//
  308. ULONG PTGetFileAttributesA( LPCSTR pszFile )
  309. {
  310.     ULONG dwAttr = GetFileAttributesA( pszFile );
  311.     if( dwAttr != 0xFFFFFFFF && (dwAttr & FILE_ATTRIBUTE_READONLY) == 0 )
  312.     {
  313.         if( !PTCheckWriteAccessA( pszFile ) )
  314.             dwAttr |= FILE_ATTRIBUTE_READONLY; 
  315.     }
  316.     return dwAttr;
  317. }
  319. //-------------------------------------------------------------------------//
  320. ULONG PTGetFileAttributesW( LPCWSTR pszFile )
  321. {
  322.     ULONG dwAttr = GetFileAttributesW( pszFile );
  323.     
  324.     if( dwAttr != 0xFFFFFFFF && (dwAttr & FILE_ATTRIBUTE_READONLY) == 0 )
  325.     {
  326.         if( !PTCheckWriteAccessW( pszFile ) )
  327.             dwAttr |= FILE_ATTRIBUTE_READONLY; 
  328.     }
  329.     return dwAttr;
  330. }
  332. //-------------------------------------------------------------------------//
  333. //  Tokenizes a string into a linked list of token descriptors.  On return, 
  334. //  all delimiters present in the original input string will be
  335. //  replaced with NULL characters.
  336. int GetTokens( LPTSTR pszString, LPCTSTR pszDelims, OUT PSTRTOK *ppList )
  337. {
  338.     PSTRTOK pNext = NULL,
  339.             pTok  = NULL ;
  340.     int     cRet  = 0 ;
  342.     if( !( pszString && *pszString && pszDelims && *pszDelims && ppList) )
  343.         return NULL ;
  345.     *ppList = NULL ;
  347.     LPTSTR  pszTok = pszString ;
  348.     int     cchString = lstrlen( pszString ),
  349.             cchDelims = lstrlen( pszDelims ) ;
  351.     for( int i=0; i < cchString; i++ )
  352.     {
  353.         //  Is the character a delimiter
  354.         if( _tcschr( pszDelims, pszTok[i] )!=NULL )
  355.         {
  356.             pszTok[i] = (TCHAR)0 ;  // zero it in place.
  357.             if( i > 0 ) continue ;  // go to next character if we're into the string
  358.         }
  360.         //  Allocate and initialize a token descriptor
  361.         if( (pTok = new STRTOK)!=NULL )
  362.         {
  363.             memset( pTok, 0, sizeof(*pTok) ) ;
  364.             pTok->pszTok = &pszTok[i] ;
  365.             
  366.             //  skip to next character
  367.             for( ; i < cchString ; i++ )
  368.             {
  369.                 if( _tcschr( pszDelims, pszTok[i] )!=NULL )
  370.                 {
  371.                     pszTok[i] = (TCHAR)0 ;  // Zero the delimiter in place
  372.                     break ;                 // We've reached the end of the token;
  373.                                             // bust out of the loop and link it to the list.
  374.                 }
  375.                 pTok->cchTok++ ;  // not a delimiter; increment char count for the token.
  376.             }
  378.             //  link the token to the list
  379.             if( pNext == NULL )
  380.                 *ppList = pNext = pTok ; // no list yet; establish our head.
  381.             else
  382.             {
  383.                 pNext->pNext = pTok ;
  384.                 pNext = pTok ;
  385.             }
  386.             cRet++ ;  // increment token count
  387.         }
  388.     }
  389.     return cRet ;
  390. }
  392. //-------------------------------------------------------------------------//
  393. //  Frees a list of token descriptors generated by GetTokens().
  394. int FreeTokens( PSTRTOK* ppList )
  395. {
  396.     int cTokens = 0 ;
  398.     if( ppList )
  399.     {
  400.         while( *ppList )
  401.         {
  402.             PSTRTOK pNext = (*ppList)->pNext ;
  403.             delete (*ppList) ;
  404.             cTokens++ ;
  405.             (*ppList) = pNext ;
  406.         }
  407.     }
  408.     
  409.     return cTokens ;
  410. }
  413. //-------------------------------------------------------------------------//
  414. //  Time validation routines.   These will remain necessary until
  415. //  SystemTimeToVariantTime() and VariantTimeToSystemTime() to date validation.
  416. //  See bug# #329259 for more info.
  417. //-------------------------------------------------------------------------//
  418. #if 0
  419. //-------------------------------------------------------------------------//
  420. EXTERN_C BOOL IsValidSystemTime( SYSTEMTIME* pst )
  421. {
  422.     FILETIME ft ;
  423.     return SystemTimeToFileTime( pst, &ft ); // validates the SYSTEMTIME arg
  424. }
  426. //-------------------------------------------------------------------------//
  427. EXTERN_C BOOL IsValidFileTime( FILETIME* pft )
  428. {
  429.     SYSTEMTIME st;
  430.     return FileTimeToSystemTime( pft, &st ); // validates the FILETIME arg
  431. }
  433. //-------------------------------------------------------------------------//
  434. EXTERN_C BOOL IsValidVariantTime( DATE* pvt )
  435. {
  436.     SYSTEMTIME st;
  437.     FILETIME   ft;
  438.     VariantTimeToSystemTime( pvt, &st );
  439.     return SystemTimeToFileTime( &st, &ft );// validates the SYSTEMTIME arg
  440. }
  441. #endif 0
  444. //-------------------------------------------------------------------------//
  445. //  Accessibility primitives
  446. //-------------------------------------------------------------------------//
  448. //-------------------------------------------------------------------------//
  449. typedef HRESULT (WINAPI * PFNCREATESDTACCESSIBLEPROXY)( HWND, LPCTSTR, LONG, REFIID, void ** );
  450. typedef LRESULT (WINAPI * PFNLRESULTFROMOBJECT)( REFIID, WPARAM, LPUNKNOWN );
  452. #ifdef UNICODE
  453. #define CREATESTDACCESSIBLEPROXY    "CreateStdAccessibleProxyW"
  454. #else
  455. #define CREATESTDACCESSIBLEPROXY    "CreateStdAccessibleProxyA"
  456. #endif
  457. #define LRESULTFROMOBJECT           "LresultFromObject"
  460. //-------------------------------------------------------------------------//
  461. class COleAcc
  462. //-------------------------------------------------------------------------//
  463. {
  464. public:
  465.     COleAcc()
  466.         :   _hinstOleAcc(NULL),
  467.             _pfnCreateStdAccessibleProxy(NULL),
  468.             _pfnLresultFromObject(NULL) {}
  470.     ~COleAcc()    {
  471.         if( _hinstOleAcc )  {
  472.             FreeLibrary( _hinstOleAcc );
  473.             _hinstOleAcc = NULL;
  474.         }
  475.     }
  477.     HRESULT _CreateStdAccessibleProxy( HWND, WPARAM, IAccessible** );
  478.     LRESULT _LresultFromObject( REFIID, WPARAM, LPUNKNOWN );
  480. private:
  481.     BOOL Init();
  483.     HINSTANCE                    _hinstOleAcc;
  484.     PFNCREATESDTACCESSIBLEPROXY  _pfnCreateStdAccessibleProxy;
  485.     PFNLRESULTFROMOBJECT         _pfnLresultFromObject;    
  487. } OleAcc ;
  489. //-------------------------------------------------------------------------//
  490. BOOL COleAcc::Init()
  491. {
  492.     if( NULL == _hinstOleAcc )
  493.     {
  494.         if( NULL == (_hinstOleAcc = LoadLibrary( TEXT("oleacc.dll") )) )
  495.             return FALSE;
  496.     }
  497.     
  498.     if( NULL == _pfnCreateStdAccessibleProxy )
  499.     {
  500.         if( NULL == (_pfnCreateStdAccessibleProxy = (PFNCREATESDTACCESSIBLEPROXY)GetProcAddress(
  501.                             _hinstOleAcc, CREATESTDACCESSIBLEPROXY )) )
  502.             return FALSE;
  503.     }
  505.     if( NULL == _pfnLresultFromObject )
  506.     {
  507.         if( NULL == (_pfnLresultFromObject = (PFNLRESULTFROMOBJECT)GetProcAddress(
  508.                             _hinstOleAcc, LRESULTFROMOBJECT )) )
  509.             return FALSE;
  510.     }
  511.    
  512.     return TRUE;
  513. }
  515. //-------------------------------------------------------------------------//
  516. HRESULT COleAcc::_CreateStdAccessibleProxy( HWND hwnd, WPARAM wParam, IAccessible** ppacc )
  517. {
  518. #if DBG
  519.     // Validate that we declared the function correctly
  520.     if (_pfnCreateStdAccessibleProxy == CreateStdAccessibleProxy) { }
  521. #endif
  522.     if( !Init() )
  523.         return E_UNEXPECTED;
  524.     return _pfnCreateStdAccessibleProxy( hwnd, WC_TREEVIEW, (LONG)wParam,
  525.                                          IID_IAccessible, (void **)ppacc );
  526. }
  528. //-------------------------------------------------------------------------//
  529. HRESULT _CreateStdAccessibleProxy( HWND hwnd, WPARAM wParam, IAccessible** ppacc )
  530. {
  531.     return OleAcc._CreateStdAccessibleProxy( hwnd, wParam, ppacc );
  532. }
  534. //-------------------------------------------------------------------------//
  535. LRESULT COleAcc::_LresultFromObject( REFIID riid, WPARAM wParam, LPUNKNOWN punk )
  536. {
  537. #if DBG
  538.     // Validate that we declared the function correctly
  539.     if (_pfnLresultFromObject == LresultFromObject) { }
  540. #endif
  541.     if( !Init() )
  542.         return E_UNEXPECTED;
  543.     return _pfnLresultFromObject( riid, wParam, punk );
  544. }
  546. //-------------------------------------------------------------------------//
  547. LRESULT _LresultFromObject( REFIID riid, WPARAM wParam, LPUNKNOWN punk )
  548. {
  549.     return OleAcc._LresultFromObject( riid, wParam, punk );
  550. }
  552. //-------------------------------------------------------------------------//
  553. //  CAccessibleBase
  554. //-------------------------------------------------------------------------//
  556. //-------------------------------------------------------------------------//
  557. //  CAccessibleBase IUnknown impl
  558. STDMETHODIMP CAccessibleBase::QueryInterface( REFIID riid, void** ppvObj )
  559. {
  560.     HRESULT hres;
  561.     if( !ppvObj ) return E_POINTER;
  562.     *ppvObj = NULL;
  564.     if( IsEqualIID( riid, IID_IUnknown ) )
  565.         *ppvObj = (IUnknown*)(IAccessible*)this;
  566.     else if( IsEqualIID( riid, IID_IDispatch ) )
  567.         *ppvObj = (IDispatch*)this;
  568.     else if( IsEqualIID( riid, IID_IAccessible ) )
  569.         *ppvObj = (IAccessible*)this;
  570.     else if( IsEqualIID( riid, IID_IOleWindow ) )
  571.         *ppvObj = (IOleWindow*)this;
  573.     if( *ppvObj )
  574.     {
  575.         AddRef();
  576.         return S_OK;
  577.     }
  578.     return E_NOINTERFACE;
  579. }
  581. //-------------------------------------------------------------------------//
  582. STDMETHODIMP_(ULONG) CAccessibleBase::AddRef()
  583. {
  584.     return InterlockedIncrement( (LONG*)&_cRef );
  585. }
  587. //-------------------------------------------------------------------------//
  588. STDMETHODIMP_(ULONG) CAccessibleBase::Release()
  589. {
  590.     ULONG cRef = InterlockedDecrement( (LONG*)&_cRef );
  591.     if( cRef <= 0 )
  592.     {
  593.         DllRelease();
  594.         delete this;
  595.     }
  596.     return cRef;
  597. }
  599. //-------------------------------------------------------------------------//
  600. //  CAccessibleBase IOleWindow impl
  601. STDMETHODIMP CAccessibleBase::GetWindow( HWND* phwnd )
  602. {
  603.     *phwnd = _hwnd;
  604.     return IsWindow( _hwnd ) ? S_OK : S_FALSE;
  605. }
  607. //-------------------------------------------------------------------------//
  608. //  CAccessibleBase IDispatch impl
  609. //-------------------------------------------------------------------------//
  611. UINT WMU_GETACCSTRING()
  612. {
  613.     static UINT _wmu_getaccstring = 0;
  614.     if( 0 == _wmu_getaccstring )
  615.         _wmu_getaccstring = RegisterWindowMessage( TEXT("PropTreeGetAccString") );
  616.     return _wmu_getaccstring;
  617. }
  619. inline BSTR _GetAccString( HWND hwnd, DISPID dispid, LPARAM lParam ) 
  620. {
  621.     if( lParam )
  622.         return (BSTR)SendMessage( hwnd, WMU_GETACCSTRING(), (WPARAM)dispid, lParam );
  623.     return NULL;
  624. }
  626. static BOOL _accLoadTypeInfo( ITypeInfo** ppti )
  627. {
  628.     ITypeLib* ptl;
  629.     HRESULT hr = LoadTypeLib(L"oleacc.dll", &ptl);
  631.     if( SUCCEEDED( hr ) )
  632.     {
  633.         hr = ptl->GetTypeInfoOfGuid( IID_IAccessible, ppti );
  634.         ATOMICRELEASE( ptl );
  635.     }
  636.     return hr;
  637. }
  639. STDMETHODIMP CAccessibleBase::GetTypeInfoCount( UINT * pctinfo ) 
  640. { 
  641.     *pctinfo = 1;
  642.     return S_OK;
  643. }
  645. STDMETHODIMP CAccessibleBase::GetTypeInfo( UINT itinfo, LCID lcid, ITypeInfo** pptinfo )
  646. { 
  647.     HRESULT hr = E_FAIL;
  648.     if( NULL == _ptiAcc && FAILED( (hr = _accLoadTypeInfo( &_ptiAcc )) ) )
  649.         return hr;
  651.     *pptinfo = _ptiAcc;
  652.     (*pptinfo)->AddRef();
  653.     return S_OK;
  654. }
  656. STDMETHODIMP CAccessibleBase::GetIDsOfNames( 
  657.     REFIID riid, 
  658.     OLECHAR** rgszNames, 
  659.     UINT cNames,
  660.     LCID lcid, DISPID * rgdispid )
  661. {
  662.     HRESULT hr = E_FAIL;
  664.     if( IID_NULL != riid && IID_IAccessible != riid )
  665.         return DISP_E_UNKNOWNINTERFACE;
  667.     if( NULL == _ptiAcc && FAILED( (hr = _accLoadTypeInfo( &_ptiAcc )) ) )
  668.         return hr;
  670.     return _ptiAcc->GetIDsOfNames( rgszNames, cNames, rgdispid );
  671. }
  673. STDMETHODIMP CAccessibleBase::Invoke( 
  674.     DISPID  dispidMember, 
  675.     REFIID  riid, 
  676.     LCID    lcid, 
  677.     WORD    wFlags,
  678.     DISPPARAMS * pdispparams, 
  679.     VARIANT * pvarResult, 
  680.     EXCEPINFO * pexcepinfo, 
  681.     UINT * puArgErr )
  682. {
  683.     HRESULT hr = E_FAIL;
  684.     if( IID_NULL != riid && IID_IAccessible != riid )
  685.         return DISP_E_UNKNOWNINTERFACE;
  687.     if( NULL == _ptiAcc && FAILED( (hr = _accLoadTypeInfo( &_ptiAcc )) ) )
  688.         return hr;
  690.     return _ptiAcc->Invoke( this, dispidMember, wFlags, pdispparams, 
  691.                             pvarResult, pexcepinfo, puArgErr );
  692. }
  694. STDMETHODIMP CAccessibleBase::get_accParent( IDispatch ** ppdispParent )
  695. {
  696.     ASSERT(_paccProxy);
  697.     return _paccProxy->get_accParent( ppdispParent );
  698. }
  700. STDMETHODIMP CAccessibleBase::get_accChildCount( long * pcChildren )
  701. {
  702.     ASSERT(_paccProxy);
  703.     return _paccProxy->get_accChildCount( pcChildren );
  704. }
  706. STDMETHODIMP CAccessibleBase::get_accChild( VARIANT varChildIndex, IDispatch ** ppdispChild)
  707. {
  708.     ASSERT(_paccProxy);
  709.     return _paccProxy->get_accChild( varChildIndex, ppdispChild );
  710. }
  712. STDMETHODIMP CAccessibleBase::get_accName( VARIANT varChild, BSTR* pbstrName)
  713. {
  714.     ASSERT(_paccProxy);
  715.     *pbstrName = _GetAccString( _hwnd, DISPID_ACC_NAME, varChild.lVal );
  716.     return *pbstrName ? S_OK :S_FALSE ;
  717. }
  719. STDMETHODIMP CAccessibleBase::get_accValue( VARIANT varChild, BSTR* pbstrValue)
  720. {
  721.     ASSERT(_paccProxy);
  722.     *pbstrValue = _GetAccString( _hwnd, DISPID_ACC_VALUE, varChild.lVal );
  723.     return *pbstrValue ? S_OK : S_FALSE;
  724. }
  726. STDMETHODIMP CAccessibleBase::get_accDescription( VARIANT varChild, BSTR * pbstrDescription)
  727. {
  728.     ASSERT(_paccProxy);
  729.     *pbstrDescription = _GetAccString( _hwnd, DISPID_ACC_DESCRIPTION, varChild.lVal );
  730.     return *pbstrDescription ? S_OK :S_FALSE ;
  731. }
  733. STDMETHODIMP CAccessibleBase::get_accRole( VARIANT varChild, VARIANT *pvarRole )
  734. {
  735.     ASSERT(_paccProxy);
  736.     return _paccProxy->get_accRole( varChild, pvarRole );
  737. }
  739. STDMETHODIMP CAccessibleBase::get_accState( VARIANT varChild, VARIANT *pvarState )
  740. {
  741.     ASSERT(_paccProxy);
  742.     return _paccProxy->get_accState( varChild, pvarState );
  743. }
  745. STDMETHODIMP CAccessibleBase::get_accHelp( VARIANT varChild, BSTR* pbstrHelp )
  746. {
  747.     ASSERT(_paccProxy);
  748.     return _paccProxy->get_accHelp( varChild, pbstrHelp );
  749. }
  751. STDMETHODIMP CAccessibleBase::get_accHelpTopic( BSTR* pbstrHelpFile, VARIANT varChild, long* pidTopic )
  752. {
  753.     ASSERT(_paccProxy);
  754.     return _paccProxy->get_accHelpTopic( pbstrHelpFile, varChild, pidTopic );
  755. }
  757. STDMETHODIMP CAccessibleBase::get_accKeyboardShortcut( VARIANT varChild, BSTR* pbstrKeyboardShortcut )
  758. {
  759.     ASSERT(_paccProxy);
  760.     return _paccProxy->get_accKeyboardShortcut( varChild, pbstrKeyboardShortcut );
  761. }
  763. STDMETHODIMP CAccessibleBase::get_accFocus( VARIANT FAR * pvarFocusChild )
  764. {
  765.     ASSERT(_paccProxy);
  766.     return _paccProxy->get_accFocus( pvarFocusChild );
  767. }
  769. STDMETHODIMP CAccessibleBase::get_accSelection( VARIANT FAR * pvarSelectedChildren )
  770. {
  771.     ASSERT(_paccProxy);
  772.     return _paccProxy->get_accSelection( pvarSelectedChildren );
  773. }
  775. STDMETHODIMP CAccessibleBase::get_accDefaultAction( VARIANT varChild, BSTR* pbstrDefaultAction )
  776. {
  777.     ASSERT(_paccProxy);
  778.     return _paccProxy->get_accDefaultAction( varChild, pbstrDefaultAction );
  779. }
  781. STDMETHODIMP CAccessibleBase::accSelect( long flagsSelect, VARIANT varChild )
  782. {
  783.     ASSERT(_paccProxy);
  784.     return _paccProxy->accSelect( flagsSelect, varChild );
  785. }
  787. STDMETHODIMP CAccessibleBase::accLocation( long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild )
  788. {
  789.     ASSERT(_paccProxy);
  790.     return _paccProxy->accLocation( pxLeft, pyTop, pcxWidth, pcyHeight, varChild );
  791. }
  793. STDMETHODIMP CAccessibleBase::accNavigate( long navDir, VARIANT varStart, VARIANT * pvarEndUpAt )
  794. {
  795.     ASSERT(_paccProxy);
  796.     return _paccProxy->accNavigate( navDir, varStart, pvarEndUpAt );
  797. }
  799. STDMETHODIMP CAccessibleBase::accHitTest( long xLeft, long yTop, VARIANT * pvarChildAtPoint )
  800. {
  801.     ASSERT(_paccProxy);
  802.     return _paccProxy->accHitTest( xLeft, yTop, pvarChildAtPoint );
  803. }
  805. STDMETHODIMP CAccessibleBase::accDoDefaultAction( VARIANT varChild )
  806. {
  807.     ASSERT(_paccProxy);
  808.     return _paccProxy->accDoDefaultAction( varChild );
  809. }
  811. STDMETHODIMP CAccessibleBase::put_accName( VARIANT varChild, BSTR bstrName )
  812. {
  813.     ASSERT(_paccProxy);
  814.     return _paccProxy->put_accName( varChild, bstrName );
  815. }
  817. STDMETHODIMP CAccessibleBase::put_accValue( VARIANT varChild, BSTR bstrValue )
  818. {
  819.     ASSERT(_paccProxy);
  820.     return _paccProxy->put_accValue( varChild, bstrValue );
  821. }