class TROOT: public TDirectory

                R O O T top level object description

    The TROOT object is the entry point to the ROOT system.
    The single instance of TROOT is accessible via the global gROOT.
    Using the gROOT pointer one has access to basically every object
    created in a ROOT based program. The TROOT object is essentially a
    container of several lists pointing to the main ROOT objects.

    The following lists are accessible from gROOT object:
       gROOT->GetListOfClasses
       gROOT->GetListOfColors
       gROOT->GetListOfTypes
       gROOT->GetListOfGlobals
       gROOT->GetListOfGlobalFunctions
       gROOT->GetListOfFiles
       gROOT->GetListOfMappedFiles
       gROOT->GetListOfSockets
       gROOT->GetListOfSecContexts
       gROOT->GetListOfCanvases
       gROOT->GetListOfStyles
       gROOT->GetListOfFunctions
       gROOT->GetListOfSpecials (for example graphical cuts)
       gROOT->GetListOfGeometries
       gROOT->GetListOfBrowsers
       gROOT->GetListOfCleanups
       gROOT->GetListOfMessageHandlers

   The TROOT class provides also many useful services:
     - Get pointer to an object in any of the lists above
     - Time utilities TROOT::Time

   The ROOT object must be created as a static object. An example
   of a main program creating an interactive version is shown below:

Example of a main program

       #include "TRint.h"

       int main(int argc, char **argv)
       {
          TRint *theApp = new TRint("ROOT example", &argc, argv);

          // Init Intrinsics, build all windows, and enter event loop
          theApp->Run();

          return(0);
       }
End of Main program

Function Members (Methods)

