GWT中数字文本字段的解决方案

我需要一个与Gxt的NumberField行为非常相似的文本字段。不幸的是，我没有在我的应用程序中使用Gxt，GWT2.0还没有数字文本字段实现

因此，现在我可以选择通过键盘处理程序过滤掉非数字击键来模拟数字字段

这是解决问题的最好办法吗？这里有没有人有更好的解决方案/方法

---

提前感谢：）

在这里您可以找到我在我的一个类中使用的代码。这些功能比GXT的功能要有限得多，但应该让您进入正确的轨道

这是一个非常基本的小部件，但做了我需要做的事情

public class ValueTextBox extends TextBox {

    private int min = 0;
    private int max = 100;
    private boolean minConstrained = true;
    private boolean maxConstrained = true;
    private int minDigits = 1;
    private int step = 1;

    private KeyUpHandler keyUpHandler = new KeyUpHandler() {

        @Override
        public void onKeyUp(KeyUpEvent event) {
            if (isReadOnly() || !isEnabled()) {
                return;
            }

            int keyCode = event.getNativeEvent().getKeyCode();

            boolean processed = false;

            switch (keyCode) {
            case KeyCodes.KEY_LEFT:
            case KeyCodes.KEY_RIGHT:
            case KeyCodes.KEY_BACKSPACE:
            case KeyCodes.KEY_DELETE:
            case KeyCodes.KEY_TAB:
                if (getText().isEmpty()) {
                    setValue(formatValue(min));
                }
                return;
            case KeyCodes.KEY_UP:
                if (step != 0) {
                    increaseValue();
                    processed = true;
                }
                break;
            case KeyCodes.KEY_DOWN:
                if (step != 0) {
                    decreaseValue();
                    processed = true;
                }
                break;
            }

            if (processed) {
                cancelKey();
            }
        }

    };

    private KeyPressHandler keyPressHandler = new KeyPressHandler() {
        @Override
        public void onKeyPress(KeyPressEvent event) {

            if (isReadOnly() || !isEnabled()) {
                return;
            }

            int keyCode = event.getNativeEvent().getKeyCode();

            switch (keyCode) {
            case KeyCodes.KEY_LEFT:
            case KeyCodes.KEY_RIGHT:
            case KeyCodes.KEY_BACKSPACE:
            case KeyCodes.KEY_DELETE:
            case KeyCodes.KEY_TAB:
            case KeyCodes.KEY_UP:
            case KeyCodes.KEY_DOWN:
                return;
            }

            int index = getCursorPos();
            String previousText = getText();
            String newText;
            if (getSelectionLength() > 0) {
                newText = previousText.substring(0, getCursorPos())
                        + event.getCharCode()
                        + previousText.substring(getCursorPos()
                                + getSelectionLength(), previousText.length());
            } else {
                newText = previousText.substring(0, index)
                        + event.getCharCode()
                        + previousText.substring(index, previousText.length());
            }
            cancelKey();

            setValue(newText, true);
        }
    };

    public ValueTextBox(int value) {
        this(value, 0, 100);
    }

    public ValueTextBox(int value, int min, int max) {
        this(value, min, max, true);
    }

    public ValueTextBox(int value, int min, int max, boolean constrained) {
        this(value, min, max, constrained, constrained);
    }

    public ValueTextBox(int value, int min, int max, boolean minConstrained,
            boolean maxConstrained) {
        super();

        addKeyPressHandler(keyPressHandler);
        addKeyUpHandler(keyUpHandler);

        this.min = min;
        this.max = max;
        this.minConstrained = minConstrained;
        this.maxConstrained = maxConstrained;

        setValue(formatValue(value), false);
        setTextAlignment(TextBoxBase.ALIGN_CENTER);
        setStyleName(Resources.INSTANCE.css().fwFormEntry());
    }

    public void setMinDigits(int minDigits) {
        if (minDigits > 0) {
            this.minDigits = minDigits;

            String value = getText();
            long newValue = parseValue(value);

            setText(formatValue(newValue));
        }
    }

    public void setSteps(int step) {
        this.step = step;
    }

    protected void increaseValue() {
        if (step != 0) {
            String value = getText();
            long newValue = parseValue(value);
            newValue += step;
            if (maxConstrained && (newValue > max)) {
                return;
            }
            setValue(formatValue(newValue));
        }
    }

