lib

eventslot.cpp
1/***************************************************************************
2 * eventslot.cpp
3 * This file is part of the KDE project
4 * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public License
15 * along with this program; see the file COPYING. If not, write to
16 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 ***************************************************************************/
19
20#include "eventslot.h"
21
22#include "variant.h"
23#include "qtobject.h"
24
25#include <tqmetaobject.h>
26#include <tqucom_p.h> // for the TQt TQUObject API.
27
28using namespace Kross::Api;
29
30EventSlot::EventSlot(const TQString& name, TQObject* receiver, TQCString slot)
31 : Event<EventSlot>(name)
32 , m_receiver(receiver)
33 , m_slot(slot) //TQObject::normalizeSignalSlot(slot)
34{
35}
36
40
41const TQString EventSlot::getClassName() const
42{
43 return "Kross::Api::EventSlot";
44}
45
46Object::Ptr EventSlot::call(const TQString& /*name*/, List::Ptr arguments)
47{
48#ifdef KROSS_API_EVENTSLOT_CALL_DEBUG
49 krossdebug( TQString("EventSlot::call() m_slot=%1 arguments=%2").arg(m_slot).arg(arguments->toString()) );
50#endif
51
52 TQString n = m_slot; //TODO name; //Variant::toString(args->item(0));
53
54 if(n.startsWith("1")) // Remove prefix of TQ_SLOT-macros
55 n.remove(0,1);
56
57 int slotid = m_receiver->metaObject()->findSlot(n.latin1(), false);
58 if(slotid < 0)
59 throw Exception::Ptr( new Exception(TQString("No such slot '%1'.").arg(n)) );
60
61 TQUObject* uo = QtObject::toTQUObject(n, arguments);
62 m_receiver->tqt_invoke(slotid, uo); // invoke the slot
63 delete [] uo;
64
65 return new Variant( TQVariant(true) );
66}
67
68/*
69TQCString EventSlot::getSlot(const TQCString& signal)
70{
71 TQString signature = TQString(signal).mid(1);
72 int startpos = signature.find("(");
73 int endpos = signature.findRev(")");
74 if(startpos < 0 || startpos > endpos) {
75 krosswarning( TQString("EventSlot::getSlot(%1) Invalid signal.").arg(signal) );
76 return TQCString();
77 }
78 TQString signalname = signature.left(startpos);
79 TQString params = signature.mid(startpos + 1, endpos - startpos - 1);
80 //TQStringList paramlist = TQStringList::split(",", params);
81 TQCString slot = TQString("callback(" + params + ")").latin1(); //normalizeSignalSlot();
82
83 TQMetaObject* mo = metaObject();
84 int slotid = mo->findSlot(slot, false);
85 if(slotid < 0) {
86 krossdebug( TQString("EventSlot::getSlot(%1) No such slot '%2' avaiable.").arg(signal).arg(slot) );
87 return TQCString();
88 }
89
90 const TQMetaData* md = mo->slot(slotid, false);
91 if(md->access != TQMetaData::Public) {
92 krossdebug( TQString("EventSlot::getSlot(%1) The slot '%2' is not public.").arg(signal).arg(slot) );
93 return TQCString();
94 }
95
96//TQMember* member = md->member;
97//const TQUMethod *method = md->method;
98
99 krossdebug( TQString("signal=%1 slot=%2 slotid=%3 params=%4 mdname=%5")
100 .arg(signal).arg(slot).arg(slotid).arg(params).arg(md->name) );
101 return TQCString("1" + slot); // Emulate the TQ_SLOT(...) macro by adding as first char a "1".
102}
103
104bool EventSlot::connect(EventManager* eventmanager, TQObject* senderobj, const TQCString& signal, TQString function, const TQCString& slot)
105{
106 if(m_sender && ! disconnect())
107 return false;
108
109 const TQCString& myslot = slot.isEmpty() ? getSlot(signal) : slot;
110 if(! myslot)
111 return false;
112
113 if(! m_eventmanager) {
114 EventSlot* eventslot = create(eventmanager);
115 eventslot->connect(eventmanager, senderobj, signal, function, slot);
116 m_slots.append(eventslot);
117 krossdebug( TQString("EventSlot::connect(%1, %2, %3) added child EventSlot !!!").arg(senderobj->name()).arg(signal).arg(function) );
118 }
119 else {
120 m_sender = senderobj;
121 m_signal = signal;
122 m_function = function;
123 m_slot = myslot;
124 if(! TQObject::connect((TQObject*)senderobj, signal, this, myslot)) {
125 krossdebug( TQString("EventSlot::connect(%1, %2, %3) failed.").arg(senderobj->name()).arg(signal).arg(function) );
126 return false;
127 }
128 krossdebug( TQString("EventSlot::connect(%1, %2, %3) successfully connected.").arg(senderobj->name()).arg(signal).arg(function) );
129 }
130 return true;
131}
132
133bool EventSlot::disconnect()
134{
135 if(! m_sender) return false;
136 TQObject::disconnect((TQObject*)m_sender, m_signal, this, m_slot);
137 m_sender = 0;
138 m_signal = 0;
139 m_slot = 0;
140 m_function = TQString();
141 return true;
142}
143
144void EventSlot::call(const TQVariant& variant)
145{
146 krossdebug( TQString("EventSlot::call() sender='%1' signal='%2' function='%3'")
147 .arg(m_sender->name()).arg(m_signal).arg(m_function) );
148
149 Kross::Api::List* arglist = 0;
150
151 TQValueList<Kross::Api::Object*> args;
152 if(variant.isValid()) {
153 args.append(Kross::Api::Variant::create(variant));
154 arglist = Kross::Api::List::create(args);
155 }
156
157 try {
158 m_eventmanager->m_scriptcontainer->callFunction(m_function, arglist);
159 }
160 catch(Exception& e) {
161 //TODO add hadError(), getError() and setError()
162 krossdebug( TQString("EXCEPTION in EventSlot::call('%1') type='%2' description='%3'").arg(variant.toString()).arg(e.type()).arg(e.description()) );
163 }
164}
165
166void EventSlot::callback() {
167 call(TQVariant()); }
168void EventSlot::callback(short s) {
169 call(TQVariant(s)); }
170void EventSlot::callback(int i) {
171 call(TQVariant(i)); }
172void EventSlot::callback(int i1, int i2) {
173 call(TQVariant( TQValueList<TQVariant>() << i1 << i2 )); }
174void EventSlot::callback(int i1, int i2, int i3) {
175 call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << i3 )); }
176void EventSlot::callback(int i1, int i2, int i3, int i4) {
177 call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << i3 << i4 )); }
178void EventSlot::callback(int i1, int i2, int i3, int i4, int i5) {
179 call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << i3 << i4 << i5 )); }
180void EventSlot::callback(int i1, int i2, int i3, int i4, bool b) {
181 call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << i3 << i4 << b )); }
182void EventSlot::callback(int i1, bool b) {
183 call(TQVariant( TQValueList<TQVariant>() << i1 << b )); }
184void EventSlot::callback(int i1, int i2, bool b) {
185 call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << b )); }
186void EventSlot::callback(int i1, int i2, const TQString& s) {
187 call(TQVariant( TQValueList<TQVariant>() << i1 << i2 << s )); }
188void EventSlot::callback(uint i) {
189 call(TQVariant(i)); }
190void EventSlot::callback(long l) {
191 call(TQVariant((TQ_LLONG)l)); }
192void EventSlot::callback(ulong l) {
193 call(TQVariant((TQ_ULLONG)l)); }
194void EventSlot::callback(double d) {
195 call(TQVariant(d)); }
196void EventSlot::callback(const char* c) {
197 call(TQVariant(c)); }
198void EventSlot::callback(bool b) {
199 call(TQVariant(b)); }
200void EventSlot::callback(const TQString& s) {
201 call(TQVariant(s)); }
202void EventSlot::callback(const TQString& s, int i) {
203 call(TQVariant( TQValueList<TQVariant>() << s << i )); }
204void EventSlot::callback(const TQString& s, int i1, int i2) {
205 call(TQVariant( TQValueList<TQVariant>() << s << i1 << i2 )); }
206void EventSlot::callback(const TQString& s, uint i) {
207 call(TQVariant( TQValueList<TQVariant>() << s << i )); }
208void EventSlot::callback(const TQString& s, bool b) {
209 call(TQVariant( TQValueList<TQVariant>() << s << b )); }
210void EventSlot::callback(const TQString& s, bool b1, bool b2) {
211 call(TQVariant( TQValueList<TQVariant>() << s << b1 << b2 )); }
212void EventSlot::callback(const TQString& s, bool b, int i) {
213 call(TQVariant( TQValueList<TQVariant>() << s << b << i )); }
214void EventSlot::callback(const TQString& s1, const TQString& s2) {
215 call(TQVariant( TQValueList<TQVariant>() << s1 << s2 )); }
216void EventSlot::callback(const TQString& s1, const TQString& s2, const TQString& s3) {
217 call(TQVariant( TQValueList<TQVariant>() << s1 << s2 << s3 )); }
218void EventSlot::callback(const TQStringList& sl) {
219 call(TQVariant(sl)); }
220void EventSlot::callback(const TQVariant& variant) {
221 call(variant); }
222*/
Kross::Api::EventSlot::~EventSlot
virtual ~EventSlot()
Destructor.
Definition eventslot.cpp:37
Kross::Api::EventSlot::getClassName
virtual const TQString getClassName() const
Definition eventslot.cpp:41
Kross::Api::EventSlot::call
virtual Object::Ptr call(const TQString &name, TDESharedPtr< List > arguments)
Definition eventslot.cpp:46
Kross::Api::EventSlot::EventSlot
EventSlot(const TQString &name, TQObject *receiver, TQCString slot)
Constructor.
Definition eventslot.cpp:30
Kross::Api::Event< EventSlot >::Event
Event(const TQString &name)
Definition event.h:68
Kross::Api::Exception
Common exception class used for representing exceptions in Kross.
Definition exception.h:39
Kross::Api::Exception::Ptr
TDESharedPtr< Exception > Ptr
Shared pointer to implement reference-counting.
Definition exception.h:45
Kross::Api::List::Ptr
TDESharedPtr< List > Ptr
Shared pointer to implement reference-counting.
Definition list.h:46
Kross::Api::Object::Ptr
TDESharedPtr< Object > Ptr
Shared pointer to implement reference-counting.
Definition object.h:56
Kross::Api::QtObject::toTQUObject
static TQUObject * toTQUObject(const TQString &signature, List::Ptr arguments)
Build a TQt TQUObject struct out of the TQt signal or slot signature and the passed List arguments.
Definition qtobject.cpp:91
Kross::Api::Variant
Variant value to wrap a TQVariant into a Kross::Api::Value to enable primitive types like strings or ...
Definition variant.h:39
Kross::Api
The common Kross API used as common codebase.
Definition callable.h:33
Kross::krossdebug
KOFFICE_EXPORT void krossdebug(const TQString &s)
Debugging function.
Definition krossdebug.cpp:28