spc-kiosk-pb/Window/WinOpenClose/DataGridViewRadioButtonCell.cs

using System;
using System.Drawing;
using System.Globalization;
using System.ComponentModel;
using System.Windows.Forms;
using System.Windows.Forms.VisualStyles;
using System.Diagnostics;

namespace DataGridViewRadioButtonElements
{
    public class DataGridViewRadioButtonCell : DataGridViewComboBoxCell, IDataGridViewEditingCell
    {
        /// <summary>
        /// Convenient enumeration using privately for calculating preferred cell sizes.
        /// </summary>
        private enum DataGridViewRadioButtonFreeDimension
        {
            Both,
            Height,
            Width
        }

        // 4 pixels of margin on the left and right of error icons
        private const byte DATAGRIDVIEWRADIOBUTTONCELL_iconMarginWidth = 4;
        // 4 pixels of margin on the top and bottom of error icons
        private const byte DATAGRIDVIEWRADIOBUTTONCELL_iconMarginHeight = 4;
        // all icons are 12 pixels wide by default
        private const byte DATAGRIDVIEWRADIOBUTTONCELL_iconsWidth = 12;
        // all icons are 11 pixels tall by default
        private const byte DATAGRIDVIEWRADIOBUTTONCELL_iconsHeight = 11;

        // default value of MaxDisplayedItems property
        internal const int DATAGRIDVIEWRADIOBUTTONCELL_defaultMaxDisplayedItems = 5; 
        // blank pixels around each radio button entry
        private const byte DATAGRIDVIEWRADIOBUTTONCELL_margin = 2;

        // codes used for the mouseLocationCode static variable:
        private const int DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric = -3;
        private const int DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationBottomScrollButton = -2; // mouse is over bottom scroll button
        private const int DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationTopScrollButton = -1;    // mouse is over top scroll button

        private DataGridViewRadioButtonCellLayout layout;   // represents the current layout information of the cell

        private static int mouseLocationCode = DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric; 
                                               // -3 no particular location
                                               // -2 mouse over bottom scroll button
                                               // -1 mouse over top scroll button
                                               // 0-N mouse over radio button glyph
        
        private PropertyDescriptor displayMemberProperty;   // Property descriptor for the DisplayMember property
        private PropertyDescriptor valueMemberProperty;     // Property descriptor for the ValueMember property
        private CurrencyManager dataManager;                // Currency manager for the cell's DataSource
        private int maxDisplayedItems;                      // Maximum number of radio buttons displayed by the cell
        private int selectedItemIndex;                      // Index of the currently selected radio button entry
        public int focusedItemIndex;                       // Index of the focused radio button entry
        private int pressedItemIndex;                       // Index of the currently pressed radio button entry
        private bool dataSourceInitializedHookedUp;         // Indicates whether the DataSource's Initialized event is listened to
        private bool valueChanged;                          // Stores whether the cell's value was changed since it became the current cell
        private bool handledKeyDown;                        // Indicates whether the cell handled the key down notification
        private bool mouseUpHooked;                         // Indicates whether the cell listens to the grid's MouseUp event
        
        /// <summary>
        /// DataGridViewRadioButtonCell class constructor.
        /// </summary>
        public DataGridViewRadioButtonCell()
        {
            this.maxDisplayedItems = DATAGRIDVIEWRADIOBUTTONCELL_defaultMaxDisplayedItems;
            this.layout = new DataGridViewRadioButtonCellLayout();
            this.selectedItemIndex = -1;
            this.focusedItemIndex = -1;
            this.pressedItemIndex = -1;
        }

        // Implementation of the IDataGridViewEditingCell interface starts here.

        /// <summary>
        /// Represents the cell's formatted value
        /// </summary>
        public virtual object EditingCellFormattedValue
        {
            get
            {
                return GetEditingCellFormattedValue(DataGridViewDataErrorContexts.Formatting);
            }
            set
            {
                if (this.FormattedValueType == null)
                {
                    throw new ArgumentException("FormattedValueType property of a cell cannot be null.");
                }
                if (value == null || !this.FormattedValueType.IsAssignableFrom(value.GetType()))
                {
                    // Assigned formatted value may not be of the good type, in cases where the app
                    // is feeding wrong values to the cell in virtual / databound mode.
                    throw new ArgumentException("The value provided for the DataGridViewRadioButtonCell has the wrong type.");
                }

                // Try to locate the item that corresponds to the 'value' provided.
                for (int itemIndex = 0; itemIndex < this.Items.Count; itemIndex++)
                {
                    object item = this.Items[itemIndex];
                    object displayValue = GetItemDisplayValue(item);
                    if (value.Equals(displayValue))
                    {
                        // 'value' was found. It becomes the new selected item.
                        this.selectedItemIndex = itemIndex;
                        return;
                    }
                }

                string strValue = value as string;
                if (strValue == string.Empty)
                {
                    // Special case the empty string situation - reset the selected item
                    this.selectedItemIndex = -1;
                    return;
                }

                // 'value' could not be matched against an item in the Items collection.
                throw new ArgumentException();
            }
        }

        /// <summary>
        /// Keeps track of whether the cell's value has changed or not.
        /// </summary>
        public virtual bool EditingCellValueChanged
        {
            get
            {
                return this.valueChanged;
            }
            set
            {
                this.valueChanged = value;
            }
        }

