wxTreeMultiCtrl.h

//---------------------------------------------------------------------------
// $RCSfile$
// $Source$
// $Revision$
// $Date$
//---------------------------------------------------------------------------
// 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();
    }
 
    wxString GetName() const {
        wxCHECK(_item, wxEmptyString);
        return _item->GetName();
    }
};
 
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;
 
    wxWindow* m_parent;
 
    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 = nullptr,
                                 const wxString& name = wxEmptyString,
                                 wxTreeMultiWindowInfo const& info = wxTreeMultiWindowInfoDefault, int flags = 0);
 
    wxTreeMultiItem InsertWindow(wxTreeMultiItem const& ParentItem, size_t Position, wxWindow* window = nullptr,
                                 wxString const& Name = wxEmptyString,
                                 wxTreeMultiWindowInfo const& info = wxTreeMultiWindowInfoDefault, int flags = 0);
 
    wxTreeMultiItem PrependWindow(wxTreeMultiItem const& ParentItem, wxWindow* window = nullptr,
                                  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 SetCaption(wxTreeMultiItem const& item, const wxString& caption);
 
    void OnDraw(wxDC& dc);
 
  private:
    DECLARE_EVENT_TABLE()
};
 
#endif