// @(#)root/eve:$Id: TEveElement.h 43018 2012-02-16 03:13:21Z matevz $ // 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 sLTI_t; typedef sLTI_t::iterator sLTI_i; typedef sLTI_t::reverse_iterator sLTI_ri; typedef std::list List_t; typedef List_t::iterator List_i; typedef List_t::const_iterator List_ci; typedef std::set 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 (ostream& out, const TString& tag, const TString& var); virtual void WriteVizParams(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(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