Application: gvSIG desktop » gvSIG legends: base legends

package org.gvsig.legend.urbanhorizontalsignage.app;

import java.awt.event.ActionEvent;

import java.util.function.Predicate;

import javax.swing.Icon;

import javax.swing.JOptionPane;

import javax.swing.SwingConstants;

import javax.swing.event.TreeModelListener;

import javax.swing.tree.TreePath;

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.documents.view.ViewDocument;

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

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

import org.gvsig.fmap.mapcontrol.CompoundStoresTreeModel;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageLegend;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageManager;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageConfig;

import org.gvsig.legend.urbanhorizontalsignage.swing.api.ConvertLinesToPolygonsPanel;

import org.gvsig.legend.urbanhorizontalsignage.swing.api.UrbanHorizontalSignageSwingLocator;

import org.gvsig.legend.urbanhorizontalsignage.swing.api.UrbanHorizontalSignageSwingManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class UrbanHorizontalSignageExtension extends Extension {

    private static final Logger LOGGER = LoggerFactory.getLogger(UrbanHorizontalSignageExtension.class);

    @Override

    public void initialize() {

        IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-urbanhorizontalsignage", this);

        IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-picturemarkersymboltable", this);

        IconThemeHelper.registerIcon("action", "layer-modify-clipboard-copy-as-polygons", this);

    }

    @Override

    public void execute(String actionCommand) {

        ApplicationManager application = ApplicationLocator.getManager();

        if ("layer-modify-clipboard-copy-as-polygons".equalsIgnoreCase(actionCommand) ) {

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

            if (viewdoc == null) {

                return;

            }

            MapContext mapContext = viewdoc.getMapContext();

            FLyrVect layer = mapContext.getLayers().getFirstActiveVectorLayer();

            if (layer == null) {

                return;

            }

            copySelecctionAsPolygons(layer);

        } else if ("tools-urbanSignage-linesToPolygons".equalsIgnoreCase(actionCommand) ) {

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

            if (viewdoc == null) {

                return;

            }

            MapContext mapContext = viewdoc.getMapContext();

            FLyrVect layer = mapContext.getLayers().getFirstActiveVectorLayer();

            if (layer == null) {

                return;

            }

            if( !(layer.getLegend() instanceof UrbanHorizontalSignageLegend) ) {

                //FIXME mensaje al usuario?

                return;

            }

            UrbanHorizontalSignageLegend legend = (UrbanHorizontalSignageLegend) layer.getLegend();

            UrbanHorizontalSignageConfig config = legend.getConfig(); // FIXME: clone

            FeatureSet lines;

            try {

                lines = layer.getFeatureStore().getFeatureSelection();

            } catch(Exception ex) {

                //FIXME mensaje al usuario?

                return;

            }

            convertLinesAsPolygons(config, lines);

        }

    }

    private void copySelecctionAsPolygons(FLyrVect sourceLayer) {

//        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        UrbanHorizontalSignageConfigForCopyPanel panel = new UrbanHorizontalSignageConfigForCopyPanel();

        panel.setFeatureType(sourceLayer.getFeatureStore().getDefaultFeatureTypeQuietly());

        UrbanHorizontalSignageLegend legend = (UrbanHorizontalSignageLegend) sourceLayer.getLegend();

        panel.put(legend.getConfig());

        I18nManager i18n = ToolsLocator.getI18nManager();

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

        Dialog theDialog = winManager.createDialog(

                panel.asJComponent(),

                i18n.getTranslation("_Copy_as_polygons"),

                i18n.getTranslation("_Copy_as_polygons"),

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        theDialog.setAutoclose(false);

        theDialog.setButtonLabel(

                WindowManager_v2.BUTTON_OK,

                i18n.getTranslation("_Accept")

        );

        theDialog.setButtonLabel(

                WindowManager_v2.BUTTON_CANCEL,

                i18n.getTranslation("_Cancel")

        );

        theDialog.addActionListener((ActionEvent e) -> {

            switch (theDialog.getAction()) {

                case WindowManager_v2.BUTTON_OK:

                    Thread task = new Thread(() -> {

                        panel.fetch(legend.getConfig());

                        performCopyAsPolygons(sourceLayer);

                        theDialog.asJComponent().setVisible(false);

                    }, "UHS_CopyAsPolygons");

                    task.start();

                    break;

                case WindowManager_v2.BUTTON_CANCEL:

                    theDialog.asJComponent().setVisible(false);

                    break;

            }

        });

        theDialog.show(WindowManager.MODE.DIALOG);

    }

    private void performCopyAsPolygons(FLyrVect sourceLayer) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        ApplicationManager application = ApplicationLocator.getManager();

        DataManager dataManager = DALLocator.getDataManager();

        UrbanHorizontalSignageLegend legend = (UrbanHorizontalSignageLegend) sourceLayer.getLegend();

        FeatureStore tempTargetStore = null;

        FeatureSet tempFeatureSet = null;

        try {

            FeatureSet sourceFeatureSet = sourceLayer.getFeatureStore().getFeatureSelection();

            tempTargetStore = uhsManager.createTemporaryPolygonsFromLines(legend.getConfig(), sourceFeatureSet, null);

            tempFeatureSet = tempTargetStore.getFeatureSet();

            int n = application.confirmDialog(

                    "_Number_of_geometries_to_be_copied_to_the_clipboard" + " " + tempFeatureSet.getSize() + "\n" + "_Do_you_want_to_continue",

                    i18n.getTranslation("_Copy_selected_features_as_polygons_to_clipboard"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE);

            if (n == JOptionPane.YES_OPTION) {

                dataManager.putFeaturesInClipboard(tempFeatureSet);

            }

        } catch (Exception e) {

            LOGGER.warn("Can't get the selection as JSON.", e);

        } finally {

            DisposeUtils.disposeQuietly(tempTargetStore);

            DisposeUtils.disposeQuietly(tempFeatureSet);

        }

    }

    private void convertLinesAsPolygons(UrbanHorizontalSignageConfig config, FeatureSet source) {

        I18nManager i18n = ToolsLocator.getI18nManager();

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

        ApplicationManager application = ApplicationLocator.getManager();

        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        UrbanHorizontalSignageSwingManager uhsSwingManager = UrbanHorizontalSignageSwingLocator.getUrbanHorizontalSignageSwingManager();

        final ConvertLinesToPolygonsPanel panel = uhsSwingManager.createConvertLinesToPolygonsPanel();       

        panel.setSource(source);

//        panel.setStores(new StoresWithLayerTypeIcon());

        panel.put(config);

        Dialog theDialog = winManager.createDialog(

                panel.asJComponent(),

                i18n.getTranslation("_Convert_lines_to_polygons"),

                i18n.getTranslation("_Convert_Urban_signage_lines_to_polygons"),

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        theDialog.setButtonLabel(WindowManager_v2.BUTTON_OK, i18n.getTranslation("_Convert"));

        theDialog.setButtonLabel(WindowManager_v2.BUTTON_CANCEL, i18n.getTranslation("_Close"));

        theDialog.setAutoclose(false);

        theDialog.addActionListener((ActionEvent e) -> {

            switch (theDialog.getAction()) {

                case WindowManager_v2.BUTTON_OK:

                    Thread task = new Thread(() -> {

                        try {

                            theDialog.setButtonEnabled(WindowManager_v2.BUTTON_OK, false);

                            panel.setTaskStatusVisible(true);

                            uhsManager.convertLinesToPolygons(

                                    panel.getConfig(), 

                                    panel.getSource(), 

                                    panel.getTargetStore(), 

                                    panel.getDeleteSourceAtFinish(),

                                    panel.getTaskStatus()

                            );

                            theDialog.asJComponent().setVisible(false);

                        } catch(Exception ex) {

                            LOGGER.warn("Can't convert lines to polygons", ex);

                            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                            dialogs.messageDialog(

                                    i18n.getTranslation("_Cant_convert_lines_to_polygons") +"\n\n" + ex.getLocalizedMessage(),

                                    i18n.getTranslation("_Convert_Urban_signage_lines_to_polygons"),

                                    JOptionPane.WARNING_MESSAGE

                            );

                        }

                    }, "UHS_ConvertLinesToPolygons");

                    task.start();

                    break;

                case WindowManager_v2.BUTTON_CANCEL:

                    theDialog.asJComponent().setVisible(false);

                    break;

            }

        });

        theDialog.show(WindowManager.MODE.WINDOW);

    }

    @Override

    public boolean isEnabled() {

        // it's enabled if there is exactly one vector layer in the active view

        // and it has a selection

        ApplicationManager application = ApplicationLocator.getManager();

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

        if (viewdoc == null) {

            return false;

        }

        MapContext mapContext = viewdoc.getMapContext();

        FLyrVect layer = mapContext.getLayers().getFirstActiveVectorLayer();

        if (layer == null) {

            return false;

        }

        if (!layer.isAvailable()) {

            // This can happen when opening a persisted project

            // and there is a "slow" layer (GeoDB)

            return false;

        }

        try {

            FeatureStore store = layer.getFeatureStore();

            if( store == null ) {

                return false;

            }

            FeatureSelection selection = store.getFeatureSelection();

            if (selection.isEmpty()) {

                return false;

            }

            return (layer.getLegend() instanceof UrbanHorizontalSignageLegend);

//            return !selection.isEmpty();

        } catch (Exception ex) {

            LOGGER.warn("Can't get selection from layer '" + layer.getName() + "'.", ex);

            return false;

        }

    }

    @Override

    public boolean isVisible() {

        ApplicationManager application = ApplicationLocator.getManager();

        return application.getActiveDocument(ViewManager.TYPENAME) != null;

    }

//    private static class StoresWithLayerTypeIcon implements CompoundStoresTreeModel {

//

//        private final CompoundStoresTreeModel delegated;

//

//        public StoresWithLayerTypeIcon() {

//            ApplicationManager application = ApplicationLocator.getManager();

//            this.delegated = (CompoundStoresTreeModel) application.createProjectStoresTreeModel();

//        }

//        

//        @Override

//        public void setFilter(Predicate<DataStore> filter) {

//            this.delegated.setFilter(filter);

//        }

//

//        @Override

//        public void addLayers(FLayers layers) {

//            this.delegated.addLayers(layers);

//        }

//

//        @Override

//        public Icon getIcon(Object item) {

//            Icon icon = this.delegated.getIcon(item);

//            if( item instanceof LabeledValue ) {

//                item = ((LabeledValue)item).getValue();

//            }

//            if (item instanceof FeatureStore) {

//                try {

//                    FeatureStore store = (FeatureStore) item;

//                    FeatureType ft = store.getDefaultFeatureTypeQuietly();

//                    int type = ft.getDefaultGeometryAttribute().getGeomType().getType();

//                    Icon icon2 = MapContextLocator.getMapContextManager().getIcon(

//                            type, 

//                            !store.isFeatureSelectionEmpty()

//                    );

//                    if( icon2!=null ) {

//                        icon = ToolsSwingLocator.getToolsSwingManager().createCompoundIcon(

//                               SwingConstants.HORIZONTAL, 2, icon, icon2

//                        );

//                    }

//                } catch(Exception ex) {

//                    LOGGER.trace("Can't get geometry type from store.", ex);

//                }

//            }

//            return icon;

//        }

//

//        @Override

//        public Object getRoot() {

//            return this.delegated.getRoot();

//        }

//

//        @Override

//        public Object getChild(Object parent, int index) {

//            return this.delegated.getChild(parent, index);

//        }

//

//        @Override

//        public int getChildCount(Object parent) {

//            return this.delegated.getChildCount(parent);

//        }

//

//        @Override

//        public boolean isLeaf(Object node) {

//            return this.delegated.isLeaf(node);

//        }

//

//        @Override

//        public void valueForPathChanged(TreePath path, Object newValue) {

//            this.delegated.valueForPathChanged(path, newValue);

//        }

//

//        @Override

//        public int getIndexOfChild(Object parent, Object child) {

//            return this.delegated.getIndexOfChild(parent, child);

//        }

//

//        @Override

//        public void addTreeModelListener(TreeModelListener l) {

//            this.delegated.addTreeModelListener(l);

//        }

//

//        @Override

//        public void removeTreeModelListener(TreeModelListener l) {

//            this.delegated.removeTreeModelListener(l);

//        }

//        

//    }

}