object.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_OBJECT_H
#define WT_OBJECT_H

#include <string>
#include <list>
#include <map>

#include <sigc++/object.h>

#include <wt/wsignal.h>

namespace Wt {

class SDLTimer;

class Event;
class ChildEvent;
class CustomEvent;
class TimerEvent;
class MouseEvent;
class WheelEvent;
class FocusEvent;
class KeyEvent;

class Object : virtual public sigc::trackable {
public:
    typedef std::list<Object*> List;

    Object(Object *parent = 0, const std::string &name = "Object::anon");

    virtual ~Object();

    Object *parent() const {
        return parent_;
    };

    const List& children() const {
        return children_;
    }

    List& children() {
        return children_;
    }

    bool isDescendant(const Object *p) const;

    virtual void insertChild(Object *obj);
    virtual void removeChild(Object *obj);
    void reparent(Object *new_parent);

    template <typename T>
    void deleteFirstChild() {
        List::iterator it(children().begin());
        List::iterator end(children().end());

        while (it != end) {
            T *t = dynamic_cast<T *>(*it);
            // before iteration invalidation
            ++it;
            // this will invalidate the iterator
            if (t) {
                delete t;
                break;
            }
        }
    }

    template <typename T>
    void deleteLastChild() {
        List::reverse_iterator it(children().rbegin());
        List::reverse_iterator end(children().rend());

        while (it != end) {
            T *t = dynamic_cast<T *>(*it);
            // before iteration invalidation
            ++it;
            // this will invalidate the iterator
            if (t) {
                delete t;
                break;
            }
        }
    }

    template <typename T>
    void deleteAllChildren() {
        List::iterator it(children().begin());
        List::iterator end(children().end());

        while (it != end) {
            T *t = dynamic_cast<T *>(*it);
            // before iteration invalidation
            ++it;
            // this will invalidate the iterator
            if (t) {
                delete t;
            }
        }
    }

    /// returns top level parent: it may return itself
    Object *topParent() const;

    const std::string& name() const {
        return name_;
    }

    void installEventFilter(const Object * filterObj);
    void removeEventFilter(const Object * obj);
    virtual bool eventFilter(Object *, Event *) {
        return false;
    }

    int startTimer(int interval);
    void killTimer(int id);
    void killTimers();

    /// signals
    Signal01<void, const Object *> destroyed;

    /// event handling
    virtual bool event(Event *e);

protected:
    /// event handling specialization
    virtual void childEvent(ChildEvent *) {}
    virtual void customEvent(CustomEvent *) {}
    virtual void timerEvent(TimerEvent *) {}

    bool filterEvent(Event *);

private:
    Object *parent_;
    std::string name_;
    List children_;
    List eventFilters_;

    /// returns the SDLTimer with id \p id or NULL if not exist
    SDLTimer *timer(int id) const;

    typedef std::map<int, SDLTimer *> SDLTimerPtrMap;
    SDLTimerPtrMap timers_;
};

std::ostream& operator<<(std::ostream& s, const Object* obj);
std::ostream& operator<<(std::ostream& s, const Object& ref);
std::ostream& operator<<(std::ostream& s, const Event* e);
std::ostream& operator<<(std::ostream& s, const Event& e);

}
#endif // WT_OBJECT_H

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.