// @(#)root/base:$Id: 5d6810ad46b864564f576f88aa9b154789d91d48 $
// Author: Valeriy Onuchin & Fons Rademakers   15/10/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// This is the ROOT implementation of the Qt object communication       //
// mechanism (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 interesting     //
// for the outside world, it emits a signal to tell whoever is          //
// listening. All slots that are connected to this signal will be       //
// activated (called). It is even possible to connect a signal          //
// directly to another signal (this will emit the second signal         //
// immediately whenever the first is emitted.) There is no limitation   //
// on the number of slots that can be connected to a signal.            //
// The slots will be activated in the order they were connected         //
// to the signal. This mechanism allows objects to be easily reused,    //
// because the object that emits a signal does not need to know         //
// to which objects the signals are connected.                          //
// Together, signals and slots make up a powerfull component            //
// programming mechanism.                                               //
//                                                                      //
// This implementation is provided by                                   //
// Valeriy Onuchin (onuchin@sirius.ihep.su).                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//***************************** Signals *****************************
//___________________________________________________________________
//
//             Destroyed()
//
// Signal emitted when object is destroyed.
// This signal could be connected to some garbage-collector object.
//
//___________________________________________________________________
//
//             ChangedBy(const char *method_name)
//
// This signal is emitted when some important data members of
// the object were changed. method_name parameter can be used
// as an identifier of the modifier method.
//
//___________________________________________________________________
//
//             Message(const char *msg)
//
// General purpose message signal
//
/////////////////////////////////////////////////////////////////////

#include "Varargs.h"
#include "TQObject.h"
#include "TQConnection.h"
#include "THashList.h"
#include "TPRegexp.h"
#include "TROOT.h"
#include "TClass.h"
#include "TSystem.h"
#include "TMethod.h"
#include "TBaseClass.h"
#include "TDataType.h"
#include "TInterpreter.h"
#include "TQClass.h"
#include "TError.h"
#include "Riostream.h"
#include "RQ_OBJECT.h"
#include "TVirtualMutex.h"
#include "Varargs.h"
#include "TInterpreter.h"
#include "RConfigure.h"

void *gTQSender; // A pointer to the object that sent the last signal.
                 // Getting access to the sender might be practical
                 // when many signals are connected to a single slot.

Bool_t TQObject::fgAllSignalsBlocked = kFALSE;


ClassImpQ(TQObject)
ClassImpQ(TQObjSender)
ClassImpQ(TQClass)

////////////////////////////// internal functions //////////////////////////////

//______________________________________________________________________________
TString TQObject::CompressName(const char *method_name)
{
   // Removes "const" words and blanks from full (with prototype)
   // method name and resolve any typedefs in the method signature.
   // If a null or empty string is passed in, an empty string
   // is returned.
   //
   // Example: CompressName(" Draw(const char *, const char *,
   //                              Option_t * , Int_t , Int_t)");
   // returns the string "Draw(char*,char*,char*,int,int)".

   TString res(method_name);
   if (res.IsNull())
      return res;

   {
      static TVirtualMutex *  lock = 0;
      R__LOCKGUARD2(lock);

      static TPMERegexp *constRe = 0, *wspaceRe = 0;
      if (constRe == 0) {
         constRe  = new TPMERegexp("(?<=\\(|\\s|,|&|\\*)const(?=\\s|,|\\)|&|\\*)", "go");
         wspaceRe = new TPMERegexp("\\s+", "go");
      }
      constRe ->Substitute(res, "");
      wspaceRe->Substitute(res, "");
   }

   TStringToken methargs(res, "\\(|\\)", kTRUE);

   methargs.NextToken();
   res = methargs;
   res += "(";

   methargs.NextToken();
   TStringToken arg(methargs, ",");
   while (arg.NextToken())
   {
      Int_t  pri = arg.Length() - 1;
      Char_t prc = 0;
      if (arg[pri] == '*' || arg[pri] == '&') {
         prc = arg[pri];
         arg.Remove(pri);
      }
      TDataType *dt = gROOT->GetType(arg.Data());
      if (dt) {
         res += dt->GetFullTypeName();
      } else {
         res += arg;
      }
      if (prc)          res += prc;
      if (!arg.AtEnd()) res += ",";
   }
   res += ")";
   return res;
}

namespace {

//______________________________________________________________________________
TMethod *GetMethodWithPrototype(TClass *cl, const char *method,
                                const char *proto, Int_t &nargs)
{
   // Almost the same as TClass::GetMethodWithPrototype().

   nargs = 0;

   if (!gInterpreter || cl == 0) return 0;

   TMethod *m = cl->GetMethodWithPrototype(method,proto);
   if (m) nargs = m->GetNargs();
   return m;
}

//______________________________________________________________________________
static TMethod *GetMethod(TClass *cl, const char *method, const char *params)
{
   // Almost the same as TClass::GetMethod().

   if (!gInterpreter || cl == 0) return 0;
   return cl->GetMethod(method,params);
}

}
////////////////////////// end of internal functions ///////////////////////////


//______________________________________________________________________________
Int_t TQObject::CheckConnectArgs(TQObject *sender,
                                 TClass *sender_class, const char *signal,
                                 TClass *receiver_class, const char *slot)
{
   // Checking of consitency of sender/receiver methods/arguments.
   // Returns -1 on error, otherwise number or arguments of signal function.
   // Static method.

   char *signal_method = new char[strlen(signal)+1];
   if (signal_method) strcpy(signal_method, signal);

   char *signal_proto;
   char *tmp;

   if ((signal_proto = strchr(signal_method,'('))) {
      // substitute first '(' symbol with '\0'
      *signal_proto++ = '\0';
      // substitute last ')' symbol with '\0'
      if ((tmp = strrchr(signal_proto,')'))) *tmp = '\0';
   }

   if (!signal_proto) signal_proto = (char*)""; // avoid zero strings

   // if delegation object TQObjSender is used get the real sender class
   if (sender && sender_class == TQObjSender::Class()) {
      sender_class = TClass::GetClass(sender->GetSenderClassName());
      if (!sender_class) {
         ::Error("TQObject::CheckConnectArgs", "for signal/slot consistency\n"
                 "checking need to specify class name as argument to "
                 "RQ_OBJECT macro");
         delete [] signal_method;
         return -1;
      }
   }

   Int_t nargs;
   TMethod *signalMethod = GetMethodWithPrototype(sender_class,
                                                  signal_method,
                                                  signal_proto,
                                                  nargs);
   if (!signalMethod) {
      ::Error("TQObject::CheckConnectArgs",  "signal %s::%s(%s) does not exist",
              sender_class->GetName(), signal_method, signal_proto);
      delete [] signal_method;
      return -1;
   }
   Int_t nsigargs = nargs;

#if defined(CHECK_COMMENT_STRING)
   const char *comment = 0;
   if (signalMethod != (TMethod *) -1)   // -1 in case of interpreted class
      comment = signalMethod->GetCommentString();

   if (!comment || !comment[0] || strstr(comment,"*SIGNAL")){
      ::Error("TQObject::CheckConnectArgs",
              "signal %s::%s(%s), to declare signal use comment //*SIGNAL*",
      sender_class->GetName(), signal_method, signal_proto);
      delete [] signal_method;
      return -1;
   }
#endif

   // cleaning
   delete [] signal_method;

   char *slot_method = new char[strlen(slot)+1];
   if (slot_method) strcpy(slot_method, slot);

   char *slot_proto;
   char *slot_params = 0;

   if ((slot_proto = strchr(slot_method,'('))) {

      // substitute first '(' symbol with '\0'
      *slot_proto++ = '\0';

      // substitute last ')' symbol with '\0'
      if ((tmp = strrchr(slot_proto,')'))) *tmp = '\0';
   }

   if (!slot_proto) slot_proto = (char*)"";     // avoid zero strings
   if ((slot_params = strchr(slot_proto,'='))) *slot_params = ' ';

   TFunction *slotMethod = 0;
   if (!receiver_class) {
      // case of slot_method is compiled/intrepreted function
      slotMethod = gROOT->GetGlobalFunction(slot_method,0,kFALSE);
   } else {
      slotMethod  = !slot_params ?
                          GetMethodWithPrototype(receiver_class,
                                                 slot_method,
                                                 slot_proto,
                                                 nargs) :
                          GetMethod(receiver_class,
                                    slot_method, slot_params);
   }

   if (!slotMethod) {
      if (!slot_params) {
         ::Error("TQObject::CheckConnectArgs", "slot %s(%s) does not exist",
                 receiver_class ? Form("%s::%s", receiver_class->GetName(),
                 slot_method) : slot_method, slot_proto);
      } else {
         ::Error("TQObject::CheckConnectArgs", "slot %s(%s) does not exist",
                 receiver_class ? Form("%s::%s", receiver_class->GetName(),
                 slot_method) : slot_method, slot_params);
      }
      delete [] slot_method;
      return -1;
   }

#if defined(CHECK_ARGS_NUMBER)
   if (slotMethod != (TMethod *) -1 && slotMethod->GetNargsOpt() >= 0 &&
       nsigargs < (slotMethod->GetNargs() - slotMethod->GetNargsOpt())) {
      ::Error("TQObject::CheckConnectArgs",
              "inconsistency in numbers of arguments");
      delete [] slot_method;
      return -1;
   }
#endif

   // cleaning
   delete [] slot_method;

   return nsigargs;
}

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//    TQConnectionList is the named list of connections,                      //
//    see also TQConnection class.                                            //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
class TQConnectionList : public TList {

private:
   Int_t   fSignalArgs;    // number of arguments in signal function

public:
   TQConnectionList(const char *name, Int_t nsigargs) : TList()
      { fName = name; fSignalArgs = nsigargs; }
   virtual ~TQConnectionList();

