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

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.json.JsonObject;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import javax.swing.table.DefaultTableCellRenderer;

import javax.swing.table.TableModel;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.mutable.MutableObject;

import org.gvsig.featureform.swing.CreateJFeatureFormException;

import org.gvsig.featureform.swing.JFeatureForm;

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.aggregate.MultiPrimitive;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.exception.BaseException;

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.pickercontroller.PickerController;

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

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.task.UserCancelTaskException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

/**

 *

 * @author gvSIG Team

 */

public class LocalChangesController extends AbstractDisposable {

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

    private static final int MAX_SELECTED_ROWS_TO_SHOW_GEOMETRIES = 200;

//    private final JButton btnLocalCheckRecomendedEntities;

//    private final JButton btnLocalCheckAllEntities;

//    private final JButton btnLocalUnCheckAllEntities;

//    private final JButton btnLocalExpandAllEntities;

//    private final JButton btnLocalCollapseAllEntities;

    private final JTable tblLocalChanges;

    private final JButton btnLocalCheckAll;

    private final JButton btnLocalUnCheckAll;

    private final JButton btnLocalShowForm;

    private final JButton btnLocalRefresh;

    private final JButton btnLocalCommit;

    private final JButton btnLocalRevert;

    private final PickerController<OnlineWorkingcopy> workspacePicker;    

    private final OnlineJChangesImpl context;

    private final JButton btnLocalZoom;

    private final JButton btnLocalCenter;

    private final JButton btnLocalHighlight;

    private final JLabel lblLocalChangesCount;

    private OnlineChanges<OnlineWorkingcopyChange> changes;

    private LocalChangesTableModel localChangesTableModel;

    private List<OnlineEntity> entitiesWithSelectedChanges = null;

    private final Set<String> entitiesToUnCheckAll;

    private TableModelListener tableModelListener;

    private boolean dissabledUncheckAllByEntities;

    private final JButton btnLocalCleanHighlighted;

    private boolean isSelectionFromEntitiesEmpty;

    public LocalChangesController(

        OnlineJChangesImpl context,

        PickerController<OnlineWorkingcopy> workspacePicker,

        JTable tblLocalChanges,

        JButton btnLocalCheckAll,

        JButton btnLocalUnCheckAll,

        JButton btnLocalShowForm,

        JButton btnLocalRefresh,

        JButton btnLocalCommit,

        JButton btnLocalRevert,

        JButton btnLocalZoom,

        JButton btnLocalCenter,

        JButton btnLocalHighlight,

        JButton btnLocalCleanHighlighted,

        JLabel lblLocalChangesCount,

        JTextField txtLocalTablesFilter,

        JButton btnLocalTable

        ) {

        this.dissabledUncheckAllByEntities = false;

        this.context = context;

        this.workspacePicker = workspacePicker;

        this.tblLocalChanges = tblLocalChanges;

        this.btnLocalCheckAll = btnLocalCheckAll;

        this.btnLocalCommit = btnLocalCommit;

        this.btnLocalRefresh = btnLocalRefresh;

        this.btnLocalRevert = btnLocalRevert;

        this.btnLocalShowForm = btnLocalShowForm;

        this.btnLocalUnCheckAll = btnLocalUnCheckAll;

        this.btnLocalZoom = btnLocalZoom;

        this.btnLocalCenter = btnLocalCenter;

        this.btnLocalHighlight = btnLocalHighlight;

        this.btnLocalCleanHighlighted = btnLocalCleanHighlighted;

        this.lblLocalChangesCount= lblLocalChangesCount;

        this.entitiesToUnCheckAll = new HashSet<>();

        initComponents();

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        OnlineSwingManager onlineSwingManager = OnlineSwingLocator.getOnlineSwingManager();

        translate();

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

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

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

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

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

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

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

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

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

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

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

        this.btnLocalCleanHighlighted.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) -> {

//            doUpdateTableLocalChanges();

//        });

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

//            switch(e.getID()) {

//                case OnlineEntitySelectorController.ACTION_SELECT_ID:

//                    doUpdateComponents();

//                    break;

//                case OnlineEntitySelectorController.ACTION_CHECK_ID:

//                    doUpdateTableLocalChanges();

//                    doUpdateComponents();

//                    break;

//                case OnlineEntitySelectorController.ACTION_RELOAD_ID:

//                    doUpdateTableLocalChanges();

//                    doUpdateComponents();

//                    break;

//            }

//        });

        this.tblLocalChanges.getSelectionModel().setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

        this.tblLocalChanges.addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

                if (e.getKeyCode() == KeyEvent.VK_SPACE) {

                    doToggleSelection();

                }

            }

        });

        this.tblLocalChanges.getSelectionModel().addListSelectionListener((ListSelectionEvent e) -> {

            doUpdateEntitiesWithSelectedChanges();

            doUpdateIsSelectionFromEntitiesEmpty();

            context.doUpdateComponents();

        });

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

            if (changes != null) {

                doCheckAll();

                doUpdateTableLocalChanges();

            }

        });

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

            if (changes != null) {

                doUnCheckAll();

                doUpdateTableLocalChanges();

            }

        });

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

            doShowForm();

        });

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

            doCommit();

        });

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

            doRevert();

        });

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

            doUpdateTableLocalChanges();

        });

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

            doZoomToSelectedChange();

        });

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

            doCenterToSelectedChange();

        });

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

            doHighLightSelectedChange();

        });

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

            cleanHighligthed();

        });

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

