using System;

using System.Collections.Generic;

using System.Text;

using System.ComponentModel;

using System.Windows.Forms;

using System.Drawing;

using System.Windows.Forms.VisualStyles;

using System.Drawing.Imaging;

namespace Aga.Controls.Tree

{

	[TypeConverter(typeof(TreeColumn.TreeColumnConverter)), DesignTimeVisible(false), ToolboxItem(false)]

	public class TreeColumn : Component

	{

		private class TreeColumnConverter : ComponentConverter

		{

			public TreeColumnConverter()

				: base(typeof(TreeColumn))

			{

			}

			public override bool GetPropertiesSupported(ITypeDescriptorContext context)

			{

				return false;

			}

		}

		private const int HeaderLeftMargin = 5;

        private const int HeaderRightMargin = 5;   

		private const int SortOrderMarkMargin = 8;

        private TextFormatFlags _headerFlags;

        private TextFormatFlags _baseHeaderFlags = TextFormatFlags.NoPadding | 

                                                   TextFormatFlags.EndEllipsis |

                                                   TextFormatFlags.VerticalCenter |

												TextFormatFlags.PreserveGraphicsTranslateTransform;

		#region Properties

        private TreeColumnCollection _owner;

		internal TreeColumnCollection Owner

		{

			get { return _owner; }

			set { _owner = value; }

		}

		[Browsable(false)]

		public int Index

		{

			get 

			{

				if (Owner != null)

					return Owner.IndexOf(this);

				else

					return -1;

			}

		}

		private string _header;

		[Localizable(true)]

		public string Header

		{

			get { return _header; }

			set 

			{ 

				_header = value;

				OnHeaderChanged();

			}

		}

		private string _tooltipText;

		[Localizable(true)]

		public string TooltipText

		{

			get { return _tooltipText; }

			set { _tooltipText = value; }

		}

		private int _width;

		[DefaultValue(50), Localizable(true)]

		public int Width

		{

			get

            {

                return _width;

            }

			set 

			{

				if (_width != value)

				{

                    _width = Math.Max(MinColumnWidth, value);

                    if (_maxColumnWidth > 0)

                    {

                        _width = Math.Min(_width, MaxColumnWidth);

                    }

					OnWidthChanged();

				}

			}

		}

        private int _minColumnWidth;

        [DefaultValue(0)]

        public int MinColumnWidth

        {

            get { return _minColumnWidth; }

            set

            {

				if (value < 0)

					throw new ArgumentOutOfRangeException("value");

				_minColumnWidth = value;

                Width = Math.Max(value, Width);

            }

        }

        private int _maxColumnWidth;

        [DefaultValue(0)]

        public int MaxColumnWidth

        {

            get { return _maxColumnWidth; }

            set

            {

				if (value < 0)

					throw new ArgumentOutOfRangeException("value");

				_maxColumnWidth = value;

				if (value > 0)

					Width = Math.Min(value, _width);

            }

        }

		private bool _visible = true;

		[DefaultValue(true)]

		public bool IsVisible

		{

			get { return _visible; }

			set 

			{ 

				_visible = value;

				OnIsVisibleChanged();

			}

		}

		private HorizontalAlignment _textAlign = HorizontalAlignment.Left;

		[DefaultValue(HorizontalAlignment.Left)]

		public HorizontalAlignment TextAlign

		{

			get { return _textAlign; }

			set 

			{

				if (value != _textAlign)

				{

					_textAlign = value;

                    _headerFlags = _baseHeaderFlags | TextHelper.TranslateAligmentToFlag(value);

					OnHeaderChanged();

				}

			}

		}

        private bool _sortable = false;

        [DefaultValue(false)]

        public bool Sortable

        {

            get { return _sortable; }

            set { _sortable = value; }

        }

		private SortOrder _sort_order = SortOrder.None;

		public SortOrder SortOrder

		{

			get { return _sort_order; }

			set

			{

				if (value == _sort_order)

					return;

				_sort_order = value;

				OnSortOrderChanged();

			}

		}

		public Size SortMarkSize

		{

			get

			{

				if (Application.RenderWithVisualStyles)

					return new Size(9, 5);

				else

					return new Size(7, 4);

			}

		}

		#endregion

		public TreeColumn(): 

			this(string.Empty, 50)

		{

		}

        public TreeColumn(string header, int width)

		{

			_header = header;

			_width = width;

            _headerFlags = _baseHeaderFlags | TextFormatFlags.Left;

		}

		public override string ToString()

		{

			if (string.IsNullOrEmpty(Header))

				return GetType().Name;

			else

				return Header;

		}

		protected override void Dispose(bool disposing)

		{

			base.Dispose(disposing);

		}

		#region Draw

		private static VisualStyleRenderer _normalRenderer;

		private static VisualStyleRenderer _pressedRenderer;

		private static VisualStyleRenderer _hotRenderer;

		private static void CreateRenderers()

		{

			if (Application.RenderWithVisualStyles && _normalRenderer == null)

			{

				_normalRenderer = new VisualStyleRenderer(VisualStyleElement.Header.Item.Normal);

				_pressedRenderer = new VisualStyleRenderer(VisualStyleElement.Header.Item.Pressed);

				_hotRenderer = new VisualStyleRenderer(VisualStyleElement.Header.Item.Hot);

			}

		}

		internal Bitmap CreateGhostImage(Rectangle bounds, Font font)

