wxTreeMultiCtrl.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
// $RCSfile: wxTreeMultiCtrl.h,v $
// $Source: /cvs/creatis/bbtk/kernel/src/ThirdParty/wx/treemultictrl/wxTreeMultiCtrl.h,v $
// $Revision: 1.1 $
// $Date: 2008/03/28 13:42:19 $
//---------------------------------------------------------------------------
// Author:      Jorgen Bodde
// Copyright:   (c) Jorgen Bodde
// License:     wxWidgets License
//---------------------------------------------------------------------------

#ifndef __WXTREEMULTICTRL_H__
#define __WXTREEMULTICTRL_H__

#ifdef __GNUG__
    #pragma interface "wxTreeMultiCtrl.cpp"
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include <wx/dynarray.h>


// classes for internal tree structure
#include "TreeMultiItemRoot.h"

// Flags for wxTreeMultCtrl use
#define wxTMC_DEFAULT_STYLE wxSIMPLE_BORDER

#define wxTMC_BG_ADJUST_CNT   0x000000001

#define wxTMC_BG_ADJUST_BTN   0x000000002

#define wxTMC_BG_ADJUST_ALL   (wxTMC_BG_ADJUST_CNT | wxTMC_BG_ADJUST_BTN)

#define wxTMC_SPAN_WIDTH      0x000000004

#define wxTreeMultiCtrlNameStr wxT("wxTreeMultiCtrl")

#define WXTMC_GUTTER_DEFAULT 6      // gutter before and after image of [+] or [-]
#define WXTMC_YSPACING_DEFAULT 10   // per item 10 pixels spacing extra for every item
#define WXTMC_PIXELS_PER_UNIT 10

enum
{
    wxTMC_HITTEST_GUTTER = 1,
    wxTMC_HITTEST_WINDOW,
    wxTMC_HITTEST_CAPTION,
    wxTMC_HITTEST_CHECKBOX
};

class wxTreeMultiItem
{
private:
    TreeMultiItemBase *_item;
public:
    wxTreeMultiItem() {
        _item = 0;
    };

#ifndef _NO_DOXYGEN_

    wxTreeMultiItem(TreeMultiItemBase *ptr) {
        _item = ptr;
    };

    // Returns the TreeMultiItemBase class. This shoult *NOT* be
    // used if you don't know what you are doing! This means never use it. */
    TreeMultiItemBase *GetItem() const {
        return _item;
    };

#endif // _NO_DOXYGEN_

    void operator=(const wxTreeMultiItem &item) {
        _item = item._item;
    };

    bool operator==(wxTreeMultiItem const& item) const {return (this->GetItem() == item.GetItem());}

    bool operator!=(wxTreeMultiItem const& item) const {return (this->GetItem() != item.GetItem());}

        wxTreeMultiItem GetParent() const{
                wxCHECK(IsOk(), wxTreeMultiItem(0));
                return wxTreeMultiItem(_item->GetParent());
        };

    bool IsOk() const {
        return _item != 0;
    };

    bool IsWindowItem() const {
        if(_item && _item->IsTreeMultiItemWindow())
            return true;
        return false;
    };

    bool IsNodeItem() const {
        if(_item && (_item->IsTreeMultiItemNode() || _item->IsTreeMultiItemRoot()))
            return true;
        return false;
    };

    bool IsRootItem() const {
        if(_item && _item->IsTreeMultiItemRoot())
            return true;
        return false;
    };

    bool IsExpanded() const {
        wxCHECK(_item, false);
        TreeMultiItemNode *n = _item->IsTreeMultiItemNode();
        wxCHECK(n, false);

        return n->IsExpanded();
    };

    bool IsExcluded() {
        wxCHECK(_item, false);
        return _item->IsExcluded();
    }

    bool IsSelected(void) const
    {
      wxCHECK(this->GetItem(),false);
      return this->GetItem()->IsSelected();
    }
    bool IsVisible() {
        wxCHECK(_item, false);
        return _item->IsVisible();
    }

};

WX_DECLARE_OBJARRAY(wxTreeMultiItem,wxArrayTreeMultiItem);

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

class wxTreeMultiWindowInfo
{
private:
    int _flags;
    int _frontSpacing,
        _frontSpacingOrg;

    int _topSpacing;

#if(CHECKBOXVIEW)

