library: libCore
#include "TQClass.h"

TQClass


class description - header file - source file
viewCVS header - viewCVS source

class TQClass: public TQObject, public TClass

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
TQClass(const char* name, Version_t cversion, const type_info& info, TVirtualIsAProxy* isa, ShowMembersFunc_t showmembers, const char* dfil = "0", const char* ifil = "0", Int_t dl = 0, Int_t il = 0)
virtual~TQClass()
voidTObject::AbstractMethod(const char* method) const
voidTClass::AddImplFile(const char* filename, int line)
voidTClass::AddInstance(Bool_t heap = kFALSE)
voidTClass::AddRef(TClassRef* ref)
voidTClass::AdoptMemberStreamer(const char* name, TMemberStreamer* strm)
voidTClass::AdoptReferenceProxy(TVirtualRefProxy* proxy)
voidTClass::AdoptStreamer(TClassStreamer* strm)
virtual voidTObject::AppendPad(Option_t* option = "")
static Int_tTClass::AutoBrowse(TObject* obj, TBrowser* browser)
virtual voidTClass::Browse(TBrowser* b)
Int_tTClass::Browse(void* obj, TBrowser* b) const
voidTClass::BuildEmulatedRealData(const char* name, Int_t offset, TClass* cl)
voidTClass::BuildRealData(void* pointer = 0)
Bool_tTClass::CanIgnoreTObjectStreamer()
Bool_tTClass::CanSplit() const
virtual voidTQObject::ChangedBy(const char* method)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTNamed::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual Int_tTNamed::Compare(const TObject* obj) const
Bool_tTQObject::Connect(const char* signal, const char* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::Connect(TQObject* sender, const char* signal, const char* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::Connect(const char* sender_class, const char* signal, const char* receiver_class, void* receiver, const char* slot)
virtual voidTQObject::Connected(const char*)
virtual voidTNamed::Copy(TObject& named) const
voidTClass::CopyCollectionProxy(const TVirtualCollectionProxy&)
virtual voidTObject::Delete(Option_t* option = "")
voidTClass::DeleteArray(void* ary, Bool_t dtorOnly = kFALSE)
virtual voidTQObject::Destroyed()
voidTClass::Destructor(void* obj, Bool_t dtorOnly = kFALSE)
Bool_tTQObject::Disconnect(const char* signal = "0", void* receiver = 0, const char* slot = "0")
static Bool_tTQObject::Disconnect(TQObject* sender, const char* signal = "0", void* receiver = 0, const char* slot = "0")
static Bool_tTQObject::Disconnect(const char* class_name, const char* signal, void* receiver = 0, const char* slot = "0")
virtual voidTQObject::Disconnected(const char*)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTClass::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTClass::Dump() const
voidTClass::Dump(void* obj) const
void*TClass::DynamicCast(const TClass* base, void* obj, Bool_t up = kTRUE)
voidTQObject::Emit(const char* signal)
voidTQObject::Emit(const char* signal, Long_t* paramArr)
voidTQObject::Emit(const char* signal, const char* params)
voidTQObject::Emit(const char* signal, Double_t param)
voidTQObject::Emit(const char* signal, Long_t param)
voidTQObject::Emit(const char* signal, Long64_t param)
voidTQObject::Emit(const char* signal, Bool_t param)
voidTQObject::Emit(const char* signal, Char_t param)
voidTQObject::Emit(const char* signal, UChar_t param)
voidTQObject::Emit(const char* signal, Short_t param)
voidTQObject::Emit(const char* signal, UShort_t param)
voidTQObject::Emit(const char* signal, Int_t param)
voidTQObject::Emit(const char* signal, UInt_t param)
voidTQObject::Emit(const char* signal, ULong_t param)
voidTQObject::Emit(const char* signal, ULong64_t param)
voidTQObject::Emit(const char* signal, Float_t param)
voidTQObject::EmitVA(const char* signal, Int_t nargs)
voidTQObject::EmitVA(const char* signal, Int_t nargs, va_list va)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
char*TClass::EscapeChars(const char* text) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
TStreamerInfo*TClass::FindStreamerInfo(UInt_t checksum) const
TClass*TClass::GetActualClass(const void* object) const
TClass*TClass::GetBaseClass(const char* classname)
TClass*TClass::GetBaseClass(const TClass* base)
Int_tTClass::GetBaseClassOffset(const TClass* base)
TClass*TClass::GetBaseDataMember(const char* datamember)
UInt_tTClass::GetCheckSum(UInt_t code = 0) const
static TClass*TClass::GetClass(const char* name, Bool_t load = kTRUE)
static TClass*TClass::GetClass(const type_info& typeinfo, Bool_t load = kTRUE)
G__ClassInfo*TClass::GetClassInfo() const
Version_tTClass::GetClassVersion() const
TVirtualCollectionProxy*TClass::GetCollectionProxy() const
const char*TClass::GetContextMenuTitle() const
TDataMember*TClass::GetDataMember(const char* datamember) const
Int_tTClass::GetDataMemberOffset(const char* membername) const
Short_tTClass::GetDeclFileLine() const
const char*TClass::GetDeclFileName() const
ROOT::DelFunc_tTClass::GetDelete() const
ROOT::DelArrFunc_tTClass::GetDeleteArray() const
ROOT::DesFunc_tTClass::GetDestructor() const
static VoidFuncPtr_tTClass::GetDict(const char* cname)
static VoidFuncPtr_tTClass::GetDict(const type_info& info)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
UInt_tTClass::GetHeapInstanceCount() const
virtual const char*TObject::GetIconName() const
Short_tTClass::GetImplFileLine() const
const char*TClass::GetImplFileName() const
UInt_tTClass::GetInstanceCount() const
TVirtualIsAProxy*TClass::GetIsAProxy() const
TList*TClass::GetListOfAllPublicDataMembers()
TList*TClass::GetListOfAllPublicMethods()
TList*TClass::GetListOfBases()
TList*TQObject::GetListOfClassSignals() const
TList*TQObject::GetListOfConnections() const
TList*TClass::GetListOfDataMembers()
TList*TClass::GetListOfMethods()
TList*TClass::GetListOfRealData() const
TList*TQObject::GetListOfSignals() const
voidTClass::GetMenuItems(TList* listitems)
TList*TClass::GetMenuList() const
TMethod*TClass::GetMethod(const char* method, const char* params)
TMethod*TClass::GetMethodAllAny(const char* method)
TMethod*TClass::GetMethodAny(const char* method)
TMethod*TClass::GetMethodWithPrototype(const char* method, const char* proto)
virtual const char*TNamed::GetName() const
Int_tTClass::GetNdata()
ROOT::NewFunc_tTClass::GetNew() const
ROOT::NewArrFunc_tTClass::GetNewArray() const
Int_tTClass::GetNmethods()
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
static multimap<void*,Version_t>&TClass::GetObjectVersionRepository()
virtual Option_t*TObject::GetOption() const
TRealData*TClass::GetRealData(const char* name) const
TVirtualRefProxy*TClass::GetReferenceProxy() const
const char*TClass::GetSharedLibs()
ShowMembersFunc_tTClass::GetShowMembersWrapper() const
TClassStreamer*TClass::GetStreamer() const
TStreamerInfo*TClass::GetStreamerInfo(Int_t version = 0)
TObjArray*TClass::GetStreamerInfos() const
virtual const char*TNamed::GetTitle() const
const type_info*TClass::GetTypeInfo() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual Bool_tTQObject::HasConnection(const char* signal_name) const
Bool_tTClass::HasDefaultConstructor() const
virtual ULong_tTNamed::Hash() const
virtual voidTQObject::HighPriority(const char* signal_name, const char* slot_name = "0")
voidTClass::IgnoreTObjectStreamer(Bool_t ignore = kTRUE)
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTClass::InheritsFrom(const char* cl) const
virtual Bool_tTClass::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
static TClass::ENewTypeTClass::IsCallingNew()
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTClass::IsFolder() const
Bool_tTClass::IsFolder(void* obj) const
Bool_tTClass::IsForeign() const
Bool_tTClass::IsLoaded() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTNamed::IsSortable() const
Bool_tTClass::IsStartingWithTObject() const
Bool_tTClass::IsTObject() const
Bool_tTObject::IsZombie() const
static TClass*TClass::Load(TBuffer& b)
static voidTQObject::LoadRQ_OBJECT()
virtual voidTQObject::LowPriority(const char* signal_name, const char* slot_name = "0")
virtual voidTNamed::ls(Option_t* option = "") const
voidTClass::MakeCustomMenuList()
voidTObject::MayNotUse(const char* method) const
virtual voidTQObject::Message(const char* msg)
void*TClass::New(TClass::ENewType defConstructor = kClassNew)
void*TClass::New(void* arena, TClass::ENewType defConstructor = kClassNew)
void*TClass::NewArray(Long_t nElements, TClass::ENewType defConstructor = kClassNew)
void*TClass::NewArray(Long_t nElements, void* arena, TClass::ENewType defConstructor = kClassNew)
virtual Bool_tTObject::Notify()
virtual Int_tTQObject::NumberOfConnections() const
virtual Int_tTQObject::NumberOfSignals() const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTClass::PostLoadCheck()
virtual voidTNamed::Print(Option_t* option = "") const
virtual Long_tTClass::Property() const
virtual Int_tTObject::Read(const char* name)
Int_tTClass::ReadBuffer(TBuffer& b, void* pointer)
Int_tTClass::ReadBuffer(TBuffer& b, void* pointer, Int_t version, UInt_t start, UInt_t count)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTClass::RemoveRef(TClassRef* ref)
voidTClass::ReplaceWith(TClass* newcl, Bool_t recurse = kTRUE) const
voidTObject::ResetBit(UInt_t f)
voidTClass::ResetClassInfo(Long_t tagnum)
voidTClass::ResetInstanceCount()
voidTClass::ResetMenuList()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidTClass::SetContextMenuTitle(const char* title)
voidTClass::SetDeclFile(const char* name, int line)
voidTClass::SetDelete(ROOT::DelFunc_t deleteFunc)
voidTClass::SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc)
voidTClass::SetDestructor(ROOT::DesFunc_t destructorFunc)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
voidTClass::SetGlobalIsA(IsAGlobalFunc_t)
voidTClass::SetImplFileName(const char* implFileName)
voidTClass::SetMemberStreamer(const char* name, MemberStreamerFunc_t strm)
virtual voidTNamed::SetName(const char* name)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
voidTClass::SetNew(ROOT::NewFunc_t newFunc)
voidTClass::SetNewArray(ROOT::NewArrFunc_t newArrayFunc)
static voidTObject::SetObjectStat(Bool_t stat)
TStreamerInfo*TClass::SetStreamerInfo(Int_t version, const char* info = "")
virtual voidTNamed::SetTitle(const char* title = "")
virtual voidTObject::SetUniqueID(UInt_t uid)
voidTClass::SetUnloaded()
virtual voidShowMembers(TMemberInspector& insp, char* parent)
Int_tTClass::Size() const
virtual Int_tTNamed::Sizeof() const
voidTClass::Store(TBuffer& b) const
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) const
Int_tTClass::WriteBuffer(TBuffer& b, void* pointer, const char* info = "")
protected:
static Int_tTQObject::CheckConnectArgs(TQObject* sender, TClass* sender_class, const char* signal, TClass* receiver_class, const char* slot)
static Bool_tTQObject::ConnectToClass(TQObject* sender, const char* signal, TClass* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::ConnectToClass(const char* sender_class, const char* signal, TClass* receiver_class, void* receiver, const char* slot)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual void*TQObject::GetSender()
virtual const char*TQObject::GetSenderClassName() const
voidTObject::MakeZombie()
TClass&TClass::operator=(const TClass&)

Data Members

public:
enum TClass::[unnamed] { kClassSaved
kIgnoreTObjectStreamer
kUnloaded
kIsTObject
kIsForeign
kIsEmulation
kStartWithTObject
kWarned
};
enum TClass::ENewType { kRealNew
kClassNew
kDummyNew
};
enum TClass::[unnamed] { kLoading
kDefault
kEmulated
kTObject
kInstrumented
kForeign
kExternal
};
enum TDictionary::ESTLType { kNone
kVector
kList
kDeque
kMap
kMultimap
kSet
kMultiset
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
TList*TQObject::fListOfSignals! list of signals from this object
TList*TQObject::fListOfConnections! list of connections to this object
TStringTNamed::fNameobject identifier
TStringTNamed::fTitleobject title

Class Description

                                                                      
 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).                            
                                                                      

TQClass(const char *name, Version_t cversion, const type_info &info, TVirtualIsAProxy *isa, ShowMembersFunc_t showmembers, const char *dfil = 0, const char *ifil = 0, Int_t dl = 0, Int_t il = 0)
{ }
virtual ~TQClass()
{ Disconnect(); }

Author: Valeriy Onuchin & Fons Rademakers 15/10/2000
Last update: root/base:$Name: $:$Id: TQObject.cxx,v 1.49 2006/11/16 17:17:37 rdm Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *


ROOT page - Class index - Class Hierarchy - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.