gvSIG projects pool

    public String getCategory();

    public List<String> getCategoriesAsList();

    public Tags getCategoryTags(String category);

    public String getFirstCategory();

import org.gvsig.online.lib.impl.OnlineCategories;

import org.gvsig.tools.dynobject.Tags;

    private static final String CATEGORY = "ENT_CATEGORY";

        private OnlineCategories categories;

        public String getCategory() {

            return this.getString(CATEGORY);

        }

        @Override

        public OnlineCategories getCategoriesAsList() {

            if( this.categories == null ) {

                this.categories = new OnlineCategories(getCategory());

            }

            return this.categories;

        }

        @Override

        public Tags getCategoryTags(String category) {

            OnlineCategories l = getCategoriesAsList();

            if( l==null ) {

                return Tags.EMPTY_TAGS;

            }

            return l.getTags(category);

        }

        @Override

        public String getFirstCategory() {

            OnlineCategories l = getCategoriesAsList();

            if( CollectionUtils.isEmpty(l) ) {

                return null;

            }

            return l.get(0);

        }

        @Override

        private boolean isOutdated() {

package org.gvsig.online.lib.impl;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.dynobject.Tagged;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.dynobject.impl.DefaultTags;

/**

 *

 * @author jjdelcerro

 */

public class OnlineCategories  extends AbstractList<String> implements List<String> {

    private final String categories_s;

    private List<Category> categories;

    private static class Category implements Tagged {        

        private final String category_s;

        private String name;

        private DefaultTags tags;

        public Category(String category) {

            this.category_s = category;

            this.parse();

        }

        private void parse() {

            this.tags = new DefaultTags();

            this.name = "unknown";

            String[] ss = StringUtils.split(this.category_s, ";");

            if( ArrayUtils.isEmpty(ss) ) {

                return;

            }

            this.name = StringUtils.strip(ss[0]);

            for (int i = 1; i < ss.length; i++) {

                String s1 = ss[i];

                if( StringUtils.isBlank(s1) ) {

                    continue;

                }

                int n = s1.indexOf("=");

                if( n<0 ) {

                    this.tags.set(StringUtils.strip(s1), null);

                } else {

                    String tagname = StringUtils.strip(StringUtils.substring(s1, 0, n));

                    String tagvalue = StringUtils.stripToNull(StringUtils.substring(s1, n+1));

                    this.tags.set(tagname, tagvalue);

                }

            }

        }

        public String getName() {

            return this.name;

        }

        @Override

        public Tags getTags() {

            return this.tags;

        }

    }

    public OnlineCategories(String categories) {

        this.categories_s = categories;

        this.categories = null;

    }

    private List<Category> getCategories() {

        if( this.categories == null ) {

            if( StringUtils.isBlank(this.categories_s) ) {

                this.categories = Collections.EMPTY_LIST;

            } else {

                try{

                    List<Category> r = new ArrayList<>();

                    String[] ss = StringUtils.split(this.categories_s, ",");

                    for (String s1 : ss) {

                        if (StringUtils.isBlank(s1)) {

                            continue;

                        }

                        Category category = new Category(s1);

                        r.add(category);

                    }

                    this.categories = r;

                } catch (Exception ex) {

                    this.categories = Collections.EMPTY_LIST;

                }

            }

        }   

        return this.categories;

    }

    @Override

    public String get(int index) {

        return this.getCategories().get(index).getName();

    }

    @Override

    public int size() {

        return this.getCategories().size();

    }

    public Tags getTags(String name) {

        for (Category category : this.getCategories()) {

            if( StringUtils.equalsIgnoreCase(name, category.getName()) ) {

                return category.getTags();

            }

        }

        return Tags.EMPTY_TAGS;

    }

}

    @Override

    public String getCategory(OnlineEntity entity) {

        String category = this.categoryOfCheckedEntity.get(entity.getEntityCode());

        if( StringUtils.isBlank(category) ) {

            category = entity.getFirstCategory();

        }

        return category;

    }

    @Override

    public String getCategory(OnlineEntity entity) {

        String category = entity.getFirstCategory();

        return category;

    }

    @Override

    public String getCategory(OnlineEntity entity) {

        String category = entity.getFirstCategory();

        return category;

    }

    @Override

    public PickerController<OnlineWorkingcopy> createPickerWorkspaceController(JComboBox combo, JButton btnInitWorkspace) {

        OnlineWorkingcopyPickerControllerImpl picker = new OnlineWorkingcopyPickerControllerImpl(combo, btnInitWorkspace);

        return picker;

    }

    public String getCategory(OnlineEntity category);

    public PickerController<OnlineWorkingcopy> createPickerWorkspaceController(JComboBox combo, JButton btnInitWorkspace);

import org.gvsig.app.extension.AddLayer;

import org.gvsig.online.app.mainplugin.addlayer.WizardOnlineTabular;

import org.gvsig.online.app.mainplugin.addlayer.WizardOnlineVectorial;

        ApplicationLocator.getManager().registerAddTableWizard(

                "Online", 

                "Online", 

                WizardOnlineTabular.class

        );

        AddLayer.addWizard(WizardOnlineVectorial.class);

package org.gvsig.online.app.mainplugin.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 static org.gvsig.online.lib.api.OnlineManager.ERR_OK;

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

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

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

import static org.gvsig.online.swing.api.OnlineEntitySelectorController.ACTION_BEGIN_PROCESSING_ID;

import static org.gvsig.online.swing.api.OnlineEntitySelectorController.ACTION_CHECK_ID;

import static org.gvsig.online.swing.api.OnlineEntitySelectorController.ACTION_END_PROCESSING_ID;

import static org.gvsig.online.swing.api.OnlineEntitySelectorController.ACTION_RELOAD_ID;

import static org.gvsig.online.swing.api.OnlineEntitySelectorController.ACTION_SELECT_ID;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

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

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractWizardOnline extends WizardPanel {

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

    protected WizardOnlineViewExtended view;

    private PickerController<OnlineWorkingcopy> workspacePicker;

    protected Map<String, TableInfo> tablesInfo = null;

    private boolean processing;

    private TaskStatusController taskStatusController;

    private TableInfoController tableInfoController;

    private OnlineEntitySelectorController entitySelector;

    private class OnlineTableInfoController extends TableInfoController {

        public OnlineTableInfoController(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 ) {

                    OnlineEntity entity = ((OnlineTableInfo)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();

            OnlineTableInfo info = (OnlineTableInfo) 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 AbstractWizardOnline() {

        createComponents();

    }

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

        ToolsSwingUtils.addInitComponentsListener(this, new InitComponentsListener() {

            @Override

            public void doDisposeComponents() {

                disposeComponents();

            }

            @Override

            public void doInitComponents() {

                initComponents();

            }

        });

        this.view = new WizardOnlineViewExtended();

        this.tableInfoController = new OnlineTableInfoController(

                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

        );

    }

    private void disposeComponents() {

        DisposeUtils.disposeQuietly(entitySelector);

    }

    private void initComponents() {

        if(this.entitySelector != null) {

            return;

        }

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        this.entitySelector = swingManager.createEntitySelectorController(

                this.view.treeTables, 

                this.view.txtTablesFilter, 

                this.view.btnTablesFilter);

        Predicate<OnlineEntity> entitySelectorFilter = OnlineEntitySelectorController.ALL_ENTITIES;

        if(this.requireGeometry()){

            entitySelectorFilter = (OnlineEntity 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);

        toolsSwingManager.translate(this.view.btnConnectToModel);

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

        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.createPickerWorkspaceController(

            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<OnlineEntity> entities = entitySelector.getEntities();

                for (OnlineEntity entity : entities) {

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

//            doConnectToModel();

//        });

        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 setVisibleMaintainStructureInToC(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;

        }

        OnlineWorkingcopy 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(OnlineEntity entity){

        Collection<TableInfo> tablesInformation = getTablesInformation();

        for (TableInfo tableInfo : tablesInformation) {

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

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

                return tableInfo;

            }

        }

        return null;

    }

    private void doChangeTableSelected() {

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

            return;

        }

        OnlineEntity 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<OnlineEntity> checkedEntities = this.entitySelector.getCheckedEntities();

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

        for (OnlineEntity checkedEntity : checkedEntities) {

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

                entityCodes.add(checkedEntity.getEntityCode());

            }

        }

        this.entitySelector.setCheck(entityCodes, false);

        Collection<TableInfo> tablesInformation = getTablesInformation();

        for (TableInfo tableInfo : tablesInformation) {

            OnlineEntity tableInfoEntity = (OnlineEntity) 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("_Online"));

    }

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

        OnlineEntity entity = this.entitySelector.getSelectedEntity();

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

        OnlineWorkingcopy ws = getWorkspace();

        if(entity == null){

            this.view.btnCheckout.setEnabled(false);

            this.tableInfoController.setEnabled(false);

        } else if(entity instanceof OnlineEntity){

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

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        final OnlineJInitWorkingcopy panelInitWorkspace = swingManager.createInitWorkspacePanel();

        final Dialog dialogInitWorkspace = winManager.createDialog(

                panelInitWorkspace.asJComponent(),

                i18nManager.getTranslation("_Online_Initialize_workingcopy"),

                i18nManager.getTranslation("_Online_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.actionPerformed();

                    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 OnlineWorkingcopy getWorkspace() {

        return this.workspacePicker.get();

    }

    private void doReloadTablesInfo() {

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

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

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

            for (OnlineEntity entity : entities) {

                if (entity instanceof OnlineEntity) {

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

                    TableInfo tableInfo = new OnlineTableInfo(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() {

        OnlineWorkingcopy workspace = getWorkspace();

        if (workspace == null) {

            return;

        }

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        I18nManager i18n = ToolsLocator.getI18nManager();

        OnlineEntity rEntity = this.entitySelector.getSelectedEntity();

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

            return;

        }

        final String entityName = rEntity.getEntityName();

        Thread task = new Thread(() -> {

            try {

                processing = true;

                doUpdateComponents();

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

                int res = workspace.download(

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

            }

        }, "OnlineAddTableCheckout");

        processing = true;

        doUpdateComponents();

        task.start();

    }

    private void doPostCheckout(String entityName) {

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

            return;

        }

        OnlineWorkingcopy 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 WizardOnlineViewExtended extends AbstractWizardOnlineView {

        @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 = WizardOnlineViewExtended.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) {

        OnlineWorkingcopy workspace = getWorkspace();

        OnlineEntity entity = workspace.getWorkspaceEntityByName(tableName);

        if(entity == null){

            return;

        }

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

//        String resources = lEntity.getResources();

//        if (StringUtils.isNotBlank(resources)) {

//            try {

//                if (!workspace.existsInWorkspace(workspace.getWorkspaceEntity(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<OnlineEntity,String> getLabelEntityFormatter() {

        return null;

    }

    protected boolean getCheckScale() {

        return this.view.chkCheckScale.isSelected();

    }

    protected boolean getAddToCWhenLoadingAll() {

        return this.view.chkAddToCWhenLoadingAll.isSelected();

    }

    protected String getCategory(OnlineEntity entity) {

        return this.entitySelector.getCategory(entity);

    }

    protected void registerDataModelRepository(OnlineWorkingcopy workspace, String dataModelName) {

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        OnlineSwingServices services = swingManager.getDefaultServices();

        workspace.registerDataModelRepository(dataModelName);

        services.connectedToModel(workspace, dataModelName);

    }  

//    private void doConnectToModel() {

//        OnlineWorkingcopy workspace = getWorkspace();

//        if (workspace == null) {

//            return;

//        }

//        I18nManager i18n = ToolsLocator.getI18nManager();

////        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

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

//        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

//        

//        String modelName = null;

//        OnlineEntity entity = this.entitySelector.getSelectedEntity();

//        if(entity != null ){

//            modelName = entity.getFirstDataModel();

//        }

//        OnlineJCheckoutDataModel panel = swingManager.createCheckoutDataModelPanel(workspace, modelName);        

//        Dialog theDialog = winManager.createDialog(

//                panel.asJComponent(),

//                i18n.getTranslation("_VCS_Connect_to_datamodel"),

//                null,

//                WindowManager_v2.BUTTONS_OK_CANCEL

//        );

//        panel.setDialog(theDialog);

//        theDialog.addActionListener((ActionEvent e) -> {

//            if( theDialog.getAction() == WindowManager_v2.BUTTON_OK) {

//                panel.connectToModel();

//            }

//        });        

//        theDialog.show(WindowManager.MODE.DIALOG);

//    }

}

package org.gvsig.online.app.mainplugin.addlayer;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.List;

import java.util.function.Function;

import javax.swing.JOptionPane;

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.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.online.lib.api.workingcopy.OnlineEntity;

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

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;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class WizardOnlineVectorial extends AbstractWizardOnline {

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public WizardOnlineVectorial() {

        super();

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

        OnlineWorkingcopy workspace = this.getWorkspace();

        boolean checkScale = this.getCheckScale();

        for (TableInfo tableInfo : getTablesInformation()) {

            if (!tableInfo.isSelected()) {

                continue;

            }

            if( ((OnlineTableInfo)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<OnlineTableInfo> tablesInformation = new ArrayList<>();

                for (TableInfo tableInfo : getTablesInformation()) {

                    if (!tableInfo.isSelected()) {

                        continue;

                    }

                    tablesInformation.add((OnlineTableInfo) tableInfo);

                }

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

                    @Override

                    public int compare(OnlineTableInfo o1, OnlineTableInfo o2) {

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

                            return 0;

                        }

                        OnlineEntity e1 = o1.getEntity();

                        OnlineEntity 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 (OnlineTableInfo tableInfo : tablesInformation) {

                    OnlineEntity 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 (OnlineTableInfo tableInfo : tablesInformation) {

                    if( taskstatus.isCancellationRequested() ) {

                        taskstatus.cancel();

                        return;

                    }

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

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

                    DBStoreParameters params = tableInfo.getParameters();

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

                    try {

                        layer = mapContextManager.createLayer(

                                tableInfo.getDocumentName(), 

                                new BaseCreateLayerParameters(params, defaultVisibility)

                        );

                        if( defaultVisibility ) {

                            checkForVisibilityScale(layer, checkScale);

                        }

                        mapContext.getLayers().add(layer);

                    } catch (Exception e) {

                        LOGGER.warn("Can't create layer '" + tableInfo.getDocumentName() + "'.", e);

                    } finally {

//                        DisposeUtils.disposeQuietly(store);

                    }

                    taskstatus.incrementCurrentValue();

                }

                taskstatus.terminate();

            } finally {

                // Dispose all created layers. If they have been included into

                // a FLayers object, they will have been binded there.

//                for (FLayer layer : layers) {

//                    layer.dispose();

//                }

            }

        }, "WizardOnlineVectorial");

        th.start();

        return null;

    }

    private void fireLayerErrorEvent(FLayer lyr, MapControl mapControl) {

        mapControl.getMapContext().callNewErrorEvent(null);

    }

    @Override

    protected Function<OnlineEntity, String> getLabelEntityFormatter() { 

        return (OnlineEntity entity) -> {

            String label = this.getWorkspace().formatEntityLabel(entity);

            FeatureType type = entity.getFeatureType();

            if (type == null) {

                return label;

            }

            IProjection srs = type.getDefaultSRS();

            if (srs == null) {

                return label;

            }

            MapContext mapContext1 = getMapContext();

            if (mapContext1 == null) {

                return label + " [" + srs.getAbrev() + "]";

            }

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

                return label + " [" + srs.getAbrev() + "]";

            }

            if (StringUtils.equalsIgnoreCase(mapContext1.getProjection().getAbrev(), srs.getAbrev())) {

                return label + " [" + srs.getAbrev() + "]";

            }

            return label + " [" + srs.getAbrev() + "!]";

        };

    }

    private int getLayerOrderWeight(OnlineEntity entity) {

        int type2d = Geometry.TYPES.SURFACE;

        try {

            GeometryType geomtype = entity.getFeatureType().getDefaultGeometryAttribute().getGeomType();

            type2d = simplifyType(geomtype);

        } catch (Exception e) {

            LOGGER.warn("While getting geo type.", e);

        }

        switch (type2d) {

            case Geometry.TYPES.SURFACE:

                return 2;

            case Geometry.TYPES.CURVE:

                return 1;

            case Geometry.TYPES.POINT:

                return 0;

            default:

                // should not reach this

                return 3;

        }

    }

    private int simplifyType(GeometryType gt) {

        if (gt.isTypeOf(Geometry.TYPES.POINT) || gt.isTypeOf(Geometry.TYPES.MULTIPOINT)) {

            return Geometry.TYPES.POINT;

        } else if (gt.isTypeOf(Geometry.TYPES.CURVE) || gt.isTypeOf(Geometry.TYPES.MULTICURVE)) {

            return Geometry.TYPES.CURVE;

        } else if (gt.isTypeOf(Geometry.TYPES.SURFACE) || gt.isTypeOf(Geometry.TYPES.MULTISURFACE)) {

            return Geometry.TYPES.SURFACE;

        }

        return Geometry.TYPES.SURFACE;

    }

}

package org.gvsig.online.app.mainplugin.addlayer;

import java.util.ArrayList;

import java.util.List;

import javax.swing.JOptionPane;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

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

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

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.StoresRepository;

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

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

import org.gvsig.geodb.TableInfo;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.i18n.I18nManager;

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

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

/**

 *

 * @author jjdelcerro

 */

public class WizardOnlineTabular extends AbstractWizardOnline {