        /// <summary>
        /// Returns the current formatted value of the cell
        /// </summary>
        public virtual object GetEditingCellFormattedValue(DataGridViewDataErrorContexts context)
        {
            if (this.FormattedValueType == null)
            {
                throw new InvalidOperationException("FormattedValueType property of a cell cannot be null.");
            }
            if (this.selectedItemIndex == -1)
            {
                return null;
            }
            object item = this.Items[this.selectedItemIndex];
            object displayValue = GetItemDisplayValue(item);
            // Making sure the returned value has an acceptable type
            if (this.FormattedValueType.IsAssignableFrom(displayValue.GetType()))
            {
                return displayValue;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Called by the grid when the cell enters editing mode. 
        /// </summary>
        public virtual void PrepareEditingCellForEdit(bool selectAll)
        {
            // This cell type has nothing to do here.
        }

        // Implementation of the IDataGridViewEditingCell interface stops here.

        /// <summary>
        /// Stores the CurrencyManager associated to the cell's DataSource
        /// </summary>
        private CurrencyManager DataManager
        {
            get
            {
                CurrencyManager cm = this.dataManager;
                if (cm == null && this.DataSource != null && this.DataGridView != null && 
                    this.DataGridView.BindingContext != null && !(this.DataSource == Convert.DBNull))
                {
                    ISupportInitializeNotification dsInit = this.DataSource as ISupportInitializeNotification;
                    if (dsInit != null && !dsInit.IsInitialized)
                    {
                        // The datasource is not ready yet. Attaching to its Initialized event to be notified
                        // when it's finally ready
                        if (!this.dataSourceInitializedHookedUp)
                        {
                            dsInit.Initialized += new EventHandler(DataSource_Initialized);
                            this.dataSourceInitializedHookedUp = true;
                        }
                    }
                    else
                    {
                        cm = (CurrencyManager)this.DataGridView.BindingContext[this.DataSource];
                        this.DataManager = cm;
                    }
                }
                return cm;
            }
            set
            {
                this.dataManager = value;
            }
        }

        /// <summary>
        /// Overrides the DataGridViewComboBox's implementation of the DataSource property to 
        /// initialize the displayMemberProperty and valueMemberProperty members.
        /// </summary>
        public override object DataSource
        {
            get
            {
                return base.DataSource;
            }
            set
            {
                if (this.DataSource != value)
                {
                    // Invalidate the currency manager
                    this.DataManager = null;

                    ISupportInitializeNotification dsInit = this.DataSource as ISupportInitializeNotification;
                    if (dsInit != null && this.dataSourceInitializedHookedUp)
                    {
                        // If we previously hooked the datasource's ISupportInitializeNotification
                        // Initialized event, then unhook it now (we don't always hook this event,
                        // only if we needed to because the datasource was previously uninitialized)
                        dsInit.Initialized -= new EventHandler(DataSource_Initialized);
                        this.dataSourceInitializedHookedUp = false;
                    }

                    base.DataSource = value;

                    // Update the displayMemberProperty and valueMemberProperty members.
                    try
                    {
                        InitializeDisplayMemberPropertyDescriptor(this.DisplayMember);
                    }
                    catch
                    {
                        Debug.Assert(this.DisplayMember != null && this.DisplayMember.Length > 0);
                        InitializeDisplayMemberPropertyDescriptor(null);
                    }

                    try
                    {
                        InitializeValueMemberPropertyDescriptor(this.ValueMember);
                    }
                    catch
                    {
                        Debug.Assert(this.ValueMember != null && this.ValueMember.Length > 0);
                        InitializeValueMemberPropertyDescriptor(null);
                    }

                    if (value == null)
                    {
                        InitializeDisplayMemberPropertyDescriptor(null);
                        InitializeValueMemberPropertyDescriptor(null);
                    }
                }
            }
        }

        /// <summary>
        /// Overrides the DataGridViewComboBox's implementation of the DisplayMember property to
        /// update the displayMemberProperty member.
        /// </summary>
        public override string DisplayMember
        {
            get
            {
                return base.DisplayMember;
            }
            set
            {
                base.DisplayMember = value;
                InitializeDisplayMemberPropertyDescriptor(value);
            }
        }

        /// <summary>
        /// Overrides the base implementation to replace the 'complex editing experience'
        /// with a 'simple editing experience'.
        /// </summary>
        public override Type EditType
        {
            get
            {
                // Return null since no editing control is used for the editing experience.
                return null;
            }
        }

        /// <summary>
        /// Custom property that represents the maximum number of radio buttons shown by the cell.
        /// </summary>
        [
            DefaultValue(DATAGRIDVIEWRADIOBUTTONCELL_defaultMaxDisplayedItems)
        ]
        public int MaxDisplayedItems
        {
            get
            {
                return this.maxDisplayedItems;
            }
            set
            {
                if (value < 1 || value > 100)
                {
                    throw new ArgumentOutOfRangeException("MaxDisplayedItems");
                }
                this.maxDisplayedItems = value;

                if (this.DataGridView != null && !this.DataGridView.IsDisposed && !this.DataGridView.Disposing)
                {
                    if (this.RowIndex == -1)
                    {
                        // Invalidate and autosize column
                        this.DataGridView.InvalidateColumn(this.ColumnIndex);

                        // TODO: Add code to autosize the cell's column, the rows, the column headers 
                        // and the row headers depending on their autosize settings.
                        // The DataGridView control does not expose a public method that takes care of this.
                    }
                    else
                    {
                        // The DataGridView control exposes a public method called UpdateCellValue
                        // that invalidates the cell so that it gets repainted and also triggers all
                        // the necessary autosizing: the cell's column and/or row, the column headers
                        // and the row headers are autosized depending on their autosize settings.
                        this.DataGridView.UpdateCellValue(this.ColumnIndex, this.RowIndex);
                    }
                }
            }
        }

        /// <summary>
        /// Called internally by the DataGridViewRadioButtonColumn class to avoid the invalidation
        /// done by the MaxDisplayedItems setter above (for performance reasons).
        /// </summary>
        internal int MaxDisplayedItemsInternal
        {
            set
            {
                Debug.Assert(value >= 1 && value <= 100);
                this.maxDisplayedItems = value;
            }
        }

        /// <summary>
        /// Utility function that returns the standard thickness (in pixels) of the four borders of the cell.
        /// </summary>
        private Rectangle StandardBorderWidths
        {
            get
            {
                if (this.DataGridView != null)
                {
                    DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle(), dgvabsEffective;
                    dgvabsEffective = AdjustCellBorderStyle(this.DataGridView.AdvancedCellBorderStyle,
                        dataGridViewAdvancedBorderStylePlaceholder,
                        false /*singleVerticalBorderAdded*/,
                        false /*singleHorizontalBorderAdded*/,
                        false /*isFirstDisplayedColumn*/,
                        false /*isFirstDisplayedRow*/);
                    return BorderWidths(dgvabsEffective);
                }
                else
                {
                    return Rectangle.Empty;
                }
            }
        }

        /// <summary>
        /// Overrides the DataGridViewComboBox's implementation of the ValueMember property to
        /// update the valueMemberProperty member.
        /// </summary>
        public override string ValueMember
        {
            get
            {
                return base.ValueMember;
            }
            set
            {
                base.ValueMember = value;
                InitializeValueMemberPropertyDescriptor(value);
            }
        }

        /// <summary>
        /// Utility function that returns the cell state inherited from the owning row and column.
        /// </summary>
        private DataGridViewElementStates CellStateFromColumnRowStates(DataGridViewElementStates rowState)
        {
            Debug.Assert(this.DataGridView != null);
            Debug.Assert(this.ColumnIndex >= 0);
            DataGridViewElementStates orFlags = DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.Selected;
            DataGridViewElementStates andFlags = DataGridViewElementStates.Displayed | DataGridViewElementStates.Frozen | DataGridViewElementStates.Visible;
            DataGridViewElementStates cellState = (this.OwningColumn.State & orFlags);
            cellState |= (rowState & orFlags);
            cellState |= ((this.OwningColumn.State & andFlags) & (rowState & andFlags));
            return cellState;
        }

        /// <summary>
        /// Custom implementation of the Clone method to copy over the special properties of the cell.
        /// </summary>
        public override object Clone()
        {
            DataGridViewRadioButtonCell dataGridViewCell = base.Clone() as DataGridViewRadioButtonCell;
            if (dataGridViewCell != null)
            {
                dataGridViewCell.MaxDisplayedItems = this.MaxDisplayedItems;
            }
            return dataGridViewCell;
        }

        /// <summary>
        /// Computes the layout of the cell and optionally paints it.
        /// </summary>
        private void ComputeLayout(Graphics graphics,
                                   Rectangle clipBounds,
                                   Rectangle cellBounds,
                                   int rowIndex,
                                   DataGridViewElementStates cellState,
                                   object formattedValue,
                                   string errorText,
                                   DataGridViewCellStyle cellStyle,
                                   DataGridViewAdvancedBorderStyle advancedBorderStyle,
                                   DataGridViewPaintParts paintParts,
                                   bool paint)
        {
            if (paint && DataGridViewRadioButtonCell.PartPainted(paintParts, DataGridViewPaintParts.Border))
            {
                // Paint the borders first
                PaintBorder(graphics, clipBounds, cellBounds, cellStyle, advancedBorderStyle);
            }

            // Discard the space taken up by the borders.
            Rectangle borderWidths = BorderWidths(advancedBorderStyle);
            Rectangle valBounds = cellBounds;
            valBounds.Offset(borderWidths.X, borderWidths.Y);
            valBounds.Width -= borderWidths.Right;
            valBounds.Height -= borderWidths.Bottom;

            SolidBrush backgroundBrush = null;
            try
            {
                Point ptCurrentCell = this.DataGridView.CurrentCellAddress;
                bool cellCurrent = ptCurrentCell.X == this.ColumnIndex && ptCurrentCell.Y == rowIndex;
                bool cellSelected = (cellState & DataGridViewElementStates.Selected) != 0;
                bool mouseOverCell = cellBounds.Contains(this.DataGridView.PointToClient(Control.MousePosition));

                if (DataGridViewRadioButtonCell.PartPainted(paintParts, DataGridViewPaintParts.SelectionBackground) && cellSelected)
                {
                    backgroundBrush = new SolidBrush(cellStyle.SelectionBackColor);
                }
                else
                {
                    backgroundBrush = new SolidBrush(cellStyle.BackColor);
                }

                if (paint && DataGridViewRadioButtonCell.PartPainted(paintParts, DataGridViewPaintParts.Background) && backgroundBrush.Color.A == 255)
                {
                    Rectangle backgroundRect = valBounds;
                    backgroundRect.Intersect(clipBounds);
                    graphics.FillRectangle(backgroundBrush, backgroundRect);
                }

                // Discard the space taken up by the padding area.
                if (cellStyle.Padding != Padding.Empty)
                {
                    valBounds.Offset(cellStyle.Padding.Left, cellStyle.Padding.Top);
                    valBounds.Width -= cellStyle.Padding.Horizontal;
                    valBounds.Height -= cellStyle.Padding.Vertical;
                }

                Rectangle errorBounds = valBounds;
                Rectangle scrollBounds = valBounds;

                this.layout.ScrollingNeeded = GetScrollingNeeded(graphics, rowIndex, cellStyle, valBounds.Size);

                if (this.layout.ScrollingNeeded)
                {
                    this.layout.ScrollButtonsSize = ScrollBarRenderer.GetSizeBoxSize(graphics, ScrollBarState.Normal);
                    // Discard the space required for displaying the 2 scroll buttons
                    valBounds.Width -= this.layout.ScrollButtonsSize.Width;
                }

                valBounds.Inflate(-DATAGRIDVIEWRADIOBUTTONCELL_margin, -DATAGRIDVIEWRADIOBUTTONCELL_margin);

                // Layout / paint the radio buttons themselves
                this.layout.RadioButtonsSize = RadioButtonRenderer.GetGlyphSize(graphics, RadioButtonState.CheckedNormal);
                this.layout.DisplayedItemsCount = 0;
                this.layout.TotallyDisplayedItemsCount = 0;
                if (valBounds.Width > 0 && valBounds.Height > 0)
                {
                    this.layout.FirstDisplayedItemLocation = new Point(valBounds.Left + DATAGRIDVIEWRADIOBUTTONCELL_margin, valBounds.Top + DATAGRIDVIEWRADIOBUTTONCELL_margin);
                    int textHeight = cellStyle.Font.Height;
                    int itemIndex = this.layout.FirstDisplayedItemIndex;
                    Rectangle radiosBounds = valBounds;
                    while (itemIndex < this.Items.Count &&
                           itemIndex < this.layout.FirstDisplayedItemIndex + this.maxDisplayedItems &&                           
                           radiosBounds.Height > 0)
                    {
                        if (paint && DataGridViewRadioButtonCell.PartPainted(paintParts, DataGridViewPaintParts.ContentBackground))
                        {
                            Rectangle itemRect = radiosBounds;
                            itemRect.Intersect(clipBounds);
                            if (!itemRect.IsEmpty)
                            {
                                bool itemReadOnly = (cellState & DataGridViewElementStates.ReadOnly) != 0;
                                bool itemSelected = false;
                                if (formattedValue != null)
                                {
                                    object displayValue = GetItemDisplayValue(this.Items[itemIndex]);
                                    if (formattedValue.Equals(displayValue))
                                    {
                                        itemSelected = true;
                                    }
                                }
                                PaintItem(graphics, 
                                          radiosBounds, 
                                          rowIndex, 
                                          itemIndex, 
                                          cellStyle,
                                          itemReadOnly,
                                          itemSelected, 
                                          mouseOverCell,
                                          cellCurrent && this.focusedItemIndex == itemIndex && DataGridViewRadioButtonCell.PartPainted(paintParts, DataGridViewPaintParts.Focus));
                            }
                        }
                        itemIndex++;
                        radiosBounds.Y += textHeight + DATAGRIDVIEWRADIOBUTTONCELL_margin;
                        radiosBounds.Height -= (textHeight + DATAGRIDVIEWRADIOBUTTONCELL_margin);
                        if (radiosBounds.Height >= 0)
                        {
                            this.layout.TotallyDisplayedItemsCount++;
                        }
                        this.layout.DisplayedItemsCount++;
                    }
                    this.layout.ContentBounds = new Rectangle(this.layout.FirstDisplayedItemLocation, new Size(this.layout.RadioButtonsSize.Width, this.layout.DisplayedItemsCount * (textHeight + DATAGRIDVIEWRADIOBUTTONCELL_margin)));
                }
                else
                {
                    this.layout.FirstDisplayedItemLocation = new Point(-1, -1);
                    this.layout.ContentBounds = Rectangle.Empty;
                }

                if (this.layout.ScrollingNeeded)
                {
                    // Layout / paint the 2 scroll buttons
                    Rectangle rectArrow = new Rectangle(scrollBounds.Right - this.layout.ScrollButtonsSize.Width,
                                                        scrollBounds.Top,
                                                        this.layout.ScrollButtonsSize.Width,
                                                        this.layout.ScrollButtonsSize.Height);
                    this.layout.UpButtonLocation = rectArrow.Location;
                    if (paint && DataGridViewRadioButtonCell.PartPainted(paintParts, DataGridViewPaintParts.ContentBackground))
                    {
                        ScrollBarRenderer.DrawArrowButton(graphics, rectArrow, GetScrollBarArrowButtonState(true, mouseOverCell ? mouseLocationCode : DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric, this.layout.FirstDisplayedItemIndex > 0 /*enabled*/));
                    }
                    rectArrow.Y = scrollBounds.Bottom - this.layout.ScrollButtonsSize.Height;
                    this.layout.DownButtonLocation = rectArrow.Location;
                    if (paint && DataGridViewRadioButtonCell.PartPainted(paintParts, DataGridViewPaintParts.ContentBackground))
                    {
                        ScrollBarRenderer.DrawArrowButton(graphics, rectArrow, GetScrollBarArrowButtonState(false, mouseOverCell ? mouseLocationCode : DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric, this.layout.FirstDisplayedItemIndex + this.layout.TotallyDisplayedItemsCount < this.Items.Count /*enabled*/));
                    }
                }

                // Finally paint the potential error icon
                if (paint && 
                    DataGridViewRadioButtonCell.PartPainted(paintParts, DataGridViewPaintParts.ErrorIcon) &&
                    !(cellCurrent && this.DataGridView.IsCurrentCellInEditMode) && 
                    this.DataGridView.ShowCellErrors)
                {
                    PaintErrorIcon(graphics, clipBounds, errorBounds, errorText);
                }
            }
            finally
            {
                if (backgroundBrush != null)
                {
                    backgroundBrush.Dispose();
                }
            }
        }

        /// <summary>
        /// Returns whether calling the OnContentClick method would force the owning row to be unshared.
        /// </summary>
        protected override bool ContentClickUnsharesRow(DataGridViewCellEventArgs e)
        {
            Point ptCurrentCell = this.DataGridView.CurrentCellAddress;
            return ptCurrentCell.X == this.ColumnIndex &&
                   ptCurrentCell.Y == e.RowIndex &&
                   this.DataGridView.IsCurrentCellInEditMode;
        }

        /// <summary>
        /// Raised when the owning grid gets a MouseUp notification
        /// </summary>
        private void DataGridView_MouseUp(object sender, MouseEventArgs e)
        {
            // Unhook the event handler
            this.DataGridView.MouseUp -= new MouseEventHandler(DataGridView_MouseUp);
            this.mouseUpHooked = false;
            // Reset the pressed item index. Since the mouse was released, no item can be pressed anymore.
            this.pressedItemIndex = -1;
        }

        /// <summary>
        /// Raised when the cell's DataSource is initialized.
        /// </summary>
        private void DataSource_Initialized(object sender, EventArgs e)
        {
            Debug.Assert(sender == this.DataSource);
            Debug.Assert(this.DataSource is ISupportInitializeNotification);
            Debug.Assert(this.dataSourceInitializedHookedUp);

            ISupportInitializeNotification dsInit = this.DataSource as ISupportInitializeNotification;
            // Unhook the Initialized event.
            if (dsInit != null)
            {
                dsInit.Initialized -= new EventHandler(DataSource_Initialized);
            }

            // The wait is over: the DataSource is initialized.
            this.dataSourceInitializedHookedUp = false;

            // Check the DisplayMember and ValueMember values - will throw if values don't match existing fields.
            InitializeDisplayMemberPropertyDescriptor(this.DisplayMember);
            InitializeValueMemberPropertyDescriptor(this.ValueMember);
        }

        /// <summary>
        /// Returns whether calling the OnEnter method would force the owning row to be unshared.
        /// </summary>
        protected override bool EnterUnsharesRow(int rowIndex, bool throughMouseClick)
        {
            return this.focusedItemIndex == -1;
        }

        /// <summary>
        /// Custom implementation of the GetContentBounds method which delegates most of the work to the ComputeLayout function.
        /// </summary>
        protected override Rectangle GetContentBounds(Graphics graphics, DataGridViewCellStyle cellStyle, int rowIndex)
        {
            if (this.DataGridView == null || rowIndex < 0 || this.OwningColumn == null)
            {
                return Rectangle.Empty;
            }

            // First determine the effective border style of this cell.
            bool singleVerticalBorderAdded = !this.DataGridView.RowHeadersVisible && this.DataGridView.AdvancedCellBorderStyle.All == DataGridViewAdvancedCellBorderStyle.Single;
            bool singleHorizontalBorderAdded = !this.DataGridView.ColumnHeadersVisible && this.DataGridView.AdvancedCellBorderStyle.All == DataGridViewAdvancedCellBorderStyle.Single;
            DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle();

            Debug.Assert(rowIndex > -1 && this.OwningColumn != null);

            DataGridViewAdvancedBorderStyle dgvabsEffective = AdjustCellBorderStyle(this.DataGridView.AdvancedCellBorderStyle,
                dataGridViewAdvancedBorderStylePlaceholder,
                singleVerticalBorderAdded,
                singleHorizontalBorderAdded,
                rowIndex == this.DataGridView.Rows.GetFirstRow(DataGridViewElementStates.Displayed) /*isFirstDisplayedRow*/,
                this.ColumnIndex == this.DataGridView.Columns.GetFirstColumn(DataGridViewElementStates.Displayed).Index /*isFirstDisplayedColumn*/);

            // Next determine the state of this cell.
            DataGridViewElementStates rowState = this.DataGridView.Rows.GetRowState(rowIndex);
            DataGridViewElementStates cellState = CellStateFromColumnRowStates(rowState);
            cellState |= this.State;

            // Then the bounds of this cell.
            Rectangle cellBounds = new Rectangle(new Point(0, 0), GetSize(rowIndex));

            // Finally compute the layout of the cell and return the resulting content bounds.
            ComputeLayout(graphics,
                cellBounds,
                cellBounds,
                rowIndex,
                cellState,
                null /*formattedValue*/,            // contentBounds is independent of formattedValue
                null /*errorText*/,                 // contentBounds is independent of errorText
                cellStyle,
                dgvabsEffective,
                DataGridViewPaintParts.ContentForeground,
                false /*paint*/);

            return this.layout.ContentBounds;
        }

        /// <summary>
        /// Utility function that converts a constraintSize provided to GetPreferredSize into a 
        /// DataGridViewRadioButtonFreeDimension enum value.
        /// </summary>
        private static DataGridViewRadioButtonFreeDimension GetFreeDimensionFromConstraint(Size constraintSize)
        {
            if (constraintSize.Width < 0 || constraintSize.Height < 0)
            {
                throw new ArgumentException("InvalidArgument=Value of '" + constraintSize.ToString() + "' is not valid for 'constraintSize'.");
            }
            if (constraintSize.Width == 0)
            {
                if (constraintSize.Height == 0)
                {
                    return DataGridViewRadioButtonFreeDimension.Both;
                }
                else
                {
                    return DataGridViewRadioButtonFreeDimension.Width;
                }
            }
            else
            {
                if (constraintSize.Height == 0)
                {
                    return DataGridViewRadioButtonFreeDimension.Height;
                }
                else
                {
                    throw new ArgumentException("InvalidArgument=Value of '" + constraintSize.ToString() + "' is not valid for 'constraintSize'.");
                }
            }
        }

        /// <summary>
        /// Utility function that returns the display value of an item given the 
        /// display/value property descriptors and display/value property names.
        /// </summary>
        private object GetItemDisplayValue(object item)
        {
            Debug.Assert(item != null);
            bool displayValueSet = false;
            object displayValue = null;
            if (this.displayMemberProperty != null)
            {
                displayValue = this.displayMemberProperty.GetValue(item);
                displayValueSet = true;
            }
            else if (this.valueMemberProperty != null)
            {
                displayValue = this.valueMemberProperty.GetValue(item);
                displayValueSet = true;
            }
            else if (!string.IsNullOrEmpty(this.DisplayMember))
            {
                PropertyDescriptor propDesc = TypeDescriptor.GetProperties(item).Find(this.DisplayMember, true /*caseInsensitive*/);
                if (propDesc != null)
                {
                    displayValue = propDesc.GetValue(item);
                    displayValueSet = true;
                }
            }
            else if (!string.IsNullOrEmpty(this.ValueMember))
            {
                PropertyDescriptor propDesc = TypeDescriptor.GetProperties(item).Find(this.ValueMember, true /*caseInsensitive*/);
                if (propDesc != null)
                {
                    displayValue = propDesc.GetValue(item);
                    displayValueSet = true;
                }
            }
            if (!displayValueSet)
            {
                displayValue = item;
            }
            return displayValue;
        }

        /// <summary>
        /// Utility function that returns the value of an item given the 
        /// display/value property descriptors and display/value property names.
        /// </summary>
        private object GetItemValue(object item)
        {
            bool valueSet = false;
            object value = null;
            if (this.valueMemberProperty != null)
            {
                value = this.valueMemberProperty.GetValue(item);
                valueSet = true;
            }
            else if (this.displayMemberProperty != null)
            {
                value = this.displayMemberProperty.GetValue(item);
                valueSet = true;
            }
            else if (!string.IsNullOrEmpty(this.ValueMember))
            {
                PropertyDescriptor propDesc = TypeDescriptor.GetProperties(item).Find(this.ValueMember, true /*caseInsensitive*/);
                if (propDesc != null)
                {
                    value = propDesc.GetValue(item);
                    valueSet = true;
                }
            }
            if (!valueSet && !string.IsNullOrEmpty(this.DisplayMember))
            {
                PropertyDescriptor propDesc = TypeDescriptor.GetProperties(item).Find(this.DisplayMember, true /*caseInsensitive*/);
                if (propDesc != null)
                {
                    value = propDesc.GetValue(item);
                    valueSet = true;
                }
            }
            if (!valueSet)
            {
                value = item;
            }
            return value;
        }

        /// <summary>
        /// Returns the code identifying the part of the cell which is underneath the mouse pointer.
        /// </summary>
        private int GetMouseLocationCode(Graphics graphics, int rowIndex, DataGridViewCellStyle cellStyle, int mouseX, int mouseY)
        {
            // First determine this cell's effective border style.
            bool singleVerticalBorderAdded = !this.DataGridView.RowHeadersVisible && this.DataGridView.AdvancedCellBorderStyle.All == DataGridViewAdvancedCellBorderStyle.Single;
            bool singleHorizontalBorderAdded = !this.DataGridView.ColumnHeadersVisible && this.DataGridView.AdvancedCellBorderStyle.All == DataGridViewAdvancedCellBorderStyle.Single;
            bool isFirstDisplayedColumn = this.ColumnIndex == this.DataGridView.Columns.GetFirstColumn(DataGridViewElementStates.Displayed).Index;
            bool isFirstDisplayedRow = rowIndex == this.DataGridView.Rows.GetFirstRow(DataGridViewElementStates.Displayed);
            DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle(), dataGridViewAdvancedBorderStyleEffective;
            dataGridViewAdvancedBorderStyleEffective = AdjustCellBorderStyle(this.DataGridView.AdvancedCellBorderStyle,
                                                                             dataGridViewAdvancedBorderStylePlaceholder,
                                                                             singleVerticalBorderAdded,
                                                                             singleHorizontalBorderAdded,
                                                                             isFirstDisplayedColumn,
                                                                             isFirstDisplayedRow);
            // Then its size.
            Rectangle cellBounds = this.DataGridView.GetCellDisplayRectangle(this.ColumnIndex, rowIndex, false /*cutOverflow*/);
            Debug.Assert(GetSize(rowIndex) == cellBounds.Size);

            // Recompute the layout of the cell.
            ComputeLayout(graphics,
                          cellBounds,
                          cellBounds,
                          rowIndex,
                          DataGridViewElementStates.None,
                          null /*formattedValue*/,
                          null /*errorText*/,
                          cellStyle,
                          dataGridViewAdvancedBorderStyleEffective,
                          DataGridViewPaintParts.None,
                          false /*paint*/);

            // Deduce the cell part beneath the mouse pointer.
            Point mousePosition = this.DataGridView.PointToClient(Control.MousePosition);
            Rectangle rect;
            if (this.layout.ScrollingNeeded)
            {
                // Is the mouse over the bottom scroll button?
                rect = new Rectangle(this.layout.DownButtonLocation, this.layout.ScrollButtonsSize);
                if (rect.Contains(mousePosition))
                {
                    return DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationBottomScrollButton;
                }
                // Is the mouse over the upper scroll button?
                rect = new Rectangle(this.layout.UpButtonLocation, this.layout.ScrollButtonsSize);
                if (rect.Contains(mousePosition))
                {
                    return DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationTopScrollButton;
                }
            }
            if (this.layout.DisplayedItemsCount > 0)
            {
                Point radioButtonLocation = this.layout.FirstDisplayedItemLocation;
                int textHeight = cellStyle.Font.Height;
                int itemIndex = this.layout.FirstDisplayedItemIndex;
                Rectangle radioButtonBounds = new Rectangle(radioButtonLocation, this.layout.RadioButtonsSize);
                while (itemIndex < this.Items.Count &&
                       itemIndex < this.layout.FirstDisplayedItemIndex + this.maxDisplayedItems &&
                       itemIndex - this.layout.FirstDisplayedItemIndex < this.layout.DisplayedItemsCount)
                {
                    if (radioButtonBounds.Contains(mousePosition))
                    {
                        // The mouse is over a radio button
                        return itemIndex - this.layout.FirstDisplayedItemIndex;
                    }
                    itemIndex++;
                    radioButtonBounds.Y += textHeight + DATAGRIDVIEWRADIOBUTTONCELL_margin;
                }
            }
            return DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric;
        }

        /// <summary>
        /// Returns a ScrollBarArrowButtonState state given the current mouse location.
        /// </summary>
        private ScrollBarArrowButtonState GetScrollBarArrowButtonState(bool upButton, int mouseLocationCode, bool enabled)
        {
            if (!enabled)
            {
                if (upButton)
                {
                    return ScrollBarArrowButtonState.UpDisabled;
                }
                else
                {
                    return ScrollBarArrowButtonState.DownDisabled;
                }
            }
            if (mouseLocationCode == DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationTopScrollButton)
            {
                // Mouse is over upper button
                if (Control.MouseButtons == MouseButtons.Left)
                {
                    if (upButton)
                    {
                        return ScrollBarArrowButtonState.UpPressed;
                    }
                    else
                    {
                        return ScrollBarArrowButtonState.DownNormal;
                    }
                }
                else
                {
                    if (upButton)
                    {
                        return ScrollBarArrowButtonState.UpHot;
                    }
                    else
                    {
                        return ScrollBarArrowButtonState.DownNormal;
                    }
                }
            }
            else if (mouseLocationCode == DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationBottomScrollButton)
            {
                // Mouse is over bottom button
                if (Control.MouseButtons == MouseButtons.Left)
                {
                    if (upButton)
                    {
                        return ScrollBarArrowButtonState.UpNormal;
                    }
                    else
                    {
                        return ScrollBarArrowButtonState.DownPressed;
                    }
                }
                else
                {
                    if (upButton)
                    {
                        return ScrollBarArrowButtonState.UpNormal;
                    }
                    else
                    {
                        return ScrollBarArrowButtonState.DownHot;
                    }
                }
            }

            else if (upButton)
            {
                return ScrollBarArrowButtonState.UpNormal;
            }
            else
            {
                return ScrollBarArrowButtonState.DownNormal;
            }
        }

        /// <summary>
        /// Custom implementation of the GetPreferredSize method.
        /// </summary>
        protected override Size GetPreferredSize(Graphics graphics, DataGridViewCellStyle cellStyle, int rowIndex, Size constraintSize)
        {
            if (this.DataGridView == null)
            {
                return new Size(-1, -1);
            }
            DataGridViewRadioButtonFreeDimension freeDimension = DataGridViewRadioButtonCell.GetFreeDimensionFromConstraint(constraintSize);
            Rectangle borderWidthsRect = this.StandardBorderWidths;
            int borderAndPaddingWidths = borderWidthsRect.Left + borderWidthsRect.Width + cellStyle.Padding.Horizontal;
            int borderAndPaddingHeights = borderWidthsRect.Top + borderWidthsRect.Height + cellStyle.Padding.Vertical;
            int preferredHeight = 0, preferredWidth = 0;
            // Assuming here that all radio button states use the same size.
            Size radioButtonGlyphSize = RadioButtonRenderer.GetGlyphSize(graphics, RadioButtonState.CheckedNormal);

            if (freeDimension != DataGridViewRadioButtonFreeDimension.Width)
            {
                preferredHeight = Math.Min(this.Items.Count, this.MaxDisplayedItems) * (Math.Max(cellStyle.Font.Height, radioButtonGlyphSize.Height) + DATAGRIDVIEWRADIOBUTTONCELL_margin) + DATAGRIDVIEWRADIOBUTTONCELL_margin;
                preferredHeight += 2 * DATAGRIDVIEWRADIOBUTTONCELL_margin + borderAndPaddingHeights;
            }
           
            if (freeDimension != DataGridViewRadioButtonFreeDimension.Height)
            {
                TextFormatFlags flags = TextFormatFlags.Top | TextFormatFlags.Left | TextFormatFlags.SingleLine | TextFormatFlags.EndEllipsis | TextFormatFlags.PreserveGraphicsClipping | TextFormatFlags.NoPrefix;

                if (this.Items.Count > 0)
                {
                    // Figure out the width of the longest entry
                    int maxPreferredItemWidth = -1, preferredItemWidth;
                    foreach (object item in this.Items)
                    {
                        string formattedValue = GetFormattedValue(GetItemValue(item), rowIndex, ref cellStyle, null, null, DataGridViewDataErrorContexts.Formatting | DataGridViewDataErrorContexts.PreferredSize) as string;
                        if (formattedValue != null)
                        {
                            preferredItemWidth = DataGridViewCell.MeasureTextSize(graphics, formattedValue, cellStyle.Font, flags).Width;
                        }
                        else
                        {
                            preferredItemWidth = DataGridViewCell.MeasureTextSize(graphics, " ", cellStyle.Font, flags).Width;
                        }
                        if (preferredItemWidth > maxPreferredItemWidth)
                        {
                            maxPreferredItemWidth = preferredItemWidth;
                        }
                    }
                    preferredWidth = maxPreferredItemWidth;
                }

                if (freeDimension == DataGridViewRadioButtonFreeDimension.Width)
                {
                    Size contentSize = new Size(Int32.MaxValue, constraintSize.Height - borderAndPaddingHeights);
                    if (GetScrollingNeeded(graphics, rowIndex, cellStyle, contentSize))
                    {
                        // Accommodate the scrolling buttons
                        preferredWidth += ScrollBarRenderer.GetSizeBoxSize(graphics, ScrollBarState.Normal).Width;
                    }
                }

                preferredWidth += radioButtonGlyphSize.Width + 5 * DATAGRIDVIEWRADIOBUTTONCELL_margin + borderAndPaddingWidths;
            }

            if (this.DataGridView.ShowCellErrors)
            {
                // Making sure that there is enough room for the potential error icon
                if (freeDimension != DataGridViewRadioButtonFreeDimension.Height)
                {
                    preferredWidth = Math.Max(preferredWidth,
                                              borderAndPaddingWidths + DATAGRIDVIEWRADIOBUTTONCELL_iconMarginWidth * 2 + DATAGRIDVIEWRADIOBUTTONCELL_iconsWidth);
                }
                if (freeDimension != DataGridViewRadioButtonFreeDimension.Width)
                {
                    preferredHeight = Math.Max(preferredHeight,
                                               borderAndPaddingHeights + DATAGRIDVIEWRADIOBUTTONCELL_iconMarginHeight * 2 + DATAGRIDVIEWRADIOBUTTONCELL_iconsHeight);
                }
            }

            return new Size(preferredWidth, preferredHeight);
        }

        /// <summary>
        /// Helper function that determines if scrolling buttons should be displayed
        /// </summary>
        private bool GetScrollingNeeded(Graphics graphics, int rowIndex, DataGridViewCellStyle cellStyle, Size contentSize)
        {
            if (this.Items.Count <= 1)
            {
                return false;
            }

            if (this.MaxDisplayedItems >= this.Items.Count && 
                this.Items.Count * (cellStyle.Font.Height + DATAGRIDVIEWRADIOBUTTONCELL_margin) + DATAGRIDVIEWRADIOBUTTONCELL_margin <= contentSize.Height /*- borderAndPaddingHeights*/)
            {
                // There is enough vertical room to display all the radio buttons
                return false;
            }

            // Is there enough room to display the scroll buttons?
            //Size sizeBoxSize = ScrollBarRenderer.GetSizeBoxSize(graphics, ScrollBarState.Normal);
            Size sizeBoxSize = sizeBoxSize = new System.Drawing.Size(20, 20);
            if (2 * DATAGRIDVIEWRADIOBUTTONCELL_margin + sizeBoxSize.Width > contentSize.Width ||
                2 * sizeBoxSize.Height > contentSize.Height)
            {
                // There isn't enough room to show the scroll buttons.
                return false;
            }

            // Scroll buttons are required and there is enough room for them.
            return true;
        }

        /// <summary>
        /// Helper function that sets the displayMemberProperty member based on the DataSource and the provided displayMember field name
        /// </summary>
        private void InitializeDisplayMemberPropertyDescriptor(string displayMember)
        {
            if (this.DataManager != null)
            {
                if (String.IsNullOrEmpty(displayMember))
                {
                    this.displayMemberProperty = null;
                }
                else
                {
                    BindingMemberInfo displayBindingMember = new BindingMemberInfo(displayMember);
                    // make the DataManager point to the sublist inside this.DataSource
                    this.DataManager = this.DataGridView.BindingContext[this.DataSource, displayBindingMember.BindingPath] as CurrencyManager;

                    PropertyDescriptorCollection props = this.DataManager.GetItemProperties();
                    PropertyDescriptor displayMemberProperty = props.Find(displayBindingMember.BindingField, true);
                    if (displayMemberProperty == null)
                    {
                        throw new ArgumentException("Field called '" + displayMember + "' does not exist.");
                    }
                    else
                    {
                        this.displayMemberProperty = displayMemberProperty;
                    }
                }
            }
        }

        /// <summary>
        /// Helper function that sets the valueMemberProperty member based on the DataSource and the provided valueMember field name
        /// </summary>
        private void InitializeValueMemberPropertyDescriptor(string valueMember)
        {
            if (this.DataManager != null)
            {
                if (String.IsNullOrEmpty(valueMember))
                {
                    this.valueMemberProperty = null;
                }
                else
                {
                    BindingMemberInfo valueBindingMember = new BindingMemberInfo(valueMember);
                    // make the DataManager point to the sublist inside this.DataSource
                    this.DataManager = this.DataGridView.BindingContext[this.DataSource, valueBindingMember.BindingPath] as CurrencyManager;

                    PropertyDescriptorCollection props = this.DataManager.GetItemProperties();
                    PropertyDescriptor valueMemberProperty = props.Find(valueBindingMember.BindingField, true);
                    if (valueMemberProperty == null)
                    {
                        throw new ArgumentException("Field called '" + valueMember + "' does not exist.");
                    }
                    else
                    {
                        this.valueMemberProperty = valueMemberProperty;
                    }
                }
            }
        }

        /// <summary>
        /// Helper function that invalidates the entire area of an entry
        /// </summary>
        private void InvalidateItem(int itemIndex, int rowIndex)
        {
            if (itemIndex >= this.layout.FirstDisplayedItemIndex &&
                itemIndex < this.layout.FirstDisplayedItemIndex + this.layout.DisplayedItemsCount)
            {
                DataGridViewCellStyle cellStyle = GetInheritedStyle(null, rowIndex, false /* includeColors */);
                Point radioButtonLocation = this.layout.FirstDisplayedItemLocation;
                int textHeight = cellStyle.Font.Height;
                radioButtonLocation.Y += (textHeight + DATAGRIDVIEWRADIOBUTTONCELL_margin) * (itemIndex - this.layout.FirstDisplayedItemIndex);
                Size cellSize = GetSize(rowIndex);
                this.DataGridView.Invalidate(new Rectangle(radioButtonLocation.X, radioButtonLocation.Y, cellSize.Width, Math.Max(textHeight + DATAGRIDVIEWRADIOBUTTONCELL_margin, this.layout.RadioButtonsSize.Height)));
            }
        }

        /// <summary>
        /// Helper function that invalidates the glyph section of an entry
        /// </summary>
        private void InvalidateRadioGlyph(int itemIndex, DataGridViewCellStyle cellStyle)
        {
            if (itemIndex >= this.layout.FirstDisplayedItemIndex &&
                itemIndex < this.layout.FirstDisplayedItemIndex + this.layout.DisplayedItemsCount)
            {
                Point radioButtonLocation = this.layout.FirstDisplayedItemLocation;
                int textHeight = cellStyle.Font.Height;
                radioButtonLocation.Y += (textHeight + DATAGRIDVIEWRADIOBUTTONCELL_margin) * (itemIndex - this.layout.FirstDisplayedItemIndex);
                this.DataGridView.Invalidate(new Rectangle(radioButtonLocation, this.layout.RadioButtonsSize));
            }
        }

        /// <summary>
        /// Returns whether calling the OnKeyDown method would force the owning row to be unshared.
        /// </summary>
        protected override bool KeyDownUnsharesRow(KeyEventArgs e, int rowIndex)
        {
            if (!e.Alt && !e.Control && !e.Shift)
            {
                if (this.handledKeyDown)
                {
                    return true;
                }
                if (e.KeyCode == Keys.Down && this.focusedItemIndex < this.Items.Count - 1)
                {
                    return true;
                }
                else if (e.KeyCode == Keys.Up && this.focusedItemIndex > 0)
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// Returns whether calling the OnKeyUp method would force the owning row to be unshared.
        /// </summary>
        protected override bool KeyUpUnsharesRow(KeyEventArgs e, int rowIndex)
        {
            if (!e.Alt && !e.Control && !e.Shift)
            {
                if (e.KeyCode == Keys.Down && this.focusedItemIndex < this.Items.Count - 1 && this.handledKeyDown)
                {
                    return true;
                }
                else if (e.KeyCode == Keys.Up && this.focusedItemIndex > 0 && this.handledKeyDown)
                {
                    return true;
                }
            }
            if (this.handledKeyDown)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// Returns whether calling the OnMouseDown method would force the owning row to be unshared.
        /// </summary>
        protected override bool MouseDownUnsharesRow(DataGridViewCellMouseEventArgs e)
        {
            if (this.DataGridView == null)
            {
                return false;
            }
            if (e.Button == MouseButtons.Left)
            {
                int mouseLocationCode = GetMouseLocationCode(this.DataGridView.CreateGraphics(),
                                                             e.RowIndex,
                                                             GetInheritedStyle(null, e.RowIndex, false /* includeColors */),
                                                             e.X,
                                                             e.Y);
                switch (mouseLocationCode)
                {
                    case DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric:
                        break;
                    case DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationBottomScrollButton:
                        if (this.layout.FirstDisplayedItemIndex + this.layout.DisplayedItemsCount < this.Items.Count)
                        {
                            return true;
                        }
                        break;
                    case DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationTopScrollButton:
                        if (this.layout.FirstDisplayedItemIndex > 0)
                        {
                            return true;
                        }
                        break;
                    default:
                        if (this.pressedItemIndex != mouseLocationCode + this.layout.FirstDisplayedItemIndex)
                        {
                            return true;
                        }
                        break;
                }
            }
            return false;
        }

        /// <summary>
        /// Returns whether calling the OnMouseLeave method would force the owning row to be unshared.
        /// </summary>
        protected override bool MouseLeaveUnsharesRow(int rowIndex)
        {
            return this.pressedItemIndex != -1 && !this.mouseUpHooked;
        }

        /// <summary>
        /// Returns whether calling the OnMouseUp method would force the owning row to be unshared.
        /// </summary>
        protected override bool MouseUpUnsharesRow(DataGridViewCellMouseEventArgs e)
        {
             return e.Button == MouseButtons.Left && this.pressedItemIndex != -1;
        }

        /// <summary>
        /// Method that declares the cell dirty and notifies the grid of the value change.
        /// </summary>
        private void NotifyDataGridViewOfValueChange()
        {
            this.valueChanged = true;
            Debug.Assert(this.DataGridView != null);
            this.DataGridView.NotifyCurrentCellDirty(true);
        }

        /// <summary>
        /// Potentially updates the selected item and notifies the grid of the change.
        /// </summary>
        protected override void OnContentClick(DataGridViewCellEventArgs e)
        {
            if (this.DataGridView == null)
            {
                return;
            }
            Point ptCurrentCell = this.DataGridView.CurrentCellAddress;
            if (ptCurrentCell.X == this.ColumnIndex &&
                ptCurrentCell.Y == e.RowIndex &&
                this.DataGridView.IsCurrentCellInEditMode)
            {
                if (mouseLocationCode >= 0 && 
                    UpdateFormattedValue(this.layout.FirstDisplayedItemIndex + mouseLocationCode, e.RowIndex))
                {
                    NotifyDataGridViewOfValueChange();
                }
            }
        }

        /// <summary>
        /// Updates the property descriptors when the cell gets attached to the grid.
        /// </summary>
        protected override void OnDataGridViewChanged()
        {
            if (this.DataGridView != null)
            {
                // Will throw an error if DataGridView is set and a member is invalid
                InitializeDisplayMemberPropertyDescriptor(this.DisplayMember);
                InitializeValueMemberPropertyDescriptor(this.ValueMember);
            }
            base.OnDataGridViewChanged();
        }

        /// <summary>
        /// Makes sure that there is a focused item when the cell becomes the current one.
        /// </summary>
        protected override void OnEnter(int rowIndex, bool throughMouseClick)
        {
            if (this.focusedItemIndex == -1)
            {
                this.focusedItemIndex = this.layout.FirstDisplayedItemIndex;
            }
            base.OnEnter(rowIndex, throughMouseClick);
        }

        /// <summary>
        /// Handles the KeyDown notification when it can result in a value change.
        /// </summary>
        protected override void OnKeyDown(KeyEventArgs e, int rowIndex)
        {
            if (this.DataGridView == null)
            {
                return;
            }
            if (!e.Alt && !e.Control && !e.Shift)
            {
                if (this.handledKeyDown)
                {
                    this.handledKeyDown = false;
                }
                if (e.KeyCode == Keys.Down && this.focusedItemIndex < this.Items.Count - 1)
                {
                    this.handledKeyDown = true;
                    e.Handled = true;
                }
                else if (e.KeyCode == Keys.Up && this.focusedItemIndex > 0)
                {
                    this.handledKeyDown = true;
                    e.Handled = true;
                }
            }
        }

        /// <summary>
        /// Handles the KeyUp notification to change the cell's value.
        /// </summary>
        protected override void OnKeyUp(KeyEventArgs e, int rowIndex)
        {
            if (this.DataGridView == null)
            {
                return;
            }
            if (!e.Alt && !e.Control && !e.Shift && this.handledKeyDown)
            {
                if (e.KeyCode == Keys.Down && this.focusedItemIndex < this.Items.Count - 1)
                {
                    // Handle the Down Arrow key
                    if (UpdateFormattedValue(this.focusedItemIndex+1, rowIndex))
                    {
                        NotifyDataGridViewOfValueChange();
                    }
                    else if (this.selectedItemIndex == this.focusedItemIndex+1)
                    {
                        this.focusedItemIndex++;
                    }
                    if (this.focusedItemIndex >= this.layout.FirstDisplayedItemIndex + this.layout.TotallyDisplayedItemsCount)
                    {
                        this.layout.FirstDisplayedItemIndex++;
                    }
                    while (this.focusedItemIndex < this.layout.FirstDisplayedItemIndex)
                    {
                        this.layout.FirstDisplayedItemIndex--;
                    }
                    this.DataGridView.InvalidateCell(this.ColumnIndex, rowIndex);
                    e.Handled = true;
                }
                else if (e.KeyCode == Keys.Up && this.focusedItemIndex > 0)
                {
                    // Handle the Up Arrow key
                    if (UpdateFormattedValue(this.focusedItemIndex - 1, rowIndex))
                    {
                        NotifyDataGridViewOfValueChange();
                    }
                    else if (this.selectedItemIndex == this.focusedItemIndex - 1)
                    {
                        this.focusedItemIndex--;
                    }
                    if (this.focusedItemIndex < this.layout.FirstDisplayedItemIndex)
                    {
                        this.layout.FirstDisplayedItemIndex--;
                    }
                    while (this.focusedItemIndex >= this.layout.FirstDisplayedItemIndex + this.layout.TotallyDisplayedItemsCount)
                    {
                        this.layout.FirstDisplayedItemIndex++;
                    }
                    this.DataGridView.InvalidateCell(this.ColumnIndex, rowIndex);
                    e.Handled = true;
                }
            }
            // Always reset the flag that indicates if the KeyDown was handled.
            if (this.handledKeyDown)
            {
                this.handledKeyDown = false;
            }
        }

        /// <summary>
        /// Custom implementation of the MouseDown notification to update the cell's value or scroll the entries.
        /// </summary>
        protected override void OnMouseDown(DataGridViewCellMouseEventArgs e)
        {
            if (this.DataGridView == null)
            {
                return;
            }
            if (e.Button == MouseButtons.Left)
            {
                int mouseLocationCode = GetMouseLocationCode(this.DataGridView.CreateGraphics(),
                                                             e.RowIndex,
                                                             GetInheritedStyle(null, e.RowIndex, false /* includeColors */),
                                                             e.X,
                                                             e.Y);
                switch (mouseLocationCode)
                {
                    case DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric:
                        break;
                    case DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationBottomScrollButton:
                        if (this.layout.FirstDisplayedItemIndex + this.layout.TotallyDisplayedItemsCount < this.Items.Count)
                        {
                            // Scroll the entries down.
                            this.layout.FirstDisplayedItemIndex++;
                            this.DataGridView.Invalidate(new Rectangle(this.layout.DownButtonLocation, this.layout.ScrollButtonsSize));
                        }
                        break;
                    case DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationTopScrollButton:
                        if (this.layout.FirstDisplayedItemIndex > 0)
                        {
                            // Scroll the entries up.
                            this.layout.FirstDisplayedItemIndex--;
                            this.DataGridView.Invalidate(new Rectangle(this.layout.UpButtonLocation, this.layout.ScrollButtonsSize));
                        }
                        break;
                    default:
                        if (this.pressedItemIndex != mouseLocationCode + this.layout.FirstDisplayedItemIndex)
                        {
                            // Update the value of the cell.
                            InvalidateItem(this.pressedItemIndex, e.RowIndex);
                            this.pressedItemIndex = mouseLocationCode + this.layout.FirstDisplayedItemIndex;
                            InvalidateItem(this.pressedItemIndex, e.RowIndex);
                        }
                        break;
                }
            }
        }

        /// <summary>
        /// Makes sure the radio button gets hot when the mouse gets over it
        /// </summary>
        protected override void OnMouseEnter(int rowIndex)
        {
            if (this.DataGridView == null)
            {
                return;
            }

            if (this.pressedItemIndex != -1)
            {
                InvalidateRadioGlyph(this.pressedItemIndex, GetInheritedStyle(null, rowIndex, false /* includeColors */));
            }
        }

        /// <summary>
        /// Invalidates part of the cell as needed
        /// </summary>
        protected override void OnMouseLeave(int rowIndex)
        {
            if (this.DataGridView == null)
            {
                return;
            }

            int oldMouseLocationCode = mouseLocationCode;
            if (oldMouseLocationCode != DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric)
            {
                mouseLocationCode = DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric;
                if (oldMouseLocationCode == DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationTopScrollButton && this.layout.FirstDisplayedItemIndex > 0)
                {
                    this.DataGridView.Invalidate(new Rectangle(this.layout.UpButtonLocation, this.layout.ScrollButtonsSize));
                }
                else if (oldMouseLocationCode == DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationBottomScrollButton && this.layout.FirstDisplayedItemIndex + this.layout.DisplayedItemsCount < this.Items.Count)
                {
                    this.DataGridView.Invalidate(new Rectangle(this.layout.DownButtonLocation, this.layout.ScrollButtonsSize));
                }
                else if (oldMouseLocationCode >= 0)
                {
                    InvalidateRadioGlyph(oldMouseLocationCode + this.layout.FirstDisplayedItemIndex, GetInheritedStyle(null, rowIndex, false /* includeColors */));
                }
            }

            if (this.pressedItemIndex != -1)
            {
                if (!this.mouseUpHooked)
                {
                    // Hookup the grid's MouseUp event so that this.pressedItemIndex can be reset when the user releases the mouse button.
                    this.DataGridView.MouseUp += new MouseEventHandler(DataGridView_MouseUp);
                    this.mouseUpHooked = true;
                }
                InvalidateRadioGlyph(this.pressedItemIndex, GetInheritedStyle(null, rowIndex, false /* includeColors */));
            }
        }

        /// <summary>
        /// Invalidates part of the cell as needed
        /// </summary>
        protected override void OnMouseMove(DataGridViewCellMouseEventArgs e)
        {
            if (this.DataGridView == null)
            {
                return;
            }

            DataGridViewCellStyle cellStyle = GetInheritedStyle(null, e.RowIndex, false /* includeColors */);
            int oldMouseLocationCode = mouseLocationCode;
            mouseLocationCode = GetMouseLocationCode(this.DataGridView.CreateGraphics(), 
                                                     e.RowIndex, 
                                                     cellStyle, 
                                                     e.X, 
                                                     e.Y);
            if (oldMouseLocationCode != mouseLocationCode)
            {
                if ((oldMouseLocationCode == DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationTopScrollButton || mouseLocationCode == DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationTopScrollButton) && this.layout.FirstDisplayedItemIndex > 0)
                {
                    this.DataGridView.Invalidate(new Rectangle(this.layout.UpButtonLocation, this.layout.ScrollButtonsSize));
                }
                else if ((oldMouseLocationCode == DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationBottomScrollButton || mouseLocationCode == DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationBottomScrollButton) && this.layout.FirstDisplayedItemIndex + this.layout.DisplayedItemsCount < this.Items.Count)
                {
                    this.DataGridView.Invalidate(new Rectangle(this.layout.DownButtonLocation, this.layout.ScrollButtonsSize));
                }
                else
                {
                    if ((this.DataGridView.Rows.SharedRow(e.RowIndex).Cells[e.ColumnIndex].GetInheritedState(e.RowIndex) & DataGridViewElementStates.ReadOnly) != 0)
                    {
                        return;
                    }
                    if (oldMouseLocationCode >= 0)
                    {
                        InvalidateRadioGlyph(oldMouseLocationCode + this.layout.FirstDisplayedItemIndex, cellStyle);
                    }
                    if (mouseLocationCode >= 0)
                    {
                        InvalidateRadioGlyph(mouseLocationCode + this.layout.FirstDisplayedItemIndex, cellStyle);
                    }
                }
            }
        }

        /// <summary>
        /// Invalidates the potential pressed radio button. 
        /// </summary>
        protected override void OnMouseUp(DataGridViewCellMouseEventArgs e)
        {
            if (this.DataGridView == null)
            {
                return;
            }
            if (e.Button == MouseButtons.Left && this.pressedItemIndex != -1)
            {
                InvalidateItem(this.pressedItemIndex, e.RowIndex);
                this.pressedItemIndex = -1;
            }
        }

        /// <summary>
        /// Paints the entire cell.
        /// </summary>
        protected override void Paint(Graphics graphics,
            Rectangle clipBounds,
            Rectangle cellBounds,
            int rowIndex,
            DataGridViewElementStates cellState,
            object value,
            object formattedValue,
            string errorText,
            DataGridViewCellStyle cellStyle,
            DataGridViewAdvancedBorderStyle advancedBorderStyle,
            DataGridViewPaintParts paintParts)
        {
            ComputeLayout(graphics,
                          clipBounds,
                          cellBounds,
                          rowIndex,
                          cellState,
                          formattedValue,
                          errorText,
                          cellStyle,
                          advancedBorderStyle,
                          paintParts,
                          true  /*paint*/);
        }

        /// <summary>
        /// Paints a single item.
        /// </summary>
        private void PaintItem(Graphics graphics, 
                               Rectangle radiosBounds, 
                               int rowIndex,
                               int itemIndex, 
                               DataGridViewCellStyle cellStyle,
                               bool itemReadOnly,
                               bool itemSelected,
                               bool mouseOverCell,
                               bool paintFocus)
        {
            object itemFormattedValue = GetFormattedValue(GetItemValue(this.Items[itemIndex]),
                                                    rowIndex,
                                                    ref cellStyle,
                                                    null /*valueTypeConverter*/,
                                                    null /*formattedValueTypeConverter*/,
                                                    DataGridViewDataErrorContexts.Display);
            string itemFormattedText = itemFormattedValue as string;
            if (string.IsNullOrEmpty(itemFormattedText))
            {
                return;
            }
            else
            {
                //Paint the glyph & caption
                Point glyphLocation = new Point(radiosBounds.Left + DATAGRIDVIEWRADIOBUTTONCELL_margin, radiosBounds.Top + DATAGRIDVIEWRADIOBUTTONCELL_margin);
                //TextFormatFlags flags = TextFormatFlags.Top | TextFormatFlags.Left | TextFormatFlags.SingleLine | TextFormatFlags.EndEllipsis | TextFormatFlags.PreserveGraphicsClipping | TextFormatFlags.NoPrefix;
                TextFormatFlags flags = TextFormatFlags.Top | TextFormatFlags.Left | TextFormatFlags.SingleLine | TextFormatFlags.EndEllipsis | TextFormatFlags.PreserveGraphicsClipping | TextFormatFlags.NoPrefix;
                Rectangle textBounds = new Rectangle(radiosBounds.Left + 2 * DATAGRIDVIEWRADIOBUTTONCELL_margin + this.layout.RadioButtonsSize.Width, radiosBounds.Top + DATAGRIDVIEWRADIOBUTTONCELL_margin, radiosBounds.Width - (2 * DATAGRIDVIEWRADIOBUTTONCELL_margin + this.layout.RadioButtonsSize.Width), cellStyle.Font.Height + 1 /*radiosBounds.Height - 2 * DATAGRIDVIEWRADIOBUTTONCELL_margin*/);
                int localMouseLocationCode = mouseOverCell ? mouseLocationCode : DATAGRIDVIEWRADIOBUTTONCELL_mouseLocationGeneric;
                using (Region clipRegion = graphics.Clip)
                {
                    graphics.SetClip(radiosBounds);
                    RadioButtonState radioButtonState;
                    if (itemSelected)
                    {
                        if (itemReadOnly)
                        {
                            radioButtonState = RadioButtonState.CheckedDisabled;
                        }
                        else
                        {
                            if (mouseOverCell && this.pressedItemIndex == itemIndex)
                            {
                                if (localMouseLocationCode + this.layout.FirstDisplayedItemIndex == this.pressedItemIndex)
                                {
                                    radioButtonState = RadioButtonState.CheckedPressed;
                                }
                                else
                                {
                                    radioButtonState = RadioButtonState.CheckedHot;
                                }
                            }
                            else
                            {
                                if (localMouseLocationCode + this.layout.FirstDisplayedItemIndex == itemIndex && this.pressedItemIndex == -1)
                                {
                                    radioButtonState = RadioButtonState.CheckedHot;
                                }
                                else
                                {
                                    radioButtonState = RadioButtonState.CheckedNormal;
                                }
                            }
                        }
                    }
                    else
                    {
                        if (itemReadOnly)
                        {
                            radioButtonState = RadioButtonState.UncheckedDisabled;
                        }
                        else
                        {
                            if (mouseOverCell && this.pressedItemIndex == itemIndex)
                            {
                                if (localMouseLocationCode + this.layout.FirstDisplayedItemIndex == this.pressedItemIndex)
                                {
                                    radioButtonState = RadioButtonState.UncheckedPressed;
                                }
                                else
                                {
                                    radioButtonState = RadioButtonState.UncheckedHot;
                                }
                            }
                            else
                            {
                                if (localMouseLocationCode + this.layout.FirstDisplayedItemIndex == itemIndex && this.pressedItemIndex == -1)
                                {
                                    radioButtonState = RadioButtonState.UncheckedHot;
                                }
                                else
                                {
                                    radioButtonState = RadioButtonState.UncheckedNormal;
                                }
                            }
                        }
                    }
                    // Note: The cell should only show the focus rectangle when this.DataGridView.ShowFocusCues is true. However that property is
                    // protected and can't be accessed directly. A custom grid derived from DataGridView could expose this notion publicly.
                    RadioButtonRenderer.DrawRadioButton(graphics, 
                                                        glyphLocation, 
                                                        textBounds, 
                                                        itemFormattedText, 
                                                        cellStyle.Font, 
                                                        flags, 
                                                        paintFocus && /* this.DataGridView.ShowFocusCues && */ this.DataGridView.Focused,
                                                        radioButtonState);
                    graphics.Clip = clipRegion;
                } 
            }
        }

        /// <summary>
        /// Helper function that indicates if a paintPart needs to be painted.
        /// </summary>
        private static bool PartPainted(DataGridViewPaintParts paintParts, DataGridViewPaintParts paintPart)
        {
            return (paintParts & paintPart) != 0;
        }

        /// <summary>
        /// Custom implementation that follows the standard representation of cell types.
        /// </summary>
        public override string ToString()
        {
            return "DataGridViewRadioButtonCell { ColumnIndex=" + this.ColumnIndex.ToString(CultureInfo.CurrentCulture) + ", RowIndex=" + this.RowIndex.ToString(CultureInfo.CurrentCulture) + " }";
        }

        /// <summary>
        /// Returns true if the provided item successfully became the selected item.
        /// </summary>
        private bool UpdateFormattedValue(int newSelectedItemIndex, int rowIndex)
        {
            if (this.FormattedValueType == null || newSelectedItemIndex == this.selectedItemIndex)
            {
                return false;
            }
            IDataGridViewEditingCell editingCell = (IDataGridViewEditingCell)this;
            Debug.Assert(newSelectedItemIndex >= 0);
            Debug.Assert(newSelectedItemIndex < this.Items.Count);
            object item = this.Items[newSelectedItemIndex];
            object displayValue = GetItemDisplayValue(item);
            if (this.FormattedValueType.IsAssignableFrom(displayValue.GetType()))
            {
                editingCell.EditingCellFormattedValue = displayValue;
                this.focusedItemIndex = this.selectedItemIndex;
                this.DataGridView.InvalidateCell(this.ColumnIndex, rowIndex);
            }
            return true;
        }
    }
}