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.app</artifactId>

        <version>1.0.89</version>

    </parent>

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

    <packaging>jar</packaging>

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

    <properties>

        <!-- Package info property values -->

        <gvsig.package.info.state>testing</gvsig.package.info.state>

        <gvsig.package.info.official>true</gvsig.package.info.official>

        <gvsig.package.info.name>vcsgis</gvsig.package.info.name>

        <gvsig.package.info.description>Provides tools for Version Control System (VCS) for GIS.</gvsig.package.info.description>

        <gvsig.package.info.categories />

        <gvsig.package.info.javaVM>j1_8</gvsig.package.info.javaVM>

        <gvsig.package.info.poolURL>https://devel.gvsig.org/download/projects/gvsig-vcsgis/pool</gvsig.package.info.poolURL>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.andami</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

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

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.app.document.table.app.mainplugin</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.apache.httpcomponents</groupId>

            <artifactId>httpclient</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.geodb.app.mainplugin</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>javax.servlet</groupId>

            <artifactId>javax.servlet-api</artifactId>

            <version>3.1.0</version>

            <scope>compile</scope>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-surefire-plugin</artifactId>

                <configuration>

                    <systemPropertyVariables>

                        <user.language>es</user.language>

                        <user.region>ES</user.region>

                    </systemPropertyVariables>                    

                    <!-- Skip test execution ? -->

                    <skipTests>true</skipTests>

                    <!-- Ignore test execution failure ? -->

                    <testFailureIgnore>false</testFailureIgnore>

                </configuration>

            </plugin>

            <!-- Skip test compilation ? -->

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-compiler-plugin</artifactId>

                <executions>

                    <execution>

                        <id>default-testCompile</id>

                        <phase>process-test-sources</phase>

                        <goals>

                            <goal>testCompile</goal>

                        </goals>

                        <configuration>

                            <skip>false</skip>

                        </configuration>

                    </execution>

                </executions>

            </plugin>

        </plugins>

    </build>

</project>

#Mon Dec 12 00:06:45 CET 2022

buildNumber=99

<!-- gvSIG. Desktop Geographic Information System. Copyright (C) 2007-2013 gvSIG

  Association. This program is free software; you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by the Free Software

  Foundation; either version 3 of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

  PURPOSE. See the GNU General Public License for more details. You should have received

  a copy of the GNU General Public License along with this program; if not, write to

  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,

  USA. For any additional information, do not hesitate to contact us at info AT gvsig.com,

  or visit our website www.gvsig.com. -->

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

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

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <include>org.gvsig:org.gvsig.vcsgis.lib.api</include>

        <include>org.gvsig:org.gvsig.vcsgis.lib.impl</include>

        <include>org.gvsig:org.gvsig.vcsgis.swing.api</include>

        <include>org.gvsig:org.gvsig.vcsgis.swing.impl</include>

        <include>javax.servlet:javax.servlet-api</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

package org.gvsig.vcsgis.app.addlayer;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.StoresRepository;

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.geodb.TableInfo;

import org.gvsig.vcsgis.lib.VCSGisEntity;

/**

 *

 * @author jjdelcerro

 */

public class VCSGisTableInfo extends TableInfo {

    private VCSGisEntity entity;

    public VCSGisTableInfo(VCSGisEntity entity, JDBCStoreParameters parameters, boolean requireGeometry, boolean isView) {

        super(entity.getEntityName(), parameters, requireGeometry, isView);

        this.entity = entity;

    }

    public VCSGisEntity getEntity() {

        return this.entity;

    }

    @Override

    protected void fetchFromStore() {

        if (this.featureType != null) {

            return;

        }

        try {

            this.featureType = entity.getFeatureType();

            this.table = this.featureType.getTags().getString("Layer.name", this.table);

            FeatureAttributeDescriptor attr = this.featureType.getDefaultGeometryAttribute();

            if (attr != null) {

                GeometryType geomType = attr.getGeomType();

                if (geomType != null) {

                    if (this.getGeometryType() == Geometry.TYPES.UNKNOWN) {

                        this.setGeometryType(geomType.getType());

                    }

                    if (this.getGeometrySubtype() == Geometry.SUBTYPES.UNKNOWN) {

                        this.setGeometrySubtype(geomType.getSubType());

                    }

                }

                if (this.getProjection() == null) {

                    this.setProjection(attr.getSRS());

                }

            }            

            if (this.readOnly == null) {

                this.readOnly = false; //!store.allowWrite();

            }

            // this force calculate some required values of tableinfo

            this.getGeomFieldComboModel();

            this.getIdFieldComboModel();

        } catch (Exception ex) {

            LOGGER.trace("Can't get feature type.", ex); // To allow set break points

        } finally {

        }

    }

