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/eventslot.cpp

223 lines
8.6 KiB

/***************************************************************************
* eventslot.cpp
* 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.
***************************************************************************/
#include "eventslot.h"
#include "variant.h"
#include "qtobject.h"
#include <tqmetaobject.h>
#include <tqucom_p.h> // for the TQt TQUObject API.
using namespace Kross::Api;
EventSlot::EventSlot(const TQString& name, TQObject* receiver, TQCString slot)
: Event<EventSlot>(name)
, m_receiver(receiver)
, m_slot(slot) //TQObject::normalizeSignalSlot(slot)
{
}
EventSlot::~EventSlot()
{
}
const TQString EventSlot::getClassName() const
{
return "Kross::Api::EventSlot";
}
Object::Ptr EventSlot::call(const TQString& /*name*/, List::Ptr arguments)
{
#ifdef KROSS_API_EVENTSLOT_CALL_DEBUG
krossdebug( TQString("EventSlot::call() m_slot=%1 arguments=%2").tqarg(m_slot).tqarg(arguments->toString()) );
#endif
TQString n = m_slot; //TODO name; //Variant::toString(args->item(0));
if(n.startsWith("1")) // Remove prefix of SLOT-macros
n.remove(0,1);
int slotid = m_receiver->tqmetaObject()->tqfindSlot(n.latin1(), false);
if(slotid < 0)
throw Exception::Ptr( new Exception(TQString("No such slot '%1'.").tqarg(n)) );
TQUObject* uo = QtObject::toTQUObject(n, arguments);
m_receiver->qt_invoke(slotid, uo); // invoke the slot
delete [] uo;
return new Variant( TQVariant(true,0) );
}
/*
TQCString EventSlot::getSlot(const TQCString& signal)
{
TQString signature = TQString(signal).mid(1);
int startpos = signature.tqfind("(");
int endpos = signature.tqfindRev(")");
if(startpos < 0 || startpos > endpos) {
krosswarning( TQString("EventSlot::getSlot(%1) Invalid signal.").tqarg(signal) );
return TQCString();
}
TQString signalname = signature.left(startpos);
TQString params = signature.mid(startpos + 1, endpos - startpos - 1);
//TQStringList paramlist = TQStringList::split(",", params);
TQCString slot = TQString("callback(" + params + ")").latin1(); //normalizeSignalSlot();
TQMetaObject* mo = tqmetaObject();
int slotid = mo->findSlot(slot, false);
if(slotid < 0) {
krossdebug( TQString("EventSlot::getSlot(%1) No such slot '%2' avaiable.").tqarg(signal).tqarg(slot) );
return TQCString();
}
const TQMetaData* md = mo->slot(slotid, false);
if(md->access != TQMetaData::Public) {
krossdebug( TQString("EventSlot::getSlot(%1) The slot '%2' is not public.").tqarg(signal).tqarg(slot) );
return TQCString();
}
//TQMember* member = md->member;
//const TQUMethod *method = md->method;
krossdebug( TQString("signal=%1 slot=%2 slotid=%3 params=%4 mdname=%5")
.tqarg(signal).tqarg(slot).tqarg(slotid).tqarg(params).tqarg(md->name) );
return TQCString("1" + slot); // Emulate the TQT_SLOT(...) macro by adding as first char a "1".
}
bool EventSlot::connect(EventManager* eventmanager, TQObject* senderobj, const TQCString& signal, TQString function, const TQCString& slot)
{
if(m_sender && ! disconnect())
return false;
const TQCString& myslot = slot.isEmpty() ? getSlot(signal) : slot;
if(! myslot)
return false;
if(! m_eventmanager) {
EventSlot* eventslot = create(eventmanager);
eventslot->connect(eventmanager, senderobj, signal, function, slot);
m_slots.append(eventslot);
krossdebug( TQString("EventSlot::connect(%1, %2, %3) added child EventSlot !!!").tqarg(senderobj->name()).tqarg(signal).tqarg(function) );
}
else {
m_sender = senderobj;
m_signal = signal;
m_function = function;
m_slot = myslot;
if(! TQObject::connect((TQObject*)senderobj, signal, this, myslot)) {
krossdebug( TQString("EventSlot::connect(%1, %2, %3) failed.").tqarg(senderobj->name()).tqarg(signal).tqarg(function) );
return false;
}
krossdebug( TQString("EventSlot::connect(%1, %2, %3) successfully connected.").tqarg(senderobj->name()).tqarg(signal).tqarg(function) );
}
return true;
}
bool EventSlot::disconnect()
{
if(! m_sender) return false;
TQObject::disconnect((TQObject*)m_sender, m_signal, this, m_slot);
m_sender = 0;
m_signal = 0;
m_slot = 0;
m_function = TQString();
return true;
}
void EventSlot::call(const TQVariant& variant)
{
krossdebug( TQString("EventSlot::call() sender='%1' signal='%2' function='%3'")
.tqarg(m_sender->name()).tqarg(m_signal).tqarg(m_function) );
Kross::Api::List* arglist = 0;
TQValueList<Kross::Api::Object*> args;
if(variant.isValid()) {
args.append(Kross::Api::Variant::create(variant));
arglist = Kross::Api::List::create(args);
}
try {
m_eventmanager->m_scriptcontainer->callFunction(m_function, arglist);
}
catch(Exception& e) {
//TODO add hadError(), getError() and setError()
krossdebug( TQString("EXCEPTION in EventSlot::call('%1') type='%2' description='%3'").tqarg(variant.toString()).tqarg(e.type()).tqarg(e.description()) );
}
}
void EventSlot::callback() {
call(TQVariant()); }
void EventSlot::callback(short s) {
call(TQVariant(s)); }
void EventSlot::callback(int i) {
call(TQVariant(i)); }
void EventSlot::callback(int i1, int i2) {
call(TQVariant( TQValueList<TQVariant>() << i1 << i2 )); }
void EventSlot::callback(int i1, int i2, int i3) {
call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << i3 )); }
void EventSlot::callback(int i1, int i2, int i3, int i4) {
call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << i3 << i4 )); }
void EventSlot::callback(int i1, int i2, int i3, int i4, int i5) {
call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << i3 << i4 << i5 )); }
void EventSlot::callback(int i1, int i2, int i3, int i4, bool b) {
call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << i3 << i4 << b )); }
void EventSlot::callback(int i1, bool b) {
call(TQVariant( TQValueList<TQVariant>() << i1 << b )); }
void EventSlot::callback(int i1, int i2, bool b) {
call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << b )); }
void EventSlot::callback(int i1, int i2, const TQString& s) {
call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << s )); }
void EventSlot::callback(uint i) {
call(TQVariant(i)); }
void EventSlot::callback(long l) {
call(TQVariant((TQ_LLONG)l)); }
void EventSlot::callback(ulong l) {
call(TQVariant((TQ_ULLONG)l)); }
void EventSlot::callback(double d) {
call(TQVariant(d)); }
void EventSlot::callback(const char* c) {
call(TQVariant(c)); }
void EventSlot::callback(bool b) {
call(TQVariant(b)); }
void EventSlot::callback(const TQString& s) {
call(TQVariant(s)); }
void EventSlot::callback(const TQString& s, int i) {
call(TQVariant( TQValueList<TQVariant>() << s << i )); }
void EventSlot::callback(const TQString& s, int i1, int i2) {
call(TQVariant( TQValueList<TQVariant>() << s << i1 << i2 )); }
void EventSlot::callback(const TQString& s, uint i) {
call(TQVariant( TQValueList<TQVariant>() << s << i )); }
void EventSlot::callback(const TQString& s, bool b) {
call(TQVariant( TQValueList<TQVariant>() << s << b )); }
void EventSlot::callback(const TQString& s, bool b1, bool b2) {
call(TQVariant( TQValueList<TQVariant>() << s << b1 << b2 )); }
void EventSlot::callback(const TQString& s, bool b, int i) {
call(TQVariant( TQValueList<TQVariant>() << s << b << i )); }
void EventSlot::callback(const TQString& s1, const TQString& s2) {
call(TQVariant( TQValueList<TQVariant>() << s1 << s2 )); }
void EventSlot::callback(const TQString& s1, const TQString& s2, const TQString& s3) {
call(TQVariant( TQValueList<TQVariant>() << s1 << s2 << s3 )); }
void EventSlot::callback(const TQStringList& sl) {
call(TQVariant(sl)); }
void EventSlot::callback(const TQVariant& variant) {
call(variant); }
*/