| gvSIG desktop 1

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<packaging>jar</packaging>

	<artifactId>org.gvsig.app.document.table.app.mainplugin</artifactId>

	<name>Document: Table</name>

	<description>Adds a table document type which shows information data sources with Features or from an already open View document. Also allows editing on data sources that allow so.</description>	

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.app.document.table.app</artifactId>

		<version>2.0.0-SNAPSHOT</version>

	</parent>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.core.maven.dependencies</artifactId>

            <version>2.0.1-SNAPSHOT</version>

            <type>pom</type>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.lib</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.app</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.andami</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.control</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.mapcontext</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.utils</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.ui</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.projection</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.timesupport.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

    </dependencies>

	<profiles>

		<profile>

			<id>gvsig-install</id>

			<activation>

				<activeByDefault>true</activeByDefault>

			</activation>

			<properties>

				<!--

					Default gvSIG installation folder relative to the current workspace

				-->

				<gvsig.install.dir>${basedir}/../../build/product</gvsig.install.dir>

			</properties>

		</profile>

	</profiles>

    <properties>

        <package.info.dependencies>required: org.gvsig.app -ge 2.0-2036</package.info.dependencies>

        <package.info.categories>Table</package.info.categories>

    </properties>

</project>

<assembly>

	<id>distribution</id>

	<formats>

		<format>dir</format>

	</formats>

	<fileSets>

		<!-- Estructure for the extension -->

		<fileSet>

			<directory>src/main/resources</directory>

			<outputDirectory>${extension.install.dir.name}

			</outputDirectory>

		</fileSet>

	</fileSets>

    <files>

        <file>

            <source>package.info</source>

            <outputDirectory>${extension.install.dir.name}</outputDirectory>

        </file>

    </files>

	<dependencySets>

		<dependencySet>

			<outputDirectory>${extension.install.dir.name}/${library-dir}

			</outputDirectory>

			<includes>

				<include>org.gvsig:org.gvsig.app.document.table.app.mainplugin</include>

			</includes>

		</dependencySet>

	</dependencySets>

</assembly>

#maven.buildNumber.plugin properties file

#Mon Jun 25 11:21:40 CEST 2012

buildNumber=15

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	org.gvsig.tools packages.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.tools">

		<priority value="DEBUG" />

	</category>

	<category name="org.gvsig.app.document.table">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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 2

 * 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.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 IVER T.I. S.A.   {{Task}}

 */

package org.gvsig.fmap.dal.serverexplorer.filesystem.swing;

import java.awt.Window;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.prepareAction.PrepareContext;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.table.TableDocument;

import org.gvsig.app.project.documents.table.TableManager;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

public class FilesystemExplorerTableWizardPanel extends

    FilesystemExplorerWizardPanel {

    private static final long serialVersionUID = 8469934188826417698L;

    private PrepareContext prepareDSContext = null;

    @Override

    public void execute() {

        executeWizard();

    }

    public Object executeWizard() {

        FeatureStore store;

        TableDocument table;

        ApplicationManager manager = ApplicationLocator.getManager();

        Project project = manager.getCurrentProject();

        PrepareContext context = this.getPrepareDataStoreContext();

        DataStoreParameters[] parameters = this.getParameters();

        List<TableDocument> tabledocs =

            new ArrayList<TableDocument>(parameters.length);

        for (DataStoreParameters params : parameters) {

            store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                store =

                    (FeatureStore) dataManager.openStore(

                        params.getDataStoreName(), params);

                manager.pepareOpenDataSource(store, context);

                table =

                    (TableDocument) ProjectManager.getInstance()

                        .createDocument(TableManager.TYPENAME);

                table.setName(store.getName());

                table.setStore(store);

                // project.add(table);

                tabledocs.add(table);

            } catch (Exception e) {

                if (store != null) {

                    store.dispose();

                }

                NotificationManager.addError(e);

            }

        }

        return tabledocs;

    }

    @Override

    protected PrepareContext getPrepareDataStoreContext() {

        if (this.prepareDSContext == null) {

            this.prepareDSContext = new PrepareContext() {

                public Window getOwnerWindow() {

                    return null;

                }

                public IProjection getViewProjection() {

                	return null;

                }

            };

        }

        return this.prepareDSContext;

    }

    public String getTabName() {

        return PluginServices.getText(this, "File");

    }

}

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<title>org.gvsig.landregistryviewer package documentation</title>

