SAMPLE: MFCDISP: Replacing MFC IDispatch Implementation

Space must be allocated for the GUIDs that are defined in Itest.h. This is done by creating a separate source file (Guids.cpp) that includes Ole2.h, Initguid.h, and Itest.h. The OLE header file Initguid.h will cause space to be allocated for the GUIDs defined in Itest.h. Make sure that Guids.cpp is not built with a pre-compiled header. To do this, add Guids.cpp to the project. Then change the project settings for the Guids.cpp file. First open the appropriate platform folder in the left pane of the Project Settings dialog box. Select Guids.cpp in the build folder in the left pane of the Project Settings dialog box, click the C/C++ tab, click the Precompiled headers category, and select Not using precompiled headers.

Include Itest.h in each source file that uses the GUIDs or interfaces that it defines. The sample includes Itest.h in Test.cpp, Testdoc.h, and Testdoc.cpp.

      DECLARE_INTERFACE_MAP()

      BEGIN_INTERFACE_PART(MyDispatch, ITest)
        STDMETHOD(GetTypeInfoCount)(UINT FAR* pctinfo);
        STDMETHOD(GetTypeInfo)(
          UINT itinfo,
          LCID lcid,
          ITypeInfo FAR* FAR* pptinfo);
        STDMETHOD(GetIDsOfNames)(
          REFIID riid,
          OLECHAR FAR* FAR* rgszNames,
          UINT cNames,
          LCID lcid,
          DISPID FAR* rgdispid);
        STDMETHOD(Invoke)(
          DISPID dispidMember,
          REFIID riid,
          LCID lcid,
          WORD wFlags,
          DISPPARAMS FAR* pdispparams,
          VARIANT FAR* pvarResult,
          EXCEPINFO FAR* pexcepinfo,
         UINT FAR* puArgErr);

        /* ITest methods */
        STDMETHOD(put_TestProperty)(short nNewValue);
        STDMETHOD(get_TestProperty)(short FAR* retval);
        STDMETHOD(TestMethod)(short n, short FAR* retval);
      END_INTERFACE_PART(MyDispatch)

   Add a private class member to the object's class to hold the typeinfo
   of the interface:

   private:
       LPTYPEINFO       m_ptinfo;           // ITest type information