//            doCheckRecomendedEntities();

//        });

        context.doUpdateComponents();

    }

//    public void doChangeWorkspace() {

//        OnlineWorkingcopy ws = getUndisposableWorkspace();

//        this.entitySelector.setWorkspace(ws);

//        if( ws!=null ) {

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

//                OnlineEntity entity = ws.getWorkspaceEntity(tableName);

//                if( entity!=null ) {

//                    this.entitySelector.check(entity);

//                }

//            }

//        }

////        doUpdateTableLocalChanges();

//    }

    private void translate() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

//        swingManager.translate(this.btnLocalCheckRecomendedEntities);

//        swingManager.translate(this.btnLocalCheckAllEntities);

//        swingManager.translate(this.btnLocalUnCheckAllEntities);

        swingManager.translate(this.btnLocalCheckAll);

        swingManager.translate(this.btnLocalCommit);

        swingManager.translate(this.btnLocalRefresh);

        swingManager.translate(this.btnLocalRevert);

        swingManager.translate(this.btnLocalShowForm);

        swingManager.translate(this.btnLocalUnCheckAll);

        swingManager.translate(this.btnLocalCenter);

        swingManager.translate(this.btnLocalHighlight);

        swingManager.translate(this.btnLocalZoom);

        swingManager.translate(this.btnLocalCleanHighlighted);

//        swingManager.translate(this.btnLocalCollapseAllEntities);

