using System.Drawing;
using System.Drawing.Drawing2D;
using System;
using System.Collections;
using DevComponents.DotNetBar;
using DevComponents.DotNetBar.Rendering;

namespace DevComponents.AdvTree.Display
{
	/// <summary>
	/// Summary description for NodeTreeDisplay.
	/// </summary>
	public class NodeTreeDisplay:NodeDisplay
	{
		#region Private Variables
		// Cashed objects
		ElementStyleDisplayInfo m_ElementStyleDisplayInfo=new ElementStyleDisplayInfo();
		NodeCellRendererEventArgs m_CellDisplayInfo=new NodeCellRendererEventArgs();
//		CurveConnectorDisplay m_CurveConnectorDisplay=null;
//		LineConnectorDisplay m_LineConnectorDisplay=null;
		private NodeSystemRenderer m_SystemRenderer=new NodeSystemRenderer();
		//private NodeProfessionalRenderer m_ProfRenderer=new NodeProfessionalRenderer();
		#endregion
		/// <summary>Creates new instance of the class</summary>
		/// <param name="tree">Object to initialize class with.</param>
		public NodeTreeDisplay(AdvTree tree):base(tree)
		{
            m_SystemRenderer.ColorTable = new TreeColorTable();
            ColorTableInitializer.InitOffice2007Blue(m_SystemRenderer.ColorTable, new ColorFactory());
		}

        public NodeSystemRenderer SystemRenderer
        {
            get { return m_SystemRenderer; }
            set { m_SystemRenderer = value; }
        }

        public TreeRenderer GetTreeRenderer()
        {
            TreeRenderer renderer = m_SystemRenderer;
            if (this.Tree.NodeRenderer != null && this.Tree.RenderMode == eNodeRenderMode.Custom)
                renderer = this.Tree.NodeRenderer;
            if (GlobalManager.Renderer is Office2007Renderer)
            {
                renderer.Office2007ColorTable = ((Office2007Renderer)GlobalManager.Renderer).ColorTable;
                renderer.ColorTable = renderer.Office2007ColorTable.AdvTree;
            }

            return renderer;
        }

        private NodeDisplayContext CreateDisplayContext(Graphics g, Rectangle clipRectangle)
        {
            NodeDisplayContext context = new NodeDisplayContext();
            context.Graphics = g;
            context.DefaultFont = this.Tree.Font;
            context.ClipRectangle = clipRectangle;
            context.Offset = this.Offset;
            context.Styles = this.Tree.Styles;
            context.IsBackgroundSelection = IsBackgroundSelection;
            context.ClientRectangle = ElementStyleLayout.GetInnerRect(Tree.BackgroundStyle, Tree.ClientRectangle);
            context.ColorScheme = Tree.ColorScheme;
            context.GridRowLines = Tree.GridRowLines;
            context.GridRowLineColor = Tree.GridLinesColor;
            context.CellSelection = Tree.SelectionPerCell;
            context.AlternateRowBrush = CreateBrush(Tree.AlternateRowColor);
            context.DrawAlternateRowBackground = !Tree.AlternateRowColor.IsEmpty;
            context.View = this.Tree.View;
            context.TileGroupLineColor = this.Tree.TileGroupLineColor;
            // Setup rendering
            context.NodeRenderer = m_SystemRenderer;
            if (this.Tree.NodeRenderer != null && this.Tree.RenderMode == eNodeRenderMode.Custom)
                context.NodeRenderer = this.Tree.NodeRenderer;
            if (GlobalManager.Renderer is Office2007Renderer)
            {
                context.NodeRenderer.Office2007ColorTable = ((Office2007Renderer)GlobalManager.Renderer).ColorTable;
                context.NodeRenderer.ColorTable = context.NodeRenderer.Office2007ColorTable.AdvTree;
            }

            context.NodeRendererEventArgs = new NodeRendererEventArgs();

            if (this.Tree.NodeStyle != null)
                context.DefaultNodeStyle = this.Tree.NodeStyle;
            else
                context.DefaultNodeStyle = GetDefaultNodeStyle();

            if (this.Tree.NodeStyleExpanded != null)
                context.ExpandedNodeStyle = this.Tree.NodeStyleExpanded;
            if (this.Tree.NodeStyleSelected != null)
                context.SelectedNodeStyle = this.Tree.NodeStyleSelected;
            if (this.Tree.NodeStyleMouseOver != null)
                context.MouseOverNodeStyle = this.Tree.NodeStyleMouseOver;

            if (this.Tree.CellStyleDefault != null)
                context.CellStyleDefault = this.Tree.CellStyleDefault;
            if (this.Tree.CellStyleDisabled != null)
                context.CellStyleDisabled = this.Tree.CellStyleDisabled;
            else
                context.CellStyleDisabled = ElementStyle.GetDefaultDisabledCellStyle();
            if (this.Tree.CellStyleMouseDown != null)
                context.CellStyleMouseDown = this.Tree.CellStyleMouseDown;
            if (this.Tree.CellStyleMouseOver != null)
                context.CellStyleMouseOver = this.Tree.CellStyleMouseOver;
            if (this.Tree.CellStyleSelected != null)
                context.CellStyleSelected = this.Tree.CellStyleSelected;
            else
                context.CellStyleSelected = ElementStyle.GetDefaultSelectedCellStyle();

            // Setup connector
            context.ConnectorDisplayInfo = new ConnectorRendererEventArgs();
            context.ConnectorDisplayInfo.Graphics = context.Graphics;
            
            // Setup Node Expander Painter
            context.ExpandDisplayInfo = new NodeExpandPartRendererEventArgs(context.Graphics);
            context.ExpandDisplayInfo.BackColor = this.Tree.GetColor(this.Tree.ExpandBackColor, this.Tree.ExpandBackColorSchemePart);
            context.ExpandDisplayInfo.BackColor2 = this.Tree.GetColor(this.Tree.ExpandBackColor2, this.Tree.ExpandBackColor2SchemePart);
            
            context.ExpandDisplayInfo.BackColorGradientAngle = this.Tree.ExpandBackColorGradientAngle;
            context.ExpandDisplayInfo.BorderColor = this.Tree.GetColor(this.Tree.ExpandBorderColor, this.Tree.ExpandBorderColorSchemePart);
            context.ExpandDisplayInfo.ExpandLineColor = this.Tree.GetColor(this.Tree.ExpandLineColor, this.Tree.ExpandLineColorSchemePart);
            context.ExpandDisplayInfo.Graphics = context.Graphics;
            context.ExpandDisplayInfo.ExpandButtonType = this.Tree.ExpandButtonType;
            context.ExpandDisplayInfo.ExpandImage = this.Tree.ExpandImage;
            context.ExpandDisplayInfo.ExpandImageCollapse = this.Tree.ExpandImageCollapse;
            
            // Setup Selection Display
            context.SelectionDisplayInfo = new SelectionRendererEventArgs();
            context.SelectionDisplayInfo.Graphics = context.Graphics;
            context.SelectionDisplayInfo.SelectionBoxStyle = this.Tree.SelectionBoxStyle;
            context.SelectionDisplayInfo.TreeActive = this.Tree.IsKeyboardFocusWithin || !this.Tree.SelectionFocusAware;

            return context;
        }

