Objet orienté C++ win32?

Question

Je veux créer ma propre classe pour gérer la création de fenêtres et la procédure de fenêtre mais j'ai remarqué que la procédure de fenêtre doit être statique! Je me demande maintenant s'il est possible de rendre l'objet de procédure de fenêtre orienté? J'ai lu quelques tutoriels sur les fenêtres orientées objet, mais ils rendent toujours la procédure statique. Quelle est l'utilité de cela? :/

Tous les liens ou informations sur la façon de contourner ce problème serait apprécié,

grâce

Answer 1

Vous pouvez vous débrouillez en faisant le WndProc statique déléguer tout aux membres:

// Forward declarations 
class MyWindowClass; 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 

std::map<HWND, MyWindowClass *> windowMap; 

// Your class 
class MyWindowClass { 
private: 
    HWND m_handle; 

    // The member WndProc 
    LRESULT MyWndProc(UINT message, WPARAM wParam, LPARAM lParam) { /* ... */ } 

public: 
    MyWindowClass() 
    { 
    /* TODO: Create the window here and assign its handle to m_handle */ 
    /* Pass &WndProc as the pointer to the Window procedure */ 

    // Register the window 
    windowMap[m_handle] = this; 
    } 
}; 

// The delegating WndProc 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 
{ 
    std::map<HWND, MyWindowClass *>::iterator it = windowMap.find(hWnd); 
    if (it != windowMap.end()) 
    return it->second->MyWndProc(message, wParam, lParam); 
    return 0; 
} 

Answer 2

Si vous êtes à la recherche de l'API Win32 orientée objet, vous devriez chercher à MFC et/ou WTL.

Answer 3

Vous pouvez utiliser le handle de fenêtre transmis à WindowProc pour récupérer un objet que vous avez créé pour cette fenêtre particulière et déléguer la gestion des événements à cet objet.

par exemple.

IMyWindowInterface* pWnd = getMyWindowObject(hWnd); 
pWnd->ProcessMessage(uMsg, wParam, lParam); 

Answer 4

La technique générale de permettre une instance de fenêtre pour être représentée par exemple que la classe est d'utiliser SetWindowLongPtr et GetWindowLongPtr pour associer votre pointeur d'instance de classe avec le handle de fenêtre. Voici quelques exemples de code pour vous aider à démarrer. Il ne peut pas compiler sans quelques modifications. C'est seulement destiné à être une référence.

Personnellement, j'ai arrêté de rouler mes propres classes de fenêtres il y a quelques années lorsque j'ai découvert la classe de modèles CWindow et CWindowImpl d'ATL. Ils prennent soin de faire tout ce codage banal pour vous permettre de se concentrer uniquement sur les méthodes d'écriture qui traitent les messages de fenêtre. Voir l'exemple de code que j'ai écrit here.

Espérons que cela aide.

class CYourWindowClass 
{ 
private: 
    HWND m_hwnd; 

public: 
    LRESULT WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam) 
    { 
     switch (uMsg) 
     { 
      case WM_CREATE: return OnCreate(wParam, lParam); 
      case wM_PAINT: return OnPaint(wParam, lParam); 
      case WM_DESTROY: 
      { 
       SetWindowLongPtr(m_hwnd, GWLP_USERDATA, NULL); 
       m_hwnd = NULL; 
       return 0; 
      } 
     } 
     return DefWindowProc(m_hwnd, uMsg, wParam, lParam); 

    } 

    CYourWindowClass() 
    { 
     m_hwnd = NULL; 
    } 

    ~CYourWindowClass() 
    { 
     ASSERT(m_hwnd == NULL && "You forgot to destroy your window!"); 
     if (m_hwnd) 
     { 
      SetWindowLong(m_hwnd, GWLP_USERDATA, 0); 
     } 
    } 

    bool Create(...) // add whatever parameters you want 
    { 
     HWND hwnd = CreateWindow("Your Window Class Name", "Your Window title", dwStyle, x, y, width, height, NULL, hMenu, g_hInstance, (LPARAM)this); 
     if (hwnd == NULL) 
      return false; 

     ASSERT(m_hwnd == hwnd); 
     return true; 
    } 


    static LRESULT __stdcall StaticWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) 
    { 
     CYourWindowClass* pWindow = (CYourWindowClass*)GetWindowLongPtr(hwnd, GWLP_USERDATA); 

     if (uMsg == WM_CREATE) 
     { 
      pWindow = ((CREATESTRUCT*)lParam)->lpCreateParams; 
      SetWindowLongPtr(hwnd, GWLP_USERDATA, (void*)pWindow); 
      m_hWnd = hwnd; 
     } 

     if (pWindow != NULL) 
     { 
      return pWindow->WndProc(uMsg, wParam, lParam); 
     } 

     return DefWindowProc(hwnd, uMsg, wParam, lParam); 
    }; 


}; 

Answer 5

Juste pour ajouter à la réponse de Brian mais pour un cadre de win32 qui est plus convivial débutant jeter un oeil à Win32++. La bibliothèque elle-même n'est pas aussi complète en fonctionnalités que MFC ou QT mais c'est un compromis que le concepteur a fait au début pour garder la bibliothèque facile à comprendre et simple à utiliser. Si vous êtes toujours intéressé par ce sujet, je vous encourage fortement à y jeter un coup d'œil, car il utilise encore une autre technique pour enregistrer le pointeur "this" en utilisant le stockage local de threads.