//        swingManager.translate(this.btnLocalExpandAllEntities);

    }

    private Iterator<Long> getSelectionIterator() {

        ListSelectionModel selection = this.tblLocalChanges.getSelectionModel();

        return new Iterator<Long>() {

            long n = selection.getMinSelectionIndex();

            @Override

            public boolean hasNext() {

                while (n <= selection.getMaxSelectionIndex()){

                    if(selection.isSelectedIndex((int) n)){

                       return true; 

                    }

                    n++;

                }

                return false;

            }

            @Override

            public Long next() {

                if(n > selection.getMaxSelectionIndex()){

                    throw new IllegalStateException();

                }

                return n++;

            }

        };

    }

    private void doToggleSelection() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                Iterator<Long> rows = getSelectionIterator();

                this.changes.process(rows, (OnlineWorkingcopyChange change) -> {

//                    if(change.getOperation() == OP_ADD_ENTITY) {

//                        if(change.isSelected()){

//                            entitiesToUnCheckAll.add(change.getEntityCode());

//                        }

//                    }

                    change.setSelected(!change.isSelected());

                    return true;

                });

                if(!entitiesToUnCheckAll.isEmpty()){

                    doUnCheckAllByEntities();

                }

            } finally {

                doUpdateEntitiesWithSelectedChanges();

                doUpdateIsSelectionFromEntitiesEmpty();

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisToggleSelectionLocalChanges");

        task.start();

    }

    private Iterator<Long> getRowsByEntitiesToUnCheckIterator() {

        long size = changes.size64();

        TableModel model = this.tblLocalChanges.getModel();

        return new Iterator<Long>() {

            long n = 0;

            @Override

            public boolean hasNext() {

                while (n < size){

                    OnlineWorkingcopyChange row = changes.get64(n);

                    if(entitiesToUnCheckAll.contains(row.getEntityCode())){

                       return true; 

                    }

                    n++;

                }

                return false;

            }

            @Override

            public Long next() {

                return n++;

            }

        };

    }

    private void doUnCheckAllByEntities(){

        if(dissabledUncheckAllByEntities){

            return;

        }

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                if(!entitiesToUnCheckAll.isEmpty()) {

                    Iterator<Long> rows = getRowsByEntitiesToUnCheckIterator();

                    this.changes.process(rows, (OnlineWorkingcopyChange change) -> {

//                         if(change.getOperation() != OP_ADD_ENTITY) {

//                            change.setSelected(false);

//                         }

                        return true;

                    });

                    entitiesToUnCheckAll.clear();

                }

            } finally {

                doUpdateEntitiesWithSelectedChanges();

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisUnCheckAllByEntitiesLocalChanges");

        task.start();

    }

    private Iterator<Long> getRowsIterator() {

        long size = changes.size64();

        return new Iterator<Long>() {

            long n = 0;

            @Override

            public boolean hasNext() {

                return (n < size);

            }

            @Override

            public Long next() {

                return n++;

            }

        };

    }

    private void doCheckAll() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                dissabledUncheckAllByEntities = true;

                context.doUpdateComponents();

                this.changes.setSelectionAll();

            } finally {

                context.processing = false;

                dissabledUncheckAllByEntities = false;

                context.doUpdateComponents();

            }

        }, "VCSGisCheckAllLocalChanges");

        task.start();

    }

    private void doUnCheckAll() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                dissabledUncheckAllByEntities = true;

                context.doUpdateComponents();

                this.changes.clearSelection();

            } finally {

                context.processing = false;

                dissabledUncheckAllByEntities = false;

                context.doUpdateComponents();

            }

        }, "VCSGisUncheckAllLocalChanges");

        task.start();

    }

    private OnlineWorkingcopy getUndisposableWorkspace() {

        OnlineWorkingcopy ws = getWorkspace();

        DisposeUtils.disposeQuietly(ws);

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

        return ws;

    }

    private OnlineWorkingcopy getWorkspace() {

        OnlineWorkingcopy ws = this.context.getWorkspace();

        return ws;

    }

    /* friend */ void doUpdateComponents() {

        if (notInSwingThreadInvokeLater(() -> {

            doUpdateComponents();

        })) {

            return;

        }

        OnlineSwingManager vcsgisSwingManager = OnlineSwingLocator.getOnlineSwingManager();

        try { 

            this.context.message("");

            boolean changesIsEmpty = changes == null || changes.isEmpty();

            this.context.setVisibleStatus(context.processing);

            OnlineWorkingcopy ws = getUndisposableWorkspace();

//            this.context.updateEntitiesFromRepository(false);

            this.context.btnClose.setEnabled(!context.processing);

//            this.entitySelector.setEnabled(!context.processing);

            this.workspacePicker.setEnabled(!context.processing);

            this.btnLocalCheckAll.setEnabled(!context.processing && !changesIsEmpty);

            this.btnLocalUnCheckAll.setEnabled(!context.processing && !changesIsEmpty);

            List<OnlineEntity> checkedEntities = context.getEntitySelector().getCheckedEntities();

            this.btnLocalRefresh.setEnabled(!context.processing && changes != null && CollectionUtils.isNotEmpty(checkedEntities));

            this.btnLocalRevert.setEnabled(ws != null

                    && !context.processing

                    && !changesIsEmpty

                    && CollectionUtils.isNotEmpty(checkedEntities)

                    && entitiesWithSelectedChanges != null

                    && !entitiesWithSelectedChanges.isEmpty()

                    && !isSelectionFromEntitiesEmpty

            );

            this.btnLocalRevert.setVisible(true);

            if (ws != null

                    && !context.processing

                    && changes != null

                    && !this.changes.isSelectionEmpty()

                    && CollectionUtils.isNotEmpty(checkedEntities)

                    && entitiesWithSelectedChanges != null

                    && !entitiesWithSelectedChanges.isEmpty()

                    && !isSelectionFromEntitiesEmpty

                    ) {

                MutableObject<String> msg = new MutableObject<>();

                if( areConflictEntities(checkedEntities) ) {

                    context.alert("_There_are_selected_entities_that_have_conflicts");

                    this.btnLocalCommit.setEnabled(false);

                    LOGGER.info("Can't enable commit (1.2). There are selected entities that have conflicts.");

                } else if( areCorruptOrDisconnectedEntities(checkedEntities) ) {

                    context.alert("_There_are_selected_corrupted_or_disconnected_entities");

                    this.btnLocalCommit.setEnabled(false);

                    LOGGER.info("Can't enable commit (1.2). There are selected corrputed or diconnected entities.");

                } else if (!ws.canUpload(msg, getEntityCodes(checkedEntities))) {

                    context.alert(msg.getValue());

                    this.btnLocalCommit.setEnabled(false);

                    LOGGER.info("Can't enable commit (1). "+ msg.getValue());

                } else {

                    this.btnLocalCommit.setEnabled(true);

                }

            } else {

                try {

                    if( CollectionUtils.isEmpty(checkedEntities) ) {

                        this.context.message("_Select_tables_to_view_changes");

                        LOGGER.info("Can't enable commit (2).");

                    } else if( changes == null || this.changes.isSelectionEmpty() ) {

                        this.context.message("_Select_the_changes_to_commit");

                        LOGGER.info("Can't enable commit (3).");

                    } else if( entitiesWithSelectedChanges == null || entitiesWithSelectedChanges.isEmpty() ) {

                        this.context.message("_Cant_locate_the_tables_related_to_changes");

                        LOGGER.info("Can't enable commit (4).");

                    } else if( isSelectionFromEntitiesEmpty ) { 

                        this.context.message("_Cant_locate_changes_in_selected_tables");

                        LOGGER.info("Can't enable commit (5).");

                    } else {

                        LOGGER.info("Can't enable commit (6).");

                    }

                } catch(Exception ex) {

                    LOGGER.info("Can't enable commit (7).");

                }

                this.btnLocalCommit.setEnabled(false);

            }

            //Show form

            boolean enableShowForm = false;

            int row = this.tblLocalChanges.getSelectedRow();

            if (!context.processing && row >= 0) {

                enableShowForm = true;

            }

            this.btnLocalShowForm.setEnabled(!context.processing && enableShowForm);

            this.tblLocalChanges.setEnabled(!context.processing);

            this.workspacePicker.setEnabled(!context.processing);

            Geometry geom = getGeometryOfSelectedChange();

            Geometry originalGeom = getOriginalGeometryOfSelectedChange();

            this.btnLocalCenter.setEnabled(!context.processing); // && (geom != null || originalGeom != null));

            this.btnLocalHighlight.setEnabled(!context.processing && (geom != null || originalGeom != null));

            this.btnLocalZoom.setEnabled(!context.processing); // && (geom != null || originalGeom != null));

            this.btnLocalCleanHighlighted.setEnabled(!context.processing);

        } catch (OnlineRuntimeException e1) {

            LOGGER.warn("Can't updating components.", e1);

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

                this.workspacePicker.set(null);

//                doChangeWorkspace();

            }

        } catch (Exception e2) {

            LOGGER.warn("Can't updating components.", e2);

        }

    }