   Bool_t Disconnect(void *receiver=0, const char *slot_name=0);
   Int_t  GetNargs() const { return fSignalArgs; }
   void   ls(Option_t *option = "") const;
};

//______________________________________________________________________________
TQConnectionList::~TQConnectionList()
{
   // Destructor.

   TIter next(this);
   TQConnection *connection;

   while ((connection = (TQConnection*)next())) {
      // remove this from feed back reference list
      connection->Remove(this);
      if (connection->IsEmpty()) delete connection;
   }
   Clear("nodelete");
}

//______________________________________________________________________________
Bool_t TQConnectionList::Disconnect(void *receiver, const char *slot_name)
{
   // Remove connection from the list. For more info see
   // TQObject::Disconnect()

   TQConnection *connection = 0;
   Bool_t return_value = kFALSE;

   TObjLink *lnk = FirstLink();
   TObjLink *savlnk; // savlnk is used when link is deleted

   while (lnk) {
      connection = (TQConnection*)lnk->GetObject();
      const char *name = connection->GetName();
      void *obj = connection->GetReceiver();

      if (!slot_name || !slot_name[0]
                     || !strcmp(name,slot_name)) {

         if (!receiver || (receiver == obj)) {
            return_value = kTRUE;
            savlnk = lnk->Next();   // keep next link ..
            Remove(lnk);
            lnk = savlnk;           // current link == saved ...
            connection->Remove(this);      // remove back reference
            if (connection->IsEmpty()) SafeDelete(connection);
            continue;               // .. continue from saved link
         }
      }
      lnk = lnk->Next();
   }
   return return_value;
}

//______________________________________________________________________________
void TQConnectionList::ls(Option_t *option) const
{
   // List signal name and list all connections in this signal list.

   std::cout <<  "TQConnectionList:" << "\t" << GetName() << std::endl;
   ((TQConnectionList*)this)->R__FOR_EACH(TQConnection,Print)(option);
}


//______________________________________________________________________________
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

   fListOfSignals     = 0;
   fListOfConnections = 0;
   fSignalsBlocked    = kFALSE;
}

//______________________________________________________________________________
TQObject::~TQObject()
{
   // TQObject Destructor.
   //    - delete all connections and signal list

   if (!gROOT) return;

   Destroyed();   // emit "Destroyed()" signal

   if (fListOfSignals) {
      fListOfSignals->Delete();
      SafeDelete(fListOfSignals);   // delete list of signals
   }

   // loop over all connections and remove references to this object
   if (fListOfConnections) {
      TIter next_connection(fListOfConnections);
      TQConnection *connection;

      while ((connection = (TQConnection*)next_connection())) {
         TIter next_list(connection);
         TQConnectionList *list;
         while ((list = (TQConnectionList*)next_list())) {
            list->Remove(connection);
            if (list->IsEmpty()) SafeDelete(list);
         }
      }
      SafeDelete(fListOfConnections);
   }
}

//______________________________________________________________________________
TList *TQObject::GetListOfClassSignals() const
{
   // Returns pointer to list of signals of this class.

   TQClass *qcl = 0;

   qcl = dynamic_cast<TQClass*>(IsA());

   return qcl ? qcl->fListOfSignals : 0; //!!
}

//______________________________________________________________________________
void TQObject::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.

   TQClass *qcl = dynamic_cast<TQClass*>(cls);
   if (qcl)
   {
      if (qcl->fListOfSignals)
         list.Add(qcl->fListOfSignals);

      // Descend into base-classes.
      TIter       next_base_class(cls->GetListOfBases());
      TBaseClass *base;
      while ((base = (TBaseClass*) next_base_class()))
      {
         CollectClassSignalLists(list, base->GetClassPointer());
      }
   }
}

//______________________________________________________________________________
void TQObject::HighPriority(const char *signal_name, const char *slot_name)
{
   // 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.

   TQConnectionList *clist = (TQConnectionList*)
      fListOfSignals->FindObject(signal_name);

   if (!clist)  return;      // not found
   if (!slot_name)  {        // update list of signal lists
      fListOfSignals->Remove(clist);   // remove and add first
      fListOfSignals->AddFirst(clist);
      return;
   } else {                   // slot_name != 0 , update signal list
      TQConnection *con = (TQConnection*) clist->FindObject(slot_name);
      if (!con) return;       // not found
      clist->Remove(con);     // remove and add as first
      clist->AddFirst(con);
   }
}

//______________________________________________________________________________
void TQObject::LowPriority(const char *signal_name, const char *slot_name)
{
   // 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.

   TQConnectionList *clist = (TQConnectionList*)
      fListOfSignals->FindObject(signal_name);

   if (!clist)   return;
   if (!slot_name)  {
      fListOfSignals->Remove(clist);   // remove and add first
      fListOfSignals->AddLast(clist);
      return;
   } else  {                  // slot_name != 0 , update signal list
      TQConnection *con = (TQConnection*) clist->FindObject(slot_name);
      if (!con) return;
      clist->Remove(con);     // remove and add as last
      clist->AddLast(con);
   }
}

//______________________________________________________________________________
Bool_t TQObject::HasConnection(const char *signal_name) const
{
   // Return true if there is any object connected to this signal.
   // Only checks for object signals.

   if (!fListOfSignals)
      return kFALSE;

   TString signal = CompressName(signal_name);

   return (fListOfSignals->FindObject(signal) != 0);
}

//______________________________________________________________________________
Int_t TQObject::NumberOfSignals() const
{
   // Return number of signals for this object.
   // Only checks for object signals.

   if (fListOfSignals)
      return fListOfSignals->GetSize();
   return 0;
}

//______________________________________________________________________________
Int_t TQObject::NumberOfConnections() const
{
   // Return number of connections for this object.

   if (fListOfConnections)
      return fListOfConnections->GetSize();
   return 0;
}

//______________________________________________________________________________
void TQObject::Emit(const char *signal_name)
{
   // Acitvate signal without args.
   // Example:
   //          theButton->Emit("Clicked()");

   if (fSignalsBlocked || fgAllSignalsBlocked) return;

   TList classSigLists;
   CollectClassSignalLists(classSigLists, IsA());

   if (classSigLists.IsEmpty() && !fListOfSignals)
      return;

   TString signal = CompressName(signal_name);

   TQConnection *connection = 0;

   // execute class signals
   TList *sigList;
   TIter  nextSigList(&classSigLists);
   while ((sigList = (TList*) nextSigList()))
   {
      TIter nextcl((TQConnectionList*) sigList->FindObject(signal));
      while ((connection = (TQConnection*)nextcl())) {
         gTQSender = GetSender();
         connection->ExecuteMethod();
      }
   }
   if (!fListOfSignals)
      return;

   // execute object signals
   TIter next((TQConnectionList*) fListOfSignals->FindObject(signal));
   while (fListOfSignals && (connection = (TQConnection*)next())) {
      gTQSender = GetSender();
      connection->ExecuteMethod();
   }
}

//______________________________________________________________________________
void TQObject::Emit(const char *signal_name, Long_t param)
{
   // Activate signal with single parameter.
   // Example:
   //          theButton->Emit("Clicked(int)",id)

   if (fSignalsBlocked || fgAllSignalsBlocked) return;

   TList classSigLists;
   CollectClassSignalLists(classSigLists, IsA());

   if (classSigLists.IsEmpty() && !fListOfSignals)
      return;

   TString signal = CompressName(signal_name);

   TQConnection *connection = 0;

   // execute class signals
   TList *sigList;
   TIter  nextSigList(&classSigLists);
   while ((sigList = (TList*) nextSigList()))
   {
      TIter nextcl((TQConnectionList*) sigList->FindObject(signal));
      while ((connection = (TQConnection*)nextcl())) {
         gTQSender = GetSender();
         connection->ExecuteMethod(param);
      }
   }
   if (!fListOfSignals)
      return;

   // execute object signals
   TIter next((TQConnectionList*) fListOfSignals->FindObject(signal));
   while (fListOfSignals && (connection = (TQConnection*)next())) {
      gTQSender = GetSender();
      connection->ExecuteMethod(param);
   }
}

//______________________________________________________________________________
void TQObject::Emit(const char *signal_name, Long64_t param)
{
   // Activate signal with single parameter.
   // Example:
   //          theButton->Emit("Progress(Long64_t)",processed)

   if (fSignalsBlocked || fgAllSignalsBlocked) return;

   TList classSigLists;
   CollectClassSignalLists(classSigLists, IsA());

   if (classSigLists.IsEmpty() && !fListOfSignals)
      return;

   TString signal = CompressName(signal_name);

   TQConnection *connection = 0;

   // execute class signals
   TList *sigList;
   TIter  nextSigList(&classSigLists);
   while ((sigList = (TList*) nextSigList()))
   {
      TIter nextcl((TQConnectionList*) sigList->FindObject(signal));
      while ((connection = (TQConnection*)nextcl())) {
         gTQSender = GetSender();
         connection->ExecuteMethod(param);
      }
   }
   if (!fListOfSignals)
      return;

   // execute object signals
   TIter next((TQConnectionList*) fListOfSignals->FindObject(signal));
   while (fListOfSignals && (connection = (TQConnection*)next())) {
      gTQSender = GetSender();
      connection->ExecuteMethod(param);
   }
}

