Desktop Manager Application

///File Name: WindowsTreeManager.cs
///This file include declaration of the class WindowsTreeManager , this class
///holds a TreeView item and it control all the activities that build this tree.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using DesktopManager.Tree.Nodes;
using DesktopManager.Tree.Nodes.Interfaces;
using DesktopManager.Tree.Utilities;

namespace DesktopManager.Tree
{
    public interface IControlStateDescriptor
    {
        bool IsBusy { get; }
    }
    public class WindowsTreeManager : IControlStateDescriptor
    {
        private TreeView m_TreeView;
        private DraggedItemPathUpdator m_DraggedItemPathUpdator;

        public WindowsTreeManager(TreeView i_TreeView)
        {
            this.m_TreeView = i_TreeView;
            this.m_DraggedItemPathUpdator = new DraggedItemPathUpdator();
            this.attachToEvents();
            this.setProperties();
            RootNode rootNode = this.addRootNode();
            rootNode.Expand();
            this.m_TreeView.PathSeparator = "@";
        }

        private void setProperties()
        {
            this.m_TreeView.AllowDrop = true;
            this.m_TreeView.LabelEdit = true;
            this.m_TreeView.ShowNodeToolTips = true;
            this.m_TreeView.ImageList = new ImageList();
            this.m_TreeView.ImageList.Images.Add("Root", s_DefualtImage);
            this.m_TreeView.ImageList.Images.Add("Category", s_DefualtImage);
        }

        private RootNode addRootNode()
        {
            RootNode rootNode = new RootNode();
            this.m_TreeView.Nodes.Add(rootNode);

            return rootNode;
        }

        private void attachToEvents()
        {
            this.m_TreeView.DragDrop += treeView_DragDrop;
            this.m_TreeView.DragEnter += treeView_DragEnter;
            this.m_TreeView.ItemDrag += treeView_ItemDrag;
            this.m_TreeView.DragLeave += new EventHandler(WindowsTree_DragLeave);
            this.m_TreeView.DragOver += new DragEventHandler(WindowsTree_DragOver);
            this.m_TreeView.BeforeLabelEdit += new NodeLabelEditEventHandler(WindowsTree_BeforeLabelEdit);
            this.m_TreeView.AfterLabelEdit += new NodeLabelEditEventHandler(WindowsTree_AfterLabelEdit);
            this.m_TreeView.MouseDoubleClick += new MouseEventHandler(WindowsTree_MouseDoubleClick);
            this.m_TreeView.NodeMouseClick += new TreeNodeMouseClickEventHandler(WindowsTree_NodeMouseClick);
        }

        void WindowsTree_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            e.Node.TreeView.SelectedNode = e.Node;
        }

        void WindowsTree_DragLeave(object sender, EventArgs e)
        {
            this.m_IsBusy = false;
        }


        void WindowsTree_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            TreeView currentTreeView = sender as TreeView;
            Point targetNodeLocation = new Point(e.X, e.Y);
            TreeNode clickedNode = currentTreeView.GetNodeAt(targetNodeLocation);