    protected void decreaseValue() {
        if (step != 0) {
            String value = getText();
            long newValue = parseValue(value);
            newValue -= step;
            if (minConstrained && (newValue < min)) {
                return;
            }
            setValue(formatValue(newValue));
        }
    }

    /**
     * @param value
     *            the value to format
     * @return the formatted value
     */
    protected String formatValue(long value) {
        String newValue = String.valueOf(value);

        if (minDigits > newValue.length()) {
            String leading = StringUtils.repeat("0", (minDigits - newValue
                    .length()));
            newValue = leading + newValue;
        }

        return newValue;
    }

    @Override
    public void setValue(String value) {
        setValue(value, false);
    }

    @Override
    public void setValue(String value, boolean fireEvents) {
        try {
            long newValue = parseValue(value);
            if ((maxConstrained && (newValue > max))
                    || (minConstrained && (newValue < min))) {
                return;
            }
            String prevText = getValue();
            super.setText(formatValue(newValue));
            if (fireEvents) {
                ValueChangeEvent.fireIfNotEqual(this, getValue(), prevText);
            }
        } catch (Exception ex) {
            // Do Nothing
            System.out.println(ex.getMessage());
        }
    }

    /**
     * @param value
     *            the value to parse
     * @return the parsed value
     */
    protected long parseValue(String value) {
        return Long.valueOf(value);
    }
}

