/** * Returns the appropriate formatter based on the state of * <code>tf</code>. If <code>tf<code> is null we return null, otherwise * we return one of the following: * 1. Returns <code>nullFormatter</code> if <code>tf.getValue()</code> is * null and <code>nullFormatter</code> is not. * 2. Returns <code>editFormatter</code> if <code>tf.hasFocus()</code> is * true and <code>editFormatter</code> is not null. * 3. Returns <code>displayFormatter</code> if <code>tf.hasFocus()</code> is * false and <code>displayFormatter</code> is not null. * 4. Otherwise returns <code>defaultFormatter</code>. */ public AbstractFormatter getFormatter(JFormattedTextField tf) { if (tf == null) return null; if (tf.getValue() == null && nullFormatter != null) return nullFormatter; if (tf.hasFocus() && editFormatter != null) return editFormatter; if (!tf.hasFocus() && displayFormatter != null) return displayFormatter; return defaultFormatter; }
/** * Checks and returns custom formats on the editor, if any. * * @param editor the editor to check * @return the custom formats uses in the editor or null if it had * used defaults as defined in the datepicker properties */ private DateFormat[] getCustomFormats(JFormattedTextField editor) { DateFormat[] formats = null; if (editor != null) { AbstractFormatterFactory factory = editor.getFormatterFactory(); if (factory != null) { AbstractFormatter formatter = factory.getFormatter(editor); // fix for #1144: classCastException for custom formatters // PENDING JW: revisit for #1138 if ((formatter instanceof DatePickerFormatter) && !(formatter instanceof UIResource)) { // if (!(formatter instanceof DatePickerFormatterUIResource)) { formats = ((DatePickerFormatter) formatter).getFormats(); } } } return formats; }
@Override public void setCommitOnValidEdit(final boolean commit) { if (textComponent instanceof JFormattedTextField) { final JFormattedTextField formattedTextField = (JFormattedTextField)textComponent; final AbstractFormatter formatter = formattedTextField.getFormatter(); if (formatter instanceof DefaultFormatter) { final DefaultFormatter defaultFormatter = (DefaultFormatter)formatter; defaultFormatter.setCommitsOnValidEdit(commit); return; } } else if (textComponent instanceof JTextArea) { // ignore it for now } else { throw new UnsupportedOperationException("setCommitOnValidValue not supported for " + this); } }
private void init() { JFormattedTextField ftf = (JFormattedTextField)((JSpinner.DefaultEditor)this.getEditor()).getTextField(); // ! depends on swing implementation to actually use FormattedTextField ftf.setColumns(((TickSpinnerModel)getModel()).format.textFieldSize); ftf.setFormatterFactory(new JFormattedTextField.AbstractFormatterFactory() { @Override public AbstractFormatter getFormatter(JFormattedTextField tf) { return new JFormattedTextField.AbstractFormatter() { @Override public Object stringToValue(String text) throws ParseException { return ((TickSpinnerModel)getModel()).stringToTicks(text); } @Override public String valueToString(Object value) throws ParseException { return ((TickSpinnerModel)getModel()).ticksToString((Long)value); } }; } }); ftf.addCaretListener(this); }
/** * Verify the input text. An empty text string is allowed for an optional field. * The text is not valid if the formatter throws a parse exception. * * @param input Input component * @return TRUE if the input text is valid */ @Override public boolean verify(JComponent input) { boolean allow = true; if (input instanceof JFormattedTextField) { JFormattedTextField textField = (JFormattedTextField)input; AbstractFormatter formatter = textField.getFormatter(); if (formatter != null) { String value = textField.getText(); if (value.length() != 0) { try { formatter.stringToValue(value); } catch (ParseException exc) { allow = false; } } else if (!optionalField) { allow = false; } } } return allow; }
/** * Verify the input text. An empty text string is allowed for an optional field. * The text is not valid if the formatter throws a parse exception. * * @param input Input component * @return TRUE if the input text is valid */ public boolean verify(JComponent input) { boolean allow = true; if (input instanceof JFormattedTextField) { JFormattedTextField textField = (JFormattedTextField)input; AbstractFormatter formatter = textField.getFormatter(); if (formatter != null) { String value = textField.getText(); if (value.length() != 0) { try { formatter.stringToValue(value); } catch (ParseException exc) { allow = false; } } else if (!optionalField) { allow = false; } } } return allow; }
/** * Sets the format used to display the value of this spinner. */ public void setFormat(Format format) { JComponent editor = getEditor(); if (editor instanceof JSpinner.DefaultEditor) { JFormattedTextField textField = ((JSpinner.DefaultEditor) editor).getTextField(); AbstractFormatter formatter = textField.getFormatter(); if (formatter instanceof NumberFormatter) { ((NumberFormatter) formatter).setFormat(format); fireStateChanged(); } } }
/** * Returns an array of the formats used by the installed formatter * if it is a subclass of <code>JXDatePickerFormatter<code>. * <code>javax.swing.JFormattedTextField.AbstractFormatter</code> * and <code>javax.swing.text.DefaultFormatter</code> do not have * support for accessing the formats used. * * @return array of formats guaranteed to be not null, but might be empty. */ public DateFormat[] getFormats() { // Dig this out from the factory, if possible, otherwise return null. AbstractFormatterFactory factory = _dateField.getFormatterFactory(); if (factory != null) { AbstractFormatter formatter = factory.getFormatter(_dateField); if (formatter instanceof DatePickerFormatter) { return ((DatePickerFormatter) formatter).getFormats(); } } return EMPTY_DATE_FORMATS; }
/** * @param model */ public SizeSpinner(final SpinnerNumberModel model) { super(model); // this.addFocusListener(this); this.nm = (SpinnerNumberModel) super.getModel(); final DefaultFormatterFactory factory = new DefaultFormatterFactory(new AbstractFormatter() { private static final long serialVersionUID = 7808117078307243989L; @Override public Object stringToValue(final String text) throws ParseException { return SizeSpinner.this.textToObject(text); } @Override public String valueToString(final Object value) throws ParseException { return SizeSpinner.this.longToText(((Number) value).longValue()); } }); ((JSpinner.DefaultEditor) this.getEditor()).getTextField().setFormatterFactory(factory); ((JSpinner.DefaultEditor) this.getEditor()).getTextField().addFocusListener(this); ((JSpinner.DefaultEditor) this.getEditor()).getTextField().addActionListener(this); }
@Override public AbstractFormatter getFormatter(JFormattedTextField tf) { NumberFormat format = DecimalFormat.getInstance(); // format.setMinimumIntegerDigits(0); format.setMinimumFractionDigits(1); //set minimum decimal place format.setMaximumFractionDigits(maximumFractionDigits); //set maximum decimal place format.setRoundingMode(RoundingMode.HALF_UP); //set rounding decimal method InternationalFormatter formatter = new InternationalFormatter(format); formatter.setAllowsInvalid(false); return formatter; }
/** * Checks and returns custom formats on the editor, if any. * * @param editor the editor to check * @return the custom formats uses in the editor or null if it had * used defaults as defined in the datepicker properties */ private DateFormat[] getCustomFormats(JFormattedTextField editor) { DateFormat[] formats = null; if (editor != null) { AbstractFormatterFactory factory = editor.getFormatterFactory(); if (factory != null) { AbstractFormatter formatter = factory.getFormatter(editor); if (!(formatter instanceof DatePickerFormatterUIResource)) { formats = ((DatePickerFormatter) formatter).getFormats(); } } } return formats; }
/** * Returns an array of the formats used by the installed formatter * if it is a subclass of <code>JXDatePickerFormatter<code>. * <code>javax.swing.JFormattedTextField.AbstractFormatter</code> * and <code>javax.swing.text.DefaultFormatter</code> do not have * support for accessing the formats used. * * @return array of formats or null if unavailable. */ public DateFormat[] getFormats() { // Dig this out from the factory, if possible, otherwise return null. AbstractFormatterFactory factory = _dateField.getFormatterFactory(); if (factory != null) { AbstractFormatter formatter = factory.getFormatter(_dateField); if (formatter instanceof JXDatePickerFormatter) { return ((JXDatePickerFormatter)formatter).getFormats(); } } return null; }
public void testListEditor_formatter() throws Exception { JComponent comp = new JButton(); Object[] values = { "arrline1", "arrline2", "text", new Integer(33), comp }; spinner.setModel(new SpinnerListModel(values)); ListEditor listEditor = new ListEditor(spinner); spinner.setEditor(listEditor); AbstractFormatter formatter = ((ListEditor) spinner.getEditor()).getTextField() .getFormatter(); assertEquals(formatter.valueToString(null), ""); assertEquals(formatter.valueToString(new Integer(33)), "33"); assertEquals(formatter.stringToValue("text"), "text"); }
public AbstractFormatter getFormatter(JFormattedTextField tf) { return new AbstractFormatter() { public Object stringToValue(String text) throws ParseException { if (text != null && !text.equals(text.toLowerCase())) { throw new ParseException(text, 0); } return text; } public String valueToString(Object value) throws ParseException { return (String) value; } }; }
/** * Creates and returns a formatted text field with the formatter * specified and the original text specified, and with the default * parameters. Registers the focus listener specified with the * JFormattedTextField created. * * @param value the formatter to use * @param format the original value * @param flt the FocusListener object */ public static JFormattedTextField formattedField(Object value, AbstractFormatter format, FocusListener flt) { JFormattedTextField t = new JFormattedTextField(format); t.addFocusListener(flt); t.setValue(value); t.setColumns(20); t.setMinimumSize(new Dimension(30, 20)); return t; }
/** * Called to verify the state of the component * * @param input The input component * @return <pre>true</pre> if the input is in a valid state for the component */ public boolean verify(JComponent input) { if (input instanceof JFormattedTextField) { final JFormattedTextField ftf = (JFormattedTextField) input; final AbstractFormatter formatter = ftf.getFormatter(); if (formatter != null) { final String text = ftf.getText(); try { formatter.stringToValue(text); return true; } catch (ParseException pe) { // not a valid value return false; } } } return true; }
public HalbjahrEditor(JSpinner spinner) { super(spinner); if (!(spinner.getModel() instanceof HalbjahrModel)) { throw new IllegalArgumentException("model not a HalbjahrModel"); } AbstractFormatter formatter = new HalbjahrFormatter(); JFormattedTextField ftf = getTextField(); ftf.setEditable(true); ftf.setFormatterFactory(new DefaultFormatterFactory(formatter)); ftf.setColumns(6); }
private void initEditorField() { JFormattedTextField text = ((JSpinner.DefaultEditor)super.getEditor()).getTextField(); text.setEditable(false); text.setFormatterFactory(new JFormattedTextField.AbstractFormatterFactory() { @Override public AbstractFormatter getFormatter(JFormattedTextField tf) { return new ScaleFormatter(); } }); text.setColumns(5); }
FontFormatter(AbstractFormatter deleg) { setOverwriteMode(false); this.deleg = deleg; }
/** * Creates a {@link JFormattedTextField} for the specified cell. If a formatter is given, will * apply it to the field. Does not validate the model, so make sure this call works! * * @param model * @param rowIndex * @param columnIndex * @param cellClass * @param formatter * the formatter or <code>null</code> if none is required * @param hideUnavailableContentAssist * @return */ public CellTypeTextFieldDefaultImpl(final TablePanelModel model, final int rowIndex, final int columnIndex, final Class<? extends CellType> cellClass, AbstractFormatter formatter, boolean hideUnavailableContentAssist) { super(); final JFormattedTextField field = CellTypeImplHelper.createFormattedTextField(model, rowIndex, columnIndex); setLayout(new BorderLayout()); add(field, BorderLayout.CENTER); // otherwise 'null' would be restored Object value = model.getValueAt(rowIndex, columnIndex); String text = value != null ? String.valueOf(value) : ""; // specical handling when formatter is given if (formatter != null) { field.setFormatterFactory(new DefaultFormatterFactory(formatter)); } field.setText(text); // set syntax assist if available String syntaxHelp = model.getSyntaxHelpAt(rowIndex, columnIndex); if (syntaxHelp != null && !"".equals(syntaxHelp.trim())) { PromptSupport.setForeground(Color.LIGHT_GRAY, field); PromptSupport.setPrompt(syntaxHelp, field); PromptSupport.setFontStyle(Font.ITALIC, field); PromptSupport.setFocusBehavior(FocusBehavior.SHOW_PROMPT, field); } // see if content assist is possible for this field, if so add it ImageIcon icon = SwingTools.createIcon("16/" + I18N.getMessageOrNull(I18N.getGUIBundle(), "gui.action.content_assist.icon")); JButton contentAssistButton = new JButton(); contentAssistButton.setIcon(icon); if (field.isEnabled() && model.isContentAssistPossibleForCell(rowIndex, columnIndex)) { contentAssistButton.setToolTipText(I18N.getMessageOrNull(I18N.getGUIBundle(), "gui.action.content_assist_enabled.tip")); CellTypeImplHelper.addContentAssist(model, rowIndex, columnIndex, field, contentAssistButton, cellClass); } else { contentAssistButton.setToolTipText(I18N.getMessageOrNull(I18N.getGUIBundle(), "gui.action.content_assist_disabled.tip")); contentAssistButton.setEnabled(false); } if (contentAssistButton.isEnabled() || (!contentAssistButton.isEnabled() && !hideUnavailableContentAssist)) { add(contentAssistButton, BorderLayout.EAST); } // set size so panels don't grow larger when they get the chance setPreferredSize(new Dimension(300, 20)); setMinimumSize(new Dimension(100, 15)); setMaximumSize(new Dimension(1600, 30)); }
/** * Gets the formatter to use if the value of the JFormattedTextField is null. * @return the formatter to use for null values. */ public AbstractFormatter getNullFormatter() { return nullFormatter; }
public DefaultEditor(AbstractFormatter formatter) { super(formatter); }
private void configureComponents() { dateEchoField.setEditable(false); AbstractFormatter formatter = new DateFormatter(DateFormat.getDateTimeInstance()); AbstractFormatterFactory tf = new DefaultFormatterFactory(formatter); dateEchoField.setFormatterFactory(tf); }
/** * Creates a new <code>DateEditField</code> instance. * */ public DateEditField(JFormattedTextField.AbstractFormatter format) { super(format); this.addFocusListener(this); }
/** * Creates a new DefaultFormatterFactory with the specified formatters. * @param defaultFormat the formatter to use if no other appropriate non-null * formatted can be found. * @param displayFormat the formatter to use if the JFormattedTextField * doesn't have focus and either the value is not null or the value is null * but no <code>nullFormatter</code> has been specified. */ public DefaultFormatterFactory(AbstractFormatter defaultFormat, AbstractFormatter displayFormat) { defaultFormatter = defaultFormat; displayFormatter = displayFormat; }
/** * Creates a new DefaultFormatterFactory with the specified formatters. * @param defaultFormat the formatter to use if no other appropriate non-null * formatted can be found. * @param displayFormat the formatter to use if the JFormattedTextField * doesn't have focus and either the value is not null or the value is null * but no <code>nullFormatter</code> has been specified. * @param editFormat the formatter to use if the JFormattedTextField has * focus and either the value is not null or the value is null but not * <code>nullFormatter</code> has been specified. */ public DefaultFormatterFactory(AbstractFormatter defaultFormat, AbstractFormatter displayFormat, AbstractFormatter editFormat) { defaultFormatter = defaultFormat; displayFormatter = displayFormat; editFormatter = editFormat; }
/** * Creates a new DefaultFormatterFactory with the specified formatters. * @param defaultFormat the formatter to use if no other appropriate non-null * formatted can be found. * @param displayFormat the formatter to use if the JFormattedTextField * doesn't have focus and either the value is not null or the value is null * but no <code>nullFormatter</code> has been specified. * @param editFormat the formatter to use if the JFormattedTextField has * focus and either the value is not null or the value is null but not * <code>nullFormatter</code> has been specified. * @param nullFormat the formatter to use when the value of the * JFormattedTextField is null. */ public DefaultFormatterFactory(AbstractFormatter defaultFormat, AbstractFormatter displayFormat, AbstractFormatter editFormat, AbstractFormatter nullFormat) { defaultFormatter = defaultFormat; displayFormatter = displayFormat; editFormatter = editFormat; nullFormatter = nullFormat; }