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

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

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.logging.Level;

import javax.swing.Action;

import javax.swing.BorderFactory;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JViewport;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynform.DynFormDefinition;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynform.JDynFormField;

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.identitymanagement.SimpleIdentity;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public abstract class AbstractJDynForm implements JDynForm {

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractJDynForm.class);

    private final DynFormSPIManager manager;

    private final DynFormDefinition definition;

    private final JDynFormFactory factory;

    private DynFormContext context;

    private int formWidth = -1;

    private int formHeight = -1;

    private int layoutMode = USE_PLAIN;

    private JLabel jlabel_messages = null;

    private boolean readOnly = true;

    private Set listeners = null;

    private boolean useScrollBars = true;

    private final Map<String, List<Action>> customActions;

    private JComponent contents = null;

    protected DynObject values = null;

    private boolean border;

    private final PropertiesSupportHelper propertiesHelper = new PropertiesSupportHelper();

    private Interpreter interpreter;

    private boolean intepreter_initialized = false;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public AbstractJDynForm(

            DynFormSPIManager manager,

            JDynFormFactory factory,

            DynFormDefinition definition,

            DynFormContext context

    ) {

        this.manager = manager;

        this.factory = factory;

        this.definition = definition;

        this.context = context;

        this.listeners = new HashSet();

        this.customActions = new HashMap();

        if (definition != null) {

            this.loadDefaultValuesFromTags(definition.getTags());

            SimpleIdentity user = ToolsLocator.getIdentityManager().getCurrentIdentity();

            if( !user.canWrite(this, definition.getName()) ) {

                this.readOnly = true;

            }

        }

    }

    private Interpreter getInterpreter() {

        if( intepreter_initialized ) {

            return interpreter;

        }

        try {

            ResourcesStorage resources = this.context.getResourcesStorage();

            if( resources==null ) {

                this.interpreter = null;

                this.intepreter_initialized = true;

                return null;

            }

            ResourcesStorage.Resource res = resources.getResource("jfrms");

            if( res == null || !res.exists() ) {

                this.interpreter = null;

                this.intepreter_initialized = true;

                return null;

            }

            List<String> lines = IOUtils.readLines(res.asInputStream());

            if( lines == null ) {

                this.interpreter = null;

                this.intepreter_initialized = true;

                return null;

            }

            String source = StringUtils.join(lines, "\n");

            ExpressionEvaluatorManager expmanager = ExpressionEvaluatorLocator.getManager();

            Code code = expmanager.compile(source);

            this.interpreter = expmanager.createInterpreter();

            this.interpreter.run(code);

            this.intepreter_initialized = true;

            return interpreter;

        } catch (IOException ex) {

            LOGGER.warn("Can't load resource jfrms.", ex);

            this.interpreter = null;

            this.intepreter_initialized = true;

            return null;

        }

    }

    @Override

    public boolean hasUserCode() {

        return this.getInterpreter()!=null;

    }

    @Override

    public boolean hasUserFunction(String name) {

        Interpreter theInterpreter = this.getInterpreter();

        if( theInterpreter==null ) {

            return false;

        }

        return theInterpreter.hasFunction(name);

    }

    protected void callUserEvent(String name, Object...args) {

        Interpreter theInterpreter = this.getInterpreter();

        if( theInterpreter==null ) {

            return;

        }

        if( theInterpreter.hasFunction(name) ) {

            try {

                theInterpreter.call(name, args);

            } catch(Exception ex) {

                LOGGER.warn("Error calling form event '"+name+"'.", ex);

            }

        }

    }

    @Override

    public Object callUserFunction(String function, Object...args) throws Exception {

        Interpreter theInterpreter = this.getInterpreter();

        if( theInterpreter==null ) {

            throw new RuntimeException("Can't exists user code associated to this form.");

        }

        if( !theInterpreter.hasFunction(function) ) {

            throw new IllegalArgumentException("Don't exists function '"+function+"' associated to this form.");

        }

        return theInterpreter.call(function, args);

    } 

    protected Collection<Function> getUserFunctions() {

        Interpreter theInterpreter = this.getInterpreter();

        if( theInterpreter==null ) {

            return Collections.EMPTY_LIST;

        }

        return theInterpreter.getSymbolTable().localfunctions();

    }

    public static int getLayoutFromTags(Tags tags) {

        String layoutMode = (String) tags.get(

                DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE, 

                DataTypes.STRING, 

                DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE_VALUE_PLAIN

        );

        if (!StringUtils.isEmpty(layoutMode)) {

            if (layoutMode.equalsIgnoreCase("0")

                    || layoutMode.equalsIgnoreCase(DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE_VALUE_PLAIN)) {

                return JDynForm.USE_PLAIN;

            } else if (layoutMode.equalsIgnoreCase("1")

                    || layoutMode.equalsIgnoreCase(DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE_VALUE_TABS)) {

                return JDynForm.USE_TABS;

            } else if (layoutMode.equalsIgnoreCase("2")

                    || layoutMode.equalsIgnoreCase(DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE_VALUE_SEPARATORS)) {

                return JDynForm.USE_SEPARATORS;

            }

        }

        return JDynForm.USE_PLAIN;

    }

    public void loadDefaultValuesFromTags(Tags tags) {

        this.setLayoutMode(getLayoutFromTags(tags));

        try {

            this.formWidth = tags.getInt(DynFormSPIManager.TAG_DYNFORM_WIDTH);

        } catch (CoercionException ex) {

        }

        try {

            this.formHeight = tags.getInt(DynFormSPIManager.TAG_DYNFORM_HEIGHT);

        } catch (CoercionException ex) {

        }

        try {

            this.border = tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_BORDER);

        } catch (CoercionException ex) {

        }

        try {

            this.useScrollBars = tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_USESCROLLBARS);

        } catch (CoercionException ex) {

        }

        try {

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

        } catch (CoercionException ex) {

        }

    }

    public DynFormSPIManager getServiceManager() {

        return this.manager;

    }

    @Override

    public JComponent asJComponent() {

        if (this.contents == null) {

            this.initComponents();

        }

        return this.contents;

    }

    protected void initComponents() {

        if (this.contents == null) {

            this.contents = addScrollsAndMessageBar(this.getFieldsContainer());

            if (this.values != null) {

                this.setValues(values);

            }

            if (this.border) {

                this.contents.setBorder(BorderFactory.createLineBorder(Color.GRAY));

            }

            message();

        }

    }

    protected boolean isContentsInitialized() {

        return this.contents != null;

    }

    @Override

    public void addListener(JDynFormListener listener) {

        this.listeners.add(listener);

    }

    @Override

    public void removeListener(JDynFormListener listener) {

        this.listeners.remove(listener);

    }

    public JLabel getMessagesJLabel() {

        if (this.jlabel_messages == null) {

            this.jlabel_messages = new JLabel();

            this.jlabel_messages.addMouseListener(new MouseAdapter() {

                @Override

                public void mouseClicked(MouseEvent evt) {

                    int count = evt.getClickCount();

                    if (count == 2) {

                        JOptionPane.showMessageDialog(contents, jlabel_messages.getText(), "Status", JOptionPane.INFORMATION_MESSAGE);

                    }

                }

            });

        }

        return this.jlabel_messages;

    }

    @Override

    public void setShowMessageStatus(boolean showMessageStatus) {

        this.getMessagesJLabel().setVisible(showMessageStatus);

    }

    @Override

    public boolean isShowMessageStatus() {

        return this.getMessagesJLabel().isVisible();

    }

    @Override

    public void message() {

        this.getMessagesJLabel().setText(" ");

    }

    @Override

    public void message(String msg) {

        this.getMessagesJLabel().setText(msg);

        fireMessageEvent(msg);

    }

    protected void fireMessageEvent(String message) {

        Iterator it = this.listeners.iterator();

        while (it.hasNext()) {

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

            try {

                listener.message(message);

            } catch (Exception ex) {

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

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

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

                        + ").", ex);

            }

        }

    }

    protected void fireFieldChangeEvent(JDynFormField field) {

        Iterator it = this.listeners.iterator();

        while (it.hasNext()) {

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

            try {

                listener.fieldChanged(field);

            } catch (Exception ex) {

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

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

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

                        + ").", ex);

            }

        }

    }

    protected JPanel addScrollsAndMessageBar(JComponent formPanel) {

        formPanel.setBorder(BorderFactory.createEmptyBorder(4, 4, 4, 4));

        JScrollPane scroll = new JScrollPane(formPanel);

        Dimension size = formPanel.getPreferredSize();

        if( this.formWidth<100 ) {

            if( size.width>800 ) {

                this.formWidth = 800;

            } else {

                this.formWidth = size.width;

            }

        }

        if( this.formHeight<100 ) {

            if( size.height>450 ) {

                this.formHeight = 450;

            } else {

                this.formHeight = size.height;

            }

        }

        if (useScrollBars) {

            int scrollBarWidth = scroll.getVerticalScrollBar().getPreferredSize().width;

            scroll.setPreferredSize(new Dimension(formWidth+4, formHeight+4));

            formPanel.setPreferredSize(new Dimension(formWidth-scrollBarWidth, size.height));

        } else {

            scroll.setPreferredSize(size);

        }

        scroll.setBorder(BorderFactory.createEmptyBorder());

        JPanel jpanel = new JPanel();

        jpanel.setLayout(new BorderLayout());

        jpanel.add(scroll, BorderLayout.CENTER);

        jpanel.add(getMessagesJLabel(), BorderLayout.PAGE_END);

        return jpanel;

    }

    @Override

    public int getLayoutMode() {

        return this.layoutMode;

    }

    @Override

    public void setLayoutMode(int layoutMode) {

        if (layoutMode < 0 || layoutMode > USE_SEPARATORS) {

            throw new IllegalArgumentException("layoutMode (" + layoutMode + ") out of range. Valid values are 0 .. " + USE_SEPARATORS + ".");

        }

        this.layoutMode = layoutMode;

    }

    @Override

    public boolean isReadOnly() {

        return readOnly;

    }

    @Override

    public void setReadOnly(boolean readOnly) {

        this.readOnly = readOnly;

    }

    @Override

    public int getFormWidth() {

        if (this.contents == null) {

            return this.formWidth;

        } else {

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

            Component comp = (Component) port.getView();

            return comp.getWidth();

        }

    }

    @Override

    public int getFormHeight() {

        if (this.contents == null) {

            return this.formHeight;

        } else {

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

            Component comp = (Component) port.getView();

            return comp.getHeight();

        }

    }

    @Override

    public void setFormSize(int width, int height) {

        this.formHeight = height;

        this.formWidth = width;

        if (this.contents != null) {

            this.asJComponent().setPreferredSize(new Dimension(width, height));

        }

    }

    protected List<Action> getCustomFields(DataType dataType) {

        return (List<Action>) customActions.get(dataType.getName());

    }

    @Override

    public void addActionToPopupMenu(DataType tipo, String name, Action action) {

        List<Action> acts = this.getCustomFields(tipo);

        action.putValue(Action.NAME, name);

        if (acts == null) {

            List<Action> aux = new ArrayList<>();

            aux.add(action);

            customActions.put(tipo.getName(), aux);

        } else {

            acts.add(action);

        }

    }

    @Override

    public void addSeparatorToPopupMenu(DataType tipo) {

        List<Action> acts = this.getCustomFields(tipo);

        if (acts == null) {

            List<Action> aux = new ArrayList<>();

            aux.add(null);

            customActions.put(tipo.getName(), aux);

        } else {

            acts.add(null);

        }

    }

    @Override

    public DynFormDefinition getDefinition() {

        return this.definition;

    }

    @Override

    public boolean getUseScrollBars() {

        return useScrollBars;

    }

    @Override

    public void setUseScrollBars(boolean usesScrolls) {

        this.useScrollBars = usesScrolls;

    }

    public void setBorder(boolean border) {

        this.border = border;

        if (this.isContentsInitialized() && border) {

            this.asJComponent().setBorder(BorderFactory.createLineBorder(Color.GRAY));

        }

    }

    @Override

    public JDynFormField getField(String fieldName) {

        return null;

    }

    @Override

    public Object getProperty(String key) {

        return this.propertiesHelper.getProperty(key);

    }

    @Override

    public void setProperty(String key, Object obj) {

        this.propertiesHelper.setProperty(key, obj);

    }

    @Override

    public Map<String, Object> getProperties() {

        return this.propertiesHelper.getProperties();

    }

    @Override

    public DynFormContext getContext() {

        return this.context;

    }

    @Override

    public void setContext(DynFormContext context) {

        this.context = context;

    }

    protected abstract JComponent getFieldsContainer();

}