gvSIG projects pool

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.online.app.mainplugin;

import java.io.File;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.json.JsonArray;

import javax.json.JsonObject;

import javax.json.JsonValue;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListModel;

import javax.swing.Icon;

import javax.swing.ListModel;

import javax.swing.tree.TreeModel;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.PluginsLocator;

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

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

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

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

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

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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

import org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.MultiCurve;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiSurface;

import org.gvsig.fmap.geom.primitive.Curve;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.geom.primitive.Surface;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

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

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

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol_v2;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.json.Json;

import org.gvsig.json.JsonArrayBuilder;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.online.lib.api.OnlineLocator;

import org.gvsig.online.lib.api.OnlineManager;

import org.gvsig.online.lib.api.OnlineRuntimeException;

import org.gvsig.online.swing.api.OnlineSwingServices;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.slf4j.LoggerFactory;

import org.gvsig.online.lib.api.workingcopy.OnlineWorkingcopy;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class OnlineSwingServicesImpl implements OnlineSwingServices {

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

    private static final String VCSGISMODELS_PROJECT_PROPERTY = "VCSGisModels";

    private Map<Integer,ISymbol> highlightedPolygonSymbols;

    private Map<Integer,ISymbol> highlightedLineSymbols;

    private Map<Integer,ISymbol> highlightedPointSymbols;

    @Override

    public TreeModel getFeatureStoresTreeModel() {

        return new FeatureStoresTreeModel();

    }

    @Override

    public ListModel getFeatureStoresListModel() {

        DefaultListModel<FeatureStore> model = new DefaultListModel();

        ApplicationManager appManager = ApplicationLocator.getApplicationManager();

        Project project = appManager.getCurrentProject();

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

        for (Document document : tables) {

            TableDocument table = (TableDocument) document;

            FeatureStore tableStore = table.getFeatureStore();

            if( tableStore!=null ) {

                model.addElement(tableStore);

            }

        }        

        return model;

    }

    @Override

    public void addTableToProject(OnlineWorkingcopy ws, FeatureStore store) {

        ApplicationManager appManager = ApplicationLocator.getApplicationManager();

        DocumentManager tableManager = appManager.getProjectManager().getDocumentManager(

                TableManager.TYPENAME

        );

        Project project = appManager.getCurrentProject();

        TableDocument tableDoc = (TableDocument) tableManager.createDocument();

        tableDoc.setName(store.getName());

        tableDoc.setStore(store);

        project.addDocument(tableDoc);

    }

    @Override

    public ComboBoxModel getViewDocumentsComboBoxModel() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        DefaultComboBoxModel<LabeledValue> model = new DefaultComboBoxModel();

        model.addElement(new LabeledValueImpl(i18n.getTranslation("_Select_a_view"), null));

        ApplicationManager appManager = ApplicationLocator.getApplicationManager();

        Project project = appManager.getCurrentProject();

        List<Document> views = project.getDocuments(ViewManager.TYPENAME);

        for (Document document : views) {

            ViewDocument view = (ViewDocument) document;

            model.addElement(new LabeledValueImpl(view.getName(), view));

        }

        return model;

    }

//    @Override

//    public void addLayerToView(FeatureStore store, LabeledValue labeledView) {

//        addLayerToView(store, labeledView, null, null, false);

//    }

