Application: gvSIG desktop

package org.gvsig.app.extension;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.zip.CRC32;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.featureform.swing.FeatureFormDefinitionsProvider;

import org.gvsig.featureform.swing.FeatureFormDefinitionsProvider.Entry;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultFeatureFormDefinitionsProvider implements FeatureFormDefinitionsProvider {

    private class DefaultEntry implements Entry {

        private String key;

        private DynClass dynClass;

        private String xml;

        public DefaultEntry(String key, DynClass dynClass, String xml) {

            this.key = key;

            this.dynClass = dynClass;

            this.xml = xml;

        }

        public DefaultEntry(String key, DynClass dynClass) {

            this(key, dynClass, null);

        }

        public DefaultEntry(FeatureStore store) throws DataException {

            this(null, store.getDefaultFeatureType(), null);

            this.key = getFilename(store);

        }

        @Override

        public DynClass getDynClass() {

            return dynClass;

        }

        @Override

        public String getKey() {

            return key;

        }

        @Override

        public String getXml() {

            if (this.xml == null) {

                DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

                this.xml = dynObjectManager.exportSimpleDynClassDefinitions(this.getDynClass());

            }

            return this.xml;

        }

        public boolean setXml(String xml) {

            if (xml == null) {

                this.xml = null;

                return true;

            }

            Map classes;

            DynClass dynClass;

            DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

            try {

                InputStream is = IOUtils.toInputStream(xml, Charset.forName("UTF-8"));

                classes = dynObjectManager.importDynClassDefinitions(is, this.getClass().getClassLoader());

            } catch (Exception ex) {

                logger.warn("Can't parse xml definition.", ex);

                return false;

            }

            if (!classes.containsKey(this.getDynClass().getName())) {

                logger.warn("Can't load definition of '" + this.getDynClass().getName() + "' from xml.");

                return false;

            }

            this.xml = xml;

            return true;

        }

        public void setDynClass(DynClass dynClass) {

            this.dynClass = dynClass;

        }

        @Override

        public int compareTo(Entry t) {

            return this.getKey().compareTo(t.getKey());

        }

    }

    private static final Logger logger = LoggerFactory.getLogger(DefaultFeatureFormDefinitionsProvider.class);

    private File definitionsFolder = null;

    public File getDefinitionsFolder() throws IOException {

        if (this.definitionsFolder == null) {

            PluginsManager pluginManager = PluginsLocator.getManager();

            PluginServices plugin = pluginManager.getPlugin(CreateDefaultFormDefinitionExtension.class);

            File homeFolder = plugin.getPluginHomeFolder();

            File definitionsFolder = new File(homeFolder, "forms");

            if (!definitionsFolder.exists()) {

                FileUtils.forceMkdir(definitionsFolder);

            }

            this.definitionsFolder = definitionsFolder;

        }

        return this.definitionsFolder;

    }

    public long getCRC(FeatureType type) {

        StringBuilder buffer = new StringBuilder();

        for (int i = 0; i < type.size(); i++) {

            FeatureAttributeDescriptor x = type.getAttributeDescriptor(i);

            buffer.append(x.getName());

            buffer.append(x.getDataTypeName());

            buffer.append(x.getSize());

        }

        CRC32 crc = new CRC32();

        byte[] data = buffer.toString().getBytes();

        crc.update(data);

        return crc.getValue();

    }

    public String getFilename(FeatureStore store) throws DataException {

        FeatureType type = store.getDefaultFeatureType();

        return store.getName() + "-" + Long.toHexString(getCRC(type)) + ".xml";

    }

    public Entry get(File definitionFile) {

        String xml;

        Map classes;

        DynClass dynClass;

        DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

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

            return null;

        }

        try {

            xml = FileUtils.readFileToString(definitionFile);

        } catch (Exception ex) {

            return null;

        }

        try {

            InputStream is = IOUtils.toInputStream(xml, Charset.forName("UTF-8"));

            classes = dynObjectManager.importDynClassDefinitions(is, this.getClass().getClassLoader());

        } catch (Exception ex) {

            logger.warn("Can't parse xml definition.", ex);

            return null;

        }

        try {

            dynClass = (DynClass) classes.values().iterator().next();

        } catch (Exception ex) {

            return null;

        }

        if (dynClass == null) {

            return null;

        }

        InputStream is;

        try {

            is = new FileInputStream(definitionFile);

        } catch (FileNotFoundException ex) {

            return null;

        }

        return new DefaultEntry(definitionFile.getName(), dynClass, xml);

    }

    @Override

    public Entry get(FeatureStore store) throws DataException {

        FeatureType type = store.getDefaultFeatureType();

        File f;

        try {

            f = new File(getDefinitionsFolder(), getFilename(store));

        } catch (IOException ex) {

            return new DefaultEntry(store);

        }

        Entry entry = this.get(f);

        return entry;

    }

    @Override

    public void put(Entry entry) throws DataException, IOException {

        if (!getDefinitionsFolder().exists()) {

            FileUtils.forceMkdir(getDefinitionsFolder());

        }

        File f = new File(getDefinitionsFolder(), entry.getKey());

        FileUtils.write(f, entry.getXml());

    }

    @Override

    public Iterator<Entry> iterator() {

        try {

            List<Entry> definitions = new ArrayList();

            File folder;

            folder = this.getDefinitionsFolder();

            for (File f : folder.listFiles()) {

                Entry entry = this.get(f);

                if (entry != null) {

                    definitions.add(entry);

                }

            }

            Collections.sort(definitions);

            return definitions.iterator();

        } catch (IOException ex) {

            logger.warn("Can't retrieve list of forms definitions.", ex);

            return null;

        }

    }

    @Override

    public void put(FeatureStore store) throws DataException, IOException {

        DefaultEntry entry = new DefaultEntry(store);

        this.put(entry);

    }

    @Override

    public DynClass getDynClass(FeatureStore store) throws DataException {

        Entry entry = this.get(store);

        if (entry == null) {

            return null;

        }

        return entry.getDynClass();

    }

}

