Hello,
I want to build Inspector object. I'm trying to achieve through inheritance class AbstractGridEditing <ColumnConfigItem> full code presents the following:
Everything works as it should. I wonder how to do to involve the appropriate options but only when you click in the right column.

Code:
private class ColumnConfigEditorValue extends
            AbstractGridEditing<ColumnConfigItem> {

        private boolean ignoreScroll;
        private boolean ignoreNextEnter;
        private boolean focusOnComplete;
        private boolean revertInvalid = false;
        private List<ColumnConfig<ColumnConfigItem, String>> listEditor;
        protected GroupingHandlerRegistration fieldRegistration = new GroupingHandlerRegistration();
        protected boolean activeEdit;
        protected boolean rowUpdated;

        private void createField(String name,
            ColumnConfig<ColumnConfigItem, String> columnConfig) {
            for (int i = 0; i < listEditor.size(); i++) {
                IsField<?> field = getEditor(listEditor.get(i));
                Widget w = field.asWidget();
                if (field != null && w.isAttached()) {    
                    field.asWidget().setVisible(false);
                    ComponentHelper.setParent(null, w);
                    ComponentHelper.doDetach(w);
                }
            }
            listEditor.clear();
            clearEditors();
            removeFieldBlurHandler();
            if (name.equalsIgnoreCase("TranslatorFieldName")) {
                addEditor(columnConfig, new TextField());
                listEditor.add(columnConfig);
            }
        }

        private void removeEditor(final GridCell cell, final IsField<?> field) {
            assert field != null;
            removeFieldBlurHandler();

            if (GXT.isIE() && field instanceof ValueBaseField<?>) {
                ValueBaseField<?> f = (ValueBaseField<?>) field;
                f.getCell().getInputElement(f.getElement()).blur();
            }

            Widget w = field.asWidget();
            if (field != null && w.isAttached()) {
                field.asWidget().setVisible(false);
                ComponentHelper.setParent(null, w);
                ComponentHelper.doDetach(w);
            }
        }

        private void removeFieldBlurHandler() {
            fieldRegistration.removeHandler();
        }

        protected <N, O> void doStartEditing(final GridCell cell) {
            if (getEditableGrid() != null && getEditableGrid().isAttached()
                    && cell != null) {
                ColumnConfigItem value = getEditableGrid().getStore().get(
                        cell.getRow());
                
                ColumnConfig<ColumnConfigItem, N> c = columnModel
                        .getColumn(cell.getCol());
                if (c != null && value != null) {

                    Converter<N, O> converter = getConverter(c);

                    ValueProvider<? super ColumnConfigItem, N> v = c
                            .getValueProvider();
                    N colValue = getEditableGrid().getStore().hasRecord(value) ? getEditableGrid()
                            .getStore().getRecord(value).getValue(v)
                            : v.getValue(value);
                    O convertedValue;
                    if (converter != null) {
                        convertedValue = converter.convertModelValue(colValue);
                    } else {
                        convertedValue = (O) colValue;
                    }

                    final IsField<O> field = getEditor(c);
                    if (field != null) {
                        if (field instanceof HasErrorHandler) {
                            ((HasErrorHandler) field).setErrorSupport(null);
                        }

                        activeCell = cell;

                        field.setValue(convertedValue);

                        if (field instanceof TriggerField<?>) {
                            ((TriggerField<?>) field).setMonitorTab(false);
                        }

                        if (field instanceof CheckBox) {
                            ((CheckBox) field).setBorders(true);
                        }

                        Widget w = field.asWidget();
                        getEditableGrid().getView().getEditorParent()
                                .appendChild(w.getElement());
                        ComponentHelper.setParent(getEditableGrid(), w);
                        ComponentHelper.doAttach(w);

                        w.setPixelSize(c.getWidth(), Integer.MIN_VALUE);
                        w.getElement().<XElement> cast().makePositionable(true);

                        Element row = getEditableGrid().getView().getRow(
                                cell.getRow());

                        int left = 0;
                        for (int i = 0; i < cell.getCol(); i++) {
                            if (!columnModel.isHidden(i)) {
                                left += columnModel.getColumnWidth(i);
                            }
                        }

                        w.getElement()
                                .<XElement> cast()
                                .setLeftTop(
                                        left,
                                        row.getAbsoluteTop()
                                                - getEditableGrid().getView()
                                                        .getBody()
                                                        .getAbsoluteTop());

                        field.asWidget().setVisible(true);

                        startMonitoring();

                        Scheduler.get().scheduleDeferred(
                                new ScheduledCommand() {
                                    @Override
                                    public void execute() {
                                        // browsers select all when tabbing into
                                        // a input and put cursor at location
                                        // when clicking into an input
                                        // with inline editing, the field is not
                                        // visible at time of click so we select
                                        // all. we ignore
                                        // field.isSelectOnFocus as this only
                                        // applies when clicking into a field
                                        if (field instanceof ValueBaseField<?>) {
                                            ValueBaseField<?> vf = (ValueBaseField<?>) field;
                                            vf.selectAll();
                                        }

                                        // EXTGWT-2856 calling doFocus before
                                        // selectAll is causing blur to fire
                                        // which ends the edit immediately
                                        // after it starts
                                        doFocus(field);

                                        ignoreScroll = false;

                                        fieldRegistration.removeHandler();

                                        fieldRegistration.add(field
                                                .addValueChangeHandler(new ValueChangeHandler<O>() {

                                                    @Override
                                                    public void onValueChange(
                                                            ValueChangeEvent<O> event) {
                                                        // if enter key cause
                                                        // value change we want
                                                        // to ignore the next
                                                        // enter key otherwise
                                                        // new edit will start
                                                        // by onEnter
                                                        ignoreNextEnter = true;

                                                        Timer t = new Timer() {

                                                            @Override
                                                            public void run() {
                                                                ignoreNextEnter = false;
                                                            }
                                                        };

                                                        completeEditing();

                                                        t.schedule(100);
                                                    }
                                                }));

                                        fieldRegistration.add(field
                                                .addBlurHandler(new BlurHandler() {

                                                    @Override
                                                    public void onBlur(
                                                            final BlurEvent event) {
                                                        ignoreNextEnter = true;

                                                        Timer t = new Timer() {

                                                            @Override
                                                            public void run() {
                                                                ignoreNextEnter = false;
                                                            }
                                                        };
                                                        cancelEditing();

                                                        t.schedule(100);
                                                    }
                                                }));

                                        fireEvent(new StartEditEvent<ColumnConfigItem>(
                                                cell));
                                    }
                                });
                    }
                }
            }

        }

        protected void doFocus(IsWidget field) {
            try {
                Widget widget = field.asWidget();
                if (widget instanceof Component) {
                    ((Component) widget).focus();
                } else if (widget instanceof Focusable) {
                    ((Focusable) widget).setFocus(true);
                } else {
                    widget.getElement().focus();
                }
            } catch (Exception e) {
                // IE throws exception if element not focusable
            }
        }

        protected <N, O> void doCompleteEditing() {
            if (activeCell != null) {
                final ColumnConfig<ColumnConfigItem, N> c = columnModel
                        .getColumn(activeCell.getCol());

                IsField<O> field = getEditor(c);

                if (field != null) {

                    Converter<N, O> converter = getConverter(c);

                    if (!field.isValid(false) && revertInvalid) {
                        cancelEditing();
                        return;
                    }

                    O fieldValue = null;

                    if (field instanceof ValueBaseField) {
                        fieldValue = ((ValueBaseField<O>) field)
                                .getCurrentValue();
                    } else {
                        fieldValue = field.getValue();
                    }

                    final N convertedValue;
                    if (converter != null) {
                        convertedValue = converter
                                .convertFieldValue(fieldValue);
                    } else {
                        convertedValue = (N) fieldValue;
                    }

                    removeEditor(activeCell, field);

                    ListStore<ColumnConfigItem> store = getEditableGrid()
                            .getStore();
                    ListStore<ColumnConfigItem>.Record r = store
                            .getRecord(store.get(activeCell.getRow()));

                    rowUpdated = true;

                    r.addChange(c.getValueProvider(), convertedValue);
                    fireEvent(new CompleteEditEvent<ColumnConfigItem>(
                            activeCell));

                    if (focusOnComplete) {
                        focusOnComplete = false;
                        focusGrid();
                    }
                }

                activeCell = null;
            }
        }

        public ColumnConfigEditorValue(TreeGrid<ColumnConfigItem> grid) {
            listEditor = new ArrayList<ColumnConfig<ColumnConfigItem, String>>();
            setEditableGrid(grid);
        }

        @Override
        public void cancelEditing() {
            // TODO Auto-generated method stub
        }

        @Override
        public void completeEditing() {
            if (activeCell != null) {
                Element elem = getEditableGrid().getView().getCell(
                        activeCell.getRow(), activeCell.getCol());
                elem.getFirstChildElement().getStyle()
                        .setVisibility(Style.Visibility.VISIBLE);
                doCompleteEditing();
            }
            stopMonitoring();
        }

        @Override
        public void startEditing(GridCell cell) {
            if (getEditableGrid() != null && getEditableGrid().isAttached()
                    && cell != null) {
                ColumnConfig<ColumnConfigItem, String> c = columnModel
                        .getColumn(cell.getCol());

                ColumnConfigItem value = getEditableGrid().getStore().get(
                        cell.getRow());
                createField(value.getName(), c);

                if (value != null) {
                    BeforeStartEditEvent<ColumnConfigItem> ce = new BeforeStartEditEvent<ColumnConfigItem>(
                            cell);
                    fireEvent(ce);
                    if (ce.isCancelled()) {
                        return;
                    }
                    if (getEditableGrid().getSelectionModel() instanceof CellSelectionModel) {
                        ((CellSelectionModel<?>) getEditableGrid()
                                .getSelectionModel()).selectCell(cell.getRow(),
                                cell.getCol());
                    }

                    Element elem = getEditableGrid().getView().getCell(
                            cell.getRow(), cell.getCol());
                    elem.getFirstChildElement().getStyle()
                            .setVisibility(Style.Visibility.HIDDEN);

                    cancelEditing();
                    ignoreScroll = true;
                    getEditableGrid().getView().ensureVisible(cell.getRow(),
                            cell.getCol(), true);

                    doStartEditing(cell);
                }
            }
        }

        @Override
        protected SafeHtml getErrorHtml() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        protected boolean isValid() {
            // TODO Auto-generated method stub
            return false;
        }

        @Override
        protected void showTooltip(SafeHtml content) {
            // TODO Auto-generated method stub

        }
    }
inspector.jpginspector_bug.jpg