Object oriented C++ win32?

Question

Voglio creare la mia classe per gestire la creazione di finestre e la procedura della finestra, ma ho notato che la procedura della finestra deve essere statica! Ora mi chiedo se è possibile rendere la procedura della finestra orientata agli oggetti? Ho letto alcuni tutorial su finestre orientate agli oggetti, ma rendono sempre la procedura statica -.- che cosa è l'uso in questo? :/

Tutti i link o informazioni su come ovviare a questo problema sarebbe apprezzato,

grazie

Answer 1

Si può andare in giro che facendo la statica WndProc delegare tutto ai membri:

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

Se siete alla ricerca di object oriented API Win32, allora si dovrebbe cercare di MFC e/o WTL.

Answer 3

È possibile utilizzare l'handle di finestra passato a WindowProc per afferrare un oggetto creato per quella finestra specifica e delegare la gestione degli eventi a tale oggetto.

ad es.

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

Answer 4

La tecnica generale di permettere un'istanza della finestra per essere rappresentato da un'istanza di classe è quello di fare uso di SetWindowLongPtr e GetWindowLongPtr per associare il puntatore dell'istanza della classe all'handle della finestra. Di seguito è riportato un codice di esempio per iniziare. Potrebbe non essere compilato senza alcune modifiche. È solo pensato per essere un riferimento.

Personalmente, ho smesso di aggiornare le mie classi di finestre alcuni anni fa quando ho scoperto la classe di template CWindow e CWindowImpl di ATL. Si prendono cura di fare tutto questo codice banale per te, così possono concentrarsi solo sulla scrittura di metodi che gestiscono i messaggi della finestra. Vedere il codice di esempio che ho scritto su here.

Spero che questo aiuti.

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

solo per aggiungere alla risposta di Brian, ma di un quadro win32 che è più principiante amichevole dare un'occhiata a Win32++. La libreria stessa non è così completa nelle funzionalità rispetto a MFC o QT, ma questo è un compromesso che il progettista ha fatto all'inizio per mantenere la libreria facile da capire e semplice da usare.

Se sei ancora interessato a questo argomento, ti incoraggio vivamente a dare un'occhiata a questo poiché utilizza ancora un'altra tecnica per salvare il puntatore "this" utilizzando la memoria locale del thread.