    bool _checkState;
#endif

public:
#if(CHECKBOXVIEW)
    wxTreeMultiWindowInfo(int flags, int frontSpacing, int topSpacing, bool checkState = false)
        : _flags(flags)
        , _frontSpacing(frontSpacing)
        , _frontSpacingOrg(frontSpacing)
        , _topSpacing(topSpacing)
        , _checkState(checkState)
#else
    wxTreeMultiWindowInfo(int flags, int frontSpacing, int topSpacing)
        : _flags(flags)
        , _frontSpacing(frontSpacing)
        , _frontSpacingOrg(frontSpacing)
        , _topSpacing(topSpacing)
#endif
    {
        // constructor
    }
    int Indent(int num = 1) {
        if(num > 0)
            _frontSpacing += (_frontSpacingOrg * num);
        return _frontSpacing;
    };
    int Outdent(int num = 1) {
        _frontSpacing -= (_frontSpacingOrg * num);
        if(_frontSpacing < 0)
            _frontSpacing = 0;
        return _frontSpacing;
    };

    void SetFrontSpacing(int frontSpacing) {
        _frontSpacing = frontSpacing;
        _frontSpacingOrg = frontSpacing;
    };
    int GetFrontSpacing() const {
        return _frontSpacing;
    };

    void SetTopSpacing(int topSpacing) {
        _topSpacing = topSpacing;
        if(_topSpacing < 0)
            _topSpacing = 0;
    };

    /* Gets top spacing currently set. */
    int GetTopSpacing() const {
        return _topSpacing;
    };

    int SetFlags(int flags) {
        int tmp = _flags;
        _flags = flags;
        return tmp;
    };

    int GetFlags() const {
        return _flags;
    };

    int AddFlag(int flag_mask) {
        int tmp = _flags;
        _flags |= flag_mask;
        return tmp;
    };

    int RemoveFlag(int flag_mask) {
        int tmp = _flags;
        _flags &= ~(flag_mask);
        return tmp;
    };

#if(CHECKBOXVIEW)

    void SetDefaultCheckState(bool checkState = true) {
        _checkState = checkState;
    };

    bool GetDefaultCheckState() const {
        return _checkState;
    };
#endif
};

// Default info string
#ifndef LINUX
  #define wxTreeMultiWindowInfoDefault wxTreeMultiWindowInfo(wxTMC_BG_ADJUST_CNT, 8, 0)
#else
  #define wxTreeMultiWindowInfoDefault wxTreeMultiWindowInfo(wxTMC_BG_ADJUST_ALL, 8, 0)
#endif

class wxTreeMultiCtrl: public wxScrolledWindow
{
    DECLARE_DYNAMIC_CLASS(wxTreeMultiCtrl)

    
private:
    TreeMultiItemRoot _root;

    long _style;
    wxBitmap *_expandBmp, *_collBmp;

    int _iconDeltaY, _checkDeltaY;

    /* Caption height. This is the height of the font of this window */
    int _captionHeight;

    int _gutterWidth;

    int _iconWidth;

    int _iconHeight;

    int _maxHeight;


    int _spacingY;

    bool _create_called;

#if(CHECKBOXVIEW)
    wxBitmap *_checkBmp, *_uncheckBmp, *_tristateBmp;

    bool _checkboxView;

    int _checkHeight, _checkWidth;
#endif

     wxBrush* m_HilightBrush;

    wxFont _captionFont;

    wxArrayTreeMultiItem m_SelectedItems;

    void DoFold(TreeMultiItemBase *item, bool expand, bool recursive);

    void RedrawFromNode(TreeMultiItemNode *n);

    void RedrawFromParentNode(TreeMultiItemBase *b);

    void DrawCheckbox(TreeMultiItemBase *b, wxDC &dc, bool convertScrolled = false);

    void RecalculateNodePositions();

    int CalculateNodeDimensions(TreeMultiItemBase *b, int currentY, int level);

    void DrawNode(TreeMultiItemBase *b, wxDC &dc);

    void SetWindowBackgroundColour(wxWindow *wnd, const wxColour &col, int flags);

    void ShowTreeMultiWindow(TreeMultiItemWindow *window, bool show = true);

    void UpdateAllWindowVisibility();

    void UpdateTreeMultiWindowVisibility(TreeMultiItemBase *b, bool show);

    void RecalculateVirtualSize();

    using wxScrolledWindow::AdjustScrollbars;
    virtual void AdjustScrollbars(int x, int y);

    void RecalculateVirtualSizeFromNode(const TreeMultiItemNode *node, int &x, int &y);

    TreeMultiItemBase *FindNodeByPoint(TreeMultiItemBase *b, wxPoint const& pt, int &area);

