Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.dynform.services.dynform;

import com.jeta.forms.components.panel.FormPanel;

import java.awt.Component;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.swing.JComponent;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynform.DynFormDefinition;

import org.gvsig.tools.dynform.DynFormFieldDefinition;

import org.gvsig.tools.dynform.JDynFormField;

import org.gvsig.tools.dynform.JDynFormField.JDynFormFieldListener;

import org.gvsig.tools.dynform.spi.AbstractJDynForm;

import org.gvsig.tools.dynform.spi.DynFormSPIManager;

import org.gvsig.tools.dynform.spi.dynformfield.AbstractJDynFormField;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.Manager;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.ServiceManager;

public class AbeilleJDynForm extends AbstractJDynForm implements Service, JDynFormFieldListener {

    private Map components = null;

    private FormPanel form = null;

    private String formPathname = null;

    private final DynFormSPIManager spimanager;

    public AbeilleJDynForm(ServiceManager manager, DynFormDefinition definition) throws ServiceException {

        super(((DynFormSPIManager)manager).getDynFormManager(),definition);

        this.spimanager = (DynFormSPIManager) manager;

        this.components = new HashMap();

        formPathname = (String) definition.getTags().get(DynFormSPIManager.TAG_DYNFORM_ABEILLE_FORM);

        if( formPathname == null ) {

            throw new IllegalArgumentException("Need tag 'dynform.abeille.form'.");

        }

        this.form = null;

    }

    @Override

    public Manager getManager() {

        return this.spimanager;

    }

    @Override

    protected JComponent getFieldsContainer() {

        this.form = new FormPanel(formPathname);

        List fields = this.getDefinition().getDefinitions();

        Iterator it = fields.iterator();

        while (it.hasNext()) {

            DynFormFieldDefinition fieldDefinition = (DynFormFieldDefinition) it.next();

            if (fieldDefinition.isHidden()) {

                continue;

            }

            Component component = this.form.getComponentByName("txt"+fieldDefinition.getName());

            if( component != null && component instanceof JTextComponent ) {

                JDynFormField jfield = new AbeilleTextJDynFormField(fieldDefinition, (JTextComponent)component);

                ((AbstractJDynFormField) jfield).setForm(this);

                jfield.setReadOnly(this.isReadOnly());

                jfield.addListener(this);

                if (this.isReadOnly()) {

                    jfield.setReadOnly(this.isReadOnly());

                }

                this.components.put(jfield.getName(), jfield);

            }

        }

        return this.form;

    }

    @Override

    public void setValues(DynObject values) {

        if (!this.isContentsInitialized()) {

            this.values = values;

            return;

        }

        DynClass def = values.getDynClass();

        DynField[] fields = def.getDynFields();

        for (int i = 0; i < fields.length; i++) {

            String name = fields[i].getName();

            if ( StringUtils.isEmpty(name) ) {

                logger.warn("Field name " + i + " of '" + def.getFullName() + "' is null or empty ");

                continue;

            }

            JDynFormField jfield = (JDynFormField) this.getField(name);

            if (jfield == null) {

                logger.info("Can't retrieve form field asociated to the field '" + name + "' of class '" + def.getFullName() + "'.");

                continue;

            }

            if (values.getDynValue(name) == null) {

                if (fields[i].getDataType().getType() == DataTypes.LIST) {

                    try {

                        if (((DynField_v2) fields[i]).getDynClassOfItems() != null) {

                            values.setDynValue(name, new ArrayList<DynObject>());

                        }

                    } catch (Exception e) {

                        logger.warn("Problems initializing the DynObject List", e);

                    }

                }

            }

            jfield.setValue(values.getDynValue(name));

        }

    }

    @Override

    public JDynFormField getField(String fieldName) {

        JDynFormField field = (JDynFormField) this.components.get(fieldName);

        return field;

    }

    @Override

