1 // @(#)root/base:$Id$
2 // Author: Valeriy Onuchin & Fons Rademakers 15/10/2000
3
4 /*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12 #ifndef ROOT_TQObject
13 #define ROOT_TQObject
14
15 //////////////////////////////////////////////////////////////////////////
16 // //
17 // This is the ROOT implementation of the Qt object communication //
18 // mechanism (see also http://www.troll.no/qt/metaobjects.html) //
19 // //
20 // Signals and slots are used for communication between objects. //
21 // When an object has changed in some way that might be interesting //
22 // for the outside world, it emits a signal to tell whoever is //
23 // listening. All slots that are connected to this signal will be //
24 // activated (called). It is even possible to connect a signal //
25 // directly to another signal (this will emit the second signal //
26 // immediately whenever the first is emitted.) There is no limitation //
27 // on the number of slots that can be connected to a signal. //
28 // The slots will be activated in the order they were connected //
29 // to the signal. This mechanism allows objects to be easily reused, //
30 // because the object that emits a signal does not need to know //
31 // to what the signals are connected to. //
32 // Together, signals and slots make up a powerfull component //
33 // programming mechanism. //
34 // //
35 // This implementation is provided by //
36 // Valeriy Onuchin (onuchin@sirius.ihep.su). //
37 // //
38 //////////////////////////////////////////////////////////////////////////
39
40 #ifndef ROOT_TString
41 #include "TString.h"
42 #endif
43
44 class TList;
45 class TObject;
46 class TQConnection;
47 class TClass;
48
49 class TQObject {
50
51 friend class TQConnection;
52
53 protected:
54 TList *fListOfSignals; //! list of signals from this object
55 TList *fListOfConnections; //! list of connections to this object
56 Bool_t fSignalsBlocked; //! flag used for suppression of signals
57
58 static Bool_t fgAllSignalsBlocked; // flag used for suppression of all signals
59
60 virtual void *GetSender() { return this; }
61 virtual const char *GetSenderClassName() const { return ""; }
62
63 static Bool_t ConnectToClass(TQObject *sender,
64 const char *signal,
65 TClass *receiver_class,
66 void *receiver,
67 const char *slot);
68
69 static Bool_t ConnectToClass(const char *sender_class,
70 const char *signal,
71 TClass *receiver_class,
72 void *receiver,
73 const char *slot);
74
75 static Int_t CheckConnectArgs(TQObject *sender,
76 TClass *sender_class, const char *signal,
77 TClass *receiver_class, const char *slot);
78
79 private:
80 TQObject(const TQObject& tqo); // not implemented
81 TQObject& operator=(const TQObject& tqo); // not implemented
82
83 public:
84 TQObject();
85 virtual ~TQObject();
86
87 TList *GetListOfClassSignals() const;
88 TList *GetListOfSignals() const { return fListOfSignals; }
89 TList *GetListOfConnections() const { return fListOfConnections; }
90
91 Bool_t AreSignalsBlocked() const { return fSignalsBlocked; }
92 Bool_t BlockSignals(Bool_t b)
93 { Bool_t ret = fSignalsBlocked; fSignalsBlocked = b; return ret; }
94
95 void CollectClassSignalLists(TList& list, TClass* cls);
96
97 void EmitVA(const char *signal, Int_t nargs, ...);
98 void EmitVA(const char *signal, Int_t nargs, va_list va);
99 void Emit(const char *signal);
100 void Emit(const char *signal, Long_t *paramArr);
101 void Emit(const char *signal, const char *params);
102 void Emit(const char *signal, Double_t param);
103 void Emit(const char *signal, Long_t param);
104 void Emit(const char *signal, Long64_t param);
105 void Emit(const char *signal, Bool_t param)
106 { Emit(signal, (Long_t)param); }
107 void Emit(const char *signal, Char_t param)
108 { Emit(signal, (Long_t)param); }
109 void Emit(const char *signal, UChar_t param)
110 { Emit(signal, (Long_t)param); }
111 void Emit(const char *signal, Short_t param)
112 { Emit(signal, (Long_t)param); }
113 void Emit(const char *signal, UShort_t param)
114 { Emit(signal, (Long_t)param); }
115 void Emit(const char *signal, Int_t param)
116 { Emit(signal, (Long_t)param); }
117 void Emit(const char *signal, UInt_t param)
118 { Emit(signal, (Long_t)param); }
119 void Emit(const char *signal, ULong_t param)
120 { Emit(signal, (Long_t)param); }
121 void Emit(const char *signal, ULong64_t param)
122 { Emit(signal, (Long64_t) param); }
123 void Emit(const char *signal, Float_t param)
124 { Emit(signal, (Double_t)param); }
125
126 Bool_t Connect(const char *signal,
127 const char *receiver_class,
128 void *receiver,
129 const char *slot);
130
131 Bool_t Disconnect(const char *signal = 0,
132 void *receiver = 0,
133 const char *slot = 0);
134
135 virtual void HighPriority(const char *signal_name,
136 const char *slot_name = 0);
137
138 virtual void LowPriority(const char *signal_name,
139 const char *slot_name = 0);
140
141 virtual Bool_t HasConnection(const char *signal_name) const;
142 virtual Int_t NumberOfSignals() const;
143 virtual Int_t NumberOfConnections() const;
144 virtual void Connected(const char * /*signal_name*/) { }
145 virtual void Disconnected(const char * /*signal_name*/) { }
146
147 virtual void Destroyed()
148 { Emit("Destroyed()"); } // *SIGNAL*
149 virtual void ChangedBy(const char *method)
150 { Emit("ChangedBy(char*)", method); } // *SIGNAL*
151 virtual void Message(const char *msg)
152 { Emit("Message(char*)", msg); } // *SIGNAL*
153
154 static Bool_t Connect(TQObject *sender,
155 const char *signal,
156 const char *receiver_class,
157 void *receiver,
158 const char *slot);
159
160 static Bool_t Connect(const char *sender_class,
161 const char *signal,
162 const char *receiver_class,
163 void *receiver,
164 const char *slot);
165
166 static Bool_t Disconnect(TQObject *sender,
167 const char *signal = 0,
168 void *receiver = 0,
169 const char *slot = 0);
170
171 static Bool_t Disconnect(const char *class_name,
172 const char *signal,
173 void *receiver = 0,
174 const char *slot = 0);
175
176 static Bool_t AreAllSignalsBlocked();
177 static Bool_t BlockAllSignals(Bool_t b);
178
179 static void LoadRQ_OBJECT();
180
181 ClassDef(TQObject,1) //Base class for object communication mechanism
182 };
183
184
185 R__EXTERN void *gTQSender; // the latest sender object
186
187 class TQObjSender : public TQObject {
188
189 protected:
190 void *fSender; //delegation object
191 TString fSenderClass; //class name of delegation object
192
193 virtual void *GetSender() { return fSender; }
194 virtual const char *GetSenderClassName() const { return fSenderClass; }
195
196 private:
197 TQObjSender(const TQObjSender&); // not implemented
198 TQObjSender& operator=(const TQObjSender&); // not implemented
199
200 public:
201 TQObjSender() : TQObject(), fSender(0), fSenderClass() { }
202 virtual ~TQObjSender() { Disconnect(); }
203
204 virtual void SetSender(void *sender) { fSender = sender; }
205 void SetSenderClassName(const char *sclass = "") { fSenderClass = sclass; }
206
207 ClassDef(TQObjSender,0) //Used to "delegate" TQObject functionality
208 //to interpreted classes, see also RQ_OBJECT.h
209 };
210
211 // Global function which simplifies making connections in interpreted
212 // ROOT session
213 //
214 // ConnectCINT - connects to interpreter(CINT) command
215
216 extern Bool_t ConnectCINT(TQObject *sender, const char *signal,
217 const char *slot);
218
219 #ifdef G__DICTIONARY
220 // This include makes it possible to have a single connection
221 // from all objects of the same class but is only needed in
222 // the dictionary.
223 #include "TQClass.h"
224 #endif
225
226
227 //---- ClassImpQ macro ----------------------------------------------
228 //
229 // This macro used to correspond to the ClassImp macro and should be used
230 // for classes derived from TQObject instead of the ClassImp macro.
231 // This macro makes it possible to have a single connection from
232 // all objects of the same class.
233 // *** It is now obsolete ***
234
235 #define ClassImpQ(name) \
236 ClassImp(name)
237
238 #endif
239