de.invation.code.toval.graphic.component.RestrictedTextField Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of TOVAL Show documentation

TOVAL comprises a set of java classes for common programming issues. It includes utils for arrays, lists, sets and collections for convenient handling and modification, but also support for mathematic definitions concerning logic (clauses + resolution) together with some algorithms for permutations, powersets and resolution. Additionally it contains a number of types for multisets, matrices with object keys and much more.

The newest version!

package de.invation.code.toval.graphic.component;

import java.awt.Dimension;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.HashSet;
import java.util.Set;

import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.text.Document;

import de.invation.code.toval.graphic.component.event.RestrictedTextFieldListener;
import de.invation.code.toval.validate.ParameterException;
import de.invation.code.toval.validate.Validate;

public class RestrictedTextField extends JTextField {

	private static final long serialVersionUID = 3020973663591477811L;
	
	private String oldValue = null;
	private Restriction restriction = null;
	private boolean validateOnTyping = false;
	
	private Set listeners = new HashSet();

	public RestrictedTextField(Restriction restriction, Document doc, String text, int columns) {
		super(doc, text, columns);
		initialize(restriction);
	}

	public RestrictedTextField(Restriction restriction, int columns) {
		super(columns);
		initialize(restriction);
	}

	public RestrictedTextField(Restriction restriction, String text, int columns) {
		super(text, columns);
		initialize(restriction);
	}

	public RestrictedTextField(Restriction restriction, String text) {
		super(text);
		initialize(restriction);
	}

	public RestrictedTextField(Restriction restriction){
		super();
		initialize(restriction);
	}
	
	public void addListener(RestrictedTextFieldListener listener){
		this.listeners.add(listener);
	}
	
	public void removeListener(RestrictedTextFieldListener listener){
		this.listeners.remove(listener);
	}
	
	private void initialize(Restriction restriction){
		this.restriction = restriction;
		this.addFocusListener(new FocusAdapter() {
			@Override
			public void focusGained(FocusEvent e) {
				super.focusGained(e);
				oldValue = getText();
			}

			public void focusLost(FocusEvent e) {
				super.focusLost(e);
				validateInput();
			}
		});
		
		this.addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(KeyEvent e) {
				super.keyTyped(e);
				if(e.getKeyCode() == KeyEvent.VK_ENTER){
					validateInput();
				}
			}
			
		});
		
		this.addKeyListener(new KeyAdapter() {
			@Override
			public void keyReleased(KeyEvent e) {
				if(validateOnTyping)
					validateInput();
			}
		});
	}
	
	private void validateInput() {
		try{
			switch (restriction) {
			case NEGATIVE_DOUBLE:
				Validate.negativeDouble(getText());
				break;
			case NEGATIVE_INTEGER:
				Validate.negativeInteger(getText());
				break;
			case POSITIVE_DOUBLE:
				Validate.positiveDouble(getText());
				break;
			case POSITIVE_INTEGER:
				Validate.positiveInteger(getText());
				break;
			case ZERO_OR_NEGATIVE_DOUBLE:
				Validate.notPositiveDouble(getText());
				break;
			case ZERO_OR_NEGATIVE_INTEGER:
				Validate.notPositiveInteger(getText());
				break;
			case ZERO_OR_POSITIVE_DOUBLE:
				Validate.notNegativeDouble(getText());
				break;
			case ZERO_OR_POSITIVE_INTEGER:
				Validate.notNegativeInteger(getText());
				break;
			case NOT_EMPTY:
				Validate.notEmpty(getText());
				break;
			case NONE:
				break;
			}
		}catch(ParameterException e){
			setText(oldValue);
		}
		notifyValueChanged(oldValue, getText());
	}
	
	private void notifyValueChanged(String oldValue, String newValue){
		if(oldValue.equals(newValue))
			return;
		for(RestrictedTextFieldListener listener: listeners){
			listener.valueChanged(oldValue, newValue);
		}
		this.oldValue = newValue;
	}
	
	public boolean validatesOnTyping() {
		return validateOnTyping;
	}

	public void setValidateOnTyping(boolean validateOnTyping) {
		this.validateOnTyping = validateOnTyping;
	}
	
	public enum Restriction {
		POSITIVE_INTEGER, NEGATIVE_INTEGER, POSITIVE_DOUBLE, NEGATIVE_DOUBLE,
		ZERO_OR_POSITIVE_INTEGER, ZERO_OR_NEGATIVE_INTEGER, ZERO_OR_POSITIVE_DOUBLE, ZERO_OR_NEGATIVE_DOUBLE,
		NOT_EMPTY, NONE;
	}
	
	public static void main(String[] args) {
		DummyPanel panel = new DummyPanel();
		RestrictedTextField t1 = new RestrictedTextField(Restriction.POSITIVE_INTEGER, "20");
		t1.setPreferredSize(new Dimension(200, 20));
		t1.addListener(panel);
		t1.setValidateOnTyping(true);
		RestrictedTextField t2 = new RestrictedTextField(Restriction.POSITIVE_DOUBLE, "20.5");
		panel.add(t1);
		panel.add(t2);
		new DisplayFrame(panel, true);
	}
	
	private static class DummyPanel extends JPanel implements RestrictedTextFieldListener {

		@Override
		public void valueChanged(String oldValue, String newValue) {
			System.out.println("old value: " + oldValue);
			System.out.println("new value: " + newValue);
			System.out.println();
		}
		
	}

}