gvSIG projects pool

/*

 * 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.online.swing.impl.changes;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.sql.Timestamp;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.swing.DefaultComboBoxModel;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JSplitPane;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import javax.swing.event.ChangeEvent;

import org.apache.commons.lang3.StringUtils;

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

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

import org.gvsig.fmap.mapcontrol.MapControl;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.online.swing.impl.OnlineSwingCommons;

import static org.gvsig.online.swing.impl.OnlineSwingCommons.notInSwingThreadInvokeLater;

import static org.gvsig.online.swing.impl.OnlineSwingCommons.showAuthenticationErrors;

import org.gvsig.online.swing.impl.OnlineSwingLibraryImpl;

import org.gvsig.online.swing.impl.OnlineSwingManagerImpl;

import static org.gvsig.online.swing.impl.OnlineSwingManagerImpl.ICON_GROUP_NAME;

import static org.gvsig.online.swing.impl.OnlineSwingManagerImpl.ICON_PROVIDER_NAME;

import org.gvsig.online.swing.impl.workingarea.WorkingAreaPickerControllerImpl;

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.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.windowmanager.Dialog;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.gvsig.tools.util.PropertiesSupport;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class OnlineJChangesImpl 

        extends OnlineJChangesView 

        implements OnlineJChanges, PropertiesSupport

    {

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

    private static final int ZONE_ONLY_CHANGES = 0;

    private static final int ZONE_CHANGES_AND_WORKING_AREA = 1;

    public static final int NOTCLOSABLE = 64;

    public static final int RESIZABLE = 1;

    public static final int MAXIMIZABLE = 2;

    public static final int ICONIFIABLE = 4;

    public static final int LOCAL_TAB_INDEX = 0;

    public static final int REMOTE_TAB_INDEX = 1;

    private PickerController<OnlineWorkingcopy> workspacePicker;

    private LocalChangesController localChangesController;

    private RemoteChangesController remoteChangesController;

//    private final List<VCSGisWorkspaceEntity> workspaceEntities = null;

//    private final List<OnlineEntity> repositoryEntities = null;

    private boolean entitiesUpdateds;

    private OnlineWorkingcopy currentWorkingcopy;

    private TaskStatusController taskStatusController;

    private Timer timerClearMsg;

    /* friend */ boolean processing;

    private JSplitPane splChanges;

    private SimpleTaskStatus taskStatus;

    private PropertiesSupportHelper propertiesSupport;

    private List<String> defaultTablesSelection;

    private OnlineEntitySelectorController entitySelector;

    private WorkingAreaPickerControllerImpl workingAreaPicker;

    public OnlineJChangesImpl() {

        this(null,null,null, null);

    }        

    public OnlineJChangesImpl(OnlineWorkingcopy workspace, List<String> tableNames, Timestamp efectivedate, String comment) {

        if( tableNames==null ) {

            this.defaultTablesSelection = Collections.EMPTY_LIST;

        } else {

            this.defaultTablesSelection = tableNames;

        }

        this.processing = false;

        this.propertiesSupport = new PropertiesSupportHelper();

        this.propertiesSupport.setProperty("WindowInfo.Flags", NOTCLOSABLE|RESIZABLE|MAXIMIZABLE|ICONIFIABLE);

        initComponents();

        SwingUtilities.invokeLater(() -> {

            this.workspacePicker.set(workspace);

        });

    }

    public List<String> getDefaultTablesSelection() {

        return this.defaultTablesSelection;

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        return OnlineSwingManagerImpl.loadImage(imageName);

    }

    private void translate() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        swingManager.translate(this.lblWorkspace);

        swingManager.translate(this.btnWorkspace);

        swingManager.translate(this.btnClose);

        swingManager.translate(this.tabLocalAndRemote);

        swingManager.translate(this.btnSynchronize);

        swingManager.translate(this.btnLocalCheckRecomendedEntities);

        swingManager.translate(this.btnLocalCheckAllEntities);

        swingManager.translate(this.btnLocalUnCheckAllEntities);

        swingManager.translate(this.btnLocalCollapseAllEntities);

        swingManager.translate(this.btnLocalExpandAllEntities);

        swingManager.translate(this.btnEntitiesReload);

        swingManager.translate(this.lblSynchorizationZone);

        swingManager.translate(this.cboSynchorizationZone);

    }

    private void initComponents() {

        OnlineSwingManager onlineSwingManager = OnlineSwingLocator.getOnlineSwingManager();

        TaskStatusSwingManager taskStatusManager = ToolsSwingLocator.getTaskStatusSwingManager();

        OnlineSwingServices onlineservices = OnlineSwingLocator.getOnlineSwingManager().getDefaultServices();

        this.addComponentListener(new ComponentAdapter() {

            @Override

            public void componentHidden(ComponentEvent e) {

                dispose();

            }

        });

        this.splChanges = ToolsSwingUtils.createHorizontalSplit(

                this.gridChanges, 

                this.gridWorkingCopyList, false, 

                this.gridTabs, false

        );

        this.splChanges.setDividerLocation(ToolsSwingUtils.cols2px(45));

        this.timerClearMsg = new Timer(20000, (ActionEvent e) -> {

//            getTaskStatusController().message("");

            this.lblStatusMessages.setText("");

        });

        this.timerClearMsg.setRepeats(false);

        translate();

        this.taskStatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("");

        this.taskStatusController = taskStatusManager.createTaskStatusController(

                this.lblStatusCaption, 

                this.lblStatusMessages, 

                this.pbStatus

        );

        this.taskStatusController.setShowCancelButton(false);

        this.taskStatusController.setShowRemoveTaskButton(false);

        this.taskStatusController.bind(this.taskStatus);

        SwingUtilities.invokeLater(() -> {this.setVisibleStatus(false); });

        this.workspacePicker = onlineSwingManager.createPickerWorkspaceController(

                this.cboWorkspace//,

//                this.btnWorkspace

        );

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

            doChangeWorkspace();

        });

        this.btnLocalCheckAllEntities.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.btnLocalUnCheckAllEntities.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

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

            this.entitySelector.checkAll();

        });

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

            this.entitySelector.clearChecks();

        });

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

            this.entitySelector.collapseAll();

        });

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

            this.entitySelector.expandAll();

        });

        this.entitySelector = onlineSwingManager.createEntitySelectorController(

                this.treeLocalTables, 

                txtLocalTablesFilter, 

                btnLocalTable

        );

        this.entitySelector.setViewFilter(OnlineEntitySelectorController.LOCAL_ENTITIES);

        this.entitySelector.setFilter(OnlineEntitySelectorController.LOCAL_ENTITIES);

        this.entitySelector.setChecksEnabled(true);

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

            localChangesController.doUpdateTableLocalChanges();

        });

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

            switch(e.getID()) {

                case OnlineEntitySelectorController.ACTION_SELECT_ID:

                    doUpdateComponents();

                    break;

                case OnlineEntitySelectorController.ACTION_CHECK_ID:

                    localChangesController.doUpdateTableLocalChanges();

                    remoteChangesController.doReloadChanges();

                    doUpdateComponents();

                    break;

                case OnlineEntitySelectorController.ACTION_RELOAD_ID:

                    localChangesController.doUpdateTableLocalChanges();

                    remoteChangesController.doReloadChanges();

                    doUpdateComponents();

                    break;

            }

        });

        this.workingAreaPicker = new WorkingAreaPickerControllerImpl(

            () -> {return getWorkspace().getSite();},

            txtWorkingAreaLabel,

            txtWorkingArea,

            btnWorkingAreaFromView,

            btnWorkingAreaDialog,

            btnWorkingAreaHistory,

            btnWorkingAreaBookmarks,

            () -> {

                LabeledValue<MapControl> n = onlineservices.getActiveMapControl();

                return (n == null) ? null : n.getValue();

            },

            () -> {

                List<OnlineLayer> selectedLayers = getSelectedLayers();

                if (selectedLayers.isEmpty()) {

                    return null;

                }

                return selectedLayers;

            }

        );

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

            doUpdateComponents();

        });

        I18nManager i18n = ToolsLocator.getI18nManager();

        DefaultComboBoxModel<LabeledValue<Integer>> zoneModel = new DefaultComboBoxModel<>();

        zoneModel.addElement(new LabeledValueImpl<>(i18n.getTranslation("_Only_changes_zone"), ZONE_ONLY_CHANGES));

        zoneModel.addElement(new LabeledValueImpl<>(i18n.getTranslation("_Changes_zone_and_working_area"), ZONE_CHANGES_AND_WORKING_AREA));

        this.cboSynchorizationZone.setModel(zoneModel);

        this.cboSynchorizationZone.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doUpdateComponents();

            }

        });

        this.cboSynchorizationZone.setSelectedIndex(0);

        this.localChangesController = new LocalChangesController(

            this,

            this.workspacePicker,

            this.tblLocalChanges,

            this.btnLocalCheckAll,

            this.btnLocalUnCheckAll,

            this.btnLocalShowForm,

            this.btnLocalRefresh,

            this.btnLocalCommit,

            this.btnLocalRevert,

            this.btnLocalZoom,

            this.btnLocalCenter,

            this.btnLocalHighlight,

            this.btnLocalCleanHighligthed,

            this.lblLocalChangesCount,

            this.txtLocalTablesFilter,

            this.btnLocalTable

        );

        this.remoteChangesController = new RemoteChangesController(

            this,

            this.workspacePicker,

            this.tblRemoteChanges,

            this.btnRemoteCheckAll,

            this.btnRemoteUncheckAll,

            this.btnRemoteReloadChanges,

            this.btnRemoteCleanChanges,

            this.btnRemoteUpdate,

            this.btnRemoteMerge,

            this.btnRemoteShowForm,

            this.btnRemoteZoom,

            this.btnRemoteCenter,

            this.btnRemoteHighlight,

            this.btnRemoteCleanHighligthed,

            this.lblRemoteChangesCount

        );

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

            if( this.processing ) {

                return;

            }

            this.setVisible(false);

        });

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

            doCheckRecomendedEntities();

        });

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

            doReloadTables();