//

    @Override

    public void addLayerToView(FeatureStore store, LabeledValue labeledView, String groupName, String name, boolean replaceLayerIfExists) {

        ViewDocument view;

        if( labeledView == null ) {

            view = null;

        } else  if (labeledView.getValue() == null){

            view = null;

        } else {

            view = (ViewDocument) labeledView.getValue();

        }

        addLayerToView(store, view, groupName, name, replaceLayerIfExists);

    }

    private void addLayerToView(FeatureStore store, ViewDocument view, String groupName, String name, boolean replaceLayerIfExists) {

        try {

            if( store == null ) {

                return;

            }

            if( view==null ) {               

                IView viewWin = getActiveView();

                if(viewWin == null){

                    return;

                }

                view = viewWin.getViewDocument();

            }

            String layerName = name;

            if(StringUtils.isBlank(layerName)){

                layerName = store.getName();

            }

            FLayer layer = MapContextLocator.getMapContextManager().createLayer(layerName, store);

            MapContext mapContext = view.getMapContext();

            mapContext.getLayers().add(layer);

            if( !mapContext.hasActiveLayers() ) {

              layer.setActive(true);

            }

        } catch (Exception ex) {

            OnlineManager manager = OnlineLocator.getOnlineManager();

            throw new OnlineRuntimeException(

                    OnlineManager.ERR_CANT_ADD_LAYER, 

                    manager.getErrorMessage(OnlineManager.ERR_CANT_ADD_LAYER),

                    ex);

        }

    }

    @Override

    public void highlight(int mode, Geometry geom) {

        highlight(mode, geom, null);

    }

    @Override

    public void highlight(int mode, Geometry geom, FeatureStore store) {

        if (this.highlightedPointSymbols == null) {

            this.highlightedPointSymbols = new HashMap<>();

            this.highlightedLineSymbols = new HashMap<>();

            this.highlightedPolygonSymbols = new HashMap<>();

            try {

                File pluginfolder = PluginsLocator.getManager().getPlugin(this).getPluginDirectory();

                File folder = new File(pluginfolder, "symbols");

                ISymbol[] symbols = MapContextLocator.getSymbolManager().loadSymbols(folder);

                for (ISymbol symbol : symbols) {

                    if (symbol instanceof ISymbol_v2) {

                        String symbolid = ((ISymbol_v2) symbol).getID();

                        switch(symbolid) {

                            case "online-remote-polygon":

                                this.highlightedPolygonSymbols.put(HIGHLIGHT_REMOTE, symbol);

                                break;

                            case "online-remote-line":

                                this.highlightedLineSymbols.put(HIGHLIGHT_REMOTE, symbol);

                                break;

                            case "online-remote-point":

                                this.highlightedPointSymbols.put(HIGHLIGHT_REMOTE, symbol);

                                break;

                            case "online-workspace-polygon":

                                this.highlightedPolygonSymbols.put(HIGHLIGHT_WORKSPACE, symbol);

                                break;

                            case "online-workspace-line":

                                this.highlightedLineSymbols.put(HIGHLIGHT_WORKSPACE, symbol);

                                break;

                            case "online-workspace-point":

                                this.highlightedPointSymbols.put(HIGHLIGHT_WORKSPACE, symbol);

                                break;

                            case "online-workspace-previous-polygon":

                                this.highlightedPolygonSymbols.put(HIGHLIGHT_WORKSPACE_PREVIOUS, symbol);

                                break;

                            case "online-workspace-previous-line":

                                this.highlightedLineSymbols.put(HIGHLIGHT_WORKSPACE_PREVIOUS, symbol);

                                break;

                            case "online-workspace-previous-point":

                                this.highlightedPointSymbols.put(HIGHLIGHT_WORKSPACE_PREVIOUS, symbol);

                                break;

                        }

                    }

                }

            } catch (Exception ex) {

            }

        }

        List<ViewDocument> viewList;

        if(store == null){

            ApplicationManager application = ApplicationLocator.getManager();

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

            viewList = new ArrayList<>();

            viewList.add(viewdoc);

        } else {

            viewList = getViewDocumentsHavingAStore(store);

        }

        for (ViewDocument viewDoc : viewList) {

            MapContext mapContext = viewDoc.getMapContext();

            GraphicLayer gl = mapContext.getGraphicsLayer();

            if (geom != null) {

                ISymbol symbol = null;

                if (geom instanceof Point || geom instanceof MultiPoint) {

                    symbol = this.highlightedPointSymbols.get(mode);

                } else if (geom instanceof Curve || geom instanceof MultiCurve) {

                    symbol = this.highlightedLineSymbols.get(mode);

                } else if (geom instanceof Surface || geom instanceof MultiSurface) {

                    symbol = this.highlightedPolygonSymbols.get(mode);

                }

                if (symbol != null) {

                    int symbolid = gl.getSymbolId(symbol);

                    if (symbolid < 0) {

                        gl.addSymbol(symbol);

                        symbolid = gl.getSymbolId(symbol);

                    }

                    gl.addGraphic("online-highlighted", geom, symbolid);

                }

            }

            mapContext.invalidate();

        }

    }

    @Override

    public void centerActiveViewToGeometry(Geometry geometry) {

        if(geometry != null){

            IView view = getActiveView();

            if(view != null){

                ViewDocument viewDocument = view.getViewDocument();

                viewDocument.center(geometry.getEnvelope());

            }

        }

    }

    @Override

    public void centerViewsHavingAStoreToGeometry(FeatureStore store, Geometry geometry) {

        if(geometry != null){

            List<ViewDocument> views = getViewDocumentsHavingAStore(store);

            for (ViewDocument view : views) {

                if(view != null){

                    view.center(geometry.getEnvelope());

                }

            }

        }

    }

    @Override

    public void zoomActiveViewToGeometry(Geometry geometry) {

        if(geometry != null){

            IView view = getActiveView();

            if(view != null){

                ViewDocument viewDocument = view.getViewDocument();

                viewDocument.getMapContext().getViewPort().setEnvelope(geometry.getEnvelope());

            }

        }

    }

    @Override

    public void zoomViewsHavingAStoreToGeometry(FeatureStore store, Geometry geometry) {

        if(geometry != null){

            List<ViewDocument> views = getViewDocumentsHavingAStore(store);

            for (ViewDocument view : views) {

                if(view != null){

                    view.getMapContext().getViewPort().setEnvelope(geometry.getEnvelope());

                }

            }

        }

    }

    private IView getActiveView() {

        ApplicationManager application = ApplicationLocator.getManager();

        IView view = (IView) application.getActiveComponent(ViewDocument.class);

        return view;

    }

    @Override

    public void cleanHighligthed() {

        ApplicationManager application = ApplicationLocator.getManager();

        ProjectManager projectManager = application.getProjectManager();

        Project project = projectManager.getCurrentProject();

        List<Document> views = project.getDocuments(ViewManager.TYPENAME);

        for (Document doc : views) {

            ViewDocument viewdoc = (ViewDocument)doc;

            MapContext mapContext = viewdoc.getMapContext();

            GraphicLayer gl = mapContext.getGraphicsLayer();

            //FIXME: Refrescar el mapContext solo cuando se ha borrado el graphics  

            if(gl.removeGraphics("online-highlighted")) {

                mapContext.invalidate();

            }

        }

    }

    @Override

    public void cleanActiveViewHighligthed() {

        ApplicationManager application = ApplicationLocator.getManager();

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

        if(viewdoc != null){

            MapContext mapContext = viewdoc.getMapContext();

            GraphicLayer gl = mapContext.getGraphicsLayer();

            gl.removeGraphics("online-highlighted");

            mapContext.invalidate();

        }

    }

    @Override

    public void refreshDocuments() {

        ApplicationManager application = ApplicationLocator.getManager();

        ProjectManager projectManager = application.getProjectManager();

        Project project = projectManager.getCurrentProject();

        List<Document> views = project.getDocuments(ViewManager.TYPENAME);

        for (Document doc : views) {

            doc.refresh();

        }

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

        for (Document doc : tables) {

            doc.refresh();

        }

    }

    @Override

    public void refreshDocument(FeatureStore store){

        if(store == null){

            return;

        }

        ApplicationManager application = ApplicationLocator.getManager();

        ProjectManager projectManager = application.getProjectManager();

        Project project = projectManager.getCurrentProject();

        String storeFullName = store.getFullName();

        List<Document> views = project.getDocuments(ViewManager.TYPENAME);

        for (Document doc : views) {

            ViewDocument view = (ViewDocument)doc;

            for (Iterator<FLayer> it = view.deepiterator(); it.hasNext();) {

                FLayer layer = it.next();

                if(layer instanceof FLyrVect){

                    FeatureStore layerStore = ((FLyrVect) layer).getFeatureStore();

                    if( layerStore!=null && StringUtils.equals(layerStore.getFullName(), storeFullName)){

                        try {

                            layerStore.refresh();

                        } catch(Exception ex) {

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

                        }

                        view.getMapContext().invalidate();

                        break;

                    }

                }

            }

        }

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

        for (Document doc : tables) {

            TableDocument table = (TableDocument)doc;

            FeatureStore featureStore = table.getStore();

            if( StringUtils.equals(featureStore.getFullName(), storeFullName)){

                try {

                    featureStore.refresh();

                } catch (DataException e) {

                    LOGGER.warn("Error refreshing table", e);

                }

            }

        }

    }

    @Override

    public void refreshDocument(Set<FeatureStore> stores){

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

            return;

        }

        ApplicationManager application = ApplicationLocator.getManager();

        ProjectManager projectManager = application.getProjectManager();

        Project project = projectManager.getCurrentProject();

        Set<ViewDocument> viewsToRefresh = new HashSet<>();

        for (FeatureStore store : stores) {

            String storeFullName = store.getFullName();

            List<Document> views = project.getDocuments(ViewManager.TYPENAME);

            for (Document doc : views) {

                ViewDocument view = (ViewDocument)doc;

                for (Iterator<FLayer> it = view.deepiterator(); it.hasNext();) {

                    FLayer layer = it.next();

                    if(layer instanceof FLyrVect){

                        FeatureStore layerStore = ((FLyrVect) layer).getFeatureStore();

                        if( layerStore!=null && StringUtils.equals(layerStore.getFullName(), storeFullName)){

                            viewsToRefresh.add(view);

                            break;

                        }

                    }

                }

            }

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

            for (Document doc : tables) {

                TableDocument table = (TableDocument)doc;

                FeatureStore featureStore = table.getStore();

                if( StringUtils.equals(featureStore.getFullName(), storeFullName)){

                    try {

                        featureStore.refresh();

                    } catch (DataException e) {

                        LOGGER.warn("Error refreshing table", e);

                    }

                }

            }

        }

        for (ViewDocument viewDocument : viewsToRefresh) {

            viewDocument.getMapContext().invalidate();

        }

    }

    public List<ViewDocument> getViewDocumentsHavingAStore(FeatureStore store){

        if(store == null){

            return null;

        }

        List<ViewDocument> viewList = new ArrayList<>();

        String storeFullName = store.getFullName();

        ApplicationManager application = ApplicationLocator.getManager();

        ProjectManager projectManager = application.getProjectManager();

        Project project = projectManager.getCurrentProject();

        List<Document> views = project.getDocuments(ViewManager.TYPENAME);

        for (Document doc : views) {

            ViewDocument view = (ViewDocument) doc;

            for (Iterator<FLayer> it = view.deepiterator(); it.hasNext();) {

                FLayer layer = it.next();

                if (layer instanceof FLyrVect) {

                    FeatureStore layerStore = ((FLyrVect) layer).getFeatureStore();

                    if ( layerStore!=null && StringUtils.equals(layerStore.getFullName(),store.getFullName() )) {

                        viewList.add(view);

                        break;

                    }

                }

            }

        }

        return viewList;

    }

