inner.cpp

《DCOM入门》随书源码 Chapter 1 (Distributed Computing) N/A Chapter 2 (DCOM Overview) N/A Chapter 3 (Objec

   // since we're only dealing in process.
   // wchar_t c[MAX_PATH];
   // wsprintf(c, TEXT("%u"), GetCurrentThreadId());
   // ::MessageBox(NULL, c, c, MB_OK);

   *ppv = NULL;

   // if aggregating, must initially request for IID_IUnknown
   if (pOuterUnk != NULL && riid != IID_IUnknown)
      return CLASS_E_NOAGGREGATION;

   // create the new object with a possibly valid outer unknown
   CoOcrEngine * pEngine = new CoOcrEngine(pOuterUnk);
   if (pEngine == NULL) { return E_OUTOFMEMORY; }

   //-----------------------------------------------
   // Modification to support aggregation
   //-----------------------------------------------
   // The first query must be to the implicit 
   // IUnknown (the inner IUnknown)
   HRESULT hr = pEngine->InternalQueryInterface(riid, ppv);

   if (FAILED(hr)) {  delete pEngine;  }

   return hr;
}

//-------------------------------------------------------------------
// CoOcrEngine::InternalQueryInterface - supporting aggregation
//-------------------------------------------------------------------
HRESULT
CoOcrEngine::InternalQueryInterface(REFIID riid, void** ppv)
{
   if (ppv==NULL) { return E_INVALIDARG; }

   if (riid==IID_IUnknown) {
      //----------------------------------------
      // Always return the implicit unknown
      //----------------------------------------
      *ppv= static_cast<IUnknown *>(&m_InnerUnk);
   } else if (riid==IID_IOcr) {
      *ppv= static_cast<IOcr *>(this);
   } else if (riid==IID_ISpell) {
      *ppv= static_cast<ISpell *>(this);
   } else {
      *ppv=NULL; return E_NOINTERFACE ;
   }

   reinterpret_cast<IUnknown *>(*ppv)->AddRef();

   return S_OK;
}

//-------------------------------------------------------------------
// CoOcrEngine::OcrImage
//-------------------------------------------------------------------
STDMETHODIMP 
CoOcrEngine::OcrImage(long lImageSize, 
                     byte *pbImage,                      
                     wchar_t **pwszOcrText)
{    
   // DisplayStatus(TEXT("CoOcrEngine::OcrImage"), S_OK);

   wchar_t wszPath[MAX_PATH];
   GetTempPath(MAX_PATH, wszPath);
   wchar_t wszFileName[MAX_PATH];
   GetTempFileName(wszPath, TEXT("TIF"), 0, wszFileName);
   DisplayStatus(wszFileName, S_OK);

   // write the received image to a file
   HANDLE hFile = CreateFile(wszFileName, 
       GENERIC_WRITE,
       FILE_SHARE_READ, 
       NULL, 
       CREATE_ALWAYS, 
       FILE_ATTRIBUTE_NORMAL, NULL);

   if (hFile==INVALID_HANDLE_VALUE) {
       Beep(1000,1000);
       wprintf(TEXT("hFile invalid\n"));
   } else {
       DWORD dwWritten = 0 ;
       WriteFile(hFile, 
           static_cast<LPCVOID>(pbImage), 
           lImageSize,
           &dwWritten, NULL);
       CloseHandle(hFile);
   }
   
   // allocate memory and return fake ocr data
   wchar_t wszOcrText[MAX_PATH];
   wcscpy(wszOcrText, TEXT("This is fake OCR text"));

   // remember that we have to take the len of string including null
   // multiply by the sizeof wchar_t
   long lAllocSize = (wcslen(wszOcrText)+1) * sizeof(wchar_t);
   wprintf(TEXT("lAllocSize = %u\n"), lAllocSize);

   *pwszOcrText = static_cast<wchar_t *>(CoTaskMemAlloc(lAllocSize));
   if (*pwszOcrText==NULL) { return E_OUTOFMEMORY; }

   wcscpy(*pwszOcrText, wszOcrText);

   wprintf(TEXT("Returning = %s\n"), *pwszOcrText);

   return S_OK ;
}

//-------------------------------------------------------------------
// CoOcrEngine::OcrZone
//-------------------------------------------------------------------
STDMETHODIMP 
CoOcrEngine::OcrZone(long lImageSize, byte *pbImage, 
                    Zone zone, wchar_t **pwszOcrText)
{
   return E_NOTIMPL ;
}

//-------------------------------------------------------------------
// CoOcrEngine::Check
//-------------------------------------------------------------------
STDMETHODIMP
CoOcrEngine::Check(wchar_t *pszWord, PossibleWords *pWords)
{
   wcscpy(reinterpret_cast<wchar_t *>(pWords->wszOne), TEXT("ChoiceOne"));
   wcscpy(reinterpret_cast<wchar_t *>(pWords->wszTwo), TEXT("ChoiceTwo"));
   return S_OK ;
}

