Für meine Nachrichten verteilung hab ich mich für einen VCL ähnlichen ansatz entschieden, ich hab also nicht für die fenster einen großen callback, sondern viele kleinere. Diese unterscheiden sich natürlich darin, welche parameter sie übergeben bekommen, etc und im endeffekt sieht meine Klasse nun(gekürzt) so aus:

class Object{
        private:
            Observer observer;
            //...
        protected:
            //diese funktionen werden von den abgeleiteten Objekten überschrieben,
            //die das event gesondert verarbeiten müssen
            virtual void ownSetTime(std::time_t time);

            virtual void ownMouseKlick(Button button,int x,int y);
            virtual void ownEnterKey(KeyState state,int key);
            virtual void ownWheelMove(int degree);
            //...

        public:

            //öffentliche schnittstelle
            void setTime(std::time_t time);

            void mouseKlick(Button button,int x,int y);
            void enterKey(KeyState state,int key);
            void wheelMove(int degree);
            //...
    };

    void Object::mouseKlick(Button button,int x,int y)
    {
        ownMouseKlick(button,x,y);

        //benachrichtigen der observer
        observer.mouseKlick(button,x,y,this);
    }
    //...

    class Observer{
        private:
            std::vector<std::tr1::function<void(Button,int,int,Object*)> > mouseKlick;
            //...
        public:
            void mouseKlick(Button button,int x,int y,Object* object);
            //...
    };

Das Problem ist nun natürlich, dass es unglaublich schwer ist, hier mal ein neues event einzuführen, da ich an vielen stellen rumfummeln müsste.

Hat da jemand ne gute idee?

Zumindest bin ich mit diesem Ansatz nun (theoretisch)ein stück weiter gekommen:
(wenn syntaxfehler drin sind, bitte übergehen, bis ich das durch den compiler jagen könnte, dauerts nochwas)

class Object{
        private:
            typedef ObserverList<GanzVieleEvents> Observer;
            Observer observer;
            //...
        protected:
            //diese funktionen werden von den abgeleiteten Objekten überschrieben,
            //die das event gesondert verarbeiten müssen(Ein Button zb ownMouseClick)
            virtual void ownSetTime(std::time_t time);

            virtual void ownMouseClick(Button button,int x,int y);
            virtual void ownEnterKey(KeyState state,int key);
            virtual void ownWheelMove(int degree);

            template<class Tuple>
            void dispatcher(Event event,const Tuple& tuple){
                switch(Event)
                {
                    case MouseKlick:
                        ownMouseClick(std::tr1::get<0>(tuple),std::tr1::get<1>(tuple),std::tr1::get<2>(tuple));
                    break;
                    //...
                }
            }
        public:

            //öffentliche schnittstelle
            template<Event event>//ne enum
            void sendEvent(const Observer::Get<event>::TupleType& tuple)
            {
                observer.call<event>(tuple,this);
                //dispatcher für die virtuellen funktionen
                dispatch(event,tuple);

            }
            template<Event event>
            void addObserver(const Observer::Get<event>::FunctorType& functor)
            {
                observer.addObserver<event>(functor);   
            }
    };

Jetzt hab ich erreicht, dass ich nurnoch an dem Observer template und dem dispatcher rumspielen muss, wenn ich noch was hinzufügen will,aber wirklich zufrieden bin ich damit immernoch net. Wie gesagt, ich such schon nach nem andren Ansatz, aber im moment bin ich recht ratlos.

Generell gefällt mir die Qt-Lösung recht gut (die Idee mehr als die konkrete Implementation). Dort werden einige Standard-Events über virtuelle Methoden behandelt, der Großteil dann aber über typsichere Signal-Slot-Verbindungen.

Mal Als Beispiel ein OnKlick Event für einen Button.

Button ist von Object abgeleitet und implementiert für die einzelnen Events 
die virtuellen funktionen. Bei Mouseklick würde er zb diese Klickanimation machen

//schritt1: es wird auf die GUI geklickt
//schritt2: es wird überprüft, welches Fenster genau getroffen wird

Klick(position x,y)
    |
    v
  __________    intersect(x,y)    ________________
 |Hauptmodul|  ------------->    |  Alle Fenster   |
 |__________|  <-------------    |_________________|
                antwort(Button)

//schritt3: an das Fenster wird das Event geschickt

  __________    MouseKlick        ___________
 |Hauptmodul|  ----------->      |  Button   |
 |__________|                    |___________|  

//schritt 4: Der Button ruft zuerst seine eigene Verarbeitungsmethode auf
             (ownMouseKlick)

//schritt5: alle Objekte, die den Button beobachten, kriegen die nachricht
            über Observer gesendet, dass der Button geklickt wurde

 _________                       ____________              __________
|  Button |---->ownMouseClick   |   Observer | mouseClick | Listener |
|         |                     |            |----------->|          |
|_________|-------------------> |____________| _          |__________|
                 mouseClick                     |          __________   
                                                |         |Listener  |
                                                |-------->|          |
                                                          |__________|

Die Listener reagieren dann darauf, dass der Button geklickt wurde.

Die Frage ist natürlich, wieso ich diese virtuellen funktionen überhaupt einbauen will. Immerhin liefert mir das selbst keinerlei vorteile, ausser dass ich in der abgeleiteten Klasse diese funktionen einfach überschreiben kann, und dann gehts los. Der Vorteil wäre also einfachkeit.

Nun...Unter diesen Annahmen könnte man doch(auch wenn es sehr eigensinnig wäre), diese virtuellen funktionen weglassen, und dafür im constructor der abgeleiteten Klasse einen callback in den Observer hängen.

Ich mein damit sowas(pseudocode):

class Button:public Object{
    private:
        void ownMouseClick(Button button,int x,int y){...}
    public:
        Button(){
            addObserver<MouseClick>(Functor(Button::ownMouseClick));
        }
};

Ich müsste halt nur dafür sorgen, dass dieser callback immer als erstes aufgerufen wird, aber das stuf ich mal als "machbar" ein.

natürlich hätte ich ein Problem, wenn ich dann ownMouseClick von Button nochmal überschreiben wollte, obwohl...an diesem ort würde ownMouseClick als virtuelle funktion wohl keine Probleme bereiten...hmm.