Merge pull request 'C2025-051 Missed one default when removing Check and Users Tabs from Admin Tool' (#604) from C2025-051 into Development

good for testing phase

PROMS/DotNetBar Source Code/AdvTree/AdvTree.resx

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<root>
+	<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+		<xsd:element name="root" msdata:IsDataSet="true">
+			<xsd:complexType>
+				<xsd:choice maxOccurs="unbounded">
+					<xsd:element name="data">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+								<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+							</xsd:sequence>
+							<xsd:attribute name="name" type="xsd:string" />
+							<xsd:attribute name="type" type="xsd:string" />
+							<xsd:attribute name="mimetype" type="xsd:string" />
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="resheader">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+							</xsd:sequence>
+							<xsd:attribute name="name" type="xsd:string" use="required" />
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:choice>
+			</xsd:complexType>
+		</xsd:element>
+	</xsd:schema>
+	<resheader name="ResMimeType">
+		<value>text/microsoft-resx</value>
+	</resheader>
+	<resheader name="Version">
+		<value>1.0.0.0</value>
+	</resheader>
+	<resheader name="Reader">
+		<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.3102.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+	<resheader name="Writer">
+		<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.3102.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+</root>

PROMS/DotNetBar Source Code/AdvTree/Cell.resx

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<root>
+	<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+		<xsd:element name="root" msdata:IsDataSet="true">
+			<xsd:complexType>
+				<xsd:choice maxOccurs="unbounded">
+					<xsd:element name="data">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+								<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+							</xsd:sequence>
+							<xsd:attribute name="name" type="xsd:string" />
+							<xsd:attribute name="type" type="xsd:string" />
+							<xsd:attribute name="mimetype" type="xsd:string" />
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="resheader">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+							</xsd:sequence>
+							<xsd:attribute name="name" type="xsd:string" use="required" />
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:choice>
+			</xsd:complexType>
+		</xsd:element>
+	</xsd:schema>
+	<resheader name="ResMimeType">
+		<value>text/microsoft-resx</value>
+	</resheader>
+	<resheader name="Version">
+		<value>1.0.0.0</value>
+	</resheader>
+	<resheader name="Reader">
+		<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+	<resheader name="Writer">
+		<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+</root>

PROMS/DotNetBar Source Code/AdvTree/CellCollection.cs

@@ -0,0 +1,211 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+
+namespace DevComponents.AdvTree
+{
+	///<summary>
+	/// A strongly-typed collection of <see cref="Cell"/> objects.
+	///</summary>
+	public class CellCollection:CollectionBase 
+	{
+		#region Private Variables
+		private Node m_ParentNode=null;
+		#endregion
+
+		#region Internal Implementation
+		/// <summary>Creates new instance of the class.</summary>
+		public CellCollection()
+		{
+		}
+		/// <summary>
+		/// Adds new object to the collection.
+		/// </summary>
+		/// <param name="cell">Object to add.</param>
+		/// <returns>Index of newly added object.</returns>
+		public int Add(Cell cell)
+		{
+			return List.Add(cell);
+		}
+		/// <summary>
+		/// Returns reference to the object in collection based on it's index.
+		/// </summary>
+		public Cell this[int index]
+		{
+			get {return (Cell)(List[index]);}
+			set {List[index] = value;}
+		}
+        /// <summary>
+        /// Returns reference to the object in collection based on it's name. Returns null/nothing if cell with given name is not found.
+        /// </summary>
+        public Cell this[string name]
+        {
+            get 
+            {
+                foreach (Cell item in List)
+                {
+                    if (item.Name == name) return item;
+                }
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the cell based on the column name. Node must be able to reach AdvTree control for this method to work.
+        /// </summary>
+        /// <param name="columnName">Column name.</param>
+        /// <returns>Cell object or null.</returns>
+        public Cell GetByColumnName(string columnName)
+        {
+            if (string.IsNullOrEmpty(columnName))
+                throw new ArgumentException("columnName argument must be non-empty non-null string with column name");
+            Node parentNode = this.ParentNode;
+            AdvTree tree = parentNode.TreeControl;
+            if (tree == null)
+                throw new NullReferenceException("AdvTree control cannot be reached. Node is not added to a tree.");
+            Cell cell = null;
+            if (parentNode.Parent != null && parentNode.Parent.NodesColumns.Count > 0)
+            {
+                int index= parentNode.Parent.NodesColumns.IndexOf(columnName);
+                if (index >= 0) cell = this[index];
+            }
+            else
+            {
+                int index = tree.Columns.IndexOf(columnName);
+                if (index >= 0) cell = this[index];
+            }
+            return cell;
+        }
+
+		/// <summary>
+		/// Inserts new object into the collection.
+		/// </summary>
+		/// <param name="index">Position of the object.</param>
+		/// <param name="value">Object to insert.</param>
+		public void Insert(int index, Cell value) 
+		{
+			List.Insert(index, value);
+		}
+
+		/// <summary>
+		/// Returns index of the object inside of the collection.
+		/// </summary>
+		/// <param name="value">Reference to the object.</param>
+		/// <returns>Index of the object.</returns>
+		public int IndexOf(Cell value) 
+		{
+			return List.IndexOf(value);
+		}
+
+		/// <summary>
+		/// Returns whether collection contains specified object.
+		/// </summary>
+		/// <param name="value">Object to look for.</param>
+		/// <returns>true if object is part of the collection, otherwise false.</returns>
+		public bool Contains(Cell value) 
+		{
+			return List.Contains(value);
+		}
+
+		/// <summary>
+		/// Removes specified object from the collection.
+		/// </summary>
+		/// <param name="value"></param>
+		public void Remove(Cell value) 
+		{
+			List.Remove(value);
+		}
+
+		protected override void OnRemoveComplete(int index,object value)
+		{
+			base.OnRemoveComplete(index,value);
+			Cell cell=value as Cell;
+			cell.SetParent(null);
+			if(m_ParentNode!=null)
+				m_ParentNode.OnCellRemoved(cell);
+		}
+		protected override void OnInsertComplete(int index,object value)
+		{
+			base.OnInsertComplete(index,value);
+			Cell cell=value as Cell;
+			if(cell.Parent!=null && cell.Parent!=m_ParentNode)
+				cell.Parent.Cells.Remove(cell);
+			cell.SetParent(m_ParentNode);
+			if(m_ParentNode!=null)
+				m_ParentNode.OnCellInserted(cell);
+		}
+        protected override void OnInsert(int index, object value)
+        {
+            if (m_ParentNode != null && m_ParentNode.Site != null && m_ParentNode.Site.DesignMode && this.List.Count > 0)
+            {
+                Cell cell = value as Cell;
+                if (cell.Site == null && this.List.Contains(cell)) this.List.Remove(cell);
+            }
+
+            base.OnInsert(index, value);
+        }
+
+		/// <summary>
+		/// Copies collection into the specified array.
+		/// </summary>
+		/// <param name="array">Array to copy collection to.</param>
+		/// <param name="index">Starting index.</param>
+		public void CopyTo(Cell[] array, int index) 
+		{
+			List.CopyTo(array, index);
+		}
+
+		/// <summary>
+		/// Copies contained items to the Cell array.
+		/// </summary>
+		/// <param name="array">Array to copy to.</param>
+		internal void CopyTo(Cell[] array)
+		{
+			List.CopyTo(array,0);
+		}
+
+        private Cell _RootCell = null;
+		protected override void OnClear()
+		{
+            if (m_ParentNode != null && m_ParentNode.Site != null && m_ParentNode.Site.DesignMode && this.List.Count>0)
+            {
+                if (this[0].Site == null)
+                    _RootCell = this[0];
+            }
+			base.OnClear();
+		}
+
+        protected override void OnClearComplete()
+        {
+            base.OnClearComplete();
+            if (_RootCell != null)
+            {
+                this.Add(_RootCell);
+                _RootCell = null;
+            }
+        }
+
+        protected override void OnSet(int index, object oldValue, object newValue)
+        {
+            base.OnSet(index, oldValue, newValue);
+        }
+
+		/// <summary>
+		/// Gets or sets the node this collection is associated with.
+		/// </summary>
+		[Browsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public Node ParentNode
+		{
+			get {return m_ParentNode;}
+		}
+		/// <summary>
+		/// Sets the node collection belongs to.
+		/// </summary>
+		/// <param name="parent">Cell that is parent of this collection.</param>
+		internal void SetParentNode(Node parent)
+		{
+			m_ParentNode=parent;
+		}
+		#endregion
+	}
+}

PROMS/DotNetBar Source Code/AdvTree/CellEditEventArgs.cs

@@ -0,0 +1,105 @@
+using System;
+
+namespace DevComponents.AdvTree
+{
+	/// <summary>
+	/// Represents event arguments for cell editing events.
+	/// </summary>
+	public class CellEditEventArgs : EventArgs
+	{
+		/// <summary>
+		/// Indicates the action that caused the event.
+		/// </summary>
+		public eTreeAction Action=eTreeAction.Code;
+		/// <summary>
+		/// Indicates the cell that is affected.
+		/// </summary>
+		public DevComponents.AdvTree.Cell Cell=null;
+		/// <summary>
+		/// Indicates new text that will be assigned to the cell if one is appropriate for given event.
+		/// </summary>
+		public string NewText="";
+
+        private ICellEditControl _Editor = null;
+        /// <summary>
+        /// Gets reference to the cell editor control.
+        /// </summary>
+        public ICellEditControl Editor
+        {
+            get
+            {
+                return _Editor;
+            }
+        }
+
+		/// <summary>
+		/// Indicates whether the current action is cancelled. For BeforeCellEdit event setting this
+		/// property to true will cancel the editing. For AfterCellEdit event setting this property to
+		/// true will cancel any changes made to the text and edits will not be accepted. For CellEditEnding
+		/// event setting this property to true will keep the cell in edit mode.
+		/// </summary>
+		public bool Cancel=false;
+
+        /// <summary>
+        /// Indicates whether editing operation was canceled by the end user, usually by pressing ESCAPE key.
+        /// </summary>
+        public readonly bool IsUserCanceled;
+
+		/// <summary>
+		/// Initializes new instance of CellEditEventArgs class.
+		/// </summary>
+		/// <param name="cell">Reference to Cell this event is raised for.</param>
+		/// <param name="action">Indicates the action that caused the event.</param>
+		/// <param name="newText">Indicates new text of the cell if it applies to given event.</param>
+		public CellEditEventArgs(Cell cell, eTreeAction action, string newText)
+		{
+			this.Action=action;
+			this.Cell=cell;
+			this.NewText=newText;
+            this.IsUserCanceled = false;
+		}
+        /// <summary>
+        /// Initializes new instance of CellEditEventArgs class.
+        /// </summary>
+        /// <param name="cell">Reference to Cell this event is raised for.</param>
+        /// <param name="action">Indicates the action that caused the event.</param>
+        /// <param name="newText">Indicates new text of the cell if it applies to given event.</param>
+        public CellEditEventArgs(Cell cell, eTreeAction action, string newText, ICellEditControl editor)
+        {
+            this.Action = action;
+            this.Cell = cell;
+            this.NewText = newText;
+            this.IsUserCanceled = false;
+            _Editor = editor;
+        }
+        /// <summary>
+        /// Initializes new instance of CellEditEventArgs class.
+        /// </summary>
+        /// <param name="cell">Reference to Cell this event is raised for.</param>
+        /// <param name="action">Indicates the action that caused the event.</param>
+        /// <param name="newText">Indicates new text of the cell if it applies to given event.</param>
+        /// <param name="isUserCanceled">Indicates whether action is canceled by the end user.</param>
+        public CellEditEventArgs(Cell cell, eTreeAction action, string newText, bool isUserCanceled)
+        {
+            this.Action = action;
+            this.Cell = cell;
+            this.NewText = newText;
+            this.IsUserCanceled = isUserCanceled;
+        }
+        /// <summary>
+        /// Initializes new instance of CellEditEventArgs class.
+        /// </summary>
+        /// <param name="cell">Reference to Cell this event is raised for.</param>
+        /// <param name="action">Indicates the action that caused the event.</param>
+        /// <param name="newText">Indicates new text of the cell if it applies to given event.</param>
+        /// <param name="isUserCanceled">Indicates whether action is canceled by the end user.</param>
+        public CellEditEventArgs(Cell cell, eTreeAction action, string newText, bool isUserCanceled, ICellEditControl editor)
+        {
+            this.Action = action;
+            this.Cell = cell;
+            this.NewText = newText;
+            this.IsUserCanceled = isUserCanceled;
+            _Editor = editor;
+        }
+	}
+}

PROMS/DotNetBar Source Code/AdvTree/CellImages.cs

@@ -0,0 +1,570 @@
+using System;
+using System.Drawing;
+using System.ComponentModel;
+using DevComponents.DotNetBar;
+
+namespace DevComponents.AdvTree
+{
+	/// <summary>
+	/// Represents class that holds images for a cell.
+	/// </summary>
+	/// <remarks>
+	/// If you plan to use alpha-blended images we recommend using PNG-24 format which
+	/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+	/// alpha-blending when used through Image class.
+	/// </remarks>
+	[ToolboxItem(false), TypeConverter(typeof(System.ComponentModel.ExpandableObjectConverter))]
+	public class CellImages
+	{
+		// Image variables
+		private System.Drawing.Image m_Image=null;
+        private System.Drawing.Image m_DisabledImageGenerated = null;
+		private int m_ImageIndex=-1; // Image index if image from ImageList is used
+		private System.Drawing.Image m_ImageMouseOver=null;
+		private int m_ImageMouseOverIndex=-1; // Image index if image from ImageList is used
+		private System.Drawing.Image m_ImageDisabled=null;
+//		private bool m_DisabledImageCustom=false;
+		private int m_ImageDisabledIndex=-1; // Image index if image from ImageList is used
+		private System.Drawing.Image m_ImageExpanded=null;
+		private int m_ImageExpandedIndex=-1;
+		private Cell m_ParentCell=null;
+		private Size m_LargestImageSize=Size.Empty;
+
+		/// <summary>
+		/// Initializes new instance of CellImages class.
+		/// </summary>
+		/// <param name="parentCell">Reference to parent cell.</param>
+		public CellImages(Cell parentCell)
+		{
+			m_ParentCell=parentCell;
+		}
+
+		#region Properties
+
+        internal System.Drawing.Image DisabledImageGenerated
+        {
+            get { return m_DisabledImageGenerated; }
+            set
+            {
+                m_DisabledImageGenerated = value;
+            }
+        }
+
+		/// <summary>
+		/// Gets or sets default cell image. Setting this property to valid image will
+		/// override any setting of ImageIndex property.
+		/// </summary>
+		/// <remarks>
+		/// 	<para>The image set through this property will be serialized with the cell. If you
+		///     plan to use ImageList then use <see cref="ImageIndex">ImageIndex</see>
+		///     property.</para>
+		/// 	<para>
+		/// 		<para>If you plan to use alpha-blended images we recommend using PNG-24 format
+		///         which supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1
+		///         do not support alpha-blending when used through Image class.</para>
+		/// 	</para>
+		/// </remarks>
+		/// <value>Image object or <strong>null (Nothing)</strong> if no image is assigned.</value>
+		[Browsable(true),DefaultValue(null),Category("Images"),Description("Indicates default cell image"), DevCoSerialize()]
+		public System.Drawing.Image Image
+		{
+			get {return m_Image;}
+			set
+			{
+				ChangeImage(ref m_Image, value);
+			}
+		}
+
+		/// <summary>
+		/// Resets Image property to it's default value (null, VB nothing).
+		/// </summary>
+		public void ResetImage()
+		{
+			TypeDescriptor.GetProperties(this)["Image"].SetValue(this, null);
+		}
+
+		/// <summary>
+		/// Gets or sets the image that is displayed when mouse is over the cell. Setting
+		/// this property to valid image will override any setting of ImageMouseOverIndex
+		/// property.
+		/// </summary>
+		/// <remarks>
+		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
+		/// supports alpha-blending. As of this writting .NET Framework 1.0 and 1.1 do not support
+		/// alpha-blending when used through Image class.
+		/// </remarks>
+		[Browsable(true),DefaultValue(null),Category("Images"),Description("Indicates cell image when mouse is over the cell"), DevCoSerialize()]
+		public System.Drawing.Image ImageMouseOver
+		{
+			get {return m_ImageMouseOver;}
+			set
+			{
+                ChangeImage(ref m_ImageMouseOver, value);
+			}
+		}
+
+		/// <summary>
+		/// Resets ImageMouseOver to it's default value (null, VB nothing).
+		/// </summary>
+		public void ResetImageMouseOver()
+		{
+			TypeDescriptor.GetProperties(this)["ImageMouseOver"].SetValue(this, null);
+		}
+
+        /// <summary>
+        /// Gets or sets the image that is displayed when cell is disabled. If not assigned
+        /// disabled image is created from default cell image. Setting this property to valid image
+        /// will override any setting of ImageDisabledIndex property.
+        /// </summary>
+        /// <remarks>
+        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
+        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+        /// alpha-blending when used through Image class.
+        /// </remarks>
+        [Browsable(true), DefaultValue(null), Category("Images"), Description("Indicates disabled cell image")]
+        public System.Drawing.Image ImageDisabled
+        {
+            get { return m_ImageDisabled; }
+            set
+            {
+                ChangeImage(ref m_ImageDisabled, value);
+            }
+        }
+
+        /// <summary>
+        /// Resets ImageDisabled to it's default value (null, VB nothing).
+        /// </summary>
+        public void ResetImageDisabled()
+        {
+            this.ImageDisabled = null;
+        }
+
+		/// <summary>
+		/// Gets or sets image that is displayed when Node that this cell belongs to is
+		/// expanded. Setting this property to valid image will override any setting of
+		/// ImageExpandedIndex property.
+		/// </summary>
+		/// <remarks>
+		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
+		/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+		/// alpha-blending when used through Image class.
+		/// </remarks>
+        [Browsable(true),DefaultValue(null),Category("Images"),Description("Indicates cell image when node associtaed with this cell is expanded"), DevCoSerialize()]
+		public System.Drawing.Image ImageExpanded
+		{
+			get {return m_ImageExpanded;}
+			set
+			{
+                ChangeImage(ref m_ImageExpanded, value);
+			}
+		}
+
+		/// <summary>
+		/// Resets ImageExpanded to it's default value (null, VB nothing).
+		/// </summary>
+		public void ResetImageExpanded()
+		{
+			TypeDescriptor.GetProperties(this)["ImageExpanded"].SetValue(this, null);
+		}
+
+		/// <summary>
+		/// Gets or sets the Index of default cell image from ImageList specified on AdvTree
+		/// control.
+		/// </summary>
+		/// <remarks>
+		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
+		/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+		/// alpha-blending when used through Image class.
+		/// </remarks>
+		[Browsable(true),DefaultValue(-1),Category("ImageList Images"),Description("Indicates default cell image"), DevCoSerialize()]
+		public int ImageIndex
+		{
+			get {return m_ImageIndex;}
+			set
+			{
+				m_ImageIndex=value;
+				this.OnImageChanged();
+			}
+		}
+
+        private string _ImageKey = "";
+        /// <summary>
+        /// Gets or sets the key of the default cell image from ImageList specified on AdvTree control.
+        /// </summary>
+        [DefaultValue(""), Category("ImageList Images"), Description("Indicates the default cell image key"), DevCoSerialize()]
+        public string ImageKey
+        {
+            get { return _ImageKey; }
+            set
+            {
+                _ImageKey = value;
+                this.OnImageChanged();
+            }
+        }
+        
+
+		/// <summary>
+		/// Property Editor support for ImageIndex selection
+		/// </summary>
+		[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+		public System.Windows.Forms.ImageList ImageList
+		{
+			get
+			{
+				if(this.Parent!=null)
+				{
+					AdvTree tree=this.Parent.TreeControl;
+					if(tree!=null)
+					{
+						return tree.ImageList;
+					}
+				}
+
+				return null;
+			}
+		}
+
+		/// <remarks>
+		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
+		/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+		/// alpha-blending when used through Image class.
+		/// </remarks>
+		/// <summary>
+		/// Gets or sets the Index of cell image when mouse is over the cell from ImageList
+		/// specified on AdvTree control.
+		/// </summary>
+		[Browsable(true),DefaultValue(-1),Category("ImageList Images"),Description("Indicates cell image when mouse is over the cell"), DevCoSerialize()]
+		public int ImageMouseOverIndex
+		{
+			get {return m_ImageMouseOverIndex;}
+			set
+			{
+				m_ImageMouseOverIndex=value;
+				this.OnImageChanged();
+			}
+		}
+
+        private string _ImageMouseOverKey = "";
+        /// <remarks>
+        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
+        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+        /// alpha-blending when used through Image class.
+        /// </remarks>
+        /// <summary>
+        /// Gets or sets the key of cell image when mouse is over the cell from ImageList
+        /// specified on AdvTree control.
+        /// </summary>
+        [Browsable(true), DefaultValue(""), Category("ImageList Images"), Description("Indicates cell image when mouse is over the cell"), DevCoSerialize()]
+        public string ImageMouseOverKey
+        {
+            get { return _ImageMouseOverKey; }
+            set
+            {
+                _ImageMouseOverKey = value;
+                this.OnImageChanged();
+            }
+        }
+
+        /// <remarks>
+        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
+        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+        /// alpha-blending when used through Image class.
+        /// </remarks>
+        /// <summary>
+        /// Gets or sets the Index of disabled cell image from ImageList specified on AdvTree
+        /// control.
+        /// </summary>
+        [Browsable(true), DefaultValue(-1), Category("ImageList Images"), Description("Indicates disabled cell image")]
+        public int ImageDisabledIndex
+        {
+            get { return m_ImageDisabledIndex; }
+            set
+            {
+                m_ImageDisabledIndex = value;
+                this.OnImageChanged();
+            }
+        }
+
+        private string _ImageDisabledKey = "";
+        /// <remarks>
+        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
+        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+        /// alpha-blending when used through Image class.
+        /// </remarks>
+        /// <summary>
+        /// Gets or sets the key of disabled cell image from ImageList specified on AdvTree
+        /// control.
+        /// </summary>
+        [Browsable(true), DefaultValue(""), Category("ImageList Images"), Description("Indicates disabled cell image")]
+        public string ImageDisabledKey
+        {
+            get { return _ImageDisabledKey; }
+            set
+            {
+                _ImageDisabledKey = value;
+                this.OnImageChanged();
+            }
+        }
+
+		/// <remarks>
+		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
+		/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+		/// alpha-blending when used through Image class.
+		/// </remarks>
+		/// <summary>
+		/// Gets or sets the Index of cell image from ImageList specified on AdvTree control
+		/// that is used when Node associated with this cell is expanded
+		/// </summary>
+		[Browsable(true),DefaultValue(-1),Category("ImageList Images"),Description("Indicates expanded cell image"), DevCoSerialize()]
+		public int ImageExpandedIndex
+		{
+			get {return m_ImageExpandedIndex;}
+			set
+			{
+				m_ImageExpandedIndex=value;
+				this.OnImageChanged();
+			}
+		}
+
+        private string _ImageExpandedKey = "";
+        /// <remarks>
+        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
+        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
+        /// alpha-blending when used through Image class.
+        /// </remarks>
+        /// <summary>
+        /// Gets or sets the key of cell image from ImageList specified on AdvTree control
+        /// that is used when Node associated with this cell is expanded
+        /// </summary>
+        [Browsable(true), DefaultValue(""), Category("ImageList Images"), Description("Indicates expanded cell image"), DevCoSerialize()]
+        public string ImageExpandedKey
+        {
+            get { return _ImageExpandedKey; }
+            set
+            {
+                _ImageExpandedKey = value;
+                this.OnImageChanged();
+            }
+        }
+
+		/// <summary>
+		/// Gets or sets the parent node of the cell.
+		/// </summary>
+		[Browsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public Cell Parent
+		{
+			get {return m_ParentCell;}
+			set {m_ParentCell=value;}
+		}
+
+		/// <summary>
+		/// Gets whether CellImages object should be serialized or not. If object has all
+		/// default values then this property will return <strong>false</strong>.
+		/// </summary>
+		internal bool ShouldSerialize
+		{
+			get
+			{
+				if(m_Image==null && m_ImageDisabled==null && m_ImageDisabledIndex==-1 &&
+					m_ImageExpanded==null && m_ImageExpandedIndex==-1 && m_ImageIndex==-1 &&
+					m_ImageMouseOver==null && m_ImageMouseOverIndex==-1)
+					return false;
+				return true;
+			}
+		}
+
+		/// <summary>
+		/// Returns largest image size in this set of images.
+		/// </summary>
+		internal Size LargestImageSize
+		{
+			get
+			{
+				return m_LargestImageSize;
+			}
+		}
+
+		#endregion
+
+		#region Methods
+
+		/// <summary>Makes a copy of a CellImages object.</summary>
+		public virtual CellImages Copy()
+		{
+			CellImages ci=new CellImages(null);
+			ci.Image=this.Image;
+//			ci.ImageDisabled=this.ImageDisabled;
+//			ci.ImageDisabledIndex=this.ImageDisabledIndex;
+		    ci.ImageExpanded = this.ImageExpanded == null ? null : (Image) this.ImageExpanded.Clone();
+			ci.ImageExpandedIndex=this.ImageExpandedIndex;
+			ci.ImageIndex=this.ImageIndex;
+			ci.ImageMouseOver=this.ImageMouseOver == null? null : (Image)this.ImageMouseOver.Clone();
+			ci.ImageMouseOverIndex=this.ImageMouseOverIndex;
+            ci.ImageDisabledKey = this.ImageDisabledKey;
+            ci.ImageExpandedKey = this.ImageExpandedKey;
+            ci.ImageKey = this.ImageKey;
+            ci.ImageMouseOverKey = this.ImageMouseOverKey;
+			return ci;
+		}
+
+		#endregion
+
+		#region Internals
+        /// <summary>
+        /// Changes the image and invokes largest image size calculation if the
+        /// image size truly changed.
+        /// </summary>
+        /// <param name="currentImage"></param>
+        /// <param name="newImage"></param>
+        private void ChangeImage(ref System.Drawing.Image currentImage, System.Drawing.Image newImage)
+        {
+            // Early out if no real change
+            if (currentImage == newImage)
+                return;
+
+            // Hold onto previous image
+            System.Drawing.Image previousImage = currentImage;
+
+            // Assign new image
+            currentImage = newImage;
+
+            // If either current or previous is null, or the sizes don't match,
+            // we need to resize ourselves and the parent.
+            if (previousImage == null || currentImage == null || GetImageSize(previousImage) != GetImageSize(currentImage))
+            {
+                RefreshLargestImageSize();
+
+                if (this.Parent != null)
+                    this.Parent.OnImageChanged();
+            }
+
+            // Dispose the generated disabled image, if applicable.
+            DisposeGeneratedDisabledImage();
+        }
+        private Size GetImageSize(Image image)
+        {
+            try
+            {
+                return image.Size;
+            }
+            catch
+            {
+                return Size.Empty;
+            }
+        }
+
+        private void OnImageChanged()
+        {
+            RefreshLargestImageSize();
+            if (this.Parent != null)
+                this.Parent.OnImageChanged();
+            DisposeGeneratedDisabledImage();
+        }
+
+        public void Dispose()
+        {
+            DisposeGeneratedDisabledImage();
+            if (BarUtilities.DisposeItemImages || _AutoDispose)
+            {
+                BarUtilities.DisposeImage(ref m_Image);
+                BarUtilities.DisposeImage(ref m_ImageDisabled);
+                BarUtilities.DisposeImage(ref m_ImageExpanded);
+                BarUtilities.DisposeImage(ref m_ImageMouseOver);
+            }
+        }
+
+        internal void DisposeGeneratedDisabledImage()
+        {
+            if (m_DisabledImageGenerated != null)
+            {
+                m_DisabledImageGenerated.Dispose();
+                m_DisabledImageGenerated = null;
+            }
+        }
+
+		internal void RefreshLargestImageSize()
+		{
+			m_LargestImageSize=Size.Empty;
+			AdjustSize(m_Image,ref m_LargestImageSize);
+			AdjustSize(m_ImageDisabled,ref m_LargestImageSize);
+			AdjustSize(m_ImageExpanded,ref m_LargestImageSize);
+			AdjustSize(m_ImageMouseOver,ref m_LargestImageSize);
+            
+			AdjustSize(GetImageByIndex(m_ImageIndex),ref m_LargestImageSize);
+			AdjustSize(GetImageByIndex(m_ImageDisabledIndex),ref m_LargestImageSize);
+			AdjustSize(GetImageByIndex(m_ImageExpandedIndex),ref m_LargestImageSize);
+			AdjustSize(GetImageByIndex(m_ImageMouseOverIndex),ref m_LargestImageSize);
+
+            AdjustSize(GetImageByKey(_ImageKey), ref m_LargestImageSize);
+            AdjustSize(GetImageByKey(_ImageDisabledKey), ref m_LargestImageSize);
+            AdjustSize(GetImageByKey(_ImageExpandedKey), ref m_LargestImageSize);
+            AdjustSize(GetImageByKey(_ImageMouseOverKey), ref m_LargestImageSize);
+		}
+		private void AdjustSize(System.Drawing.Image image, ref Size size)
+		{
+			if(image!=null)
+			{
+				if(image.Width>size.Width)
+					size.Width=image.Width;
+				if(image.Height>size.Height)
+					size.Height=image.Height;
+			}
+		}
+		/// <summary>
+		/// Returns image from image list based on the image index.
+		/// </summary>
+		/// <param name="imageIndex">Index of the image to return.</param>
+		/// <returns>Image object from image list.</returns>
+		internal System.Drawing.Image GetImageByIndex(int imageIndex)
+		{
+            if (imageIndex >= 0 && this.Parent != null && this.Parent.TreeControl != null && this.Parent.TreeControl.ImageList != null && this.Parent.TreeControl.ImageList.Images.Count > 0)
+            {
+                try
+                {
+                    return this.Parent.TreeControl.ImageList.Images[imageIndex];
+                }
+                catch
+                {
+                    return null;
+                }
+                
+            }
+            else
+                return null;
+		}
+
+        /// <summary>
+        /// Returns image from image list based on the image key.
+        /// </summary>
+        /// <param name="key">Key of the image to return.</param>
+        /// <returns>Image object from image list.</returns>
+        internal System.Drawing.Image GetImageByKey(string key)
+        {
+            if (string.IsNullOrEmpty(key)) return null;
+
+            Cell parent = this.Parent;
+            if (parent == null) return null;
+
+            AdvTree tree = parent.TreeControl;
+            if (tree == null || tree.ImageList == null || !tree.ImageList.Images.ContainsKey(key)) return null;
+
+            return tree.ImageList.Images[key];
+        }
+
+        private bool _AutoDispose = false;
+        /// <summary>
+        /// Indicates whether assigned images are automatically disposed when the cell and node are disposed. Default value is false.
+        /// </summary>
+        [Browsable(false), DefaultValue(false)]
+        public bool AutoDispose
+        {
+            get { return _AutoDispose; }
+            set
+            {
+                _AutoDispose = value;
+            }
+        }
+        
+		#endregion
+	}
+}

PROMS/DotNetBar Source Code/AdvTree/ColumnHeaderCollection.cs

@@ -0,0 +1,583 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Collections.Generic;
+using System.Windows.Forms;
+
+namespace DevComponents.AdvTree
+{
+    /// <summary>
+    /// Represents collection for ColumnHeader objects.
+    /// </summary>
+    public class ColumnHeaderCollection : CollectionBase
+    {
+        #region Private Variables
+        private Node _ParentNode = null;
+        private AdvTree _Parent = null;
+        #endregion
+
+        #region Internal Implementation
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        public ColumnHeaderCollection()
+        {
+        }
+        /// <summary>
+        /// Gets or sets the node this collection is associated with.
+        /// </summary>
+        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public Node ParentNode
+        {
+            get { return _ParentNode; }
+        }
+        /// <summary>
+        /// Sets the node collection belongs to.
+        /// </summary>
+        /// <param name="parent">ColumnHeader that is parent of this collection.</param>
+        internal void SetParentNode(Node parent)
+        {
+            _ParentNode = parent;
+        }
+
+        internal AdvTree Parent
+        {
+            get { return _Parent; }
+            set { _Parent = value; }
+        }
+
+        /// <summary>
+        /// Adds new object to the collection.
+        /// </summary>
+        /// <param name="ch">Object to add.</param>
+        /// <returns>Index of newly added object.</returns>
+        public int Add(ColumnHeader ch)
+        {
+            return List.Add(ch);
+        }
+        /// <summary>
+        /// Returns reference to the object in collection based on it's index.
+        /// </summary>
+        public ColumnHeader this[int index]
+        {
+            get { return (ColumnHeader)(List[index]); }
+            set { List[index] = value; }
+        }
+
+        /// <summary>
+        /// Returns reference to the object in collection based on it's name.
+        /// </summary>
+        public ColumnHeader this[string name]
+        {
+            get 
+            {
+                int index = IndexOf(name);
+                if (index == -1) return null;
+                return this[index];
+            }
+            set { this[IndexOf(name)] = value; }
+        }
+
+        /// <summary>
+        /// Inserts new object into the collection.
+        /// </summary>
+        /// <param name="index">Position of the object.</param>
+        /// <param name="value">Object to insert.</param>
+        public void Insert(int index, ColumnHeader value)
+        {
+            List.Insert(index, value);
+        }
+
+        /// <summary>
+        /// Returns index of the object inside of the collection.
+        /// </summary>
+        /// <param name="value">Reference to the object.</param>
+        /// <returns>Index of the object.</returns>
+        public int IndexOf(ColumnHeader value)
+        {
+            return List.IndexOf(value);
+        }
+
+        /// <summary>
+        /// Returns index of the object inside of the collection.
+        /// </summary>
+        /// <param name="name">Name of column to return index for.</param>
+        /// <returns>Index of the column or -1 if column not found.</returns>
+        public int IndexOf(string name)
+        {
+            for (int i = 0; i < this.List.Count; i++)
+            {
+                if (this[i].Name == name) return i;
+            }
+            return -1;
+        }
+
+        /// <summary>
+        /// Returns index of the object inside of the collection based on column DataFieldName.
+        /// </summary>
+        /// <param name="dataFieldName">DataFieldName of column to return index for.</param>
+        /// <returns>Index of the column or -1 if column not found.</returns>
+        public int IndexOfDataField(string dataFieldName)
+        {
+            dataFieldName = dataFieldName.ToLower();
+            for (int i = 0; i < this.List.Count; i++)
+            {
+                if (this[i].DataFieldName.ToLower() == dataFieldName) return i;
+            }
+            return -1;
+        }
+
+        /// <summary>
+        /// Returns index of the object inside of the collection based on column DataFieldName.
+        /// </summary>
+        /// <param name="fieldName">DataFieldName of column to return index for.</param>
+        /// <returns>Index of the column or -1 if column not found.</returns>
+        internal int IndexOfField(string fieldName)
+        {
+            fieldName = fieldName.ToLower();
+            for (int i = 0; i < this.List.Count; i++)
+            {
+                ColumnHeader header = this[i];
+                if (header.Tag is BindingMemberInfo && ((BindingMemberInfo)header.Tag).BindingField.ToLower() == fieldName)
+                    return i;
+                if (header.DataFieldName.ToLower() == fieldName) return i;
+                if (header.Name == fieldName) return i;
+            }
+            return -1;
+        }
+
+        /// <summary>
+        /// Returns whether collection contains specified object.
+        /// </summary>
+        /// <param name="value">Object to look for.</param>
+        /// <returns>true if object is part of the collection, otherwise false.</returns>
+        public bool Contains(ColumnHeader value)
+        {
+            return List.Contains(value);
+        }
+
+        protected override void OnSet(int index, object oldValue, object newValue)
+        {
+            if (oldValue is ColumnHeader)
+            {
+                ColumnHeader header = (ColumnHeader)oldValue;
+                if (header.SortDirection != eSortDirection.None) IsSorted = false;
+            }
+            if (newValue is ColumnHeader)
+            {
+                ColumnHeader header = (ColumnHeader)newValue;
+                if (header.SortDirection != eSortDirection.None) IsSorted = true;
+            }
+            base.OnSet(index, oldValue, newValue);
+        }
+
+        /// <summary>
+        /// Removes specified object from the collection.
+        /// </summary>
+        /// <param name="value"></param>
+        public void Remove(ColumnHeader value)
+        {
+            List.Remove(value);
+        }
+
+        protected override void OnRemoveComplete(int index, object value)
+        {
+            if (value is ColumnHeader)
+            {
+                ColumnHeader header = (ColumnHeader)value;
+                if (header.SortDirection != eSortDirection.None) IsSorted = false;
+                header.HeaderSizeChanged -= new EventHandler(this.HeaderSizeChanged);
+                header.SortCells -= new SortCellsEventHandler(SortCellsHandler);
+                header.MouseDown -= new System.Windows.Forms.MouseEventHandler(ColumnMouseDown);
+                header.MouseUp -= new System.Windows.Forms.MouseEventHandler(ColumnMouseUp);
+                header.Parent = null;
+            }
+            InvalidateDisplayIndexes();
+            UpdateTreeLayout();
+            base.OnRemoveComplete(index, value);
+        }
+        protected override void OnInsertComplete(int index, object value)
+        {
+            if (value is ColumnHeader)
+            {
+                ((ColumnHeader)value).HeaderSizeChanged += new EventHandler(this.HeaderSizeChanged);
+                ((ColumnHeader)value).SortCells += new SortCellsEventHandler(SortCellsHandler);
+                ((ColumnHeader)value).MouseDown += new System.Windows.Forms.MouseEventHandler(ColumnMouseDown);
+                ((ColumnHeader)value).MouseUp += new System.Windows.Forms.MouseEventHandler(ColumnMouseUp);
+                ((ColumnHeader)value).Parent = this;
+            }
+            InvalidateDisplayIndexes();
+            UpdateTreeLayout();
+            base.OnInsertComplete(index, value);
+        }
+
+        [System.Reflection.Obfuscation(Exclude = true)]
+        private void ColumnMouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
+        {
+            AdvTree tree = GetTree();
+            if (tree != null)
+                tree.InvokeColumnHeaderMouseUp(sender, e);
+        }
+        [System.Reflection.Obfuscation(Exclude = true)]
+        private void ColumnMouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
+        {
+            AdvTree tree = GetTree();
+            if (tree != null)
+                tree.InvokeColumnHeaderMouseDown(sender, e);
+        }
+
+        private AdvTree GetTree()
+        {
+            AdvTree tree = _Parent;
+            if (tree == null && _ParentNode != null)
+                tree = _ParentNode.TreeControl;
+            return tree;
+        }
+
+        /// <summary>
+        /// Occurs before the cells are sorted.
+        /// </summary>
+        [Description("Occurs before the cells are sorted.")]
+        public event SortCellsEventHandler SortCells;
+        protected virtual void OnSortCells(SortEventArgs e)
+        {
+            if (SortCells != null)
+                SortCells(this, e);
+        }
+
+        private void SortCellsHandler(object sender, SortEventArgs e)
+        {
+            ColumnHeader ch = (ColumnHeader)sender;
+            int i = this.IndexOf(ch);
+
+            IComparer comparer = null;
+            if (e.ReverseSort)
+            {
+                if (ch.SortComparerReverse != null)
+                    comparer = ch.SortComparerReverse;
+                else
+                    comparer = new NodeComparerReverse(i);
+            }
+            else
+            {
+                if (ch.SortComparer != null)
+                    comparer = ch.SortComparer;
+                else
+                    comparer = new NodeComparer(i);
+            }
+
+            if (e.Comparer == null)
+                e.Comparer = comparer;
+            else
+                comparer = e.Comparer;
+            OnSortCells(e);
+            if (e.Cancel)
+                return;
+
+            if (_Parent != null)
+            {
+                _Parent.Nodes.Sort(comparer);
+            }
+            else if (_ParentNode != null)
+                _ParentNode.Nodes.Sort(comparer);
+        }
+        private bool _UpdatingSortDirection = false;
+        /// <summary>
+        /// Called when SortDirection property on column header is set to value other than None.
+        /// </summary>
+        /// <param name="header">Ref to column header</param>
+        internal void SortDirectionUpdated(ColumnHeader header)
+        {
+            if (_UpdatingSortDirection) return;
+
+            _UpdatingSortDirection = true;
+            try
+            {
+                if (header.SortDirection == eSortDirection.None)
+                {
+                    IsSorted = false;
+                    return;
+                }
+                
+                IsSorted = true;
+
+                foreach (ColumnHeader col in this.List)
+                {
+                    if (col != header && col.SortDirection != eSortDirection.None)
+                        col.SortDirection = eSortDirection.None;
+                }
+            }
+            finally
+            {
+                _UpdatingSortDirection = false;
+            }
+        }
+
+        private bool _IsSorted;
+        /// <summary>
+        /// Gets whether a column that is part of this collection has SortDirection set.
+        /// </summary>
+        public bool IsSorted
+        {
+            get { return _IsSorted; }
+            internal set { _IsSorted = value; }
+        }
+
+        internal void UpdateSort()
+        {
+            if (!_IsSorted) return;
+            foreach (ColumnHeader header in this.List)
+            {
+                if (header.SortDirection != eSortDirection.None)
+                {
+                    header.Sort(header.SortDirection == eSortDirection.Descending);
+                    break;
+                }
+            }
+        }
+
+        private void UpdateTreeLayout()
+        {
+            if (_Parent != null)
+            {
+                _Parent.InvalidateNodesSize();
+                _Parent.Invalidate();
+                if (_Parent.Nodes.Count == 0)
+                    _Parent.RecalcLayout();
+                else
+                    _Parent.SetPendingLayout();
+            }
+            else if (_ParentNode != null)
+            {
+                AdvTree tree = _ParentNode.TreeControl;
+                if (tree != null)
+                {
+                    tree.InvalidateNodeSize(_ParentNode);
+                    tree.Invalidate();
+                }
+            }
+        }
+
+        private void HeaderSizeChanged(object sender, EventArgs e)
+        {
+            UpdateTreeLayout();
+        }
+
+        /// <summary>
+        /// Copies collection into the specified array.
+        /// </summary>
+        /// <param name="array">Array to copy collection to.</param>
+        /// <param name="index">Starting index.</param>
+        public void CopyTo(ColumnHeader[] array, int index)
+        {
+            List.CopyTo(array, index);
+        }
+
+        /// <summary>
+        /// Copies contained items to the ColumnHeader array.
+        /// </summary>
+        /// <param name="array">Array to copy to.</param>
+        internal void CopyTo(ColumnHeader[] array)
+        {
+            List.CopyTo(array, 0);
+        }
+
+        protected override void OnClear()
+        {
+            foreach (ColumnHeader item in this)
+            {
+                item.HeaderSizeChanged -= new EventHandler(this.HeaderSizeChanged);
+                item.SortCells -= new SortCellsEventHandler(SortCellsHandler);
+                item.MouseDown -= new System.Windows.Forms.MouseEventHandler(ColumnMouseDown);
+                item.MouseUp -= new System.Windows.Forms.MouseEventHandler(ColumnMouseUp);
+                item.Parent = null;
+            }
+            IsSorted = false;
+            base.OnClear();
+        }
+
+        /// <summary>
+        ///     A map of display index (key) to index in the column collection (value).  Used to quickly find a column from its display index.
+        /// </summary>
+        internal List<int> DisplayIndexMap
+        {
+            get
+            {
+                if (!_IsDisplayIndexValid)
+                {
+                    UpdateDisplayIndexMap();
+                }
+
+
+                return _DisplayIndexMap;
+            }
+        }
+
+        /// <summary>
+        /// Gets the display index for specified column.
+        /// </summary>
+        /// <param name="column">Column that is part f ColumnHeaderCollection</param>
+        /// <returns>Display index or -1 column is not part of this collection.</returns>
+        public int GetDisplayIndex(ColumnHeader column)
+        {
+            int index = this.IndexOf(column);
+            UpdateDisplayIndexMap();
+            for (int i = 0; i < _DisplayIndexMap.Count; i++)
+            {
+                if (_DisplayIndexMap[i] == index) return i;
+            }
+            return -1;
+        }
+
+        /// <summary>
+        /// Returns the column that is displayed at specified display index..
+        /// </summary>
+        /// <param name="displayIndex">0 based display index.</param>
+        /// <returns>ColumnHeader</returns>
+        public ColumnHeader ColumnAtDisplayIndex(int displayIndex)
+        {
+            UpdateDisplayIndexMap();
+            return this[_DisplayIndexMap[displayIndex]];
+        }
+
+        private List<int> _DisplayIndexMap = new List<int>();
+        private bool _IsDisplayIndexValid = false;
+        private void UpdateDisplayIndexMap()
+        {
+            if (_IsDisplayIndexValid) return;
+
+            _IsDisplayIndexValid = true;
+            _DisplayIndexMap.Clear();
+            List<IndexToDisplayIndex> workingMap = new List<IndexToDisplayIndex>();
+            bool isAllDefault = true;
+            for (int i = 0; i < Count; i++)
+            {
+                int displayIndex = this[i].DisplayIndex;
+                if (displayIndex != -1) isAllDefault = false;
+                workingMap.Add(new IndexToDisplayIndex(i, displayIndex));
+            }
+            if (!isAllDefault)
+                workingMap.Sort(new DisplayIndexComparer());
+            foreach (IndexToDisplayIndex item in workingMap)
+            {
+                _DisplayIndexMap.Add(item.Index);
+            }
+        }
+        /// <summary>
+        /// Gets reference to last visible column or null if there is no last visible column.
+        /// </summary>
+        public DevComponents.AdvTree.ColumnHeader LastVisibleColumn
+        {
+            get
+            {
+                List<int> displayMap = DisplayIndexMap;
+                for (int i = displayMap.Count - 1; i >=0; i--)
+                {
+                    if (this[displayMap[i]].Visible) return this[displayMap[i]];
+                }
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Gets reference to first visible column or null if there is no first visible column.
+        /// </summary>
+        public DevComponents.AdvTree.ColumnHeader FirstVisibleColumn
+        {
+            get
+            {
+                List<int> displayMap = DisplayIndexMap;
+                for (int i = 0; i < displayMap.Count; i++)
+                {
+                    if (this[displayMap[i]].Visible) return this[displayMap[i]];
+                }
+                return null;
+            }
+        }
+
+        #region IndexToDisplayIndex Class
+        private class IndexToDisplayIndex
+        {
+            public int Index = -1;
+            public int DisplayIndex = -1;
+            /// <summary>
+            /// Initializes a new instance of the IndexToDisplayIndex class.
+            /// </summary>
+            /// <param name="index"></param>
+            /// <param name="displayIndex"></param>
+            public IndexToDisplayIndex(int index, int displayIndex)
+            {
+                Index = index;
+                DisplayIndex = displayIndex;
+            }
+        }
+        #endregion
+
+        #region DisplayIndexComparer
+
+        private class DisplayIndexComparer : IComparer<IndexToDisplayIndex>
+        {
+            #region IComparer<IndexToDisplayIndex> Members
+
+            public int Compare(IndexToDisplayIndex x, IndexToDisplayIndex y)
+            {
+                if (x.DisplayIndex == y.DisplayIndex)
+                {
+                    return x.Index - y.Index;
+                }
+                else
+                {
+                    return x.DisplayIndex - y.DisplayIndex;
+                }
+            }
+            #endregion
+        }
+
+        #endregion
+
+        internal void DisplayIndexChanged(ColumnHeader column, int newDisplayIndex, int oldDisplayIndex)
+        {
+            InvalidateDisplayIndexes();
+
+            if (_UpdatingDisplayIndexes) return;
+
+            if (_Parent != null && !_Parent.IsUpdateSuspended)
+                UpdateTreeLayout();
+            else if (_ParentNode != null && _ParentNode.TreeControl != null && !_ParentNode.TreeControl.IsUpdateSuspended)
+                UpdateTreeLayout();
+        }
+        /// <summary>
+        /// Invalidates the display indexes and causes them to be re-evaluated on next layout.
+        /// </summary>
+        public void InvalidateDisplayIndexes()
+        {
+            _IsDisplayIndexValid = false;
+        }
+        #endregion
+
+        private Rectangle _Bounds = Rectangle.Empty;
+        internal void SetBounds(System.Drawing.Rectangle totalBounds)
+        {
+            _Bounds = totalBounds;
+        }
+
+        /// <summary>
+        /// Gets the column header rendering bounds.
+        /// </summary>
+        [Browsable(false)]
+        public Rectangle Bounds
+        {
+            get { return _Bounds; }
+        }
+
+        internal bool UsesRelativeSize = false;
+
+        private bool _UpdatingDisplayIndexes = false;
+        internal bool UpdatingDisplayIndexes
+        {
+            get { return _UpdatingDisplayIndexes; }
+            set { _UpdatingDisplayIndexes = value; }
+        }
+    }
+}

PROMS/DotNetBar Source Code/AdvTree/ColumnHeaderControl.cs

@@ -0,0 +1,324 @@
+using System;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using DevComponents.DotNetBar;
+using System.Drawing.Drawing2D;
+using System.Drawing.Text;
+
+namespace DevComponents.AdvTree
+{
+    internal class ColumnHeaderControl : Control
+    {
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the ColumnHeaderControl class.
+        /// </summary>
+        public ColumnHeaderControl()
+        {
+            this.SetStyle(ControlStyles.UserPaint, true);
+            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+            this.SetStyle(ControlStyles.Opaque, true);
+            this.SetStyle(ControlStyles.ResizeRedraw, true);
+            this.SetStyle(ControlStyles.DoubleBuffer, true);
+            this.SetStyle(ControlStyles.Selectable, false);
+            this.SetStyle(ControlStyles.StandardDoubleClick | ControlStyles.StandardClick, true);
+        }
+        #endregion
+
+        #region Internal Implementation
+        protected override void OnPaint(PaintEventArgs e)
+        {
+            Graphics g = e.Graphics;
+
+            DisplayHelp.FillRectangle(g, this.ClientRectangle, this.BackColor);
+
+            if (_Columns == null)
+            {
+                return;
+            }
+
+            AdvTree tree = GetTree();
+            if (tree != null)
+            {
+                SmoothingMode sm = g.SmoothingMode;
+                TextRenderingHint th = g.TextRenderingHint;
+                if (tree.AntiAlias)
+                {
+                    g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
+                    g.TextRenderingHint = DisplayHelp.AntiAliasTextRenderingHint;
+                }
+                //Creates the drawing matrix with the right zoom;
+                if (tree.Zoom != 1)
+                {
+                    System.Drawing.Drawing2D.Matrix mx = GetTranslationMatrix(tree.Zoom);
+                    //use it for drawing
+                    g.Transform = mx;
+                }
+
+                tree.NodeDisplay.PaintColumnHeaders(_Columns, g, true);
+
+                int columnMoveMarkerIndex = _ColumnMoveMarkerIndex;
+                if (columnMoveMarkerIndex >= 0)
+                    DevComponents.AdvTree.Display.ColumnHeaderDisplay.PaintColumnMoveMarker(g, tree, columnMoveMarkerIndex, _Columns);
+
+                if (tree.AntiAlias)
+                {
+                    g.SmoothingMode = sm;
+                    g.TextRenderingHint = th;
+                }
+            }
+
+
+            base.OnPaint(e);
+        }
+
+        private int _ColumnMoveMarkerIndex = -1;
+        /// <summary>
+        /// Gets or sets the column move marker that marks insertion point for column that is dragged. Marker is drawn before the column specified by this index.
+        /// </summary>
+        internal int ColumnMoveMarkerIndex
+        {
+            get { return _ColumnMoveMarkerIndex; }
+            set
+            {
+                _ColumnMoveMarkerIndex = value;
+                this.Invalidate();
+            }
+        }
+        
+
+        /// <summary>
+        /// Returns mouse position which is translated if control Zoom is not equal 1
+        /// </summary>
+        /// <param name="x">X coordinate</param>
+        /// <param name="y">Y coordinate</param>
+        /// <returns></returns>
+        private Point GetLayoutPosition(float zoom, int x, int y)
+        {
+            if (zoom == 1)
+                return new Point(x, y);
+            Point[] p = new Point[] { new Point(x, y) };
+            using (System.Drawing.Drawing2D.Matrix mx = GetTranslationMatrix(zoom))
+            {
+                mx.Invert();
+                mx.TransformPoints(p);
+            }
+            return p[0];
+        }
+
+        private System.Drawing.Drawing2D.Matrix GetTranslationMatrix(float zoom)
+        {
+            System.Drawing.Drawing2D.Matrix mx = new System.Drawing.Drawing2D.Matrix(zoom, 0, 0, zoom, 0, 0);
+            return mx;
+        }
+
+        private AdvTree GetTree()
+        {
+            return this.Parent as AdvTree;
+        }
+
+        private ColumnHeaderCollection _Columns = null;
+        /// <summary>
+        /// Gets or sets the column header collection to be rendered.
+        /// </summary>
+        public ColumnHeaderCollection Columns
+        {
+            get { return _Columns; }
+            set { _Columns = value; }
+        }
+
+        private Cursor _OldCursor = null;
+        private ColumnHeader _MouseOverColumnHeader = null;
+        protected override void OnMouseMove(MouseEventArgs e)
+        {
+            AdvTree tree = GetTree();
+
+            Point p = GetLayoutPosition(tree.Zoom, e.X, e.Y);
+            ColumnHeader ch = tree.GetColumnAt(p.X, p.Y, _Columns);
+            if (_MouseOverColumnHeader != ch)
+            {
+                if (_MouseOverColumnHeader != null)
+                    _MouseOverColumnHeader.InternalMouseLeave(e);
+                _MouseOverColumnHeader = ch;
+                if (_MouseOverColumnHeader != null)
+                {
+                    _MouseOverColumnHeader.InternalMouseEnter(e);
+                    Interop.WinApi.ResetHover(this);
+                }
+            }
+
+            if (ch != null)
+            {
+                ch.InternalMouseMove(e);
+            }
+
+            if (e.Button == MouseButtons.Left && _MouseDownHeader != null && tree.AllowUserToReorderColumns && (Math.Abs(_MouseDownPoint.X-e.X)>1))
+            {
+                tree.StartColumnReorder(p.X, p.Y);
+                return;
+            }
+
+            if (tree == null || e.Button != MouseButtons.None || !tree.AllowUserToResizeColumns) return;
+
+            
+            if (tree.CanResizeColumnAt(p.X, p.Y))
+            {
+                if (_OldCursor == null)
+                {
+                    _OldCursor = this.Cursor;
+                    this.Cursor = Cursors.VSplit;
+                }
+            }
+            else 
+            {
+                ReleaseCursor();
+            }
+
+            base.OnMouseMove(e);
+        }
+
+        ColumnHeader _MouseDownHeader = null;
+        private Point _MouseDownPoint = Point.Empty;
+        protected override void OnMouseDown(MouseEventArgs e)
+        {
+            AdvTree tree = GetTree();
+            Point p = Point.Empty;
+            
+            bool canResize = false;
+            _MouseDownPoint = e.Location;
+
+            if (tree != null)
+            {
+                p = GetLayoutPosition(tree.Zoom, e.X, e.Y);
+            }
+
+            if (tree != null && tree.AllowUserToResizeColumns && e.Button == MouseButtons.Left)
+                canResize = tree.CanResizeColumnAt(p.X, p.Y);
+
+            if (tree != null)
+            {
+                p = GetLayoutPosition(tree.Zoom, e.X, e.Y);
+                ColumnHeader ch = tree.GetColumnAt(p.X, p.Y, _Columns);
+                if (ch != null)
+                {
+                    _MouseDownHeader = ch;
+                    if (!canResize)
+                        ch.OnMouseDown(e);
+                }
+            }
+
+            if (tree == null || e.Button != MouseButtons.Left || !tree.AllowUserToResizeColumns) return;
+
+            if (canResize)
+            {
+                tree.StartColumnResize(p.X, p.Y);
+            }
+
+            this.Invalidate();
+            base.OnMouseDown(e);
+        }
+
+        protected override void OnMouseHover(EventArgs e)
+        {
+            if (Control.MouseButtons == MouseButtons.None)
+            {
+                AdvTree tree = GetTree();
+                Point p = this.PointToClient(Control.MousePosition);
+                p = GetLayoutPosition(tree.Zoom, p.X, p.Y);
+                ColumnHeader ch = tree.GetColumnAt(p.X, p.Y, _Columns);
+                if (ch != null)
+                {
+                    ch.InternalMouseHover(e);
+                }
+            }
+            base.OnMouseHover(e);
+        }
+
+        protected override void OnMouseUp(MouseEventArgs e)
+        {
+            ReleaseCursor();
+            _MouseDownPoint = Point.Empty;
+
+            if (_MouseDownHeader!=null)
+            {
+                _MouseDownHeader.OnMouseUp(e);
+                _MouseDownHeader = null;
+            }
+            this.Invalidate();
+
+            base.OnMouseUp(e);
+        }
+
+        protected override void OnClick(EventArgs e)
+        {
+            AdvTree tree = GetTree();
+            Point p = Point.Empty;
+
+            if (tree != null)
+            {
+                Point tp = tree.PointToClient(Control.MousePosition);
+                p = GetLayoutPosition(tree.Zoom, tp.X, tp.Y);
+                ColumnHeader ch = tree.GetColumnAt(p.X, p.Y, _Columns);
+                if (ch != null)
+                {
+                    ch.OnClick(e);
+                }
+            }
+            this.Invalidate();
+            base.OnClick(e);
+        }
+
+        internal DateTime IgnoreDoubleClickTime = DateTime.MinValue;
+        
+        protected override void OnDoubleClick(EventArgs e)
+        {
+            AdvTree tree = GetTree();
+            Point p = Point.Empty;
+
+            if (tree != null)
+            {
+                Point tp = tree.PointToClient(Control.MousePosition);
+                p = GetLayoutPosition(tree.Zoom, tp.X, tp.Y);
+                ColumnHeader ch = tree.GetColumnAt(p.X, p.Y, _Columns);
+                if (ch != null)
+                {
+                    DateTime now = DateTime.Now;
+                    if (IgnoreDoubleClickTime != DateTime.MinValue && now.Subtract(IgnoreDoubleClickTime).TotalMilliseconds <= SystemInformation.DoubleClickTime)
+                    {
+                        IgnoreDoubleClickTime = DateTime.MinValue;
+                        return;
+                    }
+                    IgnoreDoubleClickTime = DateTime.MinValue;
+
+                    ch.OnDoubleClick(e);
+                }
+            }
+            this.Invalidate();
+
+            base.OnDoubleClick(e);
+        }
+
+        private void ReleaseCursor()
+        {
+            if (_OldCursor != null)
+            {
+                this.Cursor = _OldCursor;
+                _OldCursor = null;
+            }
+        }
+
+        protected override void OnMouseLeave(EventArgs e)
+        {
+            if (_MouseOverColumnHeader != null)
+            {
+                _MouseOverColumnHeader.InternalMouseLeave(e);
+                _MouseOverColumnHeader = null;
+            }
+            if (Control.MouseButtons != MouseButtons.Left)
+                ReleaseCursor();
+            base.OnMouseLeave(e);
+        }
+        #endregion
+    }
+}

PROMS/DotNetBar Source Code/AdvTree/ColumnWidth.cs

@@ -0,0 +1,151 @@
+using System;
+using System.ComponentModel;
+
+namespace DevComponents.AdvTree
+{
+	/// <summary>
+	/// Represents the width of the Column. Supports absolute width in Pixels and
+	/// relative width as percentage of the width of parent control.
+	/// </summary>
+	[ToolboxItem(false) ,System.ComponentModel.DesignTimeVisible(false),TypeConverter(typeof(System.ComponentModel.ExpandableObjectConverter))]
+    public class ColumnWidth
+	{
+		private int m_Relative=0;
+		private int m_Absolute=0;
+		internal event EventHandler WidthChanged;
+
+		/// <summary>
+		/// Creates new instance of the object.
+		/// </summary>
+		public ColumnWidth()
+		{
+		}
+
+		/// <summary>
+		/// Gets or sets relative width expressed as percentage between 1-100. 0 indicates that
+		/// absolute width will be used.
+		/// </summary>
+		/// <remarks>
+		/// Relative width is expressed as percentage between 1-100 of the parent controls
+		/// width. 0 indicates that absolute width will be used. Absolute width always takes
+		/// priority over relative width. For example value of 30 assigned to this property
+		/// indicates that width of the column will be 30% of the total client width of the
+		/// control.
+		/// </remarks>
+		[DefaultValue(0),Browsable(true),Description("Gets or sets relative width in percent. Valid values are between 1-100 with 0 indicating that absolute width will be used.")]
+		public int Relative
+		{
+			get {return m_Relative;}
+			set
+			{
+				if(m_Relative!=value)
+				{
+					m_Relative=value;
+					OnSizeChanged();
+				}
+			}
+		}
+
+		/// <summary>Gets or sets the absolute width of the column in pixels.</summary>
+		/// <remarks>
+		/// Absolute width always takes precedence over the relative width of the
+		/// column.
+		/// </remarks>
+		[DefaultValue(0),Browsable(true),Description("Gets or sets the absolute width of the column in pixels.")]
+		public int Absolute
+		{
+			get {return m_Absolute;}
+			set
+			{
+				if(m_Absolute<0)
+					return;
+				if(m_Absolute!=value)
+				{
+					m_Absolute=value;
+					if(m_Absolute!=0)
+						m_Relative=0;
+					OnSizeChanged();
+				}
+			}
+		}
+
+        internal void SetAbsolute(int value)
+        {
+            m_Absolute = value;
+        }
+
+        internal int GetWidth(int containerWidth)
+        {
+            if (m_Absolute > 0)
+                return m_Absolute;
+            if(m_Relative>0)
+                return (100 / m_Relative) * containerWidth;
+            return 0;
+        }
+
+		private void OnSizeChanged()
+		{
+			if(WidthChanged!=null)
+				WidthChanged(this,new EventArgs());
+		}
+
+        private bool _AutoSize = false;
+        /// <summary>
+        /// Gets or sets whether column width is automatically set based on the column's content. Default value is false.
+        /// When set absolute and relative size values are ignored.
+        /// </summary>
+        [DefaultValue(false), Description("Indicates whether column is sized based on the content.")]
+        public bool AutoSize
+        {
+            get { return _AutoSize; }
+            set
+            {
+                if (_AutoSize != value)
+                {
+                    _AutoSize = value;
+                    OnSizeChanged();
+                }
+            }
+        }
+
+        internal void SetAutoSize(bool autoSize)
+        {
+            _AutoSize = autoSize;
+        }
+
+        private bool _AutoSizeMinHeader = false;
+        /// <summary>
+        /// Gets or sets whether column auto-width is set to minimum of the column header text width. Applies to AutoSize=true only.
+        /// </summary>
+        [DefaultValue(false), Description("Indicates whether column auto-width is set to minimum of the column header text width. Applies to AutoSize=true only.")]
+        public bool AutoSizeMinHeader
+        {
+            get { return _AutoSizeMinHeader; }
+            set
+            {
+                _AutoSizeMinHeader = value;
+                OnSizeChanged();
+            }
+        }
+        
+
+        private int _AutoSizeWidth = 0;
+        /// <summary>
+        /// Gets the auto-size calculated width of the column after tree layout is performed and column has AutoSize=true.
+        /// </summary>
+        [Browsable(false)]
+        public int AutoSizeWidth
+        {
+            get { return _AutoSizeWidth; }
+//            internal set
+//            {
+//                _AutoSizeWidth = value;
+//            }
+        }
+		internal void SetAutoSizeWidth(int value)
+		{
+			_AutoSizeWidth = value;
+		}
+        
+	}
+}

PROMS/DotNetBar Source Code/AdvTree/CommandButtonEventArgs.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace DevComponents.AdvTree
+{
+	/// <summary>
+	/// Provides event arguments for command button events.
+	/// </summary>
+	public class CommandButtonEventArgs:EventArgs
+	{
+		/// <summary>
+		/// Default constructor.
+		/// </summary>
+		/// <param name="action">Action type.</param>
+		/// <param name="node">Context node.</param>
+		public CommandButtonEventArgs(eTreeAction action, Node node)
+		{
+			this.Action=action;
+			this.Node=node;
+		}
+		
+		/// <summary>
+		/// Indicates the action type that caused the event.
+		/// </summary>
+		public eTreeAction Action=eTreeAction.Code;
+		/// <summary>
+		/// Indicates the node action is peformed on.
+		/// </summary>
+		public DevComponents.AdvTree.Node Node=null;
+	}
+}

PROMS/DotNetBar Source Code/AdvTree/ConnectorPointsCollection.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+
+namespace DevComponents.AdvTree
+{
+	/// <summary>
+	/// Represents collection of connector points for a node.
+	/// </summary>
+	public class ConnectorPointsCollection:CollectionBase 
+	{
+		#region Private Variables
+		private Node m_ParentNode=null;
+		#endregion
+
+		#region Internal Implementation
+		/// <summary>
+		/// Default constructor.
+		/// </summary>
+		public ConnectorPointsCollection()
+		{
+		}
+		/// <summary>
+		/// Gets or sets the node this collection is associated with.
+		/// </summary>
+		[Browsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public Node ParentNode
+		{
+			get {return m_ParentNode;}
+		}
+		/// <summary>
+		/// Sets the node collection belongs to.
+		/// </summary>
+		/// <param name="parent">Node that is parent of this collection.</param>
+		internal void SetParentNode(Node parent)
+		{
+			m_ParentNode=parent;
+		}
+
+		/// <summary>
+		/// Adds new object to the collection.
+		/// </summary>
+		/// <param name="p">Object to add.</param>
+		/// <returns>Index of newly added object.</returns>
+		public int Add(Point p)
+		{
+			return List.Add(p);
+		}
+
+		/// <summary>
+		/// Adds range of objects to the array.
+		/// </summary>
+		/// <param name="ap">Array to add.</param>
+		public void AddRange(Point[] ap)
+		{
+			foreach(Point p in ap)
+				this.Add(p);
+		}
+
+		/// <summary>
+		/// Copies objects of the collection to the array.
+		/// </summary>
+		/// <returns></returns>
+		public Point[] ToArray()
+		{
+			Point[] ap=new Point[this.Count];
+			this.CopyTo(ap);
+			return ap;
+		}
+
+		/// <summary>
+		/// Returns reference to the object in collection based on it's index.
+		/// </summary>
+		public Point this[int index]
+		{
+			get {return (Point)(List[index]);}
+			set {List[index] = value;}
+		}
+
+		/// <summary>
+		/// Inserts new object into the collection.
+		/// </summary>
+		/// <param name="index">Position of the object.</param>
+		/// <param name="value">Object to insert.</param>
+		public void Insert(int index, Point value) 
+		{
+			List.Insert(index, value);
+		}
+
+		/// <summary>
+		/// Returns index of the object inside of the collection.
+		/// </summary>
+		/// <param name="value">Reference to the object.</param>
+		/// <returns>Index of the object.</returns>
+		public int IndexOf(Point value) 
+		{
+			return List.IndexOf(value);
+		}
+
+		/// <summary>
+		/// Returns whether collection contains specified object.
+		/// </summary>
+		/// <param name="value">Object to look for.</param>
+		/// <returns>true if object is part of the collection, otherwise false.</returns>
+		public bool Contains(Point value) 
+		{
+			return List.Contains(value);
+		}
+
+		/// <summary>
+		/// Removes specified object from the collection.
+		/// </summary>
+		/// <param name="value"></param>
+		public void Remove(Point value) 
+		{
+			List.Remove(value);
+		}
+
+		protected override void OnRemoveComplete(int index,object value)
+		{
+			base.OnRemoveComplete(index,value);
+		}
+		protected override void OnInsertComplete(int index,object value)
+		{
+			base.OnInsertComplete(index,value);
+		}
+
+		/// <summary>
+		/// Copies collection into the specified array.
+		/// </summary>
+		/// <param name="array">Array to copy collection to.</param>
+		/// <param name="index">Starting index.</param>
+		public void CopyTo(Point[] array, int index) 
+		{
+			List.CopyTo(array, index);
+		}
+
+		/// <summary>
+		/// Copies contained items to the ColumnHeader array.
+		/// </summary>
+		/// <param name="array">Array to copy to.</param>
+		internal void CopyTo(Point[] array)
+		{
+			List.CopyTo(array,0);
+		}
+
+		protected override void OnClear()
+		{
+			base.OnClear();
+		}
+		#endregion
+	}
+}

PROMS/DotNetBar Source Code/AdvTree/CustomEditors.cs

@@ -0,0 +1,243 @@
+using System;
+using System.Text;
+using DevComponents.Editors;
+using System.Windows.Forms;
+using DevComponents.Editors.DateTimeAdv;
+
+namespace DevComponents.AdvTree
+{
+#if FRAMEWORK20
+    #region Integer Custom Editor
+    internal class IntegerCellEditor : IntegerInput, ICellEditControl
+    {
+        #region ICellEditControl Members
+
+        public void BeginEdit()
+        {
+#if (FRAMEWORK20)
+            this.MinimumSize = new System.Drawing.Size(32, 10);
+#endif
+        }
+
+        public void EndEdit()
+        {
+            this.Dispose();
+        }
+
+        public object CurrentValue
+        {
+            get
+            {
+                if (this.FreeTextEntryMode && this.IsKeyboardFocusWithin)
+                    this.ApplyFreeTextValue();
+                return this.Text;
+            }
+            set
+            {
+                if (value is int)
+                    this.Value = (int)value;
+                else if (value == null)
+                    this.ValueObject = null;
+                else
+                {
+                    string s = Utilities.StripNonNumeric(value.ToString());
+                    int i = 0;
+#if FRAMEWORK20
+                    int.TryParse(s, out i);
+#else
+            try
+            {
+                i = int.Parse(s);
+            }
+            catch { }
+#endif
+                    this.Value = i;
+                }
+            }
+        }
+        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
+        {
+            if (keyData == Keys.Enter || keyData == Keys.Tab)
+            {
+                if (EditComplete != null)
+                    EditComplete(this, new EventArgs());
+                return true;
+            }
+            else if (keyData == Keys.Escape)
+            {
+                if (CancelEdit != null)
+                    CancelEdit(this, new EventArgs());
+                return true;
+            }
+            return base.ProcessCmdKey(ref msg, keyData);
+        }
+
+        public event EventHandler EditComplete;
+
+        public event EventHandler CancelEdit;
+
+        public bool EditWordWrap
+        {
+            get { return false; }
+            set { }
+        }
+
+        #endregion
+    }
+    #endregion
+
+    #region Double Custom Editor
+    internal class DoubleCellEditor : DoubleInput, ICellEditControl
+    {
+        #region ICellEditControl Members
+
+        public void BeginEdit()
+        {
+#if (FRAMEWORK20)
+            this.MinimumSize = new System.Drawing.Size(32, 10);
+#endif
+        }
+
+        public void EndEdit()
+        {
+            this.Dispose();
+        }
+
+        public object CurrentValue
+        {
+            get
+            {
+                if (this.FreeTextEntryMode && this.IsKeyboardFocusWithin)
+                    this.ApplyFreeTextValue();
+                return this.Text;
+            }
+            set
+            {
+                if (value is int)
+                    this.Value = (int)value;
+                else if (value == null)
+                    this.ValueObject = null;
+                else
+                {
+                    string s = Utilities.StripNonNumeric(value.ToString());
+                    double i = 0;
+#if FRAMEWORK20
+                    double.TryParse(s, out i);
+#else
+            try
+            {
+                i = double.Parse(s);
+            }
+            catch { }
+#endif
+                    this.Value = i;
+                }
+            }
+        }
+        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
+        {
+            if (keyData == Keys.Enter || keyData == Keys.Tab)
+            {
+                if (EditComplete != null)
+                    EditComplete(this, new EventArgs());
+                return true;
+            }
+            else if (keyData == Keys.Escape)
+            {
+                if (CancelEdit != null)
+                    CancelEdit(this, new EventArgs());
+                return true;
+            }
+            return base.ProcessCmdKey(ref msg, keyData);
+        }
+
+        public event EventHandler EditComplete;
+
+        public event EventHandler CancelEdit;
+
+        public bool EditWordWrap
+        {
+            get { return false; }
+            set { }
+        }
+
+        #endregion
+    }
+    #endregion
+
+    #region Date-Time Custom Editor
+    internal class DateTimeCellEditor : DateTimeInput, ICellEditControl
+    {
+        #region Constructor
+        /// <summary>
+        /// Initializes a new instance of the DateTimeCellEditor class.
+        /// </summary>
+        public DateTimeCellEditor()
+        {
+            this.BackgroundStyle.BorderColor = System.Drawing.Color.Transparent;
+        }
+        #endregion
+
+        #region ICellEditControl Members
+        public void BeginEdit()
+        {
+            this.MinimumSize = new System.Drawing.Size(70, 10);
+        }
+
+        public void EndEdit()
+        {
+            this.Dispose();
+        }
+
+        public object CurrentValue
+        {
+            get
+            {
+                return this.Text;
+            }
+            set
+            {
+                if (value is DateTime)
+                    this.Value = (DateTime)value;
+                else if (value == null)
+                    this.ValueObject = null;
+                else if(value is string)
+                {
+                    DateTime date = DateTime.MinValue;
+                    if (DateTime.TryParse((string)value, out date))
+                        this.Value = date;
+                }
+            }
+        }
+        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
+        {
+            if (keyData == Keys.Enter || keyData == Keys.Tab)
+            {
+                if (EditComplete != null)
+                    EditComplete(this, new EventArgs());
+                return true;
+            }
+            else if (keyData == Keys.Escape)
+            {
+                if (CancelEdit != null)
+                    CancelEdit(this, new EventArgs());
+                return true;
+            }
+            return base.ProcessCmdKey(ref msg, keyData);
+        }
+
+        public event EventHandler EditComplete;
+
+        public event EventHandler CancelEdit;
+
+        public bool EditWordWrap
+        {
+            get { return false; }
+            set { }
+        }
+
+        #endregion
+    }
+    #endregion
+#endif
+}

PROMS/DotNetBar Source Code/AdvTree/Display/CellDisplay.cs

@@ -0,0 +1,328 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using DevComponents.DotNetBar;
+using DevComponents.DotNetBar.Rendering;
+
+namespace DevComponents.AdvTree.Display
+{
+	/// <summary>
+	/// Represents cell display class.
+	/// </summary>
+	internal class CellDisplay
+	{
+		public CellDisplay()
+		{
+		}
+
+        private static Office2007CheckBoxItemPainter _CheckBoxPainter;
+        public static Office2007CheckBoxItemPainter CheckBoxPainter
+        {
+            get { return _CheckBoxPainter; }
+            set { _CheckBoxPainter = value; }
+        }
+
+        public static Office2007CheckBoxColorTable ColorTable = null;
+
+		public static void PaintCell(NodeCellRendererEventArgs ci)
+		{
+			if(ci.Cell.CheckBoxVisible)
+				CellDisplay.PaintCellCheckBox(ci);
+			if(!ci.Cell.Images.LargestImageSize.IsEmpty)
+				CellDisplay.PaintCellImage(ci);
+			CellDisplay.PaintText(ci);
+		}
+
+		public static void PaintCellCheckBox(NodeCellRendererEventArgs ci)
+		{
+			if(!ci.Cell.CheckBoxVisible)
+				return;
+            Cell cell = ci.Cell;
+            Rectangle r = cell.CheckBoxBoundsRelative;
+			r.Offset(ci.CellOffset);
+
+            if (ci.CheckBoxImageChecked != null)
+            {
+                Image img = ci.CheckBoxImageChecked;
+                if (cell.CheckState == System.Windows.Forms.CheckState.Unchecked)
+                    img = ci.CheckBoxImageUnChecked;
+                else if (cell.CheckState == System.Windows.Forms.CheckState.Indeterminate)
+                    img = ci.CheckBoxImageIndeterminate;
+                if (img != null)
+                    ci.Graphics.DrawImage(img, r);
+            }
+            else if (_CheckBoxPainter != null)
+            {
+                Office2007CheckBoxStateColorTable ct = GetCheckBoxStateColorTable(ci);
+                if (cell.CheckBoxStyle == eCheckBoxStyle.CheckBox)
+                {
+                    _CheckBoxPainter.PaintCheckBox(ci.Graphics, r, ct, cell.CheckState);
+                }
+                else
+                {
+                    _CheckBoxPainter.PaintRadioButton(ci.Graphics, r, ct, cell.Checked);
+                }
+            }
+            else
+            {
+                System.Windows.Forms.ButtonState state = System.Windows.Forms.ButtonState.Normal;
+                if (ci.Cell.Checked)
+                    state = System.Windows.Forms.ButtonState.Checked;
+                System.Windows.Forms.ControlPaint.DrawCheckBox(ci.Graphics, r, state);
+            }
+		}
+
+        private static Office2007CheckBoxStateColorTable GetCheckBoxStateColorTable(NodeCellRendererEventArgs e)
+        {
+            Cell cell = e.Cell;
+
+            if (ColorTable != null && BarFunctions.IsOffice2007Style(e.ColorScheme.Style))
+            {
+                Office2007CheckBoxColorTable ct = ColorTable;
+                if (!cell.GetEnabled())
+                    return ct.Disabled;
+                //else if (cell.IsMouseDown)
+                //    return ct.Pressed;
+                //else if (cell.IsMouseOver)
+                //    return ct.MouseOver;
+                return ct.Default;
+            }
+            else
+            {
+                ColorScheme cs = e.ColorScheme;
+                // Create color table based on the ColorScheme object...
+                Office2007CheckBoxStateColorTable ct = new Office2007CheckBoxStateColorTable();
+                if (!cell.GetEnabled())
+                {
+                    ct.CheckBackground = new LinearGradientColorTable(cs.MenuBackground, Color.Empty);
+                    ct.CheckBorder = cs.ItemDisabledText;
+                    ct.CheckInnerBorder = cs.ItemDisabledText;
+                    ct.CheckInnerBackground = new LinearGradientColorTable();
+                    ct.CheckSign = new LinearGradientColorTable(cs.ItemDisabledText, Color.Empty);
+                    ct.Text = cs.ItemDisabledText;
+                }
+                //else if (cell.IsMouseDown)
+                //{
+                //    ct.CheckBackground = new LinearGradientColorTable(cs.MenuBackground, Color.Empty);
+                //    ct.CheckBorder = cs.ItemPressedBorder;
+                //    ct.CheckInnerBorder = cs.ItemPressedBorder;
+                //    ct.CheckInnerBackground = new LinearGradientColorTable(cs.ItemPressedBackground, cs.ItemPressedBackground2);
+                //    ct.CheckSign = new LinearGradientColorTable(cs.ItemPressedText, Color.Empty);
+                //    ct.Text = cs.ItemPressedText;
+                //}
+                //else if (cell.IsMouseOver)
+                //{
+                //    ct.CheckBackground = new LinearGradientColorTable(cs.MenuBackground, Color.Empty);
+                //    ct.CheckBorder = cs.ItemHotBorder;
+                //    ct.CheckInnerBorder = cs.ItemHotBorder;
+                //    ct.CheckInnerBackground = new LinearGradientColorTable(cs.ItemHotBackground, cs.ItemHotBackground2);
+                //    ct.CheckSign = new LinearGradientColorTable(cs.ItemHotText, Color.Empty);
+                //    ct.Text = cs.ItemHotText;
+                //}
+                else
+                {
+                    ct.CheckBackground = new LinearGradientColorTable(cs.MenuBackground, Color.Empty);
+                    ct.CheckBorder = cs.PanelBorder;
+                    ct.CheckInnerBorder = ColorBlendFactory.SoftLight(cs.PanelBorder, Color.White);
+                    ct.CheckInnerBackground = new LinearGradientColorTable(cs.MenuBackground, Color.Empty);
+                    ct.CheckSign = new LinearGradientColorTable(cs.ItemText, Color.Empty);
+                    ct.Text = cs.ItemText;
+                }
+                return ct;
+            }
+        }
+
+		public static void PaintCellImage(NodeCellRendererEventArgs ci)
+		{
+			if(ci.Cell.Images.LargestImageSize.IsEmpty)
+				return;
+			Rectangle r=ci.Cell.ImageBoundsRelative;
+			r.Offset(ci.CellOffset);
+			
+			Image image = CellDisplay.GetCellImage(ci.Cell);
+			
+			if(image!=null)
+			{
+			    Size imageSize = Dpi.ImageSize(image.Size);
+                ci.Graphics.DrawImage(image, r.X + (r.Width - imageSize.Width) / 2,
+                                      r.Y + (r.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
+			}
+		}
+
+        public static void PaintText(NodeCellRendererEventArgs ci)
+        {
+            Cell cell = ci.Cell;
+            if (cell.HostedControl == null && cell.HostedItem == null && (cell.DisplayText == "" || ci.Style.TextColor.IsEmpty) || cell.TextContentBounds.IsEmpty)
+                return;
+
+            Rectangle bounds = ci.Cell.TextContentBounds;
+            bounds.Offset(ci.CellOffset);
+
+            Graphics g = ci.Graphics;
+            if (cell.HostedControl != null)
+            {
+                if (!cell.HostedControl.Visible)
+                    cell.HostedControl.Visible = true;
+                return;
+            }
+            else if (cell.HostedItem != null)
+            {
+                BaseItem item = cell.HostedItem;
+                if (item.ItemAlignment == eItemAlignment.Near)
+                    item.LeftInternal = bounds.X;
+                else if (item.ItemAlignment == eItemAlignment.Far)
+                    item.LeftInternal = bounds.X + (bounds.Width - item.WidthInternal);
+                else if (item.ItemAlignment == eItemAlignment.Center)
+                    item.LeftInternal = bounds.X + (bounds.Width - item.WidthInternal) / 2;
+                if (item.DisplayRectangle.Height < bounds.Height)
+                    item.TopInternal = bounds.Y + (bounds.Height - item.DisplayRectangle.Height) / 2;
+                else
+                    item.TopInternal = bounds.Y;
+                item.Displayed = true;
+                Region oldClip = g.Clip;
+                Rectangle cb = bounds;
+                cb.Inflate(2, 1);
+                g.SetClip(cb, CombineMode.Intersect);
+                item.Paint(ci.ItemPaintArgs);
+                if (oldClip != null)
+                {
+                    g.Clip = oldClip;
+                    oldClip.Dispose();
+                }
+                return;
+            }
+
+            Font font = ci.Style.Font;
+            if (bounds.Width > 1 && bounds.Height > 1)
+            {
+                //eTextFormat textFormat = ci.Style.TextFormat;
+                //textFormat = textFormat & ~(textFormat & eTextFormat.HidePrefix);
+                //textFormat |= eTextFormat.NoPrefix;
+                if (cell.TextMarkupBody == null)
+                {
+                    TextDrawing.DrawString(g, cell.DisplayText, font, ci.Style.TextColor, bounds, ci.Style.TextFormat);
+                }
+                else
+                {
+                    DevComponents.DotNetBar.TextMarkup.MarkupDrawContext d = new DevComponents.DotNetBar.TextMarkup.MarkupDrawContext(g, font, ci.Style.TextColor, false);
+                    d.HotKeyPrefixVisible = !((ci.Style.TextFormat & eTextFormat.HidePrefix) == eTextFormat.HidePrefix);
+                    Rectangle mr = Rectangle.Empty;
+                    eStyleTextAlignment lineAlignment = ci.Style.TextLineAlignment;
+                    if (lineAlignment == eStyleTextAlignment.Center)
+                    {
+                        mr = new Rectangle(bounds.X, bounds.Y + (bounds.Height - cell.TextMarkupBody.Bounds.Height) / 2, cell.TextMarkupBody.Bounds.Width, cell.TextMarkupBody.Bounds.Height);
+                    }
+                    else if (lineAlignment == eStyleTextAlignment.Near)
+                    {
+                        mr = new Rectangle(bounds.X, bounds.Y, cell.TextMarkupBody.Bounds.Width, cell.TextMarkupBody.Bounds.Height);
+                    }
+                    else // Far
+                    {
+                        mr = new Rectangle(bounds.X, bounds.Y + (bounds.Height - cell.TextMarkupBody.Bounds.Height), cell.TextMarkupBody.Bounds.Width, cell.TextMarkupBody.Bounds.Height);
+                    }
+
+                    cell.TextMarkupBody.Bounds = mr;
+                    cell.TextMarkupBody.Render(d);
+                }
+            }
+        }
+
+		private static Image GetCellImage(Cell cell)
+		{
+			Image img=cell.Images.Image;
+
+            bool enabled = cell.GetEnabled();
+
+            if (!enabled && (cell.Images.ImageDisabled != null || cell.Images.ImageDisabledIndex >= 0 || cell.Images.DisabledImageGenerated != null))
+            {
+                if (cell.Images.DisabledImageGenerated != null) return cell.Images.DisabledImageGenerated;
+                if (cell.Images.ImageDisabled != null) return cell.Images.ImageDisabled;
+                if (cell.Images.ImageDisabledIndex >= 0) return cell.Images.GetImageByIndex(cell.Images.ImageDisabledIndex);
+            }
+
+            if(img == null && !string.IsNullOrEmpty(cell.Images.ImageKey))
+                img = cell.Images.GetImageByKey(cell.Images.ImageKey);
+            if (img == null && cell.Images.ImageIndex >= 0)
+                img = cell.Images.GetImageByIndex(cell.Images.ImageIndex);
+
+            if (!enabled && img is Bitmap)
+            {
+                cell.Images.DisposeGeneratedDisabledImage();
+                cell.Images.DisabledImageGenerated = ImageHelper.CreateGrayScaleImage(img as Bitmap);
+                if (cell.Images.DisabledImageGenerated != null) return cell.Images.DisabledImageGenerated;
+                return img;
+            }
+			
+			if(cell.IsMouseOver && (cell.Images.ImageMouseOver!=null || cell.Images.ImageMouseOverIndex>= 0 || !string.IsNullOrEmpty(cell.Images.ImageMouseOverKey)))
+			{
+                if (cell.Images.ImageMouseOver != null)
+                    img = cell.Images.ImageMouseOver;
+                else if (cell.Images.ImageMouseOverIndex >= 0)
+                    img = cell.Images.GetImageByIndex(cell.Images.ImageMouseOverIndex);
+                else
+                    img = cell.Images.GetImageByKey(cell.Images.ImageMouseOverKey);
+			}
+			else if(cell.Parent.Expanded && (cell.Images.ImageExpanded!=null || cell.Images.ImageExpandedIndex>= 0 || !string.IsNullOrEmpty(cell.Images.ImageExpandedKey)))
+			{
+                if (cell.Images.ImageExpanded != null)
+                    img = cell.Images.ImageExpanded;
+                else if (cell.Images.ImageExpandedIndex >= 0)
+                    img = cell.Images.GetImageByIndex(cell.Images.ImageExpandedIndex);
+                else
+                    img = cell.Images.GetImageByKey(cell.Images.ImageExpandedKey);
+			}
+			return img;
+		}
+
+		public static Font GetCellFont(AdvTree tree, Cell cell)
+		{
+			Font font=tree.Font;
+			ElementStyle style=null;
+			
+			if(cell.StyleNormal!=null)
+			{
+				style=cell.StyleNormal;
+			}
+			else
+			{
+				if(tree.NodeStyle!=null)
+					style=tree.NodeStyle;
+				else
+					style=new ElementStyle();
+
+				if(tree.CellStyleDefault!=null)
+					style=tree.CellStyleDefault;
+				else
+					style=ElementStyle.GetDefaultCellStyle(style);
+			}
+
+			if(style!=null && style.Font!=null)
+				font=style.Font;
+
+			return font;
+		}
+	}
+
+	/// <summary>
+	/// Represents information necessary to paint the cell on canvas.
+	/// </summary>
+	internal class CellDisplayInfo
+	{
+		public ElementStyle Style=null;
+		public System.Drawing.Graphics Graphics=null;
+		public Cell ContextCell=null;
+		public Point CellOffset=Point.Empty;
+
+		public CellDisplayInfo()
+		{
+		}
+
+		public CellDisplayInfo(ElementStyle