using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data.SqlTypes;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Globalization;
using System.Media;
using System.Reflection;
using System.Windows.Forms;
using System.Windows.Forms.VisualStyles;
using DevComponents.DotNetBar.SuperGrid.Primitives;
using DevComponents.DotNetBar.SuperGrid.Style;
using DevComponents.SuperGrid.TextMarkup;

namespace DevComponents.DotNetBar.SuperGrid
{
    /// <summary>
    /// Represents grid cell.
    /// </summary>
    public class GridCell : GridElement, IComparable<GridCell>, IDisposable
    {
        #region Constants

        private const int CheckBoxSpacing = 3;

        #endregion

        #region Static variables

        private static CellInfoWindow _cellInfoWindow;

        private static CellArea _hitArea;
        private static CellArea _lastHitArea;
        private static GridCell _hitCell;

        private static CellArea _mouseDownHitArea;
        private static GridCell _mouseDownHitCell;
        private static Point _mouseDownPoint;
        private static IGridCellEditControl _mouseRenderer;

        private static bool _mouseInItem;
        private static bool _mouseDownInItem;
        private static bool _needsMouseEnter;
        private static bool _dragSelection;
        private static bool _dragStarted;

        private static int _anchorRowIndex;
        private static int _anchorColumnIndex;

        private static string _toolTipText;

        #endregion

        #region Private variables

        private int _ColumnIndex;
        private int _IndentLevel;

        private Size _CellSize;
        private Size _ContentSize;
        private Size _MeasuredSize;

        private Rectangle _Bounds;
        private Rectangle _BackBounds;

        private string _InfoText;
        private Image _InfoImage;

        private Cs _States;
        private EditorInfo _EditorInfo;

        private ushort _BoundsUpdateCount;
        private ushort _ColumnMeasureCount;
        private ushort _DataResetCount;
        private ushort _MergeUpdateCount;
        private ushort _RowMeasureCount;
        private ushort _SelectionClearCount;
        private ushort _SelectionUpdateCount;
        private ushort _StyleUpdateCount;

        private object _Value;
        private object _ExpValue;

        private CellVisualStyles _Styles;
        private CellVisualStyles _EffectiveStyles;

        #endregion

        #region Constructors

        ///<summary>
        /// GridCell
        ///</summary>
        public GridCell()
        {
            SetState(Cs.AllowEdit, true);
        }

        ///<summary>
        /// GridCell
        ///</summary>
        ///<param name="value"></param>
        public GridCell(object value)
            : this()
        {
            _Value = value;
        }

        #endregion

        #region Internal properties

        #region AllowNullMerge

        internal bool AllowNullMerge
        {
            get
            {
                Tbool ns = GridColumn.AllowNullCellMerge;

                if (ns != Tbool.NotSet)
                    return (ns == Tbool.True ? true : false);

                return (GridPanel.AllowNullCellMerge);
            }
        }

        #endregion

        #region CanModify

        internal bool CanModify
        {
            get
            {
                GridColumn col = GridColumn;

                if (col == null || (col.AllowEdit == false || col.AllowSelection == false))
                    return (false);

                GridRow row = GridRow;

                if (row == null || (row.AllowEdit == false || row.AllowSelection == false || row.IsDeleted == true))
                    return (false);

                GridPanel panel = GridPanel;
                
                if (panel == null || (panel.AllowEdit == false || panel.AllowSelection == false))
                    return (false);

                if (Visible == false || AllowEdit == false ||
                    AllowSelection == false || IsEmptyCell == true || IsReadOnly == true)
                {
                    return (false);
                }

                return (true);
            }
        }

        #endregion

        #region CanModifyMerge

        internal bool CanModifyMerge
        {
            get
            {
                if (CanModify == false)
                    return (false);

                return (Merged == false || MergeSuspended == true);
            }
        }

        #endregion

        #region AnySelected

        internal bool AnySelected
        {
            get { return (TestState(Cs.AnySelected)); }
            set { SetState(Cs.AnySelected, value); }
        }

        #endregion

        #region CellSize

        internal Size CellSize
        {
            get { return (_CellSize); }
            set { _CellSize = value; }
        }

        #endregion

        #region CellEditMode

        internal CellEditMode CellEditMode
        {
            get
            {
                IGridCellEditControl editor = (EditControl ?? (GridColumn != null ? GridColumn.EditControl : null));

                if (editor == null)
                    editor = GetInternalEditControl();

                if (editor != null)
                    return (editor.CellEditMode);

                return (CellEditMode.InPlace);
            }
        }

        #endregion

        #region CheckBoxBounds

        internal Rectangle CheckBoxBounds
        {
            get { return (GridRow.CheckBoxBounds); }
        }

        #endregion

        #region ContentSize

        internal Size ContentSize
        {
            get { return(_ContentSize); }
        }

        #endregion

        #region RowContainer

        internal GridContainer RowContainer
        {
            get
            {
                GridRow row = GridRow;

                if (row != null)
                    return (row.Parent as GridContainer);

                return (null);
            }
        }

        #endregion

        #region HitArea

        internal CellArea HitArea
        {
            get { return (_hitArea); }
            set { _hitArea = value; }
        }

        #endregion

        #region IndentLevel

        internal int IndentLevel
        {
            get { return (_IndentLevel); }
            set { _IndentLevel = value; }
        }

        #endregion

        #region IsDragSelection

        internal bool IsDragSelection
        {
            get { return (_dragSelection); }
            set { _dragSelection = value; }
        }

        #endregion

        #region IsDragStarted

        internal bool IsDragStarted
        {
            get { return (_dragStarted); }
            set { _dragStarted = value; }
        }

        #endregion

        #region MergeUpdateCount

        internal ushort MergeUpdateCount
        {
            get { return (_MergeUpdateCount); }
            set { _MergeUpdateCount = value; }
        }

        #endregion

        #region MeasuredSize

        internal Size MeasuredSize
        {
            get { return (_MeasuredSize); }
        }

        #endregion

        #region Modified

        internal bool Modified
        {
            get { return (TestState(Cs.Modified)); }
            set { SetState(Cs.Modified, value); }
        }

        #endregion

        #region MouseRenderer

        internal IGridCellEditControl MouseRenderer
        {
            get { return (_mouseRenderer); }
            set { _mouseRenderer = value; }
        }

        #endregion

        #region NeedsMeasured

        internal override bool NeedsMeasured
        {
            get
            {
                if (_ColumnMeasureCount != GridColumn.MeasureCount)
                    return (true);

                if (_RowMeasureCount != GridRow.MeasureCount)
                    return (true);

                return (base.NeedsMeasured);
            }

            set
            {
                if (value == false)
                {
                    _ColumnMeasureCount = GridColumn.MeasureCount;
                    _RowMeasureCount = GridRow.MeasureCount;
                }

                base.NeedsMeasured = value;
            }
        }

        #endregion

        #region Selected

        internal bool Selected
        {
            get
            {
                if (AllowSelection == false)
                    return (false);

                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    if (_SelectionClearCount != panel.SelectionClearCount)
                    {
                        _SelectionClearCount = panel.SelectionClearCount;

                        Selected = false;

                        if (GridRow.ExpandedVisible(panel) == true)
                            panel.SetSelectedEx(this, false);

                        InvalidateRender();
                    }
                }

                return (TestState(Cs.Selected));
            }

            set
            {
                SetState(Cs.Selected, value);

                GridPanel panel = GridPanel;

                if (panel != null)
                    _SelectionClearCount = panel.SelectionClearCount;
            }
        }

        #endregion

        #region SelectionUpdateCount

        internal ushort SelectionUpdateCount
        {
            get { return (_SelectionUpdateCount); }
            set { _SelectionUpdateCount = value; }
        }

        #endregion

        #region ValueEx

        internal object ValueEx
        {
            get { return (_Value); }

            set
            {
                if ((value != null && value.Equals(_Value) == false) ||
                    (value == null && _Value != null))
                {
                    object oldValue = _Value;
                    _Value = value;

                     OnValueChanged(oldValue, value, DataContext.CellValueLoad);
                }
            }
        }

        #endregion

        #region ValueExx

        internal object ValueExx
        {
            get { return (_Value); }
            set { _Value = value; }
        }

        #endregion

        #endregion

        #region Public properties

        #region AllowEdit

        /// <summary>
        /// Gets or sets whether the cell can be edited by the user. 
        /// </summary>
        [DefaultValue(true), Category("Behavior")]
        [Description("Indicates whether the cell can be edited by the user.")]
        public bool AllowEdit
        {
            get { return (TestState(Cs.AllowEdit)); }

            set
            {
                if (value != AllowEdit)
                {
                    SetState(Cs.AllowEdit, value);

                    OnPropertyChanged("AllowEdit");
                }
            }
        }

        #endregion

        #region BackBounds

        ///<summary>
        /// Gets the scroll adjusted background bounds of the cell
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle BackBounds
        {
            get
            {
                if (_BoundsUpdateCount != SuperGrid.BoundsUpdateCount)
                    UpdateBoundingRects();

                return (_BackBounds);
            }
        }

        #endregion

        #region Bounds

