BrawlCrate.UI.TreeViewMS Class Reference

http://www.arstdesign.com/articles/treeviewms.html More...

Inheritance diagram for BrawlCrate.UI.TreeViewMS:

Public Member Functions
	TreeViewMS ()

Protected Member Functions
override void	OnPaint (PaintEventArgs pe)
override void	OnBeforeSelect (TreeViewCancelEventArgs e)
override void	OnAfterSelect (TreeViewEventArgs e)
bool	isParent (TreeNode parentNode, TreeNode childNode)
void	paintSelectedNodes ()
void	removePaintFromNodes ()

Protected Attributes
List< TreeNode >	m_coll
TreeNode	m_lastNode
TreeNode	m_firstNode

Properties
List< TreeNode >	SelectedNodes [get, set]
Type	SelectedType [get]

Detailed Description

http://www.arstdesign.com/articles/treeviewms.html

Constructor & Destructor Documentation

TreeViewMS()

BrawlCrate.UI.TreeViewMS.TreeViewMS ( )

inline

        {
            m_coll = new List<TreeNode>();
        }

Member Function Documentation

isParent()

bool BrawlCrate.UI.TreeViewMS.isParent ( TreeNode  parentNode, TreeNode  childNode  )

inlineprotected

        {
            if (parentNode == childNode)
            {
                return true;
            }
 
            TreeNode n = childNode;
            bool bFound = false;
            while (!bFound && n != null)
            {
                n = n.Parent;
                bFound = n == parentNode;
            }
 
            return bFound;
        }

OnAfterSelect()

override void BrawlCrate.UI.TreeViewMS.OnAfterSelect ( TreeViewEventArgs  e )

inlineprotected

        {
            base.OnAfterSelect(e);
 
            if (e.Action == TreeViewAction.ByMouse)
            {
                bool bControl = ModifierKeys == Keys.Control;
                bool bShift = ModifierKeys == Keys.Shift;
 
                if (bControl)
                {
                    if (!m_coll.Contains(e.Node)) // new node ?
                    {
                        m_coll.Add(e.Node);
                    }
                    else // not new, remove it from the collection
                    {
                        removePaintFromNodes();
                        m_coll.Remove(e.Node);
                    }
 
                    paintSelectedNodes();
                }
                else
                {
                    // SHIFT is pressed
                    if (bShift)
                    {
                        Queue<TreeNode> myQueue = new Queue<TreeNode>();
 
                        TreeNode uppernode = m_firstNode;
                        TreeNode bottomnode = e.Node;
                        // case 1 : begin and end nodes are parent
                        bool bParent = isParent(m_firstNode, e.Node); // is m_firstNode parent (direct or not) of e.Node
                        if (!bParent)
                        {
                            bParent = isParent(bottomnode, uppernode);
                            if (bParent) // swap nodes
                            {
                                TreeNode t = uppernode;
                                uppernode = bottomnode;
                                bottomnode = t;
                            }
                        }
 
                        if (bParent)
                        {
                            TreeNode n = bottomnode;
                            while (n != (uppernode?.Parent ?? bottomnode))
                            {
                                if (!m_coll.Contains(n)) // new node ?
                                {
                                    myQueue.Enqueue(n);
                                }
 
                                n = n.Parent;
                            }
                        }
                        // case 2 : nor the begin nor the end node are descendant one another
                        else
                        {
                            if (uppernode.Parent == null && bottomnode.Parent == null || uppernode.Parent != null &&
                                uppernode.Parent.Nodes.Contains(bottomnode)) // are they siblings ?
                            {
                                int nIndexUpper = uppernode.Index;
                                int nIndexBottom = bottomnode.Index;
                                if (nIndexBottom < nIndexUpper) // reversed?
                                {
                                    TreeNode t = uppernode;
                                    uppernode = bottomnode;
                                    bottomnode = t;
                                    nIndexUpper = uppernode.Index;
                                    nIndexBottom = bottomnode.Index;
                                }
 
                                TreeNode n = uppernode;
                                while (nIndexUpper <= nIndexBottom)
                                {
                                    if (!m_coll.Contains(n)) // new node ?
                                    {
                                        myQueue.Enqueue(n);
                                    }
 
                                    n = n.NextNode;
 
                                    nIndexUpper++;
                                } // end while
                            }
                            else
                            {
                                if (!m_coll.Contains(uppernode))
                                {
                                    myQueue.Enqueue(uppernode);
                                }
 
                                if (!m_coll.Contains(bottomnode))
                                {
                                    myQueue.Enqueue(bottomnode);
                                }
                            }
                        }
 
                        m_coll.AddRange(myQueue);
 
                        paintSelectedNodes();
                        m_firstNode = e.Node; // let us chain several SHIFTs if we like it
                    }                         // end if m_bShift
                    else
                    {
                        // in the case of a simple click, just add this item
                        if (m_coll != null && m_coll.Count > 0)
                        {
                            removePaintFromNodes();
                            m_coll.Clear();
                        }
 
                        m_coll.Add(e.Node);
                    }
                }
            }
        }

