diff -r 3145aadca3d2 -r 0c551e8818e0 External/Aga.Controls/Tree/TreeColumn.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/External/Aga.Controls/Tree/TreeColumn.cs Sun May 27 15:16:19 2012 +0000 @@ -0,0 +1,371 @@ +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 + } +}