		{

			Bitmap b = new Bitmap(bounds.Width, bounds.Height, PixelFormat.Format32bppArgb);

			Graphics gr = Graphics.FromImage(b);

			gr.FillRectangle(SystemBrushes.ControlDark, bounds);

			DrawContent(gr, bounds, font);

			BitmapHelper.SetAlphaChanelValue(b, 150);

			return b;

		}

		internal void Draw(Graphics gr, Rectangle bounds, Font font, bool pressed, bool hot)

		{

			DrawBackground(gr, bounds, pressed, hot);

			DrawContent(gr, bounds, font);

		}

        private void DrawContent(Graphics gr, Rectangle bounds, Font font)

        {

            Rectangle innerBounds = new Rectangle(bounds.X + HeaderLeftMargin, bounds.Y,

                                   bounds.Width - HeaderLeftMargin - HeaderRightMargin,

                                   bounds.Height);

            if (SortOrder != SortOrder.None)

				innerBounds.Width -= (SortMarkSize.Width + SortOrderMarkMargin);

            Size maxTextSize = TextRenderer.MeasureText(gr, Header, font, innerBounds.Size, TextFormatFlags.NoPadding);

			Size textSize = TextRenderer.MeasureText(gr, Header, font, innerBounds.Size, _baseHeaderFlags);

            if (SortOrder != SortOrder.None)

            {

				int tw = Math.Min(textSize.Width, innerBounds.Size.Width);

                int x = 0;

                if (TextAlign == HorizontalAlignment.Left)

					x = innerBounds.X + tw + SortOrderMarkMargin;

                else if (TextAlign == HorizontalAlignment.Right)

					x = innerBounds.Right + SortOrderMarkMargin;

                else

					x = innerBounds.X + tw + (innerBounds.Width - tw) / 2 + SortOrderMarkMargin;

                DrawSortMark(gr, bounds, x);

			}

			if (textSize.Width < maxTextSize.Width)

				TextRenderer.DrawText(gr, Header, font, innerBounds, SystemColors.ControlText, _baseHeaderFlags | TextFormatFlags.Left);

            else

				TextRenderer.DrawText(gr, Header, font, innerBounds, SystemColors.ControlText, _headerFlags);

        }

		private void DrawSortMark(Graphics gr, Rectangle bounds, int x)

		{

			int y = bounds.Y + bounds.Height / 2 - 2;

			x = Math.Max(x, bounds.X + SortOrderMarkMargin);

            int w2 = SortMarkSize.Width / 2;

            if (SortOrder == SortOrder.Ascending)

            {

                Point[] points = new Point[] { new Point(x, y), new Point(x + SortMarkSize.Width, y), new Point(x + w2, y + SortMarkSize.Height) };

                gr.FillPolygon(SystemBrushes.ControlDark, points);

            }

            else if (SortOrder == SortOrder.Descending)

            {

                Point[] points = new Point[] { new Point(x - 1, y + SortMarkSize.Height), new Point(x + SortMarkSize.Width, y + SortMarkSize.Height), new Point(x + w2, y - 1) };

                gr.FillPolygon(SystemBrushes.ControlDark, points);

            }

		}

		internal static void DrawDropMark(Graphics gr, Rectangle rect)

		{

			gr.FillRectangle(SystemBrushes.HotTrack, rect.X-1, rect.Y, 2, rect.Height);

		}

		internal static void DrawBackground(Graphics gr, Rectangle bounds, bool pressed, bool hot)

		{

			if (Application.RenderWithVisualStyles)

			{

				CreateRenderers();

				if (pressed)

					_pressedRenderer.DrawBackground(gr, bounds);

				else if (hot)

					_hotRenderer.DrawBackground(gr, bounds);

				else

					_normalRenderer.DrawBackground(gr, bounds);

			}

			else

			{

				gr.FillRectangle(SystemBrushes.Control, bounds);

				Pen p1 = SystemPens.ControlLightLight;

				Pen p2 = SystemPens.ControlDark;

				Pen p3 = SystemPens.ControlDarkDark;

				if (pressed)

					gr.DrawRectangle(p2, bounds.X, bounds.Y, bounds.Width, bounds.Height);

				else

				{

					gr.DrawLine(p1, bounds.X, bounds.Y, bounds.Right, bounds.Y);

					gr.DrawLine(p3, bounds.X, bounds.Bottom, bounds.Right, bounds.Bottom);

					gr.DrawLine(p3, bounds.Right - 1, bounds.Y, bounds.Right - 1, bounds.Bottom - 1);

					gr.DrawLine(p1, bounds.Left, bounds.Y + 1, bounds.Left, bounds.Bottom - 2);

					gr.DrawLine(p2, bounds.Right - 2, bounds.Y + 1, bounds.Right - 2, bounds.Bottom - 2);

					gr.DrawLine(p2, bounds.X, bounds.Bottom - 1, bounds.Right - 2, bounds.Bottom - 1);

				}

			}

		}

		#endregion

		#region Events

		public event EventHandler HeaderChanged;

		private void OnHeaderChanged()

		{

			if (HeaderChanged != null)

				HeaderChanged(this, EventArgs.Empty);

		}

		public event EventHandler SortOrderChanged;

		private void OnSortOrderChanged()

		{

			if (SortOrderChanged != null)

				SortOrderChanged(this, EventArgs.Empty);

		}

		public event EventHandler IsVisibleChanged;

		private void OnIsVisibleChanged()

		{

			if (IsVisibleChanged != null)

				IsVisibleChanged(this, EventArgs.Empty);

		}

		public event EventHandler WidthChanged;

		private void OnWidthChanged()

		{

			if (WidthChanged != null)

				WidthChanged(this, EventArgs.Empty);

		}

		#endregion

	}

}