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

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free Software

 * Foundation; either version 3 of the License, or (at your option) any later

 * version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.dynform.spi.dynformfield;

import java.awt.BorderLayout;

import java.awt.Color;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import javax.swing.Action;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JSpinner;

import javax.swing.JTextField;

import javax.swing.JViewport;

import javax.swing.text.JTextComponent;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynform.DynFormFieldDefinition;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynform.JDynFormField;

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

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

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.dynobject.Tags;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings({"rawtypes", "unchecked"})

public abstract class AbstractJDynFormField implements JDynFormField {

    protected static final Logger LOGGER = LoggerFactory

            .getLogger(AbstractJDynFormField.class);

    private final DynFormSPIManager manager;

    private final JDynFormFieldFactory factory;

    private final DynFormFieldDefinition definition;

    private final ComponentsFactory componentsFactory;

    private JDynForm form;

    protected JLabel jlabel = null;

    private JPanel jlabelpanel = null;

    private Set listeners = null;

    private JProblemIndicator problemIndicator = null;

    protected JComponent contents = null;

    protected boolean readOnly = false;

    private final List customActions;

    protected boolean emptyToNull = false;

    public AbstractJDynFormField(

            DynFormSPIManager serviceManager, 

            ComponentsFactory componentsFactory,

            JDynFormFieldFactory factory, 

            DynFormFieldDefinition definition,

            Object value

        ) {

        this.manager = serviceManager;

        this.factory = factory;

        this.definition = definition;

        this.componentsFactory = componentsFactory;

        this.listeners = new HashSet();

        this.problemIndicator = this.manager.createProblemIndicator(this);

        this.customActions = new ArrayList<>();

        if(this.definition != null){

                this.readOnly = this.definition.isReadOnly();

                this.loadDefaultValuesFromTags(definition.getTags());

        }

    }

    public ComponentsFactory getComponentsFactory() {

        return this.componentsFactory;

    }

    public void loadDefaultValuesFromTags(Tags tags) {

        try {

            this.readOnly = tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_READONLY);

        } catch (CoercionException ex) {

        }

        try {

            this.emptyToNull = tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_TRANSLATE_EMPTY_TO_NULL);

        } catch (CoercionException ex) {

        }

    }

    public abstract void initComponent();

    public abstract Object getAssignedValue();

//    public Object getParameterValue() {

//        return this.parameters.getDynValue(DynFormSPIManager.FIELD_VALUE);

//    }