//______________________________________________________________________________
void TQObject::Emit(const char *signal_name, Double_t param)
{
   // Activate signal with single parameter.
   // Example:
   //          theButton->Emit("Scale(float)",factor)

   if (fSignalsBlocked || fgAllSignalsBlocked) return;

   TList classSigLists;
   CollectClassSignalLists(classSigLists, IsA());

   if (classSigLists.IsEmpty() && !fListOfSignals)
      return;

   TString signal = CompressName(signal_name);

   TQConnection *connection = 0;

   // execute class signals
   TList *sigList;
   TIter  nextSigList(&classSigLists);
   while ((sigList = (TList*) nextSigList()))
   {
      TIter nextcl((TQConnectionList*) sigList->FindObject(signal));
      while ((connection = (TQConnection*)nextcl())) {
         gTQSender = GetSender();
         connection->ExecuteMethod(param);
      }
   }
   if (!fListOfSignals)
      return;

   // execute object signals
   TIter next((TQConnectionList*) fListOfSignals->FindObject(signal));
   while (fListOfSignals && (connection = (TQConnection*)next())) {
      gTQSender = GetSender();
      connection->ExecuteMethod(param);
   }
}

//______________________________________________________________________________
void TQObject::Emit(const char *signal_name, const char *params)
{
   // Activate signal with parameter text string.
   // Example:
   //          myObject->Emit("Error(char*)","Fatal error");

   if (fSignalsBlocked || fgAllSignalsBlocked) return;

   TList classSigLists;
   CollectClassSignalLists(classSigLists, IsA());

   if (classSigLists.IsEmpty() && !fListOfSignals)
      return;

   TString signal = CompressName(signal_name);

   TQConnection *connection = 0;

   // execute class signals
   TList *sigList;
   TIter  nextSigList(&classSigLists);
   while ((sigList = (TList*) nextSigList()))
   {
      TIter nextcl((TQConnectionList*) sigList->FindObject(signal));
      while ((connection = (TQConnection*)nextcl())) {
         gTQSender = GetSender();
         connection->ExecuteMethod(params);
      }
   }
   if (!fListOfSignals)
      return;

   // execute object signals
   TIter next((TQConnectionList*) fListOfSignals->FindObject(signal));
   while (fListOfSignals && (connection = (TQConnection*)next())) {
      gTQSender = GetSender();
      connection->ExecuteMethod(params);
   }
}

//______________________________________________________________________________
void TQObject::Emit(const char *signal_name, 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.
   // 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);

   if (fSignalsBlocked || fgAllSignalsBlocked) return;

   TList classSigLists;
   CollectClassSignalLists(classSigLists, IsA());

   if (classSigLists.IsEmpty() && !fListOfSignals)
      return;

   TString signal = CompressName(signal_name);

   TQConnectionList *clist  = 0;
   TQConnection *connection = 0;

   // execute class signals
   TList *sigList;
   TIter  nextSigList(&classSigLists);
   while ((sigList = (TList*) nextSigList()))
   {
      clist = (TQConnectionList*) sigList->FindObject(signal);
      TIter nextcl(clist);
      while ((connection = (TQConnection*)nextcl())) {
         gTQSender = GetSender();
         connection->ExecuteMethod(paramArr, clist->GetNargs());
      }
   }
   if (!fListOfSignals)
      return;

   // execute object signals
   clist = (TQConnectionList*) fListOfSignals->FindObject(signal);
   TIter next(clist);
   while (fListOfSignals && (connection = (TQConnection*)next())) {
      gTQSender = GetSender();
      connection->ExecuteMethod(paramArr, clist->GetNargs());
   }
}

//______________________________________________________________________________
Bool_t TQObject::ConnectToClass(TQObject *sender,
                                const char *signal,
                                TClass *cl,
                                void *receiver,
                                const char *slot)
{
   // Create connection between sender and receiver.
   // Receiver class needs to have a dictionary.

   // sender should be TQObject
   if (!sender->IsA()->InheritsFrom(TQObject::Class()))
      return kFALSE;

   // remove "const" and strip blanks
   TString signal_name = CompressName(signal);
   TString slot_name   = CompressName(slot);

   // check consitency of signal/slot methods/args
   Int_t nsigargs;
   if ((nsigargs = CheckConnectArgs(sender, sender->IsA(), signal_name, cl, slot_name)) == -1)
      return kFALSE;

   if (!sender->fListOfSignals)
      sender->fListOfSignals = new THashList();

   TQConnectionList *clist = (TQConnectionList*)
      sender->fListOfSignals->FindObject(signal_name);

   if (!clist) {
      clist = new TQConnectionList(signal_name, nsigargs);
      sender->fListOfSignals->Add(clist);
   }

   TIter next(clist);
   TQConnection *connection = 0;

   while ((connection = (TQConnection*)next())) {
      if (!strcmp(slot_name,connection->GetName()) &&
          (receiver == connection->GetReceiver())) break;
   }

   if (!connection)
      connection = new TQConnection(cl, receiver, slot_name);

   // check to prevent multiple entries
   if (!clist->FindObject(connection)) {
      clist->Add(connection);
      if (!connection->FindObject(clist)) connection->Add(clist);
      sender->Connected(signal_name);
   }

   return kTRUE;
}

//______________________________________________________________________________
Bool_t TQObject::ConnectToClass(const char *class_name,
                                const char *signal,
                                TClass *cl,
                                void *receiver,
                                const char *slot)
{
   // This method allows to make connection from any object
   // of the same class to the receiver object.
   // Receiver class needs to have a dictionary.

   TClass *sender = TClass::GetClass(class_name);

   // sender class should be TQObject (i.e. TQClass)
   if (!sender || !sender->IsA()->InheritsFrom(TQObject::Class()))
      return kFALSE;

   TList *slist = ((TQClass*)sender)->fListOfSignals;
   TString signal_name = CompressName(signal);
   TString slot_name   = CompressName(slot);

   // check consitency of signal/slot methods/args
   Int_t nsigargs;
   if ((nsigargs = CheckConnectArgs(0, sender, signal_name, cl, slot_name)) == -1)
      return kFALSE;

   if (!slist)
      ((TQClass*)sender)->fListOfSignals = slist = new THashList();

   TQConnectionList *clist = (TQConnectionList*) slist->FindObject(signal_name);

   if (!clist) {
      clist = new TQConnectionList(signal_name, nsigargs);
      slist->Add(clist);
   }

   TQConnection *connection = 0;
   TIter next(clist);

   while ((connection = (TQConnection*)next())) {
      if (!strcmp(slot_name,connection->GetName()) &&
          (receiver == connection->GetReceiver())) break;
   }

   if (!connection)
      connection = new TQConnection(cl, receiver, slot_name);

   // check to prevent multiple entries
   if (!clist->FindObject(connection)) {
      clist->Add(connection);
      if (!connection->FindObject(clist)) connection->Add(clist);
      ((TQClass*)sender)->Connected(signal_name);
   }

   return kTRUE;
}

//______________________________________________________________________________
Bool_t TQObject::Connect(TQObject *sender,
                         const char *signal,
                         const char *cl,
                         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,
   //
   // 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.

   if (cl) {
      TClass *rcv_cl = TClass::GetClass(cl);
      if (rcv_cl) return ConnectToClass(sender, signal, rcv_cl, receiver, slot);
   }

   // the following is the case of receiver class without dictionary
   // e.g. interpreted class or function.

   // sender should be TQObject
   if (!sender->IsA()->InheritsFrom(TQObject::Class()))
      return kFALSE;

   // remove "const" and strip blanks
   TString signal_name = CompressName(signal);
   TString slot_name   = CompressName(slot);

   // check consitency of signal/slot methods/args
   Int_t nsigargs;
   if ((nsigargs = CheckConnectArgs(sender, sender->IsA(), signal_name, 0, slot_name)) == -1)
      return kFALSE;

   if (!sender->fListOfSignals) sender->fListOfSignals = new THashList();

   TQConnectionList *clist = (TQConnectionList*)
      sender->fListOfSignals->FindObject(signal_name);

   if (!clist) {
      clist = new TQConnectionList(signal_name, nsigargs);
      sender->fListOfSignals->Add(clist);
   }

   TQConnection *connection = 0;
   TIter next(clist);

   while ((connection = (TQConnection*)next())) {
      if (!strcmp(slot_name,connection->GetName()) &&
          (receiver == connection->GetReceiver())) break;
   }

   if (!connection)
      connection = new TQConnection(cl, receiver, slot_name);

   // check to prevent multiple entries
   if (!clist->FindObject(connection)) {
      clist->Add(connection);
      if (!connection->FindObject(clist)) connection->Add(clist);
      sender->Connected(signal_name);
   }

   return kTRUE;
}