OnBeforeSelect()

override void BrawlCrate.UI.TreeViewMS.OnBeforeSelect ( TreeViewCancelEventArgs  e )

inlineprotected

        {
            base.OnBeforeSelect(e);
 
            if (e.Action == TreeViewAction.ByMouse)
            {
                bool bControl = ModifierKeys == Keys.Control;
                bool bShift = ModifierKeys == Keys.Shift;
 
                // selecting twice the node while pressing CTRL ?
                if (bControl && m_coll.Contains(e.Node))
                {
                    // unselect it (let framework know we don't want selection this time)
                    e.Cancel = true;
 
                    // update nodes
                    removePaintFromNodes();
                    m_coll.Remove(e.Node);
                    paintSelectedNodes();
                    return;
                }
 
                m_lastNode = e.Node;
                if (!bShift)
                {
                    m_firstNode = e.Node; // store begin of shift sequence
                }
            }
            else
            {
                if (m_coll != null && m_coll.Count > 0)
                {
                    removePaintFromNodes();
                    m_coll.Clear();
                }
            }
        }

OnPaint()

override void BrawlCrate.UI.TreeViewMS.OnPaint ( PaintEventArgs  pe )

inlineprotected

        {
            // TODO: Add custom paint code here
 
            // Calling the base class OnPaint
            base.OnPaint(pe);
        }

paintSelectedNodes()

void BrawlCrate.UI.TreeViewMS.paintSelectedNodes ( )

inlineprotected

        {
            foreach (TreeNode n in m_coll)
            {
                n.BackColor = SystemColors.Highlight;
                n.ForeColor = SystemColors.HighlightText;
            }
        }

removePaintFromNodes()

void BrawlCrate.UI.TreeViewMS.removePaintFromNodes ( )

inlineprotected

        {
            if (m_coll.Count == 0)
            {
                return;
            }
 
            TreeNode n0 = m_coll[0];
            if (n0.TreeView == null)
            {
                return;
            }
 
            Color back = n0.TreeView.BackColor;
            Color fore = n0.TreeView.ForeColor;
            if (n0 is BaseWrapper b)
            {
                if (b.DefaultBackColor != null)
                {
                    back = (Color) b.DefaultBackColor;
                }
 
                if (b.DefaultForeColor != null)
                {
                    fore = (Color) b.DefaultForeColor;
                }
            }
 
            foreach (TreeNode n in m_coll)
            {
                n.BackColor = back;
                n.ForeColor = fore;
            }
        }

Member Data Documentation

m_coll

List<TreeNode> BrawlCrate.UI.TreeViewMS.m_coll

protected

m_firstNode

TreeNode BrawlCrate.UI.TreeViewMS.m_firstNode

protected

m_lastNode

TreeNode BrawlCrate.UI.TreeViewMS.m_lastNode

protected

Property Documentation

SelectedNodes

List<TreeNode> BrawlCrate.UI.TreeViewMS.SelectedNodes

getset

        {
            get => m_coll;
            set
            {
                removePaintFromNodes();
                m_coll.Clear();
                m_coll = value;
                paintSelectedNodes();
            }
        }

SelectedType

Type BrawlCrate.UI.TreeViewMS.SelectedType

get

        {
            get
            {
                Type t = SelectedNode?.GetType();
                if (SelectedNodes.Count > 1)
                {
                    foreach (TreeNode n in SelectedNodes)
                    {
                        if (!n.GetType().IsAssignableFrom(t))
                        {
                            if (n.GetType().IsAssignableFrom(typeof(GenericWrapper)))
                            {
                                t = typeof(GenericWrapper);
                            }
                            else
                            {
                                t = null;
                                break;
                            }
                        }
                    }
                }
 
                return t;
            }
        }

---

The documentation for this class was generated from the following file:

• BrawlCrate/UI/TreeViewMS.cs