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.extension;

import java.awt.Dimension;

import java.awt.GridBagConstraints;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.IOException;

import java.nio.charset.StandardCharsets;

import java.util.Collections;

import java.util.Iterator;

import java.util.Objects;

import javax.swing.AbstractAction;

import javax.swing.Action;

import static javax.swing.Action.ACTION_COMMAND_KEY;

import static javax.swing.Action.NAME;

import javax.swing.JOptionPane;

import javax.swing.event.ChangeEvent;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.math.NumberUtils;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

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

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

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

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

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

import org.gvsig.configurableactions.ConfigurableActionsMamager;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.DataTypes;

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

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

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.FeatureStoreProviderFactory;

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

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

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

import org.gvsig.fmap.dal.swing.featuretype.FeatureTypeAttributePanel;

import org.gvsig.fmap.dal.swing.featuretype.FeatureTypePanel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.i18n.I18nManager;

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

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

import org.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.tools.util.ToolsUtilLocator;

/**

 * Extensi?n que abre la ventana para cambiar la configuraci?n de la estructura

 * de la tabla.

 *

 */

@SuppressWarnings("UseSpecificCatch")

public class TableEditAttributes extends Extension {

    @Override

    public void initialize() {

        IconThemeHelper.registerIcon("action", "table-column-manager", this);

        IconThemeHelper.registerIcon("action", "table-add-column", this);

    }

    @Override

    public void postInitialize() {

        ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        cfgActionsManager.addConfigurableAction(FeatureTypePanel.CONFIGURABLE_PANEL_ID, new ShowAsTableAction());

        cfgActionsManager.addConfigurableAction(FeatureTypePanel.CONFIGURABLE_PANEL_ID, new WriteToDALFileAction());

        cfgActionsManager.addConfigurableAction(FeatureTypePanel.CONFIGURABLE_PANEL_ID, new WriteToDALFileHexAction());

    }

    @Override

    public boolean canQueryByAction() {

        return true;

    }

    @Override

