Out of Process, MFC

1. AppWizard로 SDI 프로젝트를 생성한다. 이 때 스텝3에서 [Automation]을 체크한다.

2. ClassView에서 인터페이스를 선택해서 팝업메뉴에서 [Add Method]/[Add Property]를 사용해서 메소드와 프라퍼티를 추가한다.
/*
or

ClassWizard's Automation page

Add Method button
Add Property button

*/

modifications to the project's source code files:

The method and its dispatch ID are added to the project's ODL file.
The function that implements the method is declared in the class's header file.
An empty function implementation is added to the class's CPP file.
A DISP_FUNCTION statement is added to the class's dispatch map.

two types of Automation properties

Member variable properties

DISP_PROPERTY()
DISP_PROPERTY_NOTIFY()

Get/set properties

DISP_PROPERTY_EX()

DISP_PROPERTY_PARAM()

indexed properties

// MiniGraph.odl : type library source for MiniGraph.exe

// This file will be processed by the MIDL compiler to produce the
// type library (MiniGraph.tlb).

[ uuid(CBAFEDDB-727E-4B90-921A-AF8ABEF11758), version(1.0) ]
library MiniGraph
{
    importlib("stdole32.tlb");
    importlib("stdole2.tlb");


    //  Primary dispatch interface for CMiniGraphDoc
   
    [ uuid(773FFCD7-01D5-4EA5-BC0B-0EF01724819F) ]
    dispinterface IMiniGraph
    {
        properties:
            // NOTE - ClassWizard will maintain property information here.
            //    Use extreme caution when editing this section.
            //{{AFX_ODL_PROP(CMiniGraphDoc)
            [id(1)] BSTR AutoText;
            [id(2)] long X;
            [id(3)] long Y;
            //}}AFX_ODL_PROP
           
        methods:
            // NOTE - ClassWizard will maintain method information here.
            //    Use extreme caution when editing this section.
            //{{AFX_ODL_METHOD(CMiniGraphDoc)
            [id(4)] void ShowApplication();
            //}}AFX_ODL_METHOD

    };

    //  Class information for CMiniGraphDoc
   
    [ uuid(E93CCCBD-11AB-4DAE-8501-AA67AD416A8D) ]
    coclass Document
    {
        [default] dispinterface IMiniGraph;
    };

    //{{AFX_APPEND_ODL}}
    //}}AFX_APPEND_ODL}}
};


// StdAfx.h
#include <afxdisp.h>        // MFC Automation classes


class CTextServerApp : public CWinApp
{
...
// Implementation
    COleTemplateServer m_server;
        // Server object for document creation
    //{{AFX_MSG(CTextServerApp)
    afx_msg void OnAppAbout();
        // NOTE - the ClassWizard will add and remove member functions here.
        //    DO NOT EDIT what you see in these blocks of generated code !
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
};


/////////////////////////////////////////////////////////////////////////////
// The one and only CMiniGraphApp object

CMiniGraphApp theApp;
// {

// This identifier was generated to be statistically unique for your app.
// You may change it if you prefer to choose a specific identifier.

// {E93CCCBD-11AB-4DAE-8501-AA67AD416A8D}
static const CLSID clsid =
{ 0xe93cccbd, 0x11ab, 0x4dae, { 0x85, 0x1, 0xaa, 0x67, 0xad, 0x41, 0x6a, 0x8d } };

// }
/////////////////////////////////////////////////////////////////////////////
// CMiniGraphApp initialization

