// @(#)root/eve:$Id$
// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

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

#ifndef ROOT_TEveElement
#define ROOT_TEveElement

#include "TEveUtil.h"
#include "TEveProjectionBases.h"

#include "TNamed.h"
#include "TRef.h"

class TGListTree;
class TGListTreeItem;
class TGPicture;

class TEveCompound;
class TEveTrans;
class TGeoMatrix;

/******************************************************************************/
// TEveElement
/******************************************************************************/

class TEveElement
{
   friend class TEveManager;

   TEveElement& operator=(const TEveElement&); // Not implemented

public:
   class TEveListTreeInfo
   {
   public:
      TGListTree*     fTree;
      TGListTreeItem* fItem;

      TEveListTreeInfo() : fTree(0), fItem(0) {}
      TEveListTreeInfo(TGListTree* lt, TGListTreeItem* lti) : fTree(lt), fItem(lti) {}
      TEveListTreeInfo(const TEveListTreeInfo& l) : fTree(l.fTree), fItem(l.fItem) {}
      virtual ~TEveListTreeInfo() {}

      TEveListTreeInfo& operator=(const TEveListTreeInfo& l)
      { fTree = l.fTree; fItem = l.fItem; return *this; }

      bool operator==(const TEveListTreeInfo& x) const
      { return fTree == x.fTree && fItem == x.fItem; }
      bool operator<(const TEveListTreeInfo& x) const
      { return fTree == x.fTree ? fItem < x.fItem : fTree < x.fTree; }

      ClassDef(TEveListTreeInfo, 0); // Structure agregating data for a render element image in a list tree.
   };

   static const TGPicture*                      fgRnrIcons[4];
   static const TGPicture*                      fgListTreeIcons[9];

   typedef std::set<TEveListTreeInfo>           sLTI_t;
   typedef sLTI_t::iterator                     sLTI_i;
   typedef sLTI_t::reverse_iterator             sLTI_ri;

   typedef std::list<TEveElement*>              List_t;
   typedef List_t::iterator                     List_i;
   typedef List_t::const_iterator               List_ci;

   typedef std::set<TEveElement*>               Set_t;
   typedef Set_t::iterator                      Set_i;
   typedef Set_t::const_iterator                Set_ci;

protected:
   List_t           fParents;              //  List of parents.
   List_t           fChildren;             //  List of children.
   TEveCompound    *fCompound;             //  Compound this object belongs to.
   TEveElement     *fVizModel;             //! Element used as model from VizDB.
   TString          fVizTag;               //  Tag used to query VizDB for model element.

   Int_t            fNumChildren;          //!
   Int_t            fParentIgnoreCnt;      //! Counter for parents that are ignored in ref-counting.
   Int_t            fTopItemCnt;           //! Counter for top-level list-tree items that prevent automatic destruction.
   Int_t            fDenyDestroy;          //! Deny-destroy count.
   Bool_t           fDestroyOnZeroRefCnt;  //  Auto-destruct when ref-count reaches zero.

   Bool_t           fRnrSelf;                 //  Render this element.
   Bool_t           fRnrChildren;             //  Render children of this element.
   Bool_t           fCanEditMainColor;        //  Allow editing of main color.
   Bool_t           fCanEditMainTransparency; //  Allow editing of main transparency.
   Bool_t           fCanEditMainTrans;        //  Allow editing of main transformation.

   Char_t           fMainTransparency;     //  Main-transparency variable.
   Color_t         *fMainColorPtr;         //  Pointer to main-color variable.
   TEveTrans       *fMainTrans;            //  Pointer to main transformation matrix.

   sLTI_t           fItems;                //! Set of list-tree-items.

   TRef             fSource;               //  External object that is represented by this element.
   void            *fUserData;             //! Externally assigned and controlled user data.

   virtual void PreDeleteElement();
   virtual void RemoveElementsInternal();
   virtual void AnnihilateRecursively();

   static const char* ToString(Bool_t b);

public:
   TEveElement();
   TEveElement(Color_t& main_color);
   TEveElement(const TEveElement& e);
   virtual ~TEveElement();

   virtual TEveElement* CloneElement() const;
   virtual TEveElement* CloneElementRecurse(Int_t level=0) const;
   virtual void         CloneChildrenRecurse(TEveElement* dest, Int_t level=0) const;

   virtual const char* GetElementName()  const;
   virtual const char* GetElementTitle() const;
   virtual TString     GetHighlightTooltip() { return TString(GetElementTitle()); }
   virtual void SetElementName (const char* name);
   virtual void SetElementTitle(const char* title);
   virtual void SetElementNameTitle(const char* name, const char* title);
   virtual void NameTitleChanged();