    public void execute(String s) {

        final I18nManager i18n = ToolsLocator.getI18nManager();

        final WindowManager_v2 winManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        final DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        final DataManager dataMamager = DALLocator.getDataManager();

        final ApplicationManager application = ApplicationLocator.getManager();

        TableDocument tabledoc = (TableDocument) application.getActiveDocument(TableManager.TYPENAME);

        if (tabledoc == null) {

            return;

        }

//        final FeatureStore featureStore = tabledoc.getStore();

        final FeatureTableDocumentPanel tablePanel = (FeatureTableDocumentPanel) tabledoc.getMainComponent();

        final FeatureStore featureStore = tablePanel.getFeatureStore();

        if ("table-column-manager".equalsIgnoreCase(s)) {

            try {

                ApplicationManager aplication = ApplicationLocator.getManager();

                final FeatureType featureType = featureStore.getDefaultFeatureType();

                final EditableFeatureType editableFeatureType = featureType.getEditable();

                final FeatureTypePanel panel = dataSwingManager.createFeatureTypePanel();

                ViewDocument viewdoc = (ViewDocument) application.getCurrentProject().getFirstDocument(ViewDocument.class);

                if( viewdoc != null ) {

                    panel.setDefaultProjection(viewdoc.getProjection());

                }

                final ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

                ConfigurableActionsMamager.ActionsController actionController = 

                        cfgActionsManager.getConfigurableActionsController(

                                FeatureTypePanel.CONFIGURABLE_PANEL_ID

                        );

                actionController.addAction(new WriteOpenDataStoreParametersToFileHex(featureStore.getParameters()));

                panel.put(editableFeatureType);

                int mode = featureStore.isEditing()

                        ? FeatureTypePanel.MODE_EDIT_ALL

                        : FeatureTypePanel.MODE_EDIT_ONLY_METADATA;

                DataStoreProviderFactory factory = featureStore.getProviderFactory();

                if (factory instanceof FeatureStoreProviderFactory) {

                    FeatureStoreProviderFactory ffactory = (FeatureStoreProviderFactory) factory;

                    if (ffactory.allowEditableFeatureType() == FeatureStoreProviderFactory.NO) {

                        mode = FeatureTypePanel.MODE_SHOW_ONLY;

                    }

                }

                String extraMsg = Objects.toString(featureStore.getProperty(DataManager.DAL_FEATURETYPE_MODE_EDIT_MSG),null);

                if( StringUtils.isNotBlank(extraMsg) ) {

                    extraMsg = "\n"+i18n.getTranslation(extraMsg);

                } else {

                    extraMsg = "";

                }

                switch(mode) {

                    case FeatureTypePanel.MODE_SHOW_ONLY:

                        break;

                    case FeatureTypePanel.MODE_EDIT_ONLY_METADATA:

                        int newmode = NumberUtils.toInt(Objects.toString(

                                    featureStore.getProperty(DataManager.DAL_FEATURETYPE_MODE_EDIT)

                                ),

                                mode

                        );

                        switch(newmode) {

                            case FeatureTypePanel.MODE_SHOW_ONLY:

                                mode = newmode;

                                break;

                            case FeatureTypePanel.MODE_EDIT_ONLY_METADATA:

                                break;

                            case FeatureTypePanel.MODE_EDIT_ALL:

                                mode = FeatureTypePanel.MODE_EDIT_ONLY_METADATA;

                                break;

                        }   

                        break;

                    case FeatureTypePanel.MODE_EDIT_ALL:

                        mode = NumberUtils.toInt(Objects.toString(

                                featureStore.getProperty(DataManager.DAL_FEATURETYPE_MODE_EDIT)

                            ),

                            mode

                        );

                        break;

                }

                switch(mode) {

                    case FeatureTypePanel.MODE_SHOW_ONLY:

                        aplication.messageDialog(

                                i18n.getTranslation("_The_table_dont_allow_edit_columns")+extraMsg,

                                i18n.getTranslation("_Warning"),

                                JOptionPane.INFORMATION_MESSAGE);    

                        break;

                    case FeatureTypePanel.MODE_EDIT_ONLY_METADATA:

                        if( featureStore.isEditing() ) {

                            aplication.messageDialog(

                                    i18n.getTranslation("_The_table_is_not_in_edit_mode")+

                                            "\n" +

                                            i18n.getTranslation("_You_can_only_add_virtual_fields_and_modify_some_table_data_metadata") +

                                            extraMsg,

                                    i18n.getTranslation("_Warning"),

                                    JOptionPane.INFORMATION_MESSAGE);    

                        } else {

                            aplication.messageDialog(

                                    i18n.getTranslation("_The_table_only_allow_edit_metadata_of_columns")+

                                            "\n" +

                                            i18n.getTranslation("_You_can_only_add_virtual_fields_and_modify_some_table_data_metadata") +

                                            extraMsg,

                                    i18n.getTranslation("_Warning"),

                                    JOptionPane.INFORMATION_MESSAGE);    

                        }

                        break;

                    case FeatureTypePanel.MODE_EDIT_ALL:

                        if( StringUtils.isNotBlank(extraMsg) ) {

                            aplication.messageDialog(

                                    extraMsg,

                                    i18n.getTranslation("_Warning"),

                                    JOptionPane.INFORMATION_MESSAGE);    

                        }

                        break;

                }   

                panel.setMode(mode);

                String title = application.makeTitle("_Column_manager", tabledoc.getName(), featureStore.getName());

                final Dialog dialog = winManager.createDialog(

                        panel.asJComponent(),

                        title,

                        null,

                        WindowManager_v2.BUTTONS_OK_CANCEL

                );

                if( mode == FeatureTypePanel.MODE_SHOW_ONLY) {

                    dialog.setButtonEnabled(WindowManager_v2.BUTTON_OK, false);

                }

                panel.addChangeListener((ChangeEvent e) -> {

                  if (panel.isEditing()) {

                    dialog.setButtonEnabled(WindowManager_v2.BUTTON_OK, false);

                  } else {

                    dialog.setButtonEnabled(WindowManager_v2.BUTTON_OK, true);

                  }

                });

                dialog.addActionListener((ActionEvent e) -> {

                  if (dialog.getAction() != WindowManager_v2.BUTTON_OK) {

                    return;

                  }

                  try {

                    panel.fetch(editableFeatureType);

                    FeatureQuery query = tablePanel.getTablePanel().getFeatureQuery();

                    if (query != null) {

                        FeatureQueryOrder order = query.getOrder();

                        if (order != null) {

                            Iterator<FeatureQueryOrder.FeatureQueryOrderMember> it = order.iterator();

                            while (it.hasNext()) {

                                FeatureQueryOrder.FeatureQueryOrderMember orderMember = it.next();

                                String attrName = orderMember.getAttributeName();

                                if(editableFeatureType.getAttributeDescriptor(attrName)==null && !orderMember.hasEvaluator()){

//                                    int n = ToolsSwingLocator.getThreadSafeDialogsManager().confirmDialog(

//                                            i18n.getTranslation(

//                                                    "_You_are_trying_to_remove_the_column_XcolumnNameX_that_is_being_sorted_by_Do_you_wish_to_continue",

//                                                    new String[]{attrName}

//                                            ),

//                                            i18n.getTranslation("_Rename_column"),

//                                            JOptionPane.OK_CANCEL_OPTION,

//                                            JOptionPane.QUESTION_MESSAGE,

//                                            "_You_are_trying_to_remove_the_column_XcolumnNameX_that_is_being_sorted_by_Do_you_wish_to_continue"

//                                    );

//                                    if (n != JOptionPane.OK_OPTION) {

//                                        return;

//                                    }

                                    it.remove();

                                }

                            }

                        }

                    }

                    featureStore.update(editableFeatureType);

                    dataMamager.clearAvailableValuesCache();

                  } catch (Exception ex) {

                    logger.warn("Problems updating featuretype.", ex);

                    aplication.messageDialog(

                            i18n.getTranslation("_Problems_updating_columns_information") +

                                    "\n" +

                                    i18n.getTranslation("_see_error_log_for_more_information"),

                            i18n.getTranslation("_Warning"),

                            JOptionPane.WARNING_MESSAGE);    

                  }

                });

                Dimension screensize = ApplicationLocator.getApplicationManager().getUIManager().getInternalSize();

                Dimension panelsize = panel.asJComponent().getPreferredSize();

                ToolsSwingUtils.ensureHeightWitdh(

                        panel.asJComponent(), 

                        Math.max(3*(screensize.height/4), panelsize.height),

                        Math.max(2*(screensize.width/4), panelsize.width), 

                        7*(screensize.height/8), 

                        3*(screensize.width/4)

                );                    

                dialog.show(WindowManager.MODE.WINDOW,

                        Collections.singletonMap("align", GridBagConstraints.CENTER)

                );

            } catch (Exception ex) {

                logger.warn("Problems show FeatureTypePanel.", ex);

            }

        } else if ("table-add-column".equals(s)) {

            try {

                final FeatureType featureType = featureStore.getDefaultFeatureType();

                final FeatureTypeAttributePanel panel = dataSwingManager.createFeatureTypeAttributePanel();

                panel.clean();

                panel.setNameAsNew(featureType);

                panel.setMode(FeatureTypePanel.MODE_EDIT_ALL);

                final Dialog dialog = winManager.createDialog(

                        panel.asJComponent(),

                        i18n.getTranslation("_New_field") + " - " + tabledoc.getName(),

                        null,

                        WindowManager_v2.BUTTONS_OK_CANCEL

                );

                dialog.setAutoclose(false);

                dialog.addActionListener(new ActionListener() {

                    @Override

                    public void actionPerformed(ActionEvent e) {

                        if (dialog.getAction() != WindowManager_v2.BUTTONS_OK) {

                            panel.asJComponent().setVisible(false);

                            return;

                        }

                        if (!featureStore.isEditing()) {

                            panel.asJComponent().setVisible(false);

                            return;

                        }

                        try {

                            EditableFeatureType editableFeatureType = featureType.getEditable();

                            EditableFeatureAttributeDescriptor descriptor = editableFeatureType.add(

                                    panel.getName(),

                                    DataTypes.STRING

                            );

                            if(panel.fetch(descriptor)!=null) {

                                featureStore.update(editableFeatureType);

                                panel.asJComponent().setVisible(false);

                            };

                        } catch (Exception ex) {

                            logger.warn("Problems updating featuretype.", ex);

                        }

                    }

                });

                dialog.show(WindowManager.MODE.WINDOW,

                        Collections.singletonMap("align", GridBagConstraints.CENTER)

                );

            } catch (Exception ex) {

                logger.warn("Problems show FeatureTypeAttributePanel.", ex);

            }

        }

    }

