(10);
private ComponentDecorator decorator = new ComponentDecorator();
ValidationGroupImpl parent;
ValidationGroupImpl(ValidationUI... ui) {
if (ui == null) {
throw new NullPointerException ("UI null");
}
this.ui = new MulticastValidationUI();
for (ValidationUI uis : ui) {
this.ui.add(uis);
}
}
ValidationGroupImpl() {
this (new ValidationUI[0]);
}
ValidationUI getUI() {
return ui;
}
boolean isSuspended() {
return suspendCount > 0 || parent != null && parent.isSuspended();
}
void addUI (ValidationUI real) {
if (!contains(real)) {
ui.add(real);
}
}
void removeUI (ValidationUI ui) {
if (contains(ui)) {
this.ui.remove(ui);
}
}
boolean contains(ValidationUI ui) {
return this.ui == ui || this.ui.contains(ui);
}
void setParent (ValidationGroupImpl group) {
if (parent != null && group != null) {
// parent.setParent (group);
throw new IllegalStateException ("Already has parent " + parent);
} else {
this.parent = group;
}
}
ComponentDecorator getComponentDecorator() {
return decorator;
}
public void setComponentDecorator (ComponentDecorator decorator) {
assert EventQueue.isDispatchThread() : "Not on event thread"; //NOI18N
if (decorator == null) {
throw new NullPointerException("Null decorator"); //NOI18N
}
this.decorator = decorator;
}
/**
* Disable validation and invoke a runnable. This method is useful
* in UIs where a change in one component can trigger changes in
* another component, and you do not want validation to be triggered
* because a component was programmatically updated.
*
* For example, say you have a dialog that lets you create a new
* Servlet source file. As the user types the servlet name, web.xml
* entries are updated to match, and these are also in fields in the same
* dialog. Since the updated web.xml entries are being programmatically
* (and presumably correctly) generated, those changes should not
* trigger a useless validation run. Wrap such generation code in
* a Runnable and pass it to this method when making programmatic
* changes to the contents of the UI.
*
* The runnable is run synchronously, but no changes made to components
* while the runnable is running will trigger validation.
*
* When the last runnable exits,
* validateAll(null) will be called to run validation
* against the entire newly updated UI.
*
* This method is reentrant - a call to updateComponents can trigger
* another call to updateComponents without triggering multiple
* calls to validateAll() on each Runnable's exit.
*
* @param run A runnable which makes changes to the contents of one
* or more components in the UI which should not trigger validation
*/
public final void modifyComponents(Runnable run) {
if (parent != null) {
parent.modifyComponents(run);
} else {
suspendCount++;
try {
run.run();
} finally {
suspendCount--;
if (!isSuspended()) {
validateAll(null);
}
}
}
}
/**
* Create a new ValidationGroup.
* @param ui The user interface
* @return A new ValidationGroup
*/
static ValidationGroupImpl create (ValidationUI[] ui) {
if (ui == null) {
throw new NullPointerException();
}
return new ValidationGroupImpl (ui);
}
/**
* Add a text component to be validated with ValidationStrategy.DEFAULT
* using the passed validator
* @param comp A text component such as a JTextField
* @param validator A validator
*/
public final void add (JTextComponent comp, Validator validator) {
add (comp, ValidationStrategy.DEFAULT, validator);
}
/**
* Add a text component to be validated with ValidationStrategy.DEFAULT
* using the passed validators
* @param comp A text component such as a JTextField
* @param builtIns One or more of the enums from the Validators
* class which provide standard validation of many things
*/
public final void add (JTextComponent comp, Validator... builtIns) {
add (comp, ValidationStrategy.DEFAULT, builtIns);
}
/**
* Add a combo box to be validated with ValidationStrategy.DEFAULT
* using the passed validator
* @param box A text component such as a JTextField
* @param validator A validator
*/
public final void add (JComboBox box, Validator validator) {
add (box, ValidationStrategy.DEFAULT, validator);
}
/**
* Add a combo box to be validated with ValidationStrategy.DEFAULT
* using the passed validators
* @param box A combo box component
* @param builtIns One or more of the enums from the Validators
* class which provide standard validation of many things
*/
public final void add (JComboBox box, Validator... builtIns) {
add (box, ValidationStrategy.DEFAULT, builtIns);
}
/**
* Add a text control to be validated with the passed validation strategy
* using the passed validators
* @param comp A text control such as a JTextField
* @param builtIns One or more of the enums from the Validators
* class which provide standard validation of many things
*/
public final void add(JTextComponent comp, ValidationStrategy strategy, Validator... builtIns) {
Validator v = Validators.forDocument(true, builtIns);
add(comp, strategy, v);
}
/**
* Add a combo box to be validated with the passed validation strategy
* using the passed validators
* @param box A combo box component
* @param builtIns One or more of the enums from the Validators
* class which provide standard validation of many things
*/
public final void add(JComboBox box, ValidationStrategy strategy, Validator... builtIns) {
Validator v = Validators.forComboBox(true, builtIns);
add(box, strategy, v);
}
/**
* Add a validator of button models - typically to see if any are selected.
* @see org.netbeans.validation.api.builtin.Validators
* @param buttons The buttons
* @param validator A validator
*/
public final void add (AbstractButton[] buttons, Validator validator) {
ButtonModel[] mdls = new ButtonModel[buttons.length];
for (int i = 0; i < mdls.length; i++) {
mdls[i] = buttons[i].getModel();
}
add (mdls, validator);
}
public void add(ValidationListener listener) {
if (parent != null) {
parent.add(listener);
} else {
listener.setValidationGroup(this);
}
all.add(listener);
}
public void add(final ButtonModel[] buttons, final Validator validator) {
assert EventQueue.isDispatchThread() : "Must be called on event thread";
class V extends ValidationListener implements ItemListener {
public void itemStateChanged(ItemEvent e) {
validate();
}
public boolean validate(Problems problems) {
if (!enabled(buttons)) {
return true;
}
return validator.validate(problems, null, buttons);
}
private boolean enabled (ButtonModel[] b) {
boolean result = true;
for (ButtonModel m : b) {
result = m.isEnabled();
if (!result) {
break;
}
}
return result;
}
}
V v = new V();
add(v);
}
public void add(final JComboBox box, ValidationStrategy strategy, final Validator validator) {
assert EventQueue.isDispatchThread() : "Must be called on event thread";
final Border originalBorder = box.getBorder();
class V extends ValidationListener implements ItemListener, FocusListener {
public void focusLost(FocusEvent e) {
validate();
}
public void itemStateChanged(ItemEvent e) {
validate();
}
public void focusGained(FocusEvent e) {
}
public boolean validate(Problems problems) {
if (!box.isEnabled()) {
return true;
}
boolean result = validator.validate(problems,
nameForComponent(box), box.getModel());
if (originalBorder != null) {
if (result) {
//Test to avoid unncessary re-layout
if (box.getBorder() != originalBorder) {
box.setBorder(originalBorder);
}
} else {
Problem p = problems.getLeadProblem();
box.setBorder(decorator.createProblemBorder(box,
originalBorder, p.severity()));
}
}
return result;
}
}
final V v = new V();
add(v);
switch (strategy) {
case DEFAULT:
case ON_CHANGE_OR_ACTION:
box.addItemListener(v);
break;
case ON_FOCUS_LOSS:
box.addFocusListener(v);
break;
case INPUT_VERIFIER:
box.setInputVerifier(v);
break;
default:
throw new AssertionError();
}
}
public void add(final JTextComponent field, ValidationStrategy strategy, final Validator validator) {
assert EventQueue.isDispatchThread() : "Must be called on event thread";
final Border originalBorder = field.getBorder();
class V extends ValidationListener implements DocumentListener, FocusListener, Runnable {
public void focusLost(FocusEvent e) {
validate();
}
public void focusGained(FocusEvent e) {
}
public void insertUpdate(DocumentEvent e) {
removeUpdate(e);
}
public void removeUpdate(DocumentEvent e) {
//Documents can be legally updated from another thread,
//but we will not run validation outside the EDT
if (!EventQueue.isDispatchThread()) {
EventQueue.invokeLater(this);
} else {
validate();
}
}
public void changedUpdate(DocumentEvent e) {
removeUpdate(e);
}
public void run() {
validate();
}
public boolean validate(Problems problems) {
if (!field.isEnabled()) {
return true;
}
boolean result = validator.validate(problems,
nameForComponent(field), field.getDocument());
if (originalBorder != null) {
if (result) {
//Test to avoid unncessary re-layout
if (field.getBorder() != originalBorder) {
field.setBorder(originalBorder);
}
} else {
assert field != null : "Field null"; //NOi18N
assert decorator != null : "Decorator null"; //NOI18N
Problem p = problems.getLeadProblem();
assert p != null : "A validator has returned false from" + //NOI18N
" validate(), but no validator has added any" + //NOI18N
"problems to the problem set."; //NOI18N
Border border = decorator.createProblemBorder(field,
originalBorder, p.severity());
field.setBorder(border);
}
}
return result;
}
}
final V v = new V();
add(v);
switch (strategy) {
case DEFAULT:
case ON_CHANGE_OR_ACTION:
field.getDocument().addDocumentListener(v);
break;
case INPUT_VERIFIER:
field.setInputVerifier(v);
break;
case ON_FOCUS_LOSS:
field.addFocusListener(v);
break;
}
}
public Problem validateAll(ValidationListener trigger) {
assert EventQueue.isDispatchThread() : "Must be called on event thread";
if (parent != null) {
return parent.validateAll(trigger);
} else {
if (isSuspended()) {
return null;
}
Problems p = new Problems();
for (ValidationListener a : all) {
if (a == trigger) {
continue;
}
a.validate(p);
if (p.hasFatal()) {
break;
}
}
if (!p.isEmpty()) {
Problem problem = p.getLeadProblem();
return problem;
}
return null;
}
}
public void addValidationGroup(ValidationGroupImpl group, boolean useUI) {
assert EventQueue.isDispatchThread() : "Not in event thread"; //NOI18N
assert noOverlap (all, group.all);
if (group.parent != null) {
throw new IllegalStateException ("Cannot add to a group that has " + //NOI18N
"already been added to another group"); //NOI18N
}
all.addAll (group.all);
for (ValidationListener l : all) {
l.setValidationGroup(this);
}
if (useUI) {
addUI(new GroupSpecificValidationUI(group, group.ui));
} else {
//Clear any existing problem - validateAll() will recreate
//it if need-be
group.ui.clearProblem();
}
group.setParent(this);
validateAll(null);
}
public void removeValidationGroup (ValidationGroupImpl group) {
assert EventQueue.isDispatchThread() : "Not in event thread"; //NOI18N
if (group == this) {
throw new IllegalArgumentException ("Removing from self"); //NOI18N
}
all.removeAll(group.all);
for (ValidationListener l : group.all) {
l.setValidationGroup(group);
}
ui.removeUI(group);
group.setParent(null);
validateAll (null);
}
private boolean noOverlap(List all, List all0) {
HashSet s = new HashSet();
s.addAll (all);
s.addAll (all0);
return s.size() == all.size() + all0.size();
}
}