   const TString& GetVizTag() const             { return fVizTag; }
   void           SetVizTag(const TString& tag) { fVizTag = tag;  }

   TEveElement*   GetVizModel() const           { return fVizModel; }
   void           SetVizModel(TEveElement* model);
   Bool_t         FindVizModel();

   Bool_t         ApplyVizTag(const TString& tag, const TString& fallback_tag="");

   virtual void PropagateVizParamsToProjecteds();
   virtual void PropagateVizParamsToElements(TEveElement* el=0);
   virtual void CopyVizParams(const TEveElement* el);
   virtual void CopyVizParamsFromDB();
   void         SaveVizParams (std::ostream& out, const TString& tag, const TString& var);
   virtual void WriteVizParams(std::ostream& out, const TString& var);

   TEveElement*  GetMaster();
   TEveCompound* GetCompound()                { return fCompound; }
   void          SetCompound(TEveCompound* c) { fCompound = c;    }

   virtual void AddParent(TEveElement* re);
   virtual void RemoveParent(TEveElement* re);
   virtual void CheckReferenceCount(const TEveException& eh="TEveElement::CheckReferenceCount ");
   virtual void CollectSceneParents(List_t& scenes);
   virtual void CollectSceneParentsFromChildren(List_t& scenes,
                                                TEveElement* parent);

   List_i  BeginParents()        { return  fParents.begin();  }
   List_i  EndParents()          { return  fParents.end();    }
   List_ci BeginParents()  const { return  fParents.begin();  }
   List_ci EndParents()    const { return  fParents.end();    }
   Int_t   NumParents()    const { return  fParents.size();   }
   Bool_t  HasParents()    const { return !fParents.empty();  }

   const List_t& RefChildren() const { return  fChildren;     }
   List_i  BeginChildren()       { return  fChildren.begin(); }
   List_i  EndChildren()         { return  fChildren.end();   }
   List_ci BeginChildren() const { return  fChildren.begin(); }
   List_ci EndChildren()   const { return  fChildren.end();   }
   Int_t   NumChildren()   const { return  fNumChildren;      }
   Bool_t  HasChildren()   const { return  fNumChildren != 0; }

   Bool_t       HasChild(TEveElement* el);
   TEveElement* FindChild(const TString& name, const TClass* cls=0);
   TEveElement* FindChild(TPRegexp& regexp, const TClass* cls=0);
   Int_t        FindChildren(List_t& matches, const TString&  name, const TClass* cls=0);
   Int_t        FindChildren(List_t& matches, TPRegexp& regexp, const TClass* cls=0);
   TEveElement* FirstChild() const;
   TEveElement* LastChild () const;

   void EnableListElements (Bool_t rnr_self=kTRUE,  Bool_t rnr_children=kTRUE);  // *MENU*
   void DisableListElements(Bool_t rnr_self=kFALSE, Bool_t rnr_children=kFALSE); // *MENU*

   Bool_t GetDestroyOnZeroRefCnt() const;
   void   SetDestroyOnZeroRefCnt(Bool_t d);

   Int_t  GetDenyDestroy() const;
   void   IncDenyDestroy();
   void   DecDenyDestroy();

   Int_t  GetParentIgnoreCnt() const;
   void   IncParentIgnoreCnt();
   void   DecParentIgnoreCnt();

   virtual void PadPaint(Option_t* option);
   virtual void PaintStandard(TObject* id);

   virtual TObject* GetObject      (const TEveException& eh) const;
   virtual TObject* GetEditorObject(const TEveException& eh) const { return GetObject(eh); }
   virtual TObject* GetRenderObject(const TEveException& eh) const { return GetObject(eh); }

   // --------------------------------

   virtual void ExpandIntoListTree(TGListTree* ltree, TGListTreeItem* parent);
   virtual void DestroyListSubTree(TGListTree* ltree, TGListTreeItem* parent);

   virtual TGListTreeItem* AddIntoListTree(TGListTree* ltree,
                                           TGListTreeItem* parent_lti);
   virtual TGListTreeItem* AddIntoListTree(TGListTree* ltree,
                                           TEveElement* parent);
   virtual TGListTreeItem* AddIntoListTrees(TEveElement* parent);

   virtual Bool_t          RemoveFromListTree(TGListTree* ltree,
                                              TGListTreeItem* parent_lti);
   virtual Int_t           RemoveFromListTrees(TEveElement* parent);

   virtual sLTI_i          FindItem(TGListTree* ltree);
   virtual sLTI_i          FindItem(TGListTree* ltree,
                                    TGListTreeItem* parent_lti);
   virtual TGListTreeItem* FindListTreeItem(TGListTree* ltree);
   virtual TGListTreeItem* FindListTreeItem(TGListTree* ltree,
                                            TGListTreeItem* parent_lti);

