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>

    <groupId>org.gvsig</groupId>

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

    <version>1.0.63</version>

    <packaging>pom</packaging>

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

    <description />

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.desktop</artifactId>

        <version>2.0.373</version>

    </parent>

    <properties>

        <org.gvsig.h2spatial.provider>org.gvsig.h2spatial.h2gis132.provider</org.gvsig.h2spatial.provider>

        <org.gvsig.topology.version>1.0.108</org.gvsig.topology.version>

        <org.gvsig.oracle.version>2.0.89</org.gvsig.oracle.version>

        <org.gvsig.postgresql.version>2.0.210</org.gvsig.postgresql.version>

    </properties>

    <url>https://devel.gvsig.org/sites/org.gvsig.vcsgis/${project.version}</url>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-projects-pool/org.gvsig.vcsgis/tags/org.gvsig.vcsgis-1.0.63</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-projects-pool/org.gvsig.vcsgis/tags/org.gvsig.vcsgis-1.0.63</developerConnection>

        <url>https://devel.gvsig.org/svn/gvsig-projects-pool/org.gvsig.vcsgis/tags/org.gvsig.vcsgis-1.0.63</url>

    </scm>

    <repositories>

        <repository>

            <id>gvsig-public-http-repository</id>

            <name>gvSIG maven public HTTP repository</name>

            <url>http://devel.gvsig.org/m2repo/j2se</url>

            <releases>

                <enabled>true</enabled>

                <updatePolicy>daily</updatePolicy>

                <checksumPolicy>warn</checksumPolicy>

            </releases>

            <snapshots>

                <enabled>true</enabled>

                <updatePolicy>daily</updatePolicy>

                <checksumPolicy>warn</checksumPolicy>

            </snapshots>

        </repository>

    </repositories>

    <distributionManagement>

        <site>

            <id>gvsig-repository</id>

            <url>dav:https://devel.gvsig.org/download/projects/gvsig-vcsgis/pool/${project.artifactId}/${project.version}</url>

        </site>

    </distributionManagement>

    <build>

        <pluginManagement>

            <plugins>

                <plugin>

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

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

                    <configuration>

                        <encoding>UTF-8</encoding>

                    </configuration>

                </plugin>

            </plugins>

        </pluginManagement>

        <plugins>

            <plugin>

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

                <artifactId>maven-release-plugin</artifactId>

                <configuration>

                    <tagBase>https://devel.gvsig.org/svn/gvsig-projects-pool/${project.artifactId}/tags</tagBase>

                </configuration>

            </plugin>

        </plugins>

    </build>

    <dependencyManagement>

        <dependencies>

            <dependency>

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

                <artifactId>maven-war-plugin</artifactId>

                <version>3.2.3</version>

                <type>maven-plugin</type>

            </dependency>

            <dependency>

                <groupId>org.apache.tomcat</groupId>

                <artifactId>tomcat-servlet-api</artifactId>

                <version>9.0.45</version>

            </dependency>

            <dependency>

                <groupId>javax.servlet</groupId>

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

                <version>3.1.0</version>

            </dependency>

            <dependency>

                <groupId>org.eclipse.jetty</groupId>

                <artifactId>jetty-server</artifactId>

                <version>9.4.34.v20201102</version>

            </dependency>

            <dependency>

                <groupId>org.eclipse.jetty</groupId>

                <artifactId>jetty-servlet</artifactId>

                <version>9.4.34.v20201102</version>

            </dependency>

            <dependency>

                <groupId>org.eclipse.jetty</groupId>

                <artifactId>jetty-webapp</artifactId>

                <version>9.4.34.v20201102</version>

                <exclusions>

                    <exclusion>

                        <groupId>javax.servlet</groupId>

                        <artifactId>servlet-api</artifactId>

                    </exclusion>

                </exclusions>

            </dependency>

            <dependency>

                <groupId>org.eclipse.jetty</groupId>

                <artifactId>jetty-util</artifactId>

                <version>9.4.34.v20201102</version>

            </dependency>

            <dependency>

                <groupId>org.eclipse.jetty</groupId>

                <artifactId>jetty-io</artifactId>

                <version>9.4.34.v20201102</version>

            </dependency>

            <dependency>

                <groupId>org.eclipse.jetty</groupId>

                <artifactId>jetty-jndi</artifactId>

                <version>9.4.34.v20201102</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.topology</artifactId>

                <version>${org.gvsig.topology.version}</version>

                <type>pom</type>

                <scope>import</scope>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>${org.gvsig.h2spatial.provider}</artifactId>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.oracle</artifactId>

                <version>${org.gvsig.oracle.version}</version>

                <type>pom</type>

                <scope>import</scope>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.postgresql</artifactId>

                <version>${org.gvsig.postgresql.version}</version>

                <type>pom</type>

                <scope>import</scope>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

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

                <version>1.0.63</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

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

                <version>1.0.63</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

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

                <scope>test</scope>

                <type>test-jar</type>

                <version>1.0.63</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

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

                <version>1.0.63</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

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

                <version>1.0.63</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

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

                <version>1.0.63</version>

                <type>war</type>

            </dependency>

        </dependencies>

    </dependencyManagement>

    <modules>

        <module>org.gvsig.vcsgis.lib</module>

        <module>org.gvsig.vcsgis.swing</module>

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

        <module>org.gvsig.vcsgis.tomcat</module>

    </modules>

</project>

#Mon May 02 09:51:02 CEST 2022

buildNumber=71

<!-- 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>

/*

 * 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 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 final 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();

            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;

    }

}

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

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

        }

    }

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

    }

}

/*

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

                }

            }