package org.gvsig.app.extension;

import javax.swing.JOptionPane;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

/**

 *

 * @author jjdelcerro

 */

public class CreateDefaultFormDefinitionExtension extends Extension {

    private static final Logger logger = LoggerFactory.getLogger(CreateDefaultFormDefinitionExtension.class);

    @Override

    public void initialize() {

        DataSwingManager featureFormManager = DALSwingLocator.getSwingManager();

        featureFormManager.registerFeatureFormDefinitionsProvider(new DefaultFeatureFormDefinitionsProvider());

    }

    @Override

    public void execute(String actionCommand) {

        if( "layer-create-default-form-definition".equalsIgnoreCase(actionCommand) ) {

            ApplicationManager application = ApplicationLocator.getManager();

            ViewDocument viewDoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

            if( viewDoc == null ) {

                return;

            }

            MapContext mapContext = viewDoc.getMapContext();

            if( !mapContext.hasActiveVectorLayers() ) {

                return;

            }

            DataSwingManager featureFormManager = DALSwingLocator.getSwingManager();

            FLayer[] layers = mapContext.getLayers().getActives();

            for (FLayer layer1 : layers) {

                if (layer1 instanceof FLyrVect) {

                    FLyrVect layer = (FLyrVect) layer1;

                    try {

                        featureFormManager.getFeatureFormDefinitionsProvider().put(layer.getFeatureStore());

                        application.messageDialog(

                                "Se creado la definicion de formulario asociada a la capa '"+layer.getName()+"'.",

                                "Definicion de formulario", 

                                JOptionPane.INFORMATION_MESSAGE

                        );

                    } catch (Exception ex) {

                        logger.warn("Can't save form definition for layer '"+layer.getName()+"'.",ex);

                        application.messageDialog(

                                "No se ha podido crear la definicion de formulario asociada a la capa '"+layer.getName()+"'.\n\n(Consulte el registro de errores si desea mas informacion)",

                                "Definicion de formulario", 

                                JOptionPane.INFORMATION_MESSAGE

                        );

                    }

                }

            }

        }

    }

    @Override

    public boolean isEnabled() {

        return true;

    }

    @Override

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

        ViewDocument viewDoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

        if( viewDoc == null ) {

            return false;

        }

        MapContext mapContext = viewDoc.getMapContext();

        return mapContext.hasActiveVectorLayers();

    }

}

        <extension

          class-name="org.gvsig.app.extension.CreateDefaultFormDefinitionExtension"

          description="" active="true" priority="1">

          <action 

            name="layer-create-default-form-definition"

            label="Create default form definition" 

            tooltip="Create default form definition" 

            position="601400000"

            action-command="layer-create-default-form-definition" 

            icon="layer-create-default-form-definition"

            accelerator="" 

          />

          <menu 

              name="layer-create-default-form-definition" 

              text="Layer/Create default form (experimental)" 

          />

        </extension>