</head>

<body>

	<p>Open table document from file support</p>

</body>

</html>

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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 2

 * 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.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 {DiSiD Technologies}  {TableDocument implementation based on the gvSIG DAL API}

 */

package org.gvsig.app.project.documents.table;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.AbstractDocument;

import org.gvsig.app.project.documents.DocumentManager;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontrol.dal.feature.swing.table.FeatureStoreModel;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * @author <a href="mailto:cordin@disid.com">C?sar Ordi?ana</a>

 */

public class TableDocument extends AbstractDocument implements Observer {

    private static final long serialVersionUID = -1842181135614158881L;

    final static private Logger logger = LoggerFactory

        .getLogger(TableDocument.class);

    private FeatureStore store;

    private String featureTypeId;

    private String[] attributeNames;

    private List<TableLink> linkTable;

    private VectorLayer associatedLayer;

    private FeatureQuery query;

    private Evaluator baseFilter;

    private FeatureQueryOrder baseOrder;

    private FeatureStoreModel featureStoreModel;

    private Object lock = new Object();

    public TableDocument(DocumentManager factory) {

        super(factory);

        this.store = null;

        this.query = null;

        this.featureTypeId = null;

        this.baseFilter = null;

        this.baseOrder = null;

    }

    public TableDocument() {

        this(null);

    }

    public TableDocument(DocumentManager factory, FeatureStore store) {

        this(factory);

        setStore(store);

    }

    public FeatureStoreModel getFeatureStoreModel() {

        synchronized (lock) {

            if (this.featureStoreModel == null) {

                try {

                    this.featureStoreModel =

                        new FeatureStoreModel(getStore(), getQuery());

                } catch (BaseException e) {

                    NotificationManager.addError(e);

                }

            }

        }

        return this.featureStoreModel;

    }

    public void setStore(FeatureStore store) {

        if (this.store != null) {

            throw new UnsupportedOperationException(

                "can't set store. store already set.");

        }

        this.store = store;

        this.store.addObserver(this);

        this.query = null; // setQuery(store.createFeatureQuery());

    }

    @SuppressWarnings("unchecked")

    public FeatureQuery getQuery() {

        if (this.query == null) {

            try {

                FeatureType fType = null;

                this.query = this.store.createFeatureQuery();

                if (this.featureTypeId != null) {

                    Iterator<FeatureType> iter;

                    iter = this.store.getFeatureTypes().iterator();

                    while (iter.hasNext()) {

                        fType = iter.next();

                        if (this.featureTypeId.equals(fType.getId())) {

                            this.query.setFeatureType(fType);

                            break;

                        }

                    }

                    if (fType == null) {

                        throw new RuntimeException(MessageFormat.format(

                            "frature type {1} not found.", this.featureTypeId));

                    }

                } else {

                    fType = store.getDefaultFeatureType();

                }

                if (this.attributeNames != null) {

                    ArrayList<String> newNames = new ArrayList<String>();

                    for (String name : this.attributeNames) {

                        if (fType.getIndex(name) > -1) {

                            newNames.add(name);

                        }

                    }

                    if (newNames.size() > 0) {

                        this.query.setAttributeNames(newNames

                            .toArray(this.attributeNames));

                    }

                }

                this.query.setFilter(this.baseFilter); // TODO check is valid

                this.query.setOrder(this.baseOrder);

            } catch (DataException e) {

                NotificationManager.addError(e);

                return null;

            }

        }

        return this.query;

    }

    /**

     * @return the store

     */

    public FeatureStore getStore() {

        return store;

    }

    /**

     * Return information about the table links.

     * 

     * @return List of TableLink information.

     */

    public List<TableLink> getLinks() {

        return this.linkTable;

    }

    /**

     * Returns if this table document has links with other tables.

     * 

     * @return if this table document has links with other tables

     */

