class TClassTree: public TNamed

 Draw inheritance tree and their relations for a list of classes
 The following options are supported
   - Direct inheritance (default)
   - Multiple inheritance
   - Composition
   - References by data members and member functions
   - References from Code

 The list of classes is specified:
   - either in the TClassTree constructor as a second argument
   - or the parameter to TClassTRee::Draw

 Note that the ClassTree viewer can also be started from the canvas
 pull down menu "Classes".

 In the list of classes, class names are separated by a ":"
 wildcarding is supported.
 The following formats are supported, eg in TClassTree::Draw
   1- Draw("ClassA")
         Draw inheritance tree for ClassA
         Show all classes referenced by ClassA
   2- Draw("*ClassB")
         Draw inheritance tree for ClassB
         and all the classes deriving from ClassB
   3- Draw(">ClassC")
         Draw inheritance tree for ClassC
         Show classes referencing ClassC
   4- Draw("ClassD<")
         Draw inheritance tree for ClassD
         Show classes referenced by ClassD
         Show all classes referencing ClassD
   5- Draw("Cla*")
         Draw inheritance tree for all classes with name starting with "Cla"
         Show classes referenced by these classes
   6- Draw("ClassA:ClassB<")
         Draw inheritance tree for ClassA
         Show all classes referenced by ClassA
         Draw inheritance tree for ClassB
         Show classes referenced by ClassB
         Show all classes referencing ClassB

  example;  Draw("TTree<")
         Draw inheritance tree for the Root class TTree
         Show all classes referenced by TTree
         Show all classes using TTree

 By default, only direct inheritance is drawn.
 Use TClassTree::ShowLinks(option) to show additional references
   option = "H" to show links to embedded classes
   option = "M" to show multiple inheritance
   option = "R" to show pointers to other classes from data members
   option = "C" to show classes used by the code(implementation) of a class

 The following picture is produced directly by:
       TClassTree ct("ct","*TH1")
 It shows all the classes derived from the base class TH1.

 The ClassTree class uses the services of the class TPaveClass to
 show the class names. By clicking with the right mouse button in
 one TPaveClass object, one can invoke the following functions of TClassTree:
   - ShowLinks(option) with by default option = "HMR"
   - Draw(classes). By default the class drawn is the one being pointed
   - ShowClassesUsedBy(classes) (by default the pointed class)
   - ShowClassesUsing(classes) (by default the pointed class)

  The following picture has been generated with the following statements
       TClassTree tc1("tc1","TObject");
       tc1.SetShowLinks("HMR");

 Note that in case of embedded classes or pointers to classes,
 the corresponding dashed lines or arrows respectively start
 in the TPaveClass object at an X position reflecting the position
 in the list of data members.

  - References by data members to other classes are show with a full red line
  - Multiple inheritance is shown with a dashed blue line
  - "Has a" relation is shown with a dotted cyan line
  - References from code is shown by a full green line

  Use TClassTree::SetSourceDir to specify the search path for source files.
  By default the search path includes the ROOTSYS/src directory, the current
  directory and the subdirectory src.

  The first time TClassTree::Draw is invoked, all the classes in the
  current application are processed, including the parsing of the code
  to find all classes referenced by the include statements.
  This process may take a few seconds. The following commands will be
  much faster.

  A TClassTree object may be saved in a Root file.
  This object can be processed later by a Root program that ignores
  the original classes. This interesting possibility allows to send
  the class structure of an application to a colleague who does not have
  your classes.
  Example:
    TFile f("myClasses.root","recreate")
    TClassTree *ct = new TClassTree("ct","ATLF*")
    ct->Write();
  You can send at this point the file myClass.root to a colleague who can
  run the following Root basic session
     TFile f("myClass.root"); //connect the file
     tt.ls();                 //to list all classes and titles
     tt.Draw("ATLFDisplay")   //show class ATLFDisplay with all its dependencies
  At this point, one has still access to all the classes present
  in the original session and select any combination of these classes
  to be displayed.