        private Brush CreateBrush(Color color)
        {
            if (color.IsEmpty) return null;
            return new SolidBrush(color);
        }

		/// <summary>
		/// Paints the tree on canvas.
		/// </summary>
		public override void Paint(Graphics g, Rectangle clipRectangle)
		{
			base.Paint(g,clipRectangle);

            // Setup custom check box images if any
            m_CellDisplayInfo.CheckBoxImageChecked = this.Tree.CheckBoxImageChecked;
            m_CellDisplayInfo.CheckBoxImageUnChecked = this.Tree.CheckBoxImageUnChecked;
            m_CellDisplayInfo.CheckBoxImageIndeterminate = this.Tree.CheckBoxImageIndeterminate;
            m_CellDisplayInfo.ItemPaintArgs = new ItemPaintArgs(null, Tree, g, new ColorScheme());

			// Paint header
            if (GlobalManager.Renderer is Office2007Renderer)
            {
                m_SystemRenderer.Office2007ColorTable = ((Office2007Renderer)GlobalManager.Renderer).ColorTable;
                m_CellDisplayInfo.ItemPaintArgs.Colors = m_SystemRenderer.Office2007ColorTable.LegacyColors;
                m_CellDisplayInfo.ItemPaintArgs.Renderer = GlobalManager.Renderer;
            }
			// Paint Nodes...
            NodeDisplayContext context = CreateDisplayContext(g, clipRectangle);
            
			if(this.Tree.SelectedPathConnector!=null)
			{
				// Prepare nodes for path display. Downstream nodes are easily recognized when
				// path upstream nodes need special treatment to improve performance
				if(this.Tree.SelectedNode!=null)
				{
					Node n=this.Tree.SelectedNode;
					while(n!=null)
					{
						// This marker will be reset once node is painted...
						n.SelectedConnectorMarker = true;
						n=n.Parent;
					}
				}
				//context.SelectedPathConnectorDisplay=GetConnectorDisplay(this.Tree.SelectedPathConnector);
			}

            if (context.DrawAlternateRowBackground)
            {
                PaintAlternateRowBackground(context);
            }

            // Paint Grid Lines
            if (this.Tree.GridColumnLines && this.Tree.Columns.Count > 0)
            {
                PaintGridLines(context);
            }

            // Paint background for nodes with full row background
            if (this.Tree.FullRowBackgroundNodes != null && this.Tree.FullRowBackgroundNodes.Count > 0)
                PaintFullRowBackgroundForNodes(context, this.Tree.FullRowBackgroundNodes);

            // Paint selection
            if (context.IsBackgroundSelection)
            {
                PaintSelection(context);
            }
            if (Tree.HotTracking)
                PaintHotTracking(context);
            Rectangle innerRect = Tree.GetPaintRectangle();
		    Rectangle clientRect = Tree.ClientRectangle;
		    
            if(innerRect == clipRectangle || clientRect == clipRectangle || clipRectangle.IsEmpty)
                _PaintedNodes.Clear();
            
			if(this.Tree.DisplayRootNode!=null)
				this.PaintNode(this.Tree.DisplayRootNode, context);
			else
				this.PaintNodes(this.Tree.Nodes, context);

			Node dragNode=this.Tree.GetDragNode();
			if(dragNode!=null && dragNode.Parent==null)
			{
				Point p=context.Offset;
				context.Offset=Point.Empty;
				PaintNode(dragNode,context);
				context.Offset=p;
			}
            if (this.Tree.IsDragDropInProgress && this.Tree.PaintDragDropInsertMarker)
            {
                PaintDragInsertMarker(context, this.Tree.GetDragInsertionBounds(this.Tree.GetNodeDragInfo()));
            }

            if(!context.IsBackgroundSelection)
			    PaintSelection(context);

            if (context.AlternateRowBrush != null)
            {
                context.AlternateRowBrush.Dispose();
                context.AlternateRowBrush = null;
            }
		}

        private void PaintAlternateRowBackground(NodeDisplayContext context)
        {
            if (this.Tree.DisplayRootNode != null)
            {
                context.AlternateRowFlag = true;
                PaintAlternateRowBackground(context, this.Tree.DisplayRootNode.Nodes);
            }
            else
            {
                PaintAlternateRowBackground(context, this.Tree.Nodes);
            }
        }

        private void PaintAlternateRowBackground(NodeDisplayContext context, NodeCollection nodeCollection)
        {
            foreach (Node node in nodeCollection)
            {
                if (!node.Visible) continue;
                Rectangle r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds, node, context.Offset);
                if (r.Y > context.ClientRectangle.Bottom) break;

                if (r.Y >= context.ClientRectangle.Y)
                {
                    if (context.AlternateRowFlag)
                    {
                        Rectangle backRect = new Rectangle(context.ClientRectangle.X, r.Y - 1, context.ClientRectangle.Width, r.Height + 1);
                        context.Graphics.FillRectangle(context.AlternateRowBrush, backRect);
                    }
                }
                context.AlternateRowFlag = !context.AlternateRowFlag;

                if (node.Expanded && node.HasChildNodes) PaintAlternateRowBackground(context, node.Nodes);
            }
        }

