Category

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

Windows Kernel

Development Platform:

Visual C++

shell32.cpp：Code Content
  1. // Wrappers for APIs that have moved elsewhere
  3. #include "priv.h"
  4. #include "shlwapip.h"
  6. //------------------------------------------------------------------------
  7. //
  8. // APIs from SHDOCVW that are now forwarded to SHLWAPI
  9. //
  10. //
  11. //  Note that we cannot use DLL forwarders because there is a bug
  12. //  in Win95 where the loader screws up forwarders for bound DLLs.
  14. STDAPI_(DWORD) StopWatchModeFORWARD(VOID)
  15. {
  16.     return StopWatchMode();
  17. }
  19. STDAPI_(DWORD) StopWatchFlushFORWARD(VOID)
  20. {
  21.     return StopWatchFlush();
  22. }
  24. #ifdef ux10
  25. /*IEUNIX : In the hp-ux linker, there is no option of specifying an internal name and an external name.  */
  26. #define StopWatch StopWatch
  27. #define StopWatchFORWARD StopWatch
  28. #endif 
  30. STDAPI_(DWORD) StopWatchFORWARD(DWORD dwId, LPCSTR pszDesc, DWORD dwType, DWORD dwFlags, DWORD dwCount)
  31. {
  32.     return StopWatchA(dwId, (LPCSTR)pszDesc, dwType, dwFlags, dwCount);
  33. }
  35. //------------------------------------------------------------------------
  36. //
  37. // APIs from SHDOCVW that are now forwarded to SHELL32/SHDOC41
  39. //
  40. //  This variable name is a misnomer.  It's really
  41. //
  42. //  g_hinstShell32OrShdoc401DependingOnWhatWeDetected;
  43. //
  44. //  I can live with the misnomer; saves typing.  Think of it as
  45. //  "the INSTANCE of SHDOC401 or whatever DLL is masquerading as
  46. //  SHDOC401".
  47. //
  48. //
  50. extern "C" { HINSTANCE g_hinstSHDOC401 = NULL; }
  52. //
  53. //  GetShdoc401
  54. //
  55. //  Detect whether we should be using Shell32 or Shdoc401 to handle
  56. //  active desktop stuff.  The rule is
  57. //
  58. //  If PF_FORCESHDOC401 is set, then use shdoc401. (DEBUG only)
  59. //  If shell32 version >= 5, then use shell32.
  60. //  Else use shdoc401.
  61. //
  62. //  Warning:  THIS FUNCTION CANNOT BE CALLED DURING PROCESS_ATTACH
  63. //  because it calls LoadLibrary.
  65. HINSTANCE GetShdoc401()
  66. {
  67.     DWORD dwMajorVersion;
  68.     HINSTANCE hinst;
  69.     HINSTANCE hinstSh32 = GetModuleHandle(TEXT("SHELL32.DLL"));
  70.     ASSERT(hinstSh32);
  72. #ifdef DEBUG
  73.     if (g_dwPrototype & PF_FORCESHDOC401) {
  74.         hinstSh32 = NULL; // force SHDOC401 to be loaded
  75.     }
  76. #endif
  78.     if (hinstSh32) {
  79.         DLLVERSIONINFO dllinfo;
  80.         DLLGETVERSIONPROC pfnGetVersion = (DLLGETVERSIONPROC)GetProcAddress(hinstSh32, "DllGetVersion");
  82.         dllinfo.cbSize = sizeof(DLLVERSIONINFO);
  83.         if (pfnGetVersion && SUCCEEDED(pfnGetVersion(&dllinfo))) {
  84.             dwMajorVersion = dllinfo.dwMajorVersion;
  85.         } else {
  86.             dwMajorVersion = 0;
  87.         }
  88.     } else {
  89.         dwMajorVersion = 0;
  90.     }
  92.     if (dwMajorVersion >= 5) {
  93.         hinst = hinstSh32;
  94.     } else {
  95.         hinst = LoadLibrary(TEXT("SHDOC401.DLL"));
  97.         if (NULL == hinst)
  98.         {
  99.             // If this fails we're screwed
  100.             TraceMsg(TF_ERROR, "Failed to load SHDOC401.DLL.  We're screwed...");
  101.         }
  102.     }
  103.     g_hinstSHDOC401 = hinst;
  105.     return hinst;
  106. }
  108. //
  109. //  GetShdoc401ProcAddress
  110. //
  111. //  Get a procedure from SHDOC401 or whoever is masquerading as same.
  112. //
  113. //  Warning:  THIS FUNCTION CANNOT BE CALLED DURING PROCESS_ATTACH
  114. //  because it calls LoadLibrary.
  116. FARPROC GetShdoc401ProcAddress(FARPROC *ppfn, UINT ord)
  117. {
  118.     if (*ppfn) {
  119.         return *ppfn;
  120.     } else {
  121.         HINSTANCE hinst = g_hinstSHDOC401;
  123.         //
  124.         //  No race condition here.  If two threads both call GetShdoc401,
  125.         //  all that happens is that we load SHDOC401 into memory and then
  126.         //  bump his refcount up to 2 instead of leaving it at 1.  Big deal.
  127.         //
  128.         if (hinst == NULL) {
  129.             hinst = GetShdoc401();
  130.         }
  132.         if (hinst) {
  133.             return *ppfn = GetProcAddress(hinst, (LPCSTR)LongToHandle(ord));
  134.         } else {
  135.             return NULL;
  136.         }
  137.     }
  138. }
  140. //
  141. //  Delay-load-like macros.
  142. //
  144. #define DELAY_LOAD_SHDOC401(_type, _err, _fn, _ord, _arg, _nargs)   
  145.     STDAPI_(_type) _fn _arg                                         
  146.     {                                                               
  147.         static FARPROC s_pfn##_fn = NULL;                           
  148.         FARPROC pfn = GetShdoc401ProcAddress(&s_pfn##_fn, _ord);    
  149.         if (pfn) {                                                  
  150.             typedef _type (__stdcall *PFN##_fn) _arg;               
  151.             return ((PFN##_fn)pfn) _nargs;                          
  152.         } else {                                                    
  153.             return _err;                                            
  154.         }                                                           
  155.     }                                                               
  157. #define DELAY_LOAD_SHDOC401_VOID(_fn, _ord, _arg, _nargs)           
  158.     STDAPI_(void) _fn _arg                                          
  159.     {                                                               
  160.         static FARPROC s_pfn##_fn = NULL;                           
  161.         FARPROC pfn = GetShdoc401ProcAddress(&s_pfn##_fn, _ord);    
  162.         if (pfn) {                                                  
  163.             typedef void (__stdcall *PFN##_fn) _arg;                
  164.             ((PFN##_fn)pfn) _nargs;                                 
  165.         }                                                           
  166.     }                                                               
  168. // IE4 Shell Integrated Explorer called ShellDDEInit in shdocvw to
  169. // set up DDE. Forward this call to SHELL32/SHDOC401 appropriately.
  171. DELAY_LOAD_SHDOC401_VOID(ShellDDEInit, 188,
  172.                          (BOOL fInit),
  173.                          (fInit));
  175. DELAY_LOAD_SHDOC401(HANDLE, NULL,
  176.                     SHCreateDesktop, 200,
  177.                     (IDeskTray* pdtray),
  178.                     (pdtray));
  180. DELAY_LOAD_SHDOC401(BOOL, FALSE,
  181.                     SHDesktopMessageLoop, 201,
  182.                     (HANDLE hDesktop),
  183.                     (hDesktop));
  185. // This may not have been used in IE4
  186. DELAY_LOAD_SHDOC401(BOOL, FALSE,
  187.                     DDEHandleViewFolderNotify, 202,
  188.                     (IShellBrowser* psb, HWND hwnd, LPNMVIEWFOLDER lpnm),
  189.                     (psb, hwnd, lpnm));
  191. DELAY_LOAD_SHDOC401(LPNMVIEWFOLDER, NULL,
  192.                     DDECreatePostNotify, 82,
  193.                    (LPNMVIEWFOLDER pnm), 
  194.                    (pnm));
  195.                     
  196.