Dela via

Implementera ett fönster med CWindowImpl

Om du vill implementera ett fönster härleder du en klass från CWindowImpl. I din härledda klass deklarerar du en meddelandekarta och meddelandehanterarfunktionerna. Nu kan du använda din klass på tre olika sätt:

Skapa ett fönster baserat på en ny Windows-klass

CWindowImpl innehåller DECLARE_WND_CLASS makro för att deklarera Windows-klassinformation. Det här makrot implementerar GetWndClassInfo funktionen, som använder CWndClassInfo för att definiera informationen för en ny Windows-klass. När CWindowImpl::Create anropas registreras den här Windows-klassen och ett nytt fönster skapas.

Anmärkning

CWindowImpl skickar NULL till makrot DECLARE_WND_CLASS , vilket innebär att ATL genererar ett Windows-klassnamn. Om du vill ange ditt eget namn skickar du en sträng till DECLARE_WND_CLASS i din klass som är härledd från CWindowImpl.

Exempel: Implementera ett fönster

Följande är ett exempel på en klass som implementerar ett fönster baserat på en ny Windows-klass:

class CMyCustomWnd : public CWindowImpl<CMyCustomWnd>
{
public:
   // Optionally specify name of the new Windows class
   DECLARE_WND_CLASS(_T("MyName")) 
              // If this macro is not specified in your
              // class, ATL will generate a class name

   BEGIN_MSG_MAP(CMyCustomWnd)
      MESSAGE_HANDLER(WM_PAINT, OnPaint)
   END_MSG_MAP()

   LRESULT OnPaint(UINT /*nMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, 
      BOOL& /*bHandled*/)
   {
      // Do some painting code
      return 0;
   }

};

Skapa ett fönster genom att skapa en instans av CMyWindow och sedan anropa Create metoden.

Anmärkning

Om du vill åsidosätta standardinformationen GetWndClassInfo för Windows-klassen implementerar du metoden i din härledda klass genom att ange CWndClassInfo medlemmarna till lämpliga värden.

Superklassa en befintlig Windows-klass

Med makrot DECLARE_WND_SUPERCLASS kan du skapa ett fönster som superklassar en befintlig Windows-klass. Ange det här makrot i den härledda klassen CWindowImpl. Precis som andra ATL-fönster hanteras meddelanden av en meddelandekarta.

När du använder DECLARE_WND_SUPERCLASS registreras en ny Windows-klass. Den här nya klassen kommer att vara samma som den befintliga klassen som du anger, men ersätter fönsterproceduren med CWindowImpl::WindowProc (eller med din funktion som åsidosätter den här metoden).

Exempel: Superklassa klassen Redigera

Följande är ett exempel på en klass som superklassar standardklassen Redigera:

class CMyEdit : public CWindowImpl<CMyEdit>
{
public:
   // "Edit" is the name of the standard Windows class.
   // "MyEdit" is the name of the new Windows class
   // that will be based on the Edit class.
   DECLARE_WND_SUPERCLASS(_T("MyEdit"), _T("Edit"))

   BEGIN_MSG_MAP(CMyEdit)
      MESSAGE_HANDLER(WM_CHAR, OnChar)
   END_MSG_MAP()

   LRESULT OnChar(UINT /*nMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, 
      BOOL& /*bHandled*/)
   {
      // Do some character handling code
      return 0;
   }
};

Skapa det överklassade redigeringsfönstret genom att skapa en instans av CMyEdit och sedan anropa Create metoden.

Underklassning av ett befintligt fönster

Om du vill underklassa ett befintligt fönster härleder du en klass från CWindowImpl och deklarerar en meddelandekarta, som i de två föregående fallen. Observera dock att du inte anger någon Windows-klassinformation, eftersom du kommer att underklassa ett redan befintligt fönster.

I stället för att anropa Create ska du anropa SubclassWindow och skicka referensen till det befintliga fönster som du vill subklassa. När fönstret är underklassat använder CWindowImpl::WindowProc det (eller din funktion som åsidosätter den här metoden) för att dirigera meddelanden till meddelandekartan. Om du vill koppla från ett underklassat fönster från objektet anropar du UnsubclassWindow. Fönstrets ursprungliga fönsterprocedur återställs sedan.

Se även

Implementera ett fönster

  • Last updated on