//*******************************************************************
//*******************************************************************
//***  Class Factory: manufacturing CoOcrEngine objects
//***  No changes to factory to support Aggregation, since the static
//***  CreateObject function hides the changes
//*******************************************************************
//*******************************************************************
class CoOcrEngineFactory : public IClassFactory 
{
public:
   // IUnknown Methods
   STDMETHODIMP QueryInterface (REFIID riid, void** ppv);
   STDMETHODIMP_(ULONG) AddRef(void)
   { return 1; }
   STDMETHODIMP_(ULONG) Release(void) 
   { return 1; }

   // IClassFactory Methods
   STDMETHODIMP CreateInstance(LPUNKNOWN pUnkOuter, 
                               REFIID riid, 
                               void **ppv)
  {
     // call CoOcrEngine's static function to create
     // a CoOcrEngine component object
     return CoOcrEngine::CreateObject(pUnkOuter, riid, ppv);
  }

   STDMETHODIMP LockServer(BOOL fLock)
   {
      if (fLock) {
          ComponentAddRef();
      } else {
          ComponentRelease();
      }
      return S_OK;        
   }   
};

//-------------------------------------------------------------------
//  Singleton factory instance that manufacture CoCorEngine
//  component objects
//-------------------------------------------------------------------
CoOcrEngineFactory g_OcrEngineClassFactory;

//-------------------------------------------------------------------
//  CoOcrEngineFactory::QueryInterface
//-------------------------------------------------------------------
STDMETHODIMP 
CoOcrEngineFactory::QueryInterface(REFIID riid, void** ppv)
{
   if (ppv==NULL) { return E_INVALIDARG; }

   if (riid==IID_IUnknown) {
      *ppv= static_cast<IClassFactory *>(this);
   } else if (riid==IID_IClassFactory) {
      *ppv= static_cast<IClassFactory *>(this);
   } else {
      *ppv=NULL; return E_NOINTERFACE ;
   }

   reinterpret_cast<IUnknown *>(*ppv)->AddRef();

   return S_OK;
}

//*******************************************************************
//*******************************************************************
//***  DLL Exports
//*******************************************************************
//*******************************************************************
extern "C" BOOL WINAPI DllMain(HINSTANCE hInstance, 
                               DWORD dwReason, 
                               LPVOID /*lpReserved*/)
{
   if (dwReason == DLL_PROCESS_ATTACH) {
      // This message here to remind us that we are using
      // the aggregatable implementation of the CLSID_OCREngine
      // Either use this or the non-aggregatable version
      Beep(100,100);
      ::MessageBox(NULL, 
          TEXT("This is the Aggregatable Version of CLSID_OCREngine\n")
          TEXT("The Non-Aggregatable Version of CLSID_OCREngine\n")
          TEXT("lives in [basics\\inproc]\n"),
          TEXT("Aggregatable Version"), MB_OK);
      GetModuleFileName(hInstance, g_wszModuleName, MAX_PATH);
   } else if (dwReason == DLL_PROCESS_DETACH) {}

   return TRUE;    // ok
}

//*******************************************************************
//*******************************************************************
//** Used to determine whether the DLL can be unloaded by DCOM
//*******************************************************************
//*******************************************************************
STDAPI DllCanUnloadNow(void)
{ 
   if (g_lComponentRefCounts ==0) {
      return S_OK;
   } else {
      return S_FALSE;
   }
}

//*******************************************************************
//*******************************************************************
//** Returns a class factory to create an object of the requested type
//*******************************************************************
//*******************************************************************
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
   *ppv = NULL;

   // Does our component support this particular class ID?
   if (CLSID_OcrEngine!=rclsid) { return E_FAIL; }

   CoOcrEngineFactory * pCF = new CoOcrEngineFactory();
   if (pCF==NULL) { return E_OUTOFMEMORY; }

   HRESULT hr = pCF->QueryInterface(riid, ppv);
   if (FAILED(hr)) {
      delete pCF;
   } else {
      *ppv=pCF;
   }

   return hr;
}

//*******************************************************************
//*******************************************************************
//**  DllRegisterServer - Adds entries to the system registry
//*******************************************************************
//*******************************************************************
STDAPI DllRegisterServer(void)
{
   RegisterServerToSystem();
   return S_OK;
}

//*******************************************************************
//*******************************************************************
//** DllUnregisterServer - Removes entries from the system registry
//*******************************************************************
//*******************************************************************
STDAPI DllUnregisterServer(void)
{
   UnregisterServerFromSystem();
   return S_OK;
}