Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.awt.Dimension;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import javax.swing.ImageIcon;

import javax.swing.JOptionPane;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.addlayer.AddLayerDialog;

import org.gvsig.app.gui.WizardPanel;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

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

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

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

import org.gvsig.app.project.documents.actions.CopyDocumentAction;

import org.gvsig.app.project.documents.actions.CutDocumentAction;

import org.gvsig.app.project.documents.actions.PasteDocumentAction;

import org.gvsig.app.project.documents.gui.IDocumentWindow;

import org.gvsig.app.project.documents.gui.WindowLayout;

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

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

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

import org.gvsig.fmap.dal.AbstractStoresRepository;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.swing.FilesystemExplorerWizardPanel;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.persistence.PersistenceManager;

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

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

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.util.Invocable;

import org.gvsig.tools.util.MappedIterator;

import org.gvsig.tools.util.UnmodifiableBasicSet;

import org.slf4j.LoggerFactory;

/**

 * Factory of Table.

 * 

 * @author gvSIG Tem

 * 

 */

@SuppressWarnings("UseSpecificCatch")

public class TableManager extends AbstractDocumentManager {

    final static private org.slf4j.Logger LOGGER = LoggerFactory.getLogger(TableDocument.class);

    private static class TableDocumentStoresRepository extends AbstractStoresRepository {

        public TableDocumentStoresRepository(String name, String label) {

            super(name, label);

        }

        @Override

        protected DataStoreParameters getMyParameters(String name) {

            Project project = ProjectManager.getInstance().getCurrentProject();

            TableDocument tableDoc = (TableDocument) project.getDocument(name, TYPENAME);

            if( tableDoc==null || tableDoc.getFeatureStore()==null) {

                return null;

            }

            return tableDoc.getFeatureStore().getParameters();

        }

        @Override

        protected FeatureType getMyFeatureType(String name) {

            Project project = ProjectManager.getInstance().getCurrentProject();

            TableDocument tableDoc = (TableDocument) project.getDocument(name, TYPENAME);

            if( tableDoc==null || tableDoc.getFeatureStore()==null) {

                return null;

            }

            return tableDoc.getFeatureStore().getDefaultFeatureTypeQuietly();

        }

        @Override

        protected boolean isEmptyMyRepository() {

            Project project = ProjectManager.getInstance().getCurrentProject();

            return project.getDocuments(TableManager.TYPENAME).isEmpty();

        }

        @Override

        protected int getMySize() {

            Project project = ProjectManager.getInstance().getCurrentProject();

            int sz = project.getDocuments(TableManager.TYPENAME).size();

            return sz;

        }

        @Override

        protected UnmodifiableBasicSet<String> getMyKeySet() {

            Project project = ProjectManager.getInstance().getCurrentProject();

            final List<Document> docs = project.getDocuments(TableManager.TYPENAME);

            if( docs==null ) {

                return UnmodifiableBasicSet.EMPTY_UNMODIFIABLEBASICSET;

            }

            UnmodifiableBasicSet<String> x = new UnmodifiableBasicSet<String>() {

                @Override

                public boolean isEmpty() {

                    return docs.isEmpty();

                }

                @Override

                public int size() {

                    return docs.size();

                }

                @Override

                public Iterator<String> iterator() {

                    return new MappedIterator<>(docs.iterator(), (Document t) -> {

                        if( t==null ) {

                            return null;

                        }

                        return ((TableDocument)t).getName();

                    });

                }

            };

            return x;

        }

        @Override

        public Iterator<DataStoreParameters> iterator() {

            Project project = ProjectManager.getInstance().getCurrentProject();

            List<Document> docs = project.getDocuments(TableManager.TYPENAME);

            if( docs==null ) {

                return Collections.EMPTY_LIST.iterator();

            }

            return new MappedIterator<>(docs.iterator(), (Document t) -> {

                if( t==null || ((TableDocument)t).getFeatureStore()==null ) {

                    return null;

                }

                return ((TableDocument)t).getFeatureStore().getParameters();

            });

        }

        @Override