        public void ExternalPaintNode(Node node, Graphics g, Rectangle bounds)
        {
            // Setup custom check box images if any
            m_CellDisplayInfo.CheckBoxImageChecked = this.Tree.CheckBoxImageChecked;
            m_CellDisplayInfo.CheckBoxImageUnChecked = this.Tree.CheckBoxImageUnChecked;
            m_CellDisplayInfo.CheckBoxImageIndeterminate = this.Tree.CheckBoxImageIndeterminate;

            // Paint header
            if (GlobalManager.Renderer is Office2007Renderer)
                m_SystemRenderer.Office2007ColorTable = ((Office2007Renderer)GlobalManager.Renderer).ColorTable;
            // Paint Nodes...
            NodeDisplayContext context = CreateDisplayContext(g, bounds);
            context.ExpandDisplayInfo = null;
            context.ConnectorDisplayInfo = null;

            // Update offset
            context.Offset = new Point(bounds.X - node.BoundsRelative.X, bounds.Y - node.BoundsRelative.Y);

            PaintSingleNode(node, context);
        }

        private void PaintGridLines(NodeDisplayContext context)
        {
            PaintGridLines(context, Tree.Columns, context.ClientRectangle);   
        }

        private void PaintGridLines(NodeDisplayContext context, ColumnHeaderCollection columnHeaderCollection, Rectangle bounds)
        {
            Color color = this.Tree.GridLinesColor.IsEmpty ? context.NodeRenderer.ColorTable.GridLines : this.Tree.GridLinesColor;
            Graphics g = context.Graphics;
            for (int i = 0; i < columnHeaderCollection.Count; i++)
            {
                ColumnHeader columnHeader = columnHeaderCollection.ColumnAtDisplayIndex(i);
                if (!columnHeader.Visible || columnHeader.Bounds.Width <= 0) continue;
                Rectangle r = columnHeader.Bounds;
                r.Offset(context.Offset);
                if (columnHeaderCollection.ParentNode == null)
                {
                    r.Offset(bounds.Location);
                    if (!columnHeader.CellsBackColor.IsEmpty)
                    {
                        SmoothingMode oldSmoothing = g.SmoothingMode;
                        g.SmoothingMode = SmoothingMode.None;
                        Rectangle rBack = new Rectangle(r.X - 5, context.ClientRectangle.Y, r.Width + 4, context.ClientRectangle.Height);
                        using (SolidBrush brush = new SolidBrush(columnHeader.CellsBackColor))
                            g.FillRectangle(brush, rBack);
                        g.SmoothingMode = oldSmoothing;
                    }
                }
                DisplayHelp.DrawLine(g, r.Right - (columnHeader.IsLastVisible ? 0 : 1), bounds.Y, r.Right - (columnHeader.IsLastVisible ? 0 : 1), bounds.Bottom, color, 1);
            }
        }