public:
virtual~TROOT()
voidTObject::AbstractMethod(const char* method) const
virtual voidTDirectory::Add(TObject* obj)
voidAddClass(TClass* cl)
voidAddClassGenerator(TClassGenerator* gen)
static voidTDirectory::AddDirectory(Bool_t add = kTRUE)
static Bool_tTDirectory::AddDirectoryStatus()
virtual voidTDirectory::Append(TObject* obj)
virtual Int_tTDirectory::AppendKey(TKey*)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidBrowse(TBrowser* b)
virtual voidTDirectory::Build(TFile* motherFile = 0, TDirectory* motherDir = 0)
virtual Bool_tTDirectory::cd(const char* path = 0)
static Bool_tTDirectory::Cd(const char* path)
static TClass*Class()
virtual const char*TObject::ClassName() const
Bool_tClassSaved(TClass* cl)
virtual voidTDirectory::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual TObject*TDirectory::CloneObject(const TObject* obj)
virtual voidTDirectory::Close(Option_t* option = "")
virtual Int_tTNamed::Compare(const TObject* obj) const
static Int_tConvertVersionCode2Int(Int_t code)
static Int_tConvertVersionInt2Code(Int_t v)
virtual voidTDirectory::Copy(TObject&) const
static voidTDirectory::DecodeNameCycle(const char* namecycle, char* name, Short_t& cycle)
static Int_tDecreaseDirLevel()
virtual voidTDirectory::Delete(const char* namecycle = "")
virtual voidTDirectory::DeleteAll(Option_t* option = "")
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTDirectory::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTObject::Dump() const
static voidTDirectory::EncodeNameCycle(char* buffer, const char* name, Short_t cycle)
virtual voidTObject::Error(const char* method, const char* msgfmt) 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 TKey*TDirectory::FindKey(const char*) const
virtual TKey*TDirectory::FindKeyAny(const char*) const
virtual TObject*FindObject(const char* name) const
virtual TObject*FindObject(const TObject* obj) const
virtual TObject*FindObjectAny(const char* name) const
virtual TObject*TDirectory::FindObjectAnyFile(const char*) const
const char*FindObjectClassName(const char* name) const
const char*FindObjectPathName(const TObject* obj) const
TObject*FindSpecialObject(const char* name, void*& where)
TClass*FindSTLClass(const char* name, Bool_t load) const
voidForceStyle(Bool_t force = kTRUE)
Bool_tFromPopUp() const
virtual TObject*TDirectory::Get(const char* namecycle)
TApplication*GetApplication() const
virtual Int_tTDirectory::GetBufferSize() const
Int_tGetBuiltDate() const
Int_tGetBuiltTime() const
TClass*GetClass(const char* name, Bool_t load = kTRUE) const
TClass*GetClass(const type_info& typeinfo, Bool_t load = kTRUE) const
TSeqCollection*GetClipboard() const
TColor*GetColor(Int_t color) const
const char*GetConfigOptions() const
const char*GetCutClassName() const
const char*GetDefCanvasName() const
virtual TDirectory*TDirectory::GetDirectory(const char* namecycle, Bool_t printError = false, const char* funcname = "GetDirectory")
static Int_tGetDirLevel()
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
Bool_tGetEditHistograms() const
Int_tGetEditorMode() const
virtual TFile*GetFile() const
TFile*GetFile(const char* name) const
Bool_tGetForceStyle() const
TObject*GetFunction(const char* name) const
TObject*GetGeometry(const char* name) const
TGlobal*GetGlobal(const char* name, Bool_t load = kFALSE) const
TGlobal*GetGlobal(const TObject* obj, Bool_t load = kFALSE) const
TFunction*GetGlobalFunction(const char* name, const char* params = 0, Bool_t load = kFALSE)
TFunction*GetGlobalFunctionWithPrototype(const char* name, const char* proto = 0, Bool_t load = kFALSE)
virtual const char*TObject::GetIconName() const
TInterpreter*GetInterpreter() const
virtual TKey*TDirectory::GetKey(const char*, Short_t = 9999) const
virtual TList*TDirectory::GetList() const
TList*GetListOfBrowsables() const
TSeqCollection*GetListOfBrowsers() const
TSeqCollection*GetListOfCanvases() const
TCollection*GetListOfClasses() const
TCollection*GetListOfClassGenerators() const
TSeqCollection*GetListOfCleanups() const
TSeqCollection*GetListOfColors() const
TSeqCollection*GetListOfDataSets() const
TSeqCollection*GetListOfFiles() const
TCollection*GetListOfFunctions() const
TSeqCollection*GetListOfGeometries() const
TCollection*GetListOfGlobalFunctions(Bool_t load = kFALSE)
TCollection*GetListOfGlobals(Bool_t load = kFALSE)
virtual TList*TDirectory::GetListOfKeys() const
TSeqCollection*GetListOfMappedFiles() const
TSeqCollection*GetListOfMessageHandlers() const
TSeqCollection*GetListOfProofs() const
TSeqCollection*GetListOfSecContexts() const
TSeqCollection*GetListOfSockets() const
TSeqCollection*GetListOfSpecials() const
TSeqCollection*GetListOfStreamerInfo() const
TSeqCollection*GetListOfStyles() const
TSeqCollection*GetListOfTasks() const
TCollection*GetListOfTypes(Bool_t load = kFALSE)
static const char*GetMacroPath()
virtual TObject*TDirectory::GetMother() const
virtual TDirectory*TDirectory::GetMotherDir() const
virtual const char*TNamed::GetName() const
virtual Int_tTDirectory::GetNbytesKeys() const
Int_tGetNclasses() const
virtual Int_tTDirectory::GetNkeys() const
Int_tGetNtypes() const
voidTDirectory::GetObject(const char* namecycle, void*& ptr)
virtual void*TDirectory::GetObjectChecked(const char* namecycle, const char* classname)
virtual void*TDirectory::GetObjectChecked(const char* namecycle, const TClass* cl)
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual void*TDirectory::GetObjectUnchecked(const char* namecycle)
virtual Option_t*TObject::GetOption() const
virtual const char*TDirectory::GetPath() const
virtual const char*TDirectory::GetPathStatic() const
TPluginManager*GetPluginManager() const
TFolder*GetRootFolder() const
virtual Long64_tTDirectory::GetSeekDir() const
virtual Long64_tTDirectory::GetSeekKeys() const
virtual Long64_tTDirectory::GetSeekParent() const
TVirtualPad*GetSelectedPad() const
TObject*GetSelectedPrimitive() const
TStyle*GetStyle(const char* name) const
const char*GetSvnBranch() const
const char*GetSvnDate()
Int_tGetSvnRevision() const
virtual const char*TNamed::GetTitle() const
TDataType*GetType(const char* name, Bool_t load = kFALSE) const
virtual UInt_tTObject::GetUniqueID() const
TUUIDTDirectory::GetUUID() const
TProcessUUID*GetUUIDs() const
const char*GetVersion() const
Int_tGetVersionCode() const
Int_tGetVersionDate() const
Int_tGetVersionInt() const
Int_tGetVersionTime() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
voidIdle(UInt_t idleTimeInSec, const char* command = 0)
Int_tIgnoreInclude(const char* fname, const char* expandedfname)
static Int_tIncreaseDirLevel()
static voidIndentLevel()
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
static Bool_tInitialized()
virtual voidTObject::Inspect() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tIsBatch() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
Bool_tIsEscaped() const
Bool_tIsExecutingMacro() const
virtual Bool_tIsFolder() const
Bool_tIsInterrupted() const
Bool_tIsLineProcessing() const
virtual Bool_tTDirectory::IsModified() const
Bool_tTObject::IsOnHeap() const
Bool_tIsProofServ() const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tTDirectory::IsWritable() const
Bool_tTObject::IsZombie() const
TClass*LoadClass(const char* name) const
Int_tLoadClass(const char* classname, const char* libname, Bool_t check = kFALSE)
Int_tLoadMacro(const char* filename, Int_t* error = 0, Bool_t check = kFALSE)
virtual voidls(Option_t* option = "") const
Long_tMacro(const char* filename, Int_t* error = 0, Bool_t padUpdate = kTRUE)
TCanvas*MakeDefCanvas() const
voidTObject::MayNotUse(const char* method) const
static Bool_tMemCheck()
voidMessage(Int_t id, const TObject* obj)
virtual TDirectory*TDirectory::mkdir(const char* name, const char* title = "")
Bool_tMustClean() const
virtual Bool_tTObject::Notify()
virtual TFile*TDirectory::OpenFile(const char*, Option_t* = "", const char* = "", Int_t = 1, Int_t = 0)
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)
virtual voidTDirectory::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTDirectory::Print(Option_t* option = "") const
Long_tProcessLine(const char* line, Int_t* error = 0)
Long_tProcessLineFast(const char* line, Int_t* error = 0)
Long_tProcessLineSync(const char* line, Int_t* error = 0)
virtual voidTDirectory::Purge(Short_t = 1)
virtual voidTDirectory::pwd() const
virtual Int_tTObject::Read(const char* name)
virtual voidTDirectory::ReadAll(Option_t* = "")
Bool_tReadingObject() const
virtual Int_tTDirectory::ReadKeys()
virtual Int_tTDirectory::ReadTObject(TObject*, const char*)
virtual voidTDirectory::RecursiveRemove(TObject* obj)
voidRefreshBrowsers()
voidRemoveClass(TClass*)
voidReset(Option_t* option = "")
voidTObject::ResetBit(UInt_t f)
virtual voidTDirectory::rmdir(const char* name)
static Int_tRootVersionCode()
virtual voidTDirectory::Save()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
voidSaveContext()
virtual Int_tTDirectory::SaveObjectAs(const TObject*, const char* = "", Option_t* = "")
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
virtual voidTDirectory::SaveSelf(Bool_t = kFALSE)
voidSetApplication(TApplication* app)
voidSetBatch(Bool_t batch = kTRUE)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTDirectory::SetBufferSize(Int_t)
voidSetCutClassName(const char* name = "TCutG")
voidSetDefCanvasName(const char* name = "c1")
static voidSetDirLevel(Int_t level = 0)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
voidSetEditHistograms(Bool_t flag = kTRUE)
voidSetEditorMode(const char* mode = "")
voidSetEscape(Bool_t flag = kTRUE)
voidSetExecutingMacro(Bool_t flag = kTRUE)
voidSetFromPopUp(Bool_t flag = kTRUE)
voidSetInterrupt(Bool_t flag = kTRUE)
voidSetLineHasBeenProcessed()
voidSetLineIsProcessing()
static voidSetMacroPath(const char* newpath)
virtual voidTDirectory::SetModified()
virtual voidTDirectory::SetMother(const TObject* mother)
voidSetMustClean(Bool_t flag = kTRUE)
virtual voidTDirectory::SetName(const char* newname)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetReadingObject(Bool_t flag = kTRUE)
virtual voidTDirectory::SetSeekDir(Long64_t)
voidSetSelectedPad(TVirtualPad* pad)
voidSetSelectedPrimitive(const TObject* obj)
voidSetStyle(const char* stylename = "Default")
virtual voidTNamed::SetTitle(const char* title = "")
virtual voidTDirectory::SetTRefAction(TObject*, TObject*)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidTDirectory::SetWritable(Bool_t)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual Int_tTDirectory::Sizeof() 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
voidTime(Int_t casetime = 1)
Int_tTimer() const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTDirectory::Write(const char* = 0, Int_t = 0, Int_t = 0)
virtual Int_tTDirectory::Write(const char* = 0, Int_t = 0, Int_t = 0) const
virtual voidTDirectory::WriteDirHeader()
virtual voidTDirectory::WriteKeys()
Int_tTDirectory::WriteObject(const void* obj, const char* name, Option_t* option = "", Int_t bufsize = 0)
virtual Int_tTDirectory::WriteObjectAny(const void*, const char*, const char*, Option_t* = "", Int_t = 0)
virtual Int_tTDirectory::WriteObjectAny(const void*, const TClass*, const char*, Option_t* = "", Int_t = 0)
virtual Int_tTDirectory::WriteTObject(const TObject* obj, const char* name = 0, Option_t* = "", Int_t = 0)
protected:
Bool_tTDirectory::cd1(const char* path)
static Bool_tTDirectory::Cd1(const char* path)
virtual voidTDirectory::CleanTargets()
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTDirectory::FillFullPath(TString& buf) const
voidInitSystem()
voidInitThreads()
voidTObject::MakeZombie()
void*operator new(size_t l)
voidReadSvnInfo()
voidTDirectory::RegisterContext(TDirectory::TContext* ctxt)
voidTDirectory::UnregisterContext(TDirectory::TContext* ctxt)
private:
TROOT&operator=(const TROOT&)