a. An interface map is declared as follows to hook into the object's

      IUnknown::QueryInterface implementation. When a client asks for
      IDispatch (late binding/id-binding) or ITest (vtbl-binding) using
      IUnknown::QueryInterface, the vtbl for the XMyDispatch nested class
      will be returned.

         BEGIN_INTERFACE_MAP(CTestDoc, CDocument)
            INTERFACE_PART(CTestDoc, IID_IDispatch, MyDispatch)
            INTERFACE_PART(CTestDoc, IID_ITest, MyDispatch)
         END_INTERFACE_MAP()

      Remove the interface map inserted by AppWizard. For example, the
      sample removes the following interface map from Testdoc.cpp:

         BEGIN_INTERFACE_MAP(CTestDoc, CDocument)
            INTERFACE_PART(CTestDoc, IID_ITest, Dispatch)
         END_INTERFACE_MAP()

   b. Remove the declaration of the interface IID because Guids.cpp will
      allocate space for it. For example, the sample removes the following
      from Testdoc.cpp:

         static const IID IID_ITest =
         {0xc04aadf1, 0x2a82, 0x11cf, { 0x84, 0xf5, 0x0, 0xaa, 0x0, 0xc0,
         0x6, 0xcf } };

   c. Load the typeinfo of the interface from the type library when the
      object is created.

         BOOL CTestDoc::OnNewDocument()
         {
           HRESULT hr;
           LPTYPELIB ptlib;

           if (!CDocument::OnNewDocument())
               return FALSE;

           hr = LoadRegTypeLib(LIBID_Test, 1, 0, 0x09, &ptlib);
           if (FAILED(hr))
           {
            AfxMessageBox("Can't find type library test.tlb. Re-register \
                               by running test.exe");
                return FALSE;
           }
           hr = ptlib->GetTypeInfoOfGuid(IID_ITest, &m_ptinfo);
           if (FAILED(hr))
           {
               ptlib->Release();
               return FALSE;
           }
           ptlib->Release();
           return TRUE;
         }

   d. Release the typeinfo of the interface in the destructor of the
      object.

         CTestDoc::~CTestDoc()
         {
            m_ptinfo->Release();
            AfxOleUnlockApp();
         }

   e. The ITest interface is implemented as follows. Note the use of the
      METHOD_PROLOGUE macro to gain access to the member functions of the
      object by using the pThis variable. QueryInterface, AddRef, and
      Release are delegated to MFC's implementation. IDispatch is
      implemented using DispGetIDsOfNames and DispInvoke. DispInvoke will
      call the appropriate automation method or property function.

         ULONG FAR EXPORT CTestDoc::XMyDispatch::AddRef()
         {
         METHOD_PROLOGUE(CTestDoc, MyDispatch)
            return pThis->ExternalAddRef();
         }
         ULONG FAR EXPORT CTestDoc::XMyDispatch::Release()
         {
             METHOD_PROLOGUE(CTestDoc, MyDispatch)
             return pThis->ExternalRelease();
         }
         STDMETHODIMP CTestDoc::XMyDispatch::QueryInterface(REFIID riid,
         LPVOID FAR* ppvObj)
         {
             METHOD_PROLOGUE(CTestDoc, MyDispatch)
             return (HRESULT)pThis->ExternalQueryInterface(&riid, ppvObj);
         }
         STDMETHODIMP
            CTestDoc::XMyDispatch::GetTypeInfoCount(UINT FAR* pctinfo)
         {
             METHOD_PROLOGUE(CTestDoc, MyDispatch)
             *pctinfo = 1;
             return NOERROR;
         }
         STDMETHODIMP CTestDoc::XMyDispatch::GetTypeInfo(
               UINT itinfo,
                LCID lcid,
                ITypeInfo FAR* FAR* pptinfo)
         {
         METHOD_PROLOGUE(CTestDoc, MyDispatch)
           *pptinfo = NULL;

           if(itinfo != 0)
               return ResultFromScode(DISP_E_BADINDEX);
           pThis->m_ptinfo->AddRef();
           *pptinfo = pThis->m_ptinfo;
           return NOERROR;
         }
         STDMETHODIMP CTestDoc::XMyDispatch::GetIDsOfNames(
            REFIID riid,
                 OLECHAR FAR* FAR* rgszNames,
                 UINT cNames,
                 LCID lcid,
                 DISPID FAR* rgdispid)
         {
         METHOD_PROLOGUE(CTestDoc, MyDispatch)
         return DispGetIDsOfNames(pThis->m_ptinfo, rgszNames, cNames,
                               rgdispid);
         }
         STDMETHODIMP CTestDoc::XMyDispatch::Invoke(
              DISPID dispidMember,
               REFIID riid,
               LCID lcid,
               WORD wFlags,
               DISPPARAMS FAR* pdispparams,
               VARIANT FAR* pvarResult,
               EXCEPINFO FAR* pexcepinfo,
               UINT FAR* puArgErr)
         {
         METHOD_PROLOGUE(CTestDoc, MyDispatch)

         return DispInvoke(
           &pThis->m_xMyDispatch, pThis->m_ptinfo,
           dispidMember, wFlags, pdispparams,
         pvarResult, pexcepinfo, puArgErr);
         }
         STDMETHODIMP CTestDoc::XMyDispatch::get_TestProperty(short
   *pnRetVal)
         {
         METHOD_PROLOGUE(CTestDoc, MyDispatch)

         *pnRetVal = pThis->m_nTestProperty;
         return NOERROR;
         }
         STDMETHODIMP CTestDoc::XMyDispatch::put_TestProperty(short
   nNewValue)
         {
         METHOD_PROLOGUE(CTestDoc, MyDispatch)

         pThis->m_nTestProperty = nNewValue;
            return NOERROR;
         }
         STDMETHODIMP CTestDoc::XMyDispatch::TestMethod(short n, short
           *pnRetVal)
         {
            *pnRetVal = n;
            return NOERROR;
         }