mgui/tree.h

Go to the documentation of this file.

#ifndef  INC_MGUI_TREE_H
#define  INC_MGUI_TREE_H

#ifndef  INC_MGUI_CTRL_H
#include <mgui/ctrl.h>
#endif

#ifndef  INC_MGUI_KEYCODE_H
#include <mgui/keycode.h>
#endif

#ifndef  INC_MGUI_POINTERBUTTON_H
#include <mgui/pointerbutton.h>
#endif

#ifndef  INC_MGUI_CUSTOMDRAW_H
#include <mgui/customdraw.h>
#endif

#ifndef  INC_MI32_MISTRING_H
#include <mi32/mistring.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
namespace MGUI {
   class CTRL_TOOLTIP;
   class CUSTOMDRAW_TREE;
   class IMAGELIST;
   }
#endif


namespace MGUI {

class CTRL_TREE : public CTRL {
   public:

      enum CTRLSTYLE {
         CTRLSTYLE_Default =              0x0000,  
         CTRLSTYLE_ShowLines =            0x0001,  
         CTRLSTYLE_ShowLinesAtRoot =      0x0002,  
         CTRLSTYLE_NoButtons =            0x0004,  
         CTRLSTYLE_SingleExpand =         0x0008,  
         CTRLSTYLE_NoToolTips =           0x0010,  
         CTRLSTYLE_EditableText =         0x0020,  
         CTRLSTYLE_NoScrollHorizontal =   0x0040,  
         CTRLSTYLE_SizeInPixels =         0x0080,  
         CTRLSTYLE_ImageIdxIsIconID =     0x0100,  
         };

      enum ITEMSTYLE {
         ITEMSTYLE_Default =              0x0000,  
         ITEMSTYLE_OwnerText =            0x0001,  
         ITEMSTYLE_OwnerImages =          0x0002,  
         ITEMSTYLE_AllowChildReorder =    0x0004,  
         };

      enum ITEMHND {
         ITEMHND_Last =                   -2,      
         ITEMHND_None =                   -1,      
         ITEMHND_Root =                   0,       
         };

      enum ITEMSTATUS {
         ITEMSTATUS_None =                0x00,
         ITEMSTATUS_Bold =                0x01,    
         ITEMSTATUS_DropHighlighted =     0x10,    
         ITEMSTATUS_Expanded =            0x02,    
         ITEMSTATUS_ExpandedOnce =        0x04,    
         ITEMSTATUS_Selected =            0x08,    
         };

      enum FIND {
         FIND_Selected,                            
         FIND_DropHighlight,                       
         FIND_Parent,                              
         FIND_FirstChild,                          
         FIND_NextSibling,                         
         FIND_PreviousSibling,                     
         FIND_TopParent,                           
         };

      enum CHILDPRESENCE {
         CHILDPRESENCE_No =   0,                   
         CHILDPRESENCE_Yes =  1,                   
         CHILDPRESENCE_Ask =  2                    
         };

      enum CHILDVISIBILITY {
         CHILDVISIBILITY_Expand,                   
         CHILDVISIBILITY_Collapse,                 
         CHILDVISIBILITY_CollapseReset,            
         CHILDVISIBILITY_Toggle                    
         };

      enum IMAGETYPE {
         IMAGETYPE_Primary,
         IMAGETYPE_State
         };

      enum ITEMVALUES {
         ITEMVALUES_None =                0x0000,
         ITEMVALUE_ChildPresence =        0x0001,
         ITEMVALUE_ImageNormal =          0x0002,
         ITEMVALUE_ImageSelected =        0x0004,
         ITEMVALUE_ImageState =           0x0008,
         ITEMVALUE_Status =               0x0010,
         ITEMVALUE_Text =                 0x0020,
         ITEMVALUE_ID =                   0x0040,
         ITEMVALUE_Style =                0x0080,
         ITEMVALUE_HeightMult =           0x0100,
         ITEMVALUES_All =                 0x0FFF
         };