//            remoteChangesController.doReloadChanges();

        });

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

            doSynchronize();

        });

        ToolsSwingUtils.ensureRowsCols(this, 14, 100);

    }

    private List<OnlineLayer> getSelectedLayers(){

        List<OnlineEntity> entities = this.getEntitySelector().getCheckedEntities();

        OnlineProject project = this.getWorkspace().getProject();

        List<OnlineLayer> result = new ArrayList<>();

        for (OnlineEntity entity : entities) {

            OnlineLayer layer = project.getLayer(

                (OnlineLayer t) -> StringUtils.equalsIgnoreCase(t.getName(), entity.getEntityName()),

                null

            );

            result.add(layer);

        }

        return result;

    }

    /* friend */ void doUpdateComponents() {

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

            return;

        }

        if(this.localChangesController != null){

            this.localChangesController.doUpdateComponents();

        }

        if(this.remoteChangesController != null){

            this.remoteChangesController.doUpdateComponents();

        }

        OnlineWorkingcopy ws = this.getWorkspace();

        if(ws == null) {

            this.cboSynchorizationZone.setEnabled(false);

            this.workingAreaPicker.setEnabled(false);

            this.btnSynchronize.setEnabled(false);

            this.btnEntitiesReload.setEnabled(false);

            return;

        }

        LabeledValue<Integer> zoneMode = (LabeledValue<Integer>) this.cboSynchorizationZone.getSelectedItem();

        if(zoneMode == null) {

            this.cboSynchorizationZone.setEnabled(false);

            this.workingAreaPicker.setEnabled(false);

            this.btnSynchronize.setEnabled(false);

            this.btnEntitiesReload.setEnabled(false);

            return;

        }

        this.cboSynchorizationZone.setEnabled(true);

        this.btnSynchronize.setEnabled(true);

        this.btnEntitiesReload.setEnabled(true);

        switch (zoneMode.getValue()) {

            case ZONE_CHANGES_AND_WORKING_AREA:

                this.workingAreaPicker.setEnabled(true);

                break;

            case ZONE_ONLY_CHANGES:

            default:

                this.workingAreaPicker.setEnabled(false);

                break;

        }

    }

    public void updateLocalChangesTable() {

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

            return;

        }

        this.entitySelector.reloadEntities();

