GWT CellTable自定义数字单元格

GWT 2.5->我通过扩展EditTextCell创建了自定义NumberCell，但它将amount值视为字符串。我想在该列中进行列排序，但它的排序方式类似于字符串值

这是我的密码

  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.awt.event.KeyEvent;
import java.util.HashMap;
import java.util.Map;

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;

public class MyNumberEditCell extends EditTextCell 
 {
    Map<Object, MyNumberEditCell.ViewData> viewDataMap = new HashMap<Object, MyNumberEditCell.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}\" tabindex=\"-1\"></input>")
            SafeHtml input(String value);
          }



    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 if (BLUR.equals(event.getType())) {
                        // 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);
      }
    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);
        }
      }
}

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.awt.event.KeyEvent；
导入java.util.HashMap；
导入java.util.Map；
导入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；
公共类MyNumberEditCell扩展了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{
@模板（“”）
安全HTML输入（字符串值）；
}
public void render（com.google.gwt.cell.client.cell.Context），
字符串值，安全HtmlBuilder sb）{
超级渲染（上下文、值、sb）；
} 
@凌驾
public void onBrowserEvent（上下文上下文、元素父级、字符串值、，
NativeEvent事件，ValueUpdater（ValueUpdater）{
if（DBLCLICK.equals（event.getType（）））{
onBrowserEvent（supercontext、superparent、supervalue、superevent、supervalueup）；
}
else if（BLUR.equals（event.getType（）））{
//提交更改。确保我们正在模糊输入元素和
//而不是父元素本身。
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）；
}
私有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（）；
返回false；
}
私有void cancel（上下文上下文、元素父元素、字符串值）{
clearInput（getInputElement（父级））；
setValue（上下文、父项、值）；
}
私有本机void clearInput（元素输入）/*-{
如果（输入。选择结束）
input.selectionEnd=input.selectionStart；
else if（$doc.selection）
$doc.selection.clear（）；
}-*/;
私有InputElement getInputElement（元素父级）{
返回parent.getFirstChild（）.cast（）；
}
私有字符串updateViewData（元素父元素、ViewData、ViewData、，
布尔值（编辑）{
InputElement输入=（InputElement）parent.getFirstChild（）；
字符串值=input.getValue（）；
viewData.setText（值）；
viewData.setEditing（isEditing）；
返回值；
}
私有void提交（上下文上下文、元素父元素、ViewData、ViewData、，