      // (Values chosen to match Windows.)
      enum HITRESULT {
         HITRESULT_Nowhere =              0x0001,  
         HITRESULT_OnItemIcon =           0x0002,  
         HITRESULT_OnItemText =           0x0004,  
         HITRESULT_OnItemIndent =         0x0008,  
         HITRESULT_OnItemButton =         0x0010,  
         HITRESULT_OnItemRight =          0x0020,  
         HITRESULT_OnItemStateIcon =      0x0040,  
         HITRESULT_OnItem =               (HITRESULT_OnItemIcon | HITRESULT_OnItemText | HITRESULT_OnItemStateIcon)  
         };

      #if !defined(GENERATING_DOXYGEN_OUTPUT)
         class PRIV;
      #endif

      class ITEMINFO {
         public:

            ITEMINFO (
               );

            // Construct with handle and ID.
            ITEMINFO (
               ITEMHND itemhnd,
               ID id
               );

            explicit ITEMINFO (
               const MISTRING& text,
               ID id = 0
               );

            ~ITEMINFO (
               );

            CHILDPRESENCE GetChildPresence (
               ) const { return (m_ChildPresence); }

            ITEMHND GetHandle (
               ) const { return (m_itemhnd); }

            int GetHeightMult (
               ) const { return (m_HeightMult); }

            ID GetID (
               ) const { return (m_id); }

            int GetImageNormal (
               ) const { return (m_ImageNormal); }

            int GetImagePrimary (
               ) const { return ((m_status & ITEMSTATUS_Selected) ? GetImageSelected() : GetImageNormal()); }

            int GetImageSelected (
               ) const { return ((m_ImageSelected == -2) ? m_ImageNormal : m_ImageSelected); }

            int GetImageState (
               ) const { return (m_ImageState); }

            ITEMSTATUS GetStatus (
               ) const { return (m_status); }

            ITEMSTYLE GetStyle (
               ) const { return (m_style); }

            const MISTRING& GetText (
               ) const { return (m_text); }

            ITEMVALUES GetValidValues (
               ) const { return (static_cast<ITEMVALUES>(m_ValidValues)); }

            void Set (
               const ITEMINFO& iteminfo
               );

            void SetBold (
               bool bold = true                    
               );

            void SetChildPresence (
               CHILDPRESENCE ChildPresence         
               ) { m_ValidValues |= ITEMVALUE_ChildPresence; m_ChildPresence = ChildPresence; }

            void SetHeightMult (
               int HeightMult                      
               ) { m_ValidValues |= ITEMVALUE_HeightMult; m_HeightMult = HeightMult; }

            void SetID (
               ID id
               ) { m_ValidValues |= ITEMVALUE_ID; m_id = id; }

            void SetImageNormal (
               int IdxNormal                       
               );

            void SetImageSelected (
               int IdxSelected                     
               );

            void SetImageState (
               unsigned int IdxState            
               ) { m_ValidValues |= ITEMVALUE_ImageState; m_ImageState = (IdxState < 16) ? IdxState : 0; }

            void SetRetainImages (
               );

            void SetRetainText (
               );

            void SetStatus (
               ITEMSTATUS status
               ) { m_ValidValues |= ITEMVALUE_Status; m_status = status; }

            void SetStyle (
               ITEMSTYLE style
               ) { m_ValidValues |= ITEMVALUE_Style; m_style = style; }

            void SetText (
               const MISTRING& text
               ) { m_ValidValues |= ITEMVALUE_Text; m_text = text; }

            #ifndef GENERATING_DOXYGEN_OUTPUT
            // Internal methods used by implementation.
            void SetHandle (
               ITEMHND itemhnd
               ) { m_itemhnd = itemhnd; }
            #endif

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            unsigned int m_ValidValues;
            ITEMHND m_itemhnd;
            ID m_id;
            ITEMSTATUS m_status;
            ITEMSTYLE m_style;
            CHILDPRESENCE m_ChildPresence;
            MISTRING m_text;
            int m_HeightMult;
            int m_ImageNormal;
            int m_ImageSelected;
            int m_ImageState;

            friend class TREE;         
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      typedef fastdelegate::FastDelegate<bool(ITEMHND, HITRESULT, const LPOINT2D&, MGUI::POINTERBUTTON, MGUI::KEYSTATE)> DELEGATE_ONPOINTER;

      typedef fastdelegate::FastDelegate<bool(ITEMHND, HITRESULT, const LPOINT2D&, MGUI::KEYSTATE)> DELEGATE_ONMOUSE;