//        this.localChangesController.doReloadTables();

    }

    public OnlineWorkingcopy getWorkspace() {

        OnlineWorkingcopy ws = this.workspacePicker.get();

        return ws;

    }

    private OnlineWorkingcopy getUndisposableWorkspace() {

        OnlineWorkingcopy ws = this.workspacePicker.get();

        DisposeUtils.disposeQuietly(ws);

        LOGGER.info("ws.references = " + DisposeUtils.getReferences(ws));

        return ws;

    }

    private void doChangeWorkspace() {

        OnlineWorkingcopy ws = null;

        try {

            ws = this.getWorkspace();

            this.entitySelector.setWorkspace(ws);

            if (ws != null) {

                for (String tableName : this.getDefaultTablesSelection()) {

                    OnlineEntity entity = ws.getWorkspaceEntity(tableName);

                    if (entity != null) {

                        this.entitySelector.check(entity);

                    }

                }

            } else {

                this.remoteChangesController.doReloadChanges();//.doChangeWorkspace();

            }

//            if(ws.isOffline() || ws.authenticate(null)) {

//                this.localChangesController.doChangeWorkspace();

                this.remoteChangesController.doReloadChanges();//.doChangeWorkspace();

//                return;

//            }

//            showAuthenticationRequiredMessage("_Online_Changes");

//            this.workspacePicker.set(null);

//            doChangeWorkspace();

            this.workingAreaPicker.set(ws.getCurrentWorkingArea());

        } catch (OnlineRuntimeException e1) {

            LOGGER.warn("Can't set workspace.", e1);

            if (showAuthenticationErrors("_Online_Changes", e1)) {

                this.workspacePicker.set(null);

                doChangeWorkspace();

            }

        } catch (Exception e2) {

            LOGGER.warn("Can't set workspace.", e2);

        } finally {

            DisposeUtils.disposeQuietly(ws);

        }

    }

    public void doReloadTables() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws == null) {

            this.entitySelector.setWorkspace(null);

            return;

        }

        this.entitySelector.reloadEntities();