//

    @Override

    public JComponent asJComponent() {

        if (this.contents == null) {

            try {

                this.initComponent();

            } catch(Throwable th) {

                this.contents = new JLabel("##ERROR##");

                this.problemIndicator().set("Can't create component");

            }

            if (!this.customActions.isEmpty()) {

                addPopupComponents();

            }

            if (this.readOnly) {

                this.setReadOnly(readOnly);

            }

        }

        return this.contents;

    }

    @Override

    public String getName() {

        return this.definition.getName();

    }

    @Override

    public String getLabel() {

        if (definition.getLabel() != null) {

            String label = definition.getLabel();

            label = ToolsLocator.getI18nManager().getTranslation(label);

            return label;

        } else {

            return this.getName();

        }

    }

    @Override

    public String getSeparatorTitleToUseBefore() {

        String separatorTitle = this.getTagValueAsString(

                DynFormSPIManager.TAG_DYNFORM_SEPARATOR, 

                null

        );

        return separatorTitle;

    }

    @Override

    public boolean useEmptyLabel() {

        boolean useEmpty = getTagValueAsBoolean(

                DynFormSPIManager.TAG_DYNFORM_LABEL_EMPTY, 

                false

        );

        return useEmpty;

    }

    @Override

    public JComponent getJLabel() {

        if (this.jlabel == null) {

            this.jlabel = this.getComponentsFactory().getJLabel(definition, null);

            if( this.jlabel==null ) {

                this.jlabel = new JLabel();

            }

            if (!this.useEmptyLabel() ) {

                this.jlabel.setText(this.getLabel());

            }

            this.jlabel.setLabelFor(this.contents);

            if (this.getDefinition().isMandatory()) {

                this.jlabel.setForeground(Color.red.darker());

            }

            this.jlabelpanel = new JPanel();

            this.jlabelpanel.setLayout(new BorderLayout());

            this.jlabelpanel.add(jlabel, BorderLayout.CENTER);

            this.jlabelpanel.add(problemIndicator.asJComponent(), BorderLayout.LINE_END);

        }

        return this.jlabelpanel;

    }

    @Override

    public DynFormFieldDefinition getDefinition() {

        return this.definition;

    }

    public DynFormSPIManager getServiceManager() {

        return this.manager;

    }

    @Override

    public void addListener(JDynFormFieldListener listener) {

        this.listeners.add(listener);

    }

    @Override

    public void removeListener(JDynFormFieldListener listener) {

        this.listeners.remove(listener);

    }

    protected void fireFieldChangedEvent() {

        if( this.isReadOnly() ) {

            return;

        }

        Iterator it = this.listeners.iterator();

        while (it.hasNext()) {

            JDynFormFieldListener listener = (JDynFormFieldListener) it.next();

            try {

                listener.fieldChanged(this);

            } catch (Exception ex) {

                LOGGER.info("Error calling listener " + listener.toString()

                        + "(" + listener.getClass().getName() + ") from "

                        + this.toString() + "(" + this.getClass().getName()

                        + ").", ex);

            }

        }

    }

    protected void fireFieldEnterEvent() {

        Iterator it = this.listeners.iterator();

        while (it.hasNext()) {

            JDynFormFieldListener listener = (JDynFormFieldListener) it.next();

            try {

                listener.fieldEnter(this);

            } catch (Exception ex) {

                LOGGER.info("Error calling listener " + listener.toString()

                        + "(" + listener.getClass().getName() + ") from "

                        + this.toString() + "(" + this.getClass().getName()

                        + ").", ex);

            }

        }

    }

    protected void fireFieldExitEvent() {

        Iterator it = this.listeners.iterator();

        while (it.hasNext()) {

            JDynFormFieldListener listener = (JDynFormFieldListener) it.next();

            try {

                listener.fieldExit(this);

            } catch (Exception ex) {

                LOGGER.info("Error calling listener " + listener.toString()

                        + "(" + listener.getClass().getName() + ") from "

                        + this.toString() + "(" + this.getClass().getName()

                        + ").", ex);

            }

        }

    }

    @Override

    public void fireMessageEvent(String message) {

        Iterator it = this.listeners.iterator();

        while (it.hasNext()) {

            JDynFormFieldListener listener = (JDynFormFieldListener) it.next();

            try {

                listener.message(this, message);

            } catch (Exception ex) {

                LOGGER.info("Error calling listener " + listener.toString()

                        + "(" + listener.getClass().getName() + ") from "

                        + this.toString() + "(" + this.getClass().getName()

                        + ").", ex);

            }

        }

    }

    @Override

    public boolean isReadOnly() {

        return this.readOnly;

    }

    protected boolean isForcedReadOnly() {

        return this.getTagValueAsBoolean(DynFormSPIManager.TAG_DYNFORM_READONLY, false);

    }

    @Override

    public void setReadOnly(boolean readonly) {

        // FIXME: Implememtacion por defecto, sobreescribirla en las subclases

        // segun convenga para cada componente.

        if( !readonly && this.isForcedReadOnly() ) {

            readonly = true;

        }

        this.readOnly = readonly;

        if (jlabel != null) {

            this.jlabel.setEnabled(!readonly);

        }

        if (this.contents != null) {

            if (this.contents instanceof JTextComponent) {

                JTextComponent x = (JTextComponent) this.contents;

                x.setEditable(!readonly);

            } else if (this.contents instanceof JComboBox ) {

                JComboBox x = (JComboBox) this.contents;

                x.setEnabled(!readonly);

            } else if (this.contents instanceof JScrollPane) {

                try {

                    JViewport port = ((JScrollPane) this.contents).getViewport();

                    JTextComponent x = (JTextComponent) port.getView();

                    x.setEditable(!readonly);

                } catch (Exception ex) {

                    this.contents.setEnabled(!readOnly);

                }

            } else {

                this.contents.setEnabled(!readOnly);

            }

        }

    }

    public JProblemIndicator problemIndicator() {

        return this.problemIndicator;

    }

    public class IllegalFieldValue extends RuntimeException {

        /**

         *

         */

        private static final long serialVersionUID = -4409236610055983438L;

        public IllegalFieldValue(JDynFormField field, String message) {

            super("The value of field '" + field.getLabel() + "' is not valid. " + message);

        }

    }

    @Override

    public String toString() {

        return super.toString() + "{" + this.getName() + "}";

    }

    @Override

    public boolean isModified() {

        boolean modified = false;

        try {

            if (!this.isReadOnly()) {

                Object value = this.getValue();

                if (value == null) {

                    if (value != this.getAssignedValue()) {

                        modified = true;

                    }

                } else {

                    if (!value.equals(this.getAssignedValue())) {

                        modified = true;

                    }

                }

            }

        } catch (IllegalFieldValue ex) {

            // Si es incorrecto el valor del campo decimos a capom que esta modificado.

            modified = true;

        }

        return modified;

    }

    private void addPopupComponents() {

        Iterator it = this.customActions.iterator();

        while (it.hasNext()) {

            Object obj = it.next();

            if (obj != null) {

                Action act = (Action) obj;

                if (contents instanceof SupportPopupMenu) {

                    DynFormFieldAction sact = new DynFormFieldAction(this, act);

                    ((SupportPopupMenu) this.contents).addActionToPopupMenu(

                            sact.getName(),

                            sact);

                }

            } else {

                if (contents instanceof SupportPopupMenu) {

                    ((SupportPopupMenu) this.contents).addSeparatorToPopupMenu();

                }

            }

        }

    }

    @Override

    public void addActionToPopupMenu(String name, Action action) {

        if (contents != null) {

            if (contents instanceof SupportPopupMenu) {

                DynFormFieldAction sact = new DynFormFieldAction(this, action);

                ((SupportPopupMenu) this.contents).addActionToPopupMenu(

                        sact.getName(),

                        sact);

            }

        } else {

            this.customActions.add(action);

        }

    }

    @Override

    public void addSeparatorToPopupMenu() {

        if (contents != null) {

            if (contents instanceof SupportPopupMenu) {

                ((SupportPopupMenu) this.contents).addSeparatorToPopupMenu();

            }

        } else {

            this.customActions.add(null);

        }

    }

    public void setTranslateEmptyToNull(boolean emptyToNull) {

        this.emptyToNull = emptyToNull;

    }

    public boolean translateEmptyToNull() {

        return this.emptyToNull;

    }

    @SuppressWarnings("UnnecessaryReturnStatement")

    @Override

    public void clear() {

        if (this.contents == null) {

            return;

        }

        if (this.contents instanceof JTextField) {

            Object value = this.getDefinition().getDefaultValue();

            if (value != null) {

                value = value.toString();

            } else {

                value = "";

            }

            ((JTextField) this.contents).setText((String) value);

            return;

        }

        if (this.contents instanceof JSpinner) {

            Object value = this.getDefinition().getDefaultValue();

            if (value==null) {

                ((JSpinner) this.contents).setValue(0);

                return;

            }

            ((JSpinner) this.contents).setValue(value);

            return;

        }

        if (this.contents instanceof JList) {

            ((JList) this.contents).setSelectedIndex(-1);

            return;

        }

        if (this.contents instanceof JComboBox) {

            ((JComboBox) this.contents).setSelectedIndex(-1);

            return;

        }

    }

    public void setForm(JDynForm form) {

        this.form = form;

    }

    @Override

    public JDynForm getForm() {

        return this.form;

    }

    @Override

    public void fetch(DynObject container) {

        if( this.isReadOnly() ) {

            return;

        }

        Object value = this.getValue();

        DynClass dynclass = container.getDynClass();

        if( dynclass!=null ) {

            DynField dynfield = dynclass.getDynField(this.getName());

            if( dynfield!=null && dynfield.isReadOnly() ) {

                return;

            }

        }

        container.setDynValue(this.getName(), value);

    }

    protected int getTagValueAsInt(String tagname, int defaultVaue) {

        return getTagValueAsInt(tagname, null, defaultVaue);

    }

    protected int getTagValueAsInt(String tagname1, String tagname2, int defaultVaue) {

        DynField_v2 fielddef = (DynField_v2) this.getDefinition();

        String tagname;

        if (fielddef.getTags().has(tagname1)) {

            tagname = tagname1;

        } else if (fielddef.getTags().has(tagname2)) {

            tagname = tagname2;

        } else {

            return defaultVaue;

        }

        try {

            int value = fielddef.getTags().getInt(tagname);

            return value;

        } catch (CoercionException ex) {

            LOGGER.warn("Can't parse tag '" + tagname + "' as int for field '" + fielddef.getName() + "'.", ex);

        }

        return defaultVaue;

    }

    protected boolean getTagValueAsBoolean(String tagname, boolean defaultVaue) {

        return getTagValueAsBoolean(tagname, null, defaultVaue);

    }

    protected boolean getTagValueAsBoolean(String tagname1, String tagname2, boolean defaultVaue) {

        DynField_v2 fielddef = (DynField_v2) this.getDefinition();

        String tagname;

        if (fielddef.getTags().has(tagname1)) {

            tagname = tagname1;

        } else if (fielddef.getTags().has(tagname2)) {

            tagname = tagname2;

        } else {

            return defaultVaue;

        }

        try {

            boolean value = fielddef.getTags().getBoolean(tagname);

            return value;

        } catch (CoercionException ex) {

            LOGGER.warn("Can't parse tag '" + tagname + "' as boolean for field '" + fielddef.getName() + "'.", ex);

        }

        return defaultVaue;

    }

    protected String getTagValueAsString(String tagname, String defaultVaue) {

        return getTagValueAsString(tagname, null, defaultVaue);

    }

    protected String getTagValueAsString(String tagname1, String tagname2, String defaultVaue) {

        DynField_v2 fielddef = (DynField_v2) this.getDefinition();

        String tagname;

        if (fielddef.getTags().has(tagname1)) {

            tagname = tagname1;

        } else if (fielddef.getTags().has(tagname2)) {

            tagname = tagname2;

        } else {

            return defaultVaue;

        }

        try {

            String value = (String) fielddef.getTags().get(tagname, DataTypes.STRING);

            return value;

        } catch (CoercionException ex) {

            LOGGER.warn("Can't parse tag '" + tagname + "' as string for field '" + fielddef.getName() + "'.", ex);

        }

        return defaultVaue;

    }

    @Override

    public double getResizeWeight() {

        Tags tags = this.getDefinition().getTags();

        int resizeWeight = tags.getInt(DynFormSPIManager.TAG_DYNFORM_RESIZEWEIGHT, 0);

        if( resizeWeight<1 ) {

            return 0;

        }

        if( resizeWeight>100 ) {

            return 1;

        }

        return resizeWeight / 100.0;

    }

}