5. WndProc in eine Klasse bekommen...

WndProc in eine Klasse bekommen...

  • W

    OK, ich habe jetzt verstanden, um was es geht. Ich habe mir jetzt eine kleine Klasse namens CWindow gemacht, für die jede Instanz eine eigene WindowProc haben soll, die NICHT außerhalb der Klasse zu finden sein soll. Ich denke, das war genau Mis2coms Problem. Jetzt verstehe ich aber Shades Vorschlag nicht. Wie macht man das? Hier mal meine Header-Datei der Klasse:

    //---------------------------------------------------------------------------
#ifndef CWindowH
#define CWindowH
//---------------------------------------------------------------------------
#include <windows.h>
//---------------------------------------------------------------------------
typedef long(__stdcall* WNDPROC)(void*,unsigned int,unsigned int,long);

class CWindow
{
   private:
   LPCTSTR     fClassName;
   HINSTANCE   fInstance;
   HWND        fHandle;
   HWND        fParentHandle;
   DWORD       fStyle;
   DWORD       fExStyle;
   HICON       fIcon;
   HCURSOR     fCursor;
   HMENU       fMenu;
   WORD        fID;
   int         fLeft;
   int         fTop;
   int         fWidth;
   int         fHeight;
   LPCTSTR     fCaption;
   WNDPROC     fWndProc;

   BOOL        fRegistered;
   BOOL        fCreated;

   protected:
   VOID Initialize();

   public:
   CWindow(LPCTSTR classname, HINSTANCE);
   CWindow(LPCTSTR classname, HINSTANCE, HWND parent);
   ~CWindow(void);

   ATOM    Register(WNDPROC);
   BOOL    Create(void);

   BOOL    SetStyle(DWORD);
   BOOL    SetExStyle(DWORD);
   VOID    SetIcon(HICON);
   VOID    SetCursor(HCURSOR);
   VOID    SetMenu(HMENU);
   VOID    SetID(WORD);
   VOID    SetLeft(int);
   VOID    SetTop(int);
   VOID    SetWidth(int);
   VOID    SetHeight(int);
   VOID    SetBounds(int left, int top, int width, int height);
   VOID    SetRect(RECT);
   VOID    SetCaption(LPCTSTR);
   //VOID    SetWindowProc(WNDPROC);

   HWND    Handle();
   HWND    ParentHandle();
   /*DWORD   Style();
   DWORD   ExStyle();
   HICON   Icon();
   HCURSOR Cursor();
   HMENU   Menu();
   WORD    ID();
   int     Left();
   int     Top();
   int     Width();
   int     Height();
   RECT    Rect();
   LPCTSTR Caption();
   WNDPROC WndProc();*/

   LRESULT Perform(UINT, WPARAM, LPARAM);
   /*BOOL    AddStyle(DWORD);
   BOOL    DeleteStyle(DWORD);
   BOOL    AddExStyle(DWORD);
   BOOL    DeleteExStyle(DWORD);*/
};
//---------------------------------------------------------------------------

LRESULT CALLBACK ThisWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
  CWindow*  This;

  switch(iMsg)
  {
     case WM_CREATE:
        break;

     case WM_COMMAND:
        MessageBox(NULL, "HALLO", "HALLO", MB_OK);
        break;

     case WM_PAINT:
        break;

     case WM_DESTROY:
        PostQuitMessage(0);
        break;
  }
  return DefWindowProc(hwnd, iMsg, wParam, lParam);
}
//---------------------------------------------------------------------------
#endif
    0
  • K

    Shade meint glaube ich :

    class Window
{
    static LRESULT CALLBACK ThisWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam);
};

