import org.eclipse.swt.custom.CCombo;

import org.eclipse.swt.widgets.Text;

    column.setHeaderControl(new CCombo(grid,SWT.READ_ONLY|SWT.BORDER));

    column.setMoveable(true);

    column2.setMoveable(true);

    column2.setHeaderControl(new Text(grid,SWT.BORDER));

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.widgets.Button;

		Button b = new Button(shell,SWT.PUSH);

		b.addSelectionListener(new SelectionAdapter() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				System.err.println(cdt.getSelection());

			}

		});

	<classpathentry kind="src" path="src"/>

package org.eclipse.nebula.snippets.gridviewer;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ColumnLabelProvider;

import org.eclipse.jface.viewers.ColumnViewerEditor;

import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;

import org.eclipse.jface.viewers.ColumnViewerEditorActivationListener;

import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;

import org.eclipse.jface.viewers.ColumnViewerEditorDeactivationEvent;

import org.eclipse.jface.viewers.ICellModifier;

import org.eclipse.jface.viewers.TextCellEditor;

import org.eclipse.nebula.jface.gridviewer.GridTableViewer;

import org.eclipse.nebula.jface.gridviewer.GridViewerColumn;

import org.eclipse.nebula.jface.gridviewer.GridViewerEditor;

import org.eclipse.nebula.widgets.grid.Grid;

import org.eclipse.nebula.widgets.grid.GridItem;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

public class Test

{

    private Pattern m_IsValidPattern = null;

    public class MyModel

    {

        private String sCounter = "";

        public MyModel(){

        }

        public void setCounter(String sCounter)

        {

            this.sCounter = sCounter;

        }

        public String toString()

        {

            return sCounter;

        }

    }

    public class MyTextCellEditor extends TextCellEditor

    {

        /**

         * search pattern is Numeric character

         */

        private Pattern m_IsValidPattern = null;

        public MyTextCellEditor(Grid parent) {

            super(parent);

            m_IsValidPattern = Pattern.compile("[\\w+-\\.]");

        }

        @Override

        public void activate(ColumnViewerEditorActivationEvent activationEvent) {

            // set the activation character

            String s1 = String.valueOf( activationEvent.character );

            Matcher matcher = m_IsValidPattern.matcher( s1 );

            if (matcher.matches()) {

                doSetValue(s1);

            }

            super.activate(activationEvent);

        }

    }

    public Test(Shell shell)

    {

        /* allow numbers and characters */

        m_IsValidPattern = Pattern.compile("[\\w+-\\.]");

        final GridTableViewer v = new GridTableViewer(shell, SWT.BORDER

                | SWT.H_SCROLL | SWT.V_SCROLL);

        v.setCellEditors(new CellEditor[] {

                new MyTextCellEditor(v.getGrid()),

                new MyTextCellEditor(v.getGrid())

        });

        v.setCellModifier(new ICellModifier() {

            public boolean canModify(Object element, String property) {

                return true;

            }

            public Object getValue(Object element, String property) {

                return element.toString();

            }

            public void modify(Object element, String property, Object value) {

                if (element instanceof GridItem) {

                    GridItem item = (GridItem)element;

                    MyModel model = (MyModel)(item.getData());

                    model.setCounter(value.toString());

                    v.update(model, null);

                }

            }

        });

        ColumnViewerEditorActivationListener listener = new ColumnViewerEditorActivationListener() {

            public void afterEditorActivated(

                    ColumnViewerEditorActivationEvent event)

            {

            }

            public void afterEditorDeactivated(

                    ColumnViewerEditorDeactivationEvent event)

            {

            }

            public void beforeEditorActivated(

                    ColumnViewerEditorActivationEvent event)

            {

            }

            public void beforeEditorDeactivated(

                    ColumnViewerEditorDeactivationEvent event)

            {

            }

        };

        v.setContentProvider(new ArrayContentProvider());

        v.setColumnProperties(new String[] { "1", "2" });

        v.getGrid().setCellSelectionEnabled(true);

        v.getGrid().setLinesVisible(true);

        v.getGrid().setHeaderVisible(true);

        ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(

                v) {

            protected boolean isEditorActivationEvent(

                    ColumnViewerEditorActivationEvent event)

            {

                boolean result;

                String s1          = String.valueOf( event.character );

                Matcher matcher    = m_IsValidPattern.matcher( s1 );

                boolean bIsCharKey = matcher.matches();

                boolean bEnableKey =

                    (event.keyCode == SWT.CR) ||

                    (event.keyCode == SWT.KEYPAD_CR) ||

                    (event.keyCode == SWT.F2) ||

                    bIsCharKey;

                result = event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL

                        || event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION

                        || (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && bEnableKey)

                        || event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC;

                return result;

            }

        };

        GridViewerEditor.create(v, actSupport,

                ColumnViewerEditor.TABBING_HORIZONTAL

                        | ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR

                        | ColumnViewerEditor.TABBING_VERTICAL

                        | ColumnViewerEditor.KEYBOARD_ACTIVATION);

        v.getColumnViewerEditor().addEditorActivationListener(listener);

        GridViewerColumn column = new GridViewerColumn(v, SWT.NONE);

        column.getColumn().setWidth(200);

        column.getColumn().setMoveable(true);

        column.getColumn().setText("Column 1");

        column.setLabelProvider(new ColumnLabelProvider());

        column = new GridViewerColumn(v, SWT.NONE);

        column.getColumn().setWidth(200);

        column.getColumn().setMoveable(true);

        column.getColumn().setText("Column 2");

        column.setLabelProvider(new ColumnLabelProvider());

        MyModel[] model = createModel();

        v.setInput(model);

    }