Data Members

public:
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
TApplication*fApplicationPointer to current application
Bool_tfBatchTrue if session without graphics
TList*fBrowsablesList of browsables
TSeqCollection*fBrowsersList of browsers
Int_tfBuiltDateDate of ROOT built
Int_tfBuiltTimeTime of ROOT built
TSeqCollection*fCanvasesList of canvases
TCollection*fClassGeneratorsList of user defined class generators;
TCollection*fClassesList of classes definition
TSeqCollection*fCleanupsList of recursiveRemove collections
TSeqCollection*fClipboardList of clipbard objects
TSeqCollection*fColorsList of colors
TStringfConfigOptionsROOT ./configure build options
TDirectory::TContext*TDirectory::fContext!Pointer to a list of TContext object pointing to this TDirectory
TStringfCutClassNameName of default CutG class in graphics editor
TSeqCollection*fDataSetsList of data sets (TDSet or TChain)
TStringfDefCanvasNameName of default canvas
Bool_tfEditHistogramsTrue if histograms can be edited with the mouse
Int_tfEditorModeCurrent Editor mode
Bool_tfEscapeTrue if ESC has been pressed
Bool_tfExecutingMacroTrue while executing a TMacro
TSeqCollection*fFilesList of files
Bool_tfForceStyleForce setting of current style when reading objects
Bool_tfFromPopUpTrue if command executed from a popup menu
TCollection*fFunctionsList of analytic functions
TSeqCollection*fGeometriesList of geometries
TCollection*fGlobalFunctionsList of global functions
TCollection*fGlobalsList of global variables
TInterpreter*fInterpreterCommand interpreter
Bool_tfInterruptTrue if macro should be interrupted
TList*TDirectory::fListList of objects in memory
TSeqCollection*fMappedFilesList of memory mapped files
TSeqCollection*fMessageHandlersList of message handlers
TObject*TDirectory::fMotherpointer to mother of the directory
Bool_tfMustCleanTrue if object destructor scans canvases
TStringTNamed::fNameobject identifier
TStringTDirectory::fPathBuffer!Buffer for GetPath() function
TPluginManager*fPluginManagerKeeps track of plugin library handlers
TObject*fPrimitiveCurrently selected primitive
TSeqCollection*fProofsList of proof sessions
Bool_tfReadingObjectTrue while reading an object
TFolder*fRootFoldertop level folder //root
TSeqCollection*fSecContextsList of security contexts (TSecContext)
TVirtualPad*fSelectPadCurrently selected pad
TSeqCollection*fSocketsList of network sockets
TSeqCollection*fSpecialsList of special objects
TSeqCollection*fStreamerInfoList of active StreamerInfo classes
TSeqCollection*fStylesList of styles
TStringfSvnBranchSubversion branch
TStringfSvnDateDate and time when make was run
Int_tfSvnRevisionSubversion revision number of built
TSeqCollection*fTasksList of tasks
Int_tfTimerTimer flag
TStringTNamed::fTitleobject title
TCollection*fTypesList of data types definition
TUUIDTDirectory::fUUIDUnique identifier
TProcessUUID*fUUIDsPointer to TProcessID managing TUUIDs
TStringfVersionROOT version (from CMZ VERSQQ) ex 0.05/01
Int_tfVersionCodeROOT version code as used in RVersion.h
Int_tfVersionDateDate of ROOT version (ex 951226)
Int_tfVersionIntROOT version in integer format (501)
Int_tfVersionTimeTime of ROOT version (ex 1152)
static Bool_tTDirectory::fgAddDirectory!flag to add histograms, graphs,etc to the directory
private:
Int_tfLineIsProcessingTo synchronize multi-threads
static Int_tfgDirLevelIndentation level for ls()
static Bool_tfgMemCheckTurn on memory leak checker
static Bool_tfgRootInitSingleton initialization flag

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