LRESULT CALLBACK Window::ThisWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
    CWindow*  This;

    switch(iMsg)
    {
    case WM_CREATE:
        This = (Window *) (((LPCREATESTRUCT) lParam)->lpCreateParams);
        break;

    }
}

    Beim erstellen musst du jetzt den Window Pointer übergeben.

    0
  • W

    Jo, so ähnlich hatte ich mir das dann auch gedacht. Aber ich verstehe das nicht. Warum sollte in WM_CREATE in den CreateParams genau der Zeiger auf das CWindow-Objekt sein, das das Handle hwnd hat? Also, der "momentane" Zeiger? Und warum nimmt er WndProc ohne Angabe von static nicht, und so schon? Fragen über Fragen - aber ich hoffe, ihr könnt sie beantworten. Danke.

    0
  • ?

    lol, den zeiger auf die fensterklasse übergibt man bei CreateWindow, also CreateWindow(..., ..., this); Deshalb kann man dann bei den CreateParams darauf zugreifen

    0
  • ?

    Ich hab das so gemeint wie KPC erklärt hat...

    Nur hat KPC vergessen im WM_CREATE den This auch mit SetWindowLong bzw. SetWindowLongPtr zu speichern und die erste Zeile von ThisWndProc sollte This mit GetWindowLong/Ptr füllen...

    @Webfritzi:
    Die wndproc MUSS static sein, anders kann sie nicht in der klasse sein, was sie aber sein muss, sonst ist die kapselung im *****...

    deshalb machen wir sie static.

    den this gibt man bei CreateWindow als letzten Parameter an, der wird beim WM_CREATE dann mitgeliefert in der CREATESTRUCT. somit können wir ihn speichern...

    bisher habe ich noch nie eine andere vernüftige möglichkeit gesehen, das anders zu lösen. ich lasse mich aber gene eines besseren belehren.

    0
  • W

    Ich habe das jetzt so gemacht, dass ich den Pointer in der USERDATA den Windows speichere. Dann brauche ich diesen CREATESTRUCT auch nicht. Außerdem steht in meiner SDK-Hilfe:

    lpCreateParams

    Points to data to be used for creating the window.
    Windows NT: This member is the address of a SHORT (16_bit) value that specifies the size, in bytes, of the window creation data. The value is immediately followed by the creation data. For more information, see the following Remarks section.

    0
  • W

    Original erstellt von Shade@work:
    **@Webfritzi:
    Die wndproc MUSS static sein, anders kann sie nicht in der klasse sein, was sie aber sein muss, sonst ist die kapselung im *****...

    deshalb machen wir sie static.
    **

    Das habe ich schon gemerkt, dass sie static sein MUSS. Aber wieso? Ich meine, ich wüsste gerne die Bedeutung des Schlüsselwortes static in diesem Zusammenhang. Und warum geht's nicht ohne static, was wieder Mis2coms Frage vom Anfang wäre.

    0
  • S

    die frage wurde doch schon beantwortet!

    Jeder Methode wird der this zeiger uebergeben.
    A a;
    a.b() == b(&a)
    von der funktionsweise her!

    eine static methode hat aber keinen this zeiger, deshalb ist
    a.b() nicht moeglich wenn b static ist.
    A::b() ist dann aber sehr wohl moeglich!
    A::b() == b()
    und somit sind wir das problem losgeworden, dass der compiler der wndproc den this pointer mitgeben wollte...

    Denn die wndproc darf keinen this zeiger bekommen, denn sie ist callback, was soviel heisst wie: windows ruft die funktion auf! und windows hat keine ahnung welchen this zeiger es mitgeben muss.

    0
  • E

    Wenn du ne Wrapperklasse schreiben willst kannst du bei jedem aufruf der funktion einfach eine funktion deiner Wrapperklasse starten, du legst in der funktion ne statische map an und öffnest immer jeweils die funktion zum HWND das ist dann fast das selbe... du musst halt noch den zwischenschritt machen...

    erm... schau mal in meinem Tut unter Entwicklung eines Steuerelements!
    ciaoy 🙂

    > Endy <<

    0
  • 5

    da gibts ne viel einfachere lösung....

    class CWindow
{
static LRESULT CALLBACK BaseWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
};

LRESULT CALLBACK BaseWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
return CWindow::WindowProc(hWnd, uMsg, wParam, lParam);
}

LRESULT CALLBACK CWindow::WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
//hier kannste jetzt alles machen...
}

    und bei der wndclass kannste jetzt die basewndproc als wndproc angeben.....

    mfg 5th

    [ Dieser Beitrag wurde am 16.06.2002 um 11:22 Uhr von 5thElement editiert. ]

    0
  • ?

    Toll, das bringt's!!!!

    0
  • C

    Das geht doch gar nicht! :p
    Schonmal versucht das zu kompilieren?!

    <eigenwerbung>Hier gibts meine WinAPIWrapper inklusive Quelltext.</eigenwerbung>

    0
  • B

    eins vorweg:ich steige gerade um von c auf c++!
    es ist nur eine idee aber vielleicht kann man das problem als lösung verwenden!!
    vielleicht geht es das man die WndProc mit drei parametern deklariert(den indirekten this noch dazu sind es 4!)
    windows übergibt ja auch genau 4 parameter,ich hoffe das alle 4Byte lang sind(bei windows weis ichs, in der eigens definierten müssen dann alle 4Byte lang sein)
    ,wenn man den this dann in HWND castet müsste es gehen(falls der this der 1.param ist)
    ,den this muss man dann im konstruktor in einer "this" variable speichern(falls man ihn braucht).
    ich weis nich ob das geht aber ich bin mir fast sicher mit rumgecaste müsste es gehen.was sagt ihr dazu ich bin ja in c++ nich so bewandert,könnte es gehen?gebt mal euren senf dazu ab! :p 🙄 🕶 🙂

    0
  • 5

    Original erstellt von cd9000:
    **Das geht doch gar nicht! :p
    Schonmal versucht das zu kompilieren?!

    <eigenwerbung>Hier gibts meine WinAPIWrapper inklusive Quelltext.</eigenwerbung>**

    na, dann weiss ich nicht wieso es in den directx samples geht 😉
    code-ausschnitt:

    //-----------------------------------------------------------------------------