    public boolean hasLinks() {

        return this.linkTable != null && this.linkTable.size() > 0;

    }

    /**

     * Devuelve el identificador de la tabla que contiene el link.

     * 

     * @return identificador ?nico de la tabla.

     * @deprecated see {{@link #getLinks()}

     */

    public String getLinkTable() {

        if (linkTable == null || linkTable.isEmpty()) {

            return null;

        }

        return linkTable.get(0).getTargetTable().getName();

    }

    /**

     * Devuelve el nombre del campo de la tabla a enlazar.

     * 

     * @return Nombre del campo de la tabla a enlazar.

     * @deprecated see {{@link #getLink()}

     */

    public String getField1() {

        if (linkTable.isEmpty()) {

            return null;

        }

        return this.linkTable.get(0).getSourceFieldName();

    }

    /**

     * Devuelve el nombre del campo de la tabla enlazada.

     * 

     * @return Nombre del campo de la tabla enlazada.

     * @deprecated see {{@link #getLink()}

     */

    public String getField2() {

        if (linkTable.isEmpty()) {

            return null;

        }

        return this.linkTable.get(0).getTargetFieldName();

    }

    /**

     * Enlaza la seleccion de esta tabla con la de la tabla indicada

     * 

     * @deprecated see {@link #addLinkTable(String, String, String)}

     */

    public void setLinkTable(String targetTable, String fieldSource,

        String fieldTarget) {

        this.addLinkTable(targetTable, fieldSource, fieldTarget);

    }

    /**

     * Add a table link to this document.

     * 

     * @param targetTable

     * @param fieldSource

     * @param fieldTarget

     */

    public void addLinkTable(String targetTable, String fieldSource,

        String fieldTarget) {

        TableDocument target =

            (TableDocument) ProjectManager.getInstance().getCurrentProject()

                .getDocument(targetTable, TableManager.TYPENAME);

        TableLink link = new TableLink(this, target, fieldSource, fieldTarget);

        link.setEnabled(true);

        if (this.linkTable == null) {

            this.linkTable = new ArrayList<TableLink>();

        }

        this.linkTable.add(link);

    }

    /**

     * remove the last link to table added.

     * 

     */

    public void removeLinkTable() {

        if (linkTable.isEmpty()) {

            return;

        }

        TableLink link = this.linkTable.remove(this.linkTable.size() - 1);

        link.setEnabled(false);

        this.linkTable = null;

    }

    /**

     * Remove the link to the table document.

     * 

     * @param name

     *            of table document to remove.

     */

    public void removeLinkTable(String name) {

        for (TableLink link : this.linkTable) {

            if (name.equals(link.target.getName())) {

                link.setEnabled(false);

                this.linkTable.remove(link);

            }

        }

    }

    public VectorLayer getAssociatedLayer() {

        return associatedLayer;

    }

    public void setAssociatedLayer(VectorLayer associatedLayer) {

        this.associatedLayer = associatedLayer;

    }

    public void update(Observable arg0, Object arg1) {

        if (this.store.equals(arg0)) {

            if (arg1 instanceof FeatureStoreNotification) {

                FeatureStoreNotification event =

                    (FeatureStoreNotification) arg1;

                if (event.getType() == FeatureStoreNotification.TRANSFORM_CHANGE

                    || event.getType() == FeatureStoreNotification.RESOURCE_CHANGED) {

                    this.query = null;

                }

            }

        }

    }

    @SuppressWarnings("unchecked")

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        this.store = (FeatureStore) state.get("store");

        this.featureTypeId = state.getString("featureTypeId");

        this.attributeNames =

            (String[]) state.getArray("attributeNames", String.class);

        this.linkTable = state.getList("linkTable");

        this.associatedLayer = (FLyrVect) state.get("associatedLayer");

        this.query = (FeatureQuery) state.get("query");

        this.baseFilter = (Evaluator) state.get("baseFilter");

        this.baseOrder = (FeatureQueryOrder) state.get("baseOrder");

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("store", store);

        state.set("featureTypeId", featureTypeId);

        state.set("attributeNames", attributeNames);

