ROOT logo
// @(#)root/gui:$Id: TGListTree.h 38753 2011-04-06 13:14:08Z bellenot $
// Author: Fons Rademakers   25/02/98

/*************************************************************************
 * Copyright (C) 1995-2000, 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_TGListTree
#define ROOT_TGListTree


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGListTree and TGListTreeItem                                        //
//                                                                      //
// A list tree is a widget that can contain a number of items           //
// arranged in a tree structure. The items are represented by small     //
// folder icons that can be either open or closed.                      //
//                                                                      //
// The TGListTree is user callable. The TGListTreeItem is a service     //
// class of the list tree.                                              //
//                                                                      //
// A list tree can generate the following events:                       //
// kC_LISTTREE, kCT_ITEMCLICK, which button, location (y<<16|x).        //
// kC_LISTTREE, kCT_ITEMDBLCLICK, which button, location (y<<16|x).     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TGCanvas
#include "TGCanvas.h"
#endif
#ifndef ROOT_TGWidget
#include "TGWidget.h"
#endif
#ifndef ROOT_TDNDManager
#include "TGDNDManager.h"
#endif

class TGPicture;
class TGToolTip;
class TGCanvas;
class TList;
class TBufferFile;

class TGListTreeItem
{
   friend class TGListTree;

private:
   TGListTreeItem(const TGListTreeItem&);             // not implemented
   TGListTreeItem& operator=(const TGListTreeItem&);  // not implemented

protected:
   TGClient        *fClient;       // pointer to TGClient
   TGListTreeItem  *fParent;       // pointer to parent
   TGListTreeItem  *fFirstchild;   // pointer to first child item
   TGListTreeItem  *fLastchild;    // pointer to last child item
   TGListTreeItem  *fPrevsibling;  // pointer to previous sibling
   TGListTreeItem  *fNextsibling;  // pointer to next sibling

   Bool_t           fOpen;         // true if item is open

   Int_t            fDNDState;     // EDNDFlags

   // State managed by TGListTree during drawing.
   Int_t            fY;            // y position of item
   Int_t            fXtext;        // x position of item text
   Int_t            fYtext;        // y position of item text
   UInt_t           fHeight;       // item height

public:
   TGListTreeItem(TGClient *client=gClient);
   virtual ~TGListTreeItem() {}

   TGListTreeItem *GetParent()      const { return fParent; }
   TGListTreeItem *GetFirstChild()  const { return fFirstchild; }
   TGListTreeItem *GetLastChild()   const { return fLastchild;  }
   TGListTreeItem *GetPrevSibling() const { return fPrevsibling; }
   TGListTreeItem *GetNextSibling() const { return fNextsibling; }

   virtual Bool_t          IsOpen()    const { return fOpen; }
   virtual void            SetOpen(Bool_t o) { fOpen = o; }

   virtual Bool_t          IsActive() const = 0;
   virtual Pixel_t         GetActiveColor() const = 0;
   virtual void            SetActive(Bool_t) {}

   void                    Rename(const char* new_name) { SetText(new_name); }
   virtual const char     *GetText() const = 0;
   virtual Int_t           GetTextLength() const = 0;
   virtual const char     *GetTipText() const = 0;
   virtual Int_t           GetTipTextLength() const = 0;
   virtual void            SetText(const char *) {}
   virtual void            SetTipText(const char *) {}

   virtual void            SetUserData(void *, Bool_t=kFALSE) {}
   virtual void           *GetUserData() const = 0;

   virtual const TGPicture*GetPicture() const = 0;
   virtual void            SetPictures(const TGPicture*, const TGPicture*) {}
   virtual const TGPicture*GetCheckBoxPicture() const = 0;
   virtual void            SetCheckBoxPictures(const TGPicture*, const TGPicture*) {}
   virtual UInt_t          GetPicWidth() const;

   virtual void            SetCheckBox(Bool_t=kTRUE) {}
   virtual Bool_t          HasCheckBox() const = 0;
   virtual void            CheckItem(Bool_t=kTRUE) = 0;
   virtual void            Toggle() { SetCheckBox( ! IsChecked()); }
   virtual Bool_t          IsChecked() const = 0;

   // Propagation of checked-state form children to parents.
   virtual void            CheckAllChildren(Bool_t=kTRUE) {}
   virtual void            CheckChildren(TGListTreeItem*, Bool_t) {}
   virtual Bool_t          HasCheckedChild(Bool_t=kFALSE)   { return kTRUE; } // !!!!
   virtual Bool_t          HasUnCheckedChild(Bool_t=kFALSE) { return kTRUE; } // !!!!
   virtual void            UpdateState() {}

   // Item coloration (underline + minibox)
   virtual Bool_t          HasColor() const = 0;
   virtual Color_t         GetColor() const = 0;
   virtual void            SetColor(Color_t) {}
   virtual void            ClearColor() {}

   // Drag and drop.
   void            SetDNDSource(Bool_t onoff)
                   { if (onoff) fDNDState |= kIsDNDSource; else fDNDState &= ~kIsDNDSource; }
   void            SetDNDTarget(Bool_t onoff)
                   { if (onoff) fDNDState |= kIsDNDTarget; else fDNDState &= ~kIsDNDTarget; }
   Bool_t          IsDNDSource() const { return fDNDState & kIsDNDSource; }
   Bool_t          IsDNDTarget() const { return fDNDState & kIsDNDTarget; }

   // Allow handling by the items themselves ... NOT USED in TGListTree yet !!!!
   virtual Bool_t  HandlesDragAndDrop() const { return kFALSE; }
   virtual void    HandleDrag() {}
   virtual void    HandleDrop() {}

   virtual void    SavePrimitive(ostream&, Option_t*, Int_t) {}

   ClassDef(TGListTreeItem,0)  // Abstract base-class for items that go into a TGListTree container.
};


class TGListTreeItemStd : public TGListTreeItem
{
private:
   Bool_t           fActive;       // true if item is active
   Bool_t           fCheckBox;     // true if checkbox is visible
   Bool_t           fChecked;      // true if item is checked
   Bool_t           fOwnsData;     // true if user data has to be deleted
   TString          fText;         // item text
   TString          fTipText;      // tooltip text
   const TGPicture *fOpenPic;      // icon for open state
   const TGPicture *fClosedPic;    // icon for closed state
   const TGPicture *fCheckedPic;   // icon for checked item
   const TGPicture *fUncheckedPic; // icon for unchecked item
   void            *fUserData;     // pointer to user data structure

   Bool_t           fHasColor;     // true if item has assigned color
   Color_t          fColor;        // item's color

   TGListTreeItemStd(const TGListTreeItemStd&);             // not implemented
   TGListTreeItemStd& operator=(const TGListTreeItemStd&);  // not implemented

public:
   TGListTreeItemStd(TGClient *fClient = gClient, const char *name = 0,
                     const TGPicture *opened = 0, const TGPicture *closed = 0,
                     Bool_t checkbox = kFALSE);
   virtual ~TGListTreeItemStd();

   virtual Pixel_t         GetActiveColor() const;
   virtual Bool_t          IsActive()       const { return fActive; }
   virtual void            SetActive(Bool_t a)    { fActive = a; }

   virtual const char     *GetText()             const { return fText.Data(); }
   virtual Int_t           GetTextLength()       const { return fText.Length(); }
   virtual const char     *GetTipText()          const { return fTipText.Data(); }
   virtual Int_t           GetTipTextLength()    const { return fTipText.Length(); }
   virtual void            SetText(const char *text)   { fText = text; }
   virtual void            SetTipText(const char *tip) { fTipText = tip; }

   virtual void            SetUserData(void *userData, Bool_t own=kFALSE) { fUserData = userData; fOwnsData=own; }
   virtual void           *GetUserData() const { return fUserData; }

   virtual const TGPicture*GetPicture()         const { return fOpen ? fOpenPic : fClosedPic; }
   virtual const TGPicture*GetCheckBoxPicture() const { return fCheckBox ? (fChecked ? fCheckedPic : fUncheckedPic) : 0; }
   virtual void            SetPictures(const TGPicture *opened, const TGPicture *closed);
   virtual void            SetCheckBoxPictures(const TGPicture *checked, const TGPicture *unchecked);

   virtual void            SetCheckBox(Bool_t on = kTRUE);
   virtual Bool_t          HasCheckBox() const { return fCheckBox; }
   virtual void            CheckItem(Bool_t checked = kTRUE) { fChecked = checked; }
   virtual void            Toggle() { fChecked = !fChecked; }
   virtual Bool_t          IsChecked() const { return fChecked; }

   virtual void            CheckAllChildren(Bool_t state = kTRUE);
   virtual void            CheckChildren(TGListTreeItem *item, Bool_t state);
   virtual Bool_t          HasCheckedChild(Bool_t first=kFALSE);
   virtual Bool_t          HasUnCheckedChild(Bool_t first=kFALSE);
   virtual void            UpdateState();

   virtual Bool_t          HasColor() const { return fHasColor; }
   virtual Color_t         GetColor() const { return fColor; }
   virtual void            SetColor(Color_t color) { fHasColor = true;fColor = color; }
   virtual void            ClearColor() { fHasColor = false; }

   virtual void            SavePrimitive(ostream &out, Option_t *option, Int_t n);

   ClassDef(TGListTreeItemStd,0)  //Item that goes into a TGListTree container
};


class TGListTree : public TGContainer {

public:
   //---- color markup mode of tree items
   enum EColorMarkupMode {
      kDefault        = 0,
      kColorUnderline = BIT(0),
      kColorBox       = BIT(1)
   };
   enum ECheckMode {
      kSimple    = BIT(2),
      kRecursive = BIT(3)
   };

protected:
   TGListTreeItem  *fFirst;          // pointer to first item in list
   TGListTreeItem  *fLast;           // pointer to last item in list
   TGListTreeItem  *fSelected;       // pointer to selected item in list
   TGListTreeItem  *fCurrent;        // pointer to current item in list
   TGListTreeItem  *fBelowMouse;     // pointer to item below mouses cursor
   Int_t            fHspacing;       // horizontal spacing between items
   Int_t            fVspacing;       // vertical spacing between items
   Int_t            fIndent;         // number of pixels indentation
   Int_t            fMargin;         // number of pixels margin from left side
   Pixel_t          fGrayPixel;      // gray draw color
   GContext_t       fActiveGC;       // activated (selected) drawing context
   GContext_t       fDrawGC;         // icon drawing context
   GContext_t       fLineGC;         // dashed line drawing context
   GContext_t       fHighlightGC;    // highlighted icon drawing context
   FontStruct_t     fFont;           // font used to draw item text
   UInt_t           fDefw;           // default list width
   UInt_t           fDefh;           // default list height
   Int_t            fExposeTop;      // top y postion of visible region
   Int_t            fExposeBottom;   // bottom y position of visible region
   TGToolTip       *fTip;            // tooltip shown when moving over list items
   TGListTreeItem  *fTipItem;        // item for which tooltip is set
   TBufferFile     *fBuf;            // buffer used for Drag and Drop
   TDNDData         fDNDData;        // Drag and Drop data
   Atom_t          *fDNDTypeList;    // handles DND types
   TGListTreeItem  *fDropItem;       // item on which DND is over
   Bool_t           fAutoTips;       // assume item->fUserData is TObject and use GetTitle() for tip text
   Bool_t           fAutoCheckBoxPic;// change check box picture if parent and children have diffrent state
   Bool_t           fDisableOpen;    // disable branch opening on double-clicks
   Bool_t           fUserControlled; // let user decides what is the behaviour on events
   Bool_t           fEventHandled;   // flag used from user code to bypass standard event handling
   UInt_t           fLastEventState; // modifier state of the last keyboard event

   EColorMarkupMode fColorMode;      // if/how to render item's main color
   ECheckMode       fCheckMode;      // how to propagate check properties through the tree
   GContext_t       fColorGC;        // drawing context for main item color

   static Pixel_t          fgGrayPixel;
   static const TGFont    *fgDefaultFont;
   static TGGC            *fgActiveGC;
   static TGGC            *fgDrawGC;
   static TGGC            *fgLineGC;
   static TGGC            *fgHighlightGC;
   static TGGC            *fgColorGC;
   static const TGPicture *fgOpenPic;    // icon for open item
   static const TGPicture *fgClosedPic;  // icon for closed item
   static const TGPicture *fgCheckedPic;    // icon for checked item
   static const TGPicture *fgUncheckedPic;  // icon for unchecked item

   static Pixel_t       GetGrayPixel();
   static FontStruct_t  GetDefaultFontStruct();
   static const TGGC   &GetActiveGC();
   static const TGGC   &GetDrawGC();
   static const TGGC   &GetLineGC();
   static const TGGC   &GetHighlightGC();
   static const TGGC   &GetColorGC();

   void  Draw(Handle_t id, Int_t yevent, Int_t hevent);
   void  Draw(Option_t * ="") { MayNotUse("Draw(Option_t*)"); }
   Int_t DrawChildren(Handle_t id, TGListTreeItem *item, Int_t x, Int_t y, Int_t xroot);
   void  DrawItem(Handle_t id, TGListTreeItem *item, Int_t x, Int_t y, Int_t *xroot,
                  UInt_t *retwidth, UInt_t *retheight);
   void  DrawItemName(Handle_t id, TGListTreeItem *item);
   void  DrawNode(Handle_t id, TGListTreeItem *item, Int_t x, Int_t y);
   virtual void UpdateChecked(TGListTreeItem *item, Bool_t redraw = kFALSE);

   void  SaveChildren(ostream &out, TGListTreeItem *item, Int_t &n);
   void  RemoveReference(TGListTreeItem *item);
   void  PDeleteItem(TGListTreeItem *item);
   void  PDeleteChildren(TGListTreeItem *item);
   void  InsertChild(TGListTreeItem *parent, TGListTreeItem *item);
   void  InsertChildren(TGListTreeItem *parent, TGListTreeItem *item);
   Int_t SearchChildren(TGListTreeItem *item, Int_t y, Int_t findy,
                        TGListTreeItem **finditem);
   TGListTreeItem *FindItem(Int_t findy);
   void *FindItem(const TString& name,
                  Bool_t direction = kTRUE,
                  Bool_t caseSensitive = kTRUE,
                  Bool_t beginWith = kFALSE)
      { return TGContainer::FindItem(name, direction, caseSensitive, beginWith); }

   virtual void Layout() {}

   void OnMouseOver(TGFrame*) { }
   void CurrentChanged(Int_t /*x*/, Int_t /*y*/) { }
   void CurrentChanged(TGFrame *) { }
   void ReturnPressed(TGFrame*) { }
   void Clicked(TGFrame *, Int_t /*btn*/) { }
   void Clicked(TGFrame *, Int_t /*btn*/, Int_t /*x*/, Int_t /*y*/) { }
   void DoubleClicked(TGFrame *, Int_t /*btn*/) { }
   void DoubleClicked(TGFrame *, Int_t /*btn*/, Int_t /*x*/, Int_t /*y*/) { }
   void KeyPressed(TGFrame *, UInt_t /*keysym*/, UInt_t /*mask*/) { }