    private MyModel[] createModel() {

        MyModel[] elements = new MyModel[10];

        for (int i = 0; i < 10; i++)

        {

            elements[i] = new MyModel();

            if (i<3){

                Double h = Double.valueOf(i);

                elements[i].setCounter( h.toString() );

            }

        }

        return elements;

    }

    public static void main(String[] args)

    {

        Display display = new Display();

        Shell shell = new Shell(display);

        shell.setLayout(new FillLayout());

        new Test(shell);

        shell.open();

        while (!shell.isDisposed())

        {

            if (!display.readAndDispatch())

                display.sleep();

        }

        display.dispose();

    }

} 

	/**

	 * @return the bounds reserved for the control

	 */

	protected Rectangle getControlBounds(Object value, boolean preferred) {

		Rectangle bounds = getBounds();

		GridColumn column = (GridColumn) value;

		Point controlSize = computeControlSize(column);

		return new Rectangle(bounds.x+3,bounds.height-bottomMargin-controlSize.y,bounds.width-6,controlSize.y);

	}

	private Point computeControlSize(GridColumn column) {

		if( column.getHeaderControl() != null ) {

			return column.getHeaderControl().computeSize(SWT.DEFAULT, SWT.DEFAULT);

		}

		return new Point(0,0);

	}

import org.eclipse.swt.widgets.Control;

	private GridHeaderEditor controlEditor;

    /**

	 * Set a new editor at the top of the control. If there's an editor already

	 * set it is disposed.

	 * 

	 * @param control

	 *            the control to be displayed in the header

	 */

	public void setHeaderControl(Control control) {

		if (this.controlEditor == null) {

			this.controlEditor = new GridHeaderEditor(this);

		}

		this.controlEditor.setEditor(control);

		getParent().recalculateHeader();

	}

	/**

	 * @return the current header control

	 */

	public Control getHeaderControl() {

		if( this.controlEditor != null ) {

			return this.controlEditor.getEditor();

		}

		return null;

	}

	/**

	 * Returns the bounds of the control to display

	 * 

	 * @return the bounds for the control or <code>null</code> if no control is

	 *         rendered

	 */

	protected Rectangle getControlBounds(Object value, boolean preferred) {

		return null;

	}

    void recalculateHeader() {

        computeHeaderHeight(sizingGC);

        scrollValuesObsolete = true;

        redraw();    	

    }

package org.eclipse.nebula.widgets.grid;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.ControlEditor;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.ControlListener;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Listener;

/**

 * Manager for a Control that appears below the grid column header.

 * Based on {@link GridEditor}. 

 */

class GridHeaderEditor extends ControlEditor {

  private Grid table;

  private GridColumn column;

  ControlListener columnListener;

  Listener resizeListener;

  private final Listener columnVisibleListener;

  private final Listener columnGroupListener;

  private final SelectionListener scrollListener;

  /**

   * Creates a TableEditor for the specified Table.

   * 

   * @param column the Table Control above which this editor will be displayed

   */

  GridHeaderEditor(final GridColumn column)

