TQObject

 Checking of consitency of sender/receiver methods/arguments.
 Returns -1 on error, otherwise number or arguments of signal function.
 Static method.

 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

 TQObject Destructor.
    - delete all connections and signal list

 Returns pointer to list of signals of this class.

 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.

 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.

 Return true if there is any object connected to this signal.
 Only checks for object signals.

 Return number of signals for this object.

 Return number of connections for this object.

 Acitvate signal without args.
 Example:
          theButton->Emit("Clicked()");

 Activate signal with variable argument list.
 Example:
          theButton->EmitVA("Clicked(int,float)", 2, id, fid)

 Activate signal with variable argument list.
 For internal use and for var arg EmitVA() in RQ_OBJECT.h.

 Activate signal with single parameter.
 Example:
          theButton->Emit("Clicked(int)",id)

 Activate signal with single parameter.
 Example:
          theButton->Emit("Progress(Long64_t)",processed)

 Activate signal with single parameter.
 Example:
          theButton->Emit("Scale(float)",factor)

 Activate signal with parameter text string.
 Example:
          myObject->Emit("Error(char*)","Fatal error");

 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.
 Example:
    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);

 Create connection between sender and receiver.
 Receiver class needs to have a dictionary.

 This method allows to make connection from any object
 of the same class to the receiver object.
 Receiver class needs to have a dictionary.

 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,

 cl != 0 - class name, it can be class with or
           without dictionary, e.g interpreted class.
 Example:
       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.
 Example:
       TGButton *myButton;
       TH2F     *myHist;

       TQObject::Connect(myButton,"Clicked()",
                         0, 0,"hsimple()");

 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.

 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,

 cl != 0 - class name, it can be class with or
           without dictionary, e.g interpreted class.
 Example:
       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.
 Example:
       TGButton *myButton;
       TH2F     *myHist;

       TQObject::Connect("TGButton", "Clicked()",
                         0, 0, "hsimple()");

 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.

 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.

 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.

 Disconnects "class signal". The class is defined by class_name.
 See also Connect(class_name,signal,receiver,slot).

 Disconnects signal of this object from slot of receiver.
 Equivalent to Disconnect(this, signal, receiver, slot)

 Stream an object of class TQObject.

 Load RQ_OBJECT.h which contains the #define RQ_OBJECT needed to
 let interpreted classes connect to signals of compiled classes.