        private void PaintFullRowBackgroundForNodes(NodeDisplayContext context, ArrayList nodesCollection)
        {
            Rectangle clientRectangle = context.ClientRectangle;
            if (this.Tree.VScrollBar != null) clientRectangle.Width -= this.Tree.VScrollBar.Width;

            foreach (Node node in nodesCollection)
            {
                Rectangle r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds, node, context.Offset);

                if (!r.IsEmpty)
                {
                    r.X = clientRectangle.X;
                    r.Width = clientRectangle.Width;
                    r.Inflate(0, 1);
                }

                if (r.IsEmpty || !r.IntersectsWith(context.ClipRectangle) && !context.ClipRectangle.IsEmpty)
                    continue;
                ElementStyle style = GetEffectiveNodeBackgroundStyle(node, context);
                if (style == null)
                    continue;
                TreeRenderer renderer = context.NodeRenderer;
                if (node.NodeRenderer != null && node.RenderMode == eNodeRenderMode.Custom)
                    renderer = node.NodeRenderer;
                if (style != null)
                {
                    context.NodeRendererEventArgs.Graphics = context.Graphics;
                    context.NodeRendererEventArgs.Node = node;
                    context.NodeRendererEventArgs.NodeBounds = r;
                    context.NodeRendererEventArgs.Style = style;
                    renderer.DrawNodeBackground(context.NodeRendererEventArgs);
                }
            }
        }

        private void PaintDragInsertMarker(NodeDisplayContext context, Rectangle dragInsertionBounds)
        {
            if (dragInsertionBounds.IsEmpty) return;
            context.NodeRenderer.DrawDragDropMarker(new DragDropMarkerRendererEventArgs(context.Graphics, dragInsertionBounds));
        }
        
        public bool IsBackgroundSelection
        {
            get { return this.Tree.SelectionBoxStyle != eSelectionStyle.NodeMarker; }
        }
        
		private void PaintSelection(NodeDisplayContext context)
		{
            if (!this.Tree.MultiSelect && this.Tree.SelectedNode != null && this.Tree.SelectedNode.Visible && this.Tree.SelectionBox && !(this.Tree.HideSelection && !this.Tree.Focused))
			{
                PaintNodeSelection(this.Tree.SelectedNode, context);
			}
            else if (this.Tree.MultiSelect && this.Tree.SelectedNodes.Count>0 && this.Tree.SelectionBox && !(this.Tree.HideSelection && !this.Tree.Focused))
            {
                foreach (Node node in Tree.SelectedNodes)
                {
                    if(node.IsVisible)
                        PaintNodeSelection(node, context);    
                }
            }
		}

        private void PaintNodeSelection(Node node, NodeDisplayContext context)
        {
            if (!node.IsSelectionVisible) return;

            context.SelectionDisplayInfo.Node = node;
            Rectangle r;
            if (this.Tree.SelectionBoxStyle == eSelectionStyle.FullRowSelect)
            {
                if (context.CellSelection)
                {
                    Cell cell = context.SelectionDisplayInfo.Node.SelectedCell != null ? context.SelectionDisplayInfo.Node.SelectedCell : context.SelectionDisplayInfo.Node.Cells[0];
                    r = NodeDisplay.GetCellRectangle(eCellRectanglePart.CellBounds, 
                        cell, context.Offset);
                }
                else
                {
                    r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds, context.SelectionDisplayInfo.Node, context.Offset);
                    r.X = context.ClientRectangle.X;
                    r.Width = context.ClientRectangle.Width;
                }
                if(context.GridRowLines)
                    r.Inflate(0, (int)Math.Floor((float)Tree.NodeSpacing / 2));
                else
                    r.Inflate(0, (int)Math.Ceiling((float)Tree.NodeSpacing / 2));
            }
            else if (this.Tree.SelectionBoxStyle == eSelectionStyle.HighlightCells)
            {
                if (context.CellSelection)
                {
                    Cell cell = context.SelectionDisplayInfo.Node.SelectedCell != null ? context.SelectionDisplayInfo.Node.SelectedCell : context.SelectionDisplayInfo.Node.Cells[0];
                    r = NodeDisplay.GetCellRectangle(eCellRectanglePart.CellBounds,
                        cell, context.Offset);
                }
                else
                {
                    r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.CellsBounds, context.SelectionDisplayInfo.Node, context.Offset);
                }
                r.Inflate(2, 2);
                if (r.Right > context.ClientRectangle.Right)
                    r.Width -= (r.Right - context.ClientRectangle.Right);
                    
            }
            else
            {
                if (context.CellSelection)
                {
                    Cell cell = context.SelectionDisplayInfo.Node.SelectedCell != null ? context.SelectionDisplayInfo.Node.SelectedCell : context.SelectionDisplayInfo.Node.Cells[0];
                    r = NodeDisplay.GetCellRectangle(eCellRectanglePart.CellBounds,
                        cell, context.Offset);
                }
                else
                {
                    r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds, context.SelectionDisplayInfo.Node, context.Offset);
                }
            }

            context.SelectionDisplayInfo.Bounds = r;
            context.NodeRenderer.DrawSelection(context.SelectionDisplayInfo);
        }

        private void PaintHotTracking(NodeDisplayContext context)
        {
            Node node = this.Tree.MouseOverNode;
            if (node != null && !node.IsSelected && node.Selectable)
            {
                Rectangle r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.CellsBounds, node, context.Offset);
                r.Inflate(2, 2);
                context.SelectionDisplayInfo.Node = node;
                context.SelectionDisplayInfo.Bounds = r;
                context.NodeRenderer.DrawHotTracking(context.SelectionDisplayInfo);
            }
        }

        private Node PaintNodes(NodeCollection nodes, NodeDisplayContext context)
        {
            Node lastPainted = null;
            int count = nodes.Count;
            int start = 0;

            // Find first node to render in case there are lot of them
            if (context.View == eView.Tree && count > 99 && /*this.Tree.NodesConnector == null &&*/ context.Offset.Y != 0)
            {
                int testIndex = count / 2;
                int chunk = testIndex;
                while (testIndex > 0 && testIndex < count)
                {
                    chunk = chunk / 2;
                    Node node = nodes[testIndex];
                    if (!node.Visible)
                    {
                        int ti = testIndex + 1;
                        while (ti < count)
                        {
                            node = nodes[ti];
                            ti++;
                            if (node.Visible) break;
                        }
                        if (!node.Visible)
                        {
                            ti = testIndex - 1;
                            while (ti >= 0)
                            {
                                node = nodes[ti];
                                ti--;
                                if (node.Visible) break;
                            }
                        }
                    }
                    if (!node.Visible)
                    {
                        start = 0;
                        break;
                    }
                    Rectangle r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds, node, context.Offset);
                    if (chunk > 0 && r.Y > context.ClipRectangle.Bottom) // go back
                        testIndex -= chunk;
                    else if (chunk > 0 && r.Y < context.ClipRectangle.Y) // go forward
                        testIndex += chunk;
                    else
                    {
                        if (testIndex == 0) break;
                        testIndex--;
                        for (int i = testIndex; i >= 0; i--)
                        {
                            node = nodes[i];
                            if (!node.Visible) continue;
                            r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds, node, context.Offset);
                            if (r.Y < context.ClipRectangle.Y)
                            {
                                start = i;
                                break;
                            }
                        }
                        break;
                    }
                }
            }

            bool clipEmpty = context.ClipRectangle.IsEmpty;
            for (int i = start; i < count; i++)
            {
                Node node = nodes[i];
                if (PaintNode(node, context))
                {
                    lastPainted = node;
                    Rectangle r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds, node, context.Offset);
                    if (!clipEmpty && r.Y > context.ClipRectangle.Bottom && !context.ClientRectangle.IsEmpty)
                        break;
                }
            }
            return lastPainted;
        }

		private bool PaintNode(Node node, NodeDisplayContext context)
		{
			if(!node.Visible)
			{
				node.SelectedConnectorMarker = false;
				return false;
			}

			Rectangle r=NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds,node,context.Offset);
			if(r.IsEmpty)
			{
				node.SelectedConnectorMarker = false;
                return false;
			}

            if (context.GridRowLines && !node.IsDragNode)
            {
                DisplayHelp.DrawLine(context.Graphics, context.ClientRectangle.X, r.Bottom+1, context.ClientRectangle.Right, r.Bottom+1, context.GridRowLineColor, 1);
            }

            bool paintChildNodes = (node.Expanded && node.Nodes.Count > 0);
            
            if (!node.IsDragNode && (node.Parent != null || node.ExpandVisibility != eNodeExpandVisibility.Hidden))
                this.PaintConnector(null, node, context, false);

            if (paintChildNodes)
            {
                Node lastChildNode = NodeOperations.GetLastVisibleChildNode(node);
                if (lastChildNode != null)
                    this.PaintConnector(node, lastChildNode, context, false);
            }

            node.SelectedConnectorMarker = false;

            if (NodeDisplay.HasColumnsVisible(node))
            {
                r.Height += node.ColumnHeaderHeight;
                r.Width = Math.Max(r.Width, node.NodesColumns.Bounds.Width);
            }
            if (r.Y >= context.ClipRectangle.Y && r.Y <= context.ClipRectangle.Bottom ||
                r.Bottom >= context.ClipRectangle.Y && r.Bottom <= context.ClipRectangle.Bottom ||
                r.Y <= context.ClipRectangle.Y && r.Bottom > context.ClipRectangle.Y ||
                context.ClipRectangle.IsEmpty)
                PaintSingleNode(node, context);
            
            if (paintChildNodes)
            {
                PaintNodes(node.Nodes, context);
            }

            return true;
		}

        private ElementStyle GetEffectiveNodeBackgroundStyle(Node node, NodeDisplayContext context)
        {
            ElementStyle style = context.DefaultNodeStyle.Copy();

            bool bApplyStyles = true;
            bool isSelected = (node.IsSelected && node.IsSelectionVisible);

            if (isSelected && context.SelectedNodeStyle == null && node.StyleSelected == null && !node.FullRowBackground) bApplyStyles = false;

            if (isSelected && (context.SelectedNodeStyle == null || context.SelectedNodeStyle.TextColor.IsEmpty) &&
                (node.StyleSelected == null || node.StyleSelected.TextColor.IsEmpty))
            {
                eSelectionStyle ss = Tree.SelectionBoxStyle;
                TreeSelectionColors table = context.NodeRenderer.ColorTable.Selection;
                if (context.SelectionDisplayInfo.TreeActive)
                {
                    if (ss == eSelectionStyle.FullRowSelect && !table.FullRowSelect.TextColor.IsEmpty)
                        style.TextColor = table.FullRowSelect.TextColor;
                    else if (ss == eSelectionStyle.HighlightCells && !table.HighlightCells.TextColor.IsEmpty)
                        style.TextColor = table.HighlightCells.TextColor;
                    else if (ss == eSelectionStyle.NodeMarker && !table.NodeMarker.TextColor.IsEmpty)
                        style.TextColor = table.NodeMarker.TextColor;
                }
                else
                {
                    if (ss == eSelectionStyle.FullRowSelect && !table.FullRowSelectInactive.TextColor.IsEmpty)
                        style.TextColor = table.FullRowSelectInactive.TextColor;
                    else if (ss == eSelectionStyle.HighlightCells && !table.HighlightCellsInactive.TextColor.IsEmpty)
                        style.TextColor = table.HighlightCellsInactive.TextColor;
                    else if (ss == eSelectionStyle.NodeMarker && !table.NodeMarkerInactive.TextColor.IsEmpty)
                        style.TextColor = table.NodeMarkerInactive.TextColor;
                }

            }
            else if (this.Tree.HotTracking && !node.IsSelected && node.Selectable && this.Tree.MouseOverNode == node)
            {
                SelectionColorTable table = context.NodeRenderer.ColorTable.Selection.NodeHotTracking;
                if (!table.TextColor.IsEmpty)
                    style.TextColor = table.TextColor;
            }

            if (node.Style != null)
            {
                if (bApplyStyles)
                    style.ApplyStyle(node.Style); //=node.Style.Copy();
                else
                    style.ApplyFontStyle(node.Style);
            }

            if (bApplyStyles && node.MouseOverNodePart == eMouseOverNodePart.Node && style != null)
            {
                ElementStyle mouseOverStyle = context.MouseOverNodeStyle;
                if (node.StyleMouseOver != null)
                {
                    mouseOverStyle = node.StyleMouseOver;
                    bApplyStyles = false;
                }
                if (mouseOverStyle != null)
                {
                    style.ApplyStyle(mouseOverStyle);
                    bApplyStyles = false;
                }
            }

            // On default style apply expanded style
            if (bApplyStyles && node.Expanded && style != null)
            {
                ElementStyle expandedStyle = context.ExpandedNodeStyle;
                if (node.StyleExpanded != null)
                    expandedStyle = node.StyleExpanded;
                if (expandedStyle != null)
                    style.ApplyStyle(expandedStyle);
            }

            // Apply selected style if needed too
            if (bApplyStyles && node.IsSelected && style != null)
            {
                ElementStyle selectedStyle = context.SelectedNodeStyle;
                if (node.StyleSelected != null)
                    selectedStyle = node.StyleSelected;
                if (selectedStyle != null)
                    style.ApplyStyle(selectedStyle);
            }

            if (style != null)
            {
                if (style.Font == null)
                    style.Font = context.DefaultFont;
            }

            return style;
        }

		private void PaintSingleNode(Node node, NodeDisplayContext context)
		{
            _PaintedNodes.Add(node);
			Rectangle r=NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeContentBounds,node,context.Offset);
			TreeRenderer renderer=context.NodeRenderer;
			if(node.NodeRenderer!=null && node.RenderMode==eNodeRenderMode.Custom)
				renderer = node.NodeRenderer;
            bool isSelected = node.IsSelectionVisible && node.IsSelected;

			// Paint node background
            ElementStyle style = GetEffectiveNodeBackgroundStyle(node, context);

			Region backRegion=null;
			if(style!=null)
			{
				context.NodeRendererEventArgs.Graphics=context.Graphics;
				context.NodeRendererEventArgs.Node = node;
				context.NodeRendererEventArgs.NodeBounds = r;
				context.NodeRendererEventArgs.Style = style;
                if (!node.FullRowBackground) // Node full row backgrounds are drawn first...
                    renderer.DrawNodeBackground(context.NodeRendererEventArgs);
                ElementStyleDisplayInfo di = new ElementStyleDisplayInfo(style, context.Graphics, context.NodeRendererEventArgs.NodeBounds);
                di.Bounds.Inflate(1, 1);
				backRegion=ElementStyleDisplay.GetStyleRegion(di);
                di.Bounds = r;
			}

            if (NodeDisplay.DrawExpandPart(node) && context.ExpandDisplayInfo != null)
            {
                r = NodeDisplay.GetNodeRectangle(eNodeRectanglePart.ExpandBounds, node, context.Offset);
                context.ExpandDisplayInfo.Node = node;
                context.ExpandDisplayInfo.ExpandPartBounds = r;
                context.ExpandDisplayInfo.IsMouseOver = node.MouseOverNodePart == eMouseOverNodePart.Expand;
                renderer.DrawNodeExpandPart(context.ExpandDisplayInfo);
            }

            if (NodeDisplay.HasColumnsVisible(node))
            {
                PaintColumnHeaders(node.NodesColumns, context.Graphics, false);
            }

			Region oldRegion=null;
			if(backRegion!=null)
			{
				oldRegion=context.Graphics.Clip;
				context.Graphics.SetClip(backRegion,CombineMode.Intersect);
			}
			
			ElementStyle cellStyle = null;
            if (context.CellStyleDefault == null)
            {
                cellStyle = new ElementStyle();
                cellStyle.TextColor = style.TextColor;
                cellStyle.TextShadowColor = style.TextShadowColor;
                cellStyle.TextShadowOffset = style.TextShadowOffset;
                cellStyle.TextAlignment = style.TextAlignment;
                cellStyle.TextLineAlignment = style.TextLineAlignment;
                cellStyle.TextTrimming = style.TextTrimming;
                cellStyle.WordWrap = style.WordWrap;
                cellStyle.Font = style.Font;
                cellStyle.UseMnemonic = style.UseMnemonic;
            }
            
			foreach(Cell cell in node.Cells)
			{
                if (!cell.IsVisible) continue;
                if (cell.StyleNormal != null)
                {
                    if (context.CellStyleDefault != null)
                        style = context.CellStyleDefault.Copy();
                    else
                        style = cellStyle.Copy();
                    style.ApplyStyle(cell.StyleNormal);
                }
                else if (context.CellStyleDefault != null)
                    style = context.CellStyleDefault.Copy();
                else
                {
                    if (!cell.Enabled || cell.IsMouseDown && (cell.StyleMouseDown != null || context.CellStyleMouseDown != null) ||
                        cell.IsSelected && (cell.StyleSelected != null || context.CellStyleSelected != null) ||
                        cell.IsMouseOver && (cell.StyleMouseOver != null || context.CellStyleMouseOver != null))
                        style = cellStyle.Copy();
                    else
                        style = cellStyle;
                }

				if(!cell.Enabled && cell.StyleDisabled!=null)
					style.ApplyStyle(cell.StyleDisabled);
				else if(!cell.Enabled && context.CellStyleDisabled!=null)
					style.ApplyStyle(context.CellStyleDisabled);
				else if(cell.IsMouseDown && cell.StyleMouseDown!=null)
					style.ApplyStyle(cell.StyleMouseDown);
				else if(cell.IsMouseDown && context.CellStyleMouseDown!=null)
					style.ApplyStyle(context.CellStyleMouseDown);
				else 
				{
                    if (cell.IsSelected && cell.StyleSelected != null)
                        style.ApplyStyle(cell.StyleSelected);
                    else if (cell.IsSelected && context.CellStyleSelected != null && context.CellStyleSelected.Custom)
                        style.ApplyStyle(context.CellStyleSelected);
                    else if (isSelected && !cell.IsSelected && this.Tree.SelectionPerCell)
                        style.TextColor = context.DefaultNodeStyle.TextColor;

					if(cell.IsMouseOver && cell.StyleMouseOver!=null)
						style.ApplyStyle(cell.StyleMouseOver);
					else if(cell.IsMouseOver && context.CellStyleMouseOver!=null)
						style.ApplyStyle(context.CellStyleMouseOver);
				}

				r=NodeDisplay.GetNodeRectangle(eNodeRectanglePart.NodeBounds,node,context.Offset);
				
				if(style!=null)
				{
					if(style.Font==null)
						style.Font=context.DefaultFont;
                    if (isSelected)
                    {
                        style.BackColor = Color.Empty;
                        style.BackColorSchemePart = eColorSchemePart.None;
                        style.BackColor2 = Color.Empty;
                        style.BackColor2SchemePart = eColorSchemePart.None;
                    }

					Rectangle rCell=cell.BoundsRelative;
					Rectangle rText=cell.TextContentBounds;
					rCell.Offset(r.Location);
					rText.Offset(r.Location);
					ElementStyleDisplayInfo di=GetElementStyleDisplayInfo(style,context.Graphics,rCell);
					ElementStyleDisplay.Paint(di);
					NodeCellRendererEventArgs ci=GetCellDisplayInfo(style,context.Graphics,cell,r.Location, context.ColorScheme);
					
					if(ci.Cell.CheckBoxVisible)
						renderer.DrawCellCheckBox(ci);
					if(!ci.Cell.Images.LargestImageSize.IsEmpty)
						renderer.DrawCellImage(ci);
					renderer.DrawCellText(ci);
                    if (context.View == eView.Tile && node.HasChildNodes && !context.TileGroupLineColor.IsEmpty)
                        renderer.DrawTileGroupLine(new NodeRendererEventArgs(context.Graphics, node, r, style, context.TileGroupLineColor));                        
				}
			}

            if (backRegion != null)
            {
                context.Graphics.SetClip(oldRegion, CombineMode.Replace);
                backRegion.Dispose();
            }
            if(oldRegion!=null) oldRegion.Dispose();
		}

		private void PaintConnector(Node fromNode, Node toNode, NodeDisplayContext context,bool linkConnector)
		{
			PaintConnector(fromNode, toNode, context, linkConnector, null);
		}
		
		private void PaintConnector(Node fromNode, Node toNode, NodeDisplayContext context,bool linkConnector, ConnectorPointsCollection connectorPoints)
		{
            bool isRootNode = fromNode != null ? IsRootNode(fromNode) : IsRootNode(toNode);

            if (context.View == eView.Tile || isRootNode && fromNode == null && toNode.Nodes.Count == 0 && toNode.ExpandVisibility != eNodeExpandVisibility.Visible || context.ConnectorDisplayInfo == null)
                return;

			context.ConnectorDisplayInfo.FromNode=fromNode;
			context.ConnectorDisplayInfo.ToNode=toNode;
			context.ConnectorDisplayInfo.IsRootNode=isRootNode;
			context.ConnectorDisplayInfo.LinkConnector=linkConnector;
            if (fromNode != null && fromNode.Style != null)
                context.ConnectorDisplayInfo.StyleFromNode = fromNode.Style;
            else
                context.ConnectorDisplayInfo.StyleFromNode = context.DefaultNodeStyle;
			if(toNode.Style!=null)
				context.ConnectorDisplayInfo.StyleToNode=toNode.Style;
			else
				context.ConnectorDisplayInfo.StyleToNode=context.DefaultNodeStyle;
			context.ConnectorDisplayInfo.Offset=context.Offset;
			
			/*if(linkConnector)
			{
				context.ConnectorDisplayInfo.NodeConnector=this.Tree.LinkConnector;
			}
			else*/ if(toNode.SelectedConnectorMarker)
			{
				context.ConnectorDisplayInfo.NodeConnector=this.Tree.SelectedPathConnector;
			}
			else if(toNode.ParentConnector!=null)
			{
				context.ConnectorDisplayInfo.NodeConnector=toNode.ParentConnector;
			}
            //else if(isRootNode)
            //{
            //    context.ConnectorDisplayInfo.NodeConnector=this.Tree.RootConnector;
            //}
			else
			{
				context.ConnectorDisplayInfo.NodeConnector=this.Tree.NodesConnector;
			}

			if(linkConnector)
			{
				context.ConnectorDisplayInfo.ConnectorPoints=connectorPoints;
			}
			else
			{
				if(connectorPoints!=null)
					context.ConnectorDisplayInfo.ConnectorPoints=connectorPoints;
				else
					context.ConnectorDisplayInfo.ConnectorPoints=null;
			}

			context.NodeRenderer.DrawConnector(context.ConnectorDisplayInfo);
		}

		private void PaintConnector(Node toNode, NodeDisplayContext context)
		{
			PaintConnector(toNode.Parent, toNode, context,false);
		}
		
