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

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

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

import java.util.ArrayList;

import java.util.List;

import javax.swing.Action;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynform.DynFormDefinition;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynform.JDynForm.DynFormContext;

import static org.gvsig.tools.dynform.JDynForm.USE_PLAIN;

import static org.gvsig.tools.dynform.JDynForm.USE_SEPARATORS;

import org.gvsig.tools.dynform.JDynFormSet;

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

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

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public abstract class AbstractJDynFormSet implements JDynFormSet {

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

    private final DynFormSPIManager manager;

    private final JDynFormSetFactory factory;

    private final DynFormDefinition definition;

    protected JComponent contents = null;

    protected List<DynObject> values = null;

    protected VisitableSet listeners = null;

    protected boolean readOnly = false;

    protected boolean autosave = true;

    protected int layoutMode = USE_PLAIN;

    protected int formWidth = -1;

    protected int formHeight = -1;

    protected List<ActionStore> actionsBuffer = new ArrayList<>();

    private boolean useScrollBars = true;

    private boolean _allowUpdate;

    private boolean _allowDelete;

    private boolean _allowNew;

    private boolean _allowSearch;

    private boolean _allowClose;

    private boolean _isInNewState = false;

    private final JDynForm.DynFormContext context;

    private final Tags contextTags;

    public AbstractJDynFormSet(

            DynFormSPIManager manager, 

            JDynFormSetFactory factory,

            JDynForm.DynFormContext context,

            DynFormDefinition definition,

            Tags contextTags

        ) {

        this.manager = manager;

        this.factory = factory;

        this.context = context;

        this.definition = definition;

        this.contextTags = contextTags;

        this.listeners = new DefaultVisitableSet();

    }

    @Override

    public JDynForm getForm() {

        return null;

    }

    @Override

    public void fireEvent(String action, Object value) {

    }

    protected JDynFormSetFactory getFactory() {

        return this.factory;

    }

    protected DynFormDefinition getDefinition() {

        return this.definition;

    }

    protected DynFormContext getContext() {

        return this.context;

    }

    public DynFormSPIManager getManager() {

        return this.manager;

    }

    public void loadDefaultValueFromTags(Tags tags) {

        this.setLayoutMode(getLayoutFromTags(tags));

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

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

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

        this.autosave = tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_AUTOSAVE, this.autosave);

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

        this.setAllowNew( tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_ACTION_NEW, this._allowNew));

        this.setAllowUpdate(tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_ACTION_UPDATE, this._allowNew));

        this.setAllowDelete(tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_ACTION_DELETE, this._allowNew));

        this.setAllowSearch(tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_ACTION_SEARCH, this._allowNew));

        this.setAllowClose(tags.getBoolean(DynFormSPIManager.TAG_DYNFORM_ACTION_CLOSE, this._allowNew));

    }

    public boolean isInNewState() {

        return this._isInNewState;

    }

    protected void enterStateNew() {

        this._isInNewState = true;

    }

    protected void leaveTheNewState() {

        this._isInNewState = false;

    }

    public void addListener(JDynFormSetListener listener) {

        this.listeners.add(listener);

    }

    public void removeListener(JDynFormSetListener listener) {

        this.listeners.remove(listener);

    }

    protected void fireMessageEvent(final String message) {

        try {

            this.listeners.accept(new Visitor() {

                public void visit(Object listener) throws VisitCanceledException, BaseException {

                    ((JDynFormSetListener) listener).formMessage(message);

                }

            });

        } catch (Exception e) {

            LOGGER.info("Error calling to the form message event.", e);

        }

    }

    protected void fireCloseEvent() {

        try {

            this.listeners.accept(new Visitor() {

                public void visit(Object listener) throws VisitCanceledException, BaseException {

                    ((JDynFormSetListener) listener).formClose();

                }

            });

        } catch (Exception e) {

            LOGGER.info("Error calling to the form close event.", e);

        }

    }

    protected void fireFormMovedToEvent(final int position) {

        try {

            this.listeners.accept(new Visitor() {

                public void visit(Object listener) throws VisitCanceledException, BaseException {

                    ((JDynFormSetListener) listener).formMovedTo(position);

                }

            });

        } catch (Exception e) {

            LOGGER.info("Error calling to the form moved to event.", e);

        }

    }

    public int getLayoutMode() {

        return this.layoutMode;

    }

    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;

    }

    public boolean isReadOnly() {

        return readOnly;

    }

    public void setReadOnly(boolean readOnly) {

        this.readOnly = readOnly;

    }

    public boolean isAutosave() {

        return this.autosave;

    }

    public void setAutosave(boolean autosave) {

        this.autosave = autosave;

    }

    protected int confirmDialog(final String message, final String title, final int optionType,

            final int messageType) {

        return JOptionPane.showConfirmDialog(

                this.contents, message, title, optionType, messageType);

    }

    public void setFormSize(int width, int height) {

        this.formHeight = height;

        this.formWidth = width;

    }

    public int countValues() {

        return this.values.size();

    }

    public void setValues(DynObjectSet values) {

        List x = new ArrayList();

        DisposableIterator it;

        try {

            it = values.iterator();

        } catch (BaseException e) {

            LOGGER.info("Uf! o se que hacer con este error, lo relanzo sin mas.", e);

            throw new RuntimeException(e);

        }

        while ( it.hasNext() ) {

            DynObject obj = (DynObject) it.next();

            if ( obj instanceof org.gvsig.tools.lang.Cloneable ) {

                try {

                    obj = (DynObject) ((org.gvsig.tools.lang.Cloneable) obj).clone();

                } catch (CloneNotSupportedException e) {

                    // Do nothing

                }

            }

            x.add(obj);

        }

        this.values = x;

    }

    public void setValues(List values) {

//        this.values = new ArrayList<DynObject>();

//        this.values.addAll(values);

        this.values = values;

    }

    public DynObject get(int position) {

        return (DynObject) this.values.get(position);

    }

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

        try {

            this.actionsBuffer.add(new ActionStore(tipo, name, action));

        } catch (Exception ex) {

            String s = (tipo == null) ? "(null)" : tipo.getName();

            LOGGER.warn("Can't add popup menu '" + name + "' to the fields of type '" + s + "' of the form.", ex);

        }

    }

    public void addSeparatorToPopupMenu(DataType tipo) {

        try {

            this.actionsBuffer.add(new ActionStore(tipo));

        } catch (Exception ex) {

            String s = (tipo == null) ? "(null)" : tipo.getName();

            LOGGER.warn("Can't add separator to the popup menu to the fields of type '" + s + "' of the form.", ex);

        }

    }

    public void setUseScrollBars(boolean usesScrolls) {

        this.useScrollBars = usesScrolls;

    }

    public boolean getUseScrollBars() {

        return useScrollBars;

    }

    public DynFormSPIManager getServiceManager() {

        return this.manager;

    }

    public void message() {

        // Do nothing, ignore message handling

    }

    public void message(String msg) {

        // Do nothing, ignore message handling

    }

    public boolean allowUpdate() {

        return this._allowUpdate;

    }

    public boolean allowClose() {

        return this._allowClose;

    }

    public boolean allowDelete() {

        return this._allowDelete;

    }

    public boolean allowNew() {

        return this._allowNew ;

    }

    public boolean allowSearch() {

        return this._allowSearch;

    }

    public void setAllowUpdate(boolean allowUpdate) {

        this._allowUpdate = allowUpdate;

    }

    public void setAllowDelete(boolean allowDelete) {

        this._allowDelete = allowDelete;

    }

    public void setAllowNew(boolean allowNew) {

        this._allowNew = allowNew;

    }

    public void setAllowSearch(boolean allowSearch) {

        this._allowSearch = allowSearch;

    }

    public void setAllowClose(boolean allowClose) {

        this._allowClose = allowClose;

    }

    public void getFormValues(DynObject values) {

        throw new UnsupportedOperationException();

    }

    protected int getTagValueAsInt(String tagname, int defaultVaue) {

        if( definition.getTags().has(tagname) ) {

            try {

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

                return value;

            } catch (CoercionException ex) {

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

            }

        }

        return defaultVaue;

    }

    protected boolean getTagValueAsBoolean(String tagname, boolean defaultVaue) {

        if( definition.getTags().has(tagname) ) {

            try {

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

                return value;

            } catch (CoercionException ex) {

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

            }

        }

        return defaultVaue;

    }

}