// Name: WndProc()
// Desc: Static msg handler which passes messages to the application class.
//-----------------------------------------------------------------------------
LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
    return g_pD3DApp->MsgProc( hWnd, uMsg, wParam, lParam );
}

//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: Message handling function.
//-----------------------------------------------------------------------------
LRESULT CD3DApplication::MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam,
                                  LPARAM lParam )
{
//...
}

//klasse
   virtual LRESULT MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
    0
  • B

    nagut wenn ihr keinen senf dazu abgeben wollt...
    ich habs probiert und meine mit meiner lösung auch weiter zu kommen(noch nich alles getestet läuft aber schonmal!!)
    etwas ASM konnte ich aber nich vermeiden...

    #include<windows.h>

//LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);

class wrap
{
private:
public:
LRESULT CALLBACK WndProc(UINT,WPARAM,LPARAM);
};

wrap mytest;

int WINAPI WinMain(HINSTANCE h1,HINSTANCE h2,LPSTR comline,int show)
{
    HWND hwnd;
    MSG msg;
    WNDCLASS wnd;
    long (__stdcall *f2)(HWND,UINT,WPARAM,LPARAM);
    long (__stdcall wrap:: *f1)(UINT,WPARAM,LPARAM);
    char *appname = "Spielwiese";
    wnd.style=CS_VREDRAW|CS_HREDRAW;
    //wnd.lpfnWndProc=mytest.WndProc;
    f1=mytest.WndProc;
    __asm{
    mov eax,f1
        mov f2,eax
    }
    wnd.lpfnWndProc=f2;
    wnd.cbClsExtra=0;
    wnd.cbWndExtra=0;
    wnd.hInstance=h1;
    wnd.hIcon=LoadIcon(NULL,IDI_APPLICATION);
    wnd.hCursor=LoadCursor(NULL,IDC_ARROW);
    wnd.lpszMenuName=NULL;
    wnd.hbrBackground=(HBRUSH) GetStockObject(BLACK_BRUSH);
    wnd.lpszClassName=appname;

    RegisterClass(&wnd);

    hwnd=CreateWindow(appname,appname,WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,NULL,NULL,h1,NULL);
    ShowWindow(hwnd,show);
    UpdateWindow(hwnd);

    while(TRUE)
        {
        if(!PeekMessage(&msg,NULL,0,0,PM_REMOVE))
        {
            if(msg.message==WM_QUIT)
                break;
        TranslateMessage(&msg);
        DispatchMessage(&msg);
        }
        else
        {

        }
        }
    return msg.wParam;
    }

LRESULT CALLBACK wrap::WndProc(UINT message,WPARAM w,LPARAM l)
{
    HWND hwnd;
    hwnd=(HWND)this;
    switch(message)
    {
    case WM_LBUTTONDOWN:
        MessageBox(NULL,"Hallo","nochmal hallo",MB_OK);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc(hwnd,message,w,l);
}
    0
  • W

    Kannste mal den Assembler-Code erklären, bitte?

    0
  • B

    ja kann ich.

    __asm{
    mov eax,f1
        mov f2,eax
    }

    mov eax,f1
    das bedeutet das in das register(eine statische hardware variable,sozusagen)der wert geschrieben wird der in f1 steht.
    eax=f1;//wäre es in c
    mov f2,eax
    das bedeutet das aus dem register der wert in f2 geschrieben wird.
    f2=eax;//in c

    das andere sind tags.
    ich gehe den umweg über das register weil direktes umkopieren nich geht,und weil in assembler keine typen prüfung statt findet!beide funktionspointer haben unterschiedliche parameter,das kann man in c++ nicht konvertieren,aber in ASM:)

    [ Dieser Beitrag wurde am 17.06.2002 um 19:07 Uhr von Bigor editiert. ]

    0
  • H

    na, dann weiss ich nicht wieso es in den directx samples geht
    code-ausschnitt: ...

    Dein directx Beispiel funktioniert, weil Du dort einen (offenbar) globalen Pointer (g_pD3D...) hast, um das nicht-statische WndProc aufzurufen. Geht also nur solange Du nur eine Instanz Deines Windows hast.

    0
  • W

    Ist ja jetzt auch egal. Scheinbar hat jetzt jeder für sich eine Methode gefunden, die er für die beste hält. 🙂

    0
  • C

    @Bigor:
    Gute Idee 🙂
    Aber das Grundproblem bleibt bestehen: Wie kann man auf Membervariablen der Klasse zugreifen?
    Der einzige vorteil bei dir ist, dass die Methode nicht mehr static ist. Obwohl: eigentlich ist sie es ja doch, oder? Sobald man versucht auf membervariablen zuzugreifen, stürzt das Programm ab. Also quasi eine static methode, deren static eigenschaft erst zur Laufzeit klar wird.

    0
Anmelden zum Antworten