private:
   TGListTree(const TGListTree&);               // not implemented
   TGListTree& operator=(const TGListTree&);    // not implemented

public:
   TGListTree(TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
              UInt_t options = 0, Pixel_t back = GetWhitePixel());
   TGListTree(TGCanvas *p, UInt_t options, Pixel_t back = GetWhitePixel());

   virtual ~TGListTree();

   virtual Bool_t HandleButton(Event_t *event);
   virtual Bool_t HandleDoubleClick(Event_t *event);
   virtual Bool_t HandleCrossing(Event_t *event);
   virtual Bool_t HandleMotion(Event_t *event);
   virtual Bool_t HandleKey(Event_t *event);

   virtual void SetCanvas(TGCanvas *canvas) { fCanvas = canvas; }
   virtual void DrawRegion(Int_t x, Int_t y, UInt_t w, UInt_t h);

   virtual void DrawOutline(Handle_t id, TGListTreeItem *item, Pixel_t col=0xbbbbbb,
                            Bool_t clear=kFALSE);
   virtual void DrawActive(Handle_t id, TGListTreeItem *item);
   
   virtual TGDimension GetDefaultSize() const
            { return TGDimension(fDefw, fDefh); }

   void            AddItem(TGListTreeItem *parent, TGListTreeItem *item);
   TGListTreeItem *AddItem(TGListTreeItem *parent, const char *string,
                           const TGPicture *open = 0,
                           const TGPicture *closed = 0,
                           Bool_t checkbox = kFALSE);
   TGListTreeItem *AddItem(TGListTreeItem *parent, const char *string,
                           void *userData, const TGPicture *open = 0,
                           const TGPicture *closed = 0,
                           Bool_t checkbox = kFALSE);
   void  RenameItem(TGListTreeItem *item, const char *string);
   Int_t DeleteItem(TGListTreeItem *item);
   void  OpenItem(TGListTreeItem *item);
   void  CloseItem(TGListTreeItem *item);
   void  CheckItem(TGListTreeItem *item, Bool_t check = kTRUE);
   void  SetCheckBox(TGListTreeItem *item, Bool_t on = kTRUE);
   void  ToggleItem(TGListTreeItem *item);
   Int_t RecursiveDeleteItem(TGListTreeItem *item, void *userData);

   Int_t DeleteChildren(TGListTreeItem *item);
   Int_t Reparent(TGListTreeItem *item, TGListTreeItem *newparent);
   Int_t ReparentChildren(TGListTreeItem *item, TGListTreeItem *newparent);
   void  SetToolTipItem(TGListTreeItem *item, const char *string);
   void  SetAutoTips(Bool_t on = kTRUE) { fAutoTips = on; }
   void  SetAutoCheckBoxPic(Bool_t on) { fAutoCheckBoxPic = on; }
   void  SetSelected(TGListTreeItem *item) { fSelected = item; }
   void  AdjustPosition(TGListTreeItem *item);
   void  AdjustPosition() { TGContainer::AdjustPosition(); }

   // overwrite TGContainer's methods
   void Home(Bool_t select = kFALSE);
   void End(Bool_t select = kFALSE);
   void PageUp(Bool_t select = kFALSE);
   void PageDown(Bool_t select = kFALSE);
   void LineUp(Bool_t select = kFALSE);
   void LineDown(Bool_t select = kFALSE);
   void Search(Bool_t close = kTRUE);

   Int_t Sort(TGListTreeItem *item);
   Int_t SortSiblings(TGListTreeItem *item);
   Int_t SortChildren(TGListTreeItem *item);
   void  HighlightItem(TGListTreeItem *item);
   void  ClearHighlighted();
   void  GetPathnameFromItem(TGListTreeItem *item, char *path, Int_t depth = 0);
   void  UnselectAll(Bool_t draw);
   void  SetToolTipText(const char *text, Int_t x, Int_t y, Long_t delayms);
   void  HighlightItem(TGListTreeItem *item, Bool_t state, Bool_t draw);
   void  HighlightChildren(TGListTreeItem *item, Bool_t state, Bool_t draw);
   void  DisableOpen(Bool_t disable = kTRUE) { fDisableOpen = disable;}
   void  GetChecked(TList *checked);       
   void  GetCheckedChildren(TList *checked, TGListTreeItem *item);       
   void  CheckAllChildren(TGListTreeItem *item, Bool_t state);       

   TGListTreeItem *GetFirstItem()  const { return fFirst; }
   TGListTreeItem *GetSelected()   const { return fSelected; }
   TGListTreeItem *GetCurrent()    const { return fCurrent; }
   TGListTreeItem *GetBelowMouse() const { return fBelowMouse; }
   TGListTreeItem *FindSiblingByName(TGListTreeItem *item, const char *name);
   TGListTreeItem *FindSiblingByData(TGListTreeItem *item, void *userData);
   TGListTreeItem *FindChildByName(TGListTreeItem *item, const char *name);
   TGListTreeItem *FindChildByData(TGListTreeItem *item, void *userData);
   TGListTreeItem *FindItemByPathname(const char *path);
   TGListTreeItem *FindItemByObj(TGListTreeItem *item, void *ptr);

   void  AddItem(const char *string) { AddItem(fSelected, string); } //*MENU*
   void  AddRoot(const char *string) { AddItem(0, string); } //*MENU*
   Int_t DeleteSelected() { return (fSelected ? DeleteItem(fSelected) : 0); } //*MENU*
   void  RenameSelected(const char *string) { if (fSelected) RenameItem(fSelected, string); } //*MENU*

   virtual void MouseOver(TGListTreeItem *entry);  //*SIGNAL*
   virtual void MouseOver(TGListTreeItem *entry, UInt_t mask);  //*SIGNAL*
   virtual void KeyPressed(TGListTreeItem *entry, UInt_t keysym, UInt_t mask);  //*SIGNAL*
   virtual void ReturnPressed(TGListTreeItem *entry);  //*SIGNAL*
   virtual void Clicked(TGListTreeItem *entry, Int_t btn);  //*SIGNAL*
   virtual void Clicked(TGListTreeItem *entry, Int_t btn, Int_t x, Int_t y);  //*SIGNAL*
   virtual void Clicked(TGListTreeItem *entry, Int_t btn, UInt_t mask, Int_t x, Int_t y);  //*SIGNAL*
   virtual void DoubleClicked(TGListTreeItem *entry, Int_t btn);  //*SIGNAL*
   virtual void DoubleClicked(TGListTreeItem *entry, Int_t btn, Int_t x, Int_t y);  //*SIGNAL*
   virtual void Checked(TObject *obj, Bool_t check);  //*SIGNAL*
   virtual void DataDropped(TGListTreeItem *item, TDNDData *data);  //*SIGNAL*

   // Utility functions
   Int_t        FontHeight();
   Int_t        FontAscent();
   Int_t        TextWidth(const char *c);

   static const TGPicture *GetOpenPic();
   static const TGPicture *GetClosedPic();
   static const TGPicture *GetCheckedPic();
   static const TGPicture *GetUncheckedPic();

   // User control
   void         SetUserControl(Bool_t ctrl=kTRUE) { fUserControlled = ctrl; }
   Bool_t       HasUserControl() const { return fUserControlled; }
   void         SetEventHandled(Bool_t eh=kTRUE) { fEventHandled = eh; }
   Bool_t       IsEventHandled() const { return fEventHandled; }

   Bool_t   HandleDNDDrop(TDNDData *data);
   Atom_t   HandleDNDPosition(Int_t x, Int_t y, Atom_t action,
                              Int_t xroot, Int_t yroot);
   Atom_t   HandleDNDEnter(Atom_t * typelist);
   Bool_t   HandleDNDLeave();

   virtual TDNDData *GetDNDData(Atom_t) {
      return &fDNDData;
   }

   EColorMarkupMode GetColorMode() const { return fColorMode; }
   void SetColorMode(EColorMarkupMode colorMode) { fColorMode = colorMode; }

   ECheckMode GetCheckMode() const { return fCheckMode; }
   void SetCheckMode(ECheckMode mode) { fCheckMode = mode; }

   virtual void SavePrimitive(ostream &out, Option_t *option = "");

   ClassDef(TGListTree,0)  //Show items in a tree structured list
};

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