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?

Weitere Informationen findest du unter: www.wxwidgets.org

@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.

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.

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?

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.