public类ValueTextBox扩展了TextBox{
私有int min=0；
私人int最大值=100；
私有布尔值minconstrated=true；
私有布尔maxConstrained=true；
私人智力智力测验=1；
私有整数步长=1；
private KeyUpHandler KeyUpHandler=新的KeyUpHandler（）{
@凌驾
公共无效onKeyUp（KeyUpEvent事件）{
如果（isReadOnly（）| |！isEnabled（））{
返回；
}
int keyCode=event.getNativeEvent（）.getKeyCode（）；
布尔值=假；
开关（钥匙代码）{
case KeyCodes.KEYU左：
case KeyCodes.KEYU右键：
case KeyCodes.KEY\u退格：
case KeyCodes.KEYU删除：
case KeyCodes.KEY_选项卡：
if（getText（）.isEmpty（））{
设定值（最小值）；
}
返回；
case KeyCodes.KEYU UP：
如果（步骤！=0）{
增加值（）；
已处理=真；
}
打破
case KeyCodes.KEY_向下：
如果（步骤！=0）{
递减值（）；
已处理=真；
}
打破
}
如果（已处理）{
cancelKey（）；
}
}
};
private KeyPressHandler KeyPressHandler=new KeyPressHandler（）{
@凌驾
按键时公共无效（按键事件）{
如果（isReadOnly（）| |！isEnabled（））{
返回；
}
int keyCode=event.getNativeEvent（）.getKeyCode（）；
开关（钥匙代码）{
case KeyCodes.KEYU左：
case KeyCodes.KEYU右键：
case KeyCodes.KEY\u退格：
case KeyCodes.KEYU删除：
case KeyCodes.KEY_选项卡：
case KeyCodes.KEYU UP：
case KeyCodes.KEY_向下：
返回；
}
int index=getCursorPos（）；
字符串previousText=getText（）；
字符串新文本；
如果（getSelectionLength（）>0）{
newText=previousText.substring（0，getCursorPos（））
+event.getCharCode（）
+子字符串（getCursorPos（））
+getSelectionLength（），previousText.length（）；
}否则{
newText=previousText.substring（0，索引）
+event.getCharCode（）
+previousText.substring（索引，previousText.length（））；
}
cancelKey（）；
设置值（newText，true）；
}
};
公共价值文本框（int值）{
该值（0，100）；
}
公共值文本框（int值、int最小值、int最大值）{
这（值、最小值、最大值、真值）；
}
公共值文本框（int值、int最小值、int最大值、布尔约束）{
这（值、最小值、最大值、约束、约束）；
}
公共值文本框（int值、int最小值、int最大值、布尔最小值、，
布尔（最大约束）{
超级（）；
addKeyPressHandler（keyPressHandler）；
addKeyUpHandler（keyUpHandler）；
this.min=min；
this.max=max；
this.minconstrated=minconstrated；
this.maxconstrated=maxconstrated；
setValue（formatValue（value），false）；
setTextAlignment（TextBoxBase.ALIGN_CENTER）；
setStyleName（Resources.INSTANCE.css（）.fwFormEntry（））；
}
公共无效设置minDigits（int minDigits）{
如果（minDigits>0）{
this.minDigits=minDigits；
字符串值=getText（）；
long newValue=parseValue（值）；
setText（formatValue（newValue））；
}
}
公共无效设置步骤（int步骤）{
这个步骤=步骤；
}
受保护的无效增量值（）{
如果（步骤！=0）{
字符串值=getText（）；
long newValue=parseValue（值）；
newValue+=步长；
如果（maxConstrained&（newValue>max））{
返回；
}
setValue（formatValue（newValue））；
}
}
受保护的无效递减值（）{
如果（步骤！=0）{
字符串值=getText（）；
long newValue=parseValue（值）；
newValue-=步长；
if（最小约束&（新值<最小值））{
返回；
}
setValue（formatValue（newValue））；
}
}
/**
*@param值
*要格式化的值
*@返回格式化的值
*/
受保护的字符串格式值（长值）{
String newValue=String.valueOf（value）；
if（minDigits>newValue.length（））{
字符串前导=StringUtils.repeat（“0”），（minDigits-newValue
.length（））；
新值=前导+新值；
}
返回新值；
}
@凌驾
公共void设置值（字符串值）{
设置值（值，false）；
}
@凌驾
public void setValue（字符串值，布尔fireEvents）{
试一试{
long newValue=parseValue（值）；
如果（（maxConstrained&&（newValue>max））
public class NumberBox extends TextBox
{
private boolean isDecimal = false;

public NumberBox( )
{
}

public boolean isDecimal( )
{
    return isDecimal;
}

public void setDecimal( boolean isDecimal )
{
    this.isDecimal = isDecimal;
}

public Integer getIntegerValue( )
{
    return ( StringUtil.isEmpty( getSanitizedValue( ) ) ) ? null : Integer.parseInt( getSanitizedValue( ) );
}

@Override
protected void initialize( )
{
    super.initialize( );
    addStyleName( "number" );

    this.addKeyPressHandler( new KeyPressHandler( )
    {
        public void onKeyPress( KeyPressEvent event )
        {
            if ( !isEnabled( ) || isReadOnly( ) )
                return;

            int keyCode = event.getNativeEvent( ).getKeyCode( );

            // allow special keys
            if ( ( keyCode == KeyCodes.KEY_BACKSPACE )
                    || ( keyCode == KeyCodes.KEY_DELETE )
                    || ( keyCode == KeyCodes.KEY_ENTER ) || ( keyCode == KeyCodes.KEY_ESCAPE ) || ( keyCode == KeyCodes.KEY_RIGHT )
                    || ( keyCode == KeyCodes.KEY_LEFT ) || ( keyCode == KeyCodes.KEY_TAB ) )
                return;

            // check for decimal '.'
            if ( isDecimal( ) && '.' == (char)keyCode && !getValue( ).contains( "." ) )
                return;

            // filter out non-digits
            if ( Character.isDigit( charCode ) )
                return;

            cancelKey( );
        }
    } );
}

public void onKeyPress(KeyPressEvent event){
    TextBox sender = (TextBox)event.getSource();

    if (sender.isReadOnly() || !sender.isEnabled()) {
        return;
    }

    Character charCode = event.getCharCode();
    int unicodeCharCode = event.getUnicodeCharCode();

    // allow digits, '.' and non-characters
    if (!(Character.isDigit(charCode) || charCode == '.' || unicodeCharCode == 0)){
        sender.cancelKey();
    }
}

com.google.gwt.user.client.ui.DoubleBox
com.google.gwt.user.client.ui.IntegerBox
com.google.gwt.user.client.ui.LongBox 

text.addKeyPressHandler(new KeyPressHandler() {

        @Override
        public void onKeyPress(KeyPressEvent event) {
            TextBox sender = (TextBox) event.getSource();

            if (sender.isReadOnly() || !sender.isEnabled()) {
                return;
            }
            if (event.getNativeEvent().getKeyCode() == KeyCodes.KEY_ENTER){
                return;
            }

            Character charCode = event.getCharCode();

            try{
                Double.parseDouble(sender.getText().concat(charCode.toString()));
            }
            catch(Exception e){
                sender.cancelKey();
            }
        }
    });