5. WndProc in eine Klasse bekommen...

WndProc in eine Klasse bekommen...

  • 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
  • T

    also ich habe dieses problem so gelöst:
    LRESULT CALLBACK WndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam){
    klasse* wnd = (klasse*)GetWindowLong(hWnd, GWL_USERDATA);

    switch(message){
    case WM_CREATE:
    wnd = (klasse*)((CREATESTRUCT*)lParam)->lpCreateParams;
    SetWindowLong(hWnd, GWL_USERDATA, long(wnd));}
    wnd->WndProc(hWnd,message,wParam,lParam);
    return DefWindowProc(hWnd,message,wParam,lParam);}

    diese funktion gibst du bei wndclass an,
    beim erstelllen des fensters musst du als param den this zeiger übergeben, diese funktion ruft von der klasse die funktion WndProc auf(von der richtigen klasse(des entsprechenden fensters)).
    Tadda feritg. Und dynamisch, beliebig viele instancen

    0
  • B

    @cd9000:
    ja das hab ich auch gerade gemerkt...:(
    aber ich versuche das so zu lösen indem ich den this pointer vom konstruktor speichere,und dann muss man auf die variablen vom this aus zugreifen,ich schaffe es allerdings im moment nichmal einen konstruktor zum laufen zu kriegen(muss nochmal nachlesen wie das geht),das objekt wird im speicher denke ich nich wild hinund her geschoben,desahlb sollten jedes mal der this den gleichen wert haben,aber wie gesagt:ich fange gerade an von c nach c++
    ausserdem isses 1:30 mittwoch morgen und ich muss noch in die schule zeugnis abholen,ich gucke mir das morgne nochmal alles an:D:D:D:D

    0
Anmelden zum Antworten