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.vcsgis.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.sql.Timestamp;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

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

import javax.swing.ListSelectionModel;

import javax.swing.event.ChangeEvent;

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

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.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

import org.gvsig.tools.swing.api.pickercontroller.DatePickerController;

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.vcsgis.lib.VCSGisChange;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_OK;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_ADD_ENTITY;

import static org.gvsig.vcsgis.lib.VCSGisManager.OP_DELETE;

import org.gvsig.vcsgis.lib.VCSGisRuntimeException;

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

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

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

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

import org.gvsig.vcsgis.swing.VCSGisSwingLocator;

import org.gvsig.vcsgis.swing.VCSGisSwingManager;

import org.gvsig.vcsgis.swing.VCSGisSwingServices;

import static org.gvsig.vcsgis.swing.VCSGisSwingServices.HIGHLIGHT_WORKSPACE;

import static org.gvsig.vcsgis.swing.VCSGisSwingServices.HIGHLIGHT_WORKSPACE_PREVIOUS;

import org.gvsig.vcsgis.swing.VCSGisEntitySelectorController;

import org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons.cleanHighligthed;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons.notInSwingThreadInvokeLater;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons.refreshDocument;

import static org.gvsig.vcsgis.swing.impl.VCSGisSwingCommons.showAuthenticationErrors;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class LocalChangesController {

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

    private final JButton btnLocalCheckAllEntities;

    private final JButton btnLocalUnCheckAllEntities;

    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 JLabel lblLocalEffectiveDate;

    private final JTextField txtLocalEffectiveDate;

    private final JTextField txtLocalComment;

    private final JButton btnLocalEffectiveDate;

    private final JLabel lblLocalComment;

    private final PickerController<VCSGisWorkspace> workspacePicker;    

    private final VCSGisJChangesImpl context;

    private final JButton btnLocalZoom;

    private final JButton btnLocalCenter;

    private final JButton btnLocalHighlight;

    private final JLabel lblLocalChangesCount;

    private VCSGisWorkspaceChanges<VCSGisWorkspaceChange> changes;

    private ChangesTableModel localChangesTableModel;

    private List<VCSGisWorkspaceEntity> entitiesWithSelectedChanges = null;

    private DatePickerController effectiveDatePicker;

    private final Set<String> entitiesToUnCheckAll;

    private TableModelListener tableModelListener;

    private boolean dissabledUncheckAllByEntities;

    private final JButton btnLocalCleanHighlighted;

    private final JTextField txtLocalTablesFilter;

    private final JButton btnLocalTable;

    private final JTree treeLocalTables;

    private VCSGisEntitySelectorController entitySelector;

    private boolean isSelectionFromEntitiesEmpty;

    public LocalChangesController(

        VCSGisJChangesImpl context,

        PickerController<VCSGisWorkspace> workspacePicker,

        JButton btnLocalCheckAllEntities,

        JButton btnLocalUnCheckAllEntities,

        JTable tblLocalChanges,

        JButton btnLocalCheckAll,

        JButton btnLocalUnCheckAll,

        JButton btnLocalShowForm,

        JButton btnLocalRefresh,

        JButton btnLocalCommit,

        JButton btnLocalRevert,

        JLabel lblLocalEffectiveDate,

        JTextField txtLocalEffectiveDate,

        JTextField txtLocalComment,

        JButton btnLocalEffectiveDate,

        JLabel lblLocalComment,

        JButton btnLocalZoom,

        JButton btnLocalCenter,

        JButton btnLocalHighlight,

        JButton btnLocalCleanHighlighted,

        JLabel lblLocalChangesCount,

        JTextField txtLocalTablesFilter,

        JButton btnLocalTable,

        JTree treeLocalTables

        ) {

        this.dissabledUncheckAllByEntities = false;

        this.context = context;

        this.workspacePicker = workspacePicker;

        this.tblLocalChanges = tblLocalChanges;

        this.btnLocalCheckAll = btnLocalCheckAll;

        this.btnLocalCheckAllEntities = btnLocalCheckAllEntities;

        this.btnLocalCommit = btnLocalCommit;

        this.btnLocalEffectiveDate = btnLocalEffectiveDate;

        this.btnLocalRefresh = btnLocalRefresh;

        this.btnLocalRevert = btnLocalRevert;

        this.btnLocalShowForm = btnLocalShowForm;

        this.btnLocalUnCheckAll = btnLocalUnCheckAll;

        this.btnLocalUnCheckAllEntities = btnLocalUnCheckAllEntities;

        this.lblLocalComment = lblLocalComment;

        this.lblLocalEffectiveDate = lblLocalEffectiveDate;

        this.txtLocalComment = txtLocalComment;

        this.txtLocalEffectiveDate = txtLocalEffectiveDate;

        this.btnLocalZoom = btnLocalZoom;

        this.btnLocalCenter = btnLocalCenter;

        this.btnLocalHighlight = btnLocalHighlight;

        this.btnLocalCleanHighlighted = btnLocalCleanHighlighted;

        this.lblLocalChangesCount= lblLocalChangesCount;

        this.txtLocalTablesFilter = txtLocalTablesFilter;

        this.btnLocalTable = btnLocalTable;

        this.treeLocalTables = treeLocalTables;

        this.entitiesToUnCheckAll = new HashSet<>();

        initComponents();

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        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.btnLocalEffectiveDate.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.entitySelector = VCSGisSwingLocator.getVCSGisSwingManager().createEntitySelectorController(

                this.treeLocalTables, 

                txtLocalTablesFilter, 

                btnLocalTable

        );

        this.entitySelector.setViewFilter(VCSGisEntitySelectorController.LOCAL_ENTITIES);

        this.entitySelector.setFilter(VCSGisEntitySelectorController.LOCAL_ENTITIES);

        this.entitySelector.setChecksEnabled(true);

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

            doUpdateTableLocalChanges();

        });

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

            switch(e.getID()) {

//                case VCSGisEntitySelectorController.ACTION_SELECT_ID:

//                    break;

                case VCSGisEntitySelectorController.ACTION_CHECK_ID:

                    doUpdateTableLocalChanges();

                    doUpdateComponents();

                    break;

                case VCSGisEntitySelectorController.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.effectiveDatePicker = toolsSwingManager.createDatePickerController(

                this.txtLocalEffectiveDate,

                this.btnLocalEffectiveDate

        );

        this.effectiveDatePicker.set(new Date());

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

        });

        toolsSwingManager.addClearButton(this.txtLocalComment);

        toolsSwingManager.setDefaultPopupMenu(txtLocalComment);

        context.doUpdateComponents();

    }

    public void doChangeWorkspace() {

        this.entitySelector.setWorkspace(getWorkspace());

//        doUpdateTableLocalChanges();

    }

    private void translate() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

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

        swingManager.translate(this.lblLocalComment);

        swingManager.translate(this.btnLocalCenter);

        swingManager.translate(this.btnLocalHighlight);

        swingManager.translate(this.btnLocalZoom);

        swingManager.translate(this.btnLocalCleanHighlighted);

    }

    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, (VCSGisWorkspaceChange 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){

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

    }

    public VCSGisWorkspace getWorkspace() {

        return this.context.getWorkspace();

    }

    /* friend */ void doUpdateComponents() {

        if (notInSwingThreadInvokeLater(() -> {

            doUpdateComponents();

        })) {

            return;

        }

        try {

            this.context.setVisibleStatus(context.processing);

            VCSGisWorkspace ws = getWorkspace();

            this.context.updateEntitiesFromRepository(false);

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

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

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

            this.btnLocalCheckAll.setEnabled(!context.processing && changes != null && changes.size64() > 0);

            this.btnLocalUnCheckAll.setEnabled(!context.processing && changes != null && changes.size64() > 0);

            List<VCSGisEntity> checkedEntities = entitySelector.getCheckedEntities();

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

            this.btnLocalRevert.setEnabled(ws != null

                    && !context.processing

                    && changes != null

                    && changes.size64() > 0

                    && CollectionUtils.isNotEmpty(checkedEntities)

                    && entitiesWithSelectedChanges != null

                    && !entitiesWithSelectedChanges.isEmpty()

                    && !isSelectionFromEntitiesEmpty

            );

            this.btnLocalRevert.setVisible(true);

            this.btnLocalCommit.setEnabled(ws != null

                    && !context.processing

                    && changes != null

                    && !this.changes.isSelectionEmpty()

                    && CollectionUtils.isNotEmpty(checkedEntities)

                    && ws.canCommit(null, getEntityCodes(checkedEntities))

            );

            //Show form

            boolean enableShowForm = false;

            int row = this.tblLocalChanges.getSelectedRow();

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

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

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

                    enableShowForm = true;

                }

            }

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

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

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

            this.effectiveDatePicker.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 (VCSGisRuntimeException e1) {

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

            if (showAuthenticationErrors("_VCS_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() {

        VCSGisWorkspace ws = this.getWorkspace();

        if (ws != null) {

            entitiesWithSelectedChanges = ws.getEntitiesWithSelectedChanges();

        }

    }

    private void doUpdateIsSelectionFromEntitiesEmpty() {

        VCSGisWorkspace ws = this.getWorkspace();

        if (ws != null) {

            List<VCSGisEntity> checkedEntities = entitySelector.getCheckedEntities();

            this.isSelectionFromEntitiesEmpty = changes.isSelectionFromEntitiesEmpty(checkedEntities);

        }

    }

    public void doUpdateTableLocalChanges() {

        if( context.processing ) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        VCSGisWorkspace ws = this.getWorkspace();

        if(ws != null){

            doUpdateEntitiesWithSelectedChanges();

            List<VCSGisEntity> checkedEntities = entitySelector.getCheckedEntities();

            if(CollectionUtils.isEmpty(checkedEntities)) {

                localChangesTableModel = new ChangesTableModel(ws);

                this.tblLocalChanges.setModel(localChangesTableModel);

                return;

            }

            changes = ws.getLocalChanges(checkedEntities);

            localChangesTableModel = new ChangesTableModel(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);

                        VCSGisChange changeRow = changes.get64(row);

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

                        return c;

                    }

                });

            }

            this.tableModelListener = null;

            localChangesTableModel.addTableModelListener(getTableModelListener());

            context.message(i18n.getTranslation(

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

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

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

        VCSGisWorkspace ws = getWorkspace();

        if( ws==null ) {

            // TODO: Mensaje al usuario ??

            return;

        }

        List<VCSGisEntity> entities = entitySelector.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.canCommit(message, entityCodes) ) {

            dialogs.messageDialog(

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

                    i18n.getTranslation("_Commit"), 

                    JOptionPane.WARNING_MESSAGE

            );

            return;

        }

        Timestamp effectiveDate = new Timestamp(effectiveDatePicker.get().getTime());

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

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                if( !executeTopologyPlans(ws, entities) ) {

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

                );

                doPostCommit(r);

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisCommit");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

    private boolean executeTopologyPlans(VCSGisWorkspace ws, List<VCSGisEntity> entities) {

        boolean topologyRequired = false;

        for (VCSGisEntity entity : entities) {

            String x = ws.getTopologyPlan(entity.getTopologyPlanCode());

            if( StringUtils.isNotBlank(x) ) {

                topologyRequired= true;

                break;

            }

        }

        if (!topologyRequired){

            return true;

        }

        try {

            TopologyPlansExecutor executor = new TopologyPlansExecutor();

            return executor.execute(ws, entities);

        }catch(Exception ex){

            return false;

        }

    }

    private void doPostCommit(int commitStatus) {

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

            return;

        }

        if( commitStatus == ERR_OK) {

            this.context.setVisibleStatus(false);

        } else {

            showAuthenticationErrors("_VCS_Commit", commitStatus);

        }

        context.updateLocalChangesTable();

        cleanHighligthed();

    }

    private void doRevert() {

        VCSGisWorkspace ws = getWorkspace();

        if( ws==null ) {

            // TODO: Mensaje al usuario

            return;

        }

        this.context.updateEntitiesFromRepository(false);

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

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

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

                int r = ERR_OK;

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

                    for (VCSGisWorkspaceEntity entity : entities) {

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

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

                                    this.context.getTaskStatusController().getSimpleTaskStatus()

                            );

                        }

                        if(r != ERR_OK){

                            break;

                        }

                    }

                }

                doPostRevert(r, entities);

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisRevert");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

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

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

            return;

        }

        if( revertStatus == ERR_OK) {

            this.context.setVisibleStatus(false);

        }

        for (VCSGisWorkspaceEntity entity : entities) {

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

            refreshDocument(store);

        }

        context.updateLocalChangesTable();

        cleanHighligthed();

    }

    private Geometry getGeometryOfSelectedChange() {

        Geometry geom = null;

        int selected = this.tblLocalChanges.getSelectedRow();

        if(selected >= 0){

            VCSGisWorkspaceChange change = changes.get64(selected);

            try {

                Feature feature = change.getRelatedFeature();

                geom = feature.getDefaultGeometry();

            } catch (Exception ex){

            }

        }

        return geom;

    }

    private Geometry getOriginalGeometryOfSelectedChange() {

        Geometry geom = null;

        int selected = this.tblLocalChanges.getSelectedRow();

        if(selected >= 0){

            VCSGisWorkspaceChange change = changes.get64(selected);

            try {

                VCSGisWorkspace ws = getWorkspace();

                if(ws!=null) {

                    JsonObject json = change.getDataAsJson();

                    String entityCode = change.getEntityCode();

                    VCSGisEntity entity = ws.getEntity(entityCode);

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

                    Feature feature = store.createNewFeature(json);

                    geom = feature.getDefaultGeometry();

                }

            } catch (Exception ex){

            }

        }

        return geom;

    }

    private FeatureStore getStoreOfSelectedChange() {

        FeatureStore store = null;

        int selected = this.tblLocalChanges.getSelectedRow();

        if(selected >= 0){

            VCSGisWorkspaceChange change = changes.get64(selected);

            try {

                VCSGisWorkspace ws = getWorkspace();

                if(ws!=null) {

                    String entityCode = change.getEntityCode();

                    VCSGisEntity entity = ws.getEntity(entityCode);

                    store = ws.getFeatureStore(entity.getEntityName());

                }

            } catch (Exception ex){

            }

        }

        return store;

    }

    private void doZoomToSelectedChange() {

        cleanHighligthed();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services =swingManager.getDefaultServices();

        FeatureStore store = getStoreOfSelectedChange();

        Geometry geom = getGeometryOfSelectedChange();

        Geometry originalGeom = getOriginalGeometryOfSelectedChange();

        services.zoomViewsHavingAStoreToGeometry(store, VCSGisSwingCommons.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();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services =swingManager.getDefaultServices();

        FeatureStore store = getStoreOfSelectedChange();

        Geometry geom = getGeometryOfSelectedChange();

        Geometry originalGeom = getOriginalGeometryOfSelectedChange();

        services.centerViewsHavingAStoreToGeometry(store, VCSGisSwingCommons.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();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services =swingManager.getDefaultServices();

        FeatureStore store = getStoreOfSelectedChange();

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

        List<String> res = new ArrayList();

        for (VCSGisEntity entity : entities) {

            res.add(entity.getEntityCode());

        }

        return res;

    }

    public void selectOnlyAEntity(VCSGisEntity entity){

        entitySelector.clearChecks();

        entitySelector.check(entity);

    }

}