GWT 2.5--自定义EditTextCell--不允许在TextCell中输入空格

我已经通过扩展EditTextCell创建了自定义单元格，我不能在EditTextCell中输入“空格”，如果我这样做，行celltable将通过离开文本单元格编辑的焦点而被选中

这是我的密码

package com.skit.compiere.client.widgets.fields;

import static com.google.gwt.dom.client.BrowserEvents.BLUR;
import static com.google.gwt.dom.client.BrowserEvents.DBLCLICK;
import static com.google.gwt.dom.client.BrowserEvents.KEYDOWN;
import static com.google.gwt.dom.client.BrowserEvents.KEYUP;

import java.util.HashMap;
import java.util.Map;

import org.compiere.vos.FieldVO;

import com.google.gwt.cell.client.EditTextCell;
import com.google.gwt.cell.client.ValueUpdater;
import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Element;
import com.google.gwt.dom.client.EventTarget;
import com.google.gwt.dom.client.InputElement;
import com.google.gwt.dom.client.NativeEvent;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.safehtml.client.SafeHtmlTemplates;
import com.google.gwt.safehtml.client.SafeHtmlTemplates.Template;
import com.google.gwt.safehtml.shared.SafeHtml;
import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
import com.google.gwt.text.shared.SafeHtmlRenderer;
import com.google.gwt.text.shared.SimpleSafeHtmlRenderer;
import com.skit.compiere.client.panel.MultiViewPanel;

public class SkitMultiTextCell extends EditTextCell {
    Map<Object, SkitMultiTextCell.ViewData> viewDataMap = new HashMap<Object, SkitMultiTextCell.ViewData>();
    private SafeHtmlRenderer<String> renderer;
    public boolean editable = true;
    public String SelectedValue = null;
    ValueUpdater<String> supervalueup ;
    Element superparent ;
    NativeEvent superevent;
    ViewData viewdata;
    Context supercontext ;
    String supervalue ;
    Template template = GWT.create(Template.class);
    SafeHtmlBuilder superhtml = new SafeHtmlBuilder();
    Context ctx =null;
    String val;
    int i=-1;
    interface Template extends SafeHtmlTemplates {
        @Template("<input type=\"text\" value=\"{0}\"></input>")//tabindex=\"-1\"
        SafeHtml input(String value);
    }
    /**
     * Renders EditTextCell contents
     */
    public void render(com.google.gwt.cell.client.Cell.Context context,
            String value, SafeHtmlBuilder sb) {     
        super.render(context, value, sb);
    } 
    @Override
    public void onBrowserEvent(Context context, Element parent, String value,
            NativeEvent event, ValueUpdater<String> valueUpdater) {

        if (DBLCLICK.equals(event.getType())) {

            super.onBrowserEvent(supercontext, superparent, supervalue, superevent, supervalueup);  
        }
        else{
            this.supervalueup = valueUpdater;
            this.superparent = parent;
            this.superevent = event;
            this.supercontext = context;
            this.supervalue = value;
            viewdata = new ViewData(supercontext.getKey().toString());
            String type = event.getType();
            boolean keyUp = KEYUP.equals(type);
            boolean keyDown = KEYDOWN.equals(type);
            setviewData(supercontext.getKey(), viewdata);       

            if (keyUp || keyDown) {
                this.editEvent(supercontext, superparent, supervalue,viewdata, superevent, supervalueup);
            }

            else if (BLUR.equals(type)) {
                // Commit the change. Ensure that we are blurring the input element and
                // not the parent element itself.
                EventTarget eventTarget = event.getEventTarget();
                if (Element.is(eventTarget)) {
                    Element target = Element.as(eventTarget);
                    if ("input".equals(target.getTagName().toLowerCase())) {
                        commit(supercontext, superparent, viewdata, supervalueup);
                    }
                }
            }           
        }
    }
    public ViewData getviewData(Object key) {
        return (key == null) ? null : viewDataMap.get(key);
    }
    /**
     * Fires KeyPress Events
     * @param context
     * @param parent
     * @param value
     * @param viewData
     * @param event
     * @param valueUpdater
     */
    private void editEvent(Context context, Element parent, String value,
            ViewData viewData, NativeEvent event, ValueUpdater<String> valueUpdater) {
        String type = event.getType();
        System.out.println(type);
        boolean keyUp = KEYUP.equals(type);
        boolean keyDown = KEYDOWN.equals(type);
        //          int keyCodes = event.getKeyCode();
        //         if(event.getKeyCode()==32){
        //               event.preventDefault();
        //               return;
        //           }
        if (keyUp || keyDown) {
            int keyCode = event.getKeyCode();

            if ( keyCode == KeyCodes.KEY_ENTER ||keyCode == KeyCodes.KEY_ESCAPE) {
                // Commit the change.
                commit(context, parent, viewData, valueUpdater);
            } 

            else if (keyUp && keyCode == KeyCodes.KEY_ESCAPE) {
                // Cancel edit mode.
                String originalText = viewData.getOriginal();
                if (viewData.isEditingAgain()) {
                    viewData.setText(originalText);
                    viewData.setEditing(false);
                } else {
                    setviewData(context.getKey(), null);
                }
                cancel(context, parent, value);
            } else {
                // Update the text in the view data on each key.
                //                if(event.getKeyCode()==32){
                //                    viewdata.setText(viewdata.getText()+" ");
                //                    viewdata.setEditing(true);
                //                 }
                updateViewData(parent, viewData, true);
            }
        } 

    }
    @Override
    public boolean isEditing(Context context, Element parent, String value) {
        SafeHtmlBuilder safehtml = new SafeHtmlBuilder();
        return false;

    }
    private void cancel(Context context, Element parent, String value) {
        clearInput(getInputElement(parent));
        setValue(context, parent, value);
    }
    private native void clearInput(Element input) /*-{
    if (input.selectionEnd)
      input.selectionEnd = input.selectionStart;
    else if ($doc.selection)
      $doc.selection.clear();
  }-*/;

