Tree.h

#if !defined(AFX_TREE_H__BBD70483_77F5_11D3_A029_9012FE27D07B__INCLUDED_)
#define AFX_TREE_H__BBD70483_77F5_11D3_A029_9012FE27D07B__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
// Tree.h : header file
//
/////////////////////////////////////////////////////////////////////////////
// CTree window
#include "CustomData.h"
#include "CustomData.h"
#include "XStdLib.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
typedef enum
{
    TRAVERSAL_FINISH = 0,
    TRAVERSAL_NODE_INFO,
    TRAVERSAL_GOTO_PARENT_NODE,
    TRAVERSAL_NODE_HAS_CHILD,
} TreeTraversalInfo;
 
typedef enum
{
    TREE_SERIALIZE_END_OF_LEVEL = 0,
    TREE_SERIALIZE_CHILD_NODE = 1,
    TREE_SERIALIZE_NO_CHILD,
    TREE_SERIALIZE_ITEM,
    TREE_SERIALIZE_ROOT,
} TreeSerializeInfo;
 
typedef enum
{
    TRAVERSAL_CHILDS = 1,
    TRAVERSAL_CHILDS_AND_ITSELF, 
    TRAVERSAL_DIRECT_CHILD,
    TRAVERSAL_FROM_NODE_TO_NODE,
} TreeTraversalMode;
 
class CTree;
 
typedef enum
{
    TREE_NODE_NONE = 0x00,
    TREE_NODE_EXPANDED = 0x01,
} TreeNodeFlag;
 
#define TREE_NODE_VERSION 3
#define CTREE_VERSION 2
 
class DLL_TOOLSFUNCTION CTreeNode : public CXObject
{
    DECLARE_SERIAL_XOBJECT(CTreeNode);
 
    template<typename CTreeNode> friend void xDestroy(CTreeNode *);
    friend CTree;
 
private:
    CTreeNode *child;
    CTreeNode *parent;
    CTreeNode *left;
    CTreeNode *right;
    unsigned int flags;
 
protected:
    virtual ~CTreeNode();
 
public:
    CTreeNode();
 
    virtual bool DeleteNode();
 
    void SetFlag(TreeNodeFlag flag, bool set);
    unsigned int GetFlags();
 
    inline const CTreeNode* GetChild() const { return child; };
    inline const CTreeNode* GetParent() const { return parent; };
    inline const CTreeNode* GetLeft() const { return left; };
    inline const CTreeNode* GetRight() const { return right; };
    inline CTreeNode* GetChild() { return child; };
    inline CTreeNode* GetParent() { return parent; };
    inline CTreeNode* GetLeft() { return left; };
    inline CTreeNode* GetRight() { return right; };
 
    inline void SetChild(CTreeNode *node) { child = node; };
    inline void SetParent(CTreeNode* node) { parent = node; };
    inline void SetLeft(CTreeNode* node) { left = node; };
    inline void SetRight(CTreeNode* node) { right = node; };
 
    // No data in the default node. Always ==
 
    virtual CXString GetDisplayName() const {return CXString();};
    virtual CTreeNode *CopyFrom(unsigned int flags = 0) const; // flags give more control on the copy. It can be defined by the derived class if needed
    virtual bool operator==(const CTreeNode& node);
    virtual void Serialize(CXArchive& ar);
};
 
class DLL_TOOLSFUNCTION TreeTraversalCallback
{
    protected:
        CTree *tree;
        CTreeNode *find;
 
    public:
        TreeTraversalCallback(CTree *reftree)
        {
            this->tree = reftree;
            find = NULL;
        }
 
        virtual ~TreeTraversalCallback()
        {
        }
 
        CTreeNode *GetFind()
        {
            return find;
        }
 
        void SetFind(CTreeNode *node)
        {
            find = node;
        }
 
        // return true to continue, false otherwise...
        virtual bool NodeInformation(CTreeNode *node, TreeTraversalInfo info) = 0;
};
 