//______________________________________________________________________________
Bool_t TQObject::Connect(const char *class_name,
                         const char *signal,
                         const char *cl,
                         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,
   //
   // 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.

   if (cl) {
      TClass *rcv_cl = TClass::GetClass(cl);
      if (rcv_cl) return ConnectToClass(class_name, signal, rcv_cl, receiver,
                                        slot);
   }

   // the following is case of receiver class without dictionary
   // e.g. interpreted class or function.

   TClass *sender = TClass::GetClass(class_name);

   // sender class should be TQObject (i.e. TQClass)
   if (!sender || !sender->IsA()->InheritsFrom(TQObject::Class()))
      return kFALSE;

   TList *slist = ((TQClass*)sender)->fListOfSignals;

   TString signal_name = CompressName(signal);
   TString slot_name   = CompressName(slot);

   // check consitency of signal/slot methods/args
   Int_t nsigargs;
   if ((nsigargs = CheckConnectArgs(0, sender, signal_name, 0, slot_name)) == -1)
      return kFALSE;

   if (!slist) {
      slist = ((TQClass*)sender)->fListOfSignals = new THashList();
   }

   TQConnectionList *clist = (TQConnectionList*)
      slist->FindObject(signal_name);

   if (!clist) {
      clist = new TQConnectionList(signal_name, nsigargs);
      slist->Add(clist);
   }

   TQConnection *connection = 0;
   TIter next(clist);

   while ((connection = (TQConnection*)next())) {
      if (!strcmp(slot_name,connection->GetName()) &&
          (receiver == connection->GetReceiver())) break;
   }

   if (!connection)
      connection = new TQConnection(cl, receiver, slot_name);

   // check to prevent multiple entries
   if (!clist->FindObject(connection)) {
      clist->Add(connection);
      if (!connection->FindObject(clist)) connection->Add(clist);
      ((TQClass*)sender)->Connected(signal_name);
   }

   return kTRUE;
}

//______________________________________________________________________________
Bool_t TQObject::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.

   // remove "const" and strip blanks
   TString signal_name = CompressName(signal);
   TString slot_name   = CompressName(slot);

   // check consitency of signal/slot methods/args
   TClass *cl = 0;
   if (receiver_class)
      cl = TClass::GetClass(receiver_class);
   Int_t nsigargs;
   if ((nsigargs = CheckConnectArgs(this, IsA(), signal_name, cl, slot_name)) == -1)
      return kFALSE;

   if (!fListOfSignals) fListOfSignals = new THashList();

   TQConnectionList *clist = (TQConnectionList*)
      fListOfSignals->FindObject(signal_name);

   if (!clist) {
      clist = new TQConnectionList(signal_name, nsigargs);
      fListOfSignals->Add(clist);
   }

   TIter next(clist);
   TQConnection *connection = 0;

   while ((connection = (TQConnection*)next())) {
      if (!strcmp(slot_name,connection->GetName()) &&
          (receiver == connection->GetReceiver())) break;
   }

   if (!connection)
      connection = new TQConnection(receiver_class, receiver, slot_name);

   // check to prevent multiple entries
   if (!clist->FindObject(connection)) {
      clist->Add(connection);
      if (!connection->FindObject(clist)) connection->Add(clist);
      Connected(signal_name);
   }

   return kTRUE;
}

//______________________________________________________________________________
Bool_t TQObject::Disconnect(TQObject *sender,
                            const char *signal,
                            void *receiver,
                            const char *slot)
{
   // 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.

   Bool_t return_value = kFALSE;
   Bool_t next_return  = kFALSE;

   if (!sender->GetListOfSignals()) return kFALSE;

   TString signal_name = CompressName(signal);
   TString slot_name   = CompressName(slot);

   TQConnectionList *slist = 0;
   TIter next_signal(sender->GetListOfSignals());

   while ((slist = (TQConnectionList*)next_signal()))   {
      if (!signal || signal_name.IsNull()) { // disconnect all signals
         next_return = slist->Disconnect(receiver,slot_name);
         return_value = return_value || next_return;

         if (slist->IsEmpty()) {
            sender->GetListOfSignals()->Remove(slist);
            SafeDelete(slist);            // delete empty list
         }
      } else if (signal && !strcmp(signal_name,slist->GetName())) {
         next_return = slist->Disconnect(receiver,slot_name);
         return_value = return_value || next_return;

         if (slist->IsEmpty()) {
            sender->GetListOfSignals()->Remove(slist);
            SafeDelete(slist);            // delete empty list
            break;
         }
      }
   }

   if (sender->GetListOfSignals() && sender->GetListOfSignals()->IsEmpty()) {
      SafeDelete(sender->fListOfSignals);
   }

   return return_value;
}

//______________________________________________________________________________
Bool_t TQObject::Disconnect(const char *class_name,
                            const char *signal,
                            void *receiver,
                            const char *slot)
{
   // Disconnects "class signal". The class is defined by class_name.
   // See also Connect(class_name,signal,receiver,slot).

   TClass *sender = TClass::GetClass(class_name);

   // sender should be TQClass (which derives from TQObject)
   if (!sender->IsA()->InheritsFrom(TQObject::Class()))
      return kFALSE;

   TQClass *qcl = (TQClass*)sender;   // cast TClass to TQClass
   return Disconnect(qcl, signal, receiver, slot);
}

//______________________________________________________________________________
Bool_t TQObject::Disconnect(const char *signal,
                            void *receiver,
                            const char *slot)
{
   // Disconnects signal of this object from slot of receiver.
   // Equivalent to Disconnect(this, signal, receiver, slot)

   return Disconnect(this, signal, receiver, slot);
}

//______________________________________________________________________________
void TQObject::Streamer(TBuffer &R__b)
{
   // Stream an object of class TQObject.

   if (R__b.IsReading()) {
      // nothing to read
   } else {
      // nothing to write
   }
}

//______________________________________________________________________________
Bool_t TQObject::AreAllSignalsBlocked()
{
   // Returns true if all signals are blocked.

   return fgAllSignalsBlocked;
}

//______________________________________________________________________________
Bool_t TQObject::BlockAllSignals(Bool_t b)
{
   // Block or unblock all signals. Returns the previous block status.

   Bool_t ret = fgAllSignalsBlocked;
   fgAllSignalsBlocked = b;
   return ret;
}

// Global function which simplifies making connection in interpreted
// ROOT session
//
//  ConnectCINT      - connects to interpreter(CINT) command