BOOL CMiniGraphApp::InitInstance()
{
    // Initialize OLE libraries
    if (!AfxOleInit())
    {
        AfxMessageBox(IDP_OLE_INIT_FAILED);
        return FALSE;
    }

    AfxEnableControlContainer();
...
    // Register the application's document templates.  Document templates
    //  serve as the connection between documents, frame windows and views.

    CSingleDocTemplate* pDocTemplate;
    pDocTemplate = new CSingleDocTemplate(
        IDR_MAINFRAME,
        RUNTIME_CLASS(CTextServerDoc),
        RUNTIME_CLASS(CMainFrame),       // main SDI frame window
        RUNTIME_CLASS(CTextServerView));
    AddDocTemplate(pDocTemplate);

    // Connect the COleTemplateServer to the document template.
    //  The COleTemplateServer creates new documents on behalf
    //  of requesting OLE containers by using information
    //  specified in the document template.
    m_server.ConnectTemplate(clsid, pDocTemplate, TRUE);
        // Note: SDI applications register server objects only if /Embedding
        //   or /Automation is present on the command line.

    // Parse command line for standard shell commands, DDE, file open
    CCommandLineInfo cmdInfo;
    ParseCommandLine(cmdInfo);
// {
    // Check to see if launched as OLE server
    if (cmdInfo.m_bRunEmbedded || cmdInfo.m_bRunAutomated)
    {
        // Register all OLE server (factories) as running.  This enables the
        //  OLE libraries to create objects from other applications.
        COleTemplateServer::RegisterAll();

        // Application was run with /Embedding or /Automation.  Don't show the
        //  main window in this case.
        return TRUE;
    }

    // When a server application is launched stand-alone, it is a good idea
    //  to update the system registry in case it has been damaged.
    m_server.UpdateRegistry(OAT_DISPATCH_OBJECT);
    COleObjectFactory::UpdateRegistryAll();
// }
    // Dispatch commands specified on the command line
    if (!ProcessShellCommand(cmdInfo))
        return FALSE;
...
}


class CMiniGraphDoc : public CDocument
{
...
// Implementation
public:
    int m_nX;
    int m_nY;
    CString m_strText;
    virtual ~CTextServerDoc();
...
protected:

// Generated message map functions
protected:
    //{{AFX_MSG(CMiniGraphDoc)
        // NOTE - the ClassWizard will add and remove member functions here.
        //    DO NOT EDIT what you see in these blocks of generated code !
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
// {
    // Generated OLE dispatch map functions
    //{{AFX_DISPATCH(CMiniGraphDoc)
    CString m_autoText;
    afx_msg void OnAutoTextChanged();
    afx_msg long GetX();
    afx_msg void SetX(long nNewValue);
    afx_msg long GetY();
    afx_msg void SetY(long nNewValue);
    afx_msg void ShowApplication();
    //}}AFX_DISPATCH
    DECLARE_DISPATCH_MAP()
    DECLARE_INTERFACE_MAP()
// }
};

#include "MiniGraphDoc.h"
// {
#include "Graph.h"
#include "MainFrm.h"
// }
...
BEGIN_MESSAGE_MAP(CMiniGraphDoc, CDocument)
...
END_MESSAGE_MAP()

BEGIN_DISPATCH_MAP(CMiniGraphDoc, CDocument)
    //{{AFX_DISPATCH_MAP(CMiniGraphDoc)
    DISP_PROPERTY_NOTIFY(CMiniGraphDoc, "AutoText", m_autoText, OnAutoTextChanged, VT_BSTR)
    DISP_PROPERTY_EX(CMiniGraphDoc, "X", GetX, SetX, VT_I4)
    DISP_PROPERTY_EX(CMiniGraphDoc, "Y", GetY, SetY, VT_I4)
    DISP_FUNCTION(CMiniGraphDoc, "ShowApplication", ShowApplication, VT_EMPTY, VTS_NONE)
    //}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()

// Note: we add support for IID_IMiniGraph to support typesafe binding
//  from VBA.  This IID must match the GUID that is attached to the
//  dispinterface in the .ODL file.

// {773FFCD7-01D5-4EA5-BC0B-0EF01724819F}
static const IID IID_IMiniGraph =
{ 0x773ffcd7, 0x1d5, 0x4ea5, { 0xbc, 0xb, 0xe, 0xf0, 0x17, 0x24, 0x81, 0x9f } };

BEGIN_INTERFACE_MAP(CMiniGraphDoc, CDocument)
    INTERFACE_PART(CMiniGraphDoc, IID_IMiniGraph, Dispatch)
END_INTERFACE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMiniGraphDoc construction/destruction

CMiniGraphDoc::CMiniGraphDoc()
{
    // TODO: add one-time construction code here
// {
    m_pGraph = new CGraph();
    ASSERT(m_pGraph);

    // Test only - give it some data to use, while we're developing
    m_pGraph->SetTitle("First Graph");
    m_pGraph->AddData("A", 20);
// }
    EnableAutomation();
    AfxOleLockApp();
}

CMiniGraphDoc::~CMiniGraphDoc()
{
    AfxOleUnlockApp();
}
...
void CMiniGraphDoc::ShowApplication()
{
    // TODO: Add your dispatch handler code here
    CMiniGraphApp* pApp = (CMiniGraphApp*) AfxGetApp();
    CMainFrame* pFrame  = (CMainFrame*) pApp->m_pMainWnd;

    pFrame->ShowWindow(SW_SHOW);
}