//		private void MoveHostedControls(Node node, NodeDisplayContext context)
//		{
//			foreach(Cell cell in node.Cells)
//			{
//				if(cell.HostedControl!=null && cell.HostedControl.Visible)
//				{
//					Rectangle bounds = NodeDisplay.GetCellRectangle(eCellRectanglePart.TextBounds, cell, context.Offset);
//					if(cell.HostedControl.Bounds!=bounds)
//						cell.HostedControl.Bounds=bounds;
//					return;
//				}
//			}
//		}

		private ElementStyleDisplayInfo GetElementStyleDisplayInfo(ElementStyle style, Graphics g, Rectangle bounds)
		{
			m_ElementStyleDisplayInfo.Style=style;
			m_ElementStyleDisplayInfo.Graphics=g;
			m_ElementStyleDisplayInfo.Bounds=bounds;
			return m_ElementStyleDisplayInfo;
		}

		private NodeCellRendererEventArgs GetCellDisplayInfo(ElementStyle style, Graphics g, Cell cell, Point cellOffset, ColorScheme cs)
		{
			m_CellDisplayInfo.Cell=cell;
			m_CellDisplayInfo.Graphics=g;
			m_CellDisplayInfo.Style=style;
			m_CellDisplayInfo.CellOffset=cellOffset;
            m_CellDisplayInfo.ColorScheme = cs;
			return m_CellDisplayInfo;
		}
        internal override void PaintColumnHeaders(ColumnHeaderCollection columns, Graphics g, bool treeControlHeader)
        {
             // Setup rendering
            TreeRenderer renderer = m_SystemRenderer;
            if (this.Tree.NodeRenderer != null && this.Tree.RenderMode == eNodeRenderMode.Custom)
                renderer = this.Tree.NodeRenderer;
            //else if (this.Tree.RenderMode == eNodeRenderMode.Professional)
            //    renderer = m_ProfRenderer;
            PaintColumnHeaders(renderer, columns, g, treeControlHeader);
        }

        internal void PaintColumnHeaders(TreeRenderer renderer, ColumnHeaderCollection columns, Graphics g, bool treeControlHeader)
        {
            ColumnHeaderRendererEventArgs ce = new ColumnHeaderRendererEventArgs();
            ce.Graphics = g;
            ce.Tree = this.Tree;
            ce.SortIndicatorColor = renderer.ColorTable.ColumnSortIndicatorColor;

            ElementStyle defaultNormalStyle = GetDefaultColumnStyleNormal(renderer);
            ElementStyle headerStyle = null;
            if(treeControlHeader)
                headerStyle = this.Tree.ColumnsBackgroundStyle == null ? GetDefaultHeaderStyle(renderer) : this.Tree.ColumnsBackgroundStyle;
            else
                headerStyle = this.Tree.NodesColumnsBackgroundStyle == null ? GetDefaultNodesHeaderStyle(renderer) : this.Tree.NodesColumnsBackgroundStyle;

            if (Tree.ColumnStyleNormal != null && Tree.ColumnStyleNormal.Custom)
                defaultNormalStyle = Tree.ColumnStyleNormal;

            Point offset = Point.Empty;
            if (this.Tree.AutoScroll)
            {
                offset = this.Tree.GetAutoScrollPositionOffset();
                if (treeControlHeader)
                    offset.Y = 0;
            }

            Rectangle columnsBounds = columns.Bounds;
            if (!treeControlHeader) columnsBounds.Offset(offset);
            ElementStyleDisplayInfo di = new ElementStyleDisplayInfo(headerStyle, g, columnsBounds);
            ElementStyleDisplay.Paint(di);
            Color columnSeparator = (headerStyle != null && !headerStyle.BorderColor.IsEmpty) ? headerStyle.BorderColor : Color.Empty;
            for (int i = 0; i < columns.Count; i++)
            {
                ColumnHeader column = columns.ColumnAtDisplayIndex(i);
                if (!column.Visible) continue;
                ElementStyle style = null;
                if (column.StyleNormal != "")
                    style = Tree.Styles[column.StyleNormal].Copy();
                else
                    style = defaultNormalStyle.Copy();

                if (column.IsMouseDown)
                {
                    if (column.StyleMouseDown != "")
                        style.ApplyStyle(Tree.Styles[column.StyleMouseDown]);
                    else if (Tree.ColumnStyleMouseDown != null)
                        style.ApplyStyle(Tree.ColumnStyleMouseDown);
                }
                else if (column.IsMouseOver)
                {
                    if (column.StyleMouseOver != "")
                        style.ApplyStyle(Tree.Styles[column.StyleMouseOver]);
                    else if (Tree.ColumnStyleMouseOver != null)
                        style.ApplyStyle(Tree.ColumnStyleMouseOver);
                }

                ce.ColumnHeader = column;
                Rectangle columnBounds = column.Bounds;
                columnBounds.Offset(offset);
                ce.Bounds = columnBounds;
                ce.Style = style;
                renderer.DrawColumnHeader(ce);
                if (!columnSeparator.IsEmpty)
                    DisplayHelp.DrawLine(g, columnBounds.Right - (column.IsLastVisible ? 0 : 1), columnBounds.Y, columnBounds.Right - (column.IsLastVisible ? 0 : 1), columnBounds.Bottom - 1, columnSeparator, 1);
            }
        }

        private ElementStyle GetDefaultHeaderStyle(TreeRenderer renderer)
        {
            if (renderer != null && renderer.Office2007ColorTable != null)
            {
                return renderer.Office2007ColorTable.StyleClasses[ElementStyleClassKeys.TreeColumnsHeaderKey] as ElementStyle;
            }
            else
            {
                ElementStyle style = new ElementStyle();
                style.BackColor = ColorScheme.GetColor(0xF9FCFD);
                style.BackColor2 = ColorScheme.GetColor(0xD3DBE9);
                style.BackColorGradientAngle = 90;
                style.TextColor = ColorScheme.GetColor(0x000000);
                style.BorderColor = ColorScheme.GetColor(0x9EB6CE);
                style.BorderBottom = eStyleBorderType.Solid;
                style.BorderBottomWidth = 1;
                return style;
            }
        }

        private ElementStyle GetDefaultNodesHeaderStyle(TreeRenderer renderer)
        {
            if (renderer != null && renderer.Office2007ColorTable != null)
            {
                return renderer.Office2007ColorTable.StyleClasses[ElementStyleClassKeys.TreeNodesColumnsHeaderKey] as ElementStyle;
            }
            else
            {
                ElementStyle style = new ElementStyle();
                style.BackColor = ColorScheme.GetColor(0xF9FCFD);
                style.BackColor2 = ColorScheme.GetColor(0xD3DBE9);
                style.BackColorGradientAngle = 90;
                style.TextColor = ColorScheme.GetColor(0x000000);
                style.BorderColor = ColorScheme.GetColor(0x9EB6CE);
                style.BorderBottom = eStyleBorderType.Solid;
                style.BorderBottomWidth = 1;
                style.BorderLeft = eStyleBorderType.Solid;
                style.BorderLeftWidth = 1;
                style.BorderTop = eStyleBorderType.Solid;
                style.BorderTopWidth = 1;
                return style;
            }
        }

        private ElementStyle GetDefaultColumnStyleNormal(TreeRenderer renderer)
        {
            if (renderer != null && renderer.Office2007ColorTable != null)
            {
                return renderer.Office2007ColorTable.StyleClasses[ElementStyleClassKeys.TreeColumnKey] as ElementStyle;
            }
            else
            {
                ElementStyle style = new ElementStyle();
                style.TextColor = ColorScheme.GetColor(0x000000);
                return style;
            }
        }

