public interface IEditingCell 

using System;
using System.Windows.Forms;
using System.Collections.Generic;
using System.Drawing;

namespace GrapeCity.Win.MultiRow.SampleCode
{
    public class EditedProgressBarCell : ProgressBarCell , IEditingCell
    {
        public EditedProgressBarCell()
        {
            // Initialize the cell, set read only property to false to make the cell can be edited.
            this.ReadOnly = false;
        }

        int _editingValue = 0;

        public override Type EditType
        {
            get
            {
                // editing cell's edit type should be null.
                return null;
            }
        }

        public object EditingCellFormattedValue
        {
            get
            {
                return _editingValue;
            }
            set
            {
                if ((int)value < this.Minimum)
                {
                    value = Minimum;
                }
                else if ((int)value > this.Maximum)
                {
                    value = Maximum;
                }

                if (_editingValue != (int)value)
                {
                    _editingValue = (int)value;

                    // When change the editing cell's value, the cell should fire EditingCellValueChanged event to notify MultiRow control.
                    // So that, when leave editing status, MultiRow control can use this value as cell's new value.
                    this.OnEditingCellValueChanged(EventArgs.Empty);

                    // Notify MultiRow control redraw this cell.
                    this.Invalidate();
                }
            }
        }

        public event EventHandler EditingCellValueChanged;
        protected virtual void OnEditingCellValueChanged(EventArgs e)
        {
            if (this.EditingCellValueChanged != null)
            {
                this.EditingCellValueChanged(this, e);
            }
        }

        protected override void OnCellFormatting(CellFormattingEventArgs e)
        {
            // When multiRow control repaint cell, the cell will get the paint value.
            // The cell should use the EditingCellFormattedValue property value to paint cell, if cell in editing status.
            // You also change override OnPaint method to customize the cell painting logic for edit status, 
            // if so, override OnCellFormatting is not necessary.
            if (this.GcMultiRow.IsCurrentCellInEditMode &&
                this.GcMultiRow.CurrentCell.RowIndex == e.RowIndex && this.GcMultiRow.CurrentCell.CellIndex == e.CellIndex)
            {
                e.Value = this.EditingCellFormattedValue;
            }
            base.OnCellFormatting(e);
        }

        public bool WantsInputKey(Keys keyData)
        {
            // Tell MultiRow control that the cell will handle '+','-', and left, right key when edit status.
            if (keyData == Keys.Add || keyData == Keys.Subtract || keyData == Keys.Left || keyData == Keys.Right)
            {
                return true;
            }
            return false;
        }

        protected override void OnKeyDown(CellKeyEventArgs e)
        {
            // Handle key board message when editing state.
            if (this.GcMultiRow.CurrentCell.RowIndex == e.RowIndex &&
                this.GcMultiRow.CurrentCell.CellIndex == e.CellIndex &&
                this.GcMultiRow.IsCurrentCellInEditMode)
            {

                if (e.KeyData == Keys.Add || e.KeyData == Keys.Right)
                {
                    this.EditingCellFormattedValue = _editingValue + 1;
                }
                else if (e.KeyData == Keys.Subtract || e.KeyData == Keys.Left)
                {
                    this.EditingCellFormattedValue = _editingValue - 1;
                }
                base.OnKeyDown(e);
            }
        }

        bool _beginMouseDraging = false;

        protected override void OnMouseDown(CellMouseEventArgs e)
        {
            // Override OnMouseDown method to customize the action when mouse down the cell.
            if (e.Button == MouseButtons.Left)
            {
                // Assert the cell is current cell.
                if (this.GcMultiRow.CurrentCell.RowIndex == e.RowIndex &&
                    this.GcMultiRow.CurrentCell.CellIndex == e.CellIndex)
                {
                    bool beginEditSuccess = this.GcMultiRow.BeginEdit(false);

                    if (beginEditSuccess)
                    {
                        this.EditingCellFormattedValue = this.GetValueFromPoint(e.Location);
                        this._beginMouseDraging = true;
                    }
                }
            }
            base.OnMouseDown(e);
        }

        protected override void OnMouseMove(CellMouseEventArgs e)
        {
            if (this._beginMouseDraging)
            {
                // Mouse dragging to change the EditingCellFormattedValue.
                this.EditingCellFormattedValue = this.GetValueFromPoint(e.Location);
            }
            base.OnMouseMove(e);
        }

        protected override void OnMouseUp(CellMouseEventArgs e)
        {
            // When mouse up, end dragging.
            this._beginMouseDraging = false;
            base.OnMouseUp(e);
        }

        public override object Clone()
        {
            EditedProgressBarCell editedProgressBarCell = base.Clone() as EditedProgressBarCell;

            // If add new properties for new cell type. The properties should be assign to new cell instance here.

            return editedProgressBarCell;
        }

        protected override void OnEnter(CellEventArgs e)
        {   
            // When MultiRow start up, the cells and rows are virtual because of performance reason.
            // When a cell which implement IEditingCell interface begin edit. the cell may change to a new instance.
            // So, I force create cell's instance when the cell enter.
            object o = this.GcMultiRow.CurrentCell;

            base.OnEnter(e);
        }

        void GcMultiRow_MouseCaptureChanged(object sender, EventArgs e)
        {
            // When MultiRow control mouse capture changed, end dragging.
            _beginMouseDraging = false;
        }

        protected override void InitializeEditingControl(int rowIndex, object formattedValue, CellStyle style)
        {
            base.InitializeEditingControl(rowIndex, formattedValue, style);

            this.EditingCellFormattedValue = formattedValue;

            this.GcMultiRow.MouseCaptureChanged += new EventHandler(GcMultiRow_MouseCaptureChanged);
        }

        protected override void TerminateEditingControl(int rowIndex)
        {
            base.TerminateEditingControl(rowIndex);

            this.GcMultiRow.MouseCaptureChanged -= new EventHandler(GcMultiRow_MouseCaptureChanged);
        }

        int GetValueFromPoint(Point point)
        {
            double value = (this.Maximum - this.Minimum) * (((double)point.X) / (this.Width)) + this.Minimum;

            return (int)value;
        }

        public void PrepareEditingCellForEdit(bool selectAll)
        {
            // Do some thing to prepare edit for editing cell.
        }
    }

    public class EditedProgressBarCellDemo : Form
    {
        private GcMultiRow gcMultiRow1 = new GcMultiRow();

        public EditedProgressBarCellDemo()
        {
            this.Text = "Edit cell without embed control Demo";

            this.Height = 400;

            // Add MultiRow to form
            this.gcMultiRow1.Dock = DockStyle.Fill;
            this.Controls.Add(this.gcMultiRow1);

            // Tip label
            Label label = new Label();
            label.Height = 20;
            label.Dock = DockStyle.Bottom;
            label.BackColor = SystemColors.Info;
            label.Text = "Yow can try to click or drag a cell to edit cell value";
            this.Controls.Add(label);

            this.Load += new EventHandler(Form1_Load);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // Add ListBoxCell into template.
            EditedProgressBarCell editedProgressBarCell = new EditedProgressBarCell();

            editedProgressBarCell.Size = new Size(200, 30);

            Cell[] cells = new Cell[] { editedProgressBarCell };

            // Create a template by listBoxCell cell.
            Template template = Template.CreateGridTemplate(cells);

            this.gcMultiRow1.Template = template;

            this.gcMultiRow1.RowCount = 6;
        }

        [STAThreadAttribute()]
        public static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new EditedProgressBarCellDemo());
        }
    }
}