//        context.doUpdateComponents();

    }

    private void doSynchronize() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws == null) {

            this.entitySelector.setWorkspace(null);

            return;

        }

        LabeledValue<Integer> zoneMode = (LabeledValue<Integer>) this.cboSynchorizationZone.getSelectedItem();

        int zone = ZONE_ONLY_CHANGES;

        if(zoneMode != null){

            zone = zoneMode.getValue();

        }

        WorkingArea workingArea = this.workingAreaPicker.get();

        Envelope env = null;

        switch(zone){

            case ZONE_CHANGES_AND_WORKING_AREA:

                if(workingArea != null) {

                    env = workingArea.getValue();

                }

                break;

            case ZONE_ONLY_CHANGES:

            default:

                break;

        }

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

        for (OnlineEntity checkedEntity : checkedEntities) {

            ws.synchronize(checkedEntity, env, this.taskStatus);

        }

        doReloadTables();

        localChangesController.doUpdateTableLocalChanges();

        remoteChangesController.doReloadChanges();

        remoteChangesController.doUpdateComponents();

    }

    public void updateEntitiesFromRepository(boolean forceUpdateEntities) {

        OnlineWorkingcopy ws = null;

        try {

            ws = this.getWorkspace();

            if( ws == null ) {

                return;

            }

            if( !forceUpdateEntities && this.currentWorkingcopy==ws && this.entitiesUpdateds ) {

                return;

            }

            setVisibleStatus(true);

//            ws.updateEntitiesFromRepository();

            this.currentWorkingcopy = ws;

            this.entitiesUpdateds = true;

            setVisibleStatus(false);

        } finally {

            DisposeUtils.disposeQuietly(ws);

        }

    }

    public void alert(String msg) {

        if( StringUtils.startsWith(msg, "_") ) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            msg = i18n.getTranslation(msg);

        }

        message(OnlineSwingCommons.getHTMLColorTag(Color.red.darker(), msg));

    }

    public void message(final String msg) {

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

            return;

        }

        String message = msg;

        this.timerClearMsg.stop();

        if( StringUtils.startsWith(message, "_") ) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            message = i18n.getTranslation(message);

        }