    public static class WriteToDALFileAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public WriteToDALFileAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Save_as_DAL_file"));

            this.putValue(ACTION_COMMAND_KEY, "WriteToDALFile");

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            FeatureTypePanel panel = (FeatureTypePanel) ae.getSource();

            EditableFeatureType featureType = panel.fetch(null);

          ApplicationManager application = ApplicationLocator.getApplicationManager();

          I18nManager i18n = ToolsLocator.getI18nManager();

          FoldersManager foldersManager = ToolsLocator.getFoldersManager();

          File[] f = application.showSaveFileDialog(

                  i18n.getTranslation("_Save_as_DAL_file"), 

                  foldersManager.getLastPath("SaveAsDALFile", null)

          );

          if( f==null || f.length==0 ) {

            return;

          }

        foldersManager.setLastPath("SaveAsDALFile", f[0].getParentFile());

        featureType.writeAsDALFile(f[0]);

        }

    }

    public static class WriteToDALFileHexAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public WriteToDALFileHexAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Save_as_DAL_file_hex"));

            this.putValue(ACTION_COMMAND_KEY, "WriteToDALFileHex");

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            FeatureTypePanel panel = (FeatureTypePanel) ae.getSource();

            EditableFeatureType featureType = panel.fetch(null);

            ApplicationManager application = ApplicationLocator.getApplicationManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            FoldersManager foldersManager = ToolsLocator.getFoldersManager();

            File[] f = application.showSaveFileDialog(

                    i18n.getTranslation("_Save_as_DAL_file_hex"),

                    foldersManager.getLastPath("SaveAsDALFileHex", null)

            );

            if (f == null || f.length == 0) {

                return;

            }

            foldersManager.setLastPath("SaveAsDALFileHex", f[0].getParentFile());

            featureType.writeAsDALFile(f[0], "hex");

        }

    }

    public static class WriteOpenDataStoreParametersToFileHex extends AbstractAction {

        private DataStoreParameters params;

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public WriteOpenDataStoreParametersToFileHex(DataStoreParameters params) {

            this.params = params;

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Save_OpenDataStoreParameters_hex"));

            this.putValue(ACTION_COMMAND_KEY, "WriteOpenDataStoreParametersToFileHex");

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            ApplicationManager application = ApplicationLocator.getApplicationManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            FoldersManager foldersManager = ToolsLocator.getFoldersManager();

            File[] f = application.showSaveFileDialog(

                    i18n.getTranslation("_Save_OpenDataStoreParameters_hex"),

                    foldersManager.getLastPath("WriteOpenDataStoreParametersToFileHex", null)

            );

            if (f == null || f.length == 0) {

                return;

            }

            foldersManager.setLastPath("WriteOpenDataStoreParametersToFileHex", f[0].getParentFile());

            try {

                FileUtils.write(

                        f[0],

                        Hex.encodeHexString(this.params.toByteArray()),

                        StandardCharsets.UTF_8

                );

            } catch (IOException ex) {

                logger.warn("Can't save parameters to file '"+Objects.toString(f[0]), ex);

                application.messageDialog(

                        i18n.getTranslation("_Cant_save_parameters_to_file")+

                            "\n"+

                            i18n.getTranslation("_See_log_for_details"), 

                        i18n.getTranslation("_Save_parameters_as_hex"), 

                        JOptionPane.WARNING_MESSAGE

                );

            }

        }

    }

    public static class ShowAsTableAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public ShowAsTableAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Show_as_table"));

            this.putValue(ACTION_COMMAND_KEY, "ShowAsTable");

            this.putValue(

                    Action.SMALL_ICON,

                    ToolsSwingLocator.getIconThemeManager().getCurrent().get("layer-show-attributes-table")

            );

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            FeatureTypePanel panel = (FeatureTypePanel) ae.getSource();

            EditableFeatureType featureType = panel.fetch(null);

            FeatureStore store = featureType.getAsFeatureStore();

            ProjectManager projectManager = ApplicationLocator.getManager().getProjectManager();

            Project project = projectManager.getCurrentProject();

            TableDocument tableDoc = (TableDocument) project.getDocument(store.getName(), TableManager.TYPENAME);

            if (tableDoc == null) {

                tableDoc = (TableDocument) projectManager.createDocument(TableManager.TYPENAME);

                tableDoc.setStore(store);

                tableDoc.setName(store.getName());

                project.addDocument(tableDoc);

            }

            ApplicationLocator.getManager().getUIManager().addWindow(tableDoc.getMainWindow());

        }

    }

    @Override

    public boolean isEnabled() {

        ApplicationManager application = ApplicationLocator.getManager();

        TableDocument tabledoc = (TableDocument) application.getActiveDocument(TableManager.TYPENAME);

        if (tabledoc == null) {

            return false;

        }

        return tabledoc.getStore().isEditing();

    }

    @Override

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

        TableDocument tabledoc = (TableDocument) application.getActiveDocument(TableManager.TYPENAME);

        return tabledoc != null;

    }

    @Override

    public boolean isVisible(String action) {

        return this.isVisible();

    }

    @Override

    public boolean isEnabled(String action) {

        ApplicationManager application = ApplicationLocator.getManager();

        TableDocument tabledoc = (TableDocument) application.getActiveDocument(TableManager.TYPENAME);

        if (tabledoc == null) {

            return false;

        }

        if ("table-column-manager".equalsIgnoreCase(action)) {

            return true;

        } else if ("table-add-column".equals(action)) {

            FeatureStore store = tabledoc.getStore();

            DataStoreProviderFactory factory = store.getProviderFactory();

            if (factory instanceof FeatureStoreProviderFactory) {

                FeatureStoreProviderFactory ffactory = (FeatureStoreProviderFactory) factory;

                if (ffactory.allowEditableFeatureType() == FeatureStoreProviderFactory.NO) {

                    return false;

                } else {

                    return tabledoc.getStore().isEditing();

                }

            } else {

                return tabledoc.getStore().isEditing();

            }

        }

        return false;

    }

}