    public void getValues(DynObject values) {

        if (values == null) {

            return;

        }

        DynField[] fields = values.getDynClass().getDynFields();

        for (DynField field : fields) {

            String name = field.getName();

            JDynFormField jfield = (JDynFormField) this.getField(name);

            if (jfield != null) {

                try {

                    jfield.fetch(values);

                } catch (Exception ex) {

                    logger.warn("Can't get value of field '" + name + "'.", ex);

                }

            }

        }

    }

    @Override

    public Object getValue(String fieldName) {

        JDynFormField field = (JDynFormField) this.getField(fieldName);

        return field.getValue();

    }

    @Override

    public void setValue(String fieldName, Object value) {

        JDynFormField field = (JDynFormField) this.getField(fieldName);

        try {

            value = field.getDefinition().getDataType().coerce(value);

        } catch (CoercionException e) {

            String msg = "Invalid value '" + ((value == null) ? "(null)" : value.toString()) + "' for field '" + fieldName + "'.";

            logger.warn(msg, e);

            throw new RuntimeException(msg, e);

        }

        field.setValue(value);

    }

    public Iterator getFieldsIterator() {

        if (!this.isContentsInitialized()) {

            this.initComponents();

        }

        return this.components.values().iterator();

    }

    @Override

    public boolean hasValidValues() {

        Iterator it = this.getFieldsIterator();

        while (it.hasNext()) {

            JDynFormField jfield = (JDynFormField) it.next();

            if (!jfield.hasValidValue()) {

                return false;

            }

        }

        return true;    }

    @Override

    public boolean hasValidValues(List<String> fieldsName) {

        if (fieldsName == null) {

            fieldsName = new ArrayList<>();

        }

        Iterator it = this.getFieldsIterator();

        while (it.hasNext()) {

            JDynFormField jfield = (JDynFormField) it.next();

            if (!jfield.hasValidValue()) {

                fieldsName.add(jfield.getName());

            }

        }

        return fieldsName.isEmpty();

    }

    @Override

    public boolean isModified() {

        Iterator it = this.getFieldsIterator();

        while (it.hasNext()) {

            JDynFormField jfield = (JDynFormField) it.next();

            if (jfield.isModified()) {

                return true;

            }

        }

        return false;

    }

    @Override

    public void clear() {

        Iterator it = this.components.entrySet().iterator();

        while (it.hasNext()) {

            Map.Entry entry = (Map.Entry) it.next();

            ((JDynFormField) (entry.getValue())).clear();

        }

    }

    @Override

    public void fieldEnter(JDynFormField field) {

        message(field.getDefinition().getDescription());

    }

    @Override

    public void fieldExit(JDynFormField field) {

        message();

    }

    @Override

    public void fieldChanged(JDynFormField field) {

        fireFieldChangeEvent(field);

    }

    @Override

    public void message(JDynFormField field, String message) {

        message(message);

    }

    private class AbeilleTextJDynFormField extends AbstractJDynFormField {

        private final JTextComponent text;

        private final DynFormFieldDefinition fieldDefinition;

        private AbeilleTextJDynFormField(DynFormFieldDefinition fieldDefinition, JTextComponent text) {

            super(null, AbeilleJDynForm.this.getServiceManager());

            this.text = text;

            this.fieldDefinition = fieldDefinition;

        }

        @Override

        public Object getParameterValue() {

                return null;

        }

        @Override

        public DynFormFieldDefinition getDefinition() {

                return this.fieldDefinition;

        }        

        @Override

        public void initComponent() {

            // Do nothing

        }

        @Override

        public Object getAssignedValue() {

            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

        }

        @Override

        public boolean hasValidValue() {

            try {

                String s = this.text.getText();

                Object v = this.fieldDefinition.getDataType().coerce(s);

                return true;

            } catch (CoercionException ex) {

                return false;

            }

        }

        @Override

        public void setValue(Object value) {

            if( value == null ) {

                this.text.setText("");

            } else {

                this.text.setText(value.toString());

            }

        }

        @Override

        public Object getValue() {

            try {

                String s = this.text.getText();

                return this.fieldDefinition.getDataType().coerce(s);

            } catch (CoercionException ex) {

                return null;

            }

        }

    }

}