~TROOT()
 Clean up and free resources used by ROOT (files, network sockets,
 shared memory segments, etc.).
void AddClass(TClass* cl)
 Add a class to the list and map of classes.
void AddClassGenerator(TClassGenerator* gen)
 Add a class generator.  This generator will be called by TClass::GetClass
 in case its does not find a loaded rootcint dictionary to request the
 creation of a TClass object.
void Browse(TBrowser* b)
 Add browsable objects to TBrowser.
Bool_t ClassSaved(TClass* cl)
 return class status bit kClassSaved for class cl
 This function is called by the SavePrimitive functions writing
 the C++ code for an object.
TObject * FindObject(const TObject *)
 Find an object in one Root folder
TObject * FindObject(const char *name)
 Returns address of a ROOT object if it exists

 If name contains at least one "/" the function calls FindObjectany
 else
 This function looks in the following order in the ROOT lists:
     - List of files
     - List of memory mapped files
     - List of functions
     - List of geometries
     - List of canvases
     - List of styles
     - List of specials
     - List of materials in current geometry
     - List of shapes in current geometry
     - List of matrices in current geometry
     - List of Nodes in current geometry
     - Current Directory in memory
     - Current Directory on file
TObject * FindSpecialObject(const char* name, void*& where)
 Returns address and folder of a ROOT object if it exists

 This function looks in the following order in the ROOT lists:
     - List of files
     - List of memory mapped files
     - List of functions
     - List of geometries
     - List of canvases
     - List of styles
     - List of specials
     - List of materials in current geometry
     - List of shapes in current geometry
     - List of matrices in current geometry
     - List of Nodes in current geometry
     - Current Directory in memory
     - Current Directory on file
