public interface IEditingControl 

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

namespace GrapeCity.Win.MultiRow.SampleCode
{
    public class ListBoxCell : Cell
    {
        public override Type EditType
        {
            get
            {
                return typeof(ListBoxEditingControl);
            }
        }

        List<string> _items = new List<string>();

        public List<string> Items
        {
            get
            {
                return _items;
            }
        }

        protected override void InitializeEditingControl(int rowIndex, object formattedValue, CellStyle style)
        {
            // Apply the settings of cell to editing control. 
            base.InitializeEditingControl(rowIndex, formattedValue, style);

            ListBoxEditingControl listBoxEditingControl = this.GcMultiRow.EditingControl as ListBoxEditingControl;

            for (int i = 0; i < this._items.Count; i++)
            {
                listBoxEditingControl.Items.Add(this._items[i]);
            }

            listBoxEditingControl.FormattedValue = formattedValue;
        }

        protected override void TerminateEditingControl(int rowIndex)
        {
            ListBoxEditingControl listBoxEditingControl = this.GcMultiRow.EditingControl as ListBoxEditingControl;
            
            // For performance reason, MultiRow use same instance for all cells.
            // So, when leave editing status, you should clear items, to prepare editing control be used next time.
            listBoxEditingControl.Items.Clear();

            base.TerminateEditingControl(rowIndex);
        }

        public override object Clone()
        {
            // When you derive from Cell and add new properties to the derived class, be sure to
            // override the Clone method to copy the new properties during cloning operations. 
            // You should also call the base class's Clone method so that the properties of the 
            // base class are copied to the new cell. 
            ListBoxCell listBoxCell = base.Clone() as ListBoxCell;

            listBoxCell.Items.AddRange(this.Items);

            return listBoxCell;
        }
    }

    public class ListBoxEditingControl : ListBox, IEditingControl
    {
        public ListBoxEditingControl()
        {
            this.BorderStyle = BorderStyle.None;
        }

        private GcMultiRow _gcMultiRow;

        // MultiRow control will set this property when begin edit. Editing control can use this property.
        public GcMultiRow GcMultiRow
        {
            get
            {
                return _gcMultiRow;
            }
            set
            {
                _gcMultiRow = value;
            }
        }

        private int _rowIndex;

        // MultiRow control will set this property when begin edit. Editing control can use this property.
        public int RowIndex
        {
            get
            {
                return _rowIndex;
            }
            set
            {
                _rowIndex = value;
            }
        }

        // 1. When begin edit, MultiRow should initial this property.
        // 2. When end edit, MultiRow will use this property's value as cell value.
        public object FormattedValue
        {
            get
            {
                return this.Text;
            }
            set
            {
                if (value == null)
                {
                    this.Text = string.Empty;
                }
                else
                {
                    this.Text = value.ToString();
                }
            }
        }
        
        // When user press Ctrl and wheel mouse wheel button. MultiRow will be zoomed.
        // MultiRow will change this property's value when zoom.
        // EditingControl should do some thing to fit the new zoom factor, for example, change Font.
        private float _zoomFactor;
        private Font _initializeFont = null;
        public float ZoomFactor
        {
            get
            {
                return _zoomFactor;
            }
            set
            {
                this._zoomFactor = value;

                if (_zoomFactor != 1 && _initializeFont != null)
                {
                    this.Font = new Font(_initializeFont.FontFamily, _initializeFont.Size * _zoomFactor);
                }
            }
        }

        public Cursor EditingPanelCursor
        {
            get 
            {
                return Cursors.Default;
            }
        }

        // The keys which will be handle by editing control.
        public bool WantsInputKey(Keys keyData)
        {
            // The editing control will handle up and down keys.
            if (keyData == Keys.Up || keyData == Keys.Down)
            {
                return true;
            }
            return false;
        }

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

        // Apply style.
        public void ApplyCellStyleToEditingControl(CellStyle cellStyle)
        {
            this.BackColor = Color.FromArgb(255, cellStyle.BackColor);
            this.ForeColor = Color.FromArgb(255, cellStyle.ForeColor);

            _initializeFont = cellStyle.Font;

            if (this._zoomFactor != 1)
            {
                this.Font = new Font(_initializeFont.FontFamily, _initializeFont.Size * _zoomFactor);
            }
        }

        // When the value has been edited, editing control should fire DirtyStateChanged event to notify MultiRow control.
        protected override void OnSelectedIndexChanged(EventArgs e)
        {
            base.OnSelectedIndexChanged(e);

            this.OnDirtyStateChanged(EventArgs.Empty);
        }

        protected virtual void OnDirtyStateChanged(EventArgs e)
        {
            if (this.DirtyStateChanged != null)
            {
                this.DirtyStateChanged(this, e);
            }
        }

        public event EventHandler DirtyStateChanged;
    }

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

        public EmbedThridPartControlDemo()
        {
            this.Text = "Embed Third Part 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 = 35;
            label.Dock = DockStyle.Bottom;
            label.BackColor = SystemColors.Info;
            label.Text = "Yow can try to double click a cell to enter editing status, and select an item in list box control to edit cell";
            this.Controls.Add(label);

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

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

            listBoxCell.Items.Add("Item1");
            listBoxCell.Items.Add("Item2");
            listBoxCell.Items.Add("Item3");

            listBoxCell.Size = new Size(150, 42);

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

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

            this.gcMultiRow1.Template = template;

            this.gcMultiRow1.RowCount = 6;

            // Initialize some cell's back color, you can try how the style affect the editing control's back color.
            this.gcMultiRow1.AlternatingRowsDefaultCellStyle.BackColor = Color.Yellow;
        }

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