    private InputElement getInputElement(Element parent) {
        return parent.getFirstChild().<InputElement> cast();
    }

    private String updateViewData(Element parent, ViewData viewData,
            boolean isEditing) {
        InputElement input = (InputElement) parent.getFirstChild();
        String value = input.getValue();
        viewData.setText(value);
        viewData.setEditing(isEditing);
        return value;
    }

    private void commit(Context context, Element parent, ViewData viewData,
            ValueUpdater<String> valueUpdater) {
        String value = updateViewData(parent, viewData, false);
        clearInput(getInputElement(parent));
        setValue(context, parent, value);
        if (valueUpdater != null) {
            valueUpdater.update(value);
        }
    }
    public void setValue(Context context, Element parent, String value) {
        SafeHtmlBuilder sb = new SafeHtmlBuilder();
        renderFields(context, value, sb);
        parent.setInnerSafeHtml(sb.toSafeHtml());
    }
    private void renderFields(com.google.gwt.cell.client.Cell.Context context,
            String value, SafeHtmlBuilder sb) {
        this.renderer = SimpleSafeHtmlRenderer.getInstance();
        Object key = context.getKey();
        ViewData viewData = getviewData(key);
        if (viewData != null && !viewData.isEditing() && value != null
                && value.equals(viewData.getText())) {
            clearViewData(key);
            viewData = null;
        }

        String toRender = value;
        if (viewData != null) {
            String text = viewData.getText();
            if (viewData.isEditing()) {
                /*
                 * Do not use the renderer in edit mode because the value of a text
                 * input element is always treated as text. SafeHtml isn't valid in the
                 * context of the value attribute.
                 */
                 sb.append(template.input(value));
                 return;
            } else {
                // The user pressed enter, but view data still exists.
                toRender = text;
            }
        }

        if (toRender != null && toRender.trim().length() > 0) {
            sb.append(renderer.render(toRender));
        } else {
            /*
             * Render a blank space to force the rendered element to have a height.
             * Otherwise it is not clickable.
             */
            sb.appendHtmlConstant("\u00A0");
        }

    }
    public void setviewData(Object key, ViewData viewData) {
        if (key == null) {
            return;
        }

        if (viewData == null) {
            clearViewData(key);
        } else {
            viewDataMap.put(key, viewData);
        }
    }
    static class ViewData {

        private boolean isEditing;