TObject * FindObjectAny(const char* name) const
 Return a pointer to the first object with name starting at //root.
 This function scans the list of all folders.
 if no object found in folders, it scans the memory list of all files.
const char * FindObjectClassName(const char* name) const
 Returns class name of a ROOT object including CINT globals.
const char * FindObjectPathName(const TObject* obj) const
 Return path name of obj somewhere in the //root/... path.
 The function returns the first occurence of the object in the list
 of folders. The returned string points to a static char array in TROOT.
 If this function is called in a loop or recursively, it is the
 user's responsability to copy this string in his area.
TClass * FindSTLClass(const char* name, Bool_t load) const
 return a TClass object corresponding to 'name' assuming it is an STL container.
 In particular we looking for possible alternative name (default template
 parameter, typedefs template arguments, typedefed name).
TClass * GetClass(const char *name, Bool_t load)
 Return pointer to class with name. Obsolete, use TClass::GetClass directly
TClass * GetClass(const type_info& typeinfo, Bool_t load)
 Return pointer to class from its name. Obsolete, use TClass::GetClass directly
 See TClass::GetClass
TColor * GetColor(Int_t color) const
 Return address of color with index color.
TCanvas * MakeDefCanvas()
 Return a default canvas.
TDataType * GetType(const char* name, Bool_t load = kFALSE) const
 Return pointer to type with name.
TFile * GetFile(const char* name) const
 Return pointer to file with name.
TStyle * GetStyle(const char* name) const
 Return pointer to style with name
TObject * GetFunction(const char* name) const
 Return pointer to function with name.
TGlobal * GetGlobal(const char *name, Bool_t load)
 Return pointer to global variable by name. If load is true force
 reading of all currently defined globals from CINT (more expensive).
TGlobal * GetGlobal(const TObject *addr, Bool_t load)
 Return pointer to global variable with address addr. If load is true
 force reading of all currently defined globals from CINT (more
 expensive).
TFunction * GetGlobalFunction(const char* name, const char* params = 0, Bool_t load = kFALSE)
 Return pointer to global function by name. If params != 0
 it will also resolve overloading. If load is true force reading
 of all currently defined global functions from CINT (more expensive).
 The param string must be of the form: "3189,\"aap\",1.3".
