TQObject*¶
This is the ROOT implementation of the Qt object communicationmechanism (see also http:www.troll.no/qt/metaobjects.html)
Signals and slots are used for communication between objects.When an object has changed in some way that might be interestingfor the outside world, it emits a signal to tell whoever islistening. All slots that are connected to this signal will beactivated (called). It is even possible to connect a signaldirectly to another signal (this will emit the second signalimmediately whenever the first is emitted.) There is no limitationon the number of slots that can be connected to a signal.The slots will be activated in the order they were connectedto the signal. This mechanism allows objects to be easily reused,because the object that emits a signal does not need to knowto what the signals are connected to.Together, signals and slots make up a powerfull componentprogramming mechanism.
TQObject friend TQConnection
TQObjSender 继承 TQObject
class¶
TQObject
TQObject();
/// TQObject Constructor.
/// Comment:
/// - In order to minimize memory allocation fListOfSignals and
/// fListOfConnections are allocated only if it is neccesary
/// - When fListOfSignals/fListOfConnections are empty they will
/// be deleted
virtual ~TQObject();
/// TQObject Destructor.
/// - delete all connections and signal list
TList *GetListOfClassSignals() const;/// Returns pointer to list of signals of this class.
TList *GetListOfSignals() const { return fListOfSignals; }
TList *GetListOfConnections() const { return fListOfConnections; }
Bool_t AreSignalsBlocked() const { return fSignalsBlocked; }
Bool_t BlockSignals(Bool_t b)
{ Bool_t ret = fSignalsBlocked; fSignalsBlocked = b; return ret; }
void CollectClassSignalLists(TList& list, TClass* cls);
/// Collect class signal lists from class cls and all its
/// base-classes.
/// The recursive traversal is not performed for classes not
/// deriving from TQClass.
template <typename... T> void EmitVA(const char *signal_name, Int_t /* nargs */, const T&... params);
// void EmitVA(const char *signal, Int_t nargs, ...);
void EmitVA(const char *signal, Int_t nargs, va_list va) = delete;
void Emit(const char *signal);
/// Acitvate signal without args.
void Emit(const char *signal, Long_t *paramArr);
/// Emit a signal with a varying number of arguments,
/// paramArr is an array of the parameters.
/// Note: any parameter should be converted to long type.
void Emit(const char *signal, const char *params);
/// Activate signal with parameter text string.
void Emit(const char *signal, Double_t param);
/// Activate signal with single parameter.
void Emit(const char *signal, Long_t param);
/// Activate signal with single parameter.
void Emit(const char *signal, Long64_t param);
/// Activate signal with single parameter.
void Emit(const char *signal, Bool_t param)
{ Emit(signal, (Long_t)param); }
void Emit(const char *signal, Char_t param)
{ Emit(signal, (Long_t)param); }
void Emit(const char *signal, UChar_t param)
{ Emit(signal, (Long_t)param); }
void Emit(const char *signal, Short_t param)
{ Emit(signal, (Long_t)param); }
void Emit(const char *signal, UShort_t param)
{ Emit(signal, (Long_t)param); }
void Emit(const char *signal, Int_t param)
{ Emit(signal, (Long_t)param); }
void Emit(const char *signal, UInt_t param)
{ Emit(signal, (Long_t)param); }
void Emit(const char *signal, ULong_t param)
{ Emit(signal, (Long_t)param); }
void Emit(const char *signal, ULong64_t param)
{ Emit(signal, (Long64_t) param); }
void Emit(const char *signal, Float_t param)
{ Emit(signal, (Double_t)param); }
Bool_t Connect(const char *signal,
const char *receiver_class,
void *receiver,
const char *slot);
/// Non-static method is used to connect from the signal
/// of this object to the receiver slot.
/// Warning! No check on consistency of sender/receiver
/// classes/methods.
/// This method makes possible to have connection/signals from
/// interpreted class. See also RQ_OBJECT.h.
Bool_t Disconnect(const char *signal = 0,
void *receiver = 0,
const char *slot = 0);
/// Disconnects signal of this object from slot of receiver.
/// Equivalent to Disconnect(this, signal, receiver, slot)
virtual void HighPriority(const char *signal_name,
const char *slot_name = 0);
/// 1. If slot_name = 0 => makes signal defined by the signal_name
/// to be the first in the fListOfSignals, this decreases
/// the time for lookup.
/// 2. If slot_name != 0 => makes slot defined by the slot_name
/// to be executed first when signal_name is emitted.
/// Signal name is not compressed.
virtual void LowPriority(const char *signal_name,
const char *slot_name = 0);
/// 1. If slot_name = 0 => makes signal defined by the signal_name
/// to be the last in the fListOfSignals, this increase the time
/// for lookup.
/// 2. If slot_name != 0 => makes slot defined by the slot_name
/// to be executed last when signal_name is emitted.
/// Signal name is not compressed.
virtual Bool_t HasConnection(const char *signal_name) const;
/// Return true if there is any object connected to this signal.
/// Only checks for object signals.
virtual Int_t NumberOfSignals() const;
/// Return number of signals for this object.
/// Only checks for object signals.
virtual Int_t NumberOfConnections() const;/// Return number of connections for this object.
virtual void Connected(const char * /*signal_name*/) { }
virtual void Disconnected(const char * /*signal_name*/) { }
virtual void Destroyed()
{ Emit("Destroyed()"); } // *SIGNAL*
virtual void ChangedBy(const char *method)
{ Emit("ChangedBy(char*)", method); } // *SIGNAL*
virtual void Message(const char *msg)
{ Emit("Message(char*)", msg); } // *SIGNAL*
static Bool_t Connect(TQObject *sender,
const char *signal,
const char *receiver_class,
void *receiver,
const char *slot);
/// Create connection between sender and receiver.
/// Signal and slot string must have a form:
/// "Draw(char*, Option_t* ,Int_t)"
/// All blanks and "const" words will be removed,
/// Warning:
/// If receiver is class not derived from TQObject and going to be
/// deleted, disconnect all connections to this receiver.
/// In case of class derived from TQObject it is done automatically.
static Bool_t Connect(const char *sender_class,
const char *signal,
const char *receiver_class,
void *receiver,
const char *slot);
/// This method allows to make a connection from any object
/// of the same class to a single slot.
/// Signal and slot string must have a form:
/// "Draw(char*, Option_t* ,Int_t)"
/// All blanks and "const" words will be removed,
/// Warning:
/// If receiver class not derived from TQObject and going to be
/// deleted, disconnect all connections to this receiver.
/// In case of class derived from TQObject it is done automatically.
static Bool_t Disconnect(TQObject *sender,
const char *signal = 0,
void *receiver = 0,
const char *slot = 0);
/// Disconnects signal in object sender from slot_method in
/// object receiver. For objects derived from TQObject signal-slot
/// connection is removed when either of the objects involved
/// are destroyed.
/// Disconnect() is typically used in three ways, as the following
/// examples shows:
/// - Disconnect everything connected to an object's signals:
/// Disconnect(myObject);
/// - Disconnect everything connected to a signal:
/// Disconnect(myObject, "mySignal()");
/// - Disconnect a specific receiver:
/// Disconnect(myObject, 0, myReceiver, 0);
/// 0 may be used as a wildcard in three of the four arguments,
/// meaning "any signal", "any receiving object" or
/// "any slot in the receiving object", respectively.
/// The sender has no default and may never be 0
/// (you cannot disconnect signals from more than one object).
/// If signal is 0, it disconnects receiver and slot_method
/// from any signal. If not, only the specified signal is
/// disconnected.
/// If receiver is 0, it disconnects anything connected to signal.
/// If not, slots in objects other than receiver are not
/// disconnected
/// If slot_method is 0, it disconnects anything that is connected
/// to receiver. If not, only slots named slot_method will be
/// disconnected, and all other slots are left alone.
/// The slot_method must be 0 if receiver is left out, so you
/// cannot disconnect a specifically-named slot on all objects.
static Bool_t Disconnect(const char *class_name,
const char *signal,
void *receiver = 0,
const char *slot = 0);
/// Disconnects "class signal". The class is defined by class_name.
/// See also Connect(class_name,signal,receiver,slot).
static Bool_t AreAllSignalsBlocked();/// Returns true if all signals are blocked.
static Bool_t BlockAllSignals(Bool_t b);
/// Block or unblock all signals. Returns the previous block status.
TQObjSender
TQObjSender() : TQObject(), fSender(0), fSenderClass() { }
virtual ~TQObjSender() { Disconnect(); }
virtual void SetSender(void *sender) { fSender = sender; }
void SetSenderClassName(const char *sclass = "") { fSenderClass = sclass; }
code¶
// void TQObject::Emit(const char *signal_name)
theButton->Emit("Clicked()");
// void TQObject::Emit(const char *signal_name, Long_t param)
theButton->Emit("Clicked(int)",id)
// void TQObject::Emit(const char *signal_name, Long64_t param)
theButton->Emit("Progress(Long64_t)",processed)
// void TQObject::Emit(const char *signal_name, Double_t param)
theButton->Emit("Scale(float)",factor)
// void TQObject::Emit(const char *signal_name, const char *params)
myObject->Emit("Error(char*)","Fatal error");
// void TQObject::Emit(const char *signal_name, Long_t *paramArr)
TQObject *processor; // data processor
TH1F *hist; // filled with processor results
processor->Connect("Evaluated(Float_t,Float_t)",
"TH1F",hist,"Fill12(Axis_t,Axis_t)");
Long_t args[2];
args[0] = (Long_t)processor->GetValue(1);
args[1] = (Long_t)processor->GetValue(2);
processor->Emit("Evaluated(Float_t,Float_t)",args);
// Bool_t TQObject::Connect(TQObject *sender,
// const char *signal,
// const char *cl,
// void *receiver,
// const char *slot)
/// cl != 0 - class name, it can be class with or
/// without dictionary, e.g interpreted class.
TGButton *myButton;
TH2F *myHist;
TQObject::Connect(myButton,"Clicked()",
"TH2F", myHist,"Draw(Option_t*)");
/// cl == 0 - corresponds to function (interpereted or global)
/// the name of the function is defined by the slot string,
/// parameter receiver should be 0.
TGButton *myButton;
TH2F *myHist;
TQObject::Connect(myButton,"Clicked()",
0, 0,"hsimple()");
// Bool_t TQObject::Connect(const char *class_name,
// const char *signal,
// const char *cl,
// void *receiver,
// const char *slot)
/// cl != 0 - class name, it can be class with or
/// without dictionary, e.g interpreted class.
TGButton *myButton;
TH2F *myHist;
TQObject::Connect("TGButton", "Clicked()",
"TH2F", myHist, "Draw(Option_t*)");
/// cl == 0 - corresponds to function (interpereted or global)
/// the name of the function is defined by the slot string,
/// parameter receiver should be 0.
TGButton *myButton;
TH2F *myHist;
TQObject::Connect("TGButton", "Clicked()",
0, 0, "hsimple()");