phoenix-firestorm/indra/llcommon/llevent.cpp

/**
 * @file llevent.cpp
 * @brief LLEvent and LLEventListener base classes.
 *
 * $LicenseInfo:firstyear=2006&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * 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;
 * version 2.1 of the License only.
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "linden_common.h"

#include "llevent.h"

using namespace LLOldEvents;

/************************************************
    Events
************************************************/

// virtual
LLEvent::~LLEvent()
{
}

// virtual
bool LLEvent::accept(LLEventListener* listener)
{
    return true;
}

// virtual
const std::string& LLEvent::desc()
{
    return mDesc;
}

/************************************************
    Observables
************************************************/

LLObservable::LLObservable()
    : mDispatcher(new LLEventDispatcher())
{
}

// virtual
LLObservable::~LLObservable()
{
    if (mDispatcher.notNull())
    {
        mDispatcher->disengage(this);
        mDispatcher = NULL;
    }
}

// virtual
bool LLObservable::setDispatcher(LLPointer<LLEventDispatcher> dispatcher)
{
    if (mDispatcher.notNull())
    {
        mDispatcher->disengage(this);
        mDispatcher = NULL;
    }
    if (dispatcher.notNull() || dispatcher->engage(this))
    {
        mDispatcher = dispatcher;
        return true;
    }
    return false;
}

// Returns the current dispatcher pointer.
// virtual
LLEventDispatcher* LLObservable::getDispatcher()
{
    return mDispatcher;
}

// Notifies the dispatcher of an event being fired.
void LLObservable::fireEvent(LLPointer<LLEvent> event, LLSD filter)
{
    if (mDispatcher.notNull())
    {
        mDispatcher->fireEvent(event, filter);
    }
}

/************************************************
    Dispatchers
************************************************/

class LLEventDispatcher::Impl
{
public:
    virtual ~Impl()                                             {               }
    virtual bool engage(LLObservable* observable)               { return true;  }
    virtual void disengage(LLObservable* observable)            {               }

    virtual void addListener(LLEventListener *listener, LLSD filter, const LLSD& userdata) = 0;
    virtual void removeListener(LLEventListener *listener) = 0;
    virtual std::vector<LLListenerEntry> getListeners() const = 0;
    virtual bool fireEvent(LLPointer<LLEvent> event, LLSD filter) = 0;
};

bool LLEventDispatcher::engage(LLObservable* observable)
{
    return impl->engage(observable);
}

void LLEventDispatcher::disengage(LLObservable* observable)
{
    impl->disengage(observable);
}

void LLEventDispatcher::addListener(LLEventListener *listener, LLSD filter, const LLSD& userdata)
{
    impl->addListener(listener, filter, userdata);
}

void LLEventDispatcher::removeListener(LLEventListener *listener)
{
    impl->removeListener(listener);
}

std::vector<LLListenerEntry> LLEventDispatcher::getListeners() const
{
    return impl->getListeners();
}


bool LLEventDispatcher::fireEvent(LLPointer<LLEvent> event, LLSD filter)
{
    return impl->fireEvent(event, filter);
}

class LLSimpleDispatcher : public LLEventDispatcher::Impl
{
public:
    LLSimpleDispatcher(LLEventDispatcher *parent) : mParent(parent) { }
    virtual ~LLSimpleDispatcher();
    virtual void addListener(LLEventListener* listener, LLSD filter, const LLSD& userdata);
    virtual void removeListener(LLEventListener* listener);
    virtual std::vector<LLListenerEntry> getListeners() const;
    virtual bool fireEvent(LLPointer<LLEvent> event, LLSD filter);

protected:
    std::vector<LLListenerEntry> mListeners;
    LLEventDispatcher *mParent;
};

LLSimpleDispatcher::~LLSimpleDispatcher()
{
    while (mListeners.size() > 0)
    {
        removeListener(mListeners.begin()->listener);
    }
}

void LLSimpleDispatcher::addListener(LLEventListener* listener, LLSD filter, const LLSD& userdata)
{
    if (listener == NULL) return;
    removeListener(listener);
    LLListenerEntry new_entry;
    new_entry.listener = listener;
    new_entry.filter = filter;
    new_entry.userdata = userdata;
    mListeners.push_back(new_entry);
    listener->handleAttach(mParent);
}

void LLSimpleDispatcher::removeListener(LLEventListener* listener)
{
    std::vector<LLListenerEntry>::iterator itor = mListeners.begin();
    std::vector<LLListenerEntry>::iterator end = mListeners.end();
    for (; itor != end; ++itor)
    {
        if ((*itor).listener == listener)
        {
            mListeners.erase(itor);
            break;
        }
    }
    listener->handleDetach(mParent);
}

std::vector<LLListenerEntry> LLSimpleDispatcher::getListeners() const
{
    std::vector<LLListenerEntry> ret;
    for (const LLListenerEntry& entry : mListeners)
    {
        ret.push_back(entry);
    }

    return ret;
}

// virtual
bool LLSimpleDispatcher::fireEvent(LLPointer<LLEvent> event, LLSD filter)
{
    std::string filter_string = filter.asString();
    for (LLListenerEntry& entry : mListeners)
    {
        if (filter_string == "" || entry.filter.asString() == filter_string)
        {
            (entry.listener)->handleEvent(event, entry.userdata);
        }
    }
    return true;
}

LLEventDispatcher::LLEventDispatcher()
{
    impl = new LLSimpleDispatcher(this);
}

LLEventDispatcher::~LLEventDispatcher()
{
    if (impl)
    {
        delete impl;
        impl = NULL;
    }
}

/************************************************
    Listeners
************************************************/

LLEventListener::~LLEventListener()
{
}

LLSimpleListener::~LLSimpleListener()
{
    clearDispatchers();
}

void LLSimpleListener::clearDispatchers()
{
    // Remove myself from all listening dispatchers
    std::vector<LLEventDispatcher *>::iterator itor;
    while (mDispatchers.size() > 0)
    {
        itor = mDispatchers.begin();
        LLEventDispatcher *dispatcher = *itor;
        dispatcher->removeListener(this);
        itor = mDispatchers.begin();
        if (itor != mDispatchers.end() && (*itor) == dispatcher)
        {
            // Somehow, the dispatcher was not removed. Remove it forcibly
            mDispatchers.erase(itor);
        }
    }
}

bool LLSimpleListener::handleAttach(LLEventDispatcher *dispatcher)
{
    // Add dispatcher if it doesn't already exist
    for (LLEventDispatcher* disp : mDispatchers)
    {
        if (disp == dispatcher) return true;
    }
    mDispatchers.push_back(dispatcher);
    return true;
}

bool LLSimpleListener::handleDetach(LLEventDispatcher *dispatcher)
{
    // Remove dispatcher from list
    std::vector<LLEventDispatcher *>::iterator itor;
    for (itor = mDispatchers.begin(); itor != mDispatchers.end(); )
    {
        if ((*itor) == dispatcher)
        {
            itor = mDispatchers.erase(itor);
        }
        else
        {
            ++itor;
        }
    }
    return true;
}