You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koffice/lib/kross/api/event.h

230 lines
8.9 KiB

/***************************************************************************
* event.h
* This file is part of the KDE project
* copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
* This program 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
* Library General Public License for more details.
* You should have received a copy of the GNU Library General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
***************************************************************************/
#ifndef KROSS_API_EVENT_H
#define KROSS_API_EVENT_H
#include "../main/krossconfig.h"
#include "object.h"
#include "callable.h"
#include "list.h"
#include "exception.h"
#include "function.h"
#include "proxy.h"
#include "variant.h"
#include <tqstring.h>
#include <tqvaluelist.h>
#include <tqmap.h>
namespace Kross { namespace Api {
/**
* Template class for all kinds of callable events. An
* event is the abstract base for callable objects like
* methodfunctions in \a Class instances or \a EventSlot
* and \a EventSignal to access TQt signals and slots.
*/
template<class T>
class Event : public Callable
{
private:
/**
* Definition of function-pointers.
*/
typedef Object::Ptr(T::*FunctionPtr)(List::Ptr);
/**
* List of memberfunctions. Each function is accessible
* by the functionname.
*/
TQMap<TQString, Function* > m_functions;
public:
/**
* Constructor.
*
* \param name The name this \a Event has.
*/
Event(const TQString& name)
: Callable(name)
{
}
/**
* Destructor.
*/
virtual ~Event()
{
TQMapConstIterator<TQString, Function* > endit = m_functions.constEnd();
for(TQMapConstIterator<TQString, Function* > it = m_functions.constBegin(); it != endit; ++it)
delete it.data();
}
/**
* Add a \a Callable methodfunction to the list of functions
* this Object supports.
*
* The FunctionPtr points to the concret
* Object::Ptr myfuncname(List::Ptr)
* method in the class defined with template T.
*
* \param name The functionname. Each function this object
* holds should have an unique name to be
* still accessable.
* \param function A pointer to the methodfunction that
* should handle calls.
*
* \todo Remove this method as soon as there is no code using it
*/
inline void addFunction(const TQString& name, FunctionPtr function)
{
m_functions.replace(name, new Function0<T>(static_cast<T*>(this), function));
}
/**
* Add a methodfunction to the list of functions this Object
* supports.
*
* \param name The functionname. Each function this object
* holds should have an unique name to be
* still accessable.
* \param function A \a Function instance which defines
* the methodfunction. This \a Event will be the
* owner of the \a Function instance and will take
* care of deleting it if this \a Event got deleted.
*/
inline void addFunction(const TQString& name, Function* function)
{
m_functions.replace(name, function);
}
/**
* Template function to add a \a ProxyFunction as builtin-function
* to this \a Event instance.
*/
template<class RETURNOBJ, class ARG1OBJ, class ARG2OBJ, class ARG3OBJ, class ARG4OBJ, class INSTANCE, typename METHOD>
inline void addFunction4(const TQString& name, INSTANCE* instance, METHOD method, ARG1OBJ* arg1 = 0, ARG2OBJ* arg2 = 0, ARG3OBJ* arg3 = 0, ARG4OBJ* arg4 = 0)
{
m_functions.replace(name,
new Kross::Api::ProxyFunction<INSTANCE, METHOD, RETURNOBJ, ARG1OBJ, ARG2OBJ, ARG3OBJ, ARG4OBJ>
(instance, method, arg1, arg2, arg3, arg4)
);
}
/// Same as above with three arguments.
template<class RETURNOBJ, class ARG1OBJ, class ARG2OBJ, class ARG3OBJ, class INSTANCE, typename METHOD>
inline void addFunction3(const TQString& name, INSTANCE* instance, METHOD method, ARG1OBJ* arg1 = 0, ARG2OBJ* arg2 = 0, ARG3OBJ* arg3 = 0)
{
m_functions.replace(name,
new Kross::Api::ProxyFunction<INSTANCE, METHOD, RETURNOBJ, ARG1OBJ, ARG2OBJ, ARG3OBJ>
(instance, method, arg1, arg2, arg3)
);
}
/// Same as above with two arguments.
template<class RETURNOBJ, class ARG1OBJ, class ARG2OBJ, class INSTANCE, typename METHOD>
inline void addFunction2(const TQString& name, INSTANCE* instance, METHOD method, ARG1OBJ* arg1 = 0, ARG2OBJ* arg2 = 0)
{
m_functions.replace(name,
new Kross::Api::ProxyFunction<INSTANCE, METHOD, RETURNOBJ, ARG1OBJ, ARG2OBJ>
(instance, method, arg1, arg2)
);
}
/// Same as above, but with one argument.
template<class RETURNOBJ, class ARG1OBJ, class INSTANCE, typename METHOD>
inline void addFunction1(const TQString& name, INSTANCE* instance, METHOD method, ARG1OBJ* arg1 = 0)
{
m_functions.replace(name,
new Kross::Api::ProxyFunction<INSTANCE, METHOD, RETURNOBJ, ARG1OBJ>
(instance, method, arg1)
);
}
/// Same as above with no arguments.
template<class RETURNOBJ, class INSTANCE, typename METHOD>
inline void addFunction0(const TQString& name, INSTANCE* instance, METHOD method)
{
m_functions.replace(name,
new Kross::Api::ProxyFunction<INSTANCE, METHOD, RETURNOBJ>
(instance, method)
);
}
/**
* Check if a function is a member of this \a Callable
* \param name the function name
* \return true if the function is available in this \a Callable
*/
bool isAFunction(const TQString & name) const
{
return m_functions.contains(name);
}
/**
* Overloaded method to handle function-calls.
*
* \throw AttributeException if argumentparameters
* arn't valid.
* \throw RuntimeException if the functionname isn't
* valid.
* \param name The functionname. Each function this
* Object holds should have a different
* name cause they are access by they name.
* If name is TQString() or empty, a
* self-reference to this instance is
* returned.
* \param arguments The list of arguments.
* \return An Object representing the call result
* or NULL if there doesn't exists such a
* function with defined name.
*/
virtual Object::Ptr call(const TQString& name, List::Ptr arguments)
{
#ifdef KROSS_API_EVENT_CALL_DEBUG
krossdebug( TQString("Event::call() name='%1' getName()='%2'").tqarg(name).tqarg(getName()) );
#endif
Function* function = m_functions[name];
if(function) {
#ifdef KROSS_API_EVENT_CALL_DEBUG
krossdebug( TQString("Event::call() name='%1' is a builtin function.").tqarg(name) );
#endif
return function->call(arguments);
}
if(name.isNull()) {
// If no name is defined, we return a reference to our instance.
return this;
}
// Redirect the call to the Kross::Api::Callable we are inherited from.
return Callable::call(name, arguments);
}
};
}}
#endif