   virtual Int_t GetNItems() const { return fItems.size(); }

   void         SpawnEditor();                // *MENU*
   virtual void ExportToCINT(char* var_name); // *MENU*

   void    DumpSourceObject() const;                       // *MENU*
   void    PrintSourceObject() const;                      // *MENU*
   void    ExportSourceObjectToCINT(char* var_name) const; // *MENU*

   virtual Bool_t AcceptElement(TEveElement* el);

   virtual void AddElement(TEveElement* el);
   virtual void RemoveElement(TEveElement* el);
   virtual void RemoveElementLocal(TEveElement* el);
   virtual void RemoveElements();
   virtual void RemoveElementsLocal();

   virtual void AnnihilateElements();
   virtual void Annihilate();

   virtual void ProjectChild(TEveElement* el, Bool_t same_depth=kTRUE);
   virtual void ProjectAllChildren(Bool_t same_depth=kTRUE);

   virtual void Destroy();                      // *MENU*
   virtual void DestroyOrWarn();
   virtual void DestroyElements();              // *MENU*

   virtual Bool_t HandleElementPaste(TEveElement* el);
   virtual void   ElementChanged(Bool_t update_scenes=kTRUE, Bool_t redraw=kFALSE);

   virtual Bool_t CanEditElement() const { return kTRUE; }
   virtual Bool_t SingleRnrState() const { return kFALSE; }
   virtual Bool_t GetRnrSelf()     const { return fRnrSelf; }
   virtual Bool_t GetRnrChildren() const { return fRnrChildren; }
   virtual Bool_t GetRnrState()    const { return fRnrSelf && fRnrChildren; }
   virtual Bool_t GetRnrAnything() const { return fRnrSelf || (fRnrChildren && HasChildren()); }
   virtual Bool_t SetRnrSelf(Bool_t rnr);
   virtual Bool_t SetRnrChildren(Bool_t rnr);
   virtual Bool_t SetRnrSelfChildren(Bool_t rnr_self, Bool_t rnr_children);
   virtual Bool_t SetRnrState(Bool_t rnr);
   virtual void   PropagateRnrStateToProjecteds();

   virtual Bool_t CanEditMainColor() const   { return fCanEditMainColor; }
   void           SetEditMainColor(Bool_t x) { fCanEditMainColor = x; }
   Color_t* GetMainColorPtr()        const   { return fMainColorPtr; }
   void     SetMainColorPtr(Color_t* color)  { fMainColorPtr = color; }

   virtual Bool_t  HasMainColor() const { return fMainColorPtr != 0; }
   virtual Color_t GetMainColor() const { return fMainColorPtr ? *fMainColorPtr : 0; }
   virtual void    SetMainColor(Color_t color);
   void            SetMainColorPixel(Pixel_t pixel);
   void            SetMainColorRGB(UChar_t r, UChar_t g, UChar_t b);
   void            SetMainColorRGB(Float_t r, Float_t g, Float_t b);
   virtual void    PropagateMainColorToProjecteds(Color_t color, Color_t old_color);

   virtual Bool_t  CanEditMainTransparency() const   { return fCanEditMainTransparency; }
   void            SetEditMainTransparency(Bool_t x) { fCanEditMainTransparency = x; }
   virtual Char_t  GetMainTransparency()     const { return fMainTransparency; }
   virtual void    SetMainTransparency(Char_t t);
   void            SetMainAlpha(Float_t alpha);
   virtual void    PropagateMainTransparencyToProjecteds(Char_t t, Char_t old_t);

   virtual Bool_t     CanEditMainTrans() const { return fCanEditMainTrans; }
   virtual Bool_t     HasMainTrans()     const { return fMainTrans != 0;   }
   virtual TEveTrans* PtrMainTrans(Bool_t create=kTRUE);
   virtual TEveTrans& RefMainTrans();
   virtual void       InitMainTrans(Bool_t can_edit=kTRUE);
   virtual void       DestroyMainTrans();

   virtual void SetTransMatrix(Double_t* carr);
   virtual void SetTransMatrix(const TGeoMatrix& mat);

   TRef&    GetSource()                 { return fSource; }
   TObject* GetSourceObject()     const { return fSource.GetObject(); }
   void     SetSourceObject(TObject* o) { fSource = o; }
   /*
     void DumpSourceObject();    // *MENU*
     void InspectSourceObject(); // *MENU*
   */

   void* GetUserData() const { return fUserData; }
   void  SetUserData(void* ud) { fUserData = ud; }


