Zawieranie kontrolek ALT — Często zadawane pytania

Kod hostingu kontrolek atl nie wymaga używania żadnych klas ATL; Możesz po prostu utworzyć okno "AtlAxWin80" i w razie potrzeby użyć interfejsu API hostingu kontrolek (aby uzyskać więcej informacji, zobacz Co to jest interfejs API hostingu kontrolek ATL. Jednak następujące klasy ułatwiają korzystanie z funkcji zawierania.

Interfejs API hostowania kontrolek ATL to zestaw funkcji, który umożliwia każdemu oknie działanie jako kontener kontrolek ActiveX. Te funkcje mogą być statycznie lub dynamicznie połączone z projektem, ponieważ są one dostępne jako kod źródłowy i udostępniane przez bibliotekę ATL90.dll. Funkcje hostingu kontrolek są wymienione w poniższej tabeli.

HWND Parametry w pierwszych trzech funkcjach muszą być istniejącym oknem (prawie) dowolnego typu. Jeśli jawnie wywołasz dowolną z tych trzech funkcji (zazwyczaj nie musisz), nie przekaż uchwytu do okna, które działa już jako host (jeśli to zrobisz, istniejący obiekt hosta nie zostanie uwolniony).

Pierwsze siedem funkcji wywołuje niejawnie atlAxWinInit .

AtlAxWin100 to nazwa klasy okien, która pomaga zapewnić funkcje hostingu kontrolek ATL. Podczas tworzenia wystąpienia tej klasy procedura okna automatycznie użyje interfejsu API hostingu kontrolek do utworzenia obiektu hosta skojarzonego z oknem i załadowania go za pomocą kontrolki określonej jako tytuł okna.

AtlAxWinInit rejestruje klasę okien "AtlAxWin80" (plus kilka niestandardowych komunikatów okna), aby ta funkcja musiała zostać wywołana przed próbą utworzenia okna hosta. Jednak nie zawsze trzeba jawnie wywoływać tę funkcję, ponieważ interfejsy API hostingu (i klasy, które ich używają) często nazywają tę funkcję za Ciebie. Nie ma żadnych szkód w wywoływaniu tej funkcji więcej niż raz.

Obiekt hosta jest obiektem COM, który reprezentuje kontener sterowania ActiveX dostarczony przez ATL dla określonego okna. Podklasy obiektu hosta okno kontenera, dzięki czemu może odzwierciedlać komunikaty do kontrolki, udostępnia niezbędne interfejsy kontenera do użycia przez kontrolkę i uwidacznia interfejsy IAxWinHostWindow i IAxWinAmbientDispatch , aby umożliwić skonfigurowanie środowiska kontrolki.

Za pomocą obiektu hosta można ustawić właściwości otoczenia kontenera.

Nie można hostować więcej niż jednej kontrolki w jednym oknie hosta ATL. Każde okno hosta jest przeznaczone do przechowywania dokładnie jednej kontrolki naraz (pozwala to na prosty mechanizm obsługi odbicia komunikatów i właściwości otoczenia dla poszczególnych kontrolek). Jeśli jednak chcesz, aby użytkownik widział wiele kontrolek w jednym oknie, wystarczy utworzyć wiele okien hosta jako elementów podrzędnych tego okna.

Nie zaleca się ponownego używania okien hostów. Aby zapewnić niezawodność kodu, należy powiązać okres istnienia okna hosta z okresem istnienia pojedynczej kontrolki.

AtlAxWinTerm wyrejestrowuje klasę okna "AtlAxWin80". Należy wywołać tę funkcję (jeśli nie trzeba już tworzyć okien hosta) po zniszczeniu wszystkich istniejących okien hosta. Jeśli ta funkcja nie zostanie wywołana, klasa okna zostanie automatycznie wyrejestrowana po zakończeniu procesu.

W przykładzie w tej sekcji pokazano, jak utworzyć axhost i jak hostować kontrolkę ActiveX przy użyciu różnych funkcji ATL. Pokazano również, jak uzyskać dostęp do zdarzeń kontroli i ujścia (przy użyciu protokołu IDispEventImpl) z hostowanej kontrolki. Przykład obsługuje kontrolkę Kalendarz w oknie głównym lub w oknie podrzędnym.

Zwróć uwagę na definicję symbolu USE_METHOD . Możesz zmienić wartość tego symbolu tak, aby różniła się w zakresie od 1 do 8. Wartość symbolu określa sposób tworzenia kontrolki:

• W przypadku parzystym numerem wartości USE_METHODwywołania w celu utworzenia podklas hosta okno i konwertuje je na hosta sterującego. W przypadku wartości z nieparzystą liczbą kod tworzy okno podrzędne, które działa jako host.

• W przypadku wartości z USE_METHOD zakresu od 1 do 4 dostęp do kontroli i ujścia zdarzeń odbywa się w wywołaniu, które tworzy również hosta. Wartości z zakresu od 5 do 8 wysyłają zapytanie do hosta dla interfejsów i podłączają ujście.

Oto podsumowanie:

// 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;   
   }
}

Zobacz też

Często zadawane pytania dotyczące zawierania kontrolek
AtlAxCreateControl
AtlAxCreateControlEx
AtlAxCreateControlLic
AtlAxCreateControlLicEx
Klasa CAxWindow2T
Interfejs IAxWinHostWindowLic