    wxTreeMultiItem FindWindowNode(wxWindow *wnd, TreeMultiItemNode *n = 0);

    TreeMultiItemWindow *FindNextVisibleWindowItem(TreeMultiItemBase *b, int index = -1);

    void AdjustIconsDeltaY();

        void CalculateNodeSpanning(TreeMultiItemBase *b);

#if(CHECKBOXVIEW)

    void SetRecursiveCheckState(TreeMultiItemNode *n, bool check);

    void ScanTristateCheckstates(TreeMultiItemBase *b);
#endif

    wxTreeMultiItem InsertNode(TreeMultiItemNode* ParentPtr, size_t Position, wxString const& Caption, wxString const& Name);

    wxTreeMultiItem InsertWindow(TreeMultiItemNode* ParentPtr, size_t Position, wxWindow* WindowPtr, wxString const& Name,
                                 wxTreeMultiWindowInfo const& Info, int Flags);

private:
    void Init();

    // handlers
    //---------

    //virtual void OnDraw(wxDC& dc);
    void OnPaint(wxPaintEvent &event);
    void OnMouseClick     (wxMouseEvent& event);
    void OnRightMouseClick(wxMouseEvent& Event);
    void OnKey(wxKeyEvent &event);
        void OnSize(wxSizeEvent &event);

        void RecalculateSpanSizes();

public:
    wxTreeMultiCtrl()
        : _create_called(false)
    {

        Init();
    }

    wxTreeMultiCtrl(wxWindow *parent, wxWindowID id = -1,
                        const wxPoint& pos = wxDefaultPosition,
                        const wxSize& size = wxDefaultSize,
                        long style = wxTMC_DEFAULT_STYLE,
                        const wxValidator &validator = wxDefaultValidator,
                        const wxString& name = wxTreeMultiCtrlNameStr)
        : _style(style | wxTAB_TRAVERSAL)
        , _create_called(false)
    {
        Create(parent, id, pos, size, style, validator, name);
    }

    virtual ~wxTreeMultiCtrl();

    bool Create(wxWindow *parent, wxWindowID id = -1,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = wxTMC_DEFAULT_STYLE,
                const wxValidator &validator = wxDefaultValidator,
                const wxString& name = wxTreeMultiCtrlNameStr);

    // accessors
    //----------

    wxTreeMultiItem AddRoot(const wxString &caption, const wxString &name = wxEmptyString);

    wxTreeMultiItem AppendWindow(const wxTreeMultiItem &ParentItem, wxWindow *window = NULL, const wxString &name = wxEmptyString,
                                 wxTreeMultiWindowInfo const& info = wxTreeMultiWindowInfoDefault, int flags = 0);

    wxTreeMultiItem InsertWindow(wxTreeMultiItem const& ParentItem, size_t Position, wxWindow *window = NULL, wxString const& Name = wxEmptyString,
                                 wxTreeMultiWindowInfo const& info = wxTreeMultiWindowInfoDefault, int flags = 0);

    wxTreeMultiItem PrependWindow(wxTreeMultiItem const& ParentItem, wxWindow *window = NULL, const wxString &name = wxEmptyString,
                                  wxTreeMultiWindowInfo const& info = wxTreeMultiWindowInfoDefault, int flags = 0);

    wxTreeMultiItem AppendNode(wxTreeMultiItem const& ParentItem, const wxString &caption = wxEmptyString,
                               const wxString &name = wxEmptyString);

    wxTreeMultiItem InsertNode(wxTreeMultiItem const& ParentItem, size_t Position, wxString const& caption, wxString const& name);

    wxTreeMultiItem PrependNode(wxTreeMultiItem const& ParentItem, wxString const& caption = wxEmptyString,
                                wxString const& name = wxEmptyString);

    bool Delete(wxTreeMultiItem &item);

    void DeleteAllItems(void)
    {
      this->_root.Clear();
      this->m_SelectedItems.Clear();
      Refresh();
    };

    void DeleteChildren(const wxTreeMultiItem &item);

    void ExpandNodes(bool recursive = false);

    void CollapseNodes(bool recursive = false);

    void Expand(const wxTreeMultiItem &item, bool recursive);

    void Collapse(const wxTreeMultiItem &item, bool recursive);

    void CollapseAndReset(const wxTreeMultiItem &item);

    void Fold(const wxTreeMultiItem &item, bool expand = true) {
        if(expand)
            Expand(item, false);
        else
            Collapse(item, false);
    };