   // Selection state and management
   //--------------------------------

protected:
   Bool_t  fPickable;
   Bool_t  fSelected;             //!
   Bool_t  fHighlighted;          //!
   Short_t fImpliedSelected;      //!
   Short_t fImpliedHighlighted;   //!

   enum ECompoundSelectionColorBits
   {
      kCSCBImplySelectAllChildren           = BIT(0), // compound will select all children
      kCSCBTakeAnyParentAsMaster            = BIT(1), // element will take any compound parent as master
      kCSCBApplyMainColorToAllChildren      = BIT(2), // compound will apply color change to all children
      kCSCBApplyMainColorToMatchingChildren = BIT(3), // compound will apply color change to all children with matching color
      kCSCBApplyMainTransparencyToAllChildren      = BIT(4), // compound will apply transparency change to all children
      kCSCBApplyMainTransparencyToMatchingChildren = BIT(5)  // compound will apply transparency change to all children with matching color
   };

   enum EDestruct
   {
      kNone,
      kStandard,
      kAnnihilate
   };

   UChar_t fCSCBits;

public:
   typedef void (TEveElement::* Select_foo)      (Bool_t);
   typedef void (TEveElement::* ImplySelect_foo) ();

   Bool_t IsPickable()    const { return fPickable; }
   void   SetPickable(Bool_t p) { fPickable = p; }
   void   SetPickableRecursively(Bool_t p);

   virtual TEveElement* ForwardSelection();
   virtual TEveElement* ForwardEdit();

   virtual void SelectElement(Bool_t state);
   virtual void IncImpliedSelected();
   virtual void DecImpliedSelected();
   virtual void UnSelected();

   virtual void HighlightElement(Bool_t state);
   virtual void IncImpliedHighlighted();
   virtual void DecImpliedHighlighted();
   virtual void UnHighlighted();

   virtual void FillImpliedSelectedSet(Set_t& impSelSet);

   virtual UChar_t GetSelectedLevel() const;

   void   RecheckImpliedSelections();

   void   SetCSCBits(UChar_t f)   { fCSCBits |=  f; }
   void   ResetCSCBits(UChar_t f) { fCSCBits &= ~f; }
   Bool_t TestCSCBits(UChar_t f) const { return (fCSCBits & f) != 0; }

   void   ResetAllCSCBits()                     { fCSCBits  =  0; }
   void   CSCImplySelectAllChildren()           { fCSCBits |= kCSCBImplySelectAllChildren; }
   void   CSCTakeAnyParentAsMaster()            { fCSCBits |= kCSCBTakeAnyParentAsMaster;  }
   void   CSCApplyMainColorToAllChildren()      { fCSCBits |= kCSCBApplyMainColorToAllChildren; }
   void   CSCApplyMainColorToMatchingChildren() { fCSCBits |= kCSCBApplyMainColorToMatchingChildren; }
   void   CSCApplyMainTransparencyToAllChildren()      { fCSCBits |= kCSCBApplyMainTransparencyToAllChildren; }
   void   CSCApplyMainTransparencyToMatchingChildren() { fCSCBits |= kCSCBApplyMainTransparencyToMatchingChildren; }


   // Change-stamping and change bits
   //---------------------------------

   enum EChangeBits
   {
      kCBColorSelection =  BIT(0), // Main color or select/hilite state changed.
      kCBTransBBox      =  BIT(1), // Transformation matrix or bounding-box changed.
      kCBObjProps       =  BIT(2), // Object changed, requires dropping its display-lists.
      kCBVisibility     =  BIT(3)  // Rendering of self/children changed.
      // kCBElementAdded   = BIT(), // Element was added to a new parent.
      // kCBElementRemoved = BIT()  // Element was removed from a parent.

      // Deletions are handled in a special way in TEveManager::PreDeleteElement().
   };

protected:
   UChar_t      fChangeBits;  //!
   Char_t       fDestructing; //!

public:
   void StampColorSelection() { AddStamp(kCBColorSelection); }
   void StampTransBBox()      { AddStamp(kCBTransBBox); }
   void StampObjProps()       { AddStamp(kCBObjProps); }
   void StampVisibility()     { AddStamp(kCBVisibility); }
   // void StampElementAdded()   { AddStamp(kCBElementAdded); }
   // void StampElementRemoved() { AddStamp(kCBElementRemoved); }
   virtual void AddStamp(UChar_t bits);
   virtual void ClearStamps() { fChangeBits = 0; }

   UChar_t GetChangeBits() const { return fChangeBits; }


   // List-tree icons
   //-----------------

   virtual const TGPicture* GetListTreeIcon(Bool_t open=kFALSE);
   virtual const TGPicture* GetListTreeCheckBoxIcon();