    public boolean existsDALInfo() {    

        return true;

    }

    boolean needConnectToModel() {

        VCSGisEntity e = this.getEntity();

        DataManager dataManager = DALLocator.getDataManager();

        StoresRepository globalRepository = dataManager.getStoresRepository();

        boolean connected = false;

        boolean hasModels = false;

        for (String dataModel : e.getDataModelsAsList()) {

            if( dataModel==null ) {

                continue;

            }

            hasModels = true;

            if( globalRepository.getSubrepository(dataModel)!=null ) {

                connected = true;

                break;

            }

        }

        if( !hasModels ) {

            return false;

        }

        return !connected;

    }

}

package org.gvsig.vcsgis.app.addlayer;

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.event.ActionEvent;

import java.net.URL;

import java.util.ArrayList;

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

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JTextField;

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.geodb.TableInfo;

import org.gvsig.geodb.TableInfoController;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

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

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

    protected WizardVCSGisViewExtended view;

    private PickerController<VCSGisWorkspace> workspacePicker;

    protected Map<String, TableInfo> tablesInfo = null;

    private boolean processing;

    private TaskStatusController taskStatusController;

    private TableInfoController tableInfoController;

    private VCSGisEntitySelectorController entitySelector;

    private class VCSGisTableInfoController extends TableInfoController {

        public VCSGisTableInfoController(JButton btnDeselectAllColumns, JButton btnSelectAllColumns, JList lstColumns, JTextField txtName, JComboBox cboIdField, JComboBox cboGeometryField, JTextField txtProjection, JButton btnProjection, JTextField txtFilter, JButton btnFilter, JButton btnFilterBookmarks, JButton btnFilterHistory, JButton btnAdvancedProperties, JLabel lblReadOnlyNotification, JComponent pnlCfgActions, JButton btnChangeViewProjection, JCheckBox visible) {

            super(btnDeselectAllColumns, btnSelectAllColumns, lstColumns, txtName, cboIdField, cboGeometryField, txtProjection, btnProjection, txtFilter, btnFilter, btnFilterBookmarks, btnFilterHistory, btnAdvancedProperties, lblReadOnlyNotification, pnlCfgActions, btnChangeViewProjection, visible);

        }

        @Override

        public void put(TableInfo tableInfo) {

            if( tableInfo!=null ) {

                Boolean v = tableInfo.getVisible();

                if( v == null ) {

                    VCSGisEntity entity = ((VCSGisTableInfo)tableInfo).getEntity();

                    if( entity!=null ) {

                        String category = getCategory(entity);

                        boolean defaultVisibility = entity.getCategoryTags(category).getBoolean("visibility",true);

                        tableInfo.setVisible(defaultVisibility);

                    }

                }

            }

            super.put(tableInfo);

        }

        @Override

        protected void updateLabel(StringBuilder builder) throws LocatorException {

            super.updateLabel(builder);

            I18nManager i18n = ToolsLocator.getI18nManager();

            VCSGisTableInfo info = (VCSGisTableInfo) this.getTableInfo();

            if( info.needConnectToModel() ) {

                builder.append(" - <b>");

                builder.append(i18n.getTranslation("_Connect_to_model_required"));

                builder.append(" (");

                builder.append(info.getEntity().getDataModels());

                builder.append(")</b>");

            }

        }

    }

    public AbstractWizardVCSGis() {

        initComponents();

    }

    private static void waitCursor(Component component, Runnable action) {

        Cursor saved_cursor = component.getCursor();

        try {

            component.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));

            action.run();

        } finally {

            component.setCursor(saved_cursor);

        }

    }

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

        toolsSwingManager.translate(this.view.btnTablesCheckAll);

        toolsSwingManager.translate(this.view.btnTablesUncheckAll);

        toolsSwingManager.translate(this.view.btnTablesCollapseAll);

        toolsSwingManager.translate(this.view.btnTablesExpandAll);

        toolsSwingManager.translate(this.view.chkCheckScale);

        toolsSwingManager.translate(this.view.chkAddToCWhenLoadingAll);

        toolsSwingManager.translate(this.view.tabTableInfo);

        toolsSwingManager.translate(this.view.lblVisible);

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

            waitCursor(this, () -> {

                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.btnTablesCheckAll.addActionListener((ActionEvent e) -> {

//            this.entitySelector.checkAll();

            waitCursor(this, () -> {

                List<String> entityCodes = new ArrayList<>();

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

                for (VCSGisEntity entity : entities) {

                    if( entity instanceof VCSGisWorkspaceEntity ){

                        entityCodes.add(entity.getEntityCode());

                    }                

                }

                entitySelector.setCheck(entityCodes, true);

            });

        });

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

            this.entitySelector.clearChecks();

        });

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

            this.entitySelector.collapseAll();

        });

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

            this.entitySelector.expandAll();

        });

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

            doShowInitWorkspace();

        });

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

            doCheckout();

        });

        this.tableInfoController = new VCSGisTableInfoController(

                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.chkVisible

        );

        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.view.chkCheckScale.setSelected(true);

        this.view.chkAddToCWhenLoadingAll.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();

        List<String> entityCodes = new ArrayList<>();

        for (VCSGisEntity checkedEntity : checkedEntities) {

            if( checkedEntity!=null && !(checkedEntity instanceof VCSGisWorkspaceEntity)){

                entityCodes.add(checkedEntity.getEntityCode());

            }

        }

        this.entitySelector.setCheck(entityCodes, false);

        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.view.btnTablesCheckAll.setEnabled(this.entitySelector.isEnabled());

        this.view.btnTablesUncheckAll.setEnabled(this.entitySelector.isEnabled());

        this.view.btnTablesCollapseAll.setEnabled(this.entitySelector.isEnabled());

        this.view.btnTablesExpandAll.setEnabled(this.entitySelector.isEnabled());

        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 VCSGisTableInfo(entity, 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(

                    i18n.getTranslation("_Cant_update_layers_list") + "\n" + e.getMessage(),

                    i18n.getTranslation("_Add_layer"),

                    JOptionPane.WARNING_MESSAGE

            );

        }

    }

    private void doCheckout() {

        VCSGisWorkspace workspace = getWorkspace();

        if (workspace == null) {

            return;

        }

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        I18nManager i18n = ToolsLocator.getI18nManager();

        VCSGisEntity rEntity = this.entitySelector.getSelectedEntity();

        if(rEntity== null || rEntity instanceof VCSGisWorkspaceEntity){

            return;

        }

        final String entityName = rEntity.getEntityName();

        Thread task = new Thread(() -> {

            try {

                processing = true;

                doUpdateComponents();

                showMessage(i18n.getTranslation("_Checking_out"));

                int res = workspace.checkout(

                        entityName,

                        null,

                        this.getTaskStatusController().getSimpleTaskStatus()

                );

                if (res != ERR_OK) {

                    LOGGER.warn("_Cant_checkout_table");

                    dialogs.messageDialog(

                            i18n.getTranslation("_Cant_checkout_table") + "\n" + workspace.getErrorMessage(res),

                            i18n.getTranslation("_Add_table"),

                            JOptionPane.WARNING_MESSAGE

                    );

                    return;

                }

                downloadAndRegisterResources(entityName);

                showMessage(i18n.getTranslation("_Checkout_finished"));

                JDBCStoreParameters parameters = getWorkspace().getExplorer().get(entityName);

                TableInfo tableInfo = new VCSGisTableInfo(workspace.getWorkspaceEntity(entityName), parameters, this.requireGeometry(), false);

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

                doPostCheckout(entityName);

            } catch (Exception e) {

                LOGGER.warn("_Cant_add_table");

                dialogs.messageDialog(

                        i18n.getTranslation("_Cant_add_table") + "\n" + e.getMessage(),

                        i18n.getTranslation("_Add_table"),

                        JOptionPane.WARNING_MESSAGE

                );

            } finally {

                processing = false;

                doUpdateComponents();

            }

        }, "VCSGisAddTableCheckout");

        processing = true;

        doUpdateComponents();

        task.start();

    }

    private void doPostCheckout(String entityName) {

        if (notInSwingThreadInvokeLater(() -> { doPostCheckout(entityName); })) {

            return;

        }

        VCSGisWorkspace workspace = getWorkspace();

        if (workspace == null) {

            return;

        }

        doChangeWorkspace();

        this.entitySelector.setSelectedEntity(workspace.getWorkspaceEntity(entityName));

        doChangeTableSelected();

    }

    private void showMessage(String message) {

        if( notInSwingThreadInvokeLater(() -> {showMessage(message);}) ) {

            return;

        }

        this.view.lblStatusMessages.setText(message);

    }

        public boolean isProcessing() {

        return processing;

    }

    public void setVisibleStatus(boolean visible) {

        if( notInSwingThreadInvokeLater(() -> {setVisibleStatus(visible);}) ) {

            return;

        }

        this.view.lblStatusTitle.setVisible(visible);

        this.view.pbStatus.setVisible(visible);

        this.view.lblStatusMessages.setVisible(true);

    }

    public TaskStatusController getTaskStatusController() {

        return this.taskStatusController;

    }

    public static boolean notInSwingThreadInvokeLater(Runnable x) {

        if( SwingUtilities.isEventDispatchThread() ) {

            return false;

        }

        SwingUtilities.invokeLater(x);

        return true;

    }

    protected static class WizardVCSGisViewExtended extends AbstractWizardVCSGisView {

        @Override

        public ImageIcon loadImage(String imageName) {

            String name = FilenameUtils.getBaseName(imageName);

            IconTheme theme = ToolsSwingLocator.getIconThemeManager().getDefault();

            if (theme.exists(name)) {

                return theme.get(name);

            }

            URL url = WizardVCSGisViewExtended.class.getResource("images/" + name + ".png");

            if (url == null) {

                return null;

            }

            return new ImageIcon(url);

        }

    }

    private String toHTML(String s) {

      s = StringUtils.replace(s, "\n", "<br>");

      s = StringUtils.replace(s, "<html>", "");

      s = StringUtils.replace(s, "</html>", "");

      s = "<html>"+s+"</html>";

      return s;

    }

    protected void downloadAndRegisterResources(String tableName) {

        VCSGisWorkspace workspace = getWorkspace();

        VCSGisWorkspaceEntity entity = workspace.getWorkspaceEntityByName(tableName);

        if(entity == null){

            return;

        }

        VCSGisEntity lEntity = workspace.getEntity(entity.getEntityCode());

        String resources = lEntity.getResources();

        if (StringUtils.isNotBlank(resources)) {

            try {

                if (!workspace.existsInWorkspace(resources)) {

                    workspace.checkout(

                            resources,

                            null

                    );

                }

            } catch (Exception e) {

                LOGGER.warn("Can't checkout resources table '" + resources + "'", e);

            }

            workspace.getExplorer().setCustomResources(entity.getEntityName(), resources,true);

        }

    }

    @Override

    public void setMapContext(MapContext mapContext) {

        super.setMapContext(mapContext);

        this.tableInfoController.setMapContext(mapContext);

    }

    protected Function<VCSGisEntity,String> getLabelEntityFormatter() {

        return null;

    }

    protected boolean getCheckScale() {

        return this.view.chkCheckScale.isSelected();

    }

    protected boolean getAddToCWhenLoadingAll() {

        return this.view.chkAddToCWhenLoadingAll.isSelected();

    }

    protected String getCategory(VCSGisEntity entity) {

        return this.entitySelector.getCategory(entity);

    }

    protected void registerDataModelRepository(VCSGisWorkspace workspace, String dataModelName) {

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services = swingManager.getDefaultServices();

        workspace.registerDataModelRepository(dataModelName);

        services.connectedToModel(workspace, dataModelName);

    }  

}