//______________________________________________________________________________
Bool_t ConnectCINT(TQObject *sender, const char *signal, const char *slot)
{
   TString str = "ProcessLine(=";
   str += '"';
   str += slot;
   str += '"';
   str += ")";
   return TQObject::Connect(sender, signal, "TInterpreter",
                            gInterpreter, str.Data());
}
 TQObject.cxx:1
 TQObject.cxx:2
 TQObject.cxx:3
 TQObject.cxx:4
 TQObject.cxx:5
 TQObject.cxx:6
 TQObject.cxx:7
 TQObject.cxx:8
 TQObject.cxx:9
 TQObject.cxx:10
 TQObject.cxx:11
 TQObject.cxx:12
 TQObject.cxx:13
 TQObject.cxx:14
 TQObject.cxx:15
 TQObject.cxx:16
 TQObject.cxx:17
 TQObject.cxx:18
 TQObject.cxx:19
 TQObject.cxx:20
 TQObject.cxx:21
 TQObject.cxx:22
 TQObject.cxx:23
 TQObject.cxx:24
 TQObject.cxx:25
 TQObject.cxx:26
 TQObject.cxx:27
 TQObject.cxx:28
 TQObject.cxx:29
 TQObject.cxx:30
 TQObject.cxx:31
 TQObject.cxx:32
 TQObject.cxx:33
 TQObject.cxx:34
 TQObject.cxx:35
 TQObject.cxx:36
 TQObject.cxx:37
 TQObject.cxx:38
 TQObject.cxx:39
 TQObject.cxx:40
 TQObject.cxx:41
 TQObject.cxx:42
 TQObject.cxx:43
 TQObject.cxx:44
 TQObject.cxx:45
 TQObject.cxx:46
 TQObject.cxx:47
 TQObject.cxx:48
 TQObject.cxx:49
 TQObject.cxx:50
 TQObject.cxx:51
 TQObject.cxx:52
 TQObject.cxx:53
 TQObject.cxx:54
 TQObject.cxx:55
 TQObject.cxx:56
 TQObject.cxx:57
 TQObject.cxx:58
 TQObject.cxx:59
 TQObject.cxx:60
 TQObject.cxx:61
 TQObject.cxx:62
 TQObject.cxx:63
 TQObject.cxx:64
 TQObject.cxx:65
 TQObject.cxx:66
 TQObject.cxx:67
 TQObject.cxx:68
 TQObject.cxx:69
 TQObject.cxx:70
 TQObject.cxx:71
 TQObject.cxx:72
 TQObject.cxx:73
 TQObject.cxx:74
 TQObject.cxx:75
 TQObject.cxx:76
 TQObject.cxx:77
 TQObject.cxx:78
 TQObject.cxx:79
 TQObject.cxx:80
 TQObject.cxx:81
 TQObject.cxx:82
 TQObject.cxx:83
 TQObject.cxx:84
 TQObject.cxx:85
 TQObject.cxx:86
 TQObject.cxx:87
 TQObject.cxx:88
 TQObject.cxx:89
 TQObject.cxx:90
 TQObject.cxx:91
 TQObject.cxx:92
 TQObject.cxx:93
 TQObject.cxx:94
 TQObject.cxx:95
 TQObject.cxx:96
 TQObject.cxx:97
 TQObject.cxx:98
 TQObject.cxx:99
 TQObject.cxx:100
 TQObject.cxx:101
 TQObject.cxx:102
 TQObject.cxx:103
 TQObject.cxx:104
 TQObject.cxx:105
 TQObject.cxx:106
 TQObject.cxx:107
 TQObject.cxx:108
 TQObject.cxx:109
 TQObject.cxx:110
 TQObject.cxx:111
 TQObject.cxx:112
 TQObject.cxx:113
 TQObject.cxx:114
 TQObject.cxx:115
 TQObject.cxx:116
 TQObject.cxx:117
 TQObject.cxx:118
 TQObject.cxx:119
 TQObject.cxx:120
 TQObject.cxx:121
 TQObject.cxx:122
 TQObject.cxx:123
 TQObject.cxx:124
 TQObject.cxx:125
 TQObject.cxx:126
 TQObject.cxx:127
 TQObject.cxx:128
 TQObject.cxx:129
 TQObject.cxx:130
 TQObject.cxx:131
 TQObject.cxx:132
 TQObject.cxx:133
 TQObject.cxx:134
 TQObject.cxx:135
 TQObject.cxx:136
 TQObject.cxx:137
 TQObject.cxx:138
 TQObject.cxx:139
 TQObject.cxx:140
 TQObject.cxx:141
 TQObject.cxx:142
 TQObject.cxx:143
 TQObject.cxx:144
 TQObject.cxx:145
 TQObject.cxx:146
 TQObject.cxx:147
 TQObject.cxx:148
 TQObject.cxx:149
 TQObject.cxx:150
 TQObject.cxx:151
 TQObject.cxx:152
 TQObject.cxx:153
 TQObject.cxx:154
 TQObject.cxx:155
 TQObject.cxx:156
 TQObject.cxx:157
 TQObject.cxx:158
 TQObject.cxx:159
 TQObject.cxx:160
 TQObject.cxx:161
 TQObject.cxx:162
 TQObject.cxx:163
 TQObject.cxx:164
 TQObject.cxx:165
 TQObject.cxx:166
 TQObject.cxx:167
 TQObject.cxx:168
 TQObject.cxx:169
 TQObject.cxx:170
 TQObject.cxx:171
 TQObject.cxx:172
 TQObject.cxx:173
 TQObject.cxx:174
 TQObject.cxx:175
 TQObject.cxx:176
 TQObject.cxx:177
 TQObject.cxx:178
 TQObject.cxx:179
 TQObject.cxx:180
 TQObject.cxx:181
 TQObject.cxx:182
 TQObject.cxx:183
 TQObject.cxx:184
 TQObject.cxx:185
 TQObject.cxx:186
 TQObject.cxx:187
 TQObject.cxx:188
 TQObject.cxx:189
 TQObject.cxx:190
 TQObject.cxx:191
 TQObject.cxx:192
 TQObject.cxx:193
 TQObject.cxx:194
 TQObject.cxx:195
 TQObject.cxx:196
 TQObject.cxx:197
 TQObject.cxx:198
 TQObject.cxx:199
 TQObject.cxx:200
 TQObject.cxx:201
 TQObject.cxx:202
 TQObject.cxx:203
 TQObject.cxx:204
 TQObject.cxx:205
 TQObject.cxx:206
 TQObject.cxx:207
 TQObject.cxx:208
 TQObject.cxx:209
 TQObject.cxx:210
 TQObject.cxx:211
 TQObject.cxx:212
 TQObject.cxx:213
 TQObject.cxx:214
 TQObject.cxx:215
 TQObject.cxx:216
 TQObject.cxx:217
 TQObject.cxx:218
 TQObject.cxx:219
 TQObject.cxx:220
 TQObject.cxx:221
 TQObject.cxx:222
 TQObject.cxx:223
 TQObject.cxx:224
 TQObject.cxx:225
 TQObject.cxx:226
 TQObject.cxx:227
 TQObject.cxx:228
 TQObject.cxx:229
 TQObject.cxx:230
 TQObject.cxx:231
 TQObject.cxx:232
 TQObject.cxx:233
 TQObject.cxx:234
 TQObject.cxx:235
 TQObject.cxx:236
 TQObject.cxx:237
 TQObject.cxx:238
 TQObject.cxx:239
 TQObject.cxx:240
 TQObject.cxx:241
 TQObject.cxx:242
 TQObject.cxx:243
 TQObject.cxx:244
 TQObject.cxx:245
 TQObject.cxx:246
 TQObject.cxx:247
 TQObject.cxx:248
 TQObject.cxx:249
 TQObject.cxx:250
 TQObject.cxx:251
 TQObject.cxx:252
 TQObject.cxx:253
 TQObject.cxx:254
 TQObject.cxx:255
 TQObject.cxx:256
 TQObject.cxx:257
 TQObject.cxx:258
 TQObject.cxx:259
 TQObject.cxx:260
 TQObject.cxx:261
 TQObject.cxx:262
 TQObject.cxx:263
 TQObject.cxx:264
 TQObject.cxx:265
 TQObject.cxx:266
 TQObject.cxx:267
 TQObject.cxx:268
 TQObject.cxx:269
 TQObject.cxx:270
 TQObject.cxx:271
 TQObject.cxx:272
 TQObject.cxx:273
 TQObject.cxx:274
 TQObject.cxx:275
 TQObject.cxx:276
 TQObject.cxx:277
 TQObject.cxx:278
 TQObject.cxx:279
 TQObject.cxx:280
 TQObject.cxx:281
 TQObject.cxx:282
 TQObject.cxx:283
 TQObject.cxx:284
 TQObject.cxx:285
 TQObject.cxx:286
 TQObject.cxx:287
 TQObject.cxx:288
 TQObject.cxx:289
 TQObject.cxx:290
 TQObject.cxx:291
 TQObject.cxx:292
 TQObject.cxx:293
 TQObject.cxx:294
 TQObject.cxx:295
 TQObject.cxx:296
 TQObject.cxx:297
 TQObject.cxx:298
 TQObject.cxx:299
 TQObject.cxx:300
 TQObject.cxx:301
 TQObject.cxx:302
 TQObject.cxx:303
 TQObject.cxx:304
 TQObject.cxx:305
 TQObject.cxx:306
 TQObject.cxx:307
 TQObject.cxx:308
 TQObject.cxx:309
 TQObject.cxx:310
 TQObject.cxx:311
 TQObject.cxx:312
 TQObject.cxx:313
 TQObject.cxx:314
 TQObject.cxx:315
 TQObject.cxx:316
 TQObject.cxx:317
 TQObject.cxx:318
 TQObject.cxx:319
 TQObject.cxx:320
 TQObject.cxx:321
 TQObject.cxx:322
 TQObject.cxx:323
 TQObject.cxx:324
 TQObject.cxx:325
 TQObject.cxx:326
 TQObject.cxx:327
 TQObject.cxx:328
 TQObject.cxx:329
 TQObject.cxx:330
 TQObject.cxx:331
 TQObject.cxx:332
 TQObject.cxx:333
 TQObject.cxx:334
 TQObject.cxx:335
 TQObject.cxx:336
 TQObject.cxx:337
 TQObject.cxx:338
 TQObject.cxx:339
 TQObject.cxx:340
 TQObject.cxx:341
 TQObject.cxx:342
 TQObject.cxx:343
 TQObject.cxx:344
 TQObject.cxx:345
 TQObject.cxx:346
 TQObject.cxx:347
 TQObject.cxx:348
 TQObject.cxx:349
 TQObject.cxx:350
 TQObject.cxx:351
 TQObject.cxx:352
 TQObject.cxx:353
 TQObject.cxx:354
 TQObject.cxx:355
 TQObject.cxx:356
 TQObject.cxx:357
 TQObject.cxx:358
 TQObject.cxx:359
 TQObject.cxx:360
 TQObject.cxx:361
 TQObject.cxx:362
 TQObject.cxx:363
 TQObject.cxx:364
 TQObject.cxx:365
 TQObject.cxx:366
 TQObject.cxx:367
 TQObject.cxx:368
 TQObject.cxx:369
 TQObject.cxx:370
 TQObject.cxx:371
 TQObject.cxx:372
 TQObject.cxx:373
 TQObject.cxx:374
 TQObject.cxx:375
 TQObject.cxx:376
 TQObject.cxx:377
 TQObject.cxx:378
 TQObject.cxx:379
 TQObject.cxx:380
 TQObject.cxx:381
 TQObject.cxx:382
 TQObject.cxx:383
 TQObject.cxx:384
 TQObject.cxx:385
 TQObject.cxx:386
 TQObject.cxx:387
 TQObject.cxx:388
 TQObject.cxx:389
 TQObject.cxx:390
 TQObject.cxx:391
 TQObject.cxx:392
 TQObject.cxx:393
 TQObject.cxx:394
 TQObject.cxx:395
 TQObject.cxx:396
 TQObject.cxx:397
 TQObject.cxx:398
 TQObject.cxx:399
 TQObject.cxx:400
 TQObject.cxx:401
 TQObject.cxx:402
 TQObject.cxx:403
 TQObject.cxx:404
 TQObject.cxx:405
 TQObject.cxx:406
 TQObject.cxx:407
 TQObject.cxx:408
 TQObject.cxx:409
 TQObject.cxx:410
 TQObject.cxx:411
 TQObject.cxx:412
 TQObject.cxx:413
 TQObject.cxx:414
 TQObject.cxx:415
 TQObject.cxx:416
 TQObject.cxx:417
 TQObject.cxx:418
 TQObject.cxx:419
 TQObject.cxx:420
 TQObject.cxx:421
 TQObject.cxx:422
 TQObject.cxx:423
 TQObject.cxx:424
 TQObject.cxx:425
 TQObject.cxx:426
 TQObject.cxx:427
 TQObject.cxx:428
 TQObject.cxx:429
 TQObject.cxx:430
 TQObject.cxx:431
 TQObject.cxx:432
 TQObject.cxx:433
 TQObject.cxx:434
 TQObject.cxx:435
 TQObject.cxx:436
 TQObject.cxx:437
 TQObject.cxx:438
 TQObject.cxx:439
 TQObject.cxx:440
 TQObject.cxx:441
 TQObject.cxx:442
 TQObject.cxx:443
 TQObject.cxx:444
 TQObject.cxx:445
 TQObject.cxx:446
 TQObject.cxx:447
 TQObject.cxx:448
 TQObject.cxx:449
 TQObject.cxx:450
 TQObject.cxx:451
 TQObject.cxx:452
 TQObject.cxx:453
 TQObject.cxx:454
 TQObject.cxx:455
 TQObject.cxx:456
 TQObject.cxx:457
 TQObject.cxx:458
 TQObject.cxx:459
 TQObject.cxx:460
 TQObject.cxx:461
 TQObject.cxx:462
 TQObject.cxx:463
 TQObject.cxx:464
 TQObject.cxx:465
 TQObject.cxx:466
 TQObject.cxx:467
 TQObject.cxx:468
 TQObject.cxx:469
 TQObject.cxx:470
 TQObject.cxx:471
 TQObject.cxx:472
 TQObject.cxx:473
 TQObject.cxx:474
 TQObject.cxx:475
 TQObject.cxx:476
 TQObject.cxx:477
 TQObject.cxx:478
 TQObject.cxx:479
 TQObject.cxx:480
 TQObject.cxx:481
 TQObject.cxx:482
 TQObject.cxx:483
 TQObject.cxx:484
 TQObject.cxx:485
 TQObject.cxx:486
 TQObject.cxx:487
 TQObject.cxx:488
 TQObject.cxx:489
 TQObject.cxx:490
 TQObject.cxx:491
 TQObject.cxx:492
 TQObject.cxx:493
 TQObject.cxx:494
 TQObject.cxx:495
 TQObject.cxx:496
 TQObject.cxx:497
 TQObject.cxx:498
 TQObject.cxx:499
 TQObject.cxx:500
 TQObject.cxx:501
 TQObject.cxx:502
 TQObject.cxx:503
 TQObject.cxx:504
 TQObject.cxx:505
 TQObject.cxx:506
 TQObject.cxx:507
 TQObject.cxx:508
 TQObject.cxx:509
 TQObject.cxx:510
 TQObject.cxx:511
 TQObject.cxx:512
 TQObject.cxx:513
 TQObject.cxx:514
 TQObject.cxx:515
 TQObject.cxx:516
 TQObject.cxx:517
 TQObject.cxx:518
 TQObject.cxx:519
 TQObject.cxx:520
 TQObject.cxx:521
 TQObject.cxx:522
 TQObject.cxx:523
 TQObject.cxx:524
 TQObject.cxx:525
 TQObject.cxx:526
 TQObject.cxx:527
 TQObject.cxx:528
 TQObject.cxx:529
 TQObject.cxx:530
 TQObject.cxx:531
 TQObject.cxx:532
 TQObject.cxx:533
 TQObject.cxx:534
 TQObject.cxx:535
 TQObject.cxx:536
 TQObject.cxx:537
 TQObject.cxx:538
 TQObject.cxx:539
 TQObject.cxx:540
 TQObject.cxx:541
 TQObject.cxx:542
 TQObject.cxx:543
 TQObject.cxx:544
 TQObject.cxx:545
 TQObject.cxx:546
 TQObject.cxx:547
 TQObject.cxx:548
 TQObject.cxx:549
 TQObject.cxx:550
 TQObject.cxx:551
 TQObject.cxx:552
 TQObject.cxx:553
 TQObject.cxx:554
 TQObject.cxx:555
 TQObject.cxx:556
 TQObject.cxx:557
 TQObject.cxx:558
 TQObject.cxx:559
 TQObject.cxx:560
 TQObject.cxx:561
 TQObject.cxx:562
 TQObject.cxx:563
 TQObject.cxx:564
 TQObject.cxx:565
 TQObject.cxx:566
 TQObject.cxx:567
 TQObject.cxx:568
 TQObject.cxx:569
 TQObject.cxx:570
 TQObject.cxx:571
 TQObject.cxx:572
 TQObject.cxx:573
 TQObject.cxx:574
 TQObject.cxx:575
 TQObject.cxx:576
 TQObject.cxx:577
 TQObject.cxx:578
 TQObject.cxx:579
 TQObject.cxx:580
 TQObject.cxx:581
 TQObject.cxx:582
 TQObject.cxx:583
 TQObject.cxx:584
 TQObject.cxx:585
 TQObject.cxx:586
 TQObject.cxx:587
 TQObject.cxx:588
 TQObject.cxx:589
 TQObject.cxx:590
 TQObject.cxx:591
 TQObject.cxx:592
 TQObject.cxx:593
 TQObject.cxx:594
 TQObject.cxx:595
 TQObject.cxx:596
 TQObject.cxx:597
 TQObject.cxx:598
 TQObject.cxx:599
 TQObject.cxx:600
 TQObject.cxx:601
 TQObject.cxx:602
 TQObject.cxx:603
 TQObject.cxx:604
 TQObject.cxx:605
 TQObject.cxx:606
 TQObject.cxx:607
 TQObject.cxx:608
 TQObject.cxx:609
 TQObject.cxx:610
 TQObject.cxx:611
 TQObject.cxx:612
 TQObject.cxx:613
 TQObject.cxx:614
 TQObject.cxx:615
 TQObject.cxx:616
 TQObject.cxx:617
 TQObject.cxx:618
 TQObject.cxx:619
 TQObject.cxx:620
 TQObject.cxx:621
 TQObject.cxx:622
 TQObject.cxx:623
 TQObject.cxx:624
 TQObject.cxx:625
 TQObject.cxx:626
 TQObject.cxx:627
 TQObject.cxx:628
 TQObject.cxx:629
 TQObject.cxx:630
 TQObject.cxx:631
 TQObject.cxx:632
 TQObject.cxx:633
 TQObject.cxx:634
 TQObject.cxx:635
 TQObject.cxx:636
 TQObject.cxx:637
 TQObject.cxx:638
 TQObject.cxx:639
 TQObject.cxx:640
 TQObject.cxx:641
 TQObject.cxx:642
 TQObject.cxx:643
 TQObject.cxx:644
 TQObject.cxx:645
 TQObject.cxx:646
 TQObject.cxx:647
 TQObject.cxx:648
 TQObject.cxx:649
 TQObject.cxx:650
 TQObject.cxx:651
 TQObject.cxx:652
 TQObject.cxx:653
 TQObject.cxx:654
 TQObject.cxx:655
 TQObject.cxx:656
 TQObject.cxx:657
 TQObject.cxx:658
 TQObject.cxx:659
 TQObject.cxx:660
 TQObject.cxx:661
 TQObject.cxx:662
 TQObject.cxx:663
 TQObject.cxx:664
 TQObject.cxx:665
 TQObject.cxx:666
 TQObject.cxx:667
 TQObject.cxx:668
 TQObject.cxx:669
 TQObject.cxx:670
 TQObject.cxx:671
 TQObject.cxx:672
 TQObject.cxx:673
 TQObject.cxx:674
 TQObject.cxx:675
 TQObject.cxx:676
 TQObject.cxx:677
 TQObject.cxx:678
 TQObject.cxx:679
 TQObject.cxx:680
 TQObject.cxx:681
 TQObject.cxx:682
 TQObject.cxx:683
 TQObject.cxx:684
 TQObject.cxx:685
 TQObject.cxx:686
 TQObject.cxx:687
 TQObject.cxx:688
 TQObject.cxx:689
 TQObject.cxx:690
 TQObject.cxx:691
 TQObject.cxx:692
 TQObject.cxx:693
 TQObject.cxx:694
 TQObject.cxx:695
 TQObject.cxx:696
 TQObject.cxx:697
 TQObject.cxx:698
 TQObject.cxx:699
 TQObject.cxx:700
 TQObject.cxx:701
 TQObject.cxx:702
 TQObject.cxx:703
 TQObject.cxx:704
 TQObject.cxx:705
 TQObject.cxx:706
 TQObject.cxx:707
 TQObject.cxx:708
 TQObject.cxx:709
 TQObject.cxx:710
 TQObject.cxx:711
 TQObject.cxx:712
 TQObject.cxx:713
 TQObject.cxx:714
 TQObject.cxx:715
 TQObject.cxx:716
 TQObject.cxx:717
 TQObject.cxx:718
 TQObject.cxx:719
 TQObject.cxx:720
 TQObject.cxx:721
 TQObject.cxx:722
 TQObject.cxx:723
 TQObject.cxx:724
 TQObject.cxx:725
 TQObject.cxx:726
 TQObject.cxx:727
 TQObject.cxx:728
 TQObject.cxx:729
 TQObject.cxx:730
 TQObject.cxx:731
 TQObject.cxx:732
 TQObject.cxx:733
 TQObject.cxx:734
 TQObject.cxx:735
 TQObject.cxx:736
 TQObject.cxx:737
 TQObject.cxx:738
 TQObject.cxx:739
 TQObject.cxx:740
 TQObject.cxx:741
 TQObject.cxx:742
 TQObject.cxx:743
 TQObject.cxx:744
 TQObject.cxx:745
 TQObject.cxx:746
 TQObject.cxx:747
 TQObject.cxx:748
 TQObject.cxx:749
 TQObject.cxx:750
 TQObject.cxx:751
 TQObject.cxx:752
 TQObject.cxx:753
 TQObject.cxx:754
 TQObject.cxx:755
 TQObject.cxx:756
 TQObject.cxx:757
 TQObject.cxx:758
 TQObject.cxx:759
 TQObject.cxx:760
 TQObject.cxx:761
 TQObject.cxx:762
 TQObject.cxx:763
 TQObject.cxx:764
 TQObject.cxx:765
 TQObject.cxx:766
 TQObject.cxx:767
 TQObject.cxx:768
 TQObject.cxx:769
 TQObject.cxx:770
 TQObject.cxx:771
 TQObject.cxx:772
 TQObject.cxx:773
 TQObject.cxx:774
 TQObject.cxx:775
 TQObject.cxx:776
 TQObject.cxx:777
 TQObject.cxx:778
 TQObject.cxx:779
 TQObject.cxx:780
 TQObject.cxx:781
 TQObject.cxx:782
 TQObject.cxx:783
 TQObject.cxx:784
 TQObject.cxx:785
 TQObject.cxx:786
 TQObject.cxx:787
 TQObject.cxx:788
 TQObject.cxx:789
 TQObject.cxx:790
 TQObject.cxx:791
 TQObject.cxx:792
 TQObject.cxx:793
 TQObject.cxx:794
 TQObject.cxx:795
 TQObject.cxx:796
 TQObject.cxx:797
 TQObject.cxx:798
 TQObject.cxx:799
 TQObject.cxx:800
 TQObject.cxx:801
 TQObject.cxx:802
 TQObject.cxx:803
 TQObject.cxx:804
 TQObject.cxx:805
 TQObject.cxx:806
 TQObject.cxx:807
 TQObject.cxx:808
 TQObject.cxx:809
 TQObject.cxx:810
 TQObject.cxx:811
 TQObject.cxx:812
 TQObject.cxx:813
 TQObject.cxx:814
 TQObject.cxx:815
 TQObject.cxx:816
 TQObject.cxx:817
 TQObject.cxx:818
 TQObject.cxx:819
 TQObject.cxx:820
 TQObject.cxx:821
 TQObject.cxx:822
 TQObject.cxx:823
 TQObject.cxx:824
 TQObject.cxx:825
 TQObject.cxx:826
 TQObject.cxx:827
 TQObject.cxx:828
 TQObject.cxx:829
 TQObject.cxx:830
 TQObject.cxx:831
 TQObject.cxx:832
 TQObject.cxx:833
 TQObject.cxx:834
 TQObject.cxx:835
 TQObject.cxx:836
 TQObject.cxx:837
 TQObject.cxx:838
 TQObject.cxx:839
 TQObject.cxx:840
 TQObject.cxx:841
 TQObject.cxx:842
 TQObject.cxx:843
 TQObject.cxx:844
 TQObject.cxx:845
 TQObject.cxx:846
 TQObject.cxx:847
 TQObject.cxx:848
 TQObject.cxx:849
 TQObject.cxx:850
 TQObject.cxx:851
 TQObject.cxx:852
 TQObject.cxx:853
 TQObject.cxx:854
 TQObject.cxx:855
 TQObject.cxx:856
 TQObject.cxx:857
 TQObject.cxx:858
 TQObject.cxx:859
 TQObject.cxx:860
 TQObject.cxx:861
 TQObject.cxx:862
 TQObject.cxx:863
 TQObject.cxx:864
 TQObject.cxx:865
 TQObject.cxx:866
 TQObject.cxx:867
 TQObject.cxx:868
 TQObject.cxx:869
 TQObject.cxx:870
 TQObject.cxx:871
 TQObject.cxx:872
 TQObject.cxx:873
 TQObject.cxx:874
 TQObject.cxx:875
 TQObject.cxx:876
 TQObject.cxx:877
 TQObject.cxx:878
 TQObject.cxx:879
 TQObject.cxx:880
 TQObject.cxx:881
 TQObject.cxx:882
 TQObject.cxx:883
 TQObject.cxx:884
 TQObject.cxx:885
 TQObject.cxx:886
 TQObject.cxx:887
 TQObject.cxx:888
 TQObject.cxx:889
 TQObject.cxx:890
 TQObject.cxx:891
 TQObject.cxx:892
 TQObject.cxx:893
 TQObject.cxx:894
 TQObject.cxx:895
 TQObject.cxx:896
 TQObject.cxx:897
 TQObject.cxx:898
 TQObject.cxx:899
 TQObject.cxx:900
 TQObject.cxx:901
 TQObject.cxx:902
 TQObject.cxx:903
 TQObject.cxx:904
 TQObject.cxx:905
 TQObject.cxx:906
 TQObject.cxx:907
 TQObject.cxx:908
 TQObject.cxx:909
 TQObject.cxx:910
 TQObject.cxx:911
 TQObject.cxx:912
 TQObject.cxx:913
 TQObject.cxx:914
 TQObject.cxx:915
 TQObject.cxx:916
 TQObject.cxx:917
 TQObject.cxx:918
 TQObject.cxx:919
 TQObject.cxx:920
 TQObject.cxx:921
 TQObject.cxx:922
 TQObject.cxx:923
 TQObject.cxx:924
 TQObject.cxx:925
 TQObject.cxx:926
 TQObject.cxx:927
 TQObject.cxx:928
 TQObject.cxx:929
 TQObject.cxx:930
 TQObject.cxx:931
 TQObject.cxx:932
 TQObject.cxx:933
 TQObject.cxx:934
 TQObject.cxx:935
 TQObject.cxx:936
 TQObject.cxx:937
 TQObject.cxx:938
 TQObject.cxx:939
 TQObject.cxx:940
 TQObject.cxx:941
 TQObject.cxx:942
 TQObject.cxx:943
 TQObject.cxx:944
 TQObject.cxx:945
 TQObject.cxx:946
 TQObject.cxx:947
 TQObject.cxx:948
 TQObject.cxx:949
 TQObject.cxx:950
 TQObject.cxx:951
 TQObject.cxx:952
 TQObject.cxx:953
 TQObject.cxx:954
 TQObject.cxx:955
 TQObject.cxx:956
 TQObject.cxx:957
 TQObject.cxx:958
 TQObject.cxx:959
 TQObject.cxx:960
 TQObject.cxx:961
 TQObject.cxx:962
 TQObject.cxx:963
 TQObject.cxx:964
 TQObject.cxx:965
 TQObject.cxx:966
 TQObject.cxx:967
 TQObject.cxx:968
 TQObject.cxx:969
 TQObject.cxx:970
 TQObject.cxx:971
 TQObject.cxx:972
 TQObject.cxx:973
 TQObject.cxx:974
 TQObject.cxx:975
 TQObject.cxx:976
 TQObject.cxx:977
 TQObject.cxx:978
 TQObject.cxx:979
 TQObject.cxx:980
 TQObject.cxx:981
 TQObject.cxx:982
 TQObject.cxx:983
 TQObject.cxx:984
 TQObject.cxx:985
 TQObject.cxx:986
 TQObject.cxx:987
 TQObject.cxx:988
 TQObject.cxx:989
 TQObject.cxx:990
 TQObject.cxx:991
 TQObject.cxx:992
 TQObject.cxx:993
 TQObject.cxx:994
 TQObject.cxx:995
 TQObject.cxx:996
 TQObject.cxx:997
 TQObject.cxx:998
 TQObject.cxx:999
 TQObject.cxx:1000
 TQObject.cxx:1001
 TQObject.cxx:1002
 TQObject.cxx:1003
 TQObject.cxx:1004
 TQObject.cxx:1005
 TQObject.cxx:1006
 TQObject.cxx:1007
 TQObject.cxx:1008
 TQObject.cxx:1009
 TQObject.cxx:1010
 TQObject.cxx:1011
 TQObject.cxx:1012
 TQObject.cxx:1013
 TQObject.cxx:1014
 TQObject.cxx:1015
 TQObject.cxx:1016
 TQObject.cxx:1017
 TQObject.cxx:1018
 TQObject.cxx:1019
 TQObject.cxx:1020
 TQObject.cxx:1021
 TQObject.cxx:1022
 TQObject.cxx:1023
 TQObject.cxx:1024
 TQObject.cxx:1025
 TQObject.cxx:1026
 TQObject.cxx:1027
 TQObject.cxx:1028
 TQObject.cxx:1029
 TQObject.cxx:1030
 TQObject.cxx:1031
 TQObject.cxx:1032
 TQObject.cxx:1033
 TQObject.cxx:1034
 TQObject.cxx:1035
 TQObject.cxx:1036
 TQObject.cxx:1037
 TQObject.cxx:1038
 TQObject.cxx:1039
 TQObject.cxx:1040
 TQObject.cxx:1041
 TQObject.cxx:1042
 TQObject.cxx:1043
 TQObject.cxx:1044
 TQObject.cxx:1045
 TQObject.cxx:1046
 TQObject.cxx:1047
 TQObject.cxx:1048
 TQObject.cxx:1049
 TQObject.cxx:1050
 TQObject.cxx:1051
 TQObject.cxx:1052
 TQObject.cxx:1053
 TQObject.cxx:1054
 TQObject.cxx:1055
 TQObject.cxx:1056
 TQObject.cxx:1057
 TQObject.cxx:1058
 TQObject.cxx:1059
 TQObject.cxx:1060
 TQObject.cxx:1061
 TQObject.cxx:1062
 TQObject.cxx:1063
 TQObject.cxx:1064
 TQObject.cxx:1065
 TQObject.cxx:1066
 TQObject.cxx:1067
 TQObject.cxx:1068
 TQObject.cxx:1069
 TQObject.cxx:1070
 TQObject.cxx:1071
 TQObject.cxx:1072
 TQObject.cxx:1073
 TQObject.cxx:1074
 TQObject.cxx:1075
 TQObject.cxx:1076
 TQObject.cxx:1077
 TQObject.cxx:1078
 TQObject.cxx:1079
 TQObject.cxx:1080
 TQObject.cxx:1081
 TQObject.cxx:1082
 TQObject.cxx:1083
 TQObject.cxx:1084
 TQObject.cxx:1085
 TQObject.cxx:1086
 TQObject.cxx:1087
 TQObject.cxx:1088
 TQObject.cxx:1089
 TQObject.cxx:1090
 TQObject.cxx:1091
 TQObject.cxx:1092
 TQObject.cxx:1093
 TQObject.cxx:1094
 TQObject.cxx:1095
 TQObject.cxx:1096
 TQObject.cxx:1097
 TQObject.cxx:1098
 TQObject.cxx:1099
 TQObject.cxx:1100
 TQObject.cxx:1101
 TQObject.cxx:1102
 TQObject.cxx:1103
 TQObject.cxx:1104
 TQObject.cxx:1105
 TQObject.cxx:1106
 TQObject.cxx:1107
 TQObject.cxx:1108
 TQObject.cxx:1109
 TQObject.cxx:1110
 TQObject.cxx:1111
 TQObject.cxx:1112
 TQObject.cxx:1113
 TQObject.cxx:1114
 TQObject.cxx:1115
 TQObject.cxx:1116
 TQObject.cxx:1117
 TQObject.cxx:1118
 TQObject.cxx:1119
 TQObject.cxx:1120
 TQObject.cxx:1121
 TQObject.cxx:1122
 TQObject.cxx:1123
 TQObject.cxx:1124
 TQObject.cxx:1125
 TQObject.cxx:1126
 TQObject.cxx:1127
 TQObject.cxx:1128
 TQObject.cxx:1129
 TQObject.cxx:1130
 TQObject.cxx:1131
 TQObject.cxx:1132
 TQObject.cxx:1133
 TQObject.cxx:1134
 TQObject.cxx:1135
 TQObject.cxx:1136
 TQObject.cxx:1137
 TQObject.cxx:1138
 TQObject.cxx:1139
 TQObject.cxx:1140
 TQObject.cxx:1141
 TQObject.cxx:1142
 TQObject.cxx:1143
 TQObject.cxx:1144
 TQObject.cxx:1145
 TQObject.cxx:1146
 TQObject.cxx:1147
 TQObject.cxx:1148
 TQObject.cxx:1149
 TQObject.cxx:1150
 TQObject.cxx:1151
 TQObject.cxx:1152
 TQObject.cxx:1153
 TQObject.cxx:1154
 TQObject.cxx:1155
 TQObject.cxx:1156
 TQObject.cxx:1157
 TQObject.cxx:1158
 TQObject.cxx:1159
 TQObject.cxx:1160
 TQObject.cxx:1161
 TQObject.cxx:1162
 TQObject.cxx:1163
 TQObject.cxx:1164
 TQObject.cxx:1165
 TQObject.cxx:1166
 TQObject.cxx:1167
 TQObject.cxx:1168
 TQObject.cxx:1169
 TQObject.cxx:1170
 TQObject.cxx:1171
 TQObject.cxx:1172
 TQObject.cxx:1173
 TQObject.cxx:1174
 TQObject.cxx:1175
 TQObject.cxx:1176
 TQObject.cxx:1177
 TQObject.cxx:1178
 TQObject.cxx:1179
 TQObject.cxx:1180
 TQObject.cxx:1181
 TQObject.cxx:1182
 TQObject.cxx:1183
 TQObject.cxx:1184
 TQObject.cxx:1185
 TQObject.cxx:1186
 TQObject.cxx:1187
 TQObject.cxx:1188
 TQObject.cxx:1189
 TQObject.cxx:1190
 TQObject.cxx:1191
 TQObject.cxx:1192
 TQObject.cxx:1193
 TQObject.cxx:1194
 TQObject.cxx:1195
 TQObject.cxx:1196
 TQObject.cxx:1197
 TQObject.cxx:1198
 TQObject.cxx:1199
 TQObject.cxx:1200
 TQObject.cxx:1201
 TQObject.cxx:1202
 TQObject.cxx:1203
 TQObject.cxx:1204
 TQObject.cxx:1205
 TQObject.cxx:1206
 TQObject.cxx:1207
 TQObject.cxx:1208
 TQObject.cxx:1209
 TQObject.cxx:1210
 TQObject.cxx:1211
 TQObject.cxx:1212
 TQObject.cxx:1213
 TQObject.cxx:1214
 TQObject.cxx:1215
 TQObject.cxx:1216
 TQObject.cxx:1217
 TQObject.cxx:1218
 TQObject.cxx:1219
 TQObject.cxx:1220
 TQObject.cxx:1221
 TQObject.cxx:1222
 TQObject.cxx:1223
 TQObject.cxx:1224
 TQObject.cxx:1225
 TQObject.cxx:1226
 TQObject.cxx:1227
 TQObject.cxx:1228
 TQObject.cxx:1229
 TQObject.cxx:1230
 TQObject.cxx:1231
 TQObject.cxx:1232
 TQObject.cxx:1233
 TQObject.cxx:1234
 TQObject.cxx:1235
 TQObject.cxx:1236
 TQObject.cxx:1237
 TQObject.cxx:1238
 TQObject.cxx:1239
 TQObject.cxx:1240
 TQObject.cxx:1241
 TQObject.cxx:1242
 TQObject.cxx:1243
 TQObject.cxx:1244
 TQObject.cxx:1245
 TQObject.cxx:1246
 TQObject.cxx:1247
 TQObject.cxx:1248
 TQObject.cxx:1249
 TQObject.cxx:1250
 TQObject.cxx:1251
 TQObject.cxx:1252
 TQObject.cxx:1253
 TQObject.cxx:1254
 TQObject.cxx:1255
 TQObject.cxx:1256
 TQObject.cxx:1257
 TQObject.cxx:1258
 TQObject.cxx:1259
 TQObject.cxx:1260
 TQObject.cxx:1261
 TQObject.cxx:1262
 TQObject.cxx:1263
 TQObject.cxx:1264
 TQObject.cxx:1265
 TQObject.cxx:1266
 TQObject.cxx:1267
 TQObject.cxx:1268
 TQObject.cxx:1269
 TQObject.cxx:1270
 TQObject.cxx:1271
 TQObject.cxx:1272
 TQObject.cxx:1273
 TQObject.cxx:1274
 TQObject.cxx:1275
 TQObject.cxx:1276
 TQObject.cxx:1277
 TQObject.cxx:1278
 TQObject.cxx:1279
 TQObject.cxx:1280
 TQObject.cxx:1281
 TQObject.cxx:1282
 TQObject.cxx:1283
 TQObject.cxx:1284
 TQObject.cxx:1285
 TQObject.cxx:1286
 TQObject.cxx:1287
 TQObject.cxx:1288
 TQObject.cxx:1289
 TQObject.cxx:1290
 TQObject.cxx:1291
 TQObject.cxx:1292
 TQObject.cxx:1293
 TQObject.cxx:1294
 TQObject.cxx:1295
 TQObject.cxx:1296
 TQObject.cxx:1297
 TQObject.cxx:1298
 TQObject.cxx:1299
 TQObject.cxx:1300
 TQObject.cxx:1301
 TQObject.cxx:1302
 TQObject.cxx:1303
 TQObject.cxx:1304
 TQObject.cxx:1305
 TQObject.cxx:1306
 TQObject.cxx:1307
 TQObject.cxx:1308
 TQObject.cxx:1309
 TQObject.cxx:1310
 TQObject.cxx:1311
 TQObject.cxx:1312
 TQObject.cxx:1313
 TQObject.cxx:1314
 TQObject.cxx:1315
 TQObject.cxx:1316
 TQObject.cxx:1317
 TQObject.cxx:1318
 TQObject.cxx:1319
 TQObject.cxx:1320
 TQObject.cxx:1321
 TQObject.cxx:1322
 TQObject.cxx:1323
 TQObject.cxx:1324
 TQObject.cxx:1325
 TQObject.cxx:1326
 TQObject.cxx:1327
 TQObject.cxx:1328
 TQObject.cxx:1329
 TQObject.cxx:1330
 TQObject.cxx:1331
 TQObject.cxx:1332
 TQObject.cxx:1333
 TQObject.cxx:1334