   // Menu entries for VizDB communication (here so they are last in the menu).

   void VizDB_Apply(const char* tag);           // *MENU*
   void VizDB_Reapply();                        // *MENU*
   void VizDB_UpdateModel(Bool_t update=kTRUE); // *MENU*
   void VizDB_Insert(const char* tag, Bool_t replace=kTRUE, Bool_t update=kTRUE); // *MENU*

   ClassDef(TEveElement, 0); // Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management.
};


/******************************************************************************/
// TEveElementObjectPtr
/******************************************************************************/

class TEveElementObjectPtr : public TEveElement,
                             public TObject
{
   TEveElementObjectPtr& operator=(const TEveElementObjectPtr&); // Not implemented

protected:
   TObject* fObject;     // External object holding the visual data.
   Bool_t   fOwnObject;  // Is object owned / should be deleted on destruction.

public:
   TEveElementObjectPtr(TObject* obj, Bool_t own=kTRUE);
   TEveElementObjectPtr(TObject* obj, Color_t& mainColor, Bool_t own=kTRUE);
   TEveElementObjectPtr(const TEveElementObjectPtr& e);
   virtual ~TEveElementObjectPtr();

   virtual TEveElementObjectPtr* CloneElement() const;

   virtual TObject* GetObject(const TEveException& eh="TEveElementObjectPtr::GetObject ") const;
   virtual void     ExportToCINT(char* var_name);

   Bool_t GetOwnObject() const   { return fOwnObject; }
   void   SetOwnObject(Bool_t o) { fOwnObject = o; }

   ClassDef(TEveElementObjectPtr, 0); // TEveElement with external TObject as a holder of visualization data.
};


/******************************************************************************/
// TEveElementList
/******************************************************************************/

class TEveElementList : public TEveElement,
                        public TNamed,
                        public TEveProjectable
{
private:
   TEveElementList& operator=(const TEveElementList&); // Not implemented

protected:
   Color_t   fColor;          // Color of the object.
   TClass   *fChildClass;     // Class of acceptable children, others are rejected.

public:
   TEveElementList(const char* n="TEveElementList", const char* t="",
                   Bool_t doColor=kFALSE, Bool_t doTransparency=kFALSE);
   TEveElementList(const TEveElementList& e);
   virtual ~TEveElementList() {}

   virtual TObject* GetObject(const TEveException& /*eh*/="TEveElementList::GetObject ") const
   { const TObject* obj = this; return const_cast<TObject*>(obj); }

   virtual TEveElementList* CloneElement() const;

   virtual const char* GetElementName()  const { return GetName();  }
   virtual const char* GetElementTitle() const { return GetTitle(); }

   virtual void SetElementName (const char* name)
   { TNamed::SetName(name); NameTitleChanged(); }

   virtual void SetElementTitle(const char* title)
   { TNamed::SetTitle(title); NameTitleChanged(); }

   virtual void SetElementNameTitle(const char* name, const char* title)
   { TNamed::SetNameTitle(name, title); NameTitleChanged(); }

   TClass* GetChildClass() const { return fChildClass; }
   void    SetChildClass(TClass* c) { fChildClass = c; }

   virtual Bool_t  AcceptElement(TEveElement* el);

   virtual TClass* ProjectedClass(const TEveProjection* p) const;

   ClassDef(TEveElementList, 0); // List of TEveElement objects with a possibility to limit the class of accepted elements.
};


/******************************************************************************/
// TEveElementListProjected
/******************************************************************************/

class TEveElementListProjected : public TEveElementList,
                                 public TEveProjected
{
private:
   TEveElementListProjected(const TEveElementListProjected&);            // Not implemented
   TEveElementListProjected& operator=(const TEveElementListProjected&); // Not implemented

public:
   TEveElementListProjected();
   virtual ~TEveElementListProjected() {}

   virtual void UpdateProjection();
   virtual TEveElement* GetProjectedAsElement() { return this; }

   ClassDef(TEveElementListProjected, 0); // Projected TEveElementList.
};

