gvSIG projects pool

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

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.vcsgis</artifactId>

    <version>1.0.40</version>

  </parent>

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

  <packaging>pom</packaging>

  <name>${project.artifactId}</name>

  <modules>

    <module>org.gvsig.vcsgis.app.mainplugin</module>

    <module>org.gvsig.vcsgis.app.server</module>

  </modules>

</project>

#Mon Dec 20 08:21:46 CET 2021

buildNumber=48

/*

 * 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.vcsgis.app;

import java.util.HashMap;

import java.util.Map;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.event.TreeModelListener;

import javax.swing.tree.TreeModel;

import javax.swing.tree.TreePath;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

import org.gvsig.fmap.mapcontext.layers.operations.SingleLayer;

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

import org.gvsig.fmap.mapcontrol.LayersTreeModel;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

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

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

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

/**

 *

 * @author fdiaz

 */

public class FeatureStoresTreeModel implements TreeModel, IconGetter {

    private final LayersTreeModel delegated;

    private final ListElement<Object> root;

    private final Map<Object,Icon> icons;

    public FeatureStoresTreeModel() {

        this.delegated = (LayersTreeModel) ApplicationLocator.getApplicationManager().createProjectLayersTreeModel();

        this.icons = new HashMap<>();

        this.delegated.setFilter(new Evaluator() {

            @Override

            public Object evaluate(EvaluatorData data) throws EvaluatorException {

                FLayer layer = (FLayer) data.getDataValue("layer");

                return (layer instanceof VectorLayer);

            }

            @Override

            public String getName() {

                return "VectorialLayersFilter";

            }

            @Override

            public String getDescription() {

                return null;

            }

            @Override

            public String getSQL() {

                return null;

            }

            @Override

            public EvaluatorFieldsInfo getFieldsInfo() {

                return null;

            }

        });

        this.root = new ListElement<>("Project", this.delegated.getRoot());

    }

    private Object getNode(Object value) {

        if( value instanceof ListElement ) {

            return ((ListElement) value).getValue();

        }

        return value;

    }

    @Override

    public Object getRoot() {

        return this.root;

    }

    @Override

    public Object getChild(Object parent, int index) {

        parent = this.getNode(parent);

        Object x = this.delegated.getChild(parent, index);

        if( x instanceof VectorLayer ) {

            SingleLayer layer = (SingleLayer)x;

            DataStore store = (DataStore) layer.getDataStore();

            return store;

        }

        return x;

    }

    @Override

    public int getChildCount(Object parent) {

        parent = this.getNode(parent);

        return this.delegated.getChildCount(parent);

    }

    @Override

    public boolean isLeaf(Object node) {

        node = this.getNode(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) {

        parent = this.getNode(parent);

        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);

    }

    @Override

    public Icon getIcon(Object item) {

         if( !this.icons.containsKey(item) ) {

            String iconName;

            if( item instanceof DataStore ) {

                iconName = MapContextLocator.getMapContextManager().getIconLayer((DataStore)item);

            } else if( item instanceof FLayers ) {

                FLayers layers = (FLayers) item;

                if( layers.getParentLayer()!=null && layers.getParentLayer().getParentLayer()==null ) {

                    iconName = "view-navigation-zoom-all";

                } else {

                    iconName = "layer-icon-group";

                }

            } else if( item == root  ) {

                iconName = "common-folder-open";

            } else {

                iconName = "common-leaf";

            }

            ImageIcon icon = ToolsSwingLocator.getIconThemeManager().getCurrent().get(iconName);

            this.icons.put(item, icon);

        }

       return this.icons.get(item);

    }

}