void CMiniGraphDoc::OnAutoTextChanged()
{
    m_strText = m_autoText;
    UpdateAllViews(NULL);

    SetModifiedFlag();
}

long CMiniGraphDoc::GetX()
{
    return m_nX;
}

void CMiniGraphDoc::SetX(long nNewValue)
{
    if (nNewValue >= 0)
    {
        m_nX = nNewValue;
        UpdateAllViews(NULL);
       
        SetModifiedFlag();
    }
    else
        AfxMessageBox(_T("0보다 크거나 같은 값을 입력하세요"));
}
...


#include "MiniGraphView.h"
// {
#include "Graph.h"
// }
...
void CMiniGraphView::OnDraw(CDC* pDC)
{
    CMiniGraphDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    // TODO: add draw code for native data here
    CRect client;
    GetClientRect(&client);
    pDoc->GetGraph()->Display(client, pDC);
}

to fire events

An event is a notification sent from a control to its container.

Windows controls send notifications to their owners by sending messages
ActiveX controls send notifications to their containers by firing events.

An MFC Automation server registers itself each time it's run.

새로운 자동화 개체 추가

[Insert | New Class]를 선택해서 [Base Class]는 CCmdTarget, [Automation] 항목을 체크해서 MFC 클래스 추가 - 생성자와 소멸자를 public으로 수정

생성된 클래스의 멤버를 추가하고 인터페이스를 연결한다.

원래 인터페이스에 LPDISPATCH 타입과 Get/Set mothod로 프로퍼티 추가

...
#include "Appearance.h"
...
class CClockServerDoc : public CDocument
{
...
    DECLARE_DYNCREATE(CClockServerDoc)
// Attributes
public:
    CAppearance m_Appearance;
...
    // Generated OLE dispatch map functions
    //{{AFX_DISPATCH(CClockServerDoc)
    afx_msg LPDISPATCH GetAppearance();
...
    //}}AFX_DISPATCH
    DECLARE_DISPATCH_MAP()
...
};

BEGIN_DISPATCH_MAP(CClockServerDoc, CDocument)
    //{{AFX_DISPATCH_MAP(CClockServerDoc)
    DISP_PROPERTY_EX(CClockServerDoc, "Appearance", GetAppearance, SetAppearance, VT_DISPATCH)
...
    //}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()
...
LPDISPATCH CClockServerDoc::GetAppearance()
{
    // TODO: Add your property handler here
    return m_Appearance.GetIDispatch(TRUE);
//    return NULL;
}

void CClockServerDoc::SetAppearance(LPDISPATCH newValue)
{
    // TODO: Add your property handler here
    SetNotSupported();
}

class CAppearance : public CCmdTarget
{
    DECLARE_DYNCREATE(CAppearance)

public:
    CAppearance();           // protected constructor used by dynamic creation
    virtual ~CAppearance();
...
};

하나의 서버 운용

CClockServerApp theApp;
...
// {7843DB4D-E4DC-4636-9046-B68BFC0FDA83}
CLSID clsid =
{ 0x7843db4d, 0xe4dc, 0x4636, { 0x90, 0x46, 0xb6, 0x8b, 0xfc, 0xf, 0xda, 0x83 } };


class CClockServerDoc : public CDocument
{
...
// Overrides
    // ClassWizard generated virtual function overrides
    //{{AFX_VIRTUAL(CClockServerDoc)
    public:
    ...
    virtual void OnFinalRelease();
    //}}AFX_VIRTUAL
...
    DECLARE_INTERFACE_MAP()
private:
    DWORD    m_dwID;
};

extern CLSID clsid;

CClockServerDoc::CClockServerDoc()
{
    // TODO: add one-time construction code here
    EnableAutomation();
    AfxOleLockApp();

    IUnknown *pUnknown;
    GetIDispatch(FALSE)->QueryInterface(IID_IUnknown, (void **)&pUnknown);
    GetIDispatch(FALSE)->Release();

    ::RegisterActiveObject(pUnknown, clsid, ACTIVEOBJECT_WEAK, &m_dwID);
}

void CClockServerDoc::OnFinalRelease()
{
    // TODO: Add your specialized code here and/or call the base class
// {
    ::RevokeActiveObject(m_dwID, NULL);  
// }  
    CDocument::OnFinalRelease();
}