      typedef fastdelegate::FastDelegate<void(ITEMHND, HITRESULT, const LPOINT2D&, MGUI::KEYSTATE, MGUI::KEYCODE)> DELEGATE_ONKEY;

      typedef fastdelegate::FastDelegate<bool(ITEMHND, HITRESULT, const LPOINT2D&, MGUI::CTRL_TOOLTIP&)> DELEGATE_ONTOOLTIPREQUEST;

      typedef fastdelegate::FastDelegate<void(ITEMHND, CHILDVISIBILITY)> DELEGATE_ONCHILDVISIBILITYCHANGED;

      typedef fastdelegate::FastDelegate<bool(ITEMHND, CHILDVISIBILITY)> DELEGATE_ONCHILDVISIBILITYCHANGING;
      
      typedef fastdelegate::FastDelegate<MGUI::CUSTOMDRAW::RETVALUE(CUSTOMDRAW_TREE&)> DELEGATE_ONCUSTOMDRAW;

      typedef fastdelegate::FastDelegate<void(ITEMHND)> DELEGATE_ONITEM;

      typedef fastdelegate::FastDelegate<void(ITEMINFO&)> DELEGATE_ONPREINSERTITEM;
      typedef fastdelegate::FastDelegate<void(CTRL_TREE::ITEMVALUES, CTRL_TREE::ITEMINFO&)> DELEGATE_ONGETITEMINFO;

      typedef fastdelegate::FastDelegate<void(CTRL_TREE::ITEMVALUES, const CTRL_TREE::ITEMINFO&)> DELEGATE_ONSETITEMINFO;

      CTRL_TREE (
         );

      ~CTRL_TREE ();

      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    
         int height = 20,                       
         int width = 40,                        
         CTRLSTYLE style = CTRLSTYLE_Default,   
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_Expand
         );

      void DeleteChildren (
         ITEMHND hndParent                
         );

      void DeleteItem (
         ITEMHND hndItem                  
         );

      void DrawItem (
         ITEMHND hndItem,                 
         bool erase = true                
         );

      void EnsureVisible (
         ITEMHND hndItem,                 
         bool ScrollToShow = true         
         );

      ITEMHND FindChildByID (
         ITEMHND hndParent,               
         ID id,                           
         bool recursive = false           
         ) const;

      ITEMHND FindItem (
         FIND find,                       
         ITEMHND hndItem = ITEMHND_None   
         ) const;

      int GetBaseItemHeight (
         ) const;

      CHILDPRESENCE GetChildPresence (
         ITEMHND hndItem                  
         ) const;

      ITEMHND GetFirstChild (
         ITEMHND hndParent                
         ) const { return (FindItem(FIND_FirstChild,hndParent)); }

      ID GetItemID (
         ITEMHND hndItem                  
         ) const;

      void GetItemInfo (
         ITEMHND hndItem,                 
         ITEMVALUES ItemValues,           
         ITEMINFO& ItemInfo               
         ) const;

      ITEMSTATUS GetItemStatus (
         ITEMHND hndItem                  
         ) const;

      ITEMHND GetNextSibling (
         ITEMHND hndItem                  
         ) const { return (FindItem(FIND_NextSibling,hndItem)); }

      ITEMHND GetParent (
         ITEMHND hndChild                 
         ) const { return (FindItem(FIND_Parent,hndChild)); }

      ITEMHND GetSelectedItem (
         ) const { return (FindItem(FIND_Selected)); }

      ITEMHND InsertItem (
         ITEMHND hndParent,               
         ITEMHND hndInsertAfter,          
         const MISTRING text,             
         ID id = 0                        
         );

      ITEMHND InsertItem (
         ITEMHND hndParent,               
         ITEMHND hndInsertAfter,          
         ITEMINFO& ItemInfo               
         );

      bool IsRedrawDisabled (
         ) const;

      void Redraw (
         bool erase = true                
         );

      void RedrawDisable (
         );

      void RedrawEnable (
         );

      void SetAutoSelectOnClick (
         bool AutoSelectOnClick
         );

      void SetBackgroundColor (
         const COLOR& color               
         );

      void SetBaseItemHeight (
         int baseheight                   
         );