    size_t GetSelectedItemCount(void) const {return this->m_SelectedItems.GetCount();}

    wxTreeMultiItem GetFirstSelectedItem(void) const;

    wxTreeMultiItem GetLastSelectedItem(void) const;

    wxTreeMultiItem GetSelectedItem(size_t Index) const;

    size_t GetSelectedItemIndex(wxTreeMultiItem const& Item) const;

    void SelectItem(wxTreeMultiItem const& Item, bool UnselectOthers=true, bool ExpandSelection=false);

    void UnselectAll(void);

    void Unselect(wxTreeMultiItem const& Item);

    void Exclude(const wxTreeMultiItem &item);

    void Include(const wxTreeMultiItem &item);

    wxTreeMultiItem GetExcludedParent(const wxTreeMultiItem &item);

    wxTreeMultiItem HitTest(wxPoint const& pt, int &flags);

    wxTreeMultiItem FindItem(const wxTreeMultiItem &item, const wxString &name, bool ignoreCase = false,
                             bool skipFirst = false);

    wxTreeMultiItem FindItem(const wxString &name, bool ignoreCase = false) {
        return FindItem(wxTreeMultiItem(&_root), name, ignoreCase, false);
    };

    int GetChildrenCount(const wxTreeMultiItem &item) {
        if(item.IsNodeItem())
        {
            TreeMultiItemNode *n = (TreeMultiItemNode *)item.GetItem();
            return n->GetNodeCount();
        }

        return -1;
    };

    wxTreeMultiItem GetFocus();

    bool GetBooleanValue(int wndId);

    wxString GetTextValue(int wndId);

    void SetBooleanValue(int wndId, bool value = true);

    void SetTextValue(int wndId, const wxString &value = wxEmptyString);

    wxWindow *GetWindow(const wxTreeMultiItem &item) {
        if(item.IsWindowItem())
            return ((TreeMultiItemWindow *)item.GetItem())->GetWindow();
        return 0;
    };

    void SetSelectionValue(int wndId, int sel);

    int GetSelectionValue(int wndId);

    void GetSelectionValues(int wndId, wxArrayInt &sels);

#if(CHECKBOXVIEW)

    int GetCheckboxState(const wxTreeMultiItem &item, bool WXUNUSED(recursive)) {
        wxCHECK(item.IsOk(), -1);

        // return the checkbox state
        TreeMultiItemBase *b = item.GetItem();
        if(b->GetCheckbox())
            return b->GetCheckboxState();

        return -1;
    };

        void SetCheckboxState( const wxTreeMultiItem &item, int state ) {
                wxCHECK2( item.IsOk(), return );
                TreeMultiItemBase *b = item.GetItem();
                if( b->GetCheckbox() )
                        b->SetCheckboxState( state );
                RedrawFromNode( item.GetItem()->GetParent() );
        };
#endif

    void SetSpacingY(int spacingY) {
        if(spacingY >= 0)
        {
            _spacingY = spacingY;
            RedrawFromNode(0);
        }
    };

    int GetSpacingY() const {
        return _spacingY;
    };

#if(CHECKBOXVIEW)

    void SetCheckboxView(bool value) {
        _checkboxView = value;
    };

    bool GetCheckboxView() const {
        return _checkboxView;
    };
#endif

    wxTreeMultiItem GetFirstRoot(void) const {return wxTreeMultiItem(this->_root.First());}

    wxTreeMultiItem GetLastRoot(void) const {return wxTreeMultiItem(this->_root.Last());}

    wxTreeMultiItem GetParent(wxTreeMultiItem const& item) const;

    wxTreeMultiItem GetFirstChild(const wxTreeMultiItem &item, int &cookie) const;

    wxTreeMultiItem GetNextChild(const wxTreeMultiItem &item, int &cookie) const;

    wxTreeMultiItem GetLastChild(const wxTreeMultiItem &item) const;

    wxTreeMultiItem GetNextSibling(wxTreeMultiItem const& item) const;

    wxTreeMultiItem GetPrevSibling(wxTreeMultiItem const& item) const;

    wxTreeMultiItem GetNext(wxTreeMultiItem const& item) const;

    wxTreeMultiItem GetPrevious(wxTreeMultiItem const& item) const;


    const wxFont &GetCaptionFont() const {
        return _captionFont;
    };

    void SetCaptionFont(const wxFont &font);

  void OnDraw(wxDC& dc);

private:
    DECLARE_EVENT_TABLE()
};

#endif