        ///<summary>
        /// Gets the scroll adjusted bounds of the cell
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override Rectangle Bounds
        {
            get
            {
                if (_BoundsUpdateCount != SuperGrid.BoundsUpdateCount)
                    UpdateBoundingRects();

                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    CellRange cr = GetStateCellRange();

                    if (cr != null)
                        return (GetBounds(panel, cr.BackBounds));
                }

                return (_Bounds);
            }
        }

        #endregion

        #region BoundsRelative

        /// <summary>
        /// Gets or sets the relative bounds of the cell
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override Rectangle BoundsRelative
        {
            get { return (base.BoundsRelative); }

            internal set
            {
                base.BoundsRelative = value;

                _BoundsUpdateCount = 0;
            }
        }

        #endregion

        #region CellBounds

        ///<summary>
        /// Gets the clipped, scroll adjusted, bounding rectangle of the cell 
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle CellBounds
        {
            get
            {
                if (_BoundsUpdateCount != SuperGrid.BoundsUpdateCount)
                    UpdateBoundingRects();

                GridPanel panel = GridPanel;

                if (panel != null)
                    return (GetCellBounds(panel));

                return (Bounds);
            }
        }

        #endregion

        #region CellStyles

        /// <summary>
        /// Gets or sets the visual styles assigned to the cell
        /// </summary>
        [Category("Style")]
        [Description("Indicates the visual styles assigned to the cell.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public CellVisualStyles CellStyles
        {
            get
            {
                if (_Styles == null)
                {
                    _Styles = new CellVisualStyles();

                    StyleVisualChangeHandler(null, _Styles);
                }

                return (_Styles);
            }

            set
            {
                if (_Styles != value)
                {
                    CellVisualStyles oldValue = _Styles;

                    _Styles = value;

                    OnCellStyleChanged("CellVisualStyles", oldValue, value);

                    if (oldValue != null)
                        oldValue.Dispose();
                }
            }
        }

        private void OnCellStyleChanged(string property,
            CellVisualStyles oldValue, CellVisualStyles newValue)
        {
            StyleVisualChangeHandler(oldValue, newValue);

            OnPropertyChanged(property);
        }

        #endregion

        #region ColumnIndex

        /// <summary>
        /// Gets the associated Column index for the cell
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int ColumnIndex
        {
            get { return (_ColumnIndex); }
            internal set { _ColumnIndex = value; }
        }

        #endregion

        #region ContentBounds

        ///<summary>
        /// Gets the scroll adjusted, content only, bounding rectangle of the cell 
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle ContentBounds
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                    return (GetContentBounds(panel));

                return (Rectangle.Empty);
            }
        }

        #endregion

        #region EditBounds

        ///<summary>
        /// Gets the clipped, scroll adjusted, edit bounding rectangle of the cell 
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle EditBounds
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                    return (GetEditBounds(panel));

                return (Rectangle.Empty);
            }
        }

        #endregion

        #region EditControl

        ///<summary>
        /// Gets the Edit Control used for the cell. The cell level
        /// edit control is a non-shared control, created and based
        /// upon the cell level EditorType and EditorParams properties.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public IGridCellEditControl EditControl
        {
            get
            {
                if (_EditorInfo == null || _EditorInfo.EditorType == null)
                    return (null);

                if (_EditorInfo.EditControl == null)
                    EditControl = GetEditControl(_EditorInfo.EditorType, _EditorInfo.EditorParams);

                return (_EditorInfo.EditControl);
            }

            internal set
            {
                if (_EditorInfo == null)
                    _EditorInfo = new EditorInfo();

                if (_EditorInfo.EditControl != value)
                {
                    if (_EditorInfo.EditControl != null)
                    {
                        if (_EditorInfo.EditControl.EditorPanel.Parent != null)
                            SuperGrid.Controls.Remove(_EditorInfo.EditControl.EditorPanel);

                        _EditorInfo.EditControl.EditorCellBitmap = null;

                        if (_EditorInfo.EditorType != null)
                            ((Control)_EditorInfo.EditControl).Dispose();
                    }

                    _EditorInfo.EditControl = value;

                    if (_EditorInfo.EditControl != null)
                    {
                        if (_EditorInfo.EditControl.EditorPanel.Parent == null)
                            SuperGrid.Controls.Add(_EditorInfo.EditControl.EditorPanel);
                    }
                }
            }
        }

        #endregion

        #region EditorDirty

        ///<summary>
        /// Gets or sets whether the value
        /// being edited has been changed in the editor 
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool EditorDirty
        {
            get { return (GridRow.EditorDirty); }

            set
            {
                GridRow.EditorDirty = value;

                // If it is a non-modal edit event then we want the
                // editor's dirty state to be cleared immediately.

                if (SuperGrid.EditorActive == false)
                    GridRow.EditorDirty = false;
            }
        }

        #endregion

        #region EditorParams

        /// <summary>
        /// Gets or sets an array of arguments that match in number,
        /// order, and type the parameters of the EditControl constructor
        /// to invoke. If empty or null, the default constructor is invoked.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object[] EditorParams
        {
            get
            {
                if (_EditorInfo == null)
                    return (null);

                return (_EditorInfo.EditorParams);
            }

            set
            {
                if (_EditorInfo == null)
                    _EditorInfo = new EditorInfo();

                if (IsSameParams(_EditorInfo.EditorParams, value) == false)
                {
                    _EditorInfo.EditorParams = value;

                    EditControl = null;
                    RenderControl = null;

                    NeedsMeasured = true;

                    OnPropertyChangedEx("EditorParams", VisualChangeType.Layout);
                }
                                    
                if (_EditorInfo.IsEmpty == true)
                    _EditorInfo = null;
            }
        }

        #region IsSameParams

        private bool IsSameParams(object[] p1, object[] p2)
        {
            if (p1 == null || p2 == null)
                return (p1 == p2);

            if (p1.Length != p2.Length)
                return (false);

            for (int i = 0; i < p1.Length; i++)
            {
                if (p1[i] != p2[i])
                    return (false);
            }

            return (true);
        }

        #endregion

        #endregion

        #region EditorType

        ///<summary>
        /// Indicates the cell editor type. This is the control type
        /// used to perform the actual modification of the cell value
        ///</summary>
        [DefaultValue(null), Category("Data")]
        [Description("Indicates the cell editor type. This is the control type used to perform the actual modification of the cell value.")]
        [TypeConverter(typeof(EditTypeConverter))]
        [Editor("DevComponents.SuperGrid.Design.EditTypeEditor, DevComponents.SuperGrid.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=26d81176cfa2b486", typeof(UITypeEditor))]
        public Type EditorType
        {
            get
            {
                if (_EditorInfo == null)
                    return (null);

                return (_EditorInfo.EditorType);
            }

            set
            {
                if (value != null || _EditorInfo != null)
                {
                    if (_EditorInfo == null)
                        _EditorInfo = new EditorInfo();

                    if (_EditorInfo.EditorType != value)
                    {
                        _EditorInfo.EditorType = value;
                        _EditorInfo.EditControl = null;
                        _EditorInfo.RenderControl = null;

                        NeedsMeasured = true;

                        OnPropertyChangedEx("EditorType", VisualChangeType.Layout);
                    }

                    if (_EditorInfo.IsEmpty == true)
                        _EditorInfo = null;
                }
            }
        }

        #endregion

        #region ExpValue

        ///<summary>
        /// Gets the last evaluated expression value for the cell.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object ExpValue
        {
            get { return (_ExpValue); }
        }

        #endregion

        #region FormattedValue

        /// <summary>
        /// Gets the associated Formatted Value for the cell
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string FormattedValue
        {
            get { return (GetFormattedValue()); }
        }

        #endregion

        #region GridColumn

        /// <summary>
        /// Gets the GridColumn associated with the cell
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public GridColumn GridColumn
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel == null && GridRow != null)
                    panel = GridRow.AllocPanel;

                if (panel != null)
                {
                    if (_ColumnIndex < panel.Columns.Count)
                        return (panel.Columns[_ColumnIndex]);
                }

                return (null);
            }
        }

        #endregion

        #region GridRow

        ///<summary>
        /// Gets the GridRow associated with the cell.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public GridRow GridRow
        {
            get { return (Parent as GridRow); }
        }

        #endregion

        #region HighLightBounds

        ///<summary>
        /// Gets the scroll adjusted, bounding rectangle used
        /// to highlight the cell contents when selected.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle HighLightBounds
        {
            get
            {
                Rectangle r = Rectangle.Empty;
                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    switch (GetCellHighlightMode(panel))
                    {
                        case CellHighlightMode.Content:
                            IGridCellEditControl editor = GetInternalRenderControl();

                            r = GetAdjustedBounds(ContentBounds);
                            r = GetEditPanelBounds(editor, r);

                            r.Inflate(1, 1);
                            break;

                        case CellHighlightMode.Partial:
                            r = GetAdjustedBounds(ContentBounds);
                            r.Inflate(1, 1);
                            break;

                        case CellHighlightMode.Full:
                            r = GetAdjustedBounds();

                            Rectangle t = SViewRect;

                            if (t.X == 0 && r.X == 0)
                            {
                                r.X += Dpi.Width1;
                                r.Width -= Dpi.Width1;
                            }
                            break;
                    }
                }

                return (r);
            }
        }

        #endregion

        #region InfoImage

        /// <summary>
        /// Gets or sets the cell informational Image (the image
        /// to display when InfoText is non-empty)
        /// </summary>
        [DefaultValue(null), Category("Appearance")]
        [Description("Indicates the cell informational Image (the image to display when InfoText is non-empty).")]
        public Image InfoImage
        {
            get { return (_InfoImage); }

            set
            {
                if (_InfoImage != value)
                {
                    _InfoImage = value;

                    OnPropertyChangedEx("InfoImage", VisualChangeType.Render);
                }
            }
        }

        #region GetInfoImage

        internal Image GetInfoImage()
        {
            return (_InfoImage ?? GridColumn.GetInfoImage());
        }

        #endregion

        #endregion

        #region InfoImageBounds

        ///<summary>
        /// Gets the scroll adjusted, bounding
        /// rectangle for the current set info image
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle InfoImageBounds
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    Image image = GetInfoImage();

                    if (image != null)
                    {
                        if (ShowInfoCellImage(panel) == true)
                        {
                            Rectangle r = GetAdjustedBounds(ContentBounds);
                            r.Inflate(-2, -1);

                            Rectangle t = r;

                            switch (GridColumn.InfoImageAlignment)
                            {
                                case Alignment.TopCenter:
                                    r.X += (r.Width - image.Width) / 2;
                                    break;

                                case Alignment.TopRight:
                                    r.X = (r.Right - image.Width);
                                    break;

                                case Alignment.MiddleLeft:
                                    if (GridColumn.InfoImageOverlay == false)
                                        r.X -= (image.Width + 4);

                                    r.Y += (r.Height - image.Height) / 2;
                                    break;

                                case Alignment.MiddleCenter:
                                    r.X += (r.Width - image.Width) / 2;
                                    r.Y += (r.Height - image.Height) / 2;
                                    break;

                                case Alignment.MiddleRight:
                                    r.X = (GridColumn.InfoImageOverlay == true)
                                        ? (r.Right - image.Width) : (r.Right + 4);

                                    r.Y += (r.Height - image.Height) / 2;
                                    break;

                                case Alignment.BottomLeft:
                                    r.Y = (r.Bottom - image.Height);
                                    break;

                                case Alignment.BottomCenter:
                                    r.X += (r.Width - image.Width) / 2;
                                    r.Y = (r.Bottom - image.Height);
                                    break;

                                case Alignment.BottomRight:
                                    r.X = (r.Right - image.Width);
                                    r.Y = (r.Bottom - image.Height);
                                    break;
                            }

                            if (r.Y < t.Y)
                                r.Y = t.Y;

                            r.Width = image.Width;
                            r.Height = image.Height;

                            return (r);
                        }
                    }
                }

                return (Rectangle.Empty);
            }
        }

        #endregion

        #region InfoText

        ///<summary>
        /// Gets or sets the informational text associated with
        /// the cell.  If the InfoText is non-null, then the cells
        /// associated InfoImage is displayed in the cell, with the
        /// InfoText being displayed as the ToolTip for the InfoImage.
        ///</summary>
        [DefaultValue(null), Category("Appearance")]
        [Description("Indicates the informational text associated with the cell. If the InfoText is non-null, then the cells associated InfoImage is displayed in the cell, with the InfoText being displayed as the ToolTip for the InfoImage.")]
        public string InfoText
        {
            get { return (_InfoText); }

            set
            {
                if (_InfoText != value)
                {
                    _InfoText = value;

                    UpdateInfoWindow();

                    OnPropertyChangedEx("InfoText", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region IsActiveCell

        ///<summary>
        /// Gets whether the cell is the Active cell.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsActiveCell
        {
            get
            {
                if (SuperGrid != null)
                    return (SuperGrid.ActiveCell == this);

                return(false);
            }
        }

        #endregion

        #region IsCellVisible

        ///<summary>
        /// Gets whether the cell is visible (taking row visibility,
        /// column visibility, and expanded row state into account).
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsCellVisible
        {
            get
            {
                if (BoundsRelative.Width > 0)
                {
                    GridRow row = GridRow;

                    if (row != null)
                    {
                        if (GridColumn.Visible == false)
                            return (false);

                        return (row.IsExpandedVisible);
                    }
                }

                return (false);
            }
        }

        #endregion

        #region IsDataError

        ///<summary>
        /// Gets whether setting the cell Value has caused a Data Error
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsDataError
        {
            get { return (TestState(Cs.DataError)); }
            internal set { SetState(Cs.DataError, value); }
        }

        #endregion

        #region IsEditorCell

        ///<summary>
        /// Gets whether the cell is the cell being edited.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsEditorCell
        {
            get
            {
                if (SuperGrid != null)
                    return (SuperGrid.EditorCell == this);

                return (false);
            }
        }

        #endregion

        #region IsEmptyCell

        ///<summary>
        /// Gets whether the cell is an Empty cell.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsEmptyCell
        {
            get { return (TestState(Cs.EmptyCell)); }
            internal set { SetState(Cs.EmptyCell, value); }
        }

        #endregion

        #region IsHFrozen

        ///<summary>
        /// Gets whether the cell is horizontally frozen
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsHFrozen
        {
            get
            {
                GridColumn column = GridColumn;

                if (column != null)
                    return (column.IsHFrozen);

                return (false);
            }
        }

        #endregion

        #region IsPrimaryCell

        ///<summary>
        /// Gets whether the cell is the defined PrimaryCell
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsPrimaryCell
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                    return (panel.PrimaryColumnIndex == _ColumnIndex);

                return (false);
            }
        }

        #endregion

        #region IsReadOnly

        ///<summary>
        /// Gets whether the cell is ReadOnly due to 
        /// row, column, or cell ReadOnly property status.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsReadOnly
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    if (panel.ReadOnly || GridColumn.ReadOnly || GridRow.ReadOnly)
                        return (true);
                }

                return (TestState(Cs.ReadOnly));
            }
        }

        #endregion

        #region IsSelectable

        ///<summary>
        /// Gets whether the cell is selectable due to
        /// row, column, or cell AllowSelection property status.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsSelectable
        {
            get
            {
                return (AllowSelection == true &&
                    GridRow.AllowSelection == true &&
                    GridColumn.AllowSelection == true);
            }
        }

        #endregion

        #region IsSelected

        ///<summary>
        /// Gets or sets whether the cell is selected.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsSelected
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    if (AllowSelection == true && panel.AllowSelection == true)
                    {
                        if (_SelectionUpdateCount != panel.SelectionUpdateCount)
                        {
                            _SelectionUpdateCount = panel.SelectionUpdateCount;

                            AnySelected = false;

                            if (GridRow != null && GridColumn != null)
                            {
                                if (GridRow.IsSelected == true || GridColumn.IsSelected == true)
                                {
                                    AnySelected = true;
                                }
                                else
                                {
                                    CellRange cr = GetCellRange();

                                    if (cr != null && cr.Suspended == false)
                                    {
                                        AnySelected = cr.IsSelected(panel, RowContainer);
                                    }
                                    else
                                    {
                                        if (GridRow.ExpandedVisible(panel) == true)
                                            Selected = panel.IsItemSelectedEx(this);

                                        AnySelected = Selected;
                                    }
                                }
                            }
                        }

                        return (AnySelected);
                    }
                }

                return (false);
            }

            set
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    if (Selected != value)
                    {
                        Selected = value;

                        if (GridRow != null)
                        {
                            if (GridRow.ExpandedVisible(panel) == true)
                                panel.SetSelectedEx(this, value);

                            if (value == true)
                            {
                                AnySelected = true;

                                _SelectionUpdateCount = panel.SelectionUpdateCount;
                            }

                            InvalidateRender();
                        }
                    }
                }
            }
        }

        #endregion

        #region IsValueExpression

        ///<summary>
        /// Gets whether the cell Value is an expression.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsValueExpression
        {
            get { return (TestState(Cs.ValueExpression)); }
            internal set { SetState(Cs.ValueExpression, value); }
        }

        #endregion

        #region IsValueNull

        ///<summary>
        /// Gets whether the cell Value is null.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsValueNull
        {
            get
            {
                object value = Value;

                return (((GridPanel != null && GridPanel.NullValue == NullValue.DBNull)
                    ? DBNull.Value : null) == value);
            }
        }

        #endregion

        #region Merged

        ///<summary>
        ///Gets whether the cell is merged
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool Merged
        {
            get { return (TestState(Cs.Merged)); }

            internal set
            {
                if (value != Merged)
                {
                    SetState(Cs.Merged, value);

                    ClearEffectiveStyles();

                    if (value == true && _mouseDownHitCell == this)
                        DoRendererMouseLeave(EventArgs.Empty);
                }
            }
        }

        #endregion

        #region MergedBottom

        ///<summary>
        ///Gets or sets whether the cell is Merged at the Bottom
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool MergedBottom
        {
            get { return (TestState(Cs.MergedBottom)); }
            set { SetState(Cs.MergedBottom, value); }
        }

        #endregion

        #region MergedLeft

        ///<summary>
        ///Gets or sets whether the cell is Merged to the Left
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool MergedLeft
        {
            get { return (TestState(Cs.MergedLeft)); }
            set { SetState(Cs.MergedLeft, value); }
        }

        #endregion

        #region MergedRight

        ///<summary>
        ///Gets or sets whether the cell is Merged to the Right
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool MergedRight
        {
            get { return (TestState(Cs.MergedRight)); }
            set { SetState(Cs.MergedRight, value); }
        }

        #endregion

        #region MergedTop

        ///<summary>
        ///Gets or sets whether the cell is Merged at the Top
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool MergedTop
        {
            get { return (TestState(Cs.MergedTop)); }
            set { SetState(Cs.MergedTop, value); }
        }

        #endregion

        #region MergeSuspended

        ///<summary>
        ///Gets whether the cell is merged and suspended.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool MergeSuspended
        {
            get
            {
                CellRange cr = GetCellRange();

                return (cr != null && cr.Suspended == true);
            }
        }

        #endregion

        #region NullString

        /// <summary>
        /// Gets how null values are displayed 
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string NullString
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                    return (GridColumn.NullString ?? panel.NullString);

                return (String.Empty);
            }
        }

        #endregion

        #region ReadOnly

        /// <summary>
        /// Gets or sets whether the user can change cell contents
        /// </summary>
        [DefaultValue(false), Category("Behavior")]
        [Description("Indicates whether the user can change cell contents.")]
        public bool ReadOnly
        {
            get { return (TestState(Cs.ReadOnly)); }

            set
            {
                if (value != ReadOnly)
                {
                    SetState(Cs.ReadOnly, value);

                    OnPropertyChangedEx("ReadOnly", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region RenderControl

        ///<summary>
        /// Gets the current set Render Control for the cell
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public IGridCellEditControl RenderControl
        {
            get
            {                    
                if (_EditorInfo == null ||
                    (_EditorInfo.RenderType == null && _EditorInfo.EditorType == null))
                {
                    return (null);
                }

                if (_EditorInfo.RenderControl == null)
                {
                    RenderControl = (_EditorInfo.RenderType != null)
                                        ? GetEditControl(_EditorInfo.RenderType, _EditorInfo.RenderParams)
                                        : GetEditControl(_EditorInfo.EditorType, _EditorInfo.EditorParams);
                }

                return (_EditorInfo.RenderControl);
            }

            internal set
            {
                if (_EditorInfo == null)
                    _EditorInfo = new EditorInfo();

                if (_EditorInfo.RenderControl != value)
                {
                    if (_EditorInfo.RenderControl != null)
                    {
                        if (_EditorInfo.RenderControl.EditorPanel.Parent != null)
                            SuperGrid.Controls.Remove(_EditorInfo.RenderControl.EditorPanel);

                        _EditorInfo.RenderControl.EditorCellBitmap = null;

                        if (_EditorInfo.RenderType != null || _EditorInfo.EditorType != null)
                            ((Control)_EditorInfo.RenderControl).Dispose();
                    }

                    _EditorInfo.RenderControl = value;

                    if (_EditorInfo.RenderControl != null)
                    {
                        if (_EditorInfo.RenderControl.EditorPanel.Parent == null)
                            SuperGrid.Controls.Add(_EditorInfo.RenderControl.EditorPanel);
                    }
                }
            }
        }

        #endregion

        #region RenderParams

        /// <summary>
        /// Gets or sets an array of arguments that match in number,
        /// order, and type the parameters of the RenderControl constructor
        /// to invoke. If empty or null, the default constructor is invoked.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object[] RenderParams
        {
            get
            {
                if (_EditorInfo == null)
                    return (null);

                return (_EditorInfo.RenderParams);
            }

            set
            {
                if (_EditorInfo == null)
                    _EditorInfo = new EditorInfo();

                if (IsSameParams(_EditorInfo.RenderParams, value) == false)
                {
                    _EditorInfo.RenderParams = value;

                    RenderControl = null;

                    NeedsMeasured = true;

                    OnPropertyChangedEx("RenderParams", VisualChangeType.Layout);
                }

                if (_EditorInfo.IsEmpty == true)
                    _EditorInfo = null;
            }
        }

        #endregion

        #region RenderType

        ///<summary>
        /// Gets or sets the cell render type. This is the control
        /// type used to perform the default rendering of the cell value
        ///</summary>
        [DefaultValue(null), Category("Data")]
        [Description("Indicates the cell render type. This is the control type used to perform the default rendering of the cell value.")]
        [TypeConverter(typeof(EditTypeConverter))]
        [Editor("DevComponents.SuperGrid.Design.EditTypeEditor, DevComponents.SuperGrid.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=26d81176cfa2b486", typeof(UITypeEditor))]
        public Type RenderType
        {
            get
            {
                if (_EditorInfo == null)
                    return (null);

                return (_EditorInfo.RenderType);
            }

            set
            {
                if (value != null || _EditorInfo != null)
                {
                    if (_EditorInfo == null)
                        _EditorInfo = new EditorInfo();

                    if (_EditorInfo.RenderType != value)
                    {
                        _EditorInfo.RenderType = value;
                        _EditorInfo.RenderControl = null;

                        NeedsMeasured = true;

                        OnPropertyChangedEx("RenderType", VisualChangeType.Layout);
                    }

                    if (_EditorInfo.IsEmpty == true)
                        _EditorInfo = null;
                }
            }
        }

        #endregion

        #region RowIndex

        /// <summary>
        /// Gets the associated Row index for the cell
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int RowIndex
        {
            get
            {
                GridRow row = GridRow;

                return (row != null ? row.RowIndex : -1);
            }
        }

        #endregion

        #region UnMergedBounds

        ///<summary>
        /// Gets the scroll adjusted un-merged bounds of the cell
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle UnMergedBounds
        {
            get
            {
                if (_BoundsUpdateCount != SuperGrid.BoundsUpdateCount)
                    UpdateBoundingRects();

                return (_Bounds);
            }
        }

        #endregion

        #region Value

        /// <summary>
        /// Gets or sets the cell value
        /// </summary>
        [DefaultValue(null), Category("Data")]
        [Description("Indicates the cell value.")]
        [TypeConverter(typeof(ValueTypeConverter))]
        [Editor("DevComponents.SuperGrid.Design.ValueTypeEditor, DevComponents.SuperGrid.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=26d81176cfa2b486", typeof(UITypeEditor))]
        public object Value
        {
            get
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    object o = GetValue(panel);

                    if (SuperGrid != null)
                        SuperGrid.DoGetCellValueEvent(this, ref o);

                    return (o);
                }

                return (_Value);
            }

            set
            {
                if ((value != null && value.Equals(_Value) == false) ||
                    (value == null && _Value != null))
                {
                    object oldValue = _Value;

                    SetValue(value);

                    GridRow row = GridRow;

                    if (row != null && row.Loading == false)
                        OnValueChanged(oldValue, value, DataContext.CellEdit);
                }
            }
        }

        #region GetValue

        /// <summary>
        /// GetValue
        /// </summary>
        /// <param name="panel"></param>
        /// <returns></returns>
        protected virtual object GetValue(GridPanel panel)
        {
            if (panel.DataSource != null)
            {
                if (ActiveIList(panel) == true ||
                    _DataResetCount != panel.DataBinder.DataResetCount)
                {
                    _DataResetCount = panel.DataBinder.DataResetCount;

                    object o = panel.DataBinder.GetValue(this, _Value);

                    if ((o == null && o != _Value) ||
                        (o != null && o.Equals(_Value) == false))
                    {
                        _Value = o;

                        GridColumn.NeedsFilterScan = true;

                        InvalidateRender();

                        return (o);
                    }
                }
            }

            return (_Value);
        }

        #region ActiveIList

        private bool ActiveIList(GridPanel panel)
        {
            if (panel.DataSource is IList &&
                (panel.DataSource is IListSource == false &&
                 panel.DataSource is IBindingList == false))
            {
                GridRow row = GridRow;

                if (row != null)
                {
                    if (panel.LatentActiveRowIndex < 0 && row.IsTempInsertRow == false)
                        return (true);
                }
            }

            return (false);
        }

        #endregion

        #endregion

        #region SetValue

        /// <summary>
        /// SetValue
        /// </summary>
        /// <param name="value"></param>
        protected virtual void SetValue(object value)
        {
            _Value = value;

            GridPanel panel = GridPanel;

            if (panel != null)
            {
                GridRow row = GridRow;

                if (row.Loading == false && IsLoading() == false)
                {
                    GridColumn column = GridColumn;

                    panel.DataBinder.SetValue(this, value);

                    row.RowNeedsStored = true;
                    column.NeedsFilterScan = true;

                    if (column.IsGroupColumn == true)
                    {
                        if (row == panel.ActiveRow)
                            row.RowNeedsGrouped = true;
                        else
                            panel.NeedsGrouped = true;
                    }

                    if (panel.KeepRowsSorted == true)
                    {
                        if (column.IsSortColumn == true)
                        {
                            if (row.IsTempInsertRow == false)
                            {
                                if (row == panel.ActiveRow)
                                    row.RowNeedsSorted = true;
                                else
                                    panel.NeedsSorted = true;
                            }
                        }
                    }
                }
            }
        }

        private bool IsLoading()
        {
            SuperGridControl sg = SuperGrid;

            return (sg == null || sg.Parent == null);
        }

        #endregion

        #region OnValueChanged

        private void OnValueChanged(object oldValue, object newValue, DataContext context)
        {
            NeedsMeasured = true;

            IsDataError = false;

            ClearEffectiveStyles();

            if (GridRow.Loading == false)
                RefreshCellEditor();

            OnPropertyChanged("Value");

            GridPanel panel = GridPanel;

            if (panel != null)
            {
                SuperGrid.DoCellValueChangedEvent(this, oldValue, newValue, context);

                if (panel.EnableCellExpressions == true)
                {
                    if (GridRow.Loading == false)
                        UpdateCellExp(panel, oldValue, newValue);
                }

                UpdateMerge(panel);
            }
        }

        #region RefreshCellEditor

        private void RefreshCellEditor()
        {
            if (SuperGrid != null)
            {
                IGridCellEditControl editor = GetInternalEditControl(true);

                if (editor != null)
                {
                    if (SuperGrid.NonModalEditorCell == this)
                        RefreshNonModalEditor();

                    else if (SuperGrid.EditorCell == this)
                        RefreshEditor(editor);

                    switch (editor.ValueChangeBehavior)
                    {
                        case ValueChangeBehavior.InvalidateLayout:
                            GridColumn.NeedsResized = true;
                            GridRow.NeedsMeasured = true;

                            InvalidateLayout();
                            break;

                        default:
                            InvalidateRender();
                            break;
                    }
                }
            }
        }

        #region RefreshEditor

        private void RefreshEditor(IGridCellEditControl editor)
        {
            editor.SuspendUpdate = true;

            try
            {
                CellVisualStyle style = GetEffectiveStyle();

                editor.InitializeContext(this, style);
            }
            finally
            {
                editor.SuspendUpdate = false;
            }
        }

        #endregion

        #region RefreshNonModalEditor

        private void RefreshNonModalEditor()
        {
            if (SuperGrid.ActiveNonModalEditor != null)
            {
                SuperGrid.ActiveNonModalEditor.EditorValue = _Value;

                CellVisualStyle style = GetEffectiveStyle();

                InitializeContext(DataContext.CellValueLoad,
                    SuperGrid.ActiveNonModalEditor, style);
            }
        }

        #endregion

        #endregion

        #region UpdateMerge

        private void UpdateMerge(GridPanel panel)
        {
            CellRange cr = GetCellRange();

            if (cr != null && cr.Suspended == true)
            {
                Modified = true;
                cr.Modified = true;
            }
            else
            {
                if (CellCanMerge(panel) == true)
                {
                    MergeUpdateCount--;

                    if (RowContainer.IsMergeSuspended == true)
                        RowContainer.MergeUpdateCount++;

                    RowContainer.NeedMergeLayout = true;

                    RowContainer.InvalidateLayout();
                }
            }
        }

        #region CellCanMerge

        private bool CellCanMerge(GridPanel panel)
        {
            if (panel != null && panel.EnableCellMerging == true)
            {
                CellMergeMode cMode = GridColumn.CellMergeMode;

                if (cMode == CellMergeMode.NotSet)
                    cMode = panel.CellMergeMode;

                return (cMode != CellMergeMode.None);
            }

            return (false);
        }

        #endregion

        #endregion

        #endregion

        #region UpdateCellExp

        internal void UpdateCellExp(
            GridPanel panel, object oldValue, object value)
        {
            string oldExp = oldValue as string;
            string newExp = value as string;

            if (oldExp != null)
            {
                oldExp = oldExp.Trim();

                if (oldExp.StartsWith("="))
                {
                    panel.ExpDictionary.Remove(this);

                    InfoText = null;
                }
            }

            IsValueExpression = false;

            if (newExp != null)
            {
                newExp = newExp.Trim();

                if (newExp.StartsWith("="))
                    SetCellExp(panel, newExp);
            }

            RefreshExpressions(panel, this, new List<GridCell>());
        }

        #region RefreshExpressions

        private void RefreshExpressions(
            GridPanel panel, GridCell gridCell, List<GridCell> usedCells)
        {
            foreach (KeyValuePair<GridCell, EEval> item in panel.ExpDictionary)
            {
                List<GridCell> cells = item.Value.GetCellReferences();

                if (cells != null)
                {
                    if (cells.Contains(gridCell) == true)
                    {
                        item.Key.InvalidateRender();

                        if (usedCells.Contains(item.Key) == false)
                        {
                            usedCells.Add(item.Key);

                            RefreshExpressions(panel, item.Key, usedCells);

                            usedCells.Remove(item.Key);
                        }
                    }
                }
            }
        }

        #endregion

        #region SetCellExp

        internal void SetCellExp(GridPanel panel, string newExp)
        {
            if (panel.EnableCellExpressions == true)
            {
                IsValueExpression = false;

                while (true)
                {
                    try
                    {
                        EEval eval = new EEval(this, newExp);

                        panel.ExpDictionary[this] = eval;

                        InfoText = null;
                        IsValueExpression = true;

                        break;
                    }
                    catch (Exception exp)
                    {
                        bool retry = false;
                        bool throwException = false;

                        if (SuperGrid.HasDataErrorHandler == true)
                        {
                            object value = newExp;

                            if (SuperGrid.DoDataErrorEvent(GridPanel, this, exp,
                                DataContext.CellExpressionParse, ref value, ref throwException, ref retry) == true)
                            {
                                return;
                            }
                        }

                        if (throwException == true)
                            throw;

                        InfoText = exp.Message;

                        if (retry == false)
                            break;
                    }
                }
            }
        }

        #endregion

        #endregion

        #endregion

        #endregion

        #region TestState

        private bool TestState(Cs state)
        {
            return ((_States & state) == state);
        }

        #endregion

        #region SetState

        private void SetState(Cs state, bool value)
        {
            if (value == true)
                _States |= state;
            else
                _States &= ~state;
        }

        #endregion

        #region MeasureOverride

        //private int _MeasureCount;

        /// <summary>
        /// Performs the layout of the item and sets
        /// the Size property to size that item will take.
        /// </summary>
        /// <param name="layoutInfo">Layout information.</param>
        /// <param name="stateInfo"></param>
        /// <param name="constraintSize"></param>
        protected override void MeasureOverride(
            GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize)
        {
           //_MeasureCount++;

            MeasureCell(layoutInfo.Graphics,
                stateInfo.GridPanel, stateInfo.IndentLevel, constraintSize);
        }

        #region MeasureCell

        private void MeasureCell(Graphics g,
            GridPanel panel, int indentLevel, Size constraintSize)
        {
            Size sizeNeeded = Size.Empty;

            if (ColumnIndex < panel.Columns.Count)
            {
                CellVisualStyle style = GetSizingStyle(panel);
                Size imageSize = style.GetFigureSize(panel);

                Alignment imageAlignment = style.ImageAlignment;

                if (style.IsOverlayImage == true)
                    imageAlignment = Alignment.MiddleCenter;

                int width = constraintSize.Width;

                Size borderSize = style.GetBorderSize(true);

                int bwidth = borderSize.Width + Dpi.Width2;
                int bheight = borderSize.Height + Dpi.Height2;

                if (constraintSize.Width > 1)
                {
                    switch (imageAlignment)
                    {
                        case Alignment.TopCenter:
                        case Alignment.MiddleCenter:
                        case Alignment.BottomCenter:
                            break;

                        default:
                            width -= imageSize.Width;
                            break;
                    }

                    width -= bwidth;

                    if (BoundsRelative.X == GridPanel.Bounds.X)
                        width -= Dpi.Width1;
                }

                _ContentSize =
                    GetProposedSize(g, style, new Size(width, 0));

                switch (imageAlignment)
                {
                    case Alignment.MiddleCenter:
                        sizeNeeded.Height = Math.Max(imageSize.Height, _ContentSize.Height) + bheight;
                        sizeNeeded.Width = Math.Max(_ContentSize.Width, imageSize.Width) + bwidth;
                        break;

                    case Alignment.TopCenter:
                    case Alignment.BottomCenter:
                        sizeNeeded.Width = Math.Max(_ContentSize.Width, imageSize.Width) + bwidth;
                        sizeNeeded.Height = _ContentSize.Height + imageSize.Height + bheight;
                        break;

                    default:
                        sizeNeeded.Width = _ContentSize.Width + imageSize.Width + bwidth;
                        sizeNeeded.Height = Math.Max(imageSize.Height, _ContentSize.Height) + bheight;
                        break;
                }

                if (panel.GroupColumns.Count > 0)
                {
                    if (panel.Columns.FirstVisibleColumn == GridColumn)
                        sizeNeeded.Width += Dpi.Width(panel.LevelIndentSize.Width * (indentLevel + 1));
                }

                if (GridRow != null &&
                    (GridRow.Rows.Count > 0 || GridRow.RowsUnresolved == true))
                {
                    if (panel.ExpandImage != null)
                    {
                        sizeNeeded.Height = Math.Max(sizeNeeded.Height,
                            Dpi.Height(panel.ExpandImage.Height + 4));
                    }

                    if (panel.CollapseImage != null)
                    {
                        sizeNeeded.Height = Math.Max(sizeNeeded.Height,
                            Dpi.Height(panel.CollapseImage.Height + 4));
                    }
                }

                if (panel.CheckBoxes == true)
                {
                    sizeNeeded.Height = Math.Max(sizeNeeded.Height,
                        Dpi.Height(panel.CheckBoxSize.Height));

                    sizeNeeded.Width += Dpi.Width(CheckBoxSpacing * 2);
                }
            }

            sizeNeeded.Width += Dpi.Width3;
            sizeNeeded.Height += Dpi.Width3;

            if (constraintSize.Width > 0)
                sizeNeeded.Width = constraintSize.Width;

            _MeasuredSize = sizeNeeded;

            Size = sizeNeeded;
        }

        #endregion

        #endregion

        #region ArrangeOverride

        /// <summary>
        /// Performs the arrange pass layout of the item
        /// when final position and size of the item has been set.
        /// </summary>
        /// <param name="layoutInfo">Layout information.</param>
        /// <param name="stateInfo"></param>
        /// <param name="layoutBounds"></param>
        protected override void ArrangeOverride(GridLayoutInfo layoutInfo,
            GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
        {
            GridPanel panel = stateInfo.GridPanel;
            Rectangle r = layoutBounds;

            r.X += _IndentLevel * Dpi.Width(panel.LevelIndentSize.Width);
            r.Width = panel.TreeButtonIndent;

            ArrangeExpandButton(panel, ref r);
            ArrangeCheckBox(panel, r);

            _toolTipText = null;
        }

        #region ArrangeExpandButton

        private void ArrangeExpandButton(GridPanel panel, ref Rectangle r)
        {
            if (IsPrimaryCell == true)
            {
                Rectangle t = Rectangle.Empty;

                if (panel.ShowTreeButtons == true)
                {
                    if (NeedsExpandButton() == true)
                    {
                        t = r;

                        Size size = panel.GetTreeButtonSize();

                        t.X += (r.Width - size.Width) / 2;
                        t.Y += (r.Height - size.Height) / 2 - 1;

                        t.Size = size;
                    }

                    int tbi = panel.TreeButtonIndent;

                    r.X += tbi;
                    r.Width -= tbi;
                }
                else
                {
                    if (panel.CheckBoxes == true)
                    {
                        int cbs = Dpi.Width(CheckBoxSpacing);

                        r.X += cbs;
                        r.Width -= cbs;
                    }
                }

                GridRow.ExpandButtonBounds = t;
            }
        }

        #region NeedsExpandButton

        private bool NeedsExpandButton()
        {
            GridRow row = GridRow;

            if (row != null)
            {
                if (row.ShowTreeButton == true)
                {
                    if (row.RowsUnresolved || row.HasVisibleItems)
                        return (true);
                }
            }

            return (false);
        }

        #endregion

        #endregion

        #region ArrangeCheckBox

        private void ArrangeCheckBox(GridPanel panel, Rectangle r)
        {
            if (IsPrimaryCell == true)
            {
                if (GridRow.HasCheckBox == true)
                {
                    Size cbSize = Dpi.Size(panel.CheckBoxSize);

                    int n = Math.Max(cbSize.Width, cbSize.Height);

                    r.Y += (r.Height - n) / 2;

                    r.Width = n;
                    r.Height = n;

                    GridRow.CheckBoxBounds = r;
                }
                else
                {
                    GridRow.CheckBoxBounds = Rectangle.Empty;
                }
            }
        }

        #endregion

        #endregion

        #region RenderOverride

        /// <summary>
        /// Performs drawing of the item and its children.
        /// </summary>
        /// <param name="renderInfo">Holds contextual rendering information.</param>
        protected override void RenderOverride(GridRenderInfo renderInfo)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                Graphics g = renderInfo.Graphics;

                CheckMeasure(panel, g);

                CellRange cr = GetStateCellRange();

                bool rendered = (cr != null && (cr.RenderCount == panel.RenderCount));

                Rectangle backBounds = (cr != null) ? cr.BackBounds : BackBounds;
                Rectangle bounds = GetBounds(panel, backBounds);

                if (backBounds.IntersectsWith(SuperGrid.ViewRectEx) == true)
                {
                    if (rendered == false)
                    {
                        CellHighlightMode mode = GetCellHighlightMode(panel);
                        CellVisualStyle style = GetEffectiveStyle();

                        RenderCellBackground(g, panel, backBounds, mode);
                        RenderGridBorder(g, panel, backBounds);

                        int n = RenderLevelData(g, panel);

                        Rectangle r = bounds;
                        r.X += n;
                        r.Width -= n;

                        RenderCellBorder(g, panel, r, style);
                        RenderImageAndValue(g, panel, bounds, mode, style);

                        if (this.IsDataError == true)
                            RenderDataError(g);

                        else if (GridRow.IsDeleted == true)
                            RenderDeleted(g);

                        RenderFocusRect(g, panel, cr, backBounds);

                        if (cr != null)
                            cr.RenderCount = panel.RenderCount;
                    }
                    else
                    {
                        RenderLevelData(g, panel);
                    }
                }
            }
        }

        #region CheckMeasure

        private void CheckMeasure(GridPanel panel, Graphics g)
        {
            if (NeedsMeasured == true)
            {
                NeedsMeasured = false;

                Size size = new Size(GridColumn.Size.Width, GridRow.Size.Height);

                if (panel.VirtualMode == false)
                    MeasureCell(g, panel, IndentLevel, size);

                size.Height = GridRow.FixedRowHeight;
                Size = size;

                UpdateBoundingRects();
            }
        }

        #endregion

        #region RenderCellBackground

        private void RenderCellBackground(Graphics g,
            GridPanel panel, Rectangle r, CellHighlightMode mode)
        {
            if (SuperGrid.DoPreRenderCellEvent(g, this, RenderParts.Background, r) == false)
            {
                RenderCellBackgroundEx(panel, g, r, mode);
                SuperGrid.DoPostRenderCellEvent(g, this, RenderParts.Background, r);
            }
        }

        #region RenderCellBackgroundEx

        private void RenderCellBackgroundEx(GridPanel panel,
            Graphics g, Rectangle r, CellHighlightMode type)
        {
            if (SuperGrid.EditorCell == this)
            {
                TextBox tb = GetInternalEditControl() as TextBox;

                if (tb != null)
                {
                    using (Brush br = new SolidBrush(tb.BackColor))
                        RenderBackground(g, r, type, br);

                    return;
                }
            }

            using (Brush br = GetContentBrush(panel, r, type))
                RenderBackground(g, r, type, br);
        }

        #region RenderBackground

        private void RenderBackground(
            Graphics g, Rectangle r, CellHighlightMode type, Brush br)
        {
            if (type == CellHighlightMode.Partial ||
                type == CellHighlightMode.Content)
            {
                r = RenderPartialBackground(g, r, type);
            }

            if (r.Width > 0 && r.Height > 0)
                g.FillRectangle(br, r);
        }

        #endregion

        #region RenderPartialBackground

        private Rectangle RenderPartialBackground(
            Graphics g, Rectangle r, CellHighlightMode type)
        {
            CellVisualStyle defaultStyle =
                GetEffectiveStyle(StyleType.Default);

            using (Brush br = defaultStyle.Background.GetBrush(r))
                g.FillRectangle(br, r);

            r = GetAdjustedBounds(ContentBounds);

            if (type == CellHighlightMode.Content)
            {
                IGridCellEditControl editor = GetInternalRenderControl();

                r = GetEditPanelBounds(editor, r);
            }

            r.Inflate(1, 1);

            return (r);
        }

        #endregion

        #region GetContentBrush

        private Brush GetContentBrush(
            GridPanel panel, Rectangle r, CellHighlightMode type)
        {
            if (IsEmptyCell == true && panel.AllowEmptyCellSelection == false)
            {
                CellVisualStyle style =
                    GetEffectiveStyle(StyleType.Empty);

                return (style.Background.GetBrush(r));
            }

            if (IsSelectable == false)
            {
                CellVisualStyle style =
                    GetEffectiveStyle(StyleType.NotSelectable);

                return (style.Background.GetBrush(r));
            }

            if (type == CellHighlightMode.None)
            {
                CellVisualStyle style =
                    GetEffectiveStyle(false);

                return (style.Background.GetBrush(r));
            }

            CellVisualStyle contentStyle = GetContentStyle(panel);

            return (contentStyle.Background.GetBrush(r));
        }

        #endregion

        #region GetContentStyle

        private CellVisualStyle GetContentStyle(GridPanel panel)
        {
            if (panel.SelectionGranularity == SelectionGranularity.Row)
            {
                StyleState cellState = StyleState.Default;

                if (IsReadOnly == true)
                    cellState |= StyleState.ReadOnly;

                Rectangle t = ViewRect;
                Rectangle r = GridRow.Bounds;

                CellRange cr = GetCellRange();

                if (cr != null)
                    r = Rectangle.Union(r, cr.BackBounds);

                r.Intersect(t);

                if (SuperGrid.ScrollBarScrolling == false)
                {
                    if (panel.RowHighlightType == RowHighlightType.Full)
                    {
                        if (GridRow.IsMouseOver == true)
                            cellState |= StyleState.MouseOver;
                    }
                    else
                    {
                        if (r.Contains(SuperGrid.PointToClient(Control.MousePosition)))
                            cellState |= StyleState.MouseOver;
                    }
                }

                if (IsSelected == true)
                    cellState |= StyleState.Selected;

                return (GetEffectiveStyle(cellState));
            }

            return (GetEffectiveStyle());
        }

        #endregion

        #region GetCellHighlightMode

        private CellHighlightMode GetCellHighlightMode(GridPanel panel)
        {
            if (panel.SelectionGranularity != SelectionGranularity.Cell)
            {
                switch (panel.RowHighlightType)
                {
                    case RowHighlightType.None:
                        return (CellHighlightMode.None);

                    case RowHighlightType.PrimaryColumnOnly:
                        return (IsPrimaryCell == true
                            ? CellHighlightMode.Full : CellHighlightMode.None);

                    default:
                        return (CellHighlightMode.Full);
                }
            }

            if (GridRow.IsSelected == true)
                return (CellHighlightMode.Full);

            return (GridColumn.CellHighlightMode);
        }

        #endregion

        #endregion

        #endregion

        #region RenderGridBorder

        private void RenderGridBorder(
            Graphics g, GridPanel panel, Rectangle r)
        {
            if (SuperGrid.DoPreRenderCellEvent(g, this, RenderParts.Border, r) == false)
            {
                RenderGridBorderEx(g, panel, r);
                SuperGrid.DoPostRenderCellEvent(g, this, RenderParts.Border, r);
            }
        }

        private void RenderGridBorderEx(
            Graphics g, GridPanel panel, Rectangle r)
        {
            if (panel.GridLines != GridLines.None)
            {
                GridPanelVisualStyle pstyle = panel.GetEffectiveStyle();

                if (panel.GridLines == GridLines.Both)
                    RenderBothGridBorders(g, pstyle, r);

                else if (panel.GridLines == GridLines.Vertical)
                    RenderVGridBorder(g, pstyle, r);

                else if (panel.GridLines == GridLines.Horizontal)
                    RenderHGridBorder(g, pstyle, r);
            }
        }

        #region RenderBothGridBorders

        private void RenderBothGridBorders(
            Graphics g, GridPanelVisualStyle pstyle, Rectangle r)
        {
            RenderHGridBorder(g, pstyle, r);
            RenderVGridBorder(g, pstyle, r);
        }

        #endregion

        #region RenderHGridBorder

        private void RenderHGridBorder(Graphics g, GridPanelVisualStyle pstyle, Rectangle r)
        {
            if (pstyle.HorizontalLinePattern != LinePattern.None &&
                pstyle.HorizontalLinePattern != LinePattern.NotSet)
            {
                using (Pen pen = new Pen(pstyle.HorizontalLineColor, Dpi.Height1))
                {
                    pen.DashStyle = (DashStyle)pstyle.HorizontalLinePattern;
                    pen.DashOffset = r.X % 2;

                    g.DrawLine(pen, r.X, r.Top - 1, r.Right - 1, r.Top - 1);
                    g.DrawLine(pen, r.X, r.Bottom - 1, r.Right - 1, r.Bottom - 1);
                }
            }
        }

        #endregion

        #region RenderVGridBorder

        private void RenderVGridBorder(Graphics g, GridPanelVisualStyle pstyle, Rectangle r)
        {
            if (pstyle.VerticalLinePattern != LinePattern.None &&
                pstyle.VerticalLinePattern != LinePattern.NotSet)
            {
                using (Pen pen = new Pen(pstyle.VerticalLineColor, Dpi.Width1))
                {
                    pen.DashStyle = (DashStyle)pstyle.VerticalLinePattern;
                    pen.DashOffset = r.Top % 2;

                    g.DrawLine(pen, r.Right - 1, r.Top, r.Right - 1, r.Bottom);
                }
            }
        }

        #endregion

        #endregion

        #region RenderLevelData

        private int RenderLevelData(Graphics g, GridPanel panel)
        {
            int n = 0;

            if (IsPrimaryCell == true)
            {
                Rectangle r = BackBounds;

                int x = r.X;

                RenderCellTreeData(g, panel, ref r);
                RenderCellCheckBox(g, panel, ref r);

                n = r.X - x;
            }
            else
            {
                if (panel.GroupColumns.Count > 0)
                {
                    if (panel.Columns.FirstVisibleColumn == GridColumn)
                        n = Dpi.Width(panel.LevelIndentSize.Width * _IndentLevel);
                }
            }

            return (n);
        }

        #region RenderCellTreeData

        private void RenderCellTreeData(
            Graphics g, GridPanel panel, ref Rectangle r)
        {
            int liw = Dpi.Width(panel.LevelIndentSize.Width);

            if (panel.ShowTreeButtons == true || panel.ShowTreeLines == true)
            {
                GridRow row = GridRow;
                Rectangle t = row.ExpandButtonBounds;

                if (row.IsVFrozen == false)
                    t.Y -= VScrollOffset;

                if (panel.IsSubPanel == true || GridColumn.IsHFrozen == false)
                    t.X -= HScrollOffset;

                bool hasExpandButton = (panel.ShowTreeButtons == true &&
                    row.ExpandButtonBounds.IsEmpty == false);

                int tbi = panel.TreeButtonIndent;

                if (panel.ShowTreeLines == true)
                {
                    Rectangle p = r;

                    p.Y--;
                    p.Height++;

                    TreeDisplay.RenderLines(g, 
                        panel, p, row, _IndentLevel, liw, tbi, hasExpandButton);
                }

                if (hasExpandButton == true)
                {
                    Point pt = Control.MousePosition;
                    pt = SuperGrid.PointToClient(pt);

                    bool hot = t.Contains(pt);

                    Image image = (row.Expanded == true)
                        ? panel.GetCollapseButton(g, hot) : panel.GetExpandButton(g, hot);

                    ExpandDisplay.RenderButton(g, image, t, r);
                }

                r.X += tbi;
                r.Width -= tbi;
            }

            int n = liw * _IndentLevel;

            r.X += n;
            r.Width -= n;
        }

        #endregion

        #region RenderCellCheckBox

        private void RenderCellCheckBox(
            Graphics g, GridPanel panel, ref Rectangle r)
        {
            if (GridRow.HasCheckBox == true)
            {
                Rectangle t = CheckBoxBounds;

                if (GridRow.IsVFrozen == false)
                    t.Y -= VScrollOffset;

                if (panel.IsSubPanel == true || GridColumn.IsHFrozen == false)
                    t.X -= HScrollOffset;

                Region clip = null;

                if (t.Right >= r.Right || t.Height >= r.Height)
                {
                    Rectangle z = r;
                    z.Width--;
                    z.Height--;

                    clip = g.Clip;
                    g.SetClip(z, CombineMode.Intersect);
                }

                if (GridRow.Checked == true)
                {
                    CheckDisplay.RenderCheckbox(g, t,
                        CheckBoxState.CheckedNormal, ButtonState.Checked);
                }
                else
                {
                    CheckDisplay.RenderCheckbox(g, t,
                        CheckBoxState.UncheckedNormal, ButtonState.Normal);
                }

                if (clip != null)
                    g.Clip = clip;

                r.X += panel.CheckBoxSize.Width + (CheckBoxSpacing * 2);
                r.Width -= (panel.CheckBoxSize.Width + (CheckBoxSpacing * 2));
            }
        }

        #endregion

        #endregion

        #region RenderCellBorder

        private void RenderCellBorder(Graphics g,
            GridPanel panel, Rectangle r, CellVisualStyle style)
        {
            if (SuperGrid.DoPreRenderCellEvent(g, this, RenderParts.Border, r) == false)
            {
                RenderCellBorderEx(g, panel, r, style);
                SuperGrid.DoPostRenderCellEvent(g, this, RenderParts.Border, r);
            }
        }

        #region RenderCellBorderEx

        private void RenderCellBorderEx(
            Graphics g, GridPanel panel, Rectangle r, CellVisualStyle style)
        {
            Rectangle t = GetBorderRect(panel, r, style);

            style.RenderBorder(g, t);
        }

        #region GetBorderRect

        private Rectangle GetBorderRect(
            GridPanel panel, Rectangle r, CellVisualStyle style)
        {
            r.X += Dpi.Width(style.Margin.Left);
            r.Width -= Dpi.Width(style.Margin.Horizontal);

            r.Y += Dpi.Height(style.Margin.Top);
            r.Height -= Dpi.Height(style.Margin.Vertical);

            if (panel.GridLines == GridLines.Horizontal || panel.GridLines == GridLines.Both)
                r.Height -= Dpi.Height1;

            if (panel.GridLines == GridLines.Vertical || panel.GridLines == GridLines.Both)
                r.Width -= Dpi.Width1;

            return (r);
        }

        #endregion

        #endregion

        #endregion

        #region RenderImageAndValue

        private void RenderImageAndValue(Graphics g,
            GridPanel panel, Rectangle bounds, CellHighlightMode mode, CellVisualStyle style)
        {
            Rectangle r = GetAdjustedBounds(GetContentBounds(panel, bounds));

            if (style.ImageOverlay != ImageOverlay.Top)
                RenderCellImage(g, panel, style, bounds, r, mode);

            if (CanRenderCellValue() == true)
            {
                if (SuperGrid.DoPreRenderCellEvent(g, this, RenderParts.Content, r) == false)
                {
                    RenderCellValue(g, style, r);
                    SuperGrid.DoPostRenderCellEvent(g, this, RenderParts.Content, r);
                }
            }
            else
            {
                if (SuperGrid.EditorCell == this && Visible == true && IsEmptyCell == false)
                    RenderCellInfo(g, panel);
            }

            if (style.ImageOverlay == ImageOverlay.Top)
                RenderCellImage(g, panel, style, bounds, r, mode);
        }

        #region RenderCellImage

        private void RenderCellImage(Graphics g, GridPanel panel,
            CellVisualStyle style, Rectangle bounds, Rectangle r, CellHighlightMode type)
        {
            object figure = style.GetFigure(panel);

            if (figure != null)
            {
                r = style.GetFigureBounds(panel, r);
                r.Intersect(bounds);

                if (r.Width > 0 && r.Height > 0)
                {
                    if (figure is Image)
                    {
                        if (CanHighlightCell(style, type) == true)
                            DrawHighlightImage(g, (Image)figure, style, r);
                        else
                            g.DrawImageUnscaledAndClipped((Image)figure, r);
                    }
                    else
                    {
                        SymbolDef sd = (SymbolDef)figure;

                        using (Brush br = new SolidBrush(sd.SymbolColor))
                            g.DrawString(sd.SymbolRealized, sd.SymbolFont, br, r);
                    }
                }
            }
        }

        #region CanHighlightCell

        private bool CanHighlightCell(
            CellVisualStyle style, CellHighlightMode type)
        {
            switch (style.ImageHighlightMode)
            {
                case ImageHighlightMode.Always:
                    return (true);

                case ImageHighlightMode.Never:
                    return (false);

                default:
                    if (IsSelected == false)
                        return (false);

                    return (type == CellHighlightMode.Content ||
                            type == CellHighlightMode.Partial);
            }
        }

        #endregion

        #region DrawHighlightImage

        private void DrawHighlightImage(Graphics g,
            Image image, CellVisualStyle style, Rectangle r)
        {
            Color color = GetSimpleColor(style);

            float[][] ptsArray =
            {
                new float[] {(float)color.R / 255, 0, 0, 0, 0},
                new float[] {0, (float)color.G / 255, 0, 0, 0},
                new float[] {0, 0, (float)color.B / 255, 0, 0},
                new float[] {0f, 0, 0, 1, 0},
                new float[] {.15f, .15f, .15f, 0, 1}
            };

            ColorMatrix clrMatrix = new ColorMatrix(ptsArray);
            ImageAttributes imgAttribs = new ImageAttributes();

            imgAttribs.SetColorMatrix(clrMatrix,
                ColorMatrixFlag.Default, ColorAdjustType.Default);

            g.DrawImage(image, r,
                0, 0, style.Image.Width, image.Height,
                GraphicsUnit.Pixel, imgAttribs);
        }

        #endregion

        #region GetSimpleColor

        private Color GetSimpleColor(CellVisualStyle style)
        {
            Color color1;
            Color color2;

            if (style.Background.BackColorBlend.Colors != null &&
                style.Background.BackColorBlend.Colors.Length > 0)
            {
                Color[] colors = style.Background.BackColorBlend.Colors;

                color1 = colors[0];
                color2 = colors[colors.Length - 1];
            }
            else
            {
                color1 = style.Background.Color1;
                color2 = style.Background.Color2;
            }

            if (color2.IsEmpty == true)
                return (color1);

            switch (style.Alignment)
            {
                case Alignment.TopLeft:
                case Alignment.TopCenter:
                case Alignment.TopRight:
                    return (color1);

                case Alignment.MiddleLeft:
                case Alignment.MiddleCenter:
                case Alignment.MiddleRight:
                    return (Color.FromArgb((color1.R + color2.R) / 2, (color1.G + color2.G) / 2, (color1.B + color2.B) / 2));

                default:
                    return (color2);
            }
        }

        #endregion

        #endregion

        #region CanRenderCellValue

        private bool CanRenderCellValue()
        {
            if (Visible == false || IsEmptyCell == true || SuperGrid.EditorCell == this)
                return (false);

            if (SuperGrid.NonModalEditorCell == this)
                return (false);

            return (true);
        }

        #endregion

        #region RenderCellValue

        //private int _RenderCount;

        private void RenderCellValue(
            Graphics g, CellVisualStyle style, Rectangle r)
        {
            if (r.Width > 0)
            {
                GridColumn column = GridColumn;

                if (column != null)
                {
                    IGridCellEditControl renderer;

                    if (SuperGrid.ActiveEditor != null ||
                        (MouseRenderer == null || MouseRenderer.EditorCell != this))
                    {
                        renderer = GetInternalRenderControl();
                    }
                    else
                    {
                        renderer = MouseRenderer;
                    }

                    if (renderer != null && ((Control)renderer).IsDisposed == false)
                    {
                        CellRender(g, style, renderer);

                        //using (StringFormat sf = new StringFormat())
                        //{
                        //    sf.Alignment = StringAlignment.Far;
                        //    sf.LineAlignment = StringAlignment.Far;
                        //    sf.Trimming = StringTrimming.EllipsisCharacter;

                        //    g.DrawString((++_RenderCount).ToString(),
                        //                 SystemFonts.DefaultFont, Brushes.Red, r, sf);

                        //    //sf.LineAlignment = StringAlignment.Near;

                        //    //g.DrawString((_MeasureCount).ToString(),
                        //    //             SystemFonts.DefaultFont, Brushes.Blue, r, sf);
                        //}
                    }
                }
            }
        }

        #endregion

        #endregion

        #region RenderDataError

        private void RenderDataError(Graphics g)
        {
            Rectangle r = Bounds;

            int w = Dpi.Width5;
            int h = Dpi.Width5;

            if (r.Width > w && r.Height > h)
                r.Inflate(-w, -h);

            using (SolidBrush br = new SolidBrush(Color.FromArgb(64, Color.Crimson)))
                g.FillRectangle(br, r);
        }

        #endregion

        #region RenderDeleted

        private void RenderDeleted(Graphics g)
        {
            using (SolidBrush br = new SolidBrush(Color.FromArgb(128, Color.LightGray)))
                g.FillRectangle(br, Bounds);
        }

        #endregion

        #region RenderFocusRect

        private void RenderFocusRect(Graphics g,
            GridPanel panel, CellRange cr, Rectangle backBounds)
        {
            if (panel.FocusCuesEnabled == true)
            {
                if (IsFocused() == true)
                {
                    if (panel.EnableCellMerging == true && IsFocusedRow(cr) == true)
                        RenderRowFocusRect(g, panel, backBounds, cr);

                    else if (IsFocusedCell(cr) == true)
                    {
                        Rectangle r;

                        if (cr != null)
                        {
                            r = backBounds;

                            if (r.X <= 0)
                            {
                                r.X++;
                                r.Width--;
                            }

                            r.Width -= Dpi.Width1;
                            r.Height -= Dpi.Height1;
                        }
                        else
                        {
                            r = HighLightBounds;
                        }

                        RenderCellFocusRect(g, r);
                    }
                }
            }
        }

        #region IsFocused

        private bool IsFocused()
        {
            if (IsDesignerHosted == true)
                return (false);

            return (SuperGrid.ContainsFocus == true);
        }

        #endregion

        #region IsFocusedRow

        private bool IsFocusedRow(CellRange cr)
        {
            if (SuperGrid.ActiveElement is GridRow)
            {
                GridRow arow = SuperGrid.ActiveElement as GridRow;

                if (cr == null)
                    return (arow == GridRow);

                if (arow.Parent == GridRow.Parent)
                    return (arow.RowIndex >= cr.RowStart && arow.RowIndex < cr.RowEnd);
            }

            return (false);
        }

        #endregion

        #region IsFocusedCell

        private bool IsFocusedCell(CellRange cr)
        {
            GridCell acell = SuperGrid.ActiveElement as GridCell;

            if (acell == null)
                return (false);

            if (cr != null)
                return (cr == acell.GetCellRange());

            return (IsSameCell(acell));
        }

        #region IsSameCell

        internal bool IsSameCell(GridCell cell)
        {
            if (cell != null)
            {
                return (ColumnIndex == cell.ColumnIndex &&
                    GridRow == cell.GridRow);
            }

            return (false);
        }

        #endregion

        #endregion

        #region RenderRowFocusRect

        private void RenderRowFocusRect(
            Graphics g, GridPanel panel, Rectangle r, CellRange cr)
        {
            if (IsEmptyCell == false)
            {
                SmoothingMode sm = g.SmoothingMode;
                g.SmoothingMode = SmoothingMode.None;

                Rectangle t = (IsVFrozen == true ? r : SViewRect);

                Rectangle lc = GetLeftCell(panel, t, cr);
                Rectangle rc = GetRightCell(panel, t, cr);

                if (lc.IsEmpty == true && rc.IsEmpty == true)
                {
                    RenderCellFocusRect(g, r);
                }
                else
                {
                    using (Pen pen = new Pen(Color.Black, 1))
                    {
                        pen.DashStyle = DashStyle.Dot;

                        r.Width -= Dpi.Width1 + 1;
                        r.Height -= Dpi.Height1 + 1;

                        r.Intersect(t);

                        RenderVertFocus(g, r, lc, rc, pen);
                        RenderHorzFocus(g, r, lc, rc, pen);
                    }
                }

                g.SmoothingMode = sm;
            }
        }

        #region RenderVertFocus

        private void RenderVertFocus(Graphics g,
            Rectangle r, Rectangle lc, Rectangle rc, Pen pen)
        {
            pen.DashOffset = (r.X % 2);

            if (lc.IsEmpty == false)
            {
                if (r.Width > 1)
                {
                    if (r.Y < lc.Y - pen.DashOffset)
                        g.DrawLine(pen, r.X, r.Y, r.X, lc.Y);

                    if (lc.Bottom < r.Bottom - pen.DashOffset)
                        g.DrawLine(pen, r.X, lc.Bottom, r.X, r.Bottom);
                }
            }
            else
            {
                if (r.Height > 1)
                    g.DrawLine(pen, r.X, r.Y, r.X, r.Bottom);
            }

            if (rc.IsEmpty == false)
            {
                if (r.Width > 1)
                {
                    if (r.Y < rc.Y - pen.DashOffset)
                        g.DrawLine(pen, r.Right, rc.Y, r.Right, r.Y);

                    if (rc.Bottom < r.Bottom - pen.DashOffset)
                        g.DrawLine(pen, r.Right, rc.Bottom, r.Right, r.Bottom);
                }
            }
            else
            {
                if (r.Height > 1)
                    g.DrawLine(pen, r.Right, r.Y, r.Right, r.Bottom);
            }
        }

        #endregion

        #region RenderHorzFocus

        private void RenderHorzFocus(Graphics g,
            Rectangle r, Rectangle lc, Rectangle rc, Pen pen)
        {
            if (r.Width > 1)
            {
                int x1 = 0;
                int x2 = 0;

                if (lc.IsEmpty == false)
                {
                    if (lc.Y <= r.Y)
                        x1 = r.X - lc.Right;
                }

                if (rc.IsEmpty == false)
                {
                    if (rc.Y <= r.Y)
                    {
                        if (rc.X > r.Right)
                            x2 = rc.X - r.Right + 1;
                    }
                }

                pen.DashOffset = ((r.X - x1) % 2);

                if (r.Right + x2 - (r.X - x1) >  pen.DashOffset)
                    g.DrawLine(pen, r.X - x1, r.Y, r.Right + x2, r.Y);

                x1 = 0;
                x2 = 0;

                if (lc.IsEmpty == false)
                {
                    if (lc.Bottom >= r.Bottom)
                    {
                        x1 = r.X - lc.Right;
                        x2 = x1 - 1;
                    }
                }

                if (rc.IsEmpty == false)
                {
                    if (rc.Bottom >= r.Bottom)
                    {
                        if (rc.X > r.Right)
                            x2 = rc.X - r.Right + 1;
                    }
                }

                pen.DashOffset = ((r.X - x1) % 2);

                if (r.Right + x2 - (r.X - x1) > pen.DashOffset)
                    g.DrawLine(pen, r.X - x1, r.Bottom, r.Right + x2, r.Bottom);
            }
        }

        #endregion

        #region GetLeftCell

        private Rectangle GetLeftCell(GridPanel panel, Rectangle t, CellRange cr)
        {
            GridColumnCollection columns = panel.Columns;

            GridColumn col = (cr != null)
                ? columns.GetPrevVisibleColumn(columns.ColumnAtDisplayIndex(cr.ColumnStart))
                : columns.GetPrevVisibleColumn(GridColumn);

            Rectangle r = GetCellRect(col);

            r.Width -= Dpi.Width1 + 1;
            r.Height -= Dpi.Height1 + 1;

            t.Intersect(r);

            return (t);
        }

        #endregion

        #region GetRightCell

        private Rectangle GetRightCell(GridPanel panel, Rectangle t, CellRange cr)
        {
            GridColumnCollection columns = panel.Columns;

            GridColumn col = (cr != null)
                ? columns.GetNextVisibleColumn(columns.ColumnAtDisplayIndex(cr.ColumnEnd - 1))
                : columns.GetNextVisibleColumn(GridColumn);

            while (col != null)
            {
                if (col.IsOnScreen == true)
                    break;

                col = columns.GetNextVisibleColumn(col);
            }

            Rectangle r = GetCellRect(col);

            r.Width -= Dpi.Width1 + 1;
            r.Height -= Dpi.Height1 + 1;

            t.Intersect(r);

            return (t);
        }

        #endregion

        #region GetCellRect

        private Rectangle GetCellRect(GridColumn col)
        {
            if (col != null)
            {
                GridRow arow = SuperGrid.ActiveElement as GridRow;

                if (arow != null)
                {
                    GridCell cell = arow.GetCell(col.ColumnIndex);

                    if (cell != null)
                    {
                        CellRange cr2 = cell.GetStateCellRange();

                        if (cr2 != null)
                            return (cr2.BackBounds);

                        return (cell.Bounds);
                    }
                }
            }

            return (Rectangle.Empty);
        }

        #endregion

        #endregion

        #region RenderCellFocusRect

        private void RenderCellFocusRect(Graphics g, Rectangle bounds)
        {
            SmoothingMode sm = g.SmoothingMode;
            g.SmoothingMode = SmoothingMode.None;

            ControlPaint.DrawFocusRectangle(g, bounds);

            g.SmoothingMode = sm;
        }

        #endregion

        #endregion

        #endregion

        #region GetCellRange

        ///<summary>
        ///Gets the CellRange, if any, that the cell is a member of.
        ///</summary>
        ///<returns>CellRange or null.</returns>
        public CellRange GetCellRange()
        {
            GridContainer cont = RowContainer;

            if (cont != null)
                return (cont.GetCellRange(this));

            return (null);
        }

        internal CellRange GetStateCellRange()
        {
            CellRange cr = GetCellRange();

            if (cr != null)
            {
                if (cr.Suspended == true)
                    cr = null;
            }

            Merged = (cr != null);

            return (cr);
        }

        #endregion

        #region SuspendMerge

        ///<summary>
        ///If the cell is currently participating in a merged range of
        ///cells, then the merge will be suspended until the user clicks
        ///away from the merged range (or ResumeMerge is called for the cell).
        ///</summary>
        ///<param name="activate">If true, cell will be made the active cell.</param>
        public bool SuspendMerge(bool activate)
        {
            CellRange cr = GetStateCellRange();

            if (cr != null)
                SuspendMerge(cr);

            if (cr == null || cr.Suspended == true)
            {
                if (activate == true)
                {
                    if (CanSetActiveCell(GridPanel) == true)
                    {
                        _needsMouseEnter = true;

                        SetActive(true);
                    }
                }

                return (true);
            }

            return (false);
        }

        internal void SuspendMerge(CellRange cr)
        {
            GridContainer cont = RowContainer;

            if (cont != null)
                cont.SuspendMerge(cr);
        }

        #endregion

        #region ResumeMerge

        ///<summary>
        ///Resumes the suspended merge where the cell is a participant
        ///</summary>
        public void ResumeMerge(GridCell aCell)
        {
            GridContainer cont = RowContainer;

            if (cont != null)
            {
                if (ShouldResumeMerge(cont, aCell) == true)
                    RowContainer.ResumeMerge();
            }
        }

        private bool ShouldResumeMerge(GridContainer cont, GridCell aCell)
        {
            if (aCell == null)
                return (true);

            GridContainer aCont = aCell.RowContainer;

            if (aCont != cont)
                return (true);
            
            CellRange cr = cont.SuspendedRange;

            if (cr != null)
            {
                if (cr.Equals(aCont.GetCellRange(aCell)) == true)
                    return (false);
            }

            return (true);
        }

        #endregion

        #region GetProposedSize

        private Size GetProposedSize(Graphics g, CellVisualStyle style, Size constraintSize)
        {
            return (GetProposedSize(g, style, constraintSize, null, CellSizingSource.ActualAndFormattedValues));
        }

        private Size GetProposedSize(Graphics g,
            CellVisualStyle style, Size constraintSize, IGridCellEditControl editor, CellSizingSource sizingSource)
        {
            Size size = Size.Empty;

            if (IsValueExpression == true && ExpValue != null)
            {
                size = GetModalSize(g, ExpValue.ToString(), style, constraintSize);
            }
            else
            {
                if (editor == null)
                {
                    if (CellEditMode != CellEditMode.Modal)
                    {
                        if (MouseRenderer == null || MouseRenderer.EditorCell == this)
                            editor = GetInternalEditControl();

                        if (editor != null && editor.EditorCell != this)
                        {
                            if (SuperGrid.ActiveNonModalEditor == editor)
                                editor = null;
                        }

                        if (editor == null)
                            editor = GetInternalRenderControl();
                    }
                    else
                    {
                        editor = SuperGrid.EditorCell == this
                            ? GetInternalEditControl() : GetInternalRenderControl();
                    }
                }

                if (editor != null)
                {
                    bool suspended = editor.SuspendUpdate;

                    try
                    {
                        editor.SuspendUpdate = true;

                        if (SuperGrid.EditorCell != this)
                            InitializeContext(DataContext.CellProposedSize, editor, style);

                        if (editor.CellEditMode == CellEditMode.Modal)
                        {
                            Size sizeActual = Size.Empty;
                            Size sizeFormatted = Size.Empty;

                            string s = editor.EditorFormattedValue;

                            SuperGrid.DoGetCellFormattedValueEvent(this, ref s, ref sizingSource);

                            if ((sizingSource & CellSizingSource.ActualValue) == CellSizingSource.ActualValue)
                                sizeActual = editor.GetProposedSize(g, this, style, constraintSize);

                            if ((sizingSource & CellSizingSource.FormattedValue) == CellSizingSource.FormattedValue)
                                sizeFormatted = GetModalSize(g, s, style, constraintSize);

                            size.Height = Math.Max(sizeActual.Height, sizeFormatted.Height);
                            size.Width = Math.Max(sizeActual.Width, sizeFormatted.Width);
                        }
                        else
                        {
                            size = editor.GetProposedSize(g, this, style, constraintSize);
                        }
                    }
                    finally
                    {
                        editor.SuspendUpdate = suspended;
                    }
                }
            }

            return (size);
        }

        #region GetModalSize

        private Size GetModalSize(Graphics g,
            string text, CellVisualStyle style, Size constraintSize)
        {
            eTextFormat tf = style.GetTextFormatFlags();

            string s = String.IsNullOrEmpty(text) ? " " : text;

            Size size = (constraintSize.IsEmpty == true)
                            ? TextHelper.MeasureText(g, s, style.Font)
                            : TextHelper.MeasureText(g, s, style.Font, constraintSize, tf);

            return (size);
        }

        #endregion

        #endregion

        #region Mouse support

        #region InternalMouseEnter

        internal override void InternalMouseEnter(EventArgs e)
        {
            base.InternalMouseEnter(e);

            if (GridColumn != null)
            {
                GridColumn.IsMouseOver = true;

                DoRendererMouseEnter();

                SuperGrid.ToolTipText = "";
                _toolTipText = null;

                if (GridPanel.SelectionGranularity != SelectionGranularity.Cell)
                    GridRow.InvalidateRender(GridRow.Bounds);

                SuperGrid.DoCellMouseEnterEvent(this);
            }
        }

        #region DoRendererMouseEnter

        private void DoRendererMouseEnter()
        {
            if (CellEditMode != DotNetBar.SuperGrid.CellEditMode.Modal)
            {
                CellRange cr = GetStateCellRange();

                if (cr != null && cr.Suspended == false)
                    return;
            }

            _needsMouseEnter = true;

            if (SuperGrid.ActiveEditor == null)
            {
                _needsMouseEnter = false;

                if (IsEmptyCell == false)
                {
                    CellVisualStyle style = GetEffectiveStyle();

                    MouseRenderer = null;

                    if (CellEditMode != CellEditMode.Modal)
                        MouseRenderer = GetInternalEditControl();

                    if (MouseRenderer == null)
                        MouseRenderer = GetInternalRenderControl();

                    if (MouseRenderer != null)
                    {
                        switch (CellEditMode)
                        {
                            case CellEditMode.InPlace:
                                InitializeContext(DataContext.CellMouseEvent, MouseRenderer, style);
                                GetCurrentContentSize(style, MouseRenderer);
                                break;

                            case CellEditMode.NonModal:
                                if (CanModifyMerge == true)
                                {
                                    if (SuperGrid.ActiveNonModalEditor == null ||
                                        SuperGrid.ActiveNonModalEditor.CanInterrupt == true)
                                    {
                                        if (SuperGrid.ActiveNonModalEditor != null)
                                        {
                                            SuperGrid.DeactivateNonModalEditor();

                                            if (MouseRenderer == null)
                                                _needsMouseEnter = true;
                                        }

                                        if (MouseRenderer != null)
                                        {
                                            InitializeContext(DataContext.CellMouseEvent, MouseRenderer, style);

                                            PositionEditControl(MouseRenderer);

                                            MouseRenderer.BeginEdit(false);
                                            MouseRenderer.OnCellMouseEnter(EventArgs.Empty);

                                            SuperGrid.ActivateNonModalEditor(MouseRenderer, this);
                                        }
                                    }
                                    else
                                    {
                                        MouseRenderer = null;
                                        _needsMouseEnter = true;
                                    }
                                }
                                break;
                        }

                        if (MouseRenderer != null)
                            InvalidateRender();
                    }
                }
                else
                {
                    InvalidateRender();
                }
            }
        }

        #endregion

        #endregion

        #region InternalMouseLeave

        internal override void InternalMouseLeave(EventArgs e)
        {
            if (GridColumn != null)
            {
                DoRendererMouseLeave(e);

                GridColumn.IsMouseOver = false;

                if (_lastHitArea == CellArea.InCellInfo)
                    ProcessCellInfoLeave();

                if (GridPanel != null)
                {
                    if (GridPanel.SelectionGranularity != SelectionGranularity.Cell)
                        GridRow.InvalidateRender(GridRow.Bounds);
                    else
                        InvalidateRender();
                }

                SuperGrid.DoCellMouseLeaveEvent(this);

                SuperGrid.ToolTipText = "";
                _toolTipText = null;

                _lastHitArea = CellArea.NoWhere;
            }
                
            base.InternalMouseLeave(e);
        }

        #region DoRendererMouseLeave

        internal void DoRendererMouseLeave(EventArgs e)
        {
            if (MouseRenderer != null &&
                ((Control) MouseRenderer).IsDisposed == false)
            {
                if (CellEditMode != CellEditMode.InPlace || _mouseInItem == true)
                    MouseRenderer.OnCellMouseLeave(e);
            }
                
            _mouseInItem = false;
            MouseRenderer = null;
            _needsMouseEnter = false;

            InvalidateRender();
        }

        #endregion

        #endregion

        #region InternalMouseMove

        internal override void InternalMouseMove(MouseEventArgs e)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                if (CapturedItem != null && e.Button != MouseButtons.None)
                    ProcessMouseDownMove(e, panel);

                ProcessMouseMove(e);

                base.InternalMouseMove(e);

                DoRendererMouseMove(e);

                SuperGrid.DoCellMouseMoveEvent(this, e);
            }
        }

        #region DoRendererMouseMove

        private void DoRendererMouseMove(MouseEventArgs e)
        {
            if (_needsMouseEnter == true)
                DoRendererMouseEnter();

            if (MouseRenderer != null &&
                ((Control)MouseRenderer).IsDisposed == false)
            {
                if (CellEditMode == CellEditMode.InPlace)
                {
                    DoInPlaceMouseMove(e);
                }
                else
                {
                    if (CanModify == true)
                    {
                        Rectangle r = GetAdjustedBounds(EditBounds);
                        Point pt = SuperGrid.PointToClient(Control.MousePosition);

                        if (r.Contains(pt) == true)
                            MouseRenderer.OnCellMouseMove(GetControlMouseArgs(e));
                    }
                }
            }
        }

        #region DoInPlaceMouseMove

        private void DoInPlaceMouseMove(MouseEventArgs e)
        {
            if (IsMouseDown == false || _mouseDownInItem == true)
            {
                if (MouseRenderer != null)
                {
                    if (MouseRenderer.EditorCell != this)
                        InitializeContext(DataContext.CellMouseEvent, MouseRenderer, null);

                    Rectangle r = GetAdjustedBounds(ContentBounds);
                    r = GetEditPanelBounds(MouseRenderer, r);

                    bool inItem = r.Contains(e.Location);

                    if (_mouseInItem != inItem)
                    {
                        if (inItem == true)
                            MouseRenderer.OnCellMouseEnter(EventArgs.Empty);
                        else
                            MouseRenderer.OnCellMouseLeave(EventArgs.Empty);

                        _mouseInItem = inItem;
                    }

                    if (_mouseInItem == true)
                        MouseRenderer.OnCellMouseMove(GetControlMouseArgs(e, r));
                }
            }
        }

        #endregion

        #endregion

        #region ProcessMouseDownMove

        private void ProcessMouseDownMove(MouseEventArgs e, GridPanel panel)
        {
            if (_mouseDownHitCell != null)
            {
                if (_mouseDownHitArea == CellArea.InContent)
                {
                    Rectangle r = ViewRect;

                    if (MouseDownPoint.Y < r.Y)
                    {
                        int n = SuperGrid.PrimaryGrid.FixedRowHeight -
                                SuperGrid.PrimaryGrid.FixedHeaderHeight;

                        r.Y -= n;
                        r.Height += n;
                    }

                    if ((e.Y >= r.Y && e.Y < r.Bottom) && (e.X >= r.X && e.X < r.Right))
                    {
                        SuperGrid.DisableAutoScrolling();

                        ProcessInContent(panel, e);
                    }
                    else
                    {
                        SuperGrid.EnableAutoScrolling(
                            AutoScrollEnable.Horizontal | AutoScrollEnable.Vertical, r);
                    }
                }
            }
        }

        #region ProcessInContent

        private void ProcessInContent(GridPanel panel, MouseEventArgs e)
        {
            Point pt = e.Location;

            Rectangle t = SViewRect;
            pt.X = Math.Min(t.Right - 1, pt.X);
            pt.X = Math.Max(t.X, pt.X);

            Rectangle v = panel.BoundsRelative;
            v.Location = panel.PointToScroll(v.Location);
            pt.X = Math.Min(v.Right - 1, pt.X);
            pt.X = Math.Max(v.X, pt.X);

            GridCell lastCell = _hitCell;

            _hitCell = GetCellAt(panel, pt);

            if (DragStarted(panel, pt, e) == false)
            {
                if (_hitCell != null && _hitArea == CellArea.InContent)
                {
                    if (panel.MultiSelect == true)
                    {
                        if (lastCell != null)
                            lastCell.IsMouseOver = false;

                        _hitCell.IsMouseOver = true;

                        if (panel.CellDragBehavior == CellDragBehavior.ExtendSelection)
                        {
                            if (panel.LastProcessedItem is GridCell &&
                                _hitCell != panel.LastProcessedItem)
                            {
                                if (SuperGrid.ActiveEditor == null)
                                    ProcessExtendSelection(panel, true);
                            }
                        }
                    }
                }
            }
        }

        #region DragStarted

        private bool DragStarted(GridPanel panel, Point pt, MouseEventArgs e)
        {
            if (IsDragSelection == true)
            {
                if (IsDragStarted == false)
                {
                    if (DragDrop.DragStarted(_mouseDownPoint, pt) == true)
                    {
                        IsDragStarted = true;

                        if (SuperGrid.DoItemDragEvent(this, e) == true)
                        {
                            IsDragSelection = false;

                            ExtendSelection(panel);
                        }
                    }
                }

                return (true);
            }

            return (false);
        }

        #endregion

        #region GetCellAt

        private GridCell GetCellAt(GridPanel panel, Point pt)
        {
            Rectangle t = ViewRect;
            pt.X = Math.Min(t.Right - 1, pt.X);
            pt.X = Math.Max(t.X, pt.X);

            Rectangle v = panel.BoundsRelative;
            v.Location = panel.PointToScroll(v.Location);
            pt.X = Math.Min(v.Right - 1, pt.X);
            pt.X = Math.Max(v.X, pt.X);

            GridRow row = panel.InternalGetElementAt(pt.X, pt.Y) as GridRow;

            while (row != null)
            {
                GridElement item = row.InternalGetElementAt(pt.X, pt.Y);

                if (item is GridCell)
                    return (item as GridCell);

                row = item as GridRow;
            }

            return (null);
        }

        #endregion

        #endregion

        #endregion

        #region ProcessMouseMove

        private void ProcessMouseMove(MouseEventArgs e)
        {
            _hitArea = GetCellAreaAt(e);
            _hitCell = this;

            if (_hitArea == CellArea.InContent)
                SuperGrid.GridCursor = Cursors.Default;

            if (_hitArea != _lastHitArea)
            {
                ProcessToolTipText(e);

                _lastHitArea = _hitArea;

                InvalidateRender();
            }

            base.InternalMouseMove(e);
        }

        #region ProcessToolTipText

        private void ProcessToolTipText(MouseEventArgs e)
        {
            if (_hitArea == CellArea.InContent)
                ProcessCellToolTip();
            
            else if (_hitArea == CellArea.InCellInfo)
                ProcessCellInfoEnter(e);

            if (_lastHitArea == CellArea.InCellInfo)
                ProcessCellInfoLeave();
        }

        #region ProcessCellToolTip

        private void ProcessCellToolTip()
        {
            SetToolTip(GridPanel.ShowToolTips ? GetToolTipText() : string.Empty);
        }

        #region GetToolTipText

        private string GetToolTipText()
        {
            if (_toolTipText == null)
            {
                CellRange cr = GetStateCellRange();

                if (cr != null)
                {
                    _toolTipText = cr.ToolTip ?? "";
                }
                else
                {
                    string s = "";

                    if (SuperGrid.DoGetCellToolTipEvent(GridPanel, this, ref s) == false)
                    {
                        _toolTipText = "";

                        if (IsEmptyCell == false)
                        {
                            CellVisualStyle style = GetEffectiveStyle();

                            Rectangle r = GetAdjustedBounds(ContentBounds);

                            if (MouseRenderer != null &&
                                ((Control)MouseRenderer).IsDisposed == false)
                            {
                                Size size = new
                                    Size(style.AllowWrap == Tbool.True ? r.Width : 0, 0);

                                using (Graphics g = SuperGrid.CreateGraphics())
                                    size = GetProposedSize(g, style, size, MouseRenderer, CellSizingSource.FormattedValue);

                                if (size.Width > r.Width || size.Height > r.Height)
                                    _toolTipText = String.IsNullOrEmpty(s) ? GetFormattedValue(MouseRenderer) : s;
                            }
                        }
                    }
                    else
                    {
                        _toolTipText = s;
                    }
                }
            }

            return (_toolTipText);
        }

        #endregion

        #endregion

        #region ProcessCellInfoEnter

        private void ProcessCellInfoEnter(MouseEventArgs e)
        {
            SetToolTip(SuperGrid.DoCellInfoEnterEvent(this,
                SuperGrid, SuperGrid.ToolTip, e.Location) ? "" : InfoText);
        }

        #endregion

        #region ProcessCellInfoLeave

        private void ProcessCellInfoLeave()
        {
            SuperGrid.DoCellInfoLeaveEvent(this, SuperGrid, SuperGrid.ToolTip);
        }

        #endregion

        #region SetToolTip

        private void SetToolTip(string toolTipText)
        {
            if (SuperGrid.ToolTipText != _toolTipText)
                SuperGrid.ToolTip.Hide(SuperGrid);

            SuperGrid.ToolTipText = toolTipText;
        }

        #endregion

        #endregion

        #endregion

        #endregion

        #region InternalMouseDown

        internal override void InternalMouseDown(MouseEventArgs e)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                SuperGrid.DoCellMouseDownEvent(this, e);

                _mouseDownPoint = e.Location;

                IsDragSelection = false;
                IsDragStarted = false;

                if (_hitArea == CellArea.InContent || _hitArea == CellArea.InCellInfo)
                {
                    _mouseDownHitArea = CellArea.NoWhere;

                    if (_hitCell != null && 
                        _hitCell.CanSetActiveCell(panel) == true)
                    {
                        _mouseDownHitArea = _hitArea;
                        _mouseDownHitCell = _hitCell;

                        if (panel.SelectionGranularity == SelectionGranularity.Cell)
                        {
                            panel.LastProcessedItem = _hitCell;

                            InitSelectOrDrag(panel);
                        }

                        DoRendererMouseDown(e);
                    }
                }
            }

            base.InternalMouseDown(e);
        }

        #region DoRendererMouseDown

        private void DoRendererMouseDown(MouseEventArgs e)
        {
            if (CanModifyMerge == true)
            {
                if (_needsMouseEnter == true)
                    DoRendererMouseEnter();

                if (MouseRenderer != null)
                {
                    if (_mouseInItem == true)
                    {
                        _mouseDownInItem = true;

                        if (MouseRenderer.EditorCell != this)
                            InitializeContext(DataContext.CellMouseEvent, MouseRenderer, null);

                        MouseRenderer.OnCellMouseDown(GetControlMouseArgs(e));
                    }
                }
            }
        }

        #endregion

        #region CanSetActiveCell

        internal bool CanSetActiveCell(GridPanel panel)
        {
            GridCell acell = SuperGrid.ActiveCell;

            if (acell != this)
            {
                if (IsSelectable == false ||
                    (IsEmptyCell == true && panel.AllowEmptyCellSelection == false))
                {
                    if (SuperGrid.DoPlayingSoundEvent(panel, this, PlaySoundContext.CellActivate) == false)
                        SystemSounds.Beep.Play();

                    return (false);
                }

                GridCell ecell = SuperGrid.EditorCell;

                if (ecell != null)
                {
                    if (ecell.EndEdit() == false)
                        return (false);
                }

                if (acell != null)
                    acell.ResumeMerge(this);

                if (GridRow.IsActive == false)
                {
                    if (GridRow.CanSetActiveRow(false) == false)
                        return (false);

                    if (panel.SetActiveRow(GridRow, true) == false)
                        return (false);
                }

                if (panel.SelectionGranularity != SelectionGranularity.Row)
                {
                    if (SuperGrid.DoCellActivatingEvent(panel, acell, this) == true)
                        return (false);

                    SuperGrid.ActiveCell = this;

                    if (panel.SelectionGranularity == SelectionGranularity.Cell)
                    {
                        SuperGrid.ActiveElement = this;

                        panel.LastProcessedItem = this;
                    }
                }
            }

            return (true);
        }

        #endregion

        #region ProcessExtendSelection

        private void ProcessExtendSelection(GridPanel panel, bool extend)
        {
            bool ckey = (panel.MultiSelect == true) ?
                ((Control.ModifierKeys & Keys.Control) == Keys.Control) : false;

            if (ckey == true)
                ProcessControlExtend(panel, extend);
            else
                ProcessNonControlExtend(panel, extend);

            panel.LastProcessedItem = _hitCell;
        }

        #region ProcessControlExtend

        private void ProcessControlExtend(GridPanel panel, bool extend)
        {
            GridCell cell = panel.LastProcessedItem as GridCell;

            if (cell != null)
            {
                int startRowIndex = cell.GridRow.GridIndex;
                int startColumnIndex = panel.Columns.GetDisplayIndex(cell.GridColumn);

                int[] map = panel.Columns.DisplayIndexMap;

                if (extend == false)
                {
                    int columnIndex = map[startColumnIndex];

                    SetSelectedMerge(panel, startRowIndex,
                        startColumnIndex, startRowIndex, startColumnIndex, 0);

                    panel.SetSelectedCells(startRowIndex, columnIndex,
                        1, 1, !panel.IsCellSelected(startRowIndex, columnIndex));

                    cell.InvalidateRender();

                    panel.ColumnHeader.InvalidateRowHeader();
                }
                else
                {
                    int endRowIndex = _hitCell.GridRow.GridIndex;
                    int endColumnIndex = panel.Columns.GetDisplayIndex(_hitCell.GridColumn);

                    if (endColumnIndex - startColumnIndex != 0)
                    {
                        SelectControlColumn(panel, map,
                            startColumnIndex, endColumnIndex, startRowIndex);
                    }

                    if (endRowIndex - startRowIndex != 0)
                    {
                        SelectControlRow(panel, map,
                            startRowIndex, endRowIndex, endColumnIndex);
                    }
                }
            }
        }

        #region SelectControlColumn

        private void SelectControlColumn(GridPanel panel, int[] map,
            int startColumnIndex, int endColumnIndex, int startRowIndex)
        {
            int endRowIndex = startRowIndex;

            panel.NormalizeIndices(true,
                _anchorColumnIndex, ref startColumnIndex, ref endColumnIndex);

            panel.NormalizeIndices(false,
                _anchorRowIndex, ref startRowIndex, ref endRowIndex);

            if (endRowIndex > _anchorRowIndex)
                startRowIndex = _anchorRowIndex;

            else if (startRowIndex < _anchorRowIndex)
                endRowIndex = _anchorRowIndex;

            for (int i = startRowIndex; i <= endRowIndex; i++)
            {
                for (int j = startColumnIndex; j <= endColumnIndex; j++)
                {
                    if (j != _anchorColumnIndex)
                    {
                        int columnIndex = map[j];

                        panel.SetSelectedCells(i, columnIndex, 1, 1,
                            !panel.IsCellSelected(i, columnIndex));
                    }
                }
            }

            panel.InvalidateCells(startRowIndex,
                endRowIndex, startColumnIndex, endColumnIndex);
        }

        #endregion

        #region SelectControlRow

        private void SelectControlRow(GridPanel panel, int[] map,
            int startRowIndex, int endRowIndex, int endColumnIndex)
        {
            int startColumnIndex = endColumnIndex;

            panel.NormalizeIndices(false,
                _anchorColumnIndex, ref startColumnIndex, ref endColumnIndex);

            panel.NormalizeIndices(true,
                _anchorRowIndex, ref startRowIndex, ref endRowIndex);

            if (endColumnIndex > _anchorColumnIndex)
                startColumnIndex = _anchorColumnIndex;

            else if (startColumnIndex < _anchorColumnIndex)
                endColumnIndex = _anchorColumnIndex;

            for (int i = startRowIndex; i <= endRowIndex; i++)
            {
                for (int j = startColumnIndex; j <= endColumnIndex; j++)
                {
                    if (i != _anchorRowIndex)
                    {
                        int columnIndex = map[j];

                        panel.SetSelectedCells(i, columnIndex, 1, 1,
                            !panel.IsCellSelected(i, columnIndex));
                    }
                }
            }

            panel.InvalidateCells(startRowIndex,
                endRowIndex, startColumnIndex, endColumnIndex);
        }

        #endregion

        #endregion

        #region ProcessNonControlExtend

        private void ProcessNonControlExtend(GridPanel panel, bool extend)
        {
            bool skey = (panel.MultiSelect == true) ?
                ((Control.ModifierKeys & Keys.Shift) == Keys.Shift) : false;

            if (skey == false ||
                panel.SelectionRowAnchor == null ||
                panel.SelectionColumnAnchor == null)
            {
                panel.SelectionRowAnchor = _mouseDownHitCell.GridRow;
                panel.SelectionColumnAnchor = _mouseDownHitCell.GridColumn;
            }

            ExtendSelection(panel, _hitCell, extend);
        }

        #endregion

        #endregion

        #region InitSelectOrDrag

        private void InitSelectOrDrag(GridPanel panel)
        {
            if (panel.SuperGrid.HasItemDragHandler == false || panel.IsItemSelected(this) == false ||
                ((Control.ModifierKeys & (Keys.Control | Keys.Shift)) != Keys.None))
            {
                ExtendSelection(panel);
            }
            else if (IsMouseDown == true)
            {
                IsDragSelection = true;

                Capture = true;
            }
        }

        #endregion

        #endregion

        #region InternalMouseUp

        internal override void InternalMouseUp(MouseEventArgs e)
        {
            if (GridColumn != null)
            {
                if (CanModifyMerge == true)
                    DoRendererMouseUp(e);

                _mouseDownInItem = false;

                SuperGrid.DoCellMouseUpEvent(this, e);

                if (InfoImageBounds.Contains(e.X, e.Y) == true)
                {
                    SuperGrid.DoCellInfoClickEvent(this, e);
                }
                else
                {
                    if (_mouseDownHitCell == this && IsMouseOver == true)
                    {
                        if (SuperGrid.DoCellClickEvent(this, e) == false)
                        {
                            GridPanel panel = GridPanel;

                            if (panel != null)
                            {
                                if ((e.Button & MouseButtons.Left) == MouseButtons.Left)
                                {
                                    if (IsDragSelection == true)
                                        ExtendSelectionEx(panel);

                                    if (_hitArea == CellArea.InContent)
                                    {
                                        if (panel.MouseEditMode == MouseEditMode.SingleClick)
                                        {
                                            //if (Bounds.Contains(e.X, e.Y) == true)
                                            {
                                                if (CanSetActiveCell(GridPanel) == true)
                                                    BeginEdit(true);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            IsDragSelection = false;

            base.InternalMouseUp(e);
        }

        #region DoRendererMouseUp

        private void DoRendererMouseUp(MouseEventArgs e)
        {
            if (MouseRenderer != null)
            {
                if (_mouseDownInItem == true)
                {
                    if (MouseRenderer.EditorCell != this)
                        InitializeContext(DataContext.CellMouseEvent, MouseRenderer, null);

                    MouseRenderer.OnCellMouseUp(GetControlMouseArgs(e));

                    SuperGrid.Focus();
                }
            }
        }

        #endregion

        #endregion

        #region InternalMouseDoubleClick

        internal override void InternalMouseDoubleClick(MouseEventArgs e)
        {
            GridPanel panel = GridPanel;

            if (InfoImageBounds.Contains(e.X, e.Y) == true)
            {
                SuperGrid.DoCellInfoDoubleClickEvent(this, e);
            }
            else
            {
                if (SuperGrid.DoCellDoubleClickEvent(this, e) == false)
                {
                    if (_hitArea == CellArea.InContent &&
                        panel.MouseEditMode == MouseEditMode.DoubleClick)
                    {
                        if (CanSetActiveCell(panel) == true)
                        {
                            CellRange cr = GetStateCellRange();

                            if (cr != null && cr.Suspended == false)
                            {
                                if (cr.AllowSuspend == true)
                                {
                                    SuspendMerge(cr);

                                    if (_mouseDownHitCell != null)
                                    {
                                        _needsMouseEnter = true;
                                        _mouseDownHitCell.SetActive(true);
                                    }
                                }
                                else
                                {
                                    if (SuperGrid.DoPlayingSoundEvent(panel, cr, PlaySoundContext.CellActivate) == false)
                                        SystemSounds.Beep.Play();
                                }
                            }
                            else
                            {
                                BeginEdit(true);
                            }
                        }
                    }

                    _mouseDownHitCell = null;
                }
            }
        }

        #region DoRendererMouseDoubleClick

        private void DoRendererMouseDoubleClick(MouseEventArgs e)
        {
            if (CanModify == true)
            {
                if (MouseRenderer != null)
                {
                    if (_mouseDownInItem == true)
                    {
                        if (MouseRenderer.EditorCell != this)
                            InitializeContext(DataContext.CellMouseEvent, MouseRenderer, null);

                        MouseRenderer.OnCellMouseDown(GetControlMouseArgs(e));
                    }
                }
            }
        }

        #endregion

        #endregion

        #endregion

        #region GetControlMouseArgs

        private MouseEventArgs GetControlMouseArgs(MouseEventArgs e)
        {
            Rectangle r = GetAdjustedBounds(ContentBounds);
            r = GetEditPanelBounds(MouseRenderer, r);

            return (GetControlMouseArgs(e, r)); 
        }

        private MouseEventArgs
            GetControlMouseArgs(MouseEventArgs e, Rectangle r)
        {
            int x = e.X - r.X;
            int y = e.Y - r.Y;

            MouseEventArgs args = new
                MouseEventArgs(e.Button, e.Clicks, x, y, e.Delta);

            return (args);
        }

        #endregion

        #region ExtendSelection

        internal void ExtendSelection(GridPanel panel, GridCell endCell, bool extend)
        {
            if (panel.SelectionColumnAnchor is GridColumn)
            {
                int startRowIndex = panel.SelectionRowAnchor.GridIndex;
                int startColumnIndex = panel.Columns.GetDisplayIndex((GridColumn)(panel.SelectionColumnAnchor));

                int endRowIndex = endCell.GridRow.GridIndex;
                int endColumnIndex = panel.Columns.GetDisplayIndex(endCell.GridColumn);

                if (startRowIndex < 0)
                    startRowIndex = endRowIndex;

                panel.NormalizeIndices(false, 0, ref startRowIndex, ref endRowIndex);
                panel.NormalizeIndices(false, 0, ref startColumnIndex, ref endColumnIndex);

                if (startColumnIndex < 0)
                    startColumnIndex = 0;

                if (endColumnIndex < 0)
                    endColumnIndex = 0;

                if (panel.OnlyCellsSelected(
                    startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) == false)
                {
                    ClearSelected(panel, extend);

                    if (startRowIndex >= 0 && endRowIndex >= 0)
                    {
                        SetSelected(panel, startRowIndex,
                            startColumnIndex, endRowIndex, endColumnIndex);

                        InvalidateSelected(panel, startRowIndex,
                            startColumnIndex, endRowIndex, endColumnIndex);
                    }
                }
            }
        }

        #region InvalidateSelected

        private void InvalidateSelected(GridPanel panel,
            int startRowIndex, int startColumnIndex, int endRowIndex, int endColumnIndex)
        {
            GridCell lastCell = (Control.MouseButtons == MouseButtons.None)
                ? SuperGrid.LastActiveCell : panel.LastProcessedItem as GridCell;

            if (lastCell != null)
            {
                int lastIndex = panel.Columns.GetDisplayIndex(lastCell.ColumnIndex);

                if (lastIndex < startColumnIndex)
                    startColumnIndex = lastIndex;

                else if (lastIndex > endColumnIndex)
                    endColumnIndex =lastIndex;

                if (lastCell.GridRow.GridIndex < startRowIndex)
                    startRowIndex = lastCell.GridRow.GridIndex;

                else if (lastCell.GridRow.GridIndex > endRowIndex)
                    endRowIndex = lastCell.GridRow.GridIndex;
            }

            panel.InvalidateCells(startRowIndex,
                endRowIndex, startColumnIndex, endColumnIndex);
        }

        #endregion

        #region SetSelected

        private void SetSelected(GridPanel panel,
            int startRowIndex, int startColumnIndex, int endRowIndex, int endColumnIndex)
        {
            SetSelectedMerge(panel, startRowIndex,
                startColumnIndex, endRowIndex, endColumnIndex, 1);

            int[] map = panel.Columns.DisplayIndexMap;

            for (int i = startColumnIndex; i <= endColumnIndex; i++)
            {
                panel.SetSelectedCells(startRowIndex, map[i],
                    endRowIndex - startRowIndex + 1, 1, true);
            }
        }

        #region SetSelectedMerge

        private void SetSelectedMerge(GridPanel panel, int startRowIndex,
            int startColumnIndex, int endRowIndex, int endColumnIndex, int selected)
        {
            if (panel.EnableCellMerging == true)
            {
                GridContainer cont = RowContainer;

                if (cont != null)
                {
                    GridContainer srow = panel.GetRowFromIndex(startRowIndex);
                    GridContainer erow = panel.GetRowFromIndex(endRowIndex);

                    if (srow != null && erow != null)
                    {
                        int sRowIndex = panel.GetRowFromIndex(startRowIndex).RowIndex;
                        int eRowIndex = panel.GetRowFromIndex(endRowIndex).RowIndex;

                        cont.SetMergeSelection(sRowIndex,
                            eRowIndex, startColumnIndex, endColumnIndex, selected);
                    }
                }
            }
        }

        #endregion

        #endregion

        #region ClearSelected

        private void ClearSelected(GridPanel panel, bool extend)
        {
            if (panel.IsGrouped == false &&
                (panel.SelectedCellCount < 50 && panel.SelectedRowCount < 10 && panel.SelectedColumnCount < 10))
            {
                foreach (GridCell cell in panel.SelectedCells)
                    cell.IsSelected = false;

                foreach (GridColumn col in panel.SelectedColumns)
                    col.IsSelected = false;

                foreach (GridContainer row in panel.SelectedRows)
                {
                    if (row != null)
                        row.IsSelected = false;
                }

                RowContainer.ClearAllMergeSelected();
            }
            else
            {
                panel.ClearAll(extend == false);
            }

            panel.SelectionClearCount++;
        }

        #endregion

        #endregion

        #region GetNextCell

        internal GridCell GetNextCell(bool canSelect)
        {
            return (GetNextCell(canSelect, true));
        }

        internal GridCell GetNextCell(bool canSelect, bool multiRow)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                int[] map = panel.Columns.DisplayIndexMap;
                int index = panel.Columns.GetDisplayIndex(GridColumn);

                int anchor = index;

                GridRow row = GridRow;

                while (row != null)
                {
                    if (row.AllowSelection == true)
                    {
                        while (++index < map.Length)
                        {
                            if (multiRow == false && index == anchor)
                                return (null);

                            GridColumn column = panel.Columns[map[index]];

                            if (column.Visible == true &&
                                (canSelect == false || column.AllowSelection == true))
                            {
                                GridCell cell = row.GetCell(
                                    column.ColumnIndex, panel.AllowEmptyCellSelection);

                                if (cell != null)
                                {
                                    if (canSelect == false || cell.AllowSelection == true)
                                        return (cell);
                                }
                            }
                        }
                    }

                    if (multiRow == true)
                        row = row.NextVisibleRow as GridRow;
                    else
                        break;

                    index = -1;
                }
            }

            return (null);
        }

        #endregion

        #region GetPreviousCell

        internal GridCell GetPreviousCell(bool canSelect)
        {
            return (GetPreviousCell(canSelect, true));
        }

        internal GridCell GetPreviousCell(bool canSelect, bool multiRow)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                int[] map = panel.Columns.DisplayIndexMap;
                int index = panel.Columns.GetDisplayIndex(GridColumn);

                int anchor = index;

                GridRow row = GridRow;

                while (row != null)
                {
                    if (row.AllowSelection == true)
                    {
                        while (--index >= 0)
                        {
                            if (multiRow == false && index == anchor)
                                return (null);

                            GridColumn column = panel.Columns[map[index]];

                            if (column.Visible == true &&
                                (canSelect == false || column.AllowSelection == true))
                            {
                                GridCell cell = row.GetCell(
                                    column.ColumnIndex, panel.AllowEmptyCellSelection);

                                if (cell != null)
                                {
                                    if (canSelect == false || cell.AllowSelection == true)
                                        return (cell);
                                }
                            }
                        }
                    }

                    if (multiRow == true)
                        row = row.PrevVisibleRow as GridRow;
                    else
                        break;

                    index = map.Length;
                }
            }

            return (null);
        }

        #endregion

        #region GetCellAreaAt

        /// <summary>
        /// Returns element at specified mouse coordinates
        /// </summary>
        /// <param name="e">Mouse event arguments</param>
        /// <returns>Reference to child Cell element or null
        /// if no element at specified coordinates</returns>
        protected virtual CellArea GetCellAreaAt(MouseEventArgs e)
        {
            return GetCellAreaAt(e.X, e.Y);
        }

        /// <summary>
        /// Returns element at specified mouse coordinates
        /// </summary>
        /// <param name="x">Horizontal position</param>
        /// <param name="y">Vertical position</param>
        /// <returns>Reference to child element or null
        /// if no element at specified coordinates</returns>
        protected virtual CellArea GetCellAreaAt(int x, int y)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                if (InfoImageBounds.Contains(x, y) == true)
                    return (CellArea.InCellInfo);

                if (IsPrimaryCell == true)
                {
                    GridRow cellRow = GridRow;

                    if (cellRow != null)
                    {
                        Rectangle r = cellRow.ExpandButtonBounds;

                        if (cellRow.IsVFrozen == false)
                            r.Y -= VScrollOffset;

                        if (panel.IsSubPanel == true || GridColumn.IsHFrozen == false)
                            r.X -= HScrollOffset;

                        if (r.Contains(x, y) == true)
                            return (CellArea.InExpandButton);

                        r = cellRow.CheckBoxBounds;

                        if (cellRow.IsVFrozen == false)
                            r.Y -= VScrollOffset;

                        if (panel.IsSubPanel == true || GridColumn.IsHFrozen == false)
                            r.X -= HScrollOffset;

                        if (r.Contains(x, y) == true)
                            return (CellArea.InCheckBox);
                    }
                }
            }

            return (CellArea.InContent);
        }

        #endregion

        #region EnsureVisible

        ///<summary>
        /// Ensures that the given cell is visibly centered
        /// (as much as possible) in the grid display.
        ///</summary>
        ///<param name="center"></param>
        public override void EnsureVisible(bool center)
        {
            if (GridRow.Visible == true && GridColumn.Visible == true)
            {
                if (IsVFrozen == false)
                    GridRow.EnsureVisible(center);

                GridColumn column = GridColumn;

                if (column != null && column.IsHFrozen == false)
                    column.EnsureVisible(center);
            }
        }

        #endregion

        #region SetActive

        ///<summary>
        /// Sets the given cell as Active
        ///</summary>
        ///<returns>true - if successful</returns>
        public bool SetActive()
        {
            return (SetActive(false));
        }

        ///<summary>
        /// Makes the given cell active and
        /// optionally selects the given cell
        ///</summary>
        ///<returns>true, if successful</returns>
        public bool SetActive(bool select)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                if (panel.SetActiveCell(this) == true)
                {
                    if (select == true)
                    {
                        panel.ClearAll();

                        IsSelected = true;
                    }

                    return (true);
                }
            }

            return (false);
        }

        #endregion

        #region Editor support

        #region GetEditControl

        internal IGridCellEditControl GetEditControl(Type type, object[] args)
        {
            if (type != null)
            {
                IGridCellEditControl editor =
                    Activator.CreateInstance(type, args) as IGridCellEditControl;

                if (editor is Control == false)
                    throw new Exception("Edit/Render Type must be based on 'Control'.");

                editor.EditorPanel = new EditorPanel();
                editor.EditorPanel.Visible = false;
                editor.EditorPanel.Controls.Add((Control) editor);

                return (editor);
            }

            return (null);
        }

        #endregion

        #region GetInternalEditControl

        internal IGridCellEditControl GetInternalEditControl()
        {
            return (GetInternalEditControl(CanModify));
        }

        internal IGridCellEditControl GetInternalEditControl(bool canModify)
        {
            if (canModify == true)
            {
                if (SuperGrid.EditorCell != this)
                {
                    Type editorType = _EditorInfo != null ? _EditorInfo.EditorType : null;
                    object[] editorParams = _EditorInfo != null ? _EditorInfo.EditorParams : null;

                    SuperGrid.DoGetEditorEvent(GridPanel, this, ref editorType, ref editorParams);

                    EditorType = editorType;
                    EditorParams = editorParams;
                }

                return (EditControl ?? (GridColumn != null ? GridColumn.EditControl : null));
            }

            return (null);
        }

        #endregion

        #region GetInternalRenderControl

        private IGridCellEditControl GetInternalRenderControl()
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                Type renderType = _EditorInfo != null ? _EditorInfo.RenderType : null;
                object[] renderParams = _EditorInfo != null ? _EditorInfo.RenderParams : null;

                SuperGrid.DoGetRendererEvent(panel, this, ref renderType, ref renderParams);

                RenderType = renderType;
                RenderParams = renderParams;
                
                return (RenderControl ?? (GridColumn != null ? GridColumn.RenderControl : null));
            }

            return (null);
        }

        #endregion

        #region BeginEdit

        ///<summary>
        /// Begins a Modal cell edit operation using
        /// the defined column or cell Modal EditControl.
        ///</summary>
        ///<param name="selectAll"></param>
        ///<returns></returns>
        public IGridCellEditControl BeginEdit(bool selectAll)
        {
            return (BeginEdit(selectAll, null));
        }

        ///<summary>
        /// Begins a Modal cell edit operation using the defined column
        /// or cell Modal EditControl.  If a KeyEvent is provided then
        /// the event will be presented to the editor control. 
        ///</summary>
        ///<returns>Cell edit control</returns>
        public IGridCellEditControl BeginEdit(bool selectAll, KeyEventArgs e)
        {
            GridCell ecell = SuperGrid.EditorCell;

            if (ecell == this)
                return (GetInternalEditControl());

            if (ecell != null)
                throw new Exception("Modal Cell edit is already in process.");

            if (Visible == true && CanModify == true)
            {
                GridPanel.FlushSelected();

                IGridCellEditControl editor = GetInternalEditControl();

                if (editor != null && editor.CellEditMode == CellEditMode.Modal)
                {
                    if (SuspendMerge(false) == true)
                    {
                        CellVisualStyle style = GetEffectiveStyle(StyleState.Default);

                        SuperGrid.DeactivateNonModalEditor();

                        DoRendererMouseLeave(EventArgs.Empty);
                        EnsureVisible();

                        GetCurrentContentSize(style, editor);

                        InitializeContext(DataContext.CellEdit, editor, style);

                        if (SuperGrid.DoBeginEditEvent(GridPanel, this, editor) == false)
                        {
                            SuperGrid.ActiveEditor = editor;
                            SuperGrid.EditorCell = this;

                            PositionEditPanel(editor);

                            editor.EditorPanel.Show();
                            editor.EditorPanel.BringToFront();

                            if (editor.BeginEdit(selectAll) == false)
                            {
                                UpdateInfoWindow();

                                FocusEditor(editor);

                                if (e != null)
                                    SuperGrid.PressKeyDown((ushort) e.KeyCode);

                                return (editor);
                            }

                            CloseEdit(editor);
                        }
                    }
                }
            }

            return (null);
        }

        #endregion

        #region EndEdit

        ///<summary>
        /// This routine ends an in-progress Modal cell edit operation.
        ///</summary>
        ///<returns>true if ended</returns>
        public bool EndEdit()
        {
            IGridCellEditControl editor = SuperGrid.ActiveEditor;

            if (editor != null && CellEditMode == CellEditMode.Modal)
            {
                if (editor.EditorCell == this)
                {
                    if (GridRow.EditorDirty == true)
                    {
                        if (ValidateCellEdit(editor) == false)
                            return (false);

                        GridRow.EditorDirty = false;

                        object value = Value;

                        if (UpdateCellValue(editor) == true)
                            Value = value;
                    }

                    if (SuperGrid.DoEndEditEvent(GridPanel, this, editor) == false)
                    {
                        if (editor.EndEdit() == false)
                        {
                            CloseEdit(editor);

                            return (true);
                        }
                    }

                    return (false);
                }
            }

            return (true);
        }

        #region UpdateCellValue

        /// <summary>
        /// Used by IGridCellEditControl editors to update the
        /// cell Value from the EditorValue, performing any needed
        /// data conversions for proper data typing.
        /// </summary>
        /// <param name="editor"></param>
        /// <returns></returns>
        public bool UpdateCellValue(IGridCellEditControl editor)
        {
            object value = editor.EditorValue;

            while (true)
            {
                try
                {
                    ConvertValueToType(editor, value);

                    return (false);
                }
                catch (Exception exp)
                {
                    bool throwException = true;
                    bool retry = false;

                    if (SuperGrid.HasDataErrorHandler == true)
                    {
                        if (SuperGrid.DoDataErrorEvent(GridPanel, this, exp,
                            DataContext.CellValueStore, ref value, ref throwException, ref retry) == true)
                        {
                            return (true);
                        }
                    }

                    if (throwException == true)
                    {
                        MessageBoxEx.Show(exp.ToString());
                        throw;
                    }

                    if (retry == false)
                        break;
                }
            }

            return (true);
        }

        #region ConvertValueToType

        private void ConvertValueToType(IGridCellEditControl editor, object value)
        {
            Type dataType = GridColumn.DataType;

            if (editor is IGridCellConvertTo)
            {
                IGridCellConvertTo cvtEditor = (IGridCellConvertTo)editor;

                object result;
                if (cvtEditor.TryConvertTo(value, dataType, out result) == true)
                {
                    Value = result;

                    return;
                }
            }

            if (dataType == null && Value != null)
                dataType = Value.GetType();

            if (dataType == typeof (SqlDateTime))
                Value = SetSqlDateTime(value);

            else if (dataType == typeof (SqlBoolean))
                Value = SetSqlBoolean(value);

            else if (dataType == typeof (SqlString))
                Value = SetSqlString(value);

            else if (dataType == typeof (SqlSingle))
                Value = SetSqlSingle(value);

            else if (dataType == typeof (SqlDouble))
                Value = SetSqlDouble(value);

            else if (dataType == typeof(SqlDecimal))
                Value = SetSqlDecimal(value);

            else if (dataType == typeof (SqlInt16))
                Value = SetSqlInt16(value);

            else if (dataType == typeof (SqlInt32))
                Value = SetSqlInt32(value);

            else if (dataType == typeof (SqlInt64))
                Value = SetSqlInt64(value);

            else if (dataType != null)
                Value = ConvertValue.ConvertTo(value, dataType);

            else
                Value = value;
        }

        #region SetSqlDateTime

        private object SetSqlDateTime(object value)
        {
            if (value == null)
                return (new SqlDateTime());

            if (value is DateTime)
                return (new SqlDateTime((DateTime)value));

            return (new SqlDateTime(Convert.ToDateTime(value)));
        }

        #endregion

        #region SetSqlBoolean

        private object SetSqlBoolean(object value)
        {
            if (value == null)
                return (new SqlBoolean());

            if (value is CheckState)
            {
                CheckState cs = (CheckState)value;

                if (cs == CheckState.Checked)
                    return (new SqlBoolean(true));

                if (cs == CheckState.Unchecked)
                    return (new SqlBoolean(false));

                return (new SqlBoolean());
            }

            return (new SqlBoolean(Convert.ToBoolean(value)));
        }

        #endregion

        #region SetSqlBoolean

        private object SetSqlString(object value)
        {
            if (value == null)
                return (new SqlString());

            return (new SqlString(Convert.ToString(value)));
        }

        #endregion

        #region SetSqlSingle

        private object SetSqlSingle(object value)
        {
            if (value == null)
                return (new SqlSingle());

            return (new SqlSingle(Convert.ToSingle(value)));
        }

        #endregion

        #region SetSqlDouble

        private object SetSqlDouble(object value)
        {
            if (value == null)
                return (new SqlDouble());

            return (new SqlSingle(Convert.ToDouble(value)));
        }

        #endregion

        #region SetSqlDecimal

        private object SetSqlDecimal(object value)
        {
            if (value == null)
                return (new SqlDecimal());

            return (new SqlDecimal(Convert.ToDecimal(value)));
        }

        #endregion

        #region SetSqlInt16

        private object SetSqlInt16(object value)
        {
            if (value == null)
                return (new SqlInt16());

            return (new SqlInt16(Convert.ToInt16(value)));
        }

        #endregion

        #region SetSqlInt32

        private object SetSqlInt32(object value)
        {
            if (value == null)
                return (new SqlInt32());

            return (new SqlInt32(Convert.ToInt32(value)));
        }

        #endregion

        #region SetSqlInt64

        private object SetSqlInt64(object value)
        {
            if (value == null)
                return (new SqlInt64());

            return (new SqlInt64(Convert.ToInt64(value)));
        }

        #endregion

        #endregion

        #endregion

        #region ValidateCellEdit

        private bool ValidateCellEdit(IGridCellEditControl editor)
        {
            try
            {
                object value = editor.EditorValue;
                object formattedValue = GetFormattedValue(editor);

                if (SuperGrid.DoCellValidatingEvent(this, ref value, formattedValue) == true)
                {
                    if (SuperGrid.DoPlayingSoundEvent(GridPanel, this, PlaySoundContext.CellValidate) == false)
                        SystemSounds.Beep.Play();

                    return (false);
                }

                editor.EditorValue = value;

                SuperGrid.DoCellValidatedEvent(this);
            }
            catch
            {
                if (SuperGrid.DoPlayingSoundEvent(GridPanel, this, PlaySoundContext.CellValidate) == false)
                    SystemSounds.Beep.Play();

                return (false);
            }

            return (true);
        }

        #endregion

        #endregion

        #region CancelEdit

        ///<summary>
        /// Cancels the current in-progress Modal cell edit operation.
        ///</summary>
        ///<returns>true if canceled</returns>
        public bool CancelEdit()
        {
            IGridCellEditControl editor = SuperGrid.ActiveEditor;

            if (editor == null || CellEditMode != CellEditMode.Modal)
                throw new Exception("Bad CancelEdit - Modal edit not in progress.");

            if (SuperGrid.DoCancelEditEvent(GridPanel, this, editor) == false)
            {
                if (editor.CancelEdit() == false)
                {
                    bool rowDirty = GridRow.RowDirty;
                    bool needsStored = GridRow.RowNeedsStored;

                    CloseEdit(editor);

                    GridRow.RowDirty = rowDirty;
                    GridRow.RowNeedsStored = needsStored;

                    return (true);
                }
            }

            return (true);
        }

        #endregion

        #region CloseEdit

        private void CloseEdit(IGridCellEditControl editor)
        {
            CloseCellInfoWindow();

            IsMouseOver = false;

            bool wasFocused = ((Control)editor).ContainsFocus;

            editor.EditorPanel.Hide();
            editor.EditorPanel.GridCell = null;

            GridRow.EditorDirty = false;

            SuperGrid.ActiveEditor = null;
            SuperGrid.EditorCell = null;

            if (wasFocused == true)
                SuperGrid.Focus();

            SuperGrid.DoCloseEditEvent(GridPanel, this);

            if (GridPanel == null || GridPanel.NeedToUpdateDataFilter == true)
                InvalidateLayout();
            else
                InvalidateRender();

            SuperGrid.Update();
        }

        #endregion

        #region PositionEditPanel

        internal void PositionEditPanel(IGridCellEditControl editor)
        {
            PositionEditControl(editor);

            UpdateCellInfoWindowPos();

            ((Control)editor).Update();
            editor.EditorPanel.Update();
        }

        #endregion

        #region PostCellKeyDown

        ///<summary>
        /// PostCellKeyDown
        ///</summary>
        ///<returns></returns>
        internal void PostCellKeyDown(Keys keyData)
        {
            if (CanModifyMerge == true)
            {
                SuperGrid.DeactivateNonModalEditor();

                IGridCellEditControl editor = GetInternalEditControl();

                if (editor != null)
                {
                    KeyEventArgs e = new KeyEventArgs(keyData);

                    CellVisualStyle style = GetEffectiveStyle();

                    InitializeContext(DataContext.CellKeyEvent, editor, style);

                    editor.CellKeyDown(e);
                }

                PostInternalMouseMove();
            }
        }

        #endregion

        #region PositionEditControl

        ///<summary>
        /// PositionEditControl
        ///</summary>
        ///<param name="editor"></param>
        private void PositionEditControl(IGridCellEditControl editor)
        {
            if (GridColumn != null)
            {
                GridPanel panel = GridPanel;

                if (panel != null)
                {
                    Control c = (Control) editor;

                    Rectangle r = GetAdjustedBounds(ContentBounds);
                    Rectangle e = GetEditPanelBounds(editor, r);
                    e = GetClippedBounds(panel, e);

                    switch (editor.CellEditMode)
                    {
                        case CellEditMode.Modal:
                        case CellEditMode.NonModal:
                            if (GetCellHighlightMode(panel) == CellHighlightMode.Content)
                            {
                                r = GetEditPanelBounds(editor, r);
                                e = GetClippedBounds(panel, r);
                            }

                            editor.EditorPanel.Bounds = e;

                            c.Bounds = GetEditorBounds(editor, r, e);

                            editor.EditorPanel.SizeEx = Bounds.Size;
                            editor.EditorPanel.OffsetEx = new Point(Bounds.X - e.X, Bounds.Y - e.Y);

                            if (editor.CellEditMode == CellEditMode.NonModal)
                            {
                                editor.EditorPanel.BringToFront();
                                editor.EditorPanel.Show();
                            }
                            break;

                        case CellEditMode.InPlace:
                            r.Intersect(SuperGrid.SViewRect);
                            r.Location = Point.Empty;

                            c.Bounds = r;
                            break;
                    }
                }
            }
        }

        #region GetEditPanelBounds

        private Rectangle GetEditPanelBounds(IGridCellEditControl editor, Rectangle r)
        {
            CellVisualStyle style = GetEffectiveStyle();

            int n = r.Right;

            if (SuperGrid.EditorCell != this)
            {
                AlignHorizontally(editor, style, ref r);
            }
            else
            {
                if (GetCellHighlightMode(GridPanel) == CellHighlightMode.Content)
                    n -= 2;
            }

            if (r.Right > n)
                r.Width -= (r.Right - n);

            n = r.Bottom - 1;

            AlignVertically(editor, style, ref r);

            if (r.Bottom > n)
                r.Height -= (r.Bottom - n);

            return (r);
        }

        #endregion

        #region AlignHorizontally

        private void AlignHorizontally(
            IGridCellEditControl editor, CellVisualStyle style, ref Rectangle r)
        {
            Size size = _ContentSize;

            switch (editor.StretchBehavior)
            {
                case StretchBehavior.Both:
                case StretchBehavior.HorizontalOnly:
                    size.Width = r.Width;
                    break;

                default:
                    if (size.Width <= 0)
                    {
                        GetCurrentContentSize(style, editor);

                        size = _ContentSize;
                    }

                    if (size.Width <= 0)
                    {
                        size.Width = r.Width;
                    }
                    else if (r.Width > size.Width)
                    {
                        switch (style.Alignment)
                        {
                            case Alignment.TopCenter:
                            case Alignment.MiddleCenter:
                            case Alignment.BottomCenter:
                                r.X += ((r.Width - size.Width) / 2);
                                break;

                            case Alignment.TopRight:
                            case Alignment.MiddleRight:
                            case Alignment.BottomRight:
                                r.X += (r.Width - size.Width - 1);
                                break;
                        }
                    }
                    break;
            }

            r.Width = size.Width;
        }

        #endregion

        #region AlignVertically

        private void AlignVertically(
            IGridCellEditControl editor, CellVisualStyle style, ref Rectangle r)
        {
            Size size = _ContentSize;

            switch (editor.StretchBehavior)
            {
                case StretchBehavior.Both:
                case StretchBehavior.VerticalOnly:
                    size.Height = r.Height;
                    break;

                default:
                    if (size.Height <= 0)
                    {
                        size.Height = r.Height;
                    }
                    else if (r.Height > size.Height)
                    {
                        switch (style.Alignment)
                        {
                            case Alignment.MiddleLeft:
                            case Alignment.MiddleCenter:
                            case Alignment.MiddleRight:
                                r.Y += ((r.Height - size.Height)/2);
                                break;

                            case Alignment.BottomLeft:
                            case Alignment.BottomCenter:
                            case Alignment.BottomRight:
                                r.Y += r.Height - size.Height;
                                break;
                        }
                    }
                    break;
            }

            r.Height = size.Height;
        }

        #endregion

        #region GetEditorBounds

        private Rectangle GetEditorBounds(
            IGridCellEditControl editor, Rectangle r, Rectangle e)
        {
            if (GetCellHighlightMode(GridPanel) == CellHighlightMode.Content)
            {
                r.X = 0;
                r.Y = 0;
            }
            else
            {
                r.X = (r.X - e.X);
                r.Y = (r.Y - e.Y);

                r = GetEditPanelBounds(editor, r);
            }

            return (r);
        }

        #endregion

        #endregion

        #region FocusEditor

        internal void FocusEditor(IGridCellEditControl editor)
        {
            if (((Control)editor).Focused == false)
                ((Control)editor).Focus();

            if (editor is IGridCellEditorFocus)
                ((IGridCellEditorFocus)editor).FocusEditor();
        }

        #endregion

        #region CellRender

        ///<summary>
        /// This routine can be called by a cell editor / renderer to
        /// perform default cell rendering provided by the grid.
        ///</summary>
        ///<param name="editor"></param>
        ///<param name="g"></param>
        public void CellRender(IGridCellEditControl editor, Graphics g)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                CellVisualStyle style = GetEffectiveStyle();

                CellRange cr = GetStateCellRange();

                Rectangle bounds = (cr != null) ? GetBounds(panel, cr.BackBounds) : Bounds;
                Rectangle rc = GetAdjustedBounds(GetContentBounds(panel, bounds));

                if (rc.Height > 0 && rc.Width > 0)
                {
                    RenderContent(g, panel, editor, style, rc, cr);
                    RenderCellInfo(g, panel);
                }
            }
        }

        #region RenderContent

        private void RenderContent(Graphics g, GridPanel panel,
            IGridCellEditControl editor, CellVisualStyle style, Rectangle rc, CellRange cr)
        {
            if (cr != null &&
                (editor.CellEditMode == CellEditMode.Modal || cr.AlwaysDisplayFormattedValue == true))
                RenderRangeContent(g, panel, style, rc, cr);
            else
                RenderCellContent(g, editor, style, rc);
        }

        #region RenderRangeContent

        private void RenderRangeContent(Graphics g,
            GridPanel panel, CellVisualStyle style, Rectangle rc, CellRange cr)
        {
            string s = cr.FormattedValue;

            if (string.IsNullOrEmpty(s) == false)
            {
                if (panel.EnableCellRangeMarkup == true)
                {
                    if (MarkupParser.IsMarkup(s) == true)
                    {
                        BodyElement markup = MarkupParser.Parse(s);

                        RenderTextMarkup(g, markup, style, rc);
                    }
                }
                else
                {
                    eTextFormat tf = style.GetTextFormatFlags();

                    TextDrawing.DrawString(g, s, style.Font, style.TextColor, rc, tf);
                }
            }
        }

        #region RenderTextMarkup

        private void RenderTextMarkup(Graphics g,
            BodyElement textMarkup, CellVisualStyle style, Rectangle r)
        {
            MarkupDrawContext d =
                new MarkupDrawContext(g, style.Font, style.TextColor, false);

            textMarkup.Arrange(new Rectangle(r.Location, r.Size), d);

            Size size = textMarkup.Bounds.Size;

            switch (style.Alignment)
            {
                case Alignment.MiddleLeft:
                case Alignment.MiddleCenter:
                case Alignment.MiddleRight:
                    if (r.Height > size.Height)
                        r.Y += (r.Height - size.Height) / 2;
                    break;

                default:
                    if (r.Height > size.Height)
                        r.Y = r.Bottom - size.Height;
                    break;
            }

            textMarkup.Bounds = new Rectangle(r.Location, size);

            Region oldClip = g.Clip;

            try
            {
                g.SetClip(r, CombineMode.Intersect);

                textMarkup.Render(d);
            }
            finally
            {
                g.Clip = oldClip;
            }
        }

        #endregion

        #endregion

        #region RenderCellContent

        private void RenderCellContent(Graphics g,
            IGridCellEditControl editor, CellVisualStyle style, Rectangle rc)
        {
            switch (editor.CellEditMode)
            {
                case CellEditMode.Modal:
                    string s = GetFormattedValueEx(editor);
                    eTextFormat tf = style.GetTextFormatFlags();

                    if (string.IsNullOrEmpty(s) == false)
                        TextDrawing.DrawString(g, s, style.Font, style.TextColor, rc, tf);
                    break;

                case CellEditMode.NonModal:
                case CellEditMode.InPlace:
                    Rectangle re = GetEditPanelBounds(editor, rc);

                    if (re.Width > 0 && re.Height > 0)
                    {
                        Bitmap bm = GetCellBitmap(editor, rc);

                        if (bm != null)
                        {
                            PaintButtonContent(editor, bm, rc, re);

                            g.DrawImageUnscaledAndClipped(bm, re);
                        }
                    }
                    break;
            }
        }

        #endregion

        #endregion

        #region RenderCellInfo

        private void RenderCellInfo(Graphics g, GridPanel panel)
        {
            if (ShowInfoCellImage(panel) == true)
            { 
                Image image = GetInfoImage();

                if (image != null)
                {
                    Rectangle rc = InfoImageBounds;

                    if (rc.Width > 0 && rc.Height > 0)
                        g.DrawImageUnscaledAndClipped(image, rc);
                }
            }
        }

        #region ShowInfoCellImage

        private bool ShowInfoCellImage(GridPanel panel)
        {
            if (panel.ShowCellInfo == false || _InfoText == null)
                return (false);

            if (_InfoText.Equals("") == false)
                return (true);

            return (panel.ShowCellInfoDisplayMode == ShowCellInfoDisplayMode.ShowWithEmptyText);
        }

        #endregion

        #endregion

        #region GetExpValue

        ///<summary>
        /// Gets the resultant value of the evaluated Cell Expression, if
        /// applicable. Otherwise returns the given value.
        ///</summary>
        ///<param name="source"></param>
        ///<returns></returns>
        public string GetExpValue(string source)
        {
            GridPanel panel = GridPanel;

            if (IsValueExpression == true &&
                panel.EnableCellExpressions == true)
            {
                EEval eval = panel.ExpDictionary[this];

                if (eval != null)
                {
                    while (true)
                    {
                        try
                        {
                            _ExpValue = eval.Evaluate();

                            string s = (_ExpValue != null)
                                           ? _ExpValue.ToString()
                                           : "";

                            InfoText = null;

                            return (s);
                        }
                        catch (Exception exp)
                        {
                            bool retry = false;
                            bool throwException = false;

                            if (SuperGrid.HasDataErrorHandler == true)
                            {
                                object value = _Value;

                                if (SuperGrid.DoDataErrorEvent(panel, this, exp,
                                   DataContext.CellExpressionEval, ref value, ref throwException, ref retry) == true)
                                {
                                    return (source);
                                }
                            }

                            if (throwException == true)
                                throw;

                            InfoText = exp.Message;

                            if (retry == false)
                                return ("####!");
                        }
                    }
                }
            }

            return (source);
        }

        #endregion

        #region GetCellBitmap

        /// <summary>
        /// Gets the cell paint bitmap
        /// </summary>
        /// <param name="editor"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        private Bitmap GetCellBitmap(IGridCellEditControl editor, Rectangle r)
        {
            Bitmap bm = editor.EditorCellBitmap;

            if (bm == null || bm.Size != r.Size)
            {
                if (bm != null)
                    bm.Dispose();

                bm = new Bitmap(r.Width, r.Height);

                editor.EditorCellBitmap = bm;
            }

            return (bm);
        }

        #endregion

        #region PaintButtonContent

        /// <summary>
        /// Paints the button background and content
        /// </summary>
        private void PaintButtonContent(IGridCellEditControl editor,
            Bitmap bm, Rectangle rc, Rectangle re)
        {
            Control c = (Control)editor;

            // SizeEx is the size of the Adjusted Content size of the cell
            // OffsetEx is the offset from the Editor panel to the cell ContentBounds.

            editor.EditorPanel.Size = re.Size;
            editor.EditorPanel.SizeEx = rc.Size;
            editor.EditorPanel.OffsetEx = new Point(rc.X - re.X, rc.Y - re.Y);

            // Set the control bounds and initiate the
            // transfer of the control image to our bitmap.

            re.Location = Point.Empty;

            editor.SuspendUpdate = true;

            if (editor.EditorPanel.IsHandleCreated == false)
            {
                editor.EditorPanel.Show();
                editor.EditorPanel.BringToFront();
                editor.EditorPanel.Hide();
            }

            c.Bounds = re;
            c.DrawToBitmap(bm, re);

            editor.SuspendUpdate = false;
        }

        #endregion

        #endregion

        #region PaintEditorBackground

        ///<summary>
        /// Performs default cell background painting for the cell.
        ///</summary>
        ///<param name="e"></param>
        ///<param name="editor"></param>
        public void PaintEditorBackground(PaintEventArgs e, IGridCellEditControl editor)
        {
            Rectangle r = new Rectangle();

            r.Size = editor.EditorPanel.SizeEx;
            r.Location = Point.Empty;

            if (r.Width > 0 && r.Height > 0)
            {
                Graphics g = e.Graphics;

                if (SuperGrid.DoPreRenderCellEvent(g, this, RenderParts.Background, r) == false)
                {
                    GridPanel panel = GridPanel;
                    CellHighlightMode mode = GetCellHighlightMode(panel);

                    using (Brush br = GetContentBrush(panel, r, mode))
                        g.FillRectangle(br, r);

                    SuperGrid.DoPostRenderCellEvent(g, this, RenderParts.Background, r);
                }
            }
        }

        #endregion

        #region ExtendSelection

        ///<summary>
        /// ExtendSelection
        ///</summary>
        internal void ExtendSelection(GridPanel panel)
        {
            if (IsMouseSelectable() == true)
            {
                Capture = true;

                ExtendSelectionEx(panel);
            }
        }

        private void ExtendSelectionEx(GridPanel panel)
        {
            _mouseDownHitCell = this;
            _mouseDownHitArea = CellArea.InContent;

            if (panel.SelectionRowAnchor == null)
                panel.SelectionRowAnchor = GridRow;

            if (_hitCell != null)
            {
                _anchorRowIndex = _hitCell.GridRow.GridIndex;
                _anchorColumnIndex = panel.Columns.GetDisplayIndex(GridColumn);

                ProcessExtendSelection(panel, false);

                if (panel.LastProcessedItem != _hitCell)
                    GridRow.EditorDirty = false;

                if (SuperGrid.ActiveNonModalEditor != null)
                {
                    SuperGrid.Update();

                    if (SuperGrid.ActiveNonModalEditor != null)
                        SuperGrid.ActiveNonModalEditor.EditorPanel.Invalidate(true);
                }
            }
        }

        #region IsMouseSelectable

        private bool IsMouseSelectable()
        {
            if ((Control.MouseButtons & MouseButtons.Left) == MouseButtons.Left)
                return (true);

            return (IsSelected == false);
        }

        #endregion

        #endregion

        #region InitializeContext

        private void InitializeContext(DataContext dataContext,
            IGridCellEditControl editor, CellVisualStyle style)
        {
            if (((Control) editor).Handle != null)
            {
                object value = Value;

                if (InitializeContextEx(dataContext, editor, style) == true)
                    Value = value;
            }
        }

        private bool InitializeContextEx(DataContext dataContext,
            IGridCellEditControl editor, CellVisualStyle style)
        {
            object value = Value;

            while (true)
            {
                bool suspended = editor.SuspendUpdate;

                try
                {
                    IsDataError = false;

                    editor.SuspendUpdate = true;
                    editor.EditorPanel.GridCell = this;

                    editor.InitializeContext(this, style);

                    SuperGrid.DoInitEditContextEvent(this, editor);

                    return (false);
                }
                catch (Exception exp)
                {
                    bool retry = false;
                    bool throwException = false;

                    if (SuperGrid.HasDataErrorHandler == true)
                    {
                        if (SuperGrid.DoDataErrorEvent(GridPanel, this, exp,
                            dataContext, ref value, ref throwException, ref retry) == true)
                        {
                            return (true);
                        }
                    }
                    else
                    {
                        IsDataError = true;

                        return (false);
                    }

                    if (throwException == true)
                        throw;

                    if (retry == false)
                        break;

                    Value = value;
                }
                finally
                {
                    editor.SuspendUpdate = suspended;
                }
            }

            return (true);
        }

        #endregion

        #region CellRender

        private void CellRender(Graphics g,
            CellVisualStyle style, IGridCellEditControl renderer)
        {
            if (renderer.CellEditMode != CellEditMode.Modal)
            {
                try
                {
                    renderer.SuspendUpdate = true;

                    InitializeContext(DataContext.CellRender, renderer, style);
                    renderer.CellRender(g);
                }
                finally
                {
                    renderer.SuspendUpdate = false;
                }
            }
            else
            {
                InitializeContext(DataContext.CellRender, renderer, style);
                renderer.CellRender(g);
            }
        }

        #endregion

        #region SetEditorDirty

        ///<summary>
        /// Called by the cell editor to conditionally set
        /// the cells row level EditorDirty state.
        ///</summary>
        ///<param name="editor"></param>
        public void SetEditorDirty(IGridCellEditControl editor)
        {
            if (GridColumn.MarkRowDirtyOnCellValueChange == true)
            {
                if (SuperGrid.DoRowMarkedDirtyEvent(this, editor) == false)
                    EditorDirty = true;
            }
        }

        #endregion

        #region EditorValueChanged

        ///<summary>
        /// This routine is called by cell editors to signal to the grid
        /// that the editor has changed the cell Value.
        ///</summary>
        ///<param name="editor"></param>
        public void EditorValueChanged(IGridCellEditControl editor)
        {
            if (editor.SuspendUpdate == false)
            {
                SuperGrid.DoEditorValueChangedEvent(this, editor);

                editor.EditorValueChanged = true;
            }
        }

        #endregion

        #endregion

        #region UpdateBoundingRects

        private void UpdateBoundingRects()
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                _BoundsUpdateCount = SuperGrid.BoundsUpdateCount;

                _BackBounds = GetBackBounds(panel);
                _Bounds = GetBounds(panel);
            }
        }

        #region GetBackBounds

        /// <summary>
        /// Gets the scroll adjusted background bounding rectangle
        /// </summary>
        /// <param name="panel"></param>
        /// <returns></returns>
        internal Rectangle GetBackBounds(GridPanel panel)
        {
            Rectangle r = BoundsRelative;

            if (panel.IsSubPanel == false)
            {
                GridColumn column = GridColumn;

                if (column != null)
                {
                    if (column.IsHFrozen == false)
                        r.X -= HScrollOffset;
                }
            }
            else
            {
                r.X -= HScrollOffset;
            }

            if (GridRow.IsVFrozen == false)
                r.Y -= VScrollOffset;

            return (r);
        }

        #endregion

        #region GetBounds

        internal Rectangle GetBounds(GridPanel panel)
        {
            return (GetBounds(panel, BackBounds));
        }

        /// <summary>
        /// Gets the scroll adjusted bounding rectangle
        /// </summary>
        /// <param name="panel"></param>
        /// <param name="backBounds"></param>
        /// <returns></returns>
        internal Rectangle GetBounds(GridPanel panel, Rectangle backBounds)
        {
            Rectangle r = backBounds;

            r.Y += GridRow.EffectivePreDetailRowHeight;
            r.Height -= (GridRow.EffectivePreDetailRowHeight + GridRow.EffectivePostDetailRowHeight);

            return (r);
        }

        #endregion

        #region GetCellBounds

        /// <summary>
        /// Gets the SViewRect clipped Bounds
        /// </summary>
        /// <param name="panel"></param>
        /// <returns></returns>
        private Rectangle GetCellBounds(GridPanel panel)
        {
            return (GetClippedBounds(panel, Bounds));
        }

        #endregion

        #region GetContentBounds

        internal Rectangle GetContentBounds(GridPanel panel)
        {
            return (GetContentBounds(panel, Bounds));
        }

        /// <summary>
        /// Gets the cell content (excludes image) bounding rectangle
        /// </summary>
        /// <param name="panel"></param>
        /// <param name="bounds"></param>
        /// <returns></returns>
        internal Rectangle GetContentBounds(GridPanel panel, Rectangle bounds)
        {
            Rectangle r = bounds;

            int n = Dpi.Width(panel.LevelIndentSize.Width * _IndentLevel);

            CellRange cr = GetStateCellRange();

            if (HasPrimaryCell(panel, cr) == true)
            {
                if (panel.ShowTreeButtons == true || panel.ShowTreeLines == true)
                    n += panel.TreeButtonIndent;

                if (panel.CheckBoxes == true)
                    n += Dpi.Width(panel.CheckBoxSize.Width + (CheckBoxSpacing * 2));

                if (Merged == true)
                {
                    GridColumn col = panel.Columns.ColumnAtDisplayIndex(cr.ColumnStart);

                    n = Math.Max(n - (r.X - col.Bounds.X), 0);
                }

                r.X += n;
                r.Width -= n;
            }
            else if (panel.GroupColumns.Count > 0)
            {
                if (panel.Columns.FirstVisibleColumn == GridColumn)
                {
                    r.X += n;
                    r.Width -= n;
                }
            }

            CellVisualStyle style = GetEffectiveStyle();

            object figure = style.GetFigure(panel);

            if (figure != null)
                r = style.GetNonFigureBounds(panel, r);

            if (GridColumn.InfoImageOverlay == false)
            {
                if (string.IsNullOrEmpty(InfoText) == false)
                {
                    Image image = GetInfoImage();

                    if (image != null)
                    {
                        switch (GridColumn.InfoImageAlignment)
                        {
                            case Alignment.MiddleLeft:
                                r.X += (image.Size.Width + 4);
                                r.Width -= (image.Size.Width + 4);
                                break;

                            case Alignment.MiddleRight:
                                r.Width -= (image.Size.Width + 4);
                                break;
                        }
                    }
                }
            }

            r.Inflate(-1, -1);

            return (r);
        }

        #region IsPrimaryCell

        private bool HasPrimaryCell(GridPanel panel, CellRange cr)
        {
            if (cr != null)
                return (cr.ColumnStart == panel.Columns.GetDisplayIndex(panel.PrimaryColumn));

            return (panel.PrimaryColumnIndex == _ColumnIndex);

        }

        #endregion

        #endregion

        #region GetEditBounds

        /// <summary>
        /// Gets 
        /// </summary>
        /// <param name="panel"></param>
        /// <returns></returns>
        private Rectangle GetEditBounds(GridPanel panel)
        {
            Rectangle r = GetClippedBounds(panel, ContentBounds);

            r.Inflate(-1, -1);

            return (r);
        }

        #endregion

        #region GetClippedBounds

        private Rectangle GetClippedBounds(GridPanel panel, Rectangle r)
        {
            Rectangle v = SViewRect;

            if (IsVFrozen == true)
            {
                int n = panel.FixedRowHeight - panel.FixedHeaderHeight;

                v.Y -= n;
                v.Height += n;
            }

            if (GridColumn.IsHFrozen == false)
            {
                GridColumn pcol = panel.Columns.GetLastVisibleFrozenColumn();

                if (pcol != null)
                {
                    int n = Dpi.Width(pcol.BoundsRelative.Right - v.X);

                    v.X += n;
                    v.Width -= n;
                }
            }

            r.Intersect(v);

            return (r);
        }

        #endregion

        #endregion

        #region GetAdjustedBounds

        #region GetAdjustedBounds()

        private Rectangle GetAdjustedBounds()
        {
            Rectangle r = Bounds;

            switch (GridPanel.GridLines)
            {
                case GridLines.Both:
                    r.Width -= Dpi.Width1;
                    r.Height -= Dpi.Height1;
                    break;

                case GridLines.Vertical:
                    r.Width -= Dpi.Width1;
                    break;

                case GridLines.Horizontal:
                    r.Height -= Dpi.Height1;
                    break;
            }

            return (r);
        }

        #endregion

        #region GetAdjustedBounds(r)

        private Rectangle GetAdjustedBounds(Rectangle r)
        {
            CellVisualStyle style = GetEffectiveStyle();

            r.X += Dpi.Width(style.BorderThickness.Left + style.Margin.Left + style.Padding.Left);
            r.Width -= Dpi.Width(style.BorderThickness.Horizontal + style.Margin.Horizontal + style.Padding.Horizontal);

            r.Y += Dpi.Height(style.BorderThickness.Top + style.Margin.Top + style.Padding.Top);
            r.Height -= Dpi.Height(style.BorderThickness.Vertical + style.Margin.Vertical + style.Padding.Vertical);

            r.Width--;

            return (r);
        }

        #endregion

        #endregion

        #region GetCurrentContentSize

        private void GetCurrentContentSize(
            CellVisualStyle style, IGridCellEditControl editor)
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                Size oldSize = _ContentSize;
                int width = Bounds.Size.Width;

                object figure = style.GetFigure(panel);

                if (figure != null)
                {
                    Alignment alignment = style.ImageAlignment;

                    if (style.IsOverlayImage == true)
                        alignment = Alignment.MiddleCenter;

                    switch (alignment)
                    {
                        case Alignment.TopLeft:
                        case Alignment.TopRight:
                        case Alignment.MiddleLeft:
                        case Alignment.MiddleRight:
                        case Alignment.BottomLeft:
                        case Alignment.BottomRight:
                            width -= style.GetFigureSize(panel).Width;
                            break;
                    }
                }

                width -= (style.GetBorderSize(true).Width + 2);

                Size constraintSize = new Size(width, 0);

                using (Graphics g = SuperGrid.CreateGraphics())
                    _ContentSize = GetProposedSize(g, style, constraintSize, editor, CellSizingSource.ActualAndFormattedValues);

                if (_ContentSize != oldSize)
                    _BoundsUpdateCount = (ushort)(SuperGrid.BoundsUpdateCount - 1);
            }
        }

        #endregion

        #region GetCellEditBounds

        ///<summary>
        /// Get the CellEditBounds for the cell.
        ///</summary>
        ///<param name="editor"></param>
        ///<returns></returns>
        public Rectangle GetCellEditBounds(IGridCellEditControl editor)
        {
            Rectangle r = GetAdjustedBounds(ContentBounds);

            r = GetEditPanelBounds(editor, r);

            return (r);
        }

        #endregion

        #region GetFormattedValue

        internal string GetFormattedValue()
        {
            IGridCellEditControl editor = SuperGrid.EditorCell == this
                ? GetInternalEditControl() : GetInternalRenderControl();

            return (GetFormattedValue(editor));
        }

        internal string GetFormattedValue(IGridCellEditControl editor)
        {
            string s = null;

            if (editor == null || IsDataError == true)
            {
                if (_Value != null)
                    s = _Value.ToString();
            }
            else
            {
                bool suspended = editor.SuspendUpdate;

                try
                {
                    editor.SuspendUpdate = true;

                    if (SuperGrid.EditorCell != this)
                        InitializeContext(DataContext.CellGetFormattedValue, editor, null);

                    s = editor.EditorFormattedValue;
                }
                finally
                {
                    editor.SuspendUpdate = suspended;
                }

                if (s != null && s.TrimStart().StartsWith("=") == true)
                    s = GetExpValue(s);
            }

            CellSizingSource sizingSource = CellSizingSource.ActualAndFormattedValues;

            SuperGrid.DoGetCellFormattedValueEvent(this, ref s, ref sizingSource);

            return (s ?? "");
        }

        internal string GetFormattedValueEx(IGridCellEditControl editor)
        {
            string s = null;

            if (editor == null || IsDataError == true)
            {
                if (_Value != null)
                    s = _Value.ToString();
            }
            else
            {
                s = editor.EditorFormattedValue;

                if (s != null && s.TrimStart().StartsWith("=") == true)
                    s = GetExpValue(s);
            }

            CellSizingSource sizingSource = CellSizingSource.ActualAndFormattedValues;

            SuperGrid.DoGetCellFormattedValueEvent(this, ref s, ref sizingSource);

            return (s ?? "");
        }

        #endregion

        #region CellInfoWindow support

        #region UpdateInfoWindow

        private void UpdateInfoWindow()
        {
            GridPanel panel = GridPanel;

            if (panel != null)
            {
                if (SuperGrid.EditorCell != this)
                {
                    CloseCellInfoWindow();
                }
                else
                {
                    if (GridColumn.InfoImageOverlay == false)
                    {
                        if (SuperGrid.ActiveEditor != null)
                            PositionEditPanel(SuperGrid.ActiveEditor);
                    }
                    else
                    {
                        if (CanShowCellInfo(panel) == true)
                        {
                            if (_cellInfoWindow == null)
                                OpenCellInfoWindow();

                            UpdateCellInfoWindowPos();

                            _cellInfoWindow.Show();
                            _cellInfoWindow.BringToFront();
                        }
                        else
                        {
                            CloseCellInfoWindow();
                        }
                    }
                }
            }
        }

        #endregion

        #region CanShowCellInfo

        private bool CanShowCellInfo(GridPanel panel)
        {
            if (ShowInfoCellImage(panel) == true)
                return (GetInfoImage() != null);
                
            return (false);
        }

        #endregion

        #region UpdateCellInfoWindowPos

        private void UpdateCellInfoWindowPos()
        {
            if (_cellInfoWindow != null)
            {
                if (_cellInfoWindow != null)
                {
                    Point pt = InfoImageBounds.Location;

                    pt = SuperGrid.PointToScreen(pt);

                    if (SuperGrid.ActiveEditor != null)
                        pt = SuperGrid.ActiveEditor.EditorPanel.PointToClient(pt);

                    else if (SuperGrid.ActiveNonModalEditor != null)
                        pt = SuperGrid.ActiveNonModalEditor.EditorPanel.PointToClient(pt);

                    _cellInfoWindow.Location = pt;
                }
            }
        }

        #endregion

        #region OpenCellInfoWindow

        private void OpenCellInfoWindow()
        {
            _cellInfoWindow = new CellInfoWindow(SuperGrid, this);
            _cellInfoWindow.Parent = SuperGrid.ActiveEditor.EditorPanel;

            SuperGrid.ActiveEditor.EditorPanel.Controls.Add(_cellInfoWindow);
        }

        #endregion

        #region CloseCellInfoWindow

        private void CloseCellInfoWindow()
        {
            if (_cellInfoWindow != null)
            {
                SuperGrid.ToolTipText = "";

                _cellInfoWindow.Dispose();
                _cellInfoWindow = null;
            }
        }

        #endregion

        #endregion

        #region Style support

        #region GetEffectiveStyle

        ///<summary>
        /// Gets the EffectiveStyle for the cell. The effective
        /// style is the cached, composite style definition for the
        /// given cell, composed from panel, row, column, and cell styles.
        ///</summary>
        ///<returns></returns>
        public CellVisualStyle GetEffectiveStyle()
        {
            bool selected = IsSelected;

            StyleState cellState = GetCellState(selected);
            CellVisualStyle style = GetEffectiveStyle(cellState);

            return (style);
        }

        ///<summary>
        /// Gets the EffectiveStyle for the cell- for the given StyleType.
        /// The effective style is the cached, composite style definition for the
        /// given cell, composed from panel, row, column, and cell styles.
        ///</summary>
        ///<param name="type"></param>
        ///<returns></returns>
        public CellVisualStyle GetEffectiveStyle(StyleType type)
        {
            ValidateStyle();

            return (GetStyle(type));
        }

        internal CellVisualStyle GetEffectiveStyle(bool selected)
        {
            StyleState cellState = GetCellState(selected);

            return (GetEffectiveStyle(cellState));
        }

        private CellVisualStyle GetEffectiveStyle(StyleState cellState)
        {
            ValidateStyle();

            if (IsDesignerHosted == true)
                cellState &= ~(StyleState.MouseOver | StyleState.Selected);

            CellRange cr = GetStateCellRange();

            if (cr != null)
                return (cr.GetEffectiveStyle(RowContainer, cellState));

            if (IsEmptyCell == true &&
                (GridPanel.AllowEmptyCellSelection == false || cellState == StyleState.Default))
            {
                return (GetStyle(StyleType.Empty));
            }

            if (IsSelectable == false)
                return (GetStyle(StyleType.NotSelectable));

            switch (cellState)
            {
                case StyleState.MouseOver:
                    return (GetStyle(StyleType.MouseOver));

                case StyleState.Selected:
                    return (GetStyle(StyleType.Selected));

                case StyleState.Selected | StyleState.MouseOver:
                    return (GetStyle(StyleType.SelectedMouseOver));

                case StyleState.ReadOnly:
                    return (GetStyle(StyleType.ReadOnly));

                case StyleState.ReadOnly | StyleState.MouseOver:
                    return (GetStyle(StyleType.ReadOnlyMouseOver));

                case StyleState.ReadOnly | StyleState.Selected:
                    return (GetStyle(StyleType.ReadOnlySelected));

                case StyleState.ReadOnly | StyleState.MouseOver | StyleState.Selected:
                    return (GetStyle(StyleType.ReadOnlySelectedMouseOver));

                default:
                    return (GetStyle(StyleType.Default));
            }
        }

        #endregion

        #region GetCellState

        private StyleState GetCellState(bool selected)
        {
            StyleState cellState = StyleState.Default;

            if (IsReadOnly == true)
                cellState |= StyleState.ReadOnly;

            if (SuperGrid.EditorCell != null || SuperGrid.NonModalEditorCell != null)
            {
                if (SuperGrid.EditorCell == this || SuperGrid.NonModalEditorCell == this)
                    cellState |= StyleState.MouseOver;
            }
            else
            {
                if (CapturedItem == null || CapturedItem is GridCell)
                {
                    Point pt = SuperGrid.PointToClient(Control.MousePosition);
                    Rectangle r = Bounds;

                    GridPanel panel = GridPanel;

                    if (Merged == true)
                    {
                        CellRange cr = GetStateCellRange();

                        if (cr != null)
                            r = GetBounds(panel, cr.BackBounds);
                    }

                    Rectangle t = ViewRect;

                    r.Intersect(t);

                    if (r.Contains(pt) == true)
                        cellState |= StyleState.MouseOver;
                }
            }

            if (selected == true)
                cellState |= StyleState.Selected;

            return (cellState);
        }

        #endregion

        #region GetStyle

        private CellVisualStyle GetStyle(StyleType e)
        {
            CellVisualStyles cvs = _EffectiveStyles;

            if (cvs == null)
                cvs = new CellVisualStyles();

            if (cvs.IsValid(e) == false)
            {
                CellVisualStyle style = new CellVisualStyle();

                StyleType[] css = style.GetApplyStyleTypes(e);

                if (css != null)
                {
                    foreach (StyleType cs in css)
                    {
                        GridColumn.ApplyCellStyle(style, cs);
                        GridRow.ApplyCellStyle(style, cs);

                        style.ApplyStyle(CellStyles[cs]);
                    }
                }

                SuperGrid.DoGetCellStyleEvent(this, e, ref style);

                if (style.Background == null || style.Background.IsEmpty == true)
                    style.Background = new Background(Color.White);

                if (style.Font == null)
                    style.Font = SystemFonts.DefaultFont;

                style.ApplyDefaults();

                cvs[e] = style;

                _EffectiveStyles = cvs;
            }

            return (cvs[e]);
        }

        #endregion

        #region GetSizingStyle

        private CellVisualStyle GetSizingStyle(GridPanel panel)
        {
            StyleType style = panel.GetSizingStyle();

            if (style == StyleType.NotSet)
            {
                style = (IsReadOnly == true)
                    ? StyleType.ReadOnly : StyleType.Default;
            }

            return (GetEffectiveStyle(style));
        }

        #endregion

        #region StyleVisualChangeHandler

        private void StyleVisualChangeHandler(
            INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
        {
            //NeedsMeasured = true;

            if (oldValue != null)
                oldValue.PropertyChanged -= StyleChanged;

            if (newValue != null)
                newValue.PropertyChanged += StyleChanged;
        }

        #endregion

        #region StyleChanged

        /// <summary>
        /// Occurs when one of element visual styles has property changes.
        /// Default implementation invalidates visual appearance of element.
        /// </summary>
        /// <param name="sender">VisualStyle that changed.</param>
        /// <param name="e">Event arguments.</param>
        protected virtual void StyleChanged(object sender, PropertyChangedEventArgs e)
        {
            ClearEffectiveStyles();

            VisualChangeType changeType = ((VisualPropertyChangedEventArgs)e).ChangeType;

            if (changeType == VisualChangeType.Layout)
            {
                NeedsMeasured = true;

                if (GridColumn != null)
                    GridColumn.NeedsMeasured = true;

                InvalidateLayout();
            }
            else
            {
                InvalidateRender();
            }
        }

        #endregion

        #region ValidateStyle

        private void ValidateStyle()
        {
            if (_StyleUpdateCount != SuperGrid.StyleUpdateCount)
            {
                ClearEffectiveStyles();

                _StyleUpdateCount = SuperGrid.StyleUpdateCount;
            }
        }

        #endregion

        #region InvalidateStyle

        ///<summary>
        ///Invalidates the cached Style
        ///definition for all defined StyleTypes
        ///</summary>
        public void InvalidateStyle()
        {
            ClearEffectiveStyles();

            InvalidateLayout();
        }

        ///<summary>
        ///Invalidate the cached Style
        ///definition for the given StyleType
        ///</summary>
        ///<param name="type"></param>
        public void InvalidateStyle(StyleType type)
        {
            if (_EffectiveStyles != null)
            {
                if (_EffectiveStyles[type] != null)
                {
                    _EffectiveStyles[type].Dispose();
                    _EffectiveStyles[type] = null;

                    InvalidateLayout();
                }
            }
        }

        #endregion

        #region ClearEffectiveStyles

        internal void ClearEffectiveStyles()
        {
            if (_EffectiveStyles != null)
            {
                _EffectiveStyles.Dispose();
                _EffectiveStyles = null;
            }
        }

        #endregion

        #endregion

        #region InvalidateRender

        /// <summary>
        /// InvalidateRender
        /// </summary>
        public override void InvalidateRender()
        {
            if (SuperGrid != null && GridColumn != null)
            {
                if (Merged == true)
                {
                    CellRange cr = GetStateCellRange();

                    if (cr != null)
                        InvalidateRender(cr.BackBounds);
                }
                else
                {
                    base.InvalidateRender(BackBounds);
                }
            }
        }

        #endregion

        #region IComparable<GridCell> Members

        /// <summary>
        /// CompareTo
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public int CompareTo(GridCell other)
        {
            int sval = 0;
            if (SuperGrid.DoCompareElementsEvent(GridPanel, this, other, ref sval) == true)
                return (sval);

            if (GridPanel.SortUsingHiddenColumns == false)
            {
                if (Visible == false)
                    return (other.Visible == false ? 0 : -1);

                if (other.Visible == false)
                    return (1);
            }

            object val1 = IsValueExpression ? ExpValue : Value;
            object val2 = other.IsValueExpression ? other.ExpValue : other.Value;

            return (CompareVal.CompareTo(val1, val2));
        }

        #endregion

        #region ToString

        /// <summary>
        /// ToString
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string s = "GridCell " + ColumnIndex +
                ": {" + (Value ?? "<null>") + "}";

            return (s);
        }

        #endregion

        #region Dispose

        /// <summary>
        /// Dispose
        /// </summary>
        public void Dispose()
        {
            MouseRenderer = null;

            EditControl = null;
            RenderControl = null;

            CellStyles = null;

            ClearEffectiveStyles();

            if (SuperGrid != null)
            {
                if (SuperGrid.ActiveElement == this)
                    SuperGrid.ActiveElement = null;
            }
        }

        #endregion

        #region EditorInfo

        private class EditorInfo
        {
            #region Public variables

            public Type EditorType;
            public Type RenderType;

            public IGridCellEditControl EditControl;
            public IGridCellEditControl RenderControl;

            public object[] EditorParams;
            public object[] RenderParams;

            #endregion

            #region Public properties

            public bool IsEmpty
            {
                get
                {
                    return (EditorType == null && RenderType == null &&
                            (EditorParams == null && RenderParams == null));
                }
            }

            #endregion
        }

        #endregion

        #region CellStates

        [Flags]
        private enum Cs
        {
            AllowEdit = (1 << 0),
            DataError = (1 << 1),
            EmptyCell = (1 << 2),
            ReadOnly = (1 << 3),
            Selected = (1 << 4),
            AnySelected = (1 << 5),
            ValueExpression = (1 << 6),

            MergedTop = (1 << 7),
            MergedLeft = (1 << 8),
            MergedBottom = (1 << 9),
            MergedRight = (1 << 10),
            Merged = (1 << 11),

            Modified = (1 << 12),
        }

        #endregion
    }

    #region CompareVal

    internal class CompareVal
    {
        public static int CompareTo(object val1, object val2)
        {
            if (val1 != null && val1 != DBNull.Value)
            {
                if (val2 != null && val2 != DBNull.Value)
                {
                    if (val1.GetType() == val2.GetType())
                    {
                        IComparable icompa = val1 as IComparable;

                        if (icompa != null)
                            return (icompa.CompareTo(val2));
                    }

                    return (-1);
                }

                return (1);
            }

            if (val2 != null && val2 != DBNull.Value)
                return (-1);

            return (0);
        }
    }

    #endregion

    #region enums

    #region CellArea

    ///<summary>
    /// CellArea
    ///</summary>
    public enum CellArea
    {
        ///<summary>
        /// NoWhere
        ///</summary>
        NoWhere,

        ///<summary>
        /// InContent
        ///</summary>
        InContent,

        ///<summary>
        /// InExpandButton
        ///</summary>
        InExpandButton,

        ///<summary>
        /// InCheckBox
        ///</summary>
        InCheckBox,

        ///<summary>
        /// InCellInfo
        ///</summary>
        InCellInfo,
    }

    #endregion

    #region CellMergeMode

    ///<summary>
    /// Specifies the type of merging that is permitted
    /// for cells in the given row or column
    ///</summary>
    [Flags]
    public enum CellMergeMode
    {
        ///<summary>
        /// Not set
        ///</summary>
        NotSet = (0 << 0),

        ///<summary>
        /// No merging
        ///</summary>
        None = (1 << 0),

        ///<summary>
        /// Cells can merge horizontally Left
        ///</summary>
        HorizontalLeft = (1 << 1),

        ///<summary>
        /// Cells can merge horizontally Right
        ///</summary>
        HorizontalRight = (1 << 2),

        ///<summary>
        /// Cells can merge horizontally (both left and right)
        ///</summary>
        Horizontal = (HorizontalLeft | HorizontalRight),

        ///<summary>
        /// Cells can merge vertically
        ///</summary>
        Vertical = (1 << 3),

        ///<summary>
        /// Cells can merge both horizontally and vertically
        ///</summary>
        HorizontalAndVertical = (Horizontal | Vertical),
    }

    ///<summary>
    /// Specifies the type of merging that is permitted
    /// for cells in the given row or column
    ///</summary>
    public enum CellMergeOrder
    {
        ///<summary>
        /// Cells can merge horizontally, then vertically
        ///</summary>
        HorizontalThenVertical,

        ///<summary>
        /// Cells can merge vertically, then horizontally (this is the default
        /// if CellMergeMode enables both vertical and horizontal merging)
        ///</summary>
        VerticalThenHorizontal,
    }

    #endregion

    #region CellSizingSource

    /// <summary>
    /// Specifies the cell value source for the cell
    /// sizing operation (either the actual value, formatted value,
    /// or both)
    /// </summary>
    public enum CellSizingSource
    {
        ActualValue = (1 << 0),      // The actual, unformatted cell value
        FormattedValue = (1 << 1),   // The formatted cell value

        ActualAndFormattedValues = (ActualValue | FormattedValue),  // The actual and formatted cell values
                                                                    // (the maximum width/height of the two is used).
    }

    #endregion

    #endregion

    #region ValueTypeConverter

    ///<summary>
    /// ValueTypeConverter
    ///</summary>
    public class ValueTypeConverter : TypeConverter
    {
        #region CanConvertTo

        /// <summary>
        /// CanConvertTo
        /// </summary>
        /// <param name="context"></param>
        /// <param name="destinationType"></param>
        /// <returns></returns>
        public override bool CanConvertTo(
            ITypeDescriptorContext context, Type destinationType)
        {
            if (destinationType == typeof(string))
                return (true);

            return (base.CanConvertTo(context, destinationType));
        }

        #endregion

        #region ConvertTo

        /// <summary>
        /// ConvertTo
        /// </summary>
        /// <param name="context"></param>
        /// <param name="culture"></param>
        /// <param name="value"></param>
        /// <param name="destinationType"></param>
        /// <returns></returns>
        public override object ConvertTo(
            ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                string s = value as string;

                if (s != null)
                    return (s);
            }

            return (base.ConvertTo(context, culture, value, destinationType));
        }

        #endregion

        #region CanConvertFrom

        /// <summary>
        /// CanConvertFrom
        /// </summary>
        /// <param name="context"></param>
        /// <param name="sourceType"></param>
        /// <returns></returns>
        public override bool CanConvertFrom(
            ITypeDescriptorContext context, Type sourceType)
        {
            if (sourceType == typeof(string))
                return (true);

            return (base.CanConvertFrom(context, sourceType));
        }

        #endregion

        #region ConvertFrom

        /// <summary>
        /// ConvertFrom
        /// </summary>
        /// <param name="context"></param>
        /// <param name="culture"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public override object ConvertFrom(
            ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            if (value is string)
            {
                GridCell cell = context.Instance as GridCell;

                if (cell != null)
                {
                    Type type = GetEditType(cell);

                    if (type == typeof (GridDoubleInputEditControl))
                        return (ConvertFromToDouble((string)value));

                    if (type == typeof (GridIntegerInputEditControl) ||
                        type == typeof (GridProgressBarXEditControl) ||
                        type == typeof (GridSliderEditControl) ||
                        type == typeof (GridTrackBarEditControl))
                    {
                        return (ConvertFromToInteger((string) value));
                    }

                    if (type == typeof (GridNumericUpDownEditControl))
                        return (ConvertFromToDecimal((string)value));

                    if (type == typeof (GridCheckBoxXEditControl) ||
                        type == typeof (GridCheckBoxEditControl) ||
                        type == typeof(GridSwitchButtonEditControl))
                    {
                        return (ConvertFromToBool((string) value));
                    }
                }

                return (value);
            }

            return base.ConvertFrom(context, culture, value);
        }

        #region ConvertFromToDouble

        private double ConvertFromToDouble(string value)
        {
            try
            {
                return (double.Parse(value));
            }
            catch (Exception)
            {
                throw new ArgumentException("Invalid value to convert to 'double'.");
            }
        }

        #endregion

        #region ConvertFromToInteger

        private int ConvertFromToInteger(string value)
        {
            try
            {
                return (int.Parse(value));
            }
            catch (Exception)
            {
                throw new ArgumentException("Invalid value to convert to 'int'.");
            }
        }

        #endregion

        #region ConvertFromToDecimal

        private decimal ConvertFromToDecimal(string value)
        {
            try
            {
                return (decimal.Parse(value));
            }
            catch (Exception)
            {
                throw new ArgumentException("Invalid value to convert to 'decimal'.");
            }
        }

        #endregion

        #region ConvertFromToBool

        private bool ConvertFromToBool(string value)
        {
            switch (value.ToLower())
            {
                case "y":
                case "yes":
                case "t":
                case "true":
                case "1":
                    return (true);

                case "":
                case "0":
                case "n":
                case "no":
                case "f":
                case "false":
                case null:
                    return (false);

                default:
                    throw new ArgumentException("Invalid value to convert to 'bool'.");
            }
        }

        #endregion

        #endregion

        #region GetEditType

        private Type GetEditType(GridCell cell)
        {
            if (cell.EditorType != null)
                return (cell.EditorType);

            if (cell.GridColumn != null)
                return (cell.GridColumn.EditorType);

            return (null);
        }

        #endregion
    }

    #endregion
}