ATL 컨트롤 포함 FAQ

ATL의 제어 호스팅 코드는 ATL 클래스를 사용할 필요가 없습니다. 필요한 경우 "AtlAxWin80" 창을 만들고 컨트롤 호스팅 API를 사용할 수 있습니다(자세한 내용은 ATL 컨트롤 호스팅 API란?을 참조하세요.) 그러나 다음 클래스를 사용하면 포함 기능을 더 쉽게 사용할 수 있습니다.

ATL의 제어 호스팅 API는 모든 창이 ActiveX 컨트롤 컨테이너 역할을 할 수 있도록 하는 함수 집합입니다. 이러한 함수는 소스 코드로 사용할 수 있고 ATL90.dll에서 노출되므로 정적으로 또는 동적으로 프로젝트에 연결할 수 있습니다. 컨트롤 호스팅 함수는 아래 표에 나와 있습니다.

처음 세 함수의 매개 변수는 HWND 거의 모든 형식의 기존 창이어야 합니다. 이러한 세 함수를 명시적으로 호출하는 경우(일반적으로 필요하지 않음) 이미 호스트 역할을 하는 창에 핸들을 전달하지 마세요(이렇게 하면 기존 호스트 개체가 해제되지 않음).

처음 7개 함수는 암시적으로 AtlAxWinInit을 호출합니다.

AtlAxWin100 는 ATL의 제어 호스팅 기능을 제공하는 데 도움이 되는 창 클래스의 이름입니다. 이 클래스의 인스턴스를 만들 때 창 프로시저는 자동으로 컨트롤 호스팅 API를 사용하여 창과 연결된 호스트 개체를 만들고 창의 제목으로 지정한 컨트롤로 로드합니다.

AtlAxWinInit는 호스트 창을 만들기 전에 이 함수를 호출해야 하므로 "AtlAxWin80" 창 클래스(사용자 지정 창 메시지 몇 개 포함)를 등록합니다. 그러나 호스팅 API(및 이를 사용하는 클래스)가 이 함수를 자주 호출하기 때문에 항상 이 함수를 명시적으로 호출할 필요는 없습니다. 이 함수를 두 번 이상 호출하는 데는 아무런 해가 없습니다.

호스트 개체는 특정 창에 대해 ATL에서 제공하는 ActiveX 컨트롤 컨테이너를 나타내는 COM 개체입니다. 호스트 개체는 컨트롤에 메시지를 반영할 수 있도록 컨테이너 창을 서브클래싱하고, 컨트롤에서 사용하는 데 필요한 컨테이너 인터페이스를 제공하고, 컨트롤 환경을 구성할 수 있도록 IAxWinHostWindow 및 IAxWinAmbientDispatch 인터페이스를 노출합니다.

호스트 개체를 사용하여 컨테이너의 앰비언트 속성을 설정할 수 있습니다.

단일 ATL 호스트 창에서 둘 이상의 컨트롤을 호스트할 수 없습니다. 각 호스트 창은 한 번에 정확히 하나의 컨트롤을 보유하도록 설계되었습니다(이를 통해 메시지 리플렉션 및 컨트롤별 앰비언트 속성을 처리하는 간단한 메커니즘을 사용할 수 있습니다). 그러나 사용자가 단일 창에서 여러 컨트롤을 표시해야 하는 경우 해당 창의 자식으로 여러 호스트 창을 만드는 것은 간단합니다.

호스트 창을 다시 사용하는 것은 권장되지 않습니다. 코드의 견고성을 보장하려면 호스트 창의 수명을 단일 컨트롤의 수명에 연결해야 합니다.

AtlAxWinTerm은 "AtlAxWin80" 창 클래스의 등록을 취소합니다. 모든 기존 호스트 창이 제거된 후 이 함수를 호출해야 합니다(더 이상 호스트 창을 만들 필요가 없는 경우). 이 함수를 호출하지 않으면 프로세스가 종료될 때 창 클래스가 자동으로 등록 취소됩니다.

이 섹션의 샘플에서는 AXHost를 만드는 방법과 다양한 ATL 함수를 사용하여 ActiveX 컨트롤을 호스트하는 방법을 보여 줍니다. 또한 호스트되는 컨트롤에서 컨트롤 및 싱크 이벤트(IDispEventImpl 사용)에 액세스하는 방법도 보여 줍니다. 샘플에서는 기본 창 또는 자식 창에서 일정 컨트롤을 호스트합니다.

기호의 정의를 확인합니다 USE_METHOD . 이 기호의 값을 1에서 8 사이로 변경할 수 있습니다. 기호 값은 컨트롤을 만드는 방법을 결정합니다.

• 짝수 번호 값의 USE_METHOD경우 호스트를 만들기 위한 호출은 창을 서브클래싱하고 컨트롤 호스트로 변환합니다. 홀수 값의 경우 코드는 호스트 역할을 하는 자식 창을 만듭니다.

• 1에서 4 사이의 값 USE_METHOD 의 경우 호스트를 만드는 호출에서 이벤트의 컨트롤 및 싱크에 대한 액세스가 수행됩니다. 5에서 8 사이의 값은 호스트에서 인터페이스를 쿼리하고 싱크를 후크합니다.

