WindowProc in subclass-> so gut gelöst?

[otze]

in der Faq wurde einmal diskutiert,wie man ein windowproc als methode aus einer klasse benutzen kann, ich hab mal drüber nachgedacht, und kam auf folgende lösung für subclasses:

class SubClass{
    private:
        static long BaseWindowProc(HWND hwnd,unsigned int message,unsigned int wParam,unsigned int lParam){
            callback oldCallback=reinterpret_cast<callback>(GetProp(hwnd,"oldCallback"));

            SubClass* callingClass=reinterpret_cast<SubClass*>(GetProp(hwnd,"this"));
            return callingClass->WindowProc(oldCallback,hwnd,message,wParam,lParam);
        }
        HWND subWindow;
        callback oldCallback;
    protected:
        virtual long WindowProc(callback oldCallback,HWND hwnd,unsigned int message,unsigned int wParam,long lParam)=0;
    public:
        SubClass(HWND window):subWindow(window){
            if(!window){
                throw(Exception::CreationFailed("couldn't create subclass->Nullpointer",__LINE__,__FILE__));
            }
            //get old callback
            oldCallback=reinterpret_cast<callback>(GetWindowLongPtr(subWindow,GWLP_WNDPROC));

            //set properties
            SetProp(subWindow,"oldCallback",oldCallback);
            SetProp(subWindow,"this",this);

            //set new callback
            SetWindowLongPtr(subWindow,GWLP_WNDPROC,reinterpret_cast<long>(BaseWindowProc));
        }
        virtual ~SubClass(){
            //reset window
            SetWindowLongPtr(subWindow,GWLP_WNDPROC,reinterpret_cast<long>(oldCallback));
            RemoveProp(subWindow,"oldCallback");
            RemoveProp(subWindow,"this");
        }
        HWND getHandle(){
            return subWindow;
        }
    };

die klasse kann einfach abgeleitet werden, und die derived class kann dann die windowproc als normale methode stellen.

ist die lösung so richtig,bzw gut? oder fehlt noch was?habt ihr das vielleicht anders/besser gelöst?

[otze]

*snief* niemand eine meinung dazu?*mitleidereg**künstlichheul*

[Aziz]

Ich kann dir nicht sagen ob deine Lösung gut oder schlecht ist. Ich würde dir aber dazu raten lieber ein gutes Framework zu verwenden anstatt eine eigene Lösung zu erarbeiten, die dich in Zukunft bestimmt noch sehr viel Zeit und Mühe kosten wird. Ich habe selber vor zwei Monaten versucht eine Klasse zu schreiben, die für mich ein Window Handle kapseln sollte und von der auch das Ableiten möglich sein sollte. Es funktionierte im Großen und Ganzen irgendwie (war sicherlich noch fehleranfällig), aber den Aufwand den ich trieb fand ich schon ziemlich erschreckend groß. Ich gab den ganzen Kram aufgegeben als ich das erste mal von wxWidgets hörte, wovon ich sehr begeistert war. Es ist ganz einfach ein brauchbares (cross-platform) Framework und das beste ist, es lässt plattformspezifischen Code zu, somit sind die Erfahrungen die du mit der WinAPI gemacht hast nicht gänzlich unnötig.

Weitere Informationen findest du unter: www.wxwidgets.org

[würder]

otze, ich würde ne Klasse Window programmieren, die eine Methode subclass hat.

[otze]

@Aziz: da ich später eh eine GUI komplett selber programmieren muss(für opengl/dx),kann ich jede erfahrung die ich mit der WinAPI jetzt heir sammle fast 1:1 übernehmen, deshalb zieh ich das hier jetzt bis zum ende durch^^

@würder: sicher, aber die methode währe niemals so konfortabel wie eine vererbung,vorallem wegen des verfügbaren this zeigers und des direktzugriffs auf die private elemente der Klasse.Dies ist sozusagen ein statisches subclassing,gedacht für das monitoring von standard kontrollelementen wie buttons.

[würder]

so wie ich mir das dachte hätte man this zeigers und des direktzugriffs auf die private elemente.

HWND buttonHandle = CreateWindowEx(....);

Button button;
button.subclass(buttonHandle);

So hab ich das in meiner Fensterklasse gemacht.
Nach dem Aufruf von subclass wird immer erst die Button::WndProc ausgeführt und dann am Schluß die alte Callback.

[otze]

naja^^
das was du kannst schaff ich auch:

class Button:public SubClass{
    private:
        long WindowProc(callback oldCallback,HWND hwnd,unsigned int message,unsigned int wParam,long lParam){
            oldCallback(hwnd,message,wParam,lParam);
        }    
    public:
        Button(HWND hwnd):SubClass(hwnd){}
};

HWND buttonHandle = CreateWindowEx(....);

Button button(buttonHandle);

wo liegt nun der vorteil deiner version?
ps:
wenn ich den ctor von subclass als einfache funktion nochmal implementiere kann ich genau dasselbe erreichen wie du mit deiner methode

aber nur aus interesse:wie hast dus denn implementiert?

[Shlo]

Ein Button ist ein Fenster, Punkt. Nix subclass, nix Spaghetti, sondern Fenster.

[otze]

und was ist, wenn das teil kein fenster ist, sondern nur ein fenster überwacht? was is es dann?^^

[oma]

Otze der Klassenname SubClass ist sehr schlecht.
Da weiß überhaupt niemand was gemeint ist.

[Shlo]

otze schrieb:

und was ist, wenn das teil kein fenster ist, sondern nur ein fenster überwacht? was is es dann?^^

Was soll da überwacht werden? Wenn irgendwas subclassed wird, dann kann es nur ein Fenster sein. Bei Hooks wird diese Methode eh nicht funktionieren.