/*

 * 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.addlayer;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang.StringUtils;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.tools.util.IsEmpty;

/**

 *

 * @author jjdelcerro

 */

public class LayersWithGroup implements Iterable<FLayer>, IsEmpty {

    //        private final VCSGisWorkspace workspace;

    private final Map<String, FLayer> treelayers;

    private final List<FLayer> layers;

    private final MapContext mapContext;

    public LayersWithGroup(MapContext mapContext) {

        //            this.workspace = workspace;

        this.treelayers = new LinkedHashMap<>();

        this.layers = new ArrayList<>();

        this.mapContext = mapContext;

    }

    public synchronized void add(String groupName, String layerName, FLayer layer) {

//        layer.setVisible(true);

        layers.add(layer);

        if (StringUtils.isBlank(layerName)) {

            treelayers.put(layer.getName(), layer);

            return;

        }

        if (StringUtils.isBlank(groupName)) {

            treelayers.put(layerName, layer);

            return;

        }

        FLayers group = (FLayers) treelayers.get("$$" + groupName);

        if (group == null) {

            group = new FLayers();

            group.setMapContext(this.mapContext);

            group.setName(groupName);

            group.setParentLayer(mapContext.getLayers());

            treelayers.put("$$" + groupName, group);

        }

        group.add(layer);

    }