  {

      super(column.getParent());

      this.table = column.getParent();

      this.column = column;

      columnListener = new ControlListener()

      {

          public void controlMoved(ControlEvent e)

          {

              table.getDisplay().asyncExec(new Runnable() {

				public void run() {

					layout();

				}

              });

          }

          public void controlResized(ControlEvent e)

          {

              layout();

          }

      };

      columnVisibleListener = new Listener()

      {

        public void handleEvent(Event event)

          {

            getEditor().setVisible(((GridColumn)event.widget).isVisible());

            if (getEditor().isVisible()) layout();

          }  

      };

      resizeListener = new Listener()

      {

       public void handleEvent(Event event)

          {

              layout();

          }   

      };

      scrollListener = new SelectionListener()

      {

          public void widgetSelected(SelectionEvent e)

          {

              layout();

          }

          public void widgetDefaultSelected(SelectionEvent e)

          {

          }        

      };

      columnGroupListener = new Listener()

      {

          public void handleEvent(Event event)

          {

              if (getEditor() == null || getEditor().isDisposed()) return;

              getEditor().setVisible(column.isVisible());

              if (getEditor().isVisible()) layout();

          }

      };

      // The following three listeners are workarounds for

      // Eclipse bug 105764

      // https://bugs.eclipse.org/bugs/show_bug.cgi?id=105764

      table.addListener(SWT.Resize, resizeListener);

      if (table.getVerticalScrollBarProxy() != null)

      {

          table.getVerticalScrollBarProxy().addSelectionListener(scrollListener);

      }

      if (table.getHorizontalScrollBarProxy() != null)

      {

          table.getHorizontalScrollBarProxy().addSelectionListener(scrollListener);

      }

      // To be consistent with older versions of SWT, grabVertical defaults to

      // true

      grabVertical = true;

      initColumn();

  }

  /**

   * Returns the bounds of the editor.

   * @return bounds of the editor.

   */

  protected Rectangle internalComputeBounds()

  {

	return column.getHeaderRenderer().getControlBounds(column,true);

  }

  /**

   * Removes all associations between the TableEditor and the cell in the

   * table. The Table and the editor Control are <b>not</b> disposed.

   */

  public void dispose()

  {

      if (!table.isDisposed() && !column.isDisposed() )

      {

    	  column.removeControlListener(columnListener);

          if (column.getColumnGroup() != null){

        	  column.getColumnGroup().removeListener(SWT.Expand, columnGroupListener);

        	  column.getColumnGroup().removeListener(SWT.Collapse, columnGroupListener);

          }

      }

      if (!table.isDisposed())

      {

          table.removeListener(SWT.Resize, resizeListener);

          if (table.getVerticalScrollBarProxy() != null)

              table.getVerticalScrollBarProxy().removeSelectionListener(scrollListener);

          if (table.getHorizontalScrollBarProxy() != null)

              table.getHorizontalScrollBarProxy().removeSelectionListener(scrollListener);

      }

      columnListener = null;

      resizeListener = null;

      table = null;

      super.dispose();

  }

  /**

   * Sets the zero based index of the column of the cell being tracked by this

   * editor.

   * 

   * @param column the zero based index of the column of the cell being

   * tracked by this editor

   */

  void initColumn()

  {

	  column.addControlListener(columnListener);

	  column.addListener(SWT.Show, columnVisibleListener);

	  column.addListener(SWT.Hide, columnVisibleListener);

      if (column.getColumnGroup() != null){

    	  column.getColumnGroup().addListener(SWT.Expand, columnGroupListener);

    	  column.getColumnGroup().addListener(SWT.Collapse, columnGroupListener);

      }

      layout();

  }

  /** 

   * {@inheritDoc}

   */

  public void layout()

  {

      if (table.isDisposed())

          return;

      table.getDisplay().asyncExec(new Runnable() {

		public void run() {

		      boolean hadFocus = false;

		      if (getEditor() == null || getEditor().isDisposed()) {

		          return;

		      }

		      if (getEditor().getVisible())

		      {

		          hadFocus = getEditor().isFocusControl();

		      }

			Rectangle rect = internalComputeBounds();

		      if( rect == null ) {

		    	  getEditor().setVisible(false);

		    	  return;

		      }

		      getEditor().setBounds(rect);

		      if (hadFocus)

		      {

		          if (getEditor() == null || getEditor().isDisposed())

		              return;

		          getEditor().setFocus();

		      }

		}

      });

  }

}