TFunction * GetGlobalFunctionWithPrototype(const char* name, const char* proto = 0, Bool_t load = kFALSE)
 Return pointer to global function by name. If proto != 0
 it will also resolve overloading. If load is true force reading
 of all currently defined global functions from CINT (more expensive).
 The proto string must be of the form: "int, char*, float".
TObject * GetGeometry(const char* name) const
 Return pointer to Geometry with name
TCollection * GetListOfGlobals(Bool_t load = kFALSE)
 Return list containing the TGlobals currently defined.
 Since globals are created and deleted during execution of the
 program, we need to update the list of globals every time we
 execute this method. However, when calling this function in
 a (tight) loop where no interpreter symbols will be created
 you can set load=kFALSE (default).
TCollection * GetListOfGlobalFunctions(Bool_t load = kFALSE)
 Return list containing the TFunctions currently defined.
 Since functions are created and deleted during execution of the
 program, we need to update the list of functions every time we
 execute this method. However, when calling this function in
 a (tight) loop where no interpreter symbols will be created
 you can set load=kFALSE (default).
TCollection * GetListOfTypes(Bool_t load = kFALSE)
 Return list containing all TDataTypes (typedefs) currently defined.
 Since types can be added and removed during execution of the
 program, we need to update the list of types every time we
 execute this method. However, when calling this function in
 a (tight) loop where no new types will be created
 you can set load=kFALSE (default).
void Idle(UInt_t idleTimeInSec, const char* command = 0)
 Execute command when system has been idle for idleTimeInSec seconds.
Int_t IgnoreInclude(const char* fname, const char* expandedfname)
 Return true if the given include file correspond to a class that has
 been loaded through a compiled dictionnary.
void InitSystem()
 Initialize operating system interface.
void InitThreads()
 Load and initialize thread library.
TClass * LoadClass(const char* name) const
 Helper function used by TClass::GetClass().
 This function attempts to load the dictionary for 'classname'
 either from the TClassTable or from the list of generator.
Int_t LoadClass(const char* classname, const char* libname, Bool_t check = kFALSE)
 Check if class "classname" is known to the interpreter. If
 not it will load library "libname". If the library name does
 not start with "lib", "lib" will be prepended and a search will
 be made in the DynamicPath (see .rootrc). If not found a search
 will be made on libname (without "lib" prepended) and if not found
 a direct try of libname will be made (in case it contained an
 absolute path).
 If check is true it will only check if libname exists and is
 readable.
 Returns 0 on successful loading, -1 in case libname does not
 exist or in case of error and -2 in case of version mismatch.
void ls(Option_t* option = "") const
 To list all objects of the application.
 Loop on all objects created in the ROOT linked lists.
 Objects may be files and windows or any other object directly
 attached to the ROOT linked list.
Int_t LoadMacro(const char* filename, Int_t* error = 0, Bool_t check = kFALSE)
 Load a macro in the interpreter's memory. Equivalent to the command line
 command ".L filename". If the filename has "+" or "++" appended
 the macro will be compiled by ACLiC. The filename must have the format:
 [path/]macro.C[+|++[g|O]].
 The possible error codes are defined by TInterpreter::EErrorCode.
 If check is true it will only check if filename exists and is
 readable.
 Returns 0 on successful loading and -1 in case filename does not
 exist or in case of error.
Long_t Macro(const char* filename, Int_t* error = 0, Bool_t padUpdate = kTRUE)
 Execute a macro in the interpreter. Equivalent to the command line
 command ".x filename". If the filename has "+" or "++" appended
 the macro will be compiled by ACLiC. The filename must have the format:
 [path/]macro.C[+|++[g|O]][(args)].
 The possible error codes are defined by TInterpreter::EErrorCode.
 If padUpdate is true (default) update the current pad.
 Returns the macro return value.
void Message(Int_t id, const TObject* obj)
 Process message id called by obj.
Long_t ProcessLine(const char* line, Int_t* error = 0)
 Process interpreter command via TApplication::ProcessLine().
 On Win32 the line will be processed a-synchronously by sending
 it to the CINT interpreter thread. For explicit synchrounous processing
 use ProcessLineSync(). On non-Win32 platforms there is not difference
 between ProcessLine() and ProcessLineSync().
 The possible error codes are defined by TInterpreter::EErrorCode. In
 particular, error will equal to TInterpreter::kProcessing until the
 CINT interpreted thread has finished executing the line.
 Returns the result of the command, cast to a Long_t.