            if (clickedNode is IDoubleClickable)
            {
                (clickedNode as IDoubleClickable).OnItemDoubleClicked();
            }
        }

        void WindowsTree_DragOver(object sender, DragEventArgs e)
        {
            TreeView currentTreeView = sender as TreeView;
            Point targetNodeLocation = currentTreeView.PointToClient(new Point(e.X, e.Y));
            TreeNode destinationNode = currentTreeView.GetNodeAt(targetNodeLocation);

            if (!(destinationNode is IReceiver && e.Data.GetData(s_TreeNodeStrongName) is IDragAndDropable)
                  && !e.Data.GetFormats().Contains(s_FileDrop) )
            {
                e.Effect = DragDropEffects.None;
            }
            else
            {
                e.Effect = DragDropEffects.Move;
                destinationNode.TreeView.SelectedNode = destinationNode;
            }
        }

        void WindowsTree_AfterLabelEdit(object sender, NodeLabelEditEventArgs e)
        {
            try
            {
                if (!string.IsNullOrEmpty(e.Label))
                {
                    e.Node.Text = e.Label;
                    e.Node.Name = e.Label;

                    TreeNode fatherNode = e.Node;

                    this.m_DraggedItemPathUpdator.UpdateChildrenPath(fatherNode);

                }
            }
            finally
            {
                this.m_IsBusy = false;
            }
        }

        public void AddNodeByFullPath(TreeNode i_Node, string i_Path)
        {
            if (!this.m_IsBusy)
            {
                TreeNode currentNode = this.m_TreeView.Nodes[0];

                if (!string.IsNullOrEmpty(i_Path))
                {
                    List<string> pathElements = i_Path.Split(this.m_TreeView.PathSeparator.ToCharArray(),
                        StringSplitOptions.RemoveEmptyEntries).ToList<string>();
                    pathElements.Remove(pathElements[0]);
                    pathElements.Remove(pathElements[pathElements.Count - 1]);
                    TreeNodeCollection currentNodeCollection = currentNode.Nodes;

                    foreach (string nodeName in pathElements)
                    {
                        currentNode = currentNodeCollection[nodeName];
                        currentNodeCollection = currentNode.Nodes;
                    }
                }

                currentNode.Nodes.Add(i_Node);
                this.TryAddNodeImageToTreeImageList(i_Node);
            }


        }

        protected static Image s_DefualtImage = new Bitmap(1, 1);

        private void TryAddNodeImageToTreeImageList(TreeNode i_Node)
        {
            IImageRepresentable currentlyAddedContorl = i_Node as IImageRepresentable;

            if (currentlyAddedContorl != null)
            {
                if (this.m_TreeView.ImageList == null)
                {
                    this.m_TreeView.ImageList = new ImageList();
                }

                Image imageForItem = currentlyAddedContorl.Image;

                if (imageForItem == null)
                {
                    imageForItem = s_DefualtImage;
                }

                if (!this.m_TreeView.ImageList.Images.ContainsKey(currentlyAddedContorl.ImageKey))
                {
                    this.m_TreeView.ImageList.Images.Add(currentlyAddedContorl.ImageKey, imageForItem);
                }
            }
        }

        public void ClearWindowLeaves()
        {
            if (!this.m_IsBusy)
            {
                List<TreeNode> treeNodesToRemove = new List<TreeNode>();
                foreach (TreeNode node in this.m_TreeView.Nodes)
                {
                    ClearWindowLeavesHelper(node, treeNodesToRemove);
                }

                foreach (TreeNode node in treeNodesToRemove)
                {
                    node.Remove();
                }
            }
        }

        protected void ClearWindowLeavesHelper(TreeNode i_RootNode, List<TreeNode> treeNodesToRemove)
        {
            foreach (TreeNode node in i_RootNode.Nodes)
            {
                ClearWindowLeavesHelper(node, treeNodesToRemove);
            }

            if (i_RootNode is WindowNode)
            {

                treeNodesToRemove.Add(i_RootNode);
            }

        }


        void WindowsTree_BeforeLabelEdit(object sender, NodeLabelEditEventArgs e)
        {
            IsEditable edittedNode = e.Node as IsEditable;
            if (edittedNode != null)
            {
                e.CancelEdit = !edittedNode.IsLableEditable;
                this.m_IsBusy = !e.CancelEdit;
            }
        }



        protected static string s_TreeNodeStrongName = typeof(WindowNode).FullName;
        private void treeView_DragDrop(object sender, DragEventArgs e)
        {
            try
            {
                TreeView currentTreeView = sender as TreeView;
                Point targetNodeLocation = currentTreeView.PointToClient(new Point(e.X, e.Y));
                TreeNode destinationNode = currentTreeView.GetNodeAt(targetNodeLocation);

                IReceiver destinationReciever = destinationNode as IReceiver;

                if (destinationReciever != null)
                {
                    object draggedData = null;
                    if (e.Data.GetDataPresent(s_TreeNodeStrongName, false))
                    {
                        //TreeNode draggedNode = e.Data.GetData(s_TreeNodeStrongName) as TreeNode;
                        draggedData = e.Data.GetData(s_TreeNodeStrongName) as TreeNode;
              
                    }
                    else if(e.Data.GetFormats().Contains(s_FileDrop))
                    {
                        draggedData = (e.Data.GetData(s_FileDrop) as string[])[0];
                    }


                    destinationReciever.Receive(draggedData);

                    IDragAndDropable dragDropable = draggedData as IDragAndDropable;
                    
                    if (dragDropable != null)
                    {
                        dragDropable.OnDropped();
                    }

                }
            }
            finally
            {
                e.Effect = DragDropEffects.None;
                this.m_IsBusy = false;
            }

        }
        private static string s_FileDrop = "FileDrop"; 
        private void treeView_DragEnter(object sender, DragEventArgs e)
        {
            this.m_IsBusy = true;

            if (e.Data.GetFormats().Contains(s_FileDrop))
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                TreeNode draggedNode = (sender as TreeView).SelectedNode;

                if (draggedNode is IDragAndDropable)
                {
                    e.Effect = DragDropEffects.Move;
                }
                else
                {
                    e.Effect = DragDropEffects.None;
                }
            }

        }

        private void treeView_ItemDrag(object sender, ItemDragEventArgs e)
        {
            this.m_TreeView.DoDragDrop(e.Item, DragDropEffects.Move);
        }




        #region IContorlStateDescriptor Members
        private bool m_IsBusy = false;
        public bool IsBusy
        {
            get
            {

                return m_IsBusy;
            }
        }

        #endregion
    }

}