        state.set("linkTable", linkTable);

        state.set("associatedLayer", associatedLayer);

        state.set("query", query);

        // state.set("baseFilter", baseFilter);

        state.set("baseOrder", baseOrder);

    }

    public static class TableLink implements Observer, Persistent {

        private TableDocument source;

        private FeatureStore storeSource;

        private int fieldSource;

        private TableDocument target;

        private FeatureStore storeTarget;

        private int fieldTarget;

        private boolean enabled;

        public TableLink() {

            this.source = null;

            this.target = null;

            this.fieldSource = -1;

            this.fieldTarget = -1;

            this.storeSource = null;

            this.storeTarget = null;

            this.enabled = false;

        }

        public TableLink(TableDocument source, TableDocument target,

            String fieldSource, String fieldTarget) {

            this();

            this.initialize(source, target, fieldSource, fieldTarget);

        }

        private void initialize(TableDocument source, TableDocument target,

            String fieldSource, String fieldTarget) {

            this.source = source;

            this.target = target;

            this.storeSource = this.source.getStore();

            this.storeTarget = this.target.getStore();

            try {

                this.fieldSource =

                    storeSource.getDefaultFeatureType().getIndex(fieldSource);

                this.fieldTarget =

                    storeTarget.getDefaultFeatureType().getIndex(fieldTarget);

            } catch (DataException ex) {

                logger.error("Can't initialize TableLink", ex);

                throw new RuntimeException("Can't initialize TableLink", ex);

            }

        }

        public void setEnabled(boolean enabled) {

            if (enabled) {

                this.storeSource.addObserver(this);

            } else {

                this.storeSource.deleteObserver(this);

            }

            this.enabled = enabled;

        }

        public boolean getEnabled() {

            return this.enabled;

        }

        public TableDocument getTargetTable() {

            return this.target;

        }

        public TableDocument getSourceTable() {

            return this.source;

        }

        public String getSourceFieldName() {

            try {

                return ((FeatureAttributeDescriptor) this.storeSource

                    .getDefaultFeatureType().get(this.fieldSource)).getName();

            } catch (DataException e) {

                logger.warn("Can't get source field name.", e);

                return null;

            }

        }

        public String getTargetFieldName() {

            try {

                return ((FeatureAttributeDescriptor) this.storeTarget

                    .getDefaultFeatureType().get(this.fieldTarget)).getName();

            } catch (DataException e) {

                logger.warn("Can't get target field name.", e);

                return null;

            }

        }

        public void update(Observable arg0, Object arg1) {

            try {

                FeatureSet fCollection1 =

                    (FeatureSet) storeSource.getSelection();

                FeatureSelection fCollection2 =

                    (FeatureSelection) storeTarget.createSelection();

                List<Object> idx = new ArrayList<Object>();

                // Construimos el ?ndice

                DisposableIterator iterator1 = null;

                try {

                    iterator1 = fCollection1.fastIterator();

                    while (iterator1.hasNext()) {

                        Feature feature = (Feature) iterator1.next();

                        Object obj = feature.get(fieldSource);

                        if (!idx.contains(obj)) {

                            idx.add(obj);

                        }

                    }

                } finally {

                    if (iterator1 != null) {

                        iterator1.dispose();

                    }

                }

                FeatureSet set = null;

                DisposableIterator iterator2 = null;

                try {

                    set = storeTarget.getFeatureSet();

                    iterator2 = set.fastIterator();

                    while (iterator2.hasNext()) {

                        Feature feature = (Feature) iterator2.next();

                        Object obj = feature.get(fieldTarget);

                        if (idx.contains(obj)) {

                            fCollection2.select(feature);

                        }

                    }

                } catch (DataException e1) {

                    NotificationManager.addError(e1);

                    return;

                } finally {

                    if (iterator2 != null) {

                        iterator2.dispose();

                    }

                    if (set != null) {

                        set.dispose();

                    }

                }

                // this applies the selection to the linked table

                if (storeSource != storeTarget) {

                    storeTarget.setSelection(fCollection2);

                }

            } catch (DataException e2) {

                NotificationManager.addError(e2);

                return;

            }

        }

        public void loadFromState(PersistentState state)

            throws PersistenceException {

            this.initialize((TableDocument) state.get("source"),

                (TableDocument) state.get("target"),

                state.getString("fieldSource"), state.getString("fieldTarget"));

            this.setEnabled(state.getBoolean("enabled"));

        }

        public void saveToState(PersistentState state)

            throws PersistenceException {

            state.set("source", this.source);

            state.set("target", this.target);

            state.set("fieldSource", this.getSourceFieldName());

            state.set("fieldTarget", this.getTargetFieldName());

            state.set("enabled", this.getEnabled());

        }

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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 2

 * 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.

 * 

 */

package org.gvsig.app.project.documents.table;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

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

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

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

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.utils.swing.objectSelection.ObjectSelectionModel;

import org.gvsig.utils.swing.objectSelection.SelectionException;

/**

 * @author Fernando Gonz?lez Cort?s

 */

public class FieldSelectionModel implements ObjectSelectionModel {

    // final static private Logger logger =

    // LoggerFactory.getLogger(FieldSelectionModel.class);

    private FeatureStore fs;

    private String msg;

    private int type = DataTypes.INVALID;

    private boolean selectAll = false;

    /**

     * Crea un nuevo FirstFieldSelectionModel.

     * 

     */

    public FieldSelectionModel(FeatureStore fs, String msg, int type) {

        this.fs = fs;

        this.msg = msg;

        this.type = type;

    }

    public FieldSelectionModel(FeatureStore fs, String msg) {

        this(fs, msg, DataTypes.UNKNOWN);

        selectAll = true;

    }

    @SuppressWarnings("unchecked")

    public Object[] getObjects() throws SelectionException {

        List<String> fields = new ArrayList<String>();

        Iterator<FeatureAttributeDescriptor> iterator = null;

        try {

            iterator = fs.getDefaultFeatureType().iterator();

        } catch (DataException e) {

            throw new SelectionException(

                "Can't create iterator for the atribute of feature type", e);

        }

        while (iterator.hasNext()) {

            FeatureAttributeDescriptor descriptor = iterator.next();

            if (type != DataTypes.INVALID) {

                if ((descriptor.getType() == type) || selectAll) {

                    fields.add(descriptor.getName());

                }

            } else {

                fields.add(descriptor.getName());

            }

        }

        return (String[]) fields.toArray(new String[fields.size()]);

    }

    /**

     * @see org.gvsig.utils.swing.objectSelection.ObjectSelectionModel#getMsg()

     */

    public String getMsg() {

        return msg;

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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 2

 * 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.

 * 

 */

package org.gvsig.app.project.documents.table;

import java.awt.Component;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Iterator;

import javax.swing.JOptionPane;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.project.documents.table.gui.CreateNewAttributePanel;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontrol.dal.feature.swing.FeatureTable;

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * Feature Table Operations.

 * 

 * @author Vicente Caballero Navarro

 * 

 */

public class TableOperations {

    public static final int MAX_FIELD_LENGTH = 254;

    private static TableOperations fto = null;

    private FeatureStore featureStore;

    private ArrayList<Feature> selectedFeatures = new ArrayList<Feature>();

    private boolean cutting = false;

    public static TableOperations getInstance() {

        if (fto == null) {

            fto = new TableOperations();

        }

        return fto;

    }

    public void setStore(FeatureStore store) {

        featureStore = store;

    }

    public void copyFeatures() throws DataException {

        cutting = false;

        copy();

    }

    public boolean hasSelection() {

        return !selectedFeatures.isEmpty();

    }

    public void pasteFeatures() throws DataException {

        if (cutting) {

            delete();

            cutting = false;

        }

        Iterator<Feature> features = selectedFeatures.iterator();

        while (features.hasNext()) {

            Feature feature = features.next();

            featureStore.insert(feature.getEditable());

        }

    }

    public void cutFeatures() throws DataException {

        cutting = true;

        copy();

    }

    private void copy() throws DataException {

        DisposableIterator features = null;

        try {

            features =

                ((FeatureSelection) featureStore.getSelection()).fastIterator();

            selectedFeatures.clear();

            while (features.hasNext()) {

                Feature feature = (Feature) features.next();

                selectedFeatures.add(feature);

            }

        } finally {

            if (features != null) {

                features.dispose();

            }

        }

    }

    private void delete() throws DataException {

        Iterator<Feature> features = selectedFeatures.iterator();

        while (features.hasNext()) {

            Feature feature = features.next();

            featureStore.delete(feature);

        }

    }

    public void deleteFeatures() throws DataException {

        DisposableIterator features = null;

        try {

            features =

                ((FeatureSelection) featureStore.getSelection()).fastIterator();

            while (features.hasNext()) {

                Feature feature = (Feature) features.next();

                featureStore.delete(feature);

            }

        } finally {

            if (features != null) {

                features.dispose();

            }

        }

    }

    public void insertNewFeature() throws DataException {

        // if (getModel().getAssociatedTable()!=null){

        // JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),"No se puede a?adir una fila a una tabla asociada a una capa.");

        // return;

        // }

        EditableFeature feature = featureStore.createNewFeature();

        featureStore.insert(feature);

    }

    public void deleteAttributes(FeatureTable table) throws DataException {

        EditableFeatureType eft =

            featureStore.getDefaultFeatureType().getEditable();

        FeatureAttributeDescriptor[] selecteds =

            table.getSelectedColumnsAttributeDescriptor();

        for (int i = 0; i < selecteds.length; i++) {

            eft.remove(selecteds[i].getName());

        }

        featureStore.update(eft);

    }

    public void insertAttributes(FeatureTable table) throws DataException {

        EditableFeatureType eft =

            featureStore.getDefaultFeatureType().getEditable();

        try {

            CreateNewAttributePanel panelNewField =

                new CreateNewAttributePanel();

            EditableFeatureAttributeDescriptor ead =

                panelNewField.loadFieldDescription(eft);

            if (ead == null) {

                return;

            }

            if (ead.getType() == DataTypes.STRING

                && ead.getSize() > MAX_FIELD_LENGTH) {

                NotificationManager.showMessageInfo(

                    PluginServices.getText(this, "max_length_is") + ":"

                        + MAX_FIELD_LENGTH, null);

                ead.setSize(MAX_FIELD_LENGTH);

            }

            PluginServices.getMDIManager().closeWindow(panelNewField);

        } catch (ParseException e2) {

            NotificationManager.addError(e2);

        }

        featureStore.update(eft);

    }

    public void renameAttributes(FeatureTable table) throws DataException {

        EditableFeatureType eft =

            featureStore.getDefaultFeatureType().getEditable();

        FeatureAttributeDescriptor[] selecteds =

            table.getSelectedColumnsAttributeDescriptor();

        for (int i = selecteds.length - 1; i >= 0; i--) {

            String newName =

                JOptionPane.showInputDialog((Component) PluginServices

                    .getMDIManager().getActiveWindow(), PluginServices.getText(

                    this, "please_insert_new_field_name"), selecteds[i]

                    .getName());

            if (newName == null) {

                return;

            }

            if (eft.getIndex(newName) != -1) {

                NotificationManager.showMessageInfo(

                    PluginServices.getText(this, "field_already_exists"), null);

                return;

            }

            FeatureAttributeDescriptor ad =

                (FeatureAttributeDescriptor) eft.get(selecteds[i].getName());

            eft.remove(ad.getName());

            EditableFeatureAttributeDescriptor ead =

                eft.add(newName, ad.getType(), ad.getSize());

            ead.setPrecision(ad.getPrecision());

        }

        featureStore.update(eft);

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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 2

 * 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.

 * 

 */

package org.gvsig.app.project.documents.table;

import java.awt.Component;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import javax.swing.filechooser.FileFilter;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.project.documents.table.gui.CSVSeparatorOptionsPanel;

import org.gvsig.app.project.documents.table.gui.Statistics.MyObjectStatistics;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

/**

 * Class to create dbf and csv files at disk with the statistics group generated

 * from a table.

 * 

 * dbf -> Data Base File

 * csv -> Comma Separated Value

 * 

 * @author ?ngel Fraile Gri??n e-mail: angel.fraile@iver.es

 * 

 */

public class ExportStatisticsFile {

    private static final Logger logger = LoggerFactory

        .getLogger(ExportStatisticsFile.class);

    private String lastPath = null;

    private Hashtable<String, MyFileFilter> dbfExtensionsSupported; // Supported

                                                                    // extensions.

    private Hashtable<String, MyFileFilter> csvExtensionsSupported;

    public ExportStatisticsFile(List<MyObjectStatistics> valores) {

        JFileChooser jfc = new JFileChooser(lastPath);

        jfc.removeChoosableFileFilter(jfc.getAcceptAllFileFilter());

        // Adding required extensions (dbf, csv)

        dbfExtensionsSupported = new Hashtable<String, MyFileFilter>();

        csvExtensionsSupported = new Hashtable<String, MyFileFilter>();

        dbfExtensionsSupported.put("dbf", new MyFileFilter("dbf",

            PluginServices.getText(this, "Ficheros_dbf"), "dbf"));

        csvExtensionsSupported.put("csv", new MyFileFilter("csv",

            PluginServices.getText(this, "Ficheros_csv"), "csv"));

        Iterator<MyFileFilter> iter =

            csvExtensionsSupported.values().iterator();

        while (iter.hasNext()) {

            jfc.addChoosableFileFilter(iter.next());

        }

        iter = dbfExtensionsSupported.values().iterator();

        while (iter.hasNext()) {

            jfc.addChoosableFileFilter(iter.next());

        }

        // Opening a JFileCooser

        if (jfc.showSaveDialog((Component) PluginServices.getMainFrame()) == JFileChooser.APPROVE_OPTION) {

            File endFile = jfc.getSelectedFile();

            if (endFile.exists()) {// File exists in the directory.

                int resp =

                    JOptionPane.showConfirmDialog(

                        (Component) PluginServices.getMainFrame(),

                        PluginServices.getText(this,

                            "fichero_ya_existe_seguro_desea_guardarlo")

                            + "\n"

                            + endFile.getAbsolutePath(), PluginServices

                            .getText(this, "guardar"),

                        JOptionPane.YES_NO_OPTION);// Informing the user

                if (resp != JOptionPane.YES_OPTION) {// cancel pressed.

                    return;

                }

            }// end if exits.

            MyFileFilter filter = (MyFileFilter) jfc.getFileFilter();// dbf, csv

            endFile = filter.normalizeExtension(endFile);// "name" + "." +

                                                         // "dbf", "name" + "."

                                                         // + "csv"

            if (filter.getExtensionOfAFile(endFile).toLowerCase()

                .compareTo("csv") == 0) { // csv file

                exportToCSVFile(valores, endFile); // export to csv format

            } else

                if (filter.getExtensionOfAFile(endFile).toLowerCase()

                    .compareTo("dbf") == 0) {// dbf file

                    try {

                        exportToDBFFile(valores, endFile);

                    } catch (Exception e) {

                        NotificationManager.addError(e);

                    } // export to dbf format

                }

        }// end if aprove option.

    }

    /**

     * Creating cvs format file with the statistics.

     * Option to select the two columns separator.

     * 

     * Example with semicolon: Name;data\n

     * Name2;data2\n

     * 

     * @param valores

     *            - Pairs: String name (key) + Double value (

     * @param endFile

     *            - File to write the information

     */

    private void exportToCSVFile(List<MyObjectStatistics> valores, File endFile) {

        try {

            CSVSeparatorOptionsPanel csvSeparatorOptions =

                new CSVSeparatorOptionsPanel();

            PluginServices.getMDIManager().addWindow(csvSeparatorOptions);

            String separator = csvSeparatorOptions.getSeparator();

            if (separator != null) {

                FileWriter fileCSV = new FileWriter(endFile);

                fileCSV.write(PluginServices.getText(this, "Nombre")

                    + separator + PluginServices.getText(this, "Valor") + "\n");

                Iterator<MyObjectStatistics> iterador = valores.listIterator();

                while (iterador.hasNext()) {// Writing value,value\n

                    MyObjectStatistics data = iterador.next();

                    fileCSV.write(data.getKey() + separator + (data.getValue())

                        + "\n");

                }

                fileCSV.close();

                JOptionPane.showMessageDialog(

                    null,

                    PluginServices.getText(this, "fichero_creado_en") + " "

                        + endFile.getAbsolutePath(),

                    PluginServices.getText(this, "fichero_creado_en_formato")

                        + " csv "

                        + PluginServices.getText(this, "mediante_el_separador")

                        + " \"" + separator + "\"",

                    JOptionPane.INFORMATION_MESSAGE);// Informing the user

            } else {

                return;

            }

        } catch (IOException e) {// Informing the user

            logger.error("Error exportando a formato csv");

            JOptionPane.showMessageDialog(

                null,

                PluginServices.getText(this,

                    "Error_exportando_las_estadisticas")

                    + " "

                    + endFile.getAbsolutePath(), PluginServices.getText(this,

                    "Error"), JOptionPane.ERROR_MESSAGE);

        }

    }

    public void exportToDBFFile(List<MyObjectStatistics> valores, File endFile)

        throws DataException, ValidateDataParametersException {

        DataManager datamanager = DALLocator.getDataManager();

        //

        // Averigua el proveedor en funcion del fichero

        // preguntandoselo al FilesystemServerExplorer.

        DataServerExplorerParameters no_params =

            (DataServerExplorerParameters) datamanager

                .createServerExplorerParameters(FilesystemServerExplorer.NAME);

        FilesystemServerExplorer explorer =

            (FilesystemServerExplorer) datamanager.openServerExplorer(

                FilesystemServerExplorer.NAME, no_params // empty params

                );

        String providerName = explorer.getProviderName(endFile);

        try {

            DataStoreParameters dsp =

                explorer.createStoreParameters(endFile, providerName);

            NewFeatureStoreParameters parameters =

                (NewFeatureStoreParameters) datamanager

                    .createNewStoreParameters(FilesystemServerExplorer.NAME,

                        providerName);

            parameters.delegate(dsp);

            EditableFeatureType type =

                parameters.getDefaultFeatureType(); // .getEditable();

            type.add(PluginServices.getText(this, "Nombre"), DataTypes.STRING,

                50);

            type.add(PluginServices.getText(this, "Valor"), DataTypes.DOUBLE,

                100).setPrecision(25);

            parameters.setDefaultFeatureType(type);

            datamanager.newStore(FilesystemServerExplorer.NAME, providerName,

                parameters, true);

            FeatureStore target =

                (FeatureStore) datamanager.openStore(providerName, parameters);

            target.edit(FeatureStore.MODE_APPEND);

            Iterator<MyObjectStatistics> iterador = valores.listIterator();

            while (iterador.hasNext()) {

                MyObjectStatistics data = iterador.next();

                EditableFeature ef = target.createNewFeature().getEditable();

                ef.set(PluginServices.getText(this, "Nombre"), data.getKey());

                ef.set(PluginServices.getText(this, "Valor"), data.getValue());

                target.insert(ef);

            }

            target.finishEditing();

            target.dispose();

            JOptionPane.showMessageDialog(

                (Component) PluginServices.getMainFrame(),

                PluginServices.getText(this, "fichero_creado_en") + " "

                    + endFile.getAbsolutePath(),

                PluginServices.getText(this, "fichero_creado_en_formato")

                    + " dbf", JOptionPane.INFORMATION_MESSAGE);// Informing the

                                                               // user

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

/**

 * @author ?ngel Fraile Gri??n e-mail: angel.fraile@iver.es

 * 

 *         Class to work with the file extensions.

 */

class MyFileFilter extends FileFilter {

    private String[] extensiones = new String[1];

    private String description;

    private boolean dirs = true;

    private String info = null;

    public MyFileFilter(String[] ext, String desc) {

        extensiones = ext;

        description = desc;

    }

    public MyFileFilter(String[] ext, String desc, String info) {

        extensiones = ext;