    public synchronized void updateMapContext(boolean maintainStructureInToC, boolean replaceLayerIfExists) {

        this.updateMapControl(null, maintainStructureInToC, replaceLayerIfExists);

    }

    public static final int UPDATE_MODE_REPLACE_LAYER_IF_EXISTS = 0;

    public static final int UPDATE_MODE_ADD_DUPLICATES = 1;

    public static final int UPDATE_MODE_SKIP_DUPLICATES = 2;

    public synchronized void updateMapControl(MapControl mapControl, boolean maintainStructureInToC, boolean replaceLayerIfExists) {

        updateMapControl(mapControl, maintainStructureInToC, UPDATE_MODE_REPLACE_LAYER_IF_EXISTS);

    }

    public synchronized void updateMapControl(MapControl mapControl, boolean maintainStructureInToC, int updateMode) {

        mapContext.beginAtomicEvent();

        try {

            if (maintainStructureInToC) {

                FLayers layersToC = mapContext.getLayers();

                for (FLayer aLayer : this) {

                    if (aLayer == null) {

                        continue;

                    }

                    if (aLayer instanceof FLayers) {

                        FLayers group = (FLayers) aLayer;

                        FLayer groupToC = layersToC.getLayer(aLayer.getName());

                        if (groupToC instanceof FLayers) {

                            for (FLayer l : group) {

                                FLyrVect ltoc = getLayer((FLayers)groupToC, (FLyrVect) l);

                                switch(updateMode) {

                                    case UPDATE_MODE_REPLACE_LAYER_IF_EXISTS:

                                        if( ltoc == null ) {

                                            ((FLayers) groupToC).add(l);

                                        } else { 

                                            refreshLayer(ltoc);

                                        }

                                        break;

                                    case UPDATE_MODE_ADD_DUPLICATES:

                                        ((FLayers) groupToC).add(l);

                                        break;

                                    case UPDATE_MODE_SKIP_DUPLICATES:

                                        if( ltoc == null ) {

                                            ((FLayers) groupToC).add(l);

                                        }

                                        break;

                                }

//                                if( replaceLayerIfExists ) {

//                                    FLyrVect ltoc = getLayer((FLayers)groupToC, (FLyrVect) l);

//                                    if( ltoc != null ) {

//                                        refreshLayer(ltoc);

//                                        continue;

//                                    }

//                                }

//                                ((FLayers) groupToC).add(l);

                            }

                        } else {

                            group.setVisible(true);

                            addLayer(mapControl, group);

                        }

                    } else {

                        FLyrVect ltoc = getLayer(layersToC, (FLyrVect) aLayer);

                        switch(updateMode) {

                            case UPDATE_MODE_REPLACE_LAYER_IF_EXISTS:

                                if( ltoc == null ) {

                                    aLayer.setVisible(true);

                                    addLayer(mapControl, aLayer);

                                } else {

                                    refreshLayer(ltoc);

                                }

                                break;

                            case UPDATE_MODE_ADD_DUPLICATES:

                                aLayer.setVisible(true);

                                addLayer(mapControl, aLayer);

                                break;

                            case UPDATE_MODE_SKIP_DUPLICATES:

                                if( ltoc == null ) {

                                    aLayer.setVisible(true);

                                    addLayer(mapControl, aLayer);

                                }

                                break;

                        }

//                        if( replaceLayerIfExists ) {

//                            FLyrVect ltoc = getLayer(layersToC, (FLyrVect) aLayer);

//                            if( ltoc != null ) {

//                                refreshLayer(ltoc);

//                                continue;

//                            }

//                        }

//                        aLayer.setVisible(true);

//                        addLayer(mapControl, aLayer);

                    }

                }

            } else {

                for (FLayer aLayer : this.allLayers()) {

                    addLayer(mapControl, aLayer);

                }

            }

        } finally {

            mapContext.endAtomicEvent();

        }

    }