//    public void doReloadTables() {

//        this.entitySelector.reloadEntities();

//    }

    public void doUpdateEntitiesWithSelectedChanges() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws != null) {

            entitiesWithSelectedChanges = ws.getEntitiesWithSelectedChanges();

        }

    }

    private void doUpdateIsSelectionFromEntitiesEmpty() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws != null) {

            List<OnlineEntity> checkedEntities = context.getEntitySelector().getCheckedEntities();

            this.isSelectionFromEntitiesEmpty = changes.isSelectionFromEntitiesEmpty(checkedEntities);

        }

    }

    public void doUpdateTableLocalChanges() {

        if( context.processing ) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if(ws != null){

            doUpdateEntitiesWithSelectedChanges();

            List<OnlineEntity> checkedEntities = context.getEntitySelector().getCheckedEntities();

            if(CollectionUtils.isEmpty(checkedEntities)) {

                localChangesTableModel = new LocalChangesTableModel(ws);

                this.tblLocalChanges.setModel(localChangesTableModel);

                return;

            }

            changes = ws.getLocalChanges(checkedEntities);

            localChangesTableModel = new LocalChangesTableModel(changes, ws);

            this.tblLocalChanges.setModel(localChangesTableModel);

            int columns = this.tblLocalChanges.getColumnModel().getColumnCount();

            for (int i = 1; i < columns; i++) {

                this.tblLocalChanges.getColumnModel().getColumn(i).setCellRenderer(new DefaultTableCellRenderer() {

                    @Override

                    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {

                        Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);

                        OnlineChange changeRow = changes.get64(row);

                        OnlineSwingCommons.setColorCompoment(c, changeRow.getStatus());

                        return c;

                    }

                });

            }

            this.tableModelListener = null;

            localChangesTableModel.addTableModelListener(getTableModelListener());

            context.message(i18n.getTranslation(

                    "_Workingcopy_changes_list_updated",

                    new String[]{String.valueOf(changes.size64())}

            )

            );

            this.lblLocalChangesCount.setText(String.valueOf(changes.size64()));

        }

        doUpdateIsSelectionFromEntitiesEmpty();

        context.doUpdateComponents();

    }

    private TableModelListener getTableModelListener() {

        if(tableModelListener == null){

            tableModelListener =  (TableModelEvent e) -> {

                if (e.getType() == TableModelEvent.UPDATE) {

                    TableModel model = ((TableModel) (e.getSource()));

                    OnlineWorkingcopyChange change = changes.get64(e.getFirstRow());

//                    if(change.getOperation() == OP_ADD_ENTITY) {

//                        if(!change.isSelected()) {

//                            if (entitiesToUnCheckAll.add(change.getEntityCode())) {

//                                doUnCheckAllByEntities();

//                            }

//                        }

//                    }

                }

            };

        }

        return tableModelListener;

    }

    private void doShowForm() {

        int row = this.tblLocalChanges.getSelectedRow();

        OnlineWorkingcopyChange change = this.changes.get64(row);

        if(change.getOperation() == OP_DELETE 

//            || change.getOperation() == OP_ADD_ENTITY

            ){

            return;

        }

        Feature feature = change.getRelatedFeature();

        if(feature == null){

            return;

        }

        try {

            DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

            JFeatureForm form;

            form = dataSwingManager.createJFeatureForm(feature);

            WindowManager winManager = ToolsSwingLocator.getWindowManager();

            form.asJComponent().setPreferredSize(new Dimension(400,200));

            winManager.showWindow(form.asJComponent(), "Local change: "+change.getLabel(), WindowManager.MODE.WINDOW);

        } catch (CreateJFeatureFormException ex) {

            LOGGER.warn("Can't show form", ex);

        }

    }

    private void doCommit() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        OnlineWorkingcopy ws = getUndisposableWorkspace();

        if( ws==null ) {

            // TODO: Mensaje al usuario ??

            return;

        }

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

        List<String> entityCodes = getEntityCodes(entities);

        if( CollectionUtils.isEmpty(entities)){

            // TODO: Mensaje al usuario ??

            return;

        }