//        this.getTaskStatusController().message(message);

        this.lblStatusMessages.setVisible(true);

        this.lblStatusMessages.setText(message);

        this.timerClearMsg.start();

    }

    public void setVisibleStatus(boolean visible) {

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

            return;

        }

        this.lblStatusCaption.setVisible(visible);

        this.pbStatus.setVisible(visible);

        this.lblStatusMessages.setVisible(true);

    }

    public TaskStatusController getTaskStatusController() {

        return this.taskStatusController;

    }

    public static void selfRegister() {

        ToolsSwingUtils.registerIcons(

                OnlineSwingLibraryImpl.class, 

                "/org/gvsig/vcsgis/swing/impl/images",

                ICON_PROVIDER_NAME,

                new String[]{ ICON_GROUP_NAME, "vcsgis-commit-all", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-revert", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-topology-plan", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-show-local-changes", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-checkout-overwrite", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-remotechanges-clear", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-remotechanges-download", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-remotechanges-reload", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-highlight-context", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-update-all", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-merge", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-show-remote-changes", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-center-context", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-zoom-context", "vcsgis-changes"},

                new String[]{ ICON_GROUP_NAME, "vcsgis-clean-highlighted", "vcsgis-changes"}

//                new String[]{ ICON_GROUP_NAME, "vcsgis-show-local-and-remote-changes"},

        );         

        ToolsSwingUtils.registerSubgroupIconScreenshot(

                OnlineSwingLibraryImpl.class, 

                "vcsgis", 

                "vcsgis-changes", 

                "/org/gvsig/vcsgis/swing/impl/screenshots/vcsgis-changes-local.png"

        );

        ToolsSwingUtils.registerSubgroupIconScreenshot(

                OnlineSwingLibraryImpl.class, 

                "vcsgis", 

                "vcsgis-changes", 

                "/org/gvsig/vcsgis/swing/impl/screenshots/vcsgis-changes-remote.png"

        );

    }

    @Override

    public boolean isProcessing() {

        return this.processing;

    }

    public void selectTab(int tab){

        this.tabLocalAndRemote.setSelectedIndex(tab);

    }

    public void selectOnlyALocalEntity(OnlineEntity selectedTable){

        this.localChangesController.selectOnlyAEntity(selectedTable);

    }

    public void selectOnlyALocalEntity(List<OnlineEntity> selectedTables){

        this.localChangesController.selectOnlyAEntity(selectedTables);

    }

    @Override

    public void setDialog(Dialog dialog) {

        // Do nothing

    }

    public void dispose() {

        DisposeUtils.disposeQuietly(localChangesController);

        DisposeUtils.disposeQuietly(remoteChangesController);

        DisposeUtils.disposeQuietly(currentWorkingcopy);

        DisposeUtils.disposeQuietly(entitySelector);

    }

    public void setTaskStatus(SimpleTaskStatus taskStatus) {

        this.taskStatusController.bind(taskStatus);

    }

    @Override

    public Object getProperty(String name) {

        return this.propertiesSupport.getProperty(name);

    }

    @Override

    public void setProperty(String name, Object value) {

        this.propertiesSupport.setProperty(name, value);

    }

    @Override

    public Map<String, Object> getProperties() {

        return this.propertiesSupport.getProperties();

    }

    public OnlineEntitySelectorController getEntitySelector() {

        return entitySelector;

    }

    private void doCheckRecomendedEntities() {

        final OnlineWorkingcopy workspace = this.getUndisposableWorkspace();

        if( workspace==null ) {

            return;

        }

        Set<String> updateEntities = new HashSet<>();

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

        for (OnlineEntity entity : entities) {

            if (workspace.existsInWorkspace(entity)) {

                OnlineEntity lentity = workspace.getWorkspaceEntityByCode(entity.getEntityCode());

                switch (lentity.getState()) {

                    case OnlineManager.STATE_LOCAL_MODIFIED:

                    case OnlineManager.STATE_LOCAL_NEW:

                    case OnlineManager.STATE_LOCAL_UNMODIFIED:

                    case OnlineManager.STATE_REMOTE_NEW:

                    default:

                        break;

                    case OnlineManager.STATE_CONFLICT:

                    case OnlineManager.STATE_LOCAL_OUTDATED:

                    case OnlineManager.STATE_LOCAL_OUTDATED_AND_MODIFIED:

                        updateEntities.add(entity.getEntityCode());

                        break;

                }

            }

        }

        this.entitySelector.setCheck(updateEntities, true);

    }

    protected FeatureStore getWorkspaceStoreOfSelectedEntity() {

        OnlineEntity entity = this.getEntitySelector().getSelectedEntity();

        FeatureStore store = null;

        if(entity != null){

            OnlineWorkingcopy ws = getUndisposableWorkspace();

            store = ws.openFeatureStore(entity.getEntityName(),false);

        }

        return store;

    }

}