        public void add(String name, DataStoreParameters parameters) {

            Project project = ProjectManager.getInstance().getCurrentProject();

            TableDocument doc = (TableDocument) ProjectManager.getInstance().createDocument(TYPENAME);

            doc.setName(name);

            //FIXME:

            DataManager dataManager = DALLocator.getDataManager();

            FeatureStore store;

            try {

                store = (FeatureStore) dataManager.openStore(

                        parameters.getProviderName(),

                        parameters

                );

                doc.setStore(store);

                project.addDocument(doc);

            } catch (InitializeException | ProviderNotRegisteredException | ValidateDataParametersException ex) {

                LOGGER.warn("Can't add table to project", ex);

            }

        }

        @Override

        public void add(String name, FeatureStore store) {

            Project project = ProjectManager.getInstance().getCurrentProject();

            TableDocument doc = (TableDocument) ProjectManager.getInstance().createDocument(TYPENAME);

            doc.setName(name);

            doc.setStore(store);

            project.addDocument(doc);

        }

        @Override

        public DataStore getStore(String name) {

            Project project = ProjectManager.getInstance().getCurrentProject();

            TableDocument tableDoc = (TableDocument) project.getDocument(name, TYPENAME);

            if( tableDoc==null || tableDoc.getFeatureStore()==null) {

                return null;

            }

            FeatureStore store = tableDoc.getFeatureStore();

            DisposeUtils.bind(store);

            return store;

        }

    }

    public static final String PERSISTENCE_TABLE_DOCUMENT_DEFINITION_NAME =

        "TableDocument";

    public static final String PERSISTENCE_TABLELINK_DEFINITION_NAME =

        "TableLink";

    public static String TYPENAME = "project.document.table";

    private DynStruct persistenceDefinition = null;

    @Override

    public ImageIcon getIcon() {

            return IconThemeHelper.getImageIcon("document-table-icon");

    }

    @Override

    public ImageIcon getIconSelected() {

        return IconThemeHelper.getImageIcon("document-table-icon-sel");

    }

    @Override

    public String getTitle() {

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

    }

    @Override

    public String getTypeName() {

        return TYPENAME;

    }

    @Override

    public int getPriority() {

        return 1;

    }

    @Override

    public Iterator<? extends Document> createDocumentsByUser() {

        return this.createDocumentsByUser(null);

    }

    @Override

    public Iterator<? extends Document> createDocumentsByUser(Invocable whenDocumentsLoaded) {

        AddLayerDialog fopen = null;

        try {

            fopen =

                new AddLayerDialog(PluginServices.getText(this, "Nueva_tabla"));

            List<WizardPanel> wizards =

                ApplicationLocator.getManager().getWizardPanels();

            Dimension preferredSize = fopen.getPreferredSize();

            WizardPanel panel;

            Iterator<WizardPanel> iter = wizards.iterator();

            while (iter.hasNext()) {

                panel = iter.next();

                panel.initWizard();

                Dimension dim = panel.getPreferredSize();

                if( dim.height>preferredSize.height ) {

                    preferredSize.height = dim.height;

                }

                if( dim.width>preferredSize.width ) {

                    preferredSize.width = dim.width;

                }

                fopen.addWizardTab(panel.getTabName(), panel);

            }

            preferredSize.height += ToolsSwingUtils.rows2px(4);

            preferredSize.width += ToolsSwingUtils.cols2px(2);

            fopen.setPreferredSize(preferredSize);

            ToolsSwingUtils.ensureRowsCols(fopen, -1, -1, 30, 100);

            PluginServices.getMDIManager().addWindow(fopen);

            if (fopen.isAccepted()) {

                WizardPanel selectedPanel = (WizardPanel) fopen.getSelectedTab();

                if( whenDocumentsLoaded==null ) {

                    List<TableDocument> docs = (List) selectedPanel.executeWizard();

                    this.checkDocuments(docs);

                    return docs.iterator();

                }

                Thread task = new Thread(() -> {

                    List<TableDocument> docs = (List) selectedPanel.executeWizard();

                    checkDocuments(docs);

                    whenDocumentsLoaded.call(docs.iterator());

                }, "DocumentTableLoader");

                task.start();

                return Collections.EMPTY_LIST.iterator();

            }

        } catch (Exception e) {

            NotificationManager.addError(e);

        } finally {

            if (fopen != null) {

                fopen.dispose();

                fopen = null;

            }

        }

        return null;

    }