//        this.context.updateEntitiesFromRepository(false);

        MutableObject<String> message = new MutableObject<>();

        if( !ws.canUpload(message, entityCodes) ) {

            dialogs.messageDialog(

                    i18n.getTranslation("_Cant_commit") + "\n" + message.getValue(),

                    i18n.getTranslation("_Commit"), 

                    JOptionPane.WARNING_MESSAGE

            );

            return;

        }

        this.tblLocalChanges.setModel(new LocalChangesTableModel(ws));

//        List<VCSGisTopologyPlanStatus> topologicPlanStatusList = new ArrayList<>();

//        

//        Thread task = new Thread(() -> {

//            try {

//                context.processing = true;

//                context.doUpdateComponents();

//                if(!existsAllTopologyPlansLocally(ws, entities)) {

//                    ws.updateTopologyPlansFromRepository(null);

//                }

//                if( !executeTopologyPlans(ws, entities, topologicPlanStatusList) ) {

//                    dialogs.messageDialog(

//                            i18n.getTranslation("_Cant_pass_topology_plans"),

//                            i18n.getTranslation("_Commit"), 

//                            JOptionPane.WARNING_MESSAGE

//                    );

//                    return;

//                }

//                int r = ws.commit(

//                        entityCodes,

//                        null,

//                        effectiveDate, 

//                        this.txtLocalComment.getText(), 

//                        this.context.getTaskStatusController().getSimpleTaskStatus(),

//                        topologicPlanStatusList

//                );

//                if(r==OnlineManager.ERR_TOPOLOGYPLAN_OUTDATED){

//                    ws.updateTopologyPlansFromRepository(null);

//                }

//                doPostCommit(r);

//            } catch(UserCancelledException ex) {

//                LOGGER.warn("User cancelled");

//            } finally {

//                context.processing = false;

//                context.doUpdateComponents();

//            }

//        }, "VCSGisCommit");

//

//        context.processing = true;

//        context.doUpdateComponents();