    private void refreshLayer(FLyrVect layer) {

        try {

            FeatureStore store = layer.getFeatureStore();

            if( store!=null ) {

               store.refresh();

            }

        } catch (DataException ex) {

        }

    }

    private FLyrVect getLayer(FLayers group, FLyrVect layer) {

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

        DataStoreParameters params = ((FLyrVect) layer).getDataStoreParameters();

        for (FLayer layer1 : group) {

            if( layer1 instanceof FLyrVect ) {

                FeatureStore store1 = ((FLyrVect) layer1).getFeatureStore();

                if( store1==null || store == null ) {

                    if( ((FLyrVect)layer1).getDataStoreParameters().isTheSameStore(params) ) {

                        return (FLyrVect) layer1;

                    }

                } else {

                    if( StringUtils.equals(store1.getFullName(), store.getFullName() )) {

                        return (FLyrVect) layer1;

                    }

                }

            }

        }

        return null;

    }

    private void addLayer(MapControl mapControl, FLayer layer) {

        if( mapControl != null ) {

            mapControl.addLayer(layer);

            return;

        }

        this.mapContext.getLayers().add(layer);

        if( !this.mapContext.hasActiveLayers() ) {

          layer.setActive(true);

        }

    }

    public synchronized void disposeLayers() {

        for (FLayer layer : this) {

            layer.dispose();

        }

    }