/*

 * 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.vcsgis.app;

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.rendering.symbols.ISymbol;

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

import org.gvsig.json.Json;

import org.gvsig.json.JsonArrayBuilder;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.gvsig.vcsgis.app.addlayer.LayersWithGroup;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

import org.gvsig.vcsgis.lib.VCSGisRuntimeException;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

import org.gvsig.vcsgis.swing.VCSGisSwingServices;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class VCSGisSwingServicesImpl implements VCSGisSwingServices {

    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(VCSGisSwingServicesImpl.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;

            model.addElement(table.getFeatureStore());

        }

        return model;

    }

    @Override

    public void addTableToProject(VCSGisWorkspace 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);

            LayersWithGroup helper = new LayersWithGroup(view.getMapContext());

            helper.add(groupName, name, layer);

            helper.updateMapContext(true, replaceLayerIfExists);

        } catch (Exception ex) {

            VCSGisManager manager = VCSGisLocator.getManager();

            throw new VCSGisRuntimeException(

                    VCSGisManager.ERR_CANT_ADD_LAYER, 

                    manager.getErrorMessage(VCSGisManager.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 "vcsgis-repository-polygon":

                                this.highlightedPolygonSymbols.put(HIGHLIGHT_REPOSITORY, symbol);

                                break;

                            case "vcsgis-repository-line":

                                this.highlightedLineSymbols.put(HIGHLIGHT_REPOSITORY, symbol);

                                break;

                            case "vcsgis-repository-point":

                                this.highlightedPointSymbols.put(HIGHLIGHT_REPOSITORY, symbol);

                                break;

                            case "vcsgis-workspace-polygon":

                                this.highlightedPolygonSymbols.put(HIGHLIGHT_WORKSPACE, symbol);

                                break;

                            case "vcsgis-workspace-line":

                                this.highlightedLineSymbols.put(HIGHLIGHT_WORKSPACE, symbol);

                                break;

                            case "vcsgis-workspace-point":

                                this.highlightedPointSymbols.put(HIGHLIGHT_WORKSPACE, symbol);

                                break;

                            case "vcsgis-workspace-previous-polygon":

                                this.highlightedPolygonSymbols.put(HIGHLIGHT_WORKSPACE_PREVIOUS, symbol);

                                break;

                            case "vcsgis-workspace-previous-line":

                                this.highlightedLineSymbols.put(HIGHLIGHT_WORKSPACE_PREVIOUS, symbol);

                                break;

                            case "vcsgis-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("vcsgis-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("vcsgis-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("vcsgis-highlighted");

            mapContext.invalidate();

        }

    }

    @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){

                    if( StringUtils.equals(((FLyrVect) layer).getFeatureStore().getFullName(), storeFullName)){

                        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){

                        if( StringUtils.equals(((FLyrVect) layer).getFeatureStore().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) {

                    if (StringUtils.equals(

                            ((FLyrVect) layer).getFeatureStore().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(VCSGisWorkspace 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(VCSGisWorkspace workspace, String model) {

        ApplicationManager application = ApplicationLocator.getApplicationManager();

        Project project = application.getCurrentProject();

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

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

        if( x != null ) {

            JsonArray array = Json.createArray(x);

            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);

        }

        project.setProperty(VCSGISMODELS_PROJECT_PROPERTY, array.build().toString());

    }

    public void projectLoaded(Project project) {

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

        if (x == null) {

            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.

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        DataManager dataManager = DALLocator.getDataManager();

        JsonArray array = Json.createArray(x);

        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);

                VCSGisWorkspace workspace = manager.openWorkspace(wsexplorer);

                workspace.registerDataModelRepository(modelName);

            } 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 ?

            }

        }

    }

    @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();

    }

}

/*

 * gvSIG. Desktop Geographic Information System.

 * 

 * Copyright (C) 2007-2020 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, see <https://www.gnu.org/licenses/>. 

 * 

 * 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.vcsgis.app;

import java.awt.event.ActionEvent;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.util.HashMap;

import java.util.Map;

import javax.swing.JPanel;

import javax.swing.SwingUtilities;

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

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

import org.gvsig.app.ApplicationLocator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

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.vcsgis.swing.VCSGisPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class VCSGisDialogsHelper {

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

    public static class VCSGisDialogInfo {

        private VCSGisPanel panel;

        private final String name;

        private final String title;

        private String header;

        private String okLabel;

        private boolean closed;

        private Runnable action;

        private Dialog dialog;

        private boolean autoclose;

        public VCSGisDialogInfo(String name, VCSGisPanel thePanel, String title) {

            this.name = name;

            this.panel = thePanel;

            this.title = title;

            this.closed = true;

            this.autoclose = false;

            this.panel.asJComponent().addComponentListener(new ComponentAdapter() {

                @Override

                public void componentHidden(ComponentEvent e) {

                    closed = true;

                }

            });

        }

        public VCSGisDialogInfo(String name, VCSGisPanel thePanel, String title, String header, String okLabel) {

            this(name, thePanel, title);

            this.header = header;

            this.okLabel = okLabel;

        }

        private void performDialogAction() {

            action.run();

        }

        public void setAction(Runnable action) {

            this.action = action;

        }

        public Component getPanel() {

            return this.panel;

        }

        public boolean isClosed() {

            return this.closed;

        }

        public String getName() {

            return this.name;

        }

        public void setAutoclose(boolean autoclose) {

            this.autoclose = autoclose;

        }

        private Dialog createDialog() {

            I18nManager i18n = ToolsLocator.getI18nManager();

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

            Dialog theDialog = winManager.createDialog(

                    this.panel.asJComponent(),

                    i18n.getTranslation(title),

                    i18n.getTranslation(header),

                    WindowManager_v2.BUTTONS_OK_CANCEL

            );

            theDialog.setAutoclose(false);

            this.panel.setDialog(theDialog);

            theDialog.setButtonLabel(

                    WindowManager_v2.BUTTON_OK,

                    i18n.getTranslation(okLabel)

            );

            theDialog.setButtonLabel(

                    WindowManager_v2.BUTTON_CANCEL,

                    i18n.getTranslation("_Close")

            );

            if (this.panel.isProcessing()) {

                theDialog.setButtonEnabled(WindowManager_v2.BUTTON_OK, false);

            }

            theDialog.addActionListener((ActionEvent e) -> {

                switch (theDialog.getAction()) {

                    case WindowManager_v2.BUTTON_OK:

                        Thread task = new Thread(() -> {

                            if(this.autoclose){

                                this.dialog.setButtonEnabled(WindowManager_v2.BUTTON_OK, false);

                            }

                            performDialogAction();

                            if(this.autoclose){

                                close();

                            }

                        }, "VCSGis" + name);

                        task.start();

                        break;

                    case WindowManager_v2.BUTTON_CANCEL:

                        close();

                        break;

                }

            });

            return theDialog;

        }

        public void show() {

            if (!this.closed) {

                MDIManager manager = ApplicationLocator.getApplicationManager().getUIManager();

                manager.moveToFrom(manager.getWindow((JPanel) this.panel.asJComponent()));

                return;

            }

            this.closed = false;

            if( this.action==null ) {

                I18nManager i18n = ToolsLocator.getI18nManager();

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

                winManager.showWindow(

                        this.panel.asJComponent(),

                        i18n.getTranslation(this.title),

                        WindowManager.MODE.WINDOW

                );

            } else {

                this.dialog = this.createDialog();

                this.dialog.show(WindowManager.MODE.WINDOW);

            }

        }

        private void close() {

            if (this.closed || this.dialog == null) {

                this.panel = null;

                this.dialog = null;

                return;

            }

            if(!SwingUtilities.isEventDispatchThread()){

                SwingUtilities.invokeLater(this::close);

                return;

            }

            this.dialog.asJComponent().setVisible(false);     

            this.panel = null;

            this.dialog = null;

        }

    }

    private Map<String, VCSGisDialogInfo> dialogsInfo;

    public VCSGisDialogInfo getDialog(String name) {

        if (this.dialogsInfo == null) {

            return null;

        }

        VCSGisDialogInfo info = this.dialogsInfo.get(name);

        return info;

    }

    public VCSGisDialogInfo getOrCreateDialog(String name, VCSGisPanel panel, String title, String header, String okLabel, Runnable action) {

        if (this.dialogsInfo == null) {

            this.dialogsInfo = new HashMap<>();

        }

        VCSGisDialogInfo info = this.dialogsInfo.get(name);

        if (info == null || info.isClosed() ) {

            info = new VCSGisDialogInfo(name, panel, title, header, okLabel);

            info.setAction(action);

            this.dialogsInfo.put(name, info);

        }

        return info;

    }

    public VCSGisDialogInfo getOrCreateDialog(String name, VCSGisPanel panel, String title) {

        if (this.dialogsInfo == null) {

            this.dialogsInfo = new HashMap<>();

        }

        VCSGisDialogInfo info = this.dialogsInfo.get(name);

        if (info == null || info.isClosed()) {

            info = new VCSGisDialogInfo(name, panel, title);

            this.dialogsInfo.put(name, info);

        }

        return info;

    }

}

package org.gvsig.vcsgis.app.addlayer;

import java.awt.BorderLayout;

import java.awt.Cursor;

import java.awt.event.ActionEvent;

import java.net.URL;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.function.Function;

import java.util.function.Predicate;

import javax.swing.ImageIcon;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.event.ChangeEvent;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.app.gui.WizardPanel;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.geodb.TableInfo;

import org.gvsig.geodb.TableInfoController;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

import org.gvsig.tools.swing.api.pickercontroller.PickerController;

import org.gvsig.tools.swing.api.task.TaskStatusController;

import org.gvsig.tools.swing.api.task.TaskStatusSwingManager;

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.swing.icontheme.IconTheme;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_OK;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspace;

import org.gvsig.vcsgis.lib.workspace.VCSGisWorkspaceEntity;

import org.gvsig.vcsgis.swing.VCSGisEntitySelectorController;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_BEGIN_PROCESSING_ID;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_CHECK_ID;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_END_PROCESSING_ID;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_RELOAD_ID;

import static org.gvsig.vcsgis.swing.VCSGisEntitySelectorController.ACTION_SELECT_ID;

import org.gvsig.vcsgis.swing.VCSGisJInitWorkspace;

import org.gvsig.vcsgis.swing.VCSGisSwingLocator;

import org.gvsig.vcsgis.swing.VCSGisSwingManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractWizardVCSGis extends WizardPanel {

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractWizardVCSGis.class);

    private WizardVCSGisViewExtended view;

    private PickerController<VCSGisWorkspace> workspacePicker;

    protected Map<String, TableInfo> tablesInfo = null;

    private boolean processing;

    private TaskStatusController taskStatusController;

    private TableInfoController tableInfoController;

    private VCSGisEntitySelectorController entitySelector;

    public AbstractWizardVCSGis() {

        initComponents();

    }

    private void initComponents() {

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        this.view = new WizardVCSGisViewExtended();

//        this.view.txtRepositoryInfo.setVisible(false);

        this.entitySelector = swingManager.createEntitySelectorController(

                this.view.treeTables, 

                this.view.txtTablesFilter, 

                this.view.btnTablesFilter);

        Predicate<VCSGisEntity> entitySelectorFilter = VCSGisEntitySelectorController.ALL_ENTITIES;

        if(this.requireGeometry()){

            entitySelectorFilter = (VCSGisEntity t) -> (StringUtils.isNotBlank(t.getGeometryFieldName()));

        }

        this.entitySelector.setFilter(entitySelectorFilter);

        this.entitySelector.setViewFilter(entitySelectorFilter);

        this.entitySelector.setLabelEntityFormatter(this.getLabelEntityFormatter());

        this.entitySelector.setChecksEnabled(true);

        TaskStatusSwingManager taskStatusManager = ToolsSwingLocator.getTaskStatusSwingManager();

        this.taskStatusController = taskStatusManager.createTaskStatusController(

                this.view.lblStatusTitle,

                this.view.lblStatusMessages,

                this.view.pbStatus

        );

        this.taskStatusController.setShowCancelButton(false);

        this.taskStatusController.setShowRemoveTaskButton(false);

        this.taskStatusController.bind(ToolsLocator.getTaskStatusManager());

        toolsSwingManager.translate(this.view.lblColumns);

        toolsSwingManager.translate(this.view.lblWorkspace);

        toolsSwingManager.translate(this.view.lblFilter);

        toolsSwingManager.translate(this.view.lblGeometryField);

        toolsSwingManager.translate(this.view.lblIdField);

        toolsSwingManager.translate(this.view.lblName);

        toolsSwingManager.translate(this.view.lblProjection);

        toolsSwingManager.translate(this.view.lblTable);

        toolsSwingManager.translate(this.view.cboWorkspaces);

        toolsSwingManager.translate(this.view.btnAddWorkspace);

        toolsSwingManager.translate(this.view.btnCheckout);

        toolsSwingManager.translate(this.view.btnInitWorkspace);

        toolsSwingManager.translate(this.view.chkMaintainStructureInToC);

        this.view.btnInitWorkspace.setText(toHTML(this.view.btnInitWorkspace.getText()));

//        toolsSwingManager.translate(this.view.txtRepositoryInfo);

        toolsSwingManager.addClearButton(this.view.txtName);

        toolsSwingManager.setDefaultPopupMenu(this.view.txtName);

        this.view.btnInitWorkspace.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.view.btnAddWorkspace.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.workspacePicker = swingManager.createWorkspacePickerController(

            this.view.cboWorkspaces,

            this.view.btnAddWorkspace

        );

        this.workspacePicker.addChangeListener((ChangeEvent e) -> {

            doChangeWorkspace();

            doUpdateComponents();

        });

        this.entitySelector.addActionListener((ActionEvent e) -> {

            switch(e.getID()){

                case ACTION_RELOAD_ID:

                    doReloadTablesInfo();

                    break;

                case ACTION_BEGIN_PROCESSING_ID:

                case ACTION_END_PROCESSING_ID:

                    doUpdateComponents();

                    break;

                case ACTION_SELECT_ID:

                    doChangeTableSelected();

                    break;

                case ACTION_CHECK_ID:

                    doChangeTableChecked();

                    doUpdateComponents();

                    break;

            }

        });

        this.view.btnInitWorkspace.addActionListener((ActionEvent e) -> {

            doShowInitWorkspace();

        });

        this.view.btnCheckout.addActionListener((ActionEvent e) -> {

            doCheckout();

        });

        this.tableInfoController = new TableInfoController(

                this.view.btnDeselectAllColumns,

                this.view.btnSelectAllColumns,

                this.view.lstColumns,

                this.view.txtName,

                this.view.cboIdField,

                this.view.cboGeometryField,

                this.view.txtProjection,

                this.view.btnProjection,

                this.view.txtFilter,

                this.view.btnFilter,

                this.view.btnFilterBookmarks,

                this.view.btnFilterHistory,

                this.view.btnAdvancedProperties,

                this.view.lblReadOnlyNotification,

                null,

                this.view.btnChangeViewProjection

        );

        this.view.btnChangeViewProjection.setVisible(this.requireGeometry());

        this.view.btnInitWorkspace.setBackground(UIManager.getColor("Panel.background"));

//        this.view.txtRepositoryInfo.setBackground(UIManager.getColor("Panel.background"));

        this.clearTables();

        this.view.chkMaintainStructureInToC.setVisible(false);

        this.view.chkMaintainStructureInToC.setSelected(true);

        this.setLayout(new BorderLayout());

        this.add(this.view, BorderLayout.CENTER);

        ToolsSwingUtils.ensureRowsCols(this, 22, 90, 25, 100);

        doUpdateComponents();

    }

    protected abstract boolean requireGeometry();

    protected boolean maintainStructureInToC() {

        return this.view.chkMaintainStructureInToC.isSelected();

    }

    protected void setVidibleMaintainStructureInToC(boolean visible) {

        this.view.chkMaintainStructureInToC.setVisible(visible);

    }

    protected Collection<TableInfo> getTablesInformation() {

        this.updateTableInfoFromUI();

        if( this.tablesInfo == null ) {

            this.tablesInfo = new HashMap<>();

        }

        return this.tablesInfo.values();

    }

    private void clearTables() {

        this.entitySelector.clear();

        this.tableInfoController.clear();

    }

    private void doChangeWorkspace() {

        if (notInSwingThreadInvokeLater(this::doChangeWorkspace)) {

            return;

        }

        VCSGisWorkspace workspace = workspacePicker.get();

        this.entitySelector.setWorkspace(workspace);

//        if (workspace == null) {

//            this.view.txtRepositoryInfo.setText("");

//            return;

//        }

//

//        this.view.txtRepositoryInfo.setText(workspace.getRepository().getLabel());

    }

    private TableInfo getTableInfo(VCSGisEntity entity){

        Collection<TableInfo> tablesInformation = getTablesInformation();

        for (TableInfo tableInfo : tablesInformation) {

            VCSGisEntity tableInfoEntity = (VCSGisEntity) tableInfo.getProperty("entity");

            if(tableInfoEntity!=null && StringUtils.equals(tableInfoEntity.getEntityCode(), entity.getEntityCode())){

                return tableInfo;

            }

        }

        return null;

    }

    private void doChangeTableSelected() {

        if( notInSwingThreadInvokeLater(() -> {doChangeTableSelected();}) ) {

            return;

        }

        VCSGisEntity selected = this.entitySelector.getSelectedEntity();

        if(selected == null){

            this.tableInfoController.put(null);

            return;

        }

        TableInfo tableInfo = getTableInfo(selected);

        if (tableInfo != null) {

            this.updateTableInfoFromUI();

            this.tableInfoController.put(tableInfo);

            this.tableInfoController.setEnabled(true);

        } else {

            this.tableInfoController.clear();

            this.tableInfoController.setEnabled(false);

        }

        showMessage("");

        doUpdateComponents();

    }

    private void doChangeTableChecked() {

        List<VCSGisEntity> checkedEntities = this.entitySelector.getCheckedEntities();

        for (VCSGisEntity checkedEntity : checkedEntities) {

            if(!(checkedEntity instanceof VCSGisWorkspaceEntity)){

                this.entitySelector.unCheck(checkedEntity);

            }

        }

        Collection<TableInfo> tablesInformation = getTablesInformation();

        for (TableInfo tableInfo : tablesInformation) {

            VCSGisEntity tableInfoEntity = (VCSGisEntity) tableInfo.getProperty("entity");

            tableInfo.setSelected(checkedEntities.contains(tableInfoEntity));

        }

        this.checkFinishable();

    }

    private void updateTableInfoFromUI() {

        String previousId = this.tableInfoController.getId();

        if (previousId == null) {

            return;

        }

        if (this.tablesInfo != null && !this.tablesInfo.isEmpty()) {

            TableInfo previousInfo = this.tablesInfo.get(previousId);

            if (previousInfo != null) {

                this.tableInfoController.fetch(previousInfo);

            }

        }

    }

    @Override

    public void initWizard() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        setTabName(i18n.getTranslation("_VCSGis"));

    }

    @Override

    public boolean areSettingsValid() {

        if(processing){

            return false;

        }

        boolean hasInvalidValues = false;

        boolean hasSelectedTables = false;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if (tableInfo.isSelected()) {

                hasSelectedTables = true;

                if (!tableInfo.hasValidValues()) {

                    hasInvalidValues = true;

                }

            }

        }

        return hasSelectedTables && !hasInvalidValues;

    }

    @Override

    public DataStoreParameters[] getParameters() {

        int sz = 0;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if( tableInfo.isSelected() ) {

                sz++;

            }

        }

        if( sz == 0 ) {

            return null;

        }

        DataStoreParameters[] dbParameters = new DataStoreParameters[sz];

        int n = 0;

        for (TableInfo tableInfo : this.getTablesInformation() ) {

            if( tableInfo.isSelected() ) {

                dbParameters[n++] = tableInfo.getParameters();

            }

        }

        return dbParameters;

    }

    @Override

    public void execute() {

        executeWizard();

    }

    @Override

    public void close() {

    }

    protected void checkFinishable() {

        boolean finishable = areSettingsValid();

        callStateChanged(finishable);

    }

    private void doUpdateComponents() {

        VCSGisEntity entity = this.entitySelector.getSelectedEntity();

        boolean theProcessing = this.processing || this.entitySelector.isProcessing();

        VCSGisWorkspace ws = getWorkspace();

        if(entity == null){

            this.view.btnCheckout.setEnabled(false);

            this.tableInfoController.setEnabled(false);

        } else if(entity instanceof VCSGisWorkspaceEntity){

            this.view.btnCheckout.setEnabled(false);

            this.tableInfoController.setEditable(!theProcessing && ws != null);

            this.tableInfoController.setEnabled(ws != null);

        } else { //Entidad de repositorio

            this.view.btnCheckout.setEnabled(!theProcessing && ws != null);

            this.tableInfoController.setEnabled(false);

        }

        this.entitySelector.setEnabled(!theProcessing && ws != null);

        this.workspacePicker.setEnabled(!theProcessing);

        this.view.btnInitWorkspace.setEnabled(!theProcessing);

//        this.view.txtRepositoryInfo.setEnabled(!theProcessing && ws != null);

        this.setVisibleStatus(theProcessing);

        this.checkFinishable();

    }

    private void doShowInitWorkspace() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

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

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        final VCSGisJInitWorkspace panelInitWorkspace = swingManager.createInitWorkspacePanel();

        final Dialog dialogInitWorkspace = winManager.createDialog(

                panelInitWorkspace.asJComponent(),

                i18nManager.getTranslation("_VCS_Initialize_workingcopy"),

                i18nManager.getTranslation("_VCS_Initialize_workingcopy"),

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        panelInitWorkspace.setDialog(dialogInitWorkspace);

        dialogInitWorkspace.setButtonLabel(

                WindowManager_v2.BUTTON_OK,

                i18nManager.getTranslation("_VCS_Initialize_workingcopy")

        );

        dialogInitWorkspace.addActionListener((ActionEvent e) -> {

            switch (dialogInitWorkspace.getAction()) {

                case WindowManager_v2.BUTTON_OK:

                    int r = panelInitWorkspace.initializeWorkspace();

                    if (r != 0) {

                        String message = "_Cant_initialize_workingcopy_{0}";

                        StringBuilder compoundMessage = new StringBuilder();

                        String[] messageArgs = new String[]{panelInitWorkspace.getWorkspaceName()};

                        compoundMessage.append(i18nManager.getTranslation(

                                message,

                                messageArgs

                        ));

                        ThreadSafeDialogsManager dialogsManager = ToolsSwingLocator.getThreadSafeDialogsManager();

                        dialogsManager.messageDialog(

                                compoundMessage.toString(),

                                i18nManager.getTranslation("_VCS_Initialize_workingcopy"),

                                JOptionPane.WARNING_MESSAGE

                        );

                    }

                    break;

            }

        });

        dialogInitWorkspace.show(WindowManager.MODE.DIALOG);

    }

    public VCSGisWorkspace getWorkspace() {

        return this.workspacePicker.get();

    }

    private void doReloadTablesInfo() {

        if (notInSwingThreadInvokeLater(() -> { doReloadTablesInfo(); })) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

            Collection<VCSGisEntity> entities = this.entitySelector.getEntities();

            for (VCSGisEntity entity : entities) {

                if (entity instanceof VCSGisWorkspaceEntity) {

                    JDBCStoreParameters parameters = getWorkspace().getExplorer().get(entity.getEntityName());

                    TableInfo tableInfo = new TableInfo(entity.getEntityName(), parameters, this.requireGeometry(), false);

                    if(StringUtils.isNotBlank(entity.getLabel()) ) {

                        tableInfo.setDocumentName(entity.getLabel());

                    }

                    tableInfo.setProperty("entity", entity);

                    this.tablesInfo.put(tableInfo.getId(), tableInfo);

                }

            }

        } catch (Exception e) {

            LOGGER.warn("_Cant_update_layers_list", e);

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(