//        task.start();

    }

    private void doPostCommit(int commitStatus) {

        if (notInSwingThreadInvokeLater(() -> {doPostCommit(commitStatus);})) {

            return;

        }

        switch (commitStatus) {

            case ERR_OK:

                this.context.setVisibleStatus(false);

                break;

            default:

                showAuthenticationErrors("_VCS_Commit", commitStatus);

                break;

        }

        context.getEntitySelector().reloadEntities();

        context.updateLocalChangesTable();

        cleanHighligthed();

    }

    private void doRevert() {

        OnlineWorkingcopy ws = getUndisposableWorkspace();

        if( ws==null ) {

            // TODO: Mensaje al usuario

            return;

        }

//        this.context.updateEntitiesFromRepository(false);

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                List<OnlineEntity> entities = ws.getEntitiesWithSelectedChanges();

                List<String> selectedEntityCodes = getEntityCodes(context.getEntitySelector().getCheckedEntities());

                int r = ERR_OK;

                if(!entities.isEmpty() && CollectionUtils.isNotEmpty(selectedEntityCodes)){

                    for (OnlineEntity entity : entities) {

                        if(selectedEntityCodes.contains(entity.getEntityCode())){

                            r = ws.revert(entity.getEntityCode(), 

                                    this.context.getTaskStatusController().getSimpleTaskStatus()

                            );

                        }

                        if(r != ERR_OK){

                            break;

                        }

                    }

                }

                doPostRevert(r, entities);

            } catch(UserCancelTaskException ex) {

                LOGGER.warn("User cancelled");

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisRevert");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

    private void doPostRevert(int revertStatus, List<OnlineEntity> entities) {

        if (notInSwingThreadInvokeLater(() -> {doPostRevert(revertStatus, entities);})) {

            return;

        }

        if( revertStatus == ERR_OK) {

            this.context.setVisibleStatus(false);

        }

        for (OnlineEntity entity : entities) {

            FeatureStore store = getUndisposableWorkspace().getFeatureStore(entity.getEntityName());

            refreshDocument(store);

        }

        context.updateLocalChangesTable();

        cleanHighligthed();

    }

    private Geometry getBBoxOfSelectedChanges() {

        int[] selecteds = this.tblLocalChanges.getSelectedRows();

        if(selecteds!=null && selecteds.length >= 0){

            Envelope env = GeometryUtils.createEnvelope(Geometry.SUBTYPES.GEOM2D);

            for (int i = 0; i < selecteds.length; i++) {

                int selected = selecteds[i];

                OnlineWorkingcopyChange change = changes.get64(selected);

                try {

                    Feature feature = change.getRelatedFeature();

                    Geometry geom = feature.getDefaultGeometry();

                    env.add(geom);

                } catch (Exception ex){

                }

            }

            if( !env.isEmpty() ) {

                return env.getBox2D();

            }

        }

        return null;

    }

    private Geometry getOriginalBBoxOfSelectedChanges() {

        int[] selecteds = this.tblLocalChanges.getSelectedRows();

        if(selecteds != null && selecteds.length >= 0) {

            Envelope env = GeometryUtils.createEnvelope(Geometry.SUBTYPES.GEOM2D);

            Map<String, FeatureStore> stores = new HashMap<>();

            try {

                for (int i = 0; i < selecteds.length; i++) {

                    int selected = selecteds[i];

                    OnlineWorkingcopyChange change = changes.get64(selected);

                    FeatureStore store = null;

                    try {

                        OnlineWorkingcopy ws = getUndisposableWorkspace();

                        if (ws != null) {

                            JsonObject json = change.getDataAsJson();

                            String entityCode = change.getEntityCode();

                            OnlineEntity entity = ws.getEntity(entityCode);

                            store = stores.get(entity.getEntityName());

                            if (store == null) {

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

                                stores.put(entity.getEntityName(), store);

                            }

                            Feature feature = store.createNewFeature(json);

                            Geometry geom = feature.getDefaultGeometry();

                            env.add(geom);

                        }

                    } catch (Exception ex) {

                    }

                }

            } finally {

                for (FeatureStore value : stores.values()) {

                    DisposeUtils.disposeQuietly(value);

                }

                stores = null;

            }

            if (!env.isEmpty()) {

                return env.getBox2D();

            }

        }

        return null;

    }

    private Geometry getGeometryOfSelectedChange() {

        Geometry geom = null;

        try {

            if( this.tblLocalChanges.getSelectedRowCount()>1 && this.tblLocalChanges.getSelectedRowCount()<MAX_SELECTED_ROWS_TO_SHOW_GEOMETRIES ) {

                for (int selectedRow : this.tblLocalChanges.getSelectedRows()) {

                    OnlineWorkingcopyChange change = changes.get64(selectedRow);

                    Feature feature = change.getRelatedFeature();

                    Geometry currentGeom = feature.getDefaultGeometry();

                    if( currentGeom!=null ) {

                        if( geom == null ) {

                            int type = currentGeom.getType();

                            if( GeometryUtils.isSubtype(Geometry.TYPES.POINT, type) || GeometryUtils.isSubtype(Geometry.TYPES.MULTIPOINT, type)) {

                                    geom = GeometryLocator.getGeometryManager().createMultiPoint(currentGeom.getGeometryType().getSubType());

                            } else if( GeometryUtils.isSubtype(Geometry.TYPES.LINE, type) || GeometryUtils.isSubtype(Geometry.TYPES.MULTILINE, type)) {

                                geom = GeometryLocator.getGeometryManager().createMultiCurve(currentGeom.getGeometryType().getSubType());

                            } else if( GeometryUtils.isSubtype(Geometry.TYPES.SURFACE, type) || GeometryUtils.isSubtype(Geometry.TYPES.MULTISURFACE, type)) {

                                geom = GeometryLocator.getGeometryManager().createMultiSurface(currentGeom.getGeometryType().getSubType());

                            } else {

                                return geom;

                            }

                        }

                        ((MultiPrimitive)geom).addPrimitives(currentGeom);

                    }

                }

            } else {

                int selected = this.tblLocalChanges.getSelectedRow();

                if(selected >= 0){

                    OnlineWorkingcopyChange change = changes.get64(selected);

                    try {

                        Feature feature = change.getRelatedFeature();

                        geom = feature.getDefaultGeometry();

                    } catch (Exception ex){

                    }

                }

            }

            return geom;

        } catch (Exception ex) {

            return geom;

        }

    }

    private Geometry getOriginalGeometryOfSelectedChange() {

        Geometry geom = null;

        try {

            if( this.tblLocalChanges.getSelectedRowCount()>1 && this.tblLocalChanges.getSelectedRowCount()<MAX_SELECTED_ROWS_TO_SHOW_GEOMETRIES ) {

                for (int selectedRow : this.tblLocalChanges.getSelectedRows()) {

                    OnlineWorkingcopyChange change = changes.get64(selectedRow);

                    try {

                        OnlineWorkingcopy ws = getUndisposableWorkspace();

                        if(ws!=null) {

                            JsonObject json = change.getDataAsJson();

                            String entityCode = change.getEntityCode();

                            OnlineEntity entity = ws.getEntity(entityCode);

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

                            Feature feature = store.createNewFeature(json);

                            Geometry currentGeom = feature.getDefaultGeometry();

                            if( currentGeom!=null ) {

                                if( geom == null ) {

                                    int type = currentGeom.getType();

                                    if( GeometryUtils.isSubtype(Geometry.TYPES.POINT, type) || GeometryUtils.isSubtype(Geometry.TYPES.MULTIPOINT, type)) {

                                        geom = GeometryLocator.getGeometryManager().createMultiPoint(currentGeom.getGeometryType().getSubType());

                                    } else if( GeometryUtils.isSubtype(Geometry.TYPES.LINE, type) || GeometryUtils.isSubtype(Geometry.TYPES.MULTILINE, type)) {

                                        geom = GeometryLocator.getGeometryManager().createMultiCurve(currentGeom.getGeometryType().getSubType());

                                    } else if( GeometryUtils.isSubtype(Geometry.TYPES.SURFACE, type) || GeometryUtils.isSubtype(Geometry.TYPES.MULTISURFACE, type)) {

                                        geom = GeometryLocator.getGeometryManager().createMultiSurface(currentGeom.getGeometryType().getSubType());

                                    } else {

                                        return geom;

                                    }

                                }

                                ((MultiPrimitive)geom).addPrimitives(currentGeom);

                            }

                        }

                    } catch (Exception ex){

                    }

                }

            } else {

                int selected = this.tblLocalChanges.getSelectedRow();

                if(selected >= 0){

                    OnlineWorkingcopyChange change = changes.get64(selected);

                    try {

                        OnlineWorkingcopy ws = getUndisposableWorkspace();

                        if(ws!=null) {

                            JsonObject json = change.getDataAsJson();

                            String entityCode = change.getEntityCode();

                            OnlineEntity entity = ws.getEntity(entityCode);

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

                            Feature feature = store.createNewFeature(json);

                            geom = feature.getDefaultGeometry();

                        }

                    } catch (Exception ex){

                    }

                }

            }

            return geom;

        } catch (Exception ex) {

            return geom;

        }

   }

    private Envelope getEnvelopeOfAllLocalChanges() {

        Envelope env = GeometryUtils.createEnvelope(Geometry.SUBTYPES.GEOM2D);

        try {

            OnlineWorkingcopy ws = getUndisposableWorkspace();

            for (int i = 0; i < changes.size64(); i++) {

                OnlineWorkingcopyChange change = changes.get64(i);

                Geometry currentGeom = change.getRelatedFeature().getDefaultGeometry();

                env.add(currentGeom);

                if (ws != null) {

                    try {

                    JsonObject json = change.getDataAsJson();

                    String entityCode = change.getEntityCode();

                    OnlineEntity entity = ws.getEntity(entityCode);

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

                    Feature feature = store.createNewFeature(json);

                    Geometry originalGeom = feature.getDefaultGeometry();

                    env.add(originalGeom);

                    } catch (Exception ex) {

                        continue;

                    }

                }

            }

            return env;

        } catch (Exception ex) {

            return env;

        }

    }

    private FeatureStore getStoreOfSelectedChange() {

        FeatureStore store = null;

        int selected = this.tblLocalChanges.getSelectedRow();

        if(selected >= 0){

            OnlineWorkingcopyChange change = changes.get64(selected);

            try {

                OnlineWorkingcopy ws = getUndisposableWorkspace();

                if(ws!=null) {

                    String entityCode = change.getEntityCode();

                    OnlineEntity entity = ws.getEntity(entityCode);

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

                }

            } catch (Exception ex){

            }

        }

        return store;

    }

    private void doZoomToSelectedChange() {

        cleanHighligthed();

//        OnlineManager manager = OnlineLocator.getOnlineManager();

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        OnlineSwingServices services =swingManager.getDefaultServices();

        if(tblLocalChanges.getSelectionModel().isSelectionEmpty()){

            FeatureStore store = this.context.getWorkspaceStoreOfSelectedEntity();

            if(store == null){

                return;

            }

            Envelope env = getEnvelopeOfAllLocalChanges();

            services.zoomViewsHavingAStoreToGeometry(store, env.getBox2D());

            return;

        }

        FeatureStore store = getStoreOfSelectedChange();     

        if( this.tblLocalChanges.getSelectedRowCount() > MAX_SELECTED_ROWS_TO_SHOW_GEOMETRIES ) {

            Geometry geom = getBBoxOfSelectedChanges();

            Geometry originalGeom = getOriginalBBoxOfSelectedChanges();

            services.zoomViewsHavingAStoreToGeometry(store, OnlineSwingCommons.createBBox(geom, originalGeom));

            this.context.message("_Too_many_items_selected");

        } else {

            Geometry geom = getGeometryOfSelectedChange();

            Geometry originalGeom = getOriginalGeometryOfSelectedChange();

            services.zoomViewsHavingAStoreToGeometry(store, OnlineSwingCommons.createBBox(geom, originalGeom));

            if(geom != null){

                services.highlight(HIGHLIGHT_WORKSPACE, geom, store);

            }

            if(originalGeom != null){

                services.highlight(HIGHLIGHT_WORKSPACE_PREVIOUS, originalGeom, store);

            }

        }        

    }

    private void doCenterToSelectedChange() {

        cleanHighligthed();

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        OnlineSwingServices services =swingManager.getDefaultServices();

        if(tblLocalChanges.getSelectionModel().isSelectionEmpty()){

            FeatureStore store = this.context.getWorkspaceStoreOfSelectedEntity();

            if(store == null){

                return;

            }

            Envelope env = getEnvelopeOfAllLocalChanges();

            services.centerViewsHavingAStoreToGeometry(store, env.getBox2D());

            return;

        }

        FeatureStore store = getStoreOfSelectedChange();

        if( this.tblLocalChanges.getSelectedRowCount() > MAX_SELECTED_ROWS_TO_SHOW_GEOMETRIES ) {

            Geometry geom = getBBoxOfSelectedChanges();

            Geometry originalGeom = getOriginalBBoxOfSelectedChanges();

            services.centerViewsHavingAStoreToGeometry(store, OnlineSwingCommons.createBBox(geom, originalGeom));

            this.context.message("_Too_many_items_selected");

        } else {

            Geometry geom = getGeometryOfSelectedChange();

            Geometry originalGeom = getOriginalGeometryOfSelectedChange();

            services.centerViewsHavingAStoreToGeometry(store, OnlineSwingCommons.createBBox(geom, originalGeom));

            if(geom != null){

                services.highlight(HIGHLIGHT_WORKSPACE, geom, store);

            }

            if(originalGeom != null){

                services.highlight(HIGHLIGHT_WORKSPACE_PREVIOUS, originalGeom, store);

            }

        }        

    }

    private void doHighLightSelectedChange() {

        cleanHighligthed();

//        OnlineManager manager = OnlineLocator.getOnlineManager();

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        OnlineSwingServices services =swingManager.getDefaultServices();

        FeatureStore store = getStoreOfSelectedChange();

        if( this.tblLocalChanges.getSelectedRowCount() > MAX_SELECTED_ROWS_TO_SHOW_GEOMETRIES ) {

            this.context.message("_Too_many_items_selected");

        } else {

            Geometry geom = getGeometryOfSelectedChange();

            Geometry originalGeom = getOriginalGeometryOfSelectedChange();

            if(geom != null){

                services.highlight(HIGHLIGHT_WORKSPACE, geom, store);

            }

            if(originalGeom != null){

                services.highlight(HIGHLIGHT_WORKSPACE_PREVIOUS, originalGeom, store);

            }

        }        

    }

    private List<String> getEntityCodes(List<OnlineEntity> entities) {

        List<String> res = new ArrayList();

        for (OnlineEntity entity : entities) {

            res.add(entity.getEntityCode());

        }

        return res;

    }

    public void selectOnlyAEntity(OnlineEntity entity){

        context.getEntitySelector().clearChecks();

        context.getEntitySelector().check(entity);

    }

    public void selectOnlyAEntity(List<OnlineEntity> entities){

        context.getEntitySelector().clearChecks();

        for (OnlineEntity entity : entities) {

            context.getEntitySelector().check(entity);

        }

    }

    @Override

    protected void doDispose() throws BaseException {

//        DisposeUtils.disposeQuietly(entitySelector);

    }

    private void doCheckRecomendedEntities() {

        final OnlineWorkingcopy workspace = this.getUndisposableWorkspace();

        if( workspace==null ) {

            return;

        }

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

        Collection<OnlineEntity> entities = context.getEntitySelector().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:

                    default:

                        commitEntities.add(entity.getEntityCode());

                        break;

                    case OnlineManager.STATE_LOCAL_UNMODIFIED:

                    case OnlineManager.STATE_REMOTE_NEW:

                    case OnlineManager.STATE_CONFLICT:

                    case OnlineManager.STATE_CORRUPT:

                    case OnlineManager.STATE_CORRUPT+OnlineManager.STATE_DISCONNECTED:

                    case OnlineManager.STATE_DISCONNECTED:

                    case OnlineManager.STATE_LOCAL_OUTDATED:

                    case OnlineManager.STATE_LOCAL_OUTDATED_AND_MODIFIED:

                        break;

                }

            }

        }

        context.getEntitySelector().setCheck(commitEntities, true);

    }

    private boolean areCorruptOrDisconnectedEntities(List<OnlineEntity> entities) {

        for (OnlineEntity entity : entities) {

            if( entity instanceof OnlineEntity ) {

                OnlineEntity lentity = (OnlineEntity) entity;

                int maskState = lentity.getState();

                if( (maskState & STATE_DISCONNECTED)  == STATE_DISCONNECTED || 

                        (maskState & STATE_CORRUPT)  == STATE_CORRUPT) {

                    return true;

                }

            }

        }

        return false;

    }

    private boolean areConflictEntities(List<OnlineEntity> entities) {

        for (OnlineEntity entity : entities) {

            if( entity instanceof OnlineEntity ) {

                OnlineEntity lentity = (OnlineEntity) entity;

                int maskState = lentity.getState();

                if( (maskState & STATE_CONFLICT)  == STATE_CONFLICT) {

                    return true;

                }

            }

        }

        return false;

    }

}