Horizontal Tree Control

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Drawing2D;
using Sarafian.Framework.ClientSide.UI.Resources.HorizontalTree.NodeControls;
using Sarafian.Framework.ClientSide.UI.Resources.HorizontalTree.Nodes;
using Sarafian.Framework.ClientSide.UI.Resources.HorizontalTree.NodeParts;

namespace Sarafian.Framework.ClientSide.UI.Resources.HorizontalTree.Selection
{
    public partial class SelectorControl : ListBox
    {
        public SelectorControl()
        {
            base.BackColor = Color.WhiteSmoke;
            base.DrawMode = DrawMode.OwnerDrawFixed;
            base.Visible = false;
        }
        private SolidBrush sbBack = new SolidBrush(Color.FromArgb(100, Color.LightGray));

        private HorizontalTreeControl horizontalTree;
        public HorizontalTreeControl HorizontalTree
        {
            get { return this.horizontalTree; }
            set
            {
                this.horizontalTree = value;
                base.BackColor = this.horizontalTree.SelectorBackColor;
                this.horizontalTree.ParentForm.Controls.Add(this);
            }
        }

        private NodeBaseControl baseParent;
        public NodeBaseControl BaseParent
        {
            get { return this.baseParent; }
            set { this.baseParent = value; }
        }
        internal void Populate()
        {
            base.Items.Clear();
            AddNodes(this.baseParent.Nodes);
        }
        private bool itemsHaveImage = false;
        internal void AddNodes(NodeBase[] nodes)
        {
            base.Items.AddRange(nodes);
            this.itemsHaveImage = false;
            foreach (NodeBase node in nodes)
            {
                if (node is Node)
                {
                    if ((node as Node).Image != null)
                    {
                        this.itemsHaveImage = true;
                        continue;
                    }
                }
            }
            base.ClientSize = new Size(GetWidth(), base.Items.Count * base.ItemHeight);
        }
        internal void RemoveNode(object node)
        {
            base.Items.Remove(node);
            base.ClientSize = new Size(base.ClientSize.Width, base.Items.Count * base.ItemHeight);
        }
        private Node selectedNode = null;
        public Node SelectedNode
        {
            get { return this.selectedNode; }
        }

        private int GetWidth()
        {
            int width = 0;
            using (Graphics g = Graphics.FromHwnd(this.Handle))
            {
                foreach (NodeBase nodeBase in base.Items)
                {
                    if (nodeBase is NodeSeperator)
                    {
                        continue;
                    }
                    Node node = nodeBase as Node;
                    Size temp = g.MeasureString(node.DisplayText, base.Font).ToSize();
                    if (temp.Width + node.ImageSize.Width > width)
                    {
                        width = temp.Width + node.ImageSize.Width + 5;
                    }
                }
            }
            return width + Configuration.Margin;
        }
        private void DrawSeperator(Rectangle bounds, Graphics g, NodeSeperator seperator)
        {
            int offSet = (bounds.Width * (100 - seperator.Percent)) / 100;
            Point start = bounds.Location;
            start.Y += (int)((float)bounds.Height) / 2;
            start.X += offSet;
            Point end = new Point(bounds.Right - offSet, start.Y);
            g.DrawLine(HorizontalTree.LinePen, start, end);
        }

        protected override void OnDrawItem(DrawItemEventArgs e)
        {
            e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
            if (base.Items[e.Index] is NodeSeperator)
            {
                DrawSeperator(e.Bounds, e.Graphics, (NodeSeperator)base.Items[e.Index]);
                return;
            }
            Node node = (Node)base.Items[e.Index];
            Rectangle border = e.Bounds;
            border.Width--;
            border.Height--;

            if (e.State == DrawItemState.Selected)
            {

                using (LinearGradientBrush lgb = new LinearGradientBrush(e.Bounds, this.horizontalTree.HotColorMinOpacity, this.horizontalTree.HotColorMaxOpacity, 90, false))
                {
                    e.Graphics.FillRectangle(lgb, e.Bounds);
                }
                e.Graphics.DrawPath(HorizontalTree.HotColorPen, Sarafian.Framework.General.Drawing.Rectangle.GetBorderPath(border));
            }
            else
            {
                e.Graphics.FillRectangle(HorizontalTree.SelectorBackBrush, e.Bounds);
            }
            if (this.itemsHaveImage)
            {
                Rectangle imageRect = new Rectangle(0, e.Bounds.Y, e.Bounds.Height, e.Bounds.Height);
                Rectangle textRect = e.Bounds;
                Point lineStart = new Point(imageRect.Right + 2, imageRect.Y);
                Point lineEnd = new Point(lineStart.X, imageRect.Bottom);
                textRect.X = lineEnd.X + 3;
                textRect.Width = e.Bounds.Width - textRect.X;

                if (node.Image != null)
                {
                    e.Graphics.DrawImage(node.Image, imageRect);
                }
                e.Graphics.DrawLine(HorizontalTree.LinePen, lineStart, lineEnd);

                e.Graphics.DrawString(node.DisplayText, e.Font, Brushes.Black, textRect);
            }
            else
            {
                e.Graphics.DrawString(node.DisplayText, e.Font, Brushes.Black, e.Bounds);
            }
        }
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
            if (!base.ClientRectangle.Contains(e.Location))
            {
                Canceled();
            }
        }
        protected override void OnMouseClick(MouseEventArgs e)
        {
            base.OnMouseClick(e);
            if (base.SelectedIndex == -1 || base.SelectedItem is NodeSeperator)
            {
            }
            else
            {
                this.selectedNode = (Node)base.SelectedItem;
                Selected();
            }
        }


        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
            if (base.ClientRectangle.Contains(e.Location))
            {
                int indexToSelect = (int)((float)e.Y / base.ItemHeight);
                if (indexToSelect < base.Items.Count)
                {
                    base.SelectedIndex = indexToSelect;
                }
            }
            else
            {
                this.horizontalTree.MouseMoveFromSelector(Sarafian.Framework.General.Drawing.Point.TranslatePoint(this, this.horizontalTree, e.Location));
                base.SelectedIndex = -1;
            }

        }


        protected override void OnMouseLeave(EventArgs e)
        {
            base.SelectedIndex = -1;
        }
        internal event DelegateEnum.DelegateSelectorSelected Selected = null;
        internal event DelegateEnum.DelegateSelectorCanceled Canceled = null;

    }
}