        /**
         * If true, this is not the first edit.
         */
        private boolean isEditingAgain;

        /**
         * Keep track of the original value at the start of the edit, which might be
         * the edited value from the previous edit and NOT the actual value.
         */
        private String original;

        private String text;

        /**
         * Construct a new ViewData in editing mode.
         *
         * @param text the text to edit
         */
        public ViewData(String text) {
            this.original = text;
            this.text = text;
            this.isEditing = true;
            this.isEditingAgain = false;
        }

        @Override
        public boolean equals(Object o) {
            if (o == null) {
                return false;
            }
            ViewData vd = (ViewData) o;
            return equalsOrBothNull(original, vd.original)
                    && equalsOrBothNull(text, vd.text) && isEditing == vd.isEditing
                    && isEditingAgain == vd.isEditingAgain;
        }

        public String getOriginal() {
            return original;
        }

        public String getText() {
            return text;
        }

        @Override
        public int hashCode() {
            return original.hashCode() + text.hashCode()
                    + Boolean.valueOf(isEditing).hashCode() * 29
                    + Boolean.valueOf(isEditingAgain).hashCode();
        }

        public boolean isEditing() {
            return isEditing;
        }

        public boolean isEditingAgain() {
            return isEditingAgain;
        }

        public void setEditing(boolean isEditing) {
            boolean wasEditing = this.isEditing;
            this.isEditing = isEditing;

            // This is a subsequent edit, so start from where we left off.
            if (!wasEditing && isEditing) {
                isEditingAgain = true;
                original = text;
            }
        }

        public void setText(String text) {
            this.text = text;
        }

        private boolean equalsOrBothNull(Object o1, Object o2) {
            return (o1 == null) ? o2 == null : o1.equals(o2);
        }
    }
    public void setEditable(boolean flag)
    {
        editable = flag;
    }
    public void SetSelectedValue (String Value)
    {
        SelectedValue = Value;
    }
      String oldvalue = null;  static FieldVO m_fieldVO = null; 
      /**
       * Sets FieldVO, ListOptions
       * @param fieldvo
       * @param val
       * @param pinfo
       */
      public void SetFieldVO(FieldVO fieldvo) 
      {     
        m_fieldVO = fieldvo;
       }   

       public static  MultiViewPanel mv=null;
       /**
        * Sets MultiViewpanel value
        * @param mvp
        */
        public void setMVP(MultiViewPanel mvp)
        {
          this.mv = mvp;
        }
}

