/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.cocoon.woody.formmodel;
import org.apache.cocoon.woody.Constants;
import org.apache.cocoon.woody.FormContext;
import org.apache.cocoon.woody.util.I18nMessage;
import org.apache.cocoon.woody.validation.ValidationError;
import org.apache.cocoon.woody.validation.ValidationErrorAware;
import org.apache.cocoon.woody.datatype.SelectionList;
import org.apache.cocoon.woody.datatype.Datatype;
import org.apache.cocoon.woody.event.DeferredValueChangedEvent;
import org.apache.cocoon.woody.event.WidgetEvent;
import org.apache.cocoon.woody.event.ValueChangedEvent;
import org.apache.cocoon.xml.AttributesImpl;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import java.util.Locale;
/**
* A general-purpose Widget that can hold one value. A Field widget can be associated
* with a {@link org.apache.cocoon.woody.datatype.Datatype Datatype}, and thus
* a Field widget can be used to edit different kinds of data, such as strings,
* numbers and dates. A Datatype can also have an associated SelectionList, so
* that the value for the Field can be selected from a list, rather than being
* entered in a textbox. The validation of the field is delegated to its associated
* Datatype.
*
* @author Bruno Dumon
* @author <a href="http://www.apache.org/~sylvain/">Sylvain Wallez</a>
* @version CVS $Id$
*/
public class Field extends AbstractWidget implements ValidationErrorAware, DataWidget, SelectableWidget {
protected SelectionList selectionList;
protected String enteredValue;
protected Object value;
// At startup, we don't need to parse (both enteredValue and value are null),
// but need to validate (error if field is required)
protected boolean needsParse = true;
protected boolean needsValidate = true;
private boolean isValidating;
protected ValidationError validationError;
public Field(FieldDefinition fieldDefinition) {
setDefinition(fieldDefinition);
setLocation(fieldDefinition.getLocation());
}
public final FieldDefinition getFieldDefinition() {
return (FieldDefinition)super.definition;
}
public String getId() {
return definition.getId();
}
public Object getValue() {
// Parse the value
if (this.needsParse) {
// Clear value, it will be recomputed
this.value = null;
if (this.enteredValue != null) {
// Parse the value
this.value = getDatatype().convertFromString(this.enteredValue, getForm().getLocale());
if (this.value != null) { // Conversion successfull
this.needsParse = false;
this.needsValidate = true;
} else { // Conversion failed
this.validationError = new ValidationError(new I18nMessage(
"datatype.conversion-failed",
new String[] {"datatype." + getDatatype().getDescriptiveName()},
new boolean[] { true },
Constants.I18N_CATALOGUE
));
// No need for further validation (and need to keep the above error)
this.needsValidate = false;
}
} else {
this.needsParse = false;
this.needsValidate = true;
}
}
// if getValue() is called on this field while we're validating, then it's because a validation
// rule called getValue(), so then we just return the parsed (but not validated) value to avoid an endless loop
if (isValidating) {
return value;
}
// Validate the value
if (this.needsValidate) {
isValidating = true;
try {
if (super.validate(null)) {
// New-style validators were successful. Check the old-style ones.
if (this.value != null) {
this.validationError = getDatatype().validate(value, new ExpressionContextImpl(this));
} else { // No value : is it required ?
if (getFieldDefinition().isRequired()) {
this.validationError = new ValidationError(new I18nMessage("general.field-required", Constants.I18N_CATALOGUE));
}
}
}
this.needsValidate = false;
} finally {
isValidating = false;
}
}
return this.validationError == null ? this.value : null;
}
public void setValue(Object newValue) {
if (newValue != null && !getDatatype().getTypeClass().isAssignableFrom(newValue.getClass())) {
throw new RuntimeException("Incorrect value type for \"" + getFullyQualifiedId() +
"\" (expected " + getDatatype().getTypeClass() +
", got " + newValue.getClass() + ".");
}
Object oldValue = this.value;
boolean changed = ! (oldValue == null ? "" : oldValue).equals(newValue == null ? "" : newValue);
// Do something only if value is different or null
// (null allows to reset validation error)
if (changed || newValue == null) {
this.value = newValue;
this.needsParse = false;
this.validationError = null;
// Force validation, even if set by the application
this.needsValidate = true;
if (newValue != null) {
this.enteredValue = getDatatype().convertToString(newValue, getForm().getLocale());
} else {
this.enteredValue = null;
}
if (changed) {
getForm().addWidgetEvent(new ValueChangedEvent(this, oldValue, newValue));
}
}
}
public void readFromRequest(FormContext formContext) {
String newEnteredValue = formContext.getRequest().getParameter(getFullyQualifiedId());
readFromRequest(newEnteredValue);
}
protected void readFromRequest(String newEnteredValue) {
// whitespace & empty field handling
if (newEnteredValue != null) {
// TODO make whitespace behaviour configurable !!
newEnteredValue = newEnteredValue.trim();
if (newEnteredValue.length() == 0) {
newEnteredValue = null;
}
}
// Only convert if the text value actually changed. Otherwise, keep the old value
// and/or the old validation error (allows to keep errors when clicking on actions)
if (!(newEnteredValue == null ? "" : newEnteredValue).equals((enteredValue == null ? "" : enteredValue))) {
getForm().addWidgetEvent(new DeferredValueChangedEvent(this, value));
enteredValue = newEnteredValue;
validationError = null;
value = null;
needsParse = true;
}
// Always revalidate, as validation may depend on the value of other fields
this.needsValidate = true;
}
public boolean validate(FormContext formContext) {
// If needed, getValue() will do the validation
getValue();
return this.validationError == null;
}
/**
* Returns the validation error, if any. There will always be a validation error in case the
* {@link #validate(FormContext)} method returned false.
*/
public ValidationError getValidationError() {
return validationError;
}
/**
* Set a validation error on this field. This allows fields to be externally marked as invalid by
* application logic.
*
* @param error the validation error
*/
public void setValidationError(ValidationError error) {
this.validationError = error;
}
public boolean isRequired() {
return getFieldDefinition().isRequired();
}
private static final String FIELD_EL = "field";
private static final String VALUE_EL = "value";
private static final String VALIDATION_MSG_EL = "validation-message";
public void generateSaxFragment(ContentHandler contentHandler, Locale locale) throws SAXException {
AttributesImpl fieldAttrs = new AttributesImpl();
fieldAttrs.addCDATAAttribute("id", getFullyQualifiedId());
fieldAttrs.addCDATAAttribute("required", String.valueOf(isRequired()));
contentHandler.startElement(Constants.WI_NS, FIELD_EL, Constants.WI_PREFIX_COLON + FIELD_EL, fieldAttrs);
if (enteredValue != null || value != null) {
contentHandler.startElement(Constants.WI_NS, VALUE_EL, Constants.WI_PREFIX_COLON + VALUE_EL, Constants.EMPTY_ATTRS);
String stringValue;
if (value != null) {
stringValue = getDatatype().convertToString(value, locale);
} else {
stringValue = enteredValue;
}
contentHandler.characters(stringValue.toCharArray(), 0, stringValue.length());
contentHandler.endElement(Constants.WI_NS, VALUE_EL, Constants.WI_PREFIX_COLON + VALUE_EL);
}
// validation message element: only present if the value is not valid
if (validationError != null) {
contentHandler.startElement(Constants.WI_NS, VALIDATION_MSG_EL, Constants.WI_PREFIX_COLON + VALIDATION_MSG_EL, Constants.EMPTY_ATTRS);
validationError.generateSaxFragment(contentHandler);
contentHandler.endElement(Constants.WI_NS, VALIDATION_MSG_EL, Constants.WI_PREFIX_COLON + VALIDATION_MSG_EL);
}
// generate label, help, hint, etc.
definition.generateDisplayData(contentHandler);
// generate selection list, if any
if (selectionList != null) {
selectionList.generateSaxFragment(contentHandler, locale);
} else if (getFieldDefinition().getSelectionList() != null) {
getFieldDefinition().getSelectionList().generateSaxFragment(contentHandler, locale);
}
contentHandler.endElement(Constants.WI_NS, FIELD_EL, Constants.WI_PREFIX_COLON + FIELD_EL);
}
public void generateLabel(ContentHandler contentHandler) throws SAXException {
definition.generateLabel(contentHandler);
}
/**
* Set this field's selection list.
* @param selectionList The new selection list.
*/
public void setSelectionList(SelectionList selectionList) {
if (selectionList != null &&
selectionList.getDatatype() != null &&
selectionList.getDatatype() != getDatatype()) {
throw new RuntimeException("Tried to assign a SelectionList that is not associated with this widget's datatype.");
}
this.selectionList = selectionList;
}
/**
* Read this field's selection list from an external source.
* All Cocoon-supported protocols can be used.
* The format of the XML produced by the source should be the
* same as in case of inline specification of the selection list,
* thus the root element should be a <code>wd:selection-list</code>
* element.
* @param uri The URI of the source.
*/
public void setSelectionList(String uri) {
setSelectionList(getFieldDefinition().buildSelectionList(uri));
}
/**
* Set this field's selection list using values from an in-memory
* object. The <code>object</code> parameter should point to a collection
* (Java collection or array, or Javascript array) of objects. Each object
* belonging to the collection should have a <em>value</em> property and a
* <em>label</em> property, whose values are used to specify the <code>value</code>
* attribute and the contents of the <code>wd:label</code> child element
* of every <code>wd:item</code> in the list.
* <p>Access to the values of the above mentioned properties is done
* via <a href="http://jakarta.apache.org/commons/jxpath/users-guide.html">XPath</a> expressions.
* @param model The collection used as a model for the selection list.
* @param valuePath An XPath expression referring to the attribute used
* to populate the values of the list's items.
* @param labelPath An XPath expression referring to the attribute used
* to populate the labels of the list's items.
*/
public void setSelectionList(Object model, String valuePath, String labelPath) {
setSelectionList(getFieldDefinition().buildSelectionListFromModel(model, valuePath, labelPath));
}
public Datatype getDatatype() {
return getFieldDefinition().getDatatype();
}
public void broadcastEvent(WidgetEvent event) {
getFieldDefinition().fireValueChangedEvent((ValueChangedEvent)event);
}
}