    private void checkDocuments(List<TableDocument> docs) {

        if( docs==null ) {

            return;

        }

        for (TableDocument doc : docs) {

            try {

                FeatureStore store = ((TableDocument)doc).getDataStore();

                FeatureType type = store.getDefaultFeatureType();

                if( ! type.supportReferences() ) {

                    I18nManager i18n = ToolsLocator.getI18nManager();

                    ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                    dialogs.messageDialog(

                            "\""+ doc.getName() + "\"\n"+

                            i18n.getTranslation("_The_table_has_no_primary_key_or_OID") +"\n" +

                                   i18n.getTranslation("_Many_features_selection_deletion_modification_will_not_be_available_as_they_require_it_for_proper_operation"),

                            null, 

                            i18n.getTranslation("_Warning"),

                            JOptionPane.WARNING_MESSAGE, 

                            "TableDoNotSupportReferences"

                   );

                }

            } catch (Exception ex) {

            }

        }        

    }

    @Override

    public AbstractDocument createDocumentByUser() {

        return (AbstractDocument) createDocumentsByUser().next();

    }

    /**

     * Registers in the points of extension the Factory with alias.

     * 

     */

    public static void register() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        TableManager factory = new TableManager();

        // A?adimos nuestra extension para el tratamiento de la apertura de

        // ficheros

        // dentro de gvSIG

        ToolsLocator.getExtensionPointManager().add("FileTableOpenDialog", "")

            .append("FileOpenTable", "", FilesystemExplorerWizardPanel.class);

                IconThemeHelper.registerIcon("document", "document-table-icon", TableManager.class);

        IconThemeHelper.registerIcon("document", "document-table-icon-sel", TableManager.class);

        IconThemeHelper.registerIcon("document", "document-table-icon-small", TableManager.class);

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        manager.registerFactory(factory);

        if (factory.persistenceDefinition == null) {

            DynObjectManager dynman = ToolsLocator.getDynObjectManager();

            factory.persistenceDefinition =

                dynman.createDynClass(PersistenceManager.PERSISTENCE_NAMESPACE,

                    PERSISTENCE_TABLE_DOCUMENT_DEFINITION_NAME,

                    "Table document Persistence definition");

            factory.persistenceDefinition.extend(manager

                .getDefinition(AbstractDocument.PERSISTENCE_DEFINITION_NAME));

            factory.persistenceDefinition.addDynFieldObject("store")

                .setClassOfValue(FeatureStore.class).setMandatory(true);

            factory.persistenceDefinition.addDynFieldString("featureTypeId")

                .setMandatory(false);

            factory.persistenceDefinition.addDynFieldArray("attributeNames")

                .setClassOfItems(String.class).setMandatory(false);

            factory.persistenceDefinition.addDynFieldObject("associatedLayer")

                .setClassOfValue(FLyrVect.class).setMandatory(false);

            factory.persistenceDefinition.addDynFieldObject("query")

                .setClassOfValue(FeatureQuery.class).setMandatory(false);

            factory.persistenceDefinition.addDynFieldObject("baseFilter")

                .setClassOfValue(Evaluator.class).setMandatory(false);

            factory.persistenceDefinition.addDynFieldObject("baseOrder")

                .setClassOfValue(FeatureQueryOrder.class).setMandatory(false);

            factory.persistenceDefinition.addDynFieldList("linkTable")

                .setClassOfItems(TableLink.class).setMandatory(false);          

            factory.persistenceDefinition.addDynFieldMap("patterns")

                .setClassOfItems(String.class).setMandatory(false);          

        }

        //Register also the TableLink