package com.skit.compiere.client.widgets.fields；
导入静态com.google.gwt.dom.client.BrowserEvents.BLUR；
导入静态com.google.gwt.dom.client.BrowserEvents.DBLCLICK；
导入静态com.google.gwt.dom.client.BrowserEvents.KEYDOWN；
导入静态com.google.gwt.dom.client.BrowserEvents.KEYUP；
导入java.util.HashMap；
导入java.util.Map；
导入org.compiere.vos.FieldVO；
导入com.google.gwt.cell.client.EditTextCell；
导入com.google.gwt.cell.client.ValueUpdater；
导入com.google.gwt.core.client.gwt；
导入com.google.gwt.dom.client.Element；
导入com.google.gwt.dom.client.EventTarget；
导入com.google.gwt.dom.client.InputElement；
导入com.google.gwt.dom.client.NativeEvent；
导入com.google.gwt.event.dom.client.KeyCodes；
导入com.google.gwt.safehtml.client.SafeHtmlTemplates；
导入com.google.gwt.safehtml.client.SafeHtmlTemplates.Template；
导入com.google.gwt.safehtml.shared.safehtml；
导入com.google.gwt.safehtml.shared.SafeHtmlBuilder；
导入com.google.gwt.text.shared.SafeHtmlRenderer；
导入com.google.gwt.text.shared.SimpleSafeHtmlRenderer；
导入com.skit.compiere.client.panel.MultiViewPanel；
公共类SkitMultiTextCell扩展了EditTextCell{
Map viewDataMap=新建HashMap（）；
私人保险公司；
公共布尔可编辑=真；
公共字符串SelectedValue=null；
ValueUpdater supervalueup；
元素超级母体；
国家事件超级事件；
ViewData ViewData；
语境超语境；
字符串超值；
Template Template=GWT.create（Template.class）；
SafeHtmlBuilder superTML=新的SafeHtmlBuilder（）；
上下文ctx=null；
字符串val；
int i=-1；
接口模板扩展了安全HtmlTemplates{
@模板（“”//tabindex=\“-1\”
安全HTML输入（字符串值）；
}
/**
*呈现EditTextCell内容
*/
public void render（com.google.gwt.cell.client.cell.Context），
字符串值，SafeHtmlBuilder sb）{
超级渲染（上下文、值、sb）；
} 
@凌驾
public void onBrowserEvent（上下文上下文、元素父级、字符串值、，
NativeEvent事件，ValueUpdater（ValueUpdater）{
if（DBLCLICK.equals（event.getType（）））{
onBrowserEvent（supercontext、superparent、supervalue、superevent、supervalueup）；
}
否则{
this.supervalueup=valueUpdater；
this.superparent=父对象；
this.superevent=事件；
this.supercontext=上下文；
this.supervalue=值；
viewdata=新的viewdata（supercontext.getKey（）.toString（））；
字符串类型=event.getType（）；
布尔keyUp=keyUp.equals（类型）；
布尔keyDown=keyDown.equals（类型）；
setviewData（supercontext.getKey（），viewdata）；
如果（键向上| |键向下）{
editEvent（supercontext、superparent、supervalue、viewdata、superevent、supervalueup）；
}
else if（模糊等于（类型））{
//提交更改。确保我们正在模糊输入元素和
//而不是父元素本身。
EventTarget EventTarget=event.getEventTarget（）；
if（元素is（事件目标））{
元素目标=元素.as（eventTarget）；
if（“input”.equals（target.getTagName（）.toLowerCase（）））{
提交（supercontext、superparent、viewdata、supervalueup）；
}
}
}           
}
}
公共视图数据getviewData（对象键）{
return（key==null）？null:viewDataMap.get（key）；
}
/**
*触发按键事件
*@param上下文
*@param父级
*@param值
*@param viewData
*@param事件
*@param valueUpdater
*/
私有void editEvent（上下文上下文、元素父元素、字符串值、，
ViewData（ViewData、NativeEvent事件、ValueUpdater ValueUpdater）{
字符串类型=event.getType（）；
系统输出打印项次（类型）；
布尔keyUp=keyUp.equals（类型）；
布尔keyDown=keyDown.equals（类型）；
//int keyCodes=event.getKeyCode（）；
//if（event.getKeyCode（）==32）{
//event.preventDefault（）；
//返回；
//           }
如果（键向上| |键向下）{
int keyCode=event.getKeyCode（）；
如果（keyCode==KeyCodes.KEY_输入| | keyCode==KeyCodes.KEY_转义）{
//提交更改。
提交（上下文、父级、viewData、valueUpdater）；
} 
else if（keyUp&&keyCode==KeyCodes.KEY\u ESCAPE）{
//取消编辑模式。
String originalText=viewData.getOriginal（）；
if（viewData.isEditingAgain（））{
viewData.setText（originalText）；
viewData.setEditing（false）；
}否则{
setviewData（context.getKey（），null）；
}
取消（上下文、父项、值）；
}否则{
//更新每个关键点上的视图数据中的文本。
//if（event.getKeyCode（）==32）{
//viewdata.setText（viewdata.getText（）+）；
//viewdata.setEditing（true）；
//                 }
updateViewData（父级、viewData、true）；
}
} 
}
@凌驾
公共布尔isEditing（上下文上下文、元素父级、字符串值）{
SafeHtmlBuilder safehtml=新的SafeHtmlBuilder（）；
    if(keyCode == 32)
 {
            InputElement element = event.getEventTarget().cast();
            final int start = element.getPropertyInt("selectionStart");
            final int end = element.getPropertyInt("selectionEnd");
            if (start == end) {
                    String before = element.getValue();
                    String after = before.substring(0, start) + " "
                                    + before.substring(start);
                    element.setValue(after);
                    element.setPropertyInt("selectionStart", start + 1);
                    element.setPropertyInt("selectionEnd", start + 1); 
                }
    }