다음은 요약입니다.

// Your project must be apartment threaded or the (AtlAx)CreateControl(Lic)(Ex)
// calls will fail.
#define _ATL_APARTMENT_THREADED
#include <atlbase.h>
#include <atlwin.h>
#include <atlhost.h>

// Value of g_UseMethod determines the function used to create the control.
int g_UseMethod = 0; // 1 to 8 are valid values
bool ValidateUseMethod() { return (1 <= g_UseMethod) && (g_UseMethod <= 8); }

#import "PROGID:MSCAL.Calendar.7" no_namespace, raw_interfaces_only

// Child window class that will be subclassed for hosting Active X control
class CChildWindow : public CWindowImpl<CChildWindow>
{
public:
   BEGIN_MSG_MAP(CChildWindow)
   END_MSG_MAP()
};

class CMainWindow : public CWindowImpl<CMainWindow, CWindow, CFrameWinTraits>,
   public IDispEventImpl<1, CMainWindow, &__uuidof(DCalendarEvents), &__uuidof(__MSACAL), 7, 0>
{
public :

   CChildWindow m_wndChild;
   CAxWindow2 m_axwnd;
   CWindow m_wndEdit;

   static ATL::CWndClassInfo& GetWndClassInfo()
   {
      static ATL::CWndClassInfo wc =
      {
         { 
            sizeof(WNDCLASSEX), 
            CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS, 
            StartWindowProc,
            0, 0, NULL, NULL, NULL, 
            (HBRUSH)(COLOR_WINDOW + 1), 
            0, 
            _T("MainWindow"), 
            NULL 
         },
         NULL, NULL, IDC_ARROW, TRUE, 0, _T("")
      };
      return wc;
   }
   
   BEGIN_MSG_MAP(CMainWindow)
      MESSAGE_HANDLER(WM_CREATE, OnCreate)
      MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
   END_MSG_MAP()

   BEGIN_SINK_MAP(CMainWindow)
      SINK_ENTRY_EX(1, __uuidof(DCalendarEvents), DISPID_CLICK, OnClick)
   END_SINK_MAP()

   // Helper to display events
   void DisplayNotification(TCHAR* pszMessage)
   {
      CWindow wnd;
      wnd.Attach(GetDlgItem(2));
      
      wnd.SendMessage(EM_SETSEL, (WPARAM)-1, -1);
      wnd.SendMessage(EM_REPLACESEL, 0, (LPARAM)pszMessage);
   }
   
   // Event Handler for Click
   STDMETHOD(OnClick)()
   {
      DisplayNotification(_T("OnClick\r\n"));
      return S_OK;
   }

   LRESULT OnCreate(UINT, WPARAM, LPARAM, BOOL&)
   {
      HRESULT hr = E_INVALIDARG;

      _pAtlModule->Lock();

      RECT rect;
      GetClientRect(&rect);
      
      RECT rect2;
      rect2 = rect;
      
      rect2.bottom -=200;
      
      // if g_UseMethod is odd then create AxHost directly as the child of the main window
      if (g_UseMethod & 0x1) 
      {
         m_axwnd.Create(m_hWnd, rect2, NULL, WS_CHILD | WS_VISIBLE | WS_BORDER, 0, 1);
      }
      // if g_UseMethod is even then the AtlAx version is invoked.
      else
      {
         // Create a child window.
         // AtlAx functions will subclass this window.
         m_wndChild.Create(m_hWnd, rect2, NULL, WS_CHILD | WS_VISIBLE | WS_BORDER, 0, 1);
         // Attach the child window to the CAxWindow so we can access the 
         // host that subclasses the child window.
         m_axwnd.Attach(m_wndChild);
      }

      if (m_axwnd.m_hWnd != NULL)
      {
         CComPtr<IUnknown> spControl;

         // The calls to (AtlAx)CreateControl(Lic)(Ex) do the following:
         // Create Calendar control. (Passing in NULL for license key. 
         //   Pass in valid license key to the Lic functions if the 
         //   control requires one.)
         // Get the IUnknown pointer for the control.
         // Sink events from the control.
         
         // The AtlAx versions subclass the hWnd that is passed in to them 
         //   to implement the host functionality.

         // The first 4 calls accomplish it in one call.
         // The last 4 calls accomplish it using multiple steps.

         switch (g_UseMethod)
         {
            case 1:
            {
               hr = m_axwnd.CreateControlLicEx(
                  OLESTR("MSCAL.Calendar.7"), 
                  NULL, 
                  NULL, 
                  &spControl, 
                  __uuidof(DCalendarEvents), 
                  (IUnknown*)(IDispEventImpl<1, CMainWindow, 
                     &__uuidof(DCalendarEvents), &__uuidof(__MSACAL), 7, 0>*)this
               );
               break;
            }
            case 2:
            {
               hr = AtlAxCreateControlLicEx(
                  OLESTR("MSCAL.Calendar.7"), 
                  m_wndChild.m_hWnd, 
                  NULL, 
                  NULL, 
                  &spControl, 
                  __uuidof(DCalendarEvents), 
                  (IUnknown*)(IDispEventImpl<1, CMainWindow, 
                     &__uuidof(DCalendarEvents), &__uuidof(__MSACAL), 7, 0>*)this, 
                  NULL
               );
               break;
            }
            case 3:
            {
               hr = m_axwnd.CreateControlEx(
                  OLESTR("MSCAL.Calendar.7"), 
                  NULL, 
                  NULL, 
                  &spControl, 
                  __uuidof(DCalendarEvents), 
                  (IUnknown*)(IDispEventImpl<1, CMainWindow, 
                     &__uuidof(DCalendarEvents), &__uuidof(__MSACAL), 7, 0>*)this
               );
               break;
            }
            case 4:
            {
               hr = AtlAxCreateControlEx(
                  OLESTR("MSCAL.Calendar.7"), 
                  m_wndChild.m_hWnd, 
                  NULL, 
                  NULL, 
                  &spControl, 
                  __uuidof(DCalendarEvents), 
                  (IUnknown*)(IDispEventImpl<1, CMainWindow, 
                     &__uuidof(DCalendarEvents), &__uuidof(__MSACAL), 7, 0>*)this
               );
               break;
            }
            // The following calls create the control, obtain an interface to 
            // the control, and set up the sink in multiple steps.
            case 5:
            {
               hr = m_axwnd.CreateControlLic(
                  OLESTR("MSCAL.Calendar.7")
               );
               break;
            }
            case 6:
            {
               hr = AtlAxCreateControlLic(
                  OLESTR("MSCAL.Calendar.7"), 
                  m_wndChild.m_hWnd, 
                  NULL, 
                  NULL
               );
               break;
            }
            case 7:
            {
               hr = m_axwnd.CreateControl(
                  OLESTR("MSCAL.Calendar.7")
               );
               break;
            }
            case 8:
            {
               hr = AtlAxCreateControl(
                  OLESTR("MSCAL.Calendar.7"), 
                  m_wndChild.m_hWnd , 
                  NULL, 
                  NULL
               );
               break;
            }
         }

         // have to obtain an interface to the control and set up the sink
         if (g_UseMethod > 4)
         {
            if (SUCCEEDED(hr))
            {
               hr = m_axwnd.QueryControl(&spControl);
               if (SUCCEEDED(hr))
               {
                  // Sink events form the control
                  DispEventAdvise(spControl, &__uuidof(DCalendarEvents));
               }
            }
         }

         if (SUCCEEDED(hr))
         {
            // Use the returned IUnknown pointer.
            CComPtr<ICalendar> spCalendar;
            hr = spControl.QueryInterface(&spCalendar);
            if (SUCCEEDED(hr))
            {
               spCalendar->put_ShowDateSelectors(VARIANT_FALSE);
            }
         }
      }

      rect2 = rect;
      rect2.top = rect.bottom - 200 + 1;
      m_wndEdit.Create(_T("Edit"), m_hWnd, rect2, NULL, WS_CHILD | WS_VISIBLE | 
         WS_BORDER | ES_AUTOHSCROLL | ES_AUTOVSCROLL | ES_MULTILINE, 0, 2);
      return 0;
   }

   LRESULT OnDestroy(UINT, WPARAM, LPARAM, BOOL&)
   {
      _pAtlModule->Unlock();
      return 0;
   }
};