        if (manager.getDefinition(PERSISTENCE_TABLELINK_DEFINITION_NAME) == null){

            DynStruct tableLinkDefinition =

                manager.addDefinition(TableLink.class,

                    PERSISTENCE_TABLELINK_DEFINITION_NAME,

                    "TableLink Persistence definition", null, null);                 

            tableLinkDefinition.addDynFieldObject("source")

                .setClassOfValue(TableDocument.class).setMandatory(true);

            tableLinkDefinition.addDynFieldObject("target")

                .setClassOfValue(TableDocument.class).setMandatory(true);

            tableLinkDefinition.addDynFieldString("fieldSource").setMandatory(true);

            tableLinkDefinition.addDynFieldString("fieldTarget").setMandatory(true);

            tableLinkDefinition.addDynFieldBoolean("enabled").setMandatory(true);

        }  

        ProjectManager.getInstance().registerDocumentFactory(factory);

        ProjectManager.getInstance().registerDocumentAction(TYPENAME,new CopyDocumentAction());

        ProjectManager.getInstance().registerDocumentAction(TYPENAME,new CutDocumentAction());

        ProjectManager.getInstance().registerDocumentAction(TYPENAME,new PasteDocumentAction());

        DataManager dataManager = DALLocator.getDataManager();

        dataManager.getStoresRepository().addRepository(

                new TableDocumentStoresRepository(

                    "PROJECT_TABLES",

                    i18n.getTranslation("_Project_tables")

            )

        );

    }

    /**

     * Create a new table document.

     * 

     * @return TableDocument.

     */

    @Override

    public AbstractDocument createDocument() {

        AbstractDocument doc = new TableDocument(this);

        if( this.notifyObservers(NOTIFY_AFTER_CREATEDOCUMENT,doc).isCanceled() ) {

            return null;

        }

            return doc;        

    }

    @Override

    public Class<? extends IDocumentWindow> getMainWindowClass() {

        return FeatureTableDocumentPanel.class;

    }

    @Override

    public IWindow getMainWindow(Document doc, WindowLayout layout) {

       IDocumentWindow win = (IDocumentWindow) super.getMainWindow(doc, layout);

        if (win == null) {

            try {

                win = (IDocumentWindow) this.createDocumentWindow(doc);

            } catch(Throwable t){

            }

            if(win == null){

                try {

                    ((TableDocument)doc).getFeatureStore().refresh();

                } catch (DataException ex) {

                    throw new RuntimeException(ex);

                }

                win = (IDocumentWindow) this.createDocumentWindow(doc);

            }

            if (layout != null && win != null) {

                win.setWindowLayout(layout);

            }

        }

        if( this.notifyObservers(NOTIFY_AFTER_GETMAINWINDOW,win).isCanceled() ) {

            return null;

        }

        return win;

    }

    @Override

    public IWindow getPropertiesWindow(Document doc) {

        IWindow win = super.getPropertiesWindow(doc);

        if( win == null ) {

            win = new TableProperties((TableDocument) doc);

        }

        if( this.notifyObservers(NOTIFY_AFTER_GETPROPERTIESWINDOW,win).isCanceled() ) {

            return null;

        }

        return win;        

    }

    @Override

    protected Class<? extends Document> getDocumentClass() {

        return TableDocument.class;

    }

    @Override

    public DynStruct getDefinition(String className) {

        if (this.persistenceDefinition.getName().equalsIgnoreCase(className)) {

            return this.persistenceDefinition;

        }

        if (this.persistenceDefinition.getFullName()

            .equalsIgnoreCase(className)) {

            return this.persistenceDefinition;

        }

        if (this.getDocumentClass().getName().equals(className)) {

            return this.persistenceDefinition;

        }

        return null;

    }

    @Override

    public boolean manages(Object object) {

        return object instanceof TableDocument;

    }

    public TableDocument getTableDocument(VectorLayer layer) {

        if (layer == null) {

            return null;

        }

        List<Document> tableDocs =

            getProject().getDocuments(TableManager.TYPENAME);

        for (Document document : tableDocs) {

            if (layer == ((TableDocument) document).getAssociatedLayer()) {

                return (TableDocument) document;

            }

        }

        return null;

    }

    public void removeTableDocument(VectorLayer layer) {

        TableDocument doc = getTableDocument(layer);

        // Only remove it if it exists

        if (doc != null) {

            PluginServices.getMDIManager().closeSingletonWindow(doc);

            getProject().remove(doc);

        }

    }

    private Project getProject() {

        return ProjectManager.getInstance().getCurrentProject();

    }

}