Long_t ProcessLineSync(const char* line, Int_t* error = 0)
 Process interpreter command via TApplication::ProcessLine().
 On Win32 the line will be processed synchronously (i.e. it will
 only return when the CINT interpreter thread has finished executing
 the line). On non-Win32 platforms there is not difference between
 ProcessLine() and ProcessLineSync().
 The possible error codes are defined by TInterpreter::EErrorCode.
 Returns the result of the command, cast to a Long_t.
Long_t ProcessLineFast(const char* line, Int_t* error = 0)
 Process interpreter command directly via CINT interpreter.
 Only executable statements are allowed (no variable declarations),
 In all other cases use TROOT::ProcessLine().
 The possible error codes are defined by TInterpreter::EErrorCode.
void ReadSvnInfo()
 Read Subversion revision information and branch name from the
 etc/svnrev.txt file.
const char * GetSvnDate()
 Return date/time make was run.
void RefreshBrowsers()
 Refresh all browsers. Call this method when some command line
 command or script has changed the browser contents. Not needed
 for objects that have the kMustCleanup bit set. Most useful to
 update browsers that show the file system or other objects external
 to the running ROOT session.
void RemoveClass(TClass* )
 Remove a class from the list and map of classes
void Reset(Option_t* option = "")
 Delete all global interpreter objects created since the last call to Reset

 If option="a" is set reset to startup context (i.e. unload also
 all loaded files, classes, structs, typedefs, etc.).

 This function is typically used at the beginning (or end) of a macro
 to clean the environment.
void SaveContext()
 Save the current interpreter context.
void SetCutClassName(const char* name = "TCutG")
 Set the default graphical cut class name for the graphics editor
 By default the graphics editor creates an instance of a class TCutG.
 This function may be called to specify a different class that MUST
 derive from TCutG
void SetEditorMode(const char* mode = "")
 Set editor mode
void SetStyle(const char* stylename = "Default")
 Change current style to style with name stylename
Int_t DecreaseDirLevel()
 Decrease the indentation level for ls().
Int_t GetDirLevel()
return directory level
const char * GetMacroPath()
 Get macro search path. Static utility function.
void SetMacroPath(const char* newpath)
 Set or extend the macro search path. Static utility function.
 If newpath=0 or "" reset to value specified in the rootrc file.
Int_t IncreaseDirLevel()
 Increase the indentation level for ls().
void IndentLevel()
 Functions used by ls() to indent an object hierarchy.
Bool_t Initialized()
 Return kTRUE if the TROOT object has been initialized.
Bool_t MemCheck()
 Return kTRUE if the memory leak checke is on.
void SetDirLevel(Int_t level = 0)
 Return Indentation level for ls().
Int_t ConvertVersionCode2Int(Int_t code)
 Convert version code to an integer, i.e. 331527 -> 51507.
Int_t ConvertVersionInt2Code(Int_t v)
 Convert version as an integer to version code as used in RVersion.h.
Int_t RootVersionCode()
 Return ROOT version code as defined in RVersion.h.
