object.cpp

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.
*/

#include "sdltimer.h"

#include <wt/trace.h>
#include <wt/application.h>
#include <wt/event.h>
#include <wt/object.h>

namespace Wt {

Object::Object(Object *parent, const std::string &name) :
        parent_(parent),
name_(name) {
    trace("obj") << "Creating " << this << std::endl;
    if (parent_)
        parent_->insertChild(this);
}

Object::~Object() {
    trace("obj") << "Entering Destructor for " <<  this << std::endl;
    destroyed(this);
    // delete childs
    while (!children_.empty()) {
        Object *child = *children_.begin();
        trace("obj") << "Deleting child " << child << std::endl;
        delete child;
    }

    if (parent_)
        parent_->removeChild(this);

    // kill all pending timers
    killTimers();

    // this is to signal queue to not deliver any message to this object

    // from this point on it is not possible to deliver any SDLTimeEvent
    // in the SDL stack. We only have to take care the interval == 0 case.
    // Actually we don't have to do that either because rescheduling happens
    // on the same level with the timer event and we are not going to get
    // anymore of that after the next statement.
    Event *child_event = new ChildEvent(Event::ChildRemoved, this);
    Application::postEvent(0, child_event);
    trace("obj") << "Destroyed " <<  this << std::endl;
    Application::sendPostedEvents();
}

bool Object::isDescendant(const Object *p) const {
    if (!p)
        return false;

    const Object *q = this;

    do {
        if (p == q)
            return true;
    } while ((q = q->parent()));

    return false;
}

void Object::insertChild(Object *obj) {
    children_.push_back(obj);
    obj->parent_ = this;
    Event *child_event = new ChildEvent(Event::ChildInserted, obj);
    Application::postEvent(this, child_event);
}

void Object::removeChild(Object *obj) {
    List::iterator end = children_.end();
    List::iterator p = find(children_.begin(), end, obj);

    if (p != end) {
        children_.erase(p);
        obj->parent_ = 0;
        Event *child_event = new ChildEvent(Event::ChildRemoved, obj);
        Application::postEvent(this, child_event);
    }
}

void Object::reparent(Object *new_parent) {
    if (parent_ == new_parent)
        return;
    trace("obj") << "Reparenting " <<  this << std::endl;

    if (parent_) {
        trace("obj") << "   Leaving parent " <<  parent_ << std::endl;
        parent_->removeChild(this);
    }
    if (new_parent) {
        trace("obj") << "   Going to new parent " <<  new_parent << std::endl;
        new_parent->insertChild(this);
    }
    parent_ = new_parent;
}

Object *Object::topParent() const {
    const Object *p = this;
    while (p->parent_) {
        p = p->parent_;
    }
    return const_cast<Object *>(p);
}

void Object::installEventFilter(const Object *filterObj) {
    // we have to deconstify here. We cannot deliver event to const objects
    Object *obj = const_cast<Object *>(filterObj);
    eventFilters_.push_back(obj);
    obj->destroyed.connect(sigc::slot1<void, const Object *>(
                               sigc::mem_fun(*this, &Object::removeEventFilter)));
}

void Object::removeEventFilter(const Object *obj) {
    List::iterator p, end(eventFilters_.end());
    p = find(eventFilters_.begin(), end, obj);
    if (p != end)
        eventFilters_.erase(p);
}

int Object::startTimer(int interval) {
    int id = timers_.size() + 1;
    timers_[id] = new SDLTimer(this, id, interval);
    return id;
}

void Object::killTimer(int id) {
    delete timers_[id];
    timers_.erase(id);
}

void Object::killTimers() {
    uint n = timers_.size() + 1;
    for (uint i = 1; i < n; i++) {
        delete timers_[i];
    }
    timers_.clear();
}

/// check if SDL timer still exists
SDLTimer *Object::timer(int id) const {
    SDLTimerPtrMap::const_iterator it = timers_.find(id);
    return (it != timers_.end() ? it->second : 0);
}

bool Object::filterEvent(Event *e) {
    for (List::iterator filter(eventFilters_.begin()),
            end(eventFilters_.end()); filter != end; ++filter) {
        if ((*filter)->eventFilter(this, e))
            return true;
    }
    return false;
}

bool Object::event(Event *e) {
    bool handled = true;

    if (filterEvent(e))
        return true;

    switch (e->type()) {
    case Event::Timer: {
            TimerEvent *te = static_cast<TimerEvent *>(e);
            int id = te->timerid();
            if (timer(id)) {
                timerEvent(te);
            }
            // if it is signle shot it may have been killed
            // during eventhandling
            SDLTimer *t = timer(id);
            if (t)
                t->scheduleNext();
        }
        break;
    case Event::ChildInserted:
    case Event::ChildRemoved:
        childEvent(static_cast<ChildEvent *>(e));
        break;
    default:
        if (e->type() >= Event::User) {
            customEvent(static_cast<CustomEvent *>(e));
        } else {
            handled = false;
        }
        break;
    }

    return handled;
}

std::ostream& operator<<(std::ostream& s, const Object* obj) {
    const std::string& nm = (obj) ? obj->name() : "(null)";
    s << "object: " << nm << " ("
    << static_cast<const void *>(obj) << ") parent: ";
    const Object *parent = (obj) ? obj->parent() : 0;
    if (parent)
        s << parent->name() <<
        " (" << (void *) parent << ")";
    else
        s << "none (0)";

    return s;
}

std::ostream& operator<<(std::ostream& s, const Object& ref) {
    return s << &ref;
}

std::ostream& operator<<(std::ostream& s, const Event* e) {
    s << "Event " << static_cast<const void *>(e) << " type: " << e->type();
    return s;
}

std::ostream& operator<<(std::ostream& s, const Event& e) {
    return s << &e;
}

}

---

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.