class CCustomTree;
class DLL_TOOLSFUNCTION CTree : public CXObject
{
    friend CCustomTree;
 
// Construction
public:
    DECLARE_SERIAL_XOBJECT(CTree);
 
    CTree();
    virtual ~CTree();
 
    CTreeNode *GetRoot() const;
    bool IsEmpty() const;
 
    static CTreeNode *GetParent(const CTreeNode *node);
    static const CTreeNode *GetConstParent(const CTreeNode *node);
    static CTreeNode *GetChild(const CTreeNode *node);
    static const CTreeNode *GetConstChild(const CTreeNode *node);
    static CTreeNode *GetRight(const CTreeNode *node);
    static const CTreeNode *GetConstRight(const CTreeNode *node);
    static CTreeNode *GetLeft(const CTreeNode *node);
    static const CTreeNode *GetConstLeft(const CTreeNode *node);
    static int GetDepth(const CTreeNode *node);
    
    CTreeNode *GetFirstNode(const CTreeNode *node) const;
    CTreeNode *GetNextNode(const CTreeNode *node, const CTreeNode *stopNode = NULL) const;
    CTreeNode *HasCommonParent(const CTreeNode *refnode, const CTreeNode *checknode) const; // Look if refnode direct parent can be found in checknode parent branch, if so, return refnode->parent, otherwise null
 
    void SetRoot(CTreeNode *node);
    void AddChild(CTreeNode *parentNode, CTreeNode *newnode, bool last = true);
    void MoveRight(CTreeNode *parentNode, CTreeNode *newnode);
    bool ReplaceNode(CTreeNode *newnode, CTreeNode *oldnode, bool deleteIt = true); // Replace oldnode with newnode, meaning that newnode is attached to oldnode parent and childs. old node become alone.
    CTreeNode *RemoveNode(CTreeNode *node); // Remove a node without deleting it
    CTreeNode *DeleteNode(CTreeNode *node, CXArray<CTreeNode *> *deletedNodes = NULL); // Remove and delete a node
    void DeleteAll(bool deleteRoot = false, CXArray<CTreeNode*>* deletedNodes = NULL);
 
    int GetChildNbr(const CTreeNode *node, bool directChild) const;
 
    virtual void Sort(CTreeNode *node, XQSORT_PROTO compareCallback, void *compareData = NULL, bool sortDirectChildOnly = false);
    void DoTraversal(CTreeNode *node, TreeTraversalMode mode, TreeTraversalCallback *callback);
 
    CTreeNode* NodeExist(TreeTraversalMode mode, CTreeNode* where, CTreeNode* what, bool searchOnlyPtr = false); // if searchOnlyPtr = false, we use the == operator of the nodes. NodeExists can be resume to a find operation. Otherwise we look only for the same pointer.
 
    void SetSilent(bool silent) { silentSerialization = silent; }
    virtual void Serialize(CXArchive& ar);
 
// Attributes
protected:
    void DeleteChilds(CTreeNode *node, CXArray<CTreeNode*>* deletedNodes = NULL);
    void CopyChilds(CTreeNode *node, CTreeNode *copyNode, unsigned int flags = 0);
 
    void NodeSerialize(CTreeNode *parentnode, CXArchive& ar);
    void MoveNode(CTreeNode *node, CTreeNode *newParent);
    CTreeNode *CopyBranch(CTreeNode *srcNode, CTreeNode *newParent, bool copyChilds, unsigned int flags = 0);
    CTreeNode *CopyNode(const CTreeNode *srcNode, CTreeNode *newParent, bool copyChilds, unsigned int flags = 0);
 
    // Overrides
    // ClassWizard generated virtual function overrides
    //{{AFX_VIRTUAL(CTree)
    //}}AFX_VIRTUAL
 
    // Generated message map functions
protected:
    bool silentSerialization;
    CTreeNode *root;
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_TREE_H__BBD70483_77F5_11D3_A029_9012FE27D07B__INCLUDED_)