      void SetChildVisibility (
         ITEMHND hndParent,               
         CHILDVISIBILITY visibility       
         );

      void SetDelegateOnChildVisibilityChanged(DELEGATE_ONCHILDVISIBILITYCHANGED);

      void SetDelegateOnChildVisibilityChanging(DELEGATE_ONCHILDVISIBILITYCHANGING);
      
      void SetDelegateOnCustomDraw(DELEGATE_ONCUSTOMDRAW);

      void SetDelegateOnDestroyItem (DELEGATE_ONITEM);

      void SetDelegateOnGetItemInfo (DELEGATE_ONGETITEMINFO);

      void SetDelegateOnItemChangePosition (
         DELEGATE_ONITEM delegate
         ) { m_DelegateOnItemChangePosition = delegate; }

      void SetDelegateOnItemDeselected (
         DELEGATE_ONITEM delegate
         ) { m_DelegateOnItemDeselected = delegate; }

      void SetDelegateOnItemSelected (
         DELEGATE_ONITEM delegate
         ) { m_DelegateOnItemSelected = delegate; }

      void SetDelegateOnKeyPress(DELEGATE_ONKEY);

      void SetDelegateOnLeftButtonDoubleClick(DELEGATE_ONMOUSE);

      void SetDelegateOnPointerButtonDown (
         DELEGATE_ONPOINTER delegate
         ) { m_DelegateOnPointerButtonDown = delegate; }

      void SetDelegateOnPointerButtonUp (
         DELEGATE_ONPOINTER delegate
         ) { m_DelegateOnPointerButtonUp = delegate; }

      void SetDelegateOnPreInsertItem (DELEGATE_ONPREINSERTITEM);

      void SetDelegateOnSetItemInfo (DELEGATE_ONSETITEMINFO);

      void SetDelegateOnSize (DELEGATE_ONSIZE delegate);

      void SetDelegateOnToolTipRequest (DELEGATE_ONTOOLTIPREQUEST);

      void SetImageList (
         IMAGELIST& ImageList,            
         IMAGETYPE ImageType              
         );

      void SetItemBold (
         ITEMHND hndItem,                 
         bool bold                        
         );

      void SetItemImageNormal (
         ITEMHND hndItem,                 
         int IdxNormal                    
         );

      void SetItemImageState (
         ITEMHND hndItem,                 
         unsigned int IdxState            
         );

      void SetItemInfo (
         ITEMHND hndItem,                 
         const ITEMINFO& ItemInfo         
         );

      void SetItemInfo (
         const ITEMINFO& ItemInfo         
         ) { SetItemInfo(ItemInfo.GetHandle(),ItemInfo); }

      void SetItemPosition (
         ITEMHND hndItem,                 
         ITEMHND hndInsertAfter           
         );

      void SetItemText (
         ITEMHND hndItem,                 
         const MISTRING& text             
         );

      void SetLineColor (
         const COLOR& color               
         );

      void SetSelectedItem (
         ITEMHND hndItem                  
         );

   protected:

      ITEMHND HitTest (
         const LPOINT2D& point,              
         HITRESULT *pHitResult = 0           
         ) const;

      virtual void v_OnItemChangePosition (
         ITEMHND hndItem                     
         );

      virtual void v_OnLeftButtonDown (
         ITEMHND hndItem,                    
         HITRESULT HitResult,                
         const LPOINT2D& point,              
         KEYSTATE keystate                   
         );

      virtual void v_OnLeftButtonUp (
         ITEMHND hndItem,                    
         HITRESULT HitResult,                
         const LPOINT2D& point,              
         KEYSTATE keystate                   
         );

      virtual void v_OnPointerButtonDown (
         ITEMHND hndItem,                    
         HITRESULT HitResult,                
         const LPOINT2D& point,              
         POINTERBUTTON button,               
         KEYSTATE keystate                   
         );

      virtual void v_OnPointerButtonUp (
         ITEMHND hndItem,                    
         HITRESULT HitResult,                
         const LPOINT2D& point,              
         POINTERBUTTON button,               
         KEYSTATE keystate                   
         );

      virtual void v_OnRightButtonDown (
         ITEMHND hndItem,                    
         HITRESULT HitResult,                
         const LPOINT2D& point,              
         KEYSTATE keystate                   
         );

