An important part of any kind of GUI is input validation. If you are living in the Java world, you probably know about Bean Validation and its reference implementation Hibernate Validation. Using Bean Validation you sprinkle your code with annotations in order to declare the maximum size attributes, if they may be Null and many more. It looks like this:

    @NotNull
@Size(min = 2, max = 14)
private String licensePlate;

That's not bad. It's declarative and you can use the same annotation for your presentation model and your persistence model. If you use Hibernate for persistence it creates the right kind of constraint for the database as well. But there are a couple of shortcomings.

The last point is obviously my own problem, but it also provides a starting point for a solution for the other shortcomings.

For those too lazy to read the referenced article, let me reintroduce the Property class. You define a Property like this:

val age = new Property(20)

This line of code is pretty much equivalent to this java code (with pcs being an instance of PropertyChangeSupport):

int age = 20;

public void setAge(int theAge){
int oldAge = age
age = theAge;
pcs.firePropertyChange("age", oldAge, age)
}

public int getAge(){
return age;
}

You can set its value (with p being an instance of what ever class contains the code above):

p := 63

You can retrieve its value:

val ageOfP = p()

And you can register a listener on it

p.age.registerListener(println(_))

Back to validation. For age I only want to allow values between 9 and 99. How would you like to check if a given age is valid? Well, I would like to ask the property!

if (p.age.valid()) doSomething()
else doSomethingElse()

If I want to know what is wrong with the age value, I'd like to ask the property for a list of validation messages like this:

val problems = p.age.validationMessages()

All you have to do for this, is to add a trait to the age Property

val age = new Property(20) with Size { min = 9; max = 99 }

You can properly abstract over constraints as well by defining you own Property classes:

    class Name(value : String) extends Property(value) with Length { min = 3; max = 20 }
val firstname = new Name("")
val lastname = new Name("")

And it is easy to define your own Validations. Have look at the implementation of Length

trait Length extends Validation[String] {
self : Property[String] =>
var min : Int = -1
var max : Int = Int.MaxValue
override def validate : List[String] = minimumValidation ::: maximumValidation ::: super.validate
def minimumValidation = if (value != null && value.length < min) List("Should have minimum length " + min) else List()
def maximumValidation = if (value != null && value.length > max) List("Should have maximum length " + max) else List()
}

There are a couple of simple rules for implementing a Validation:

validationMessages and valid aren't methods but are Properties themselves. Therefor you can register listeners with them and bind your swing GUI to it. For example the following code snippet binds the validationMessages and valid to the tooltip and the visibility of label, resulting in a validation marker for a Property

def bindValidation(validation : Validation[_], component : JComponent) {

component.setVisible(!validation.valid)
validation.valid.registerListener(valid => component.setVisible(!valid))

def setToolTip(messages : List[String]) {
component.setToolTipText(
{
messages match {
case x :: xs =>
"" + (x :: xs).mkString("
") + ""
case _ => null
}
})
}

setToolTip(validation.validationMessages())
validation.validationMessages.registerListener(setToolTip)
}

If you are interested in more source code: Everything is up at github under the working title "moreThanProperties". You can also find other related articles by looking for the tag moreThanProperties.