#endif
 TEveElement.h:1
 TEveElement.h:2
 TEveElement.h:3
 TEveElement.h:4
 TEveElement.h:5
 TEveElement.h:6
 TEveElement.h:7
 TEveElement.h:8
 TEveElement.h:9
 TEveElement.h:10
 TEveElement.h:11
 TEveElement.h:12
 TEveElement.h:13
 TEveElement.h:14
 TEveElement.h:15
 TEveElement.h:16
 TEveElement.h:17
 TEveElement.h:18
 TEveElement.h:19
 TEveElement.h:20
 TEveElement.h:21
 TEveElement.h:22
 TEveElement.h:23
 TEveElement.h:24
 TEveElement.h:25
 TEveElement.h:26
 TEveElement.h:27
 TEveElement.h:28
 TEveElement.h:29
 TEveElement.h:30
 TEveElement.h:31
 TEveElement.h:32
 TEveElement.h:33
 TEveElement.h:34
 TEveElement.h:35
 TEveElement.h:36
 TEveElement.h:37
 TEveElement.h:38
 TEveElement.h:39
 TEveElement.h:40
 TEveElement.h:41
 TEveElement.h:42
 TEveElement.h:43
 TEveElement.h:44
 TEveElement.h:45
 TEveElement.h:46
 TEveElement.h:47
 TEveElement.h:48
 TEveElement.h:49
 TEveElement.h:50
 TEveElement.h:51
 TEveElement.h:52
 TEveElement.h:53
 TEveElement.h:54
 TEveElement.h:55
 TEveElement.h:56
 TEveElement.h:57
 TEveElement.h:58
 TEveElement.h:59
 TEveElement.h:60
 TEveElement.h:61
 TEveElement.h:62
 TEveElement.h:63
 TEveElement.h:64
 TEveElement.h:65
 TEveElement.h:66
 TEveElement.h:67
 TEveElement.h:68
 TEveElement.h:69
 TEveElement.h:70
 TEveElement.h:71
 TEveElement.h:72
 TEveElement.h:73
 TEveElement.h:74
 TEveElement.h:75
 TEveElement.h:76
 TEveElement.h:77
 TEveElement.h:78
 TEveElement.h:79
 TEveElement.h:80
 TEveElement.h:81
 TEveElement.h:82
 TEveElement.h:83
 TEveElement.h:84
 TEveElement.h:85
 TEveElement.h:86
 TEveElement.h:87
 TEveElement.h:88
 TEveElement.h:89
 TEveElement.h:90
 TEveElement.h:91
 TEveElement.h:92
 TEveElement.h:93
 TEveElement.h:94
 TEveElement.h:95
 TEveElement.h:96
 TEveElement.h:97
 TEveElement.h:98
 TEveElement.h:99
 TEveElement.h:100
 TEveElement.h:101
 TEveElement.h:102
 TEveElement.h:103
 TEveElement.h:104
 TEveElement.h:105
 TEveElement.h:106
 TEveElement.h:107
 TEveElement.h:108
 TEveElement.h:109
 TEveElement.h:110
 TEveElement.h:111
 TEveElement.h:112
 TEveElement.h:113
 TEveElement.h:114
 TEveElement.h:115
 TEveElement.h:116
 TEveElement.h:117
 TEveElement.h:118
 TEveElement.h:119
 TEveElement.h:120
 TEveElement.h:121
 TEveElement.h:122
 TEveElement.h:123
 TEveElement.h:124
 TEveElement.h:125
 TEveElement.h:126
 TEveElement.h:127
 TEveElement.h:128
 TEveElement.h:129
 TEveElement.h:130
 TEveElement.h:131
 TEveElement.h:132
 TEveElement.h:133
 TEveElement.h:134
 TEveElement.h:135
 TEveElement.h:136
 TEveElement.h:137
 TEveElement.h:138
 TEveElement.h:139
 TEveElement.h:140
 TEveElement.h:141
 TEveElement.h:142
 TEveElement.h:143
 TEveElement.h:144
 TEveElement.h:145
 TEveElement.h:146
 TEveElement.h:147
 TEveElement.h:148
 TEveElement.h:149
 TEveElement.h:150
 TEveElement.h:151
 TEveElement.h:152
 TEveElement.h:153
 TEveElement.h:154
 TEveElement.h:155
 TEveElement.h:156
 TEveElement.h:157
 TEveElement.h:158
 TEveElement.h:159
 TEveElement.h:160
 TEveElement.h:161
 TEveElement.h:162
 TEveElement.h:163
 TEveElement.h:164
 TEveElement.h:165
 TEveElement.h:166
 TEveElement.h:167
 TEveElement.h:168
 TEveElement.h:169
 TEveElement.h:170
 TEveElement.h:171
 TEveElement.h:172
 TEveElement.h:173
 TEveElement.h:174
 TEveElement.h:175
 TEveElement.h:176
 TEveElement.h:177
 TEveElement.h:178
 TEveElement.h:179
 TEveElement.h:180
 TEveElement.h:181
 TEveElement.h:182
 TEveElement.h:183
 TEveElement.h:184
 TEveElement.h:185
 TEveElement.h:186
 TEveElement.h:187
 TEveElement.h:188
 TEveElement.h:189
 TEveElement.h:190
 TEveElement.h:191
 TEveElement.h:192
 TEveElement.h:193
 TEveElement.h:194
 TEveElement.h:195
 TEveElement.h:196
 TEveElement.h:197
 TEveElement.h:198
 TEveElement.h:199
 TEveElement.h:200
 TEveElement.h:201
 TEveElement.h:202
 TEveElement.h:203
 TEveElement.h:204
 TEveElement.h:205
 TEveElement.h:206
 TEveElement.h:207
 TEveElement.h:208
 TEveElement.h:209
 TEveElement.h:210
 TEveElement.h:211
 TEveElement.h:212
 TEveElement.h:213
 TEveElement.h:214
 TEveElement.h:215
 TEveElement.h:216
 TEveElement.h:217
 TEveElement.h:218
 TEveElement.h:219
 TEveElement.h:220
 TEveElement.h:221
 TEveElement.h:222
 TEveElement.h:223
 TEveElement.h:224
 TEveElement.h:225
 TEveElement.h:226
 TEveElement.h:227
 TEveElement.h:228
 TEveElement.h:229
 TEveElement.h:230
 TEveElement.h:231
 TEveElement.h:232
 TEveElement.h:233
 TEveElement.h:234
 TEveElement.h:235
 TEveElement.h:236
 TEveElement.h:237
 TEveElement.h:238
 TEveElement.h:239
 TEveElement.h:240
 TEveElement.h:241
 TEveElement.h:242
 TEveElement.h:243
 TEveElement.h:244
 TEveElement.h:245
 TEveElement.h:246
 TEveElement.h:247
 TEveElement.h:248
 TEveElement.h:249
 TEveElement.h:250
 TEveElement.h:251
 TEveElement.h:252
 TEveElement.h:253
 TEveElement.h:254
 TEveElement.h:255
 TEveElement.h:256
 TEveElement.h:257
 TEveElement.h:258
 TEveElement.h:259
 TEveElement.h:260
 TEveElement.h:261
 TEveElement.h:262
 TEveElement.h:263
 TEveElement.h:264
 TEveElement.h:265
 TEveElement.h:266
 TEveElement.h:267
 TEveElement.h:268
 TEveElement.h:269
 TEveElement.h:270
 TEveElement.h:271
 TEveElement.h:272
 TEveElement.h:273
 TEveElement.h:274
 TEveElement.h:275
 TEveElement.h:276
 TEveElement.h:277
 TEveElement.h:278
 TEveElement.h:279
 TEveElement.h:280
 TEveElement.h:281
 TEveElement.h:282
 TEveElement.h:283
 TEveElement.h:284
 TEveElement.h:285
 TEveElement.h:286
 TEveElement.h:287
 TEveElement.h:288
 TEveElement.h:289
 TEveElement.h:290
 TEveElement.h:291
 TEveElement.h:292
 TEveElement.h:293
 TEveElement.h:294
 TEveElement.h:295
 TEveElement.h:296
 TEveElement.h:297
 TEveElement.h:298
 TEveElement.h:299
 TEveElement.h:300
 TEveElement.h:301
 TEveElement.h:302
 TEveElement.h:303
 TEveElement.h:304
 TEveElement.h:305
 TEveElement.h:306
 TEveElement.h:307
 TEveElement.h:308
 TEveElement.h:309
 TEveElement.h:310
 TEveElement.h:311
 TEveElement.h:312
 TEveElement.h:313
 TEveElement.h:314
 TEveElement.h:315
 TEveElement.h:316
 TEveElement.h:317
 TEveElement.h:318
 TEveElement.h:319
 TEveElement.h:320
 TEveElement.h:321
 TEveElement.h:322
 TEveElement.h:323
 TEveElement.h:324
 TEveElement.h:325
 TEveElement.h:326
 TEveElement.h:327
 TEveElement.h:328
 TEveElement.h:329
 TEveElement.h:330
 TEveElement.h:331
 TEveElement.h:332
 TEveElement.h:333
 TEveElement.h:334
 TEveElement.h:335
 TEveElement.h:336
 TEveElement.h:337
 TEveElement.h:338
 TEveElement.h:339
 TEveElement.h:340
 TEveElement.h:341
 TEveElement.h:342
 TEveElement.h:343
 TEveElement.h:344
 TEveElement.h:345
 TEveElement.h:346
 TEveElement.h:347
 TEveElement.h:348
 TEveElement.h:349
 TEveElement.h:350
 TEveElement.h:351
 TEveElement.h:352
 TEveElement.h:353
 TEveElement.h:354
 TEveElement.h:355
 TEveElement.h:356
 TEveElement.h:357
 TEveElement.h:358
 TEveElement.h:359
 TEveElement.h:360
 TEveElement.h:361
 TEveElement.h:362
 TEveElement.h:363
 TEveElement.h:364
 TEveElement.h:365
 TEveElement.h:366
 TEveElement.h:367
 TEveElement.h:368
 TEveElement.h:369
 TEveElement.h:370
 TEveElement.h:371
 TEveElement.h:372
 TEveElement.h:373
 TEveElement.h:374
 TEveElement.h:375
 TEveElement.h:376
 TEveElement.h:377
 TEveElement.h:378
 TEveElement.h:379
 TEveElement.h:380
 TEveElement.h:381
 TEveElement.h:382
 TEveElement.h:383
 TEveElement.h:384
 TEveElement.h:385
 TEveElement.h:386
 TEveElement.h:387
 TEveElement.h:388
 TEveElement.h:389
 TEveElement.h:390
 TEveElement.h:391
 TEveElement.h:392
 TEveElement.h:393
 TEveElement.h:394
 TEveElement.h:395
 TEveElement.h:396
 TEveElement.h:397
 TEveElement.h:398
 TEveElement.h:399
 TEveElement.h:400
 TEveElement.h:401
 TEveElement.h:402
 TEveElement.h:403
 TEveElement.h:404
 TEveElement.h:405
 TEveElement.h:406
 TEveElement.h:407
 TEveElement.h:408
 TEveElement.h:409
 TEveElement.h:410
 TEveElement.h:411
 TEveElement.h:412
 TEveElement.h:413
 TEveElement.h:414
 TEveElement.h:415
 TEveElement.h:416
 TEveElement.h:417
 TEveElement.h:418
 TEveElement.h:419
 TEveElement.h:420
 TEveElement.h:421
 TEveElement.h:422
 TEveElement.h:423
 TEveElement.h:424
 TEveElement.h:425
 TEveElement.h:426
 TEveElement.h:427
 TEveElement.h:428
 TEveElement.h:429
 TEveElement.h:430
 TEveElement.h:431
 TEveElement.h:432
 TEveElement.h:433
 TEveElement.h:434
 TEveElement.h:435
 TEveElement.h:436
 TEveElement.h:437
 TEveElement.h:438
 TEveElement.h:439
 TEveElement.h:440
 TEveElement.h:441
 TEveElement.h:442
 TEveElement.h:443
 TEveElement.h:444
 TEveElement.h:445
 TEveElement.h:446
 TEveElement.h:447
 TEveElement.h:448
 TEveElement.h:449
 TEveElement.h:450
 TEveElement.h:451
 TEveElement.h:452
 TEveElement.h:453
 TEveElement.h:454
 TEveElement.h:455
 TEveElement.h:456
 TEveElement.h:457
 TEveElement.h:458
 TEveElement.h:459
 TEveElement.h:460
 TEveElement.h:461
 TEveElement.h:462
 TEveElement.h:463
 TEveElement.h:464
 TEveElement.h:465
 TEveElement.h:466
 TEveElement.h:467
 TEveElement.h:468
 TEveElement.h:469
 TEveElement.h:470
 TEveElement.h:471
 TEveElement.h:472
 TEveElement.h:473
 TEveElement.h:474
 TEveElement.h:475
 TEveElement.h:476
 TEveElement.h:477
 TEveElement.h:478
 TEveElement.h:479
 TEveElement.h:480
 TEveElement.h:481
 TEveElement.h:482
 TEveElement.h:483
 TEveElement.h:484
 TEveElement.h:485
 TEveElement.h:486
 TEveElement.h:487
 TEveElement.h:488
 TEveElement.h:489
 TEveElement.h:490
 TEveElement.h:491
 TEveElement.h:492
 TEveElement.h:493
 TEveElement.h:494
 TEveElement.h:495
 TEveElement.h:496
 TEveElement.h:497
 TEveElement.h:498
 TEveElement.h:499
 TEveElement.h:500
 TEveElement.h:501
 TEveElement.h:502
 TEveElement.h:503
 TEveElement.h:504
 TEveElement.h:505
 TEveElement.h:506
 TEveElement.h:507
 TEveElement.h:508
 TEveElement.h:509
 TEveElement.h:510
 TEveElement.h:511
 TEveElement.h:512
 TEveElement.h:513
 TEveElement.h:514
 TEveElement.h:515
 TEveElement.h:516
 TEveElement.h:517
 TEveElement.h:518
 TEveElement.h:519
 TEveElement.h:520
 TEveElement.h:521
 TEveElement.h:522
 TEveElement.h:523
 TEveElement.h:524
 TEveElement.h:525