2010-05-19 17 views
14

में न्यूमेरिक टेक्स्ट फ़ील्ड के लिए समाधान मुझे Gxt की NumberField के व्यवहार में बहुत समान टेक्स्ट फ़ील्ड चाहिए। दुर्भाग्य से मैं अपने आवेदन में जीटीटी का उपयोग नहीं कर रहा हूं और जीडब्ल्यूटी 2.0 में अभी तक एक न्यूमेरिक टेक्स्ट फील्ड कार्यान्वयन नहीं है।जीडब्ल्यूटी

तो वर्तमान में मुझे कीबोर्डफैंडर का उपयोग करके गैर-न्यूमेरिक कीस्ट्रोक को फ़िल्टर करके नंबरफिल्ड अनुकरण करने के विकल्प के साथ छोड़ देता है।

क्या यह समस्या से निपटने का सबसे अच्छा तरीका है? क्या यहां किसी के पास दिमाग में बेहतर समाधान/दृष्टिकोण है?

अग्रिम में :)

+0

अनुमान, इस CRUD आवेदन में एक बहुत ही लगातार आवश्यकता है ऑन। जानना चाहते हैं कि आपने इसे कैसे लागू किया है। –

+1

'कुंजी * हैंडलर' में से किसी एक के माध्यम से फ़िल्टर करना बहुत सरल लगता है - आपको और क्या चाहिए/उम्मीद है? आप GXT के स्रोत कोड को भी देख सकते हैं कि उन्होंने अपने नंबरफिल्ड को कैसे कार्यान्वित किया - जीडब्ल्यूटी में इसे पुन: कार्यान्वित करना एक हवा होना चाहिए। –

उत्तर

13

यहाँ आप कोड है कि मैं अपने वर्गों में से एक में उपयोग पा सकते हैं धन्यवाद। विशेषताएं 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); 
    } 
} 

अद्यतन: कोड उपलब्ध है https://github.com/ctasada/GWT-Eureka

+0

धन्यवाद कार्लोस, मैंने अपने संस्करण को नंबरफेल्ड पर पूरी तरह से KeyPressHandler में लागू किया था क्योंकि मुझे कीप और कीडाउन - स्पिनर जैसी सुविधा की आवश्यकता नहीं थी।मैं विशेष रूप से आपके प्रारूप वैल्यू तकनीक की तरह, क्योंकि यह क्षेत्र की अधिकतम सीमा को भी संक्षेप में बताता है - आपके विचार को उधार लेने की योजना;) जैसे ही मैं अपने विकास वर्कस्टेशन में जाता हूं, मैं अपना संस्करण पोस्ट करूंगा। धन्यवाद :) –

+0

इससे बहुत मदद मिलती है - क्या मैं व्यावसायिक रूप से उस कोड का उपयोग कर सकता हूं? और यदि हां, तो किस स्थितियों में? – slartidan

+2

@ स्लार्टिडन। अगर उसने आपकी मदद की तो बस वोट दें;) अगर आपको कुछ अतिरिक्त मदद की ज़रूरत है तो बस मुझसे संपर्क करें। –

0

में यहाँ NumberField की मेरी कार्यान्वयन है। कार्लोस के संस्करण की कार्यक्षमता में बहुत समान है, लेकिन दशमलव इनपुट और गैर-न्यूमेरिक कुंजी फ़िल्टरिंग के लिए अतिरिक्त समर्थन के साथ।

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(); 
     } 
    }); 
} 

}


पुनश्च: सुपर क्लास पाठ बॉक्स कुछ अतिरिक्त आवेदन विशिष्ट सुविधाओं के साथ GWT पाठ बॉक्स का विस्तार एक कस्टम वर्ग है। प्रारंभिक विधि() को मूल रूप से टेक्स्टबॉक्स कन्स्ट्रक्टर के अंदर बुलाया जाता है, और getSanitizedValue ट्रिमिंग के साथ कुछ बुनियादी सैनिटी चेक करता है।

5

उपयोगकर्ता को दशमलव संख्या इनपुट करने की अनुमति देने के लिए यहां एक सरल KeyPressHandler है;

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(); 
    } 
} 
+0

यह समाधान कई दशमलव बिंदुओं को अनुमति देता है, जो एक अवैध दशमलव बिंदु संख्या उत्पन्न करता है। – Alicia

1

कार्लोस Tasada जवाब काम करता है, लेकिन एक बग शामिल हैं: आप event.isShiftKeyDown जोड़ना चाहिए() से पहले स्विच/मामला ब्लॉक onKeyPress हैंडलर में जाँच करें। ऐसा लगता है कि कुछ प्रतीकों अन्यथा पारित करेंगे '('

+0

लेकिन यह अभी भी 'और' पास होगा। प्रतीकों, तो आपको event.getCharCode() भी जांचना होगा – HtonS

3

पता नहीं है जब इन कक्षाओं GWT में जोड़ा गया था, लेकिन वे मेरे लिए अच्छा काम किसी भी अतिरिक्त कोड के बिना:।

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

अधिक उन्नत सत्यापन के लिए आप कुछ कस्टम पार्सर के साथ अपने आधार वर्ग ValueBox अधिलेखित करने के लिए चाहते हो सकता है ...

1

जूलियन Downes के आधार पर जवाब देने के आप यह कर सकते हैं:

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(); 
      } 
     } 
    });