//		private NodeConnectorDisplay GetConnectorDisplay(NodeConnector c)
//		{
//			NodeConnectorDisplay d=null;
//			if(c==null)
//				return null;
//
//			switch(c.ConnectorType)
//			{
//				case eNodeConnectorType.Curve:
//				{
//					if(m_CurveConnectorDisplay==null)
//						m_CurveConnectorDisplay=new CurveConnectorDisplay();
//					d=m_CurveConnectorDisplay;
//					break;
//				}
//				case eNodeConnectorType.Line:
//				{
//					if(m_LineConnectorDisplay==null)
//						m_LineConnectorDisplay=new LineConnectorDisplay();
//					d=m_LineConnectorDisplay;
//					break;
//				}
//			}
//			return d;
//		}

		private class NodeDisplayContext
		{
			public Graphics Graphics=null;
			public Font DefaultFont=null;
			public Rectangle ClipRectangle=Rectangle.Empty;
			public Point Offset=Point.Empty;
			public ElementStyle DefaultNodeStyle=null;
			public ElementStyle ExpandedNodeStyle=null;
			public ElementStyle SelectedNodeStyle=null;
			public ElementStyle MouseOverNodeStyle=null;
			public ElementStyle CellStyleDefault=null;
			public ElementStyle CellStyleMouseDown=null;
			public ElementStyle CellStyleMouseOver=null;
			public ElementStyle CellStyleSelected=null;
			public ElementStyle CellStyleDisabled=null;
			public ElementStyleCollection Styles=null;
			//public NodeConnectorDisplay RootConnectorDisplay=null;
			//public NodeConnectorDisplay NodesConnectorDisplay=null;
			//public NodeConnectorDisplay LinkConnectorDisplay=null;
			//public NodeConnectorDisplay SelectedPathConnectorDisplay=null;
			public ConnectorRendererEventArgs ConnectorDisplayInfo=null;
			public NodeExpandPartRendererEventArgs ExpandDisplayInfo=null;
			//public NodeExpandDisplay ExpandDisplay=null;
			//public NodeSelectionDisplay SelectionDisplay=null;
			public SelectionRendererEventArgs SelectionDisplayInfo=null;
			//public NodeCommandDisplay CommandDisplay=null;
			//public NodeCommandPartRendererEventArgs CommandDisplayInfo=null;
			public bool SelectedNodePath=false;
			public TreeRenderer NodeRenderer=null;
			public NodeRendererEventArgs NodeRendererEventArgs=null;
            public bool IsBackgroundSelection = false;
            public Rectangle ClientRectangle = Rectangle.Empty;
            public ColorScheme ColorScheme = null;
            public bool GridRowLines = false;
            public Color GridRowLineColor = Color.Empty;
            public bool CellSelection = false;
            public Brush AlternateRowBrush = null;
            public bool DrawAlternateRowBackground = false;
            public bool AlternateRowFlag = false;
            public eView View = eView.Tree;
            public Color TileGroupLineColor = Color.Empty;
		}

		
	}
}