home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / audio / wavefile / factory1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-05  |  5.1 KB  |  251 lines
  1. /**************************************************************************
  2.  *
  3.  *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4.  *  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5.  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6.  *  PURPOSE.
  7.  *
  8.  *  Copyright (C) 1992 - 1997 Microsoft Corporation.  All Rights Reserved.
  9.  *
  10.  **************************************************************************/
  11. /*
  12. **    
  13. **    FACTORY1.C - All of the class factory stuff for our handler
  14. **
  15. */
  16. #define    INITGUID
  17. #define INC_OLE2
  18.  
  19. #include <windows.h>
  20. #include <windowsx.h>
  21. #include <string.h>
  22. #include <mmsystem.h>
  23. #include <vfw.h>
  24.  
  25. #include "wavefile.h"
  26.  
  27.  
  28. HMODULE ghModule = NULL;    // global HMODULE/HINSTANCE for resource access
  29. //
  30. // Here are the function prototypes for the methods for the class factory
  31. //
  32. STDMETHODIMP WaveFactoryQueryInterface(
  33.     LPCLASSFACTORY pcf,
  34.     REFIID iid,
  35.     void FAR* FAR* ppv);
  36. STDMETHODIMP_(ULONG) WaveFactoryAddRef(
  37.     LPCLASSFACTORY pcf);
  38. STDMETHODIMP_(ULONG) WaveFactoryRelease(
  39.     LPCLASSFACTORY pcf);
  40. STDMETHODIMP WaveFactoryCreateInstance(
  41.     LPCLASSFACTORY pcf,
  42.     IUnknown FAR* pUnknownOuter,
  43.     REFIID riid,
  44.     void FAR* FAR* ppv);
  45. STDMETHODIMP WaveFactoryLockServer(
  46.     LPCLASSFACTORY pcf,
  47.     BOOL fLock);
  48. HRESULT WaveFactoryCreate(
  49.     REFCLSID    rclsid,
  50.     REFIID        riid,
  51.     void FAR* FAR*    ppv);
  52.  
  53.  
  54. //
  55. // And here's the Vtbl...
  56. //
  57. IClassFactoryVtbl    WaveFactoryVtbl = {
  58.             WaveFactoryQueryInterface,
  59.             WaveFactoryAddRef,
  60.             WaveFactoryRelease,
  61.             WaveFactoryCreateInstance,
  62.             WaveFactoryLockServer};
  63.  
  64. /*    -    -    -    -    -    -    -    -    */
  65.  
  66. EXTERN_C BOOL APIENTRY DllMain(HANDLE, DWORD, LPVOID);
  67. EXTERN_C BOOL APIENTRY DllMain(
  68. HANDLE hModule,
  69. DWORD dwReason,
  70. LPVOID lpReserved )
  71. {
  72.     switch( dwReason)
  73.     {
  74.         case DLL_PROCESS_ATTACH:
  75.             if(ghModule == NULL)
  76.                 ghModule = (HMODULE)hModule;
  77.             break;
  78.         case DLL_THREAD_ATTACH:
  79.             break;
  80.         case DLL_THREAD_DETACH:
  81.             break;
  82.         case DLL_PROCESS_DETACH:
  83.             break;
  84.     }
  85.     return TRUE;
  86. }
  87.  
  88. /*    -    -    -    -    -    -    -    -    */
  89.  
  90. BOOL FAR PASCAL WEP(
  91.     BOOL    fSystemExit)
  92. {
  93.     return TRUE;
  94. }
  95.  
  96. /*    -    -    -    -    -    -    -    -    */
  97.  
  98. //
  99. // Can we be unloaded? Only if our reference count AND lock counts are both
  100. // zero.
  101. //
  102. STDAPI DllCanUnloadNow(
  103.     void)
  104. {
  105.     return ResultFromScode((uLockCount || uUseCount) ? S_FALSE : S_OK);
  106. }
  107.  
  108. /*    -    -    -    -    -    -    -    -    */
  109.  
  110. //
  111. // Create a new class factory object.  We must allocate the space for our
  112. // structure ourselves since we're using C.
  113. //
  114. HRESULT WaveFactoryCreate(
  115.     REFCLSID    rclsid,
  116.     REFIID        riid,
  117.     void FAR* FAR*    ppv)
  118. {
  119.     LPWAVEFACTORY    pcf;
  120.     IUnknown FAR*    pUnknown;
  121.     HRESULT hresult;
  122.  
  123.     /*
  124.     ** Allocate the new class factory object from the heap
  125.     */
  126.     pcf = (LPWAVEFACTORY)GlobalAllocPtr(GMEM_MOVEABLE,sizeof(WAVEFACTORY));
  127.     if (pcf == NULL)
  128.         return ResultFromScode(E_OUTOFMEMORY);
  129.  
  130.     /* Initialize our structure */
  131.     pcf->lpVtbl = &WaveFactoryVtbl;
  132.     pcf->clsid = (CLSID FAR *)rclsid;
  133.     pcf->ulRef = 0;
  134.     pUnknown = (IUnknown FAR *)pcf;
  135.  
  136.     /*
  137.     ** Get the specified interface from the class factory
  138.     ** (If it's not IClassFactory, it will fail....)
  139.     */
  140.     hresult = pUnknown->lpVtbl->QueryInterface(pUnknown, riid, ppv);
  141.     
  142.     if (FAILED(GetScode(hresult)))
  143.         GlobalFreePtr(pcf);
  144.     return hresult;
  145. }
  146.  
  147. /*    -    -    -    -    -    -    -    -    */
  148.  
  149. //
  150. // Retrieve the class object from the DLL... Create an instance.
  151. //
  152. STDAPI DllGetClassObject(
  153.     REFCLSID    rclsid,
  154.     REFIID        riid,
  155.     void FAR* FAR*    ppv)
  156. {
  157.     HRESULT    hresult;
  158.  
  159.     /*
  160.     ** Create a class factory object...
  161.     */
  162.     hresult = WaveFactoryCreate(rclsid, riid, ppv);
  163.     return hresult;
  164. }
  165.  
  166. /*    -    -    -    -    -    -    -    -    */
  167.  
  168.  
  169. //
  170. // Query Interface.. We support Unknown and our own interface
  171. //
  172. STDMETHODIMP WaveFactoryQueryInterface(
  173.     LPCLASSFACTORY pcf,
  174.     REFIID        iid,
  175.     void FAR* FAR*    ppv)
  176. {
  177.     if (IsEqualIID(iid, &IID_IUnknown))
  178.         *ppv = pcf;
  179.     else if (IsEqualIID(iid, &IID_IClassFactory))
  180.         *ppv = pcf;
  181.     else
  182.         return ResultFromScode(E_NOINTERFACE);
  183.     // remember to increase our reference count
  184.     WaveFactoryAddRef(pcf);
  185.     return NOERROR;
  186. }
  187.  
  188. /*    -    -    -    -    -    -    -    -    */
  189.  
  190. //
  191. // Increase our reference count
  192. //
  193. STDMETHODIMP_(ULONG) WaveFactoryAddRef(
  194.     LPCLASSFACTORY pcf)
  195. {
  196.     LPWAVEFACTORY pwf = (LPWAVEFACTORY) pcf;
  197.     
  198.     return ++pwf->ulRef;
  199. }
  200.  
  201. /*    -    -    -    -    -    -    -    -    */
  202.  
  203. //
  204. // Decrease our reference count -- free the memory for the structure if we're
  205. // down to zero.
  206. //
  207. STDMETHODIMP_(ULONG) WaveFactoryRelease(
  208.     LPCLASSFACTORY pcf)
  209. {
  210.     LPWAVEFACTORY pwf = (LPWAVEFACTORY) pcf;
  211.     
  212.     if (!--pwf->ulRef) {
  213.         GlobalFreePtr(pwf);
  214.         return 0;
  215.     }
  216.     return pwf->ulRef;
  217. }
  218.  
  219. /*    -    -    -    -    -    -    -    -    */
  220.  
  221. //
  222. // Create an object of our class
  223. //
  224. STDMETHODIMP WaveFactoryCreateInstance(
  225.     LPCLASSFACTORY    pcf,
  226.     IUnknown FAR*    pUnknownOuter,
  227.     REFIID        riid,
  228.     void FAR* FAR*    ppv)
  229. {
  230.     // Actually create a real object using the CAVIFile class....
  231.     return WaveFileCreate(pUnknownOuter, riid, ppv);
  232. }
  233.  
  234. /*    -    -    -    -    -    -    -    -    */
  235.  
  236. //
  237. // The standard LockServer function.
  238. //
  239. STDMETHODIMP WaveFactoryLockServer(
  240.     LPCLASSFACTORY    pcf,
  241.     BOOL        fLock)
  242. {
  243.     if (fLock)
  244.         uLockCount++;
  245.     else
  246.         uLockCount--;
  247.     return NOERROR;
  248. }
  249.  
  250. /*    -    -    -    -    -    -    -    -    */
  251.