//    @Override

//    public void addLayerToActiveView(FeatureStore store, String name) {

//        if(store != null && StringUtils.isNotBlank(name)){

//            IView view = getActiveView();

//            if(view != null){

//                ViewDocument viewDocument = view.getViewDocument();

//                this.addLayerToView(store, viewDocument, null, name, false);

//            }

//        }

//    }

//

    @Override

    public boolean isThereAnyActiveView() {

        return this.getActiveView() != null;

    }

    @Override

    public void addTableToProject(OnlineWorkingcopy ws, FeatureStore store, String tableName) {

        ApplicationManager appManager = ApplicationLocator.getApplicationManager();

        DocumentManager tableManager = appManager.getProjectManager().getDocumentManager(

                TableManager.TYPENAME

        );

        Project project = appManager.getCurrentProject();

        TableDocument tableDoc = (TableDocument) tableManager.createDocument();

        tableDoc.setName(tableName);

        tableDoc.setStore(store);

        project.addDocument(tableDoc);

    }

    @Override

    public Icon getFeatureStoresTreeModelIcon(TreeModel model, Object obj) {

        if( model instanceof FeatureStoresTreeModel ) {

            return ((FeatureStoresTreeModel)model).getIcon(obj);

        }

        return null;

    }

    @Override

    public void connectedToModel(OnlineWorkingcopy workspace, String model) {

        String previousProjectModelInfo = null;

        try {

            ApplicationManager application = ApplicationLocator.getApplicationManager();

            Project project = application.getCurrentProject();

            Map<String,JsonObject> models = new HashMap<>();

            previousProjectModelInfo = (String) project.getProperty(VCSGISMODELS_PROJECT_PROPERTY);

            if( previousProjectModelInfo != null ) {

                JsonArray array = Json.createArray(previousProjectModelInfo);

                for (JsonValue value : array) {

                    JsonObject item = (JsonObject) value;

                    String modelName = item.getString("model", null);

                    JDBCServerExplorerParameters wsparameters = (JDBCServerExplorerParameters) Json.toObject(item.getJsonObject("parameters"));

                    String url = wsparameters.getUrl();

                    String key = modelName; //+ "("+ url + ")";

                    models.put(key, item);

                }

            }

            JDBCServerExplorerParameters parameters = workspace.getExplorerParameters();

            String url = parameters.getUrl();

            String key = model;// + "("+ url + ")";

            JsonObjectBuilder item = Json.createObjectBuilder();

            item.add("model", model);

            item.add("parameters", parameters);

            models.put(key, item.build());

            JsonArrayBuilder array = Json.createArrayBuilder();

            for (JsonObject n : models.values()) {

                array.add(n);

            }

            String s = array.build().toString();

            project.setProperty(VCSGISMODELS_PROJECT_PROPERTY, s);

            LOGGER.info("Added information of online model to project properties.");

            LOGGER.debug(s);

        } catch(Exception ex) {

            LOGGER.warn("Can't add information of online model to project properties. Previous model info='"+previousProjectModelInfo+"'", ex);

        }

    }

    public void projectLoaded(Project project) {

        String projectModelInfo = null;

        try {

            projectModelInfo = (String) project.getProperty(VCSGISMODELS_PROJECT_PROPERTY);

            if (projectModelInfo == null) {

                LOGGER.info("Project loaded without information of online models.");

                return;

            }

            // TODO:    El projecto se guardo cuando estaba conectado a uno o mas

            //          modelos de datos... 

            //          ¿ Preguntamos al usuario si nos reconectamos automaticamente

            //          o nos reconectamos sin decirle nada ?

            //          Si preguntamos que recuerde la respuesta.

            OnlineManager manager = OnlineLocator.getOnlineManager();

            DataManager dataManager = DALLocator.getDataManager();

            JsonArray array = Json.createArray(projectModelInfo);

            for (JsonValue value : array) {

                String modelName = "unkbown";

                String url = "unknown";

                try {

                    JsonObject item = (JsonObject) value;

                    modelName = item.getString("model", null);

                    JDBCServerExplorerParameters wsparameters = (JDBCServerExplorerParameters) Json.toObject(item.get("parameters"));

                    url = wsparameters.getUrl();

                    JDBCServerExplorer wsexplorer = (JDBCServerExplorer) dataManager.openServerExplorer(wsparameters.getProviderName(), wsparameters);

                    OnlineWorkingcopy workspace = manager.openWorkingcopy(wsexplorer);

                    workspace.registerDataModelRepository(modelName);

                    LOGGER.info("Conected to online model '"+modelName+"' (workspace="+url+").");

                } catch (Exception ex) {

                    LOGGER.warn("Can't register data model '" + modelName + "' of workspace '" + url + "'.", ex);

                    // TODO: ¿ avisar al usuario o basta con lo que saca en la linea de mensajes del MDI ?

                }

            }

        } catch(Exception ex) {

            LOGGER.warn("Can't add information of online model to project properties ("+projectModelInfo+").", ex);

        }

    }

    @Override

    public Geometry getExtentOfCurrentDocument() {

        ApplicationManager application = ApplicationLocator.getApplicationManager();

        Project project = application.getCurrentProject();

        ViewDocument view = (ViewDocument) project.getActiveDocument(ViewDocument.class);

        if( view == null ) {

            return null;

        }

        return view.getMapContext().getViewPort().getEnvelope().getBox2D();

    }

    @Override

    public boolean isInSomeDocument(FeatureStore store) {

        if(store == null){

            return false;

        }

        ApplicationManager application = ApplicationLocator.getManager();

        ProjectManager projectManager = application.getProjectManager();

        Project project = projectManager.getCurrentProject();

        String storeFullName = store.getFullName();

        List<Document> views = project.getDocuments(ViewManager.TYPENAME);

        for (Document doc : views) {

            ViewDocument view = (ViewDocument)doc;

            for (Iterator<FLayer> it = view.deepiterator(); it.hasNext();) {

                FLayer layer = it.next();

                if(layer instanceof FLyrVect){

                    FeatureStore layerStore = ((FLyrVect) layer).getFeatureStore();

                    if( layerStore!=null && StringUtils.equals(layerStore.getFullName(), storeFullName)){

                        return true;

                    }

                }

            }

        }

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

        for (Document doc : tables) {

            TableDocument table = (TableDocument)doc;

            FeatureStore featureStore = table.getStore();

            if( StringUtils.equals(featureStore.getFullName(), storeFullName)){

                return true;

            }

        }

        return false;

    }

    @Override

    public LabeledValue<MapControl> getActiveMapControl() {

        try {

            ApplicationManager application = ApplicationLocator.getApplicationManager();

            Project project = application.getCurrentProject();

            ViewDocument viewDoc = (ViewDocument) project.getActiveDocument(ViewDocument.class);

            if( viewDoc == null ) {

                return null;

            }

            IView view = (IView) viewDoc.getMainComponent();

            return new LabeledValueImpl<>(viewDoc.getName(), view.getMapControl());

        } catch(Throwable t) {

            return null;

        }

    }

    public List<LabeledValue<MapControl>> getMapControls() {

        ApplicationManager application = ApplicationLocator.getManager();

        ProjectManager projectManager = application.getProjectManager();

        Project project = projectManager.getCurrentProject();

        List<LabeledValue<MapControl>> mapControls = new ArrayList<>();

        List<Document> views = project.getDocuments(ViewManager.TYPENAME);        

        for (Document doc : views) {

            ViewDocument viewDoc = (ViewDocument)doc;

            IView view = (IView) viewDoc.getMainComponent();

            mapControls.add(new LabeledValueImpl<>(viewDoc.getName(), view.getMapControl()));

        }

        return mapControls;

    }

    private static class ListDisposable<T> extends ArrayList<T> implements Disposable {

        @Override

        public void dispose() {

            for (T element : this) {

                DisposeUtils.dispose(element);

            }

            this.clear();

        }

    }

    public List<FeatureStore> getFeatureStores() {

        ListDisposable<FeatureStore> stores = new ListDisposable<>();

        ApplicationManager appManager = ApplicationLocator.getApplicationManager();

        Project project = appManager.getCurrentProject();

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

        for (Document document : docs) {

            if( document instanceof TableDocument ) {

                TableDocument table = (TableDocument) document;

                FeatureStore store = table.getFeatureStore();

                if( store!=null ) {

                    DisposeUtils.bind(store);

                    stores.add(store);

                }

            } else if( document instanceof ViewDocument ) {

                ViewDocument view = (ViewDocument) document;

                Iterator<FLayer> it = view.getMapContext().deepiterator();

                while (it.hasNext()) {

                    FLayer layer = it.next();

                    if( layer instanceof VectorLayer ) {

                        FeatureStore store = ((VectorLayer) layer).getFeatureStore();

                        if( store!=null ) {

                            DisposeUtils.bind(store);

                            stores.add(store);

                        }

                    }

                }

            }

        }  

        return stores;

    }

}