TROOT& operator=(const TROOT& )
void * operator new(size_t l)
{ return TObject::operator new(l); }
void ForceStyle(Bool_t force = kTRUE)
{ fForceStyle = force; }
Bool_t FromPopUp()
{ return fFromPopUp; }
TPluginManager * GetPluginManager()
{ return fPluginManager; }
TApplication * GetApplication()
{ return fApplication; }
TInterpreter * GetInterpreter()
{ return fInterpreter; }
const char * GetConfigOptions()
{ return fConfigOptions; }
const char * GetCutClassName()
{ return fCutClassName; }
const char * GetDefCanvasName()
{ return fDefCanvasName; }
Bool_t GetEditHistograms()
{ return fEditHistograms; }
Int_t GetEditorMode()
{ return fEditorMode; }
Bool_t GetForceStyle()
{ return fForceStyle; }
Int_t GetBuiltDate()
{ return fBuiltDate; }
Int_t GetBuiltTime()
{ return fBuiltTime; }
Int_t GetSvnRevision()
{ return fSvnRevision; }
const char * GetSvnBranch()
{ return fSvnBranch; }
Int_t GetVersionDate()
{ return fVersionDate; }
Int_t GetVersionTime()
{ return fVersionTime; }
Int_t GetVersionInt()
{ return fVersionInt; }
Int_t GetVersionCode()
{ return fVersionCode; }
const char * GetVersion()
{ return fVersion; }
TCollection * GetListOfClasses()
{ return fClasses; }
TSeqCollection * GetListOfColors()
{ return fColors; }
TSeqCollection * GetListOfFiles()
{ return fFiles; }
TSeqCollection * GetListOfMappedFiles()
{ return fMappedFiles; }
TSeqCollection * GetListOfSockets()
{ return fSockets; }
TSeqCollection * GetListOfCanvases()
{ return fCanvases; }
TSeqCollection * GetListOfStyles()
{ return fStyles; }
TCollection * GetListOfFunctions()
{ return fFunctions; }
TSeqCollection * GetListOfGeometries()
{ return fGeometries; }
TSeqCollection * GetListOfBrowsers()
{ return fBrowsers; }
TSeqCollection * GetListOfSpecials()
{ return fSpecials; }
TSeqCollection * GetListOfTasks()
{ return fTasks; }
TSeqCollection * GetListOfCleanups()
{ return fCleanups; }
TSeqCollection * GetListOfStreamerInfo()
{ return fStreamerInfo; }
TSeqCollection * GetListOfMessageHandlers()
{ return fMessageHandlers; }
TCollection * GetListOfClassGenerators()
{ return fClassGenerators; }
TSeqCollection * GetListOfSecContexts()
{ return fSecContexts; }
TSeqCollection * GetListOfProofs()
{ return fProofs; }
TSeqCollection * GetClipboard()
{ return fClipboard; }
TSeqCollection * GetListOfDataSets()
{ return fDataSets; }
TList * GetListOfBrowsables()
{ return fBrowsables; }
TFile * GetFile(const char* name) const
{ if (gDirectory != this) return gDirectory->GetFile(); else return 0;}
TObject * GetSelectedPrimitive()
{ return fPrimitive; }
TVirtualPad * GetSelectedPad()
{ return fSelectPad; }
Int_t GetNclasses()
{ return fClasses->GetSize(); }
Int_t GetNtypes()
{ return fTypes->GetSize(); }
TFolder * GetRootFolder()
{ return fRootFolder; }
TProcessUUID * GetUUIDs()
{ return fUUIDs; }
Bool_t IsBatch()
{ return fBatch; }
Bool_t IsExecutingMacro()
{ return fExecutingMacro; }
Bool_t IsFolder()
{ return kTRUE; }
Bool_t IsInterrupted()
{ return fInterrupt; }
Bool_t IsEscaped()
{ return fEscape; }
Bool_t IsLineProcessing()
{ return fLineIsProcessing ? kTRUE : kFALSE; }
Bool_t IsProofServ()
{ return fName == "proofserv" ? kTRUE : kFALSE; }
Bool_t MustClean()
{ return fMustClean; }
Bool_t ReadingObject()
{ return fReadingObject; }
void SetApplication(TApplication* app)
{ fApplication = app; }
void SetBatch(Bool_t batch = kTRUE)
{ fBatch = batch; }
void SetDefCanvasName(const char* name = "c1")
{ fDefCanvasName = name; }
void SetEditHistograms(Bool_t flag = kTRUE)
{ fEditHistograms = flag; }
void SetExecutingMacro(Bool_t flag = kTRUE)
{ fExecutingMacro = flag; }
void SetFromPopUp(Bool_t flag = kTRUE)
{ fFromPopUp = flag; }
void SetInterrupt(Bool_t flag = kTRUE)
{ fInterrupt = flag; }
void SetEscape(Bool_t flag = kTRUE)
{ fEscape = flag; }
void SetLineIsProcessing()
{ fLineIsProcessing++; }
void SetLineHasBeenProcessed()
{ if (fLineIsProcessing) fLineIsProcessing--; }
void SetReadingObject(Bool_t flag = kTRUE)
{ fReadingObject = flag; }
void SetMustClean(Bool_t flag = kTRUE)
{ fMustClean=flag; }
void SetSelectedPrimitive(const TObject* obj)
{ fPrimitive = (TObject*)obj; }
void SetSelectedPad(TVirtualPad* pad)
{ fSelectPad = pad; }
void Time(Int_t casetime = 1)
{ fTimer = casetime; }
Int_t Timer()
{ return fTimer; }

Author: Rene Brun 08/12/94
Last update: root/base:$Id: TROOT.h 20877 2007-11-19 11:17:07Z rdm $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *

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.