class CHostActiveXModule : public CAtlExeModuleT<CHostActiveXModule>
{
public :

   CMainWindow m_wndMain;

   // Create the Main window
   HRESULT PreMessageLoop(int nCmdShow)
   {
      HRESULT hr = CAtlExeModuleT<CHostActiveXModule>::PreMessageLoop(nCmdShow);
      if (SUCCEEDED(hr))
      {
         AtlAxWinInit();
         hr = S_OK;
         RECT rc;
         rc.top = rc.left = 100;
         rc.bottom = rc.right = 500;
         m_wndMain.Create(NULL, rc, _T("Host Calendar") );
         m_wndMain.ShowWindow(nCmdShow);         
      }
      return hr;
   }

   // Clean up. App is exiting.
   HRESULT PostMessageLoop()
   {
      AtlAxWinTerm();
      return CAtlExeModuleT<CHostActiveXModule>::PostMessageLoop();
   }
};

CHostActiveXModule _AtlModule;

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
   UNREFERENCED_PARAMETER(hInstance);
   UNREFERENCED_PARAMETER(hPrevInstance);

   g_UseMethod = _ttoi(lpCmdLine);

   if (ValidateUseMethod())
   {
      return _AtlModule.WinMain(nCmdShow);
   }
   else
   {
      return E_INVALIDARG;   
   }
}

참고 항목

컨트롤 포함 FAQ
AtlAxCreateControl
AtlAxCreateControlEx
AtlAxCreateControlLic
AtlAxCreateControlLicEx
CAxWindow2T 클래스
IAxWinHostWindowLic 인터페이스