      virtual void v_OnRightButtonUp (
         ITEMHND hndItem,                    
         HITRESULT HitResult,                
         const LPOINT2D& point,              
         KEYSTATE keystate                   
         );

      virtual bool v_OnToolTipRequest (
         ITEMHND hndItem,                    
         HITRESULT HitResult,                
         const LPOINT2D& point,              
         MGUI::CTRL_TOOLTIP& ToolTipCtrl     
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      PRIV *m_pPriv;
      DELEGATE_ONPOINTER m_DelegateOnPointerButtonDown;
      DELEGATE_ONPOINTER m_DelegateOnPointerButtonUp;
      DELEGATE_ONITEM m_DelegateOnItemChangePosition;
      DELEGATE_ONITEM m_DelegateOnItemDeselected;
      DELEGATE_ONITEM m_DelegateOnItemSelected;

      void NotifyPointerButtonPress (ITEMHND hnditem, HITRESULT HitResult, const LPOINT2D& point, POINTERBUTTON button, KEYSTATE keystate);
      void NotifyPointerButtonRelease (ITEMHND hnditem, HITRESULT HitResult, const LPOINT2D& point, POINTERBUTTON button, KEYSTATE keystate);

      CTRL_TREE (const CTRL_TREE&);
      CTRL_TREE& operator= (const CTRL_TREE&);
      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables not callable from derived classes.

      virtual void v_OnChildVisibilityChanged (
         ITEMHND hndItem,                    
         CHILDVISIBILITY visibility          
         );

      virtual bool v_OnChildVisibilityChanging (
         ITEMHND hndItem,                    
         CHILDVISIBILITY visibility          
         );

      virtual void v_OnCreateEnd (
         );

      virtual MGUI::CUSTOMDRAW::RETVALUE v_OnCustomDraw (
         CUSTOMDRAW_TREE& CustomDraw         
         );

      virtual void v_OnDestroyItem (
         ITEMHND hndItem                     
         );

      virtual void v_OnGetItemInfo (
         ITEMVALUES RequestedValue,          
         ITEMINFO& ItemInfo                  
         );

      virtual void v_OnItemDeselected (
         ITEMHND hndItem                     
         );

      virtual void v_OnItemSelected (
         ITEMHND hndItem                     
         );

      virtual void v_OnPreInsertItem (
         ITEMINFO& ItemInfo                  
         );

      virtual void v_OnSetItemInfo (
         ITEMVALUES ChangedValue,            
         const ITEMINFO& ItemInfo            
         );

   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(CTRL_TREE::CTRLSTYLE)
DEFINE_ENUM_OP_BITWISE(CTRL_TREE::ITEMSTYLE)
DEFINE_ENUM_OP_BITWISE(CTRL_TREE::ITEMSTATUS)
DEFINE_ENUM_OP_BITWISE(CTRL_TREE::ITEMVALUES)
#endif

class CUSTOMDRAW_TREE : public MGUI::CUSTOMDRAW {
   public:
      CUSTOMDRAW_TREE ();
      ~CUSTOMDRAW_TREE ();
      CTRL_TREE::ITEMHND GetItemHnd (
         ) const;
      MGD::PIXEL GetBackgroundPixel (
         ) const { return (m_PixelBG); }
      int GetLevel (
         ) const { return (m_level); }
      MGD::PIXEL GetTextPixel (
         ) const { return (m_PixelText); }
      void SetBackgroundColor (
         const COLOR& color            
         );
      void SetBackgroundPixel (
         MGD::PIXEL pixel              
         ) { m_PixelBG = pixel; }
      void SetTextColor (
         const COLOR& color            
         );
      void SetTextPixel (
         MGD::PIXEL pixel              
         ) { m_PixelText = pixel; }
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MGD::PIXEL m_PixelBG;
      MGD::PIXEL m_PixelText;
      int m_level;
      CUSTOMDRAW_TREE (
         DRAWSTAGE drawstage,
         const LRECT2D& rect
         );
      void SetupItem (
         const CTRL_TREE::ITEMINFO& iteminfo,
         const LRECT2D& rect,
         int level,
         MGD::CONTEXT *pDC
         );
      friend class CTRL_TREE::PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}  // End namespace MGUI

#endif

---