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.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import javax.json.JsonObject;

import javax.swing.AbstractButton;

import javax.swing.Action;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JViewport;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

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.gvsig.tools.script.Script;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.ToolsSwingUtils;

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.swing.icontheme.IconThemeManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

public abstract class AbstractJDynFormField implements JDynFormField, FocusListener {

    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;

    private Map<String, AbstractButton> buttonsOfEvents;

    public AbstractJDynFormField(

            DynFormSPIManager serviceManager,

            ComponentsFactory componentsFactory,

            JDynFormFieldFactory factory,

            DynFormFieldDefinition definition,

            Object value

        ) {

        this.buttonsOfEvents = null;

        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) {

                StringWriter sw = new StringWriter();

                th.printStackTrace(new PrintWriter(sw));

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

                this.problemIndicator().set("Can't create component\n"+sw.toString());

            }

            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.jlabel.setText("<html><b>"+this.getLabel()+"</b></html>");

            }

            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);

    }

    /*

     * Estos eventos no se deben disparar cuando se asignan valores por c?digo,

     * solo cuando los modifica el usuario

     */

    public 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);

            }

        }

        this.setReadOnlyButtonsOfEvents(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) {

                    Object x = this.getAssignedValue();

                    if (StringUtils.isNotBlank(Objects.toString(x,null))) {

                        modified = true;

                    }

                } else {

                    Object x = this.getAssignedValue();

                    if (x instanceof CharSequence){

                        if (!StringUtils.equals((CharSequence) x, value.toString())){

                            modified = true;

                        }

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

                        modified = true;

                    }

                }

            }

        } catch (IllegalFieldValue ex) {

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

            modified = true;

        }

        return modified;

    }

//    protected Object getValueWithoutValidate() {

//

//    }

    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;

        }

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

        this.setValue(value);

//        if (this.contents instanceof JTextField) {

//            if (value != null) {

//                value = value.toString();

//            } else {

//                value = "";

//            }

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

//            return;

//        }

//        if (this.contents instanceof JSpinner) {

//            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;

    }

    @Override

    public void focusGained(FocusEvent arg0) {

        fireFieldEnterEvent();

        this.problemIndicator().restore();

    }

    @Override

    public void focusLost(FocusEvent arg0) {

        if (this.hasValidValue()) {

            this.problemIndicator().clear();

        } else {

            try {

                Object value = this.getValue();

            } catch (Exception e) {

                this.problemIndicator().set(e.getLocalizedMessage());

            }

        }

        fireFieldExitEvent();

    }

    protected void fixPreferredWidth(JComponent comp)  {

        Dimension prefsize = comp.getPreferredSize();

        if( prefsize.width>200 ) {

            prefsize.width = 200;

            comp.setPreferredSize(prefsize);

        }

    }

    protected ImageIcon getIcon(String name) {

        IconThemeManager iconThemeManager = ToolsSwingLocator.getIconThemeManager();

        IconTheme theme = iconThemeManager.getCurrent();

        ImageIcon icon = theme.get(name);

        return icon;

    }

    @Override

    public String toHTML() {

        return null;

    }

    @Override

    public boolean hasClickEvent(String eventName) {

        Script script = this.getForm().getScript();

        if( script == null ) {

            return false;

        }

        String functionName = this.getName()+"_"+eventName+"_click";

        List<String> names = script.getNames();

        if( names!=null && names.contains(functionName)) {

            return true;

        }

        return false;

    }

    public AbstractButton getButtonForClickEvent(String eventName, String tip, String iconName) {

        JDynFormField jfield = this;

        JDynForm jform = this.getForm();

        Script script = jform.getScript();

        if( script == null ) {

            return null;

        }

        if( this.buttonsOfEvents==null ) {

            this.buttonsOfEvents = new HashMap<>();

        }

        AbstractButton button = buttonsOfEvents.get(eventName+"_click");

        if( button!=null ) {

            return button;

        }

        String functionName = this.getName()+"_"+eventName+"_click";

        button = new JButton();

        ToolsSwingUtils.configurePickersButton(

                button,

                tip,

                iconName,

                (ActionEvent e) -> {

                    try {

                        // TODO: ?Lanzarlo en un thread aparte?

                        script.invokeFunction(functionName, new Object[] {jform, jfield});

                    } catch (Throwable t) {

                        LOGGER.warn("Error calling event '"+functionName+"'",t);

                    }

                },

                new FocusListener() {

                    @Override

                    public void focusGained(FocusEvent e) {

                        fireFieldEnterEvent();

                    }

                    @Override

                    public void focusLost(FocusEvent e) {

                    }

                }

        );

        this.buttonsOfEvents.put(eventName+"_click",button);

        return button;

    }

    protected JsonObject getEventConfiguration(String name) {

        // Habria que cachear estas configuraciones en el jDynFormField

        JDynForm jform = this.getForm();

        Script script = jform.getScript();

        if( script == null ) {

            return null;

        }

        String functionName = this.getName()+"_"+name+"_config";

        try {

            Object x = script.invokeFunction(functionName, new Object[0]);

            return (JsonObject)x;

        } catch (Throwable t) {

            LOGGER.warn("Error calling event '"+functionName+"'",t);

            return null;

        }

    }

    protected void setReadOnlyButtonsOfEvents(boolean readonly) {

        if( this.buttonsOfEvents==null ) {

            return;

        }

        for (Map.Entry<String, AbstractButton> entry : buttonsOfEvents.entrySet()) {

            String name = entry.getKey();

            AbstractButton button = entry.getValue();

            try {

                JsonObject config = this.getEventConfiguration(StringUtils.removeEnd(name, "_click"));

                boolean enabled = config.getBoolean("enabled");

                button.setEnabled(enabled);

            } catch(Throwable ex) {

                button.setEnabled(!readonly);

            }

        }

    }

}