    @Override

    public boolean isEmpty() {

        return this.treelayers.isEmpty();

    }

    @Override

    public Iterator<FLayer> iterator() {

        return this.treelayers.values().iterator();

    }

    public Collection<FLayer> allLayers() {

        return this.layers;

    }

}

package org.gvsig.vcsgis.app.addlayer;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.List;

import java.util.function.Function;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.lang.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.StoresRepository;

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

import org.gvsig.fmap.dal.store.db.DBStoreParameters;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.mapcontext.BaseCreateLayerParameters;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.geodb.TableInfo;

import static org.gvsig.geodb.vectorialdb.visibility.LayerScaleVisibilityUtils.checkForVisibilityScale;

import org.gvsig.tools.ToolsLocator;

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.task.SimpleTaskStatus;

import static org.gvsig.vcsgis.app.addlayer.AbstractWizardVCSGis.LOGGER;

import org.gvsig.vcsgis.lib.VCSGisEntity;

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

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class WizardVCSGisVectorial extends AbstractWizardVCSGis {

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public WizardVCSGisVectorial() {

        super();

        this.setVidibleMaintainStructureInToC(true);

    }

    @Override

    protected boolean requireGeometry() {

        return true;

    }

    @Override

    public Object executeWizard() {

        DataManager man = DALLocator.getDataManager();

        MapContextManager mapContextManager = MapContextLocator.getMapContextManager();

        MapControl mapControl = this.getMapCtrl();

        MapContext mapContext = mapControl.getMapContext();

        LayersWithGroup layers = new LayersWithGroup(mapContext);

        VCSGisWorkspace workspace = this.getWorkspace();

        boolean checkScale = this.getCheckScale();

        boolean addToCWhenLoadingAll = this.getAddToCWhenLoadingAll();

        for (TableInfo tableInfo : getTablesInformation()) {

            if (!tableInfo.isSelected()) {

                continue;

            }

            if( ((VCSGisTableInfo)tableInfo).needConnectToModel() ) {

                I18nManager i18n = ToolsLocator.getI18nManager();

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                int n = dialogs.confirmDialog(

                        i18n.getTranslation("_Some_of_the_selected_tables_require_connection_to_a_data_model") + 

                                "\n" +

                                i18n.getTranslation("_It_is_recommended_that_you_connect_to_the_data_model_before_loading_the_tables") +

                                "\n" +

                                i18n.getTranslation("_Do_you_want_to_add_the_selected_tables_anyway"), 

                        i18n.getTranslation("_AddLayer"), 

                        JOptionPane.YES_NO_OPTION, 

                        JOptionPane.QUESTION_MESSAGE, 

                        "_Some_of_the_selected_tables_require_connection_to_a_data_model"

                );

                if( n != JOptionPane.YES_OPTION ) {

                    return null;

                }

            }

        }

        Thread th = new Thread(() -> {

            SimpleTaskStatus taskstatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Loading layers");        

            taskstatus.setIndeterminate();

            taskstatus.setAutoremove(true);

            taskstatus.add();

            try {

                List<VCSGisTableInfo> tablesInformation = new ArrayList<>();

                for (TableInfo tableInfo : getTablesInformation()) {

                    if (!tableInfo.isSelected()) {

                        continue;

                    }

                    tablesInformation.add((VCSGisTableInfo) tableInfo);

                }

                tablesInformation.sort(new Comparator<VCSGisTableInfo>() {

                    @Override

                    public int compare(VCSGisTableInfo o1, VCSGisTableInfo o2) {

                        if( o1==null || o2==null ) {

                            return 0;

                        }

                        VCSGisEntity e1 = o1.getEntity();

                        VCSGisEntity e2 = o2.getEntity();

                        if( e1==null || e2==null ) {

                            return 0;

                        }

                        FeatureType ft1 = o1.getFeatureType();

                        FeatureType ft2 = o2.getFeatureType();

                        int order1 = (ft1==null)? 0:ft1.getTags().getInt("TOC_Order",0);

                        int order2 = (ft2==null)? 0:ft2.getTags().getInt("TOC_Order",0);

                        String id1 = String.format("%05d/%02d/%s/%s", order1, getLayerOrderWeight(e1), getCategory(e1), e1.getLabelOrName());

                        String id2 = String.format("%05d/%02d/%s/%s", order2, getLayerOrderWeight(e2), getCategory(e2), e2.getLabelOrName());

                        return id2.compareTo(id1);

                    }

                });

                List<String> dataModels = new ArrayList<>();

                for (VCSGisTableInfo tableInfo : tablesInformation) {

                    VCSGisEntity entity = tableInfo.getEntity();

                    List<String> entityModels = entity.getDataModelsAsList();

                    if( entityModels!=null ) {

                        for (String entityModel : entityModels) {

                            dataModels.add(entityModel);

                        }

                    }

                }

                if( !dataModels.isEmpty() ) {

                    for (StoresRepository storesRepository : man.getStoresRepository().getSubrepositories() ) {

                        dataModels.remove(storesRepository.getID());

                    }

                    for (String dataModel : dataModels) {

                        registerDataModelRepository(workspace, dataModel);

                    }

                }

                taskstatus.setRangeOfValues(0, tablesInformation.size());

                FLayer layer;

                for (VCSGisTableInfo tableInfo : tablesInformation) {

                    if( taskstatus.isCancellationRequested() ) {

                        taskstatus.cancel();

                        return;

                    }

                    taskstatus.message(tableInfo.getEntity().getLabelOrName());

                    LOGGER.info("Load layer '"+tableInfo.getId()+"'");

                    DBStoreParameters params = tableInfo.getParameters();

                    VCSGisEntity entity = tableInfo.getEntity();

                    List<String> entityModels = entity.getDataModelsAsList();

                    if( entityModels!=null ) {

                        for (String entityModel : entityModels) {

                            dataModels.add(entityModel);

                        }

                    }

                    String category = this.getCategory(entity);

                    fixCRS(params);

                    if( tableInfo.getVisible()==null ) {

                        tableInfo.setVisible(entity.getCategoryTags(category).getBoolean("visibility", true));

                    }

                    boolean defaultVisibility = tableInfo.getVisible();

//                    FeatureStore store;

//                    try {

//                        store = (FeatureStore) man.openStore(

//                                params.getDataStoreName(),

//                                params

//                        );

//                    } catch (Exception e) {

//                        LOGGER.warn("While opening DB store.", e);

//                        taskstatus.abort();

//                        return;

//                    }

                    try {

                        layer = mapContextManager.createLayer(

                                tableInfo.getDocumentName(), 

                                new BaseCreateLayerParameters(params, defaultVisibility)

                        );

//                        layer = mapContextManager.createLayer(

//                                tableInfo.getDocumentName(),

//                                store

//                        );

                        if( defaultVisibility ) {

                            checkForVisibilityScale(layer, checkScale);

                        }

                        String tableName = params.getTable();

                        if (StringUtils.isBlank(tableName)) {

                            layers.add(null, null, layer);

                        } else {

                            if (workspace.getWorkspaceEntityByName(tableName) == null) {

                                layers.add(null, tableName, layer);

                            } else {