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.util.Iterator;

import javax.swing.DefaultListCellRenderer;

import javax.swing.DefaultListModel;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ListSelectionEvent;

import javax.swing.table.DefaultTableCellRenderer;

import javax.swing.table.DefaultTableModel;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

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

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.feature.FeatureType;

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.json.Json;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynform.DynFormLocator;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynobject.DynObject;

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.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

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 static org.gvsig.vcsgis.lib.VCSGisManager.STATE_UNKNOWN;

import org.gvsig.vcsgis.lib.VCSGisRuntimeException;

import org.gvsig.vcsgis.lib.repository.VCSGisRepositoryChange;

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

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

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.changes.VCSGisJChangesImpl.LOCAL_TAB_INDEX;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class RemoteChangesController {

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

    private final PickerController<VCSGisWorkspace> workspacePicker;

    private final JTable tblRemoteChanges;

    private final JButton btnRemoteShowForm;

    private final JButton btnRemoteUpdate;

    private final JButton btnRemoteMerge;

    private final JButton btnRemoteReloadChanges;

    private final JButton btnRemoteCheckAll;

    private final JButton btnRemoteUnCheckAll;

    private final JList lstRemoteTables;

    private VCSGisWorkspaceChanges<VCSGisRepositoryChange> changes;

    private final JButton btnRemoteTablesReload;

    private final JButton btnRemoteDownloadChanges;

    private final JButton btnRemoteCleanChanges;

    private final VCSGisJChangesImpl context;

    private final JButton btnRemoteZoom;

    private final JButton btnRemoteCenter;

    private final JButton btnRemoteCheckout;

    private final JButton btnRemoteCleanHighligthed;

    private final JLabel lblRemoteChangesCount;

    public RemoteChangesController(

            VCSGisJChangesImpl context,

            PickerController<VCSGisWorkspace> workspacePicker,

            JList lstRemoteTables,

            JButton btnRemoteTablesReload,

            JTable tblRemoteChanges,

            JButton btnRemoteCheckAll,

            JButton btnRemoteUnCheckAll,

            JButton btnRemoteDownloadChanges,

            JButton btnRemoteReloadChanges,

            JButton btnRemoteCleanChanges,

            JButton btnRemoteUpdate,

            JButton btnRemoteMerge,

            JButton btnRemoteShowForm,

            JButton btnRemoteZoom,

            JButton btnRemoteCenter,

            JButton btnRemoteCheckout,

            JButton btnRemoteCleanHighligthed,

            JLabel lblRemoteChangesCount

    ) {

        this.context = context;

        this.workspacePicker = workspacePicker;

        this.lstRemoteTables = lstRemoteTables;

        this.btnRemoteTablesReload = btnRemoteTablesReload;

        this.tblRemoteChanges = tblRemoteChanges;

        this.btnRemoteCheckAll = btnRemoteCheckAll;

        this.btnRemoteUnCheckAll = btnRemoteUnCheckAll;

        this.btnRemoteDownloadChanges = btnRemoteDownloadChanges;

        this.btnRemoteCleanChanges = btnRemoteCleanChanges;

        this.btnRemoteReloadChanges = btnRemoteReloadChanges;

        this.btnRemoteUpdate = btnRemoteUpdate;

        this.btnRemoteMerge = btnRemoteMerge;

        this.btnRemoteShowForm = btnRemoteShowForm;

        this.btnRemoteZoom = btnRemoteZoom;

        this.btnRemoteCenter = btnRemoteCenter;

        this.btnRemoteCheckout = btnRemoteCheckout;

        this.btnRemoteCleanHighligthed = btnRemoteCleanHighligthed;

        this.lblRemoteChangesCount= lblRemoteChangesCount;

        initComponents();

    }

    public void message(final String msg) {

        this.context.message(msg);

    }

    public void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        I18nManager i18n = ToolsLocator.getI18nManager();

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

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

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

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

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

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

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

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

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

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

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

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

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

        translate();

        lstRemoteTables.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        lstRemoteTables.setCellRenderer(new DefaultListCellRenderer() {

            @Override

            public java.awt.Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

                JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

                LabeledValue lvalue = (LabeledValue) value;

                VCSGisEntity entity = (VCSGisEntity) lvalue.getValue();

                String entityCode = entity.getEntityCode();

                VCSGisWorkspaceEntity lentity = getWorkspace().getWorkspaceEntity(entityCode);

                String s = VCSGisSwingCommons.getHTMLColorTag(

                        lentity == null ? VCSGisManager.STATE_REPOSITORY_NEW : lentity.getState(),

                        lvalue.getLabel()

                );

                label.setText(s);

                return label;

            }

        });

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

            doReloadChanges();

        });

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

            doReloadTables(true);

            doReloadChanges();

        });

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

        this.tblRemoteChanges.addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

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

                    doToggleSelection();

                }

            }

        });

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

            context.doUpdateComponents();

        });

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

            if (changes != null) {

                doCheckAll();

                doReloadChanges();

            }

        });

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

            if (changes != null) {

                doUnCheckAll();

                doReloadChanges();

            }

        });

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

            doDownloadChangesOfSelectedTable();

        });

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

            doDownloadChangesOfSelectedTable();

        });

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

            doCleanChanges();

            doReloadChanges();

        });

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

            doUpdate();

        });

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

            doMerge();

        });

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

            doShowForm();

        });

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

            doZoomToSelectedChange();

        });

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

            doCenterToSelectedChange();

        });

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

            cleanHighligthed();

        });

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

            doCheckout();

        });

        context.doUpdateComponents();

        SwingUtilities.invokeLater(() -> {

            message(i18n.getTranslation("_Ready"));

            this.lblRemoteChangesCount.setText("");

        });

    }

    public void doChangeWorkspace() {

        doReloadTables(false);

        doReloadChanges();

    }

    public void translate() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        swingManager.translate(this.btnRemoteCheckAll);

        swingManager.translate(this.btnRemoteUpdate);

        swingManager.translate(this.btnRemoteCleanChanges);

        swingManager.translate(this.btnRemoteReloadChanges);

        swingManager.translate(this.btnRemoteMerge);

        swingManager.translate(this.btnRemoteShowForm);

        swingManager.translate(this.btnRemoteUnCheckAll);

        swingManager.translate(this.btnRemoteTablesReload);

        swingManager.translate(this.btnRemoteDownloadChanges);

        swingManager.translate(this.btnRemoteCenter);

        swingManager.translate(this.btnRemoteZoom);

        swingManager.translate(this.btnRemoteCheckout);

        swingManager.translate(this.btnRemoteCleanHighligthed);

    }

    public VCSGisWorkspace getWorkspace() {

        return this.context.getWorkspace();

    }

    /* friend */ void doUpdateComponents() {

        if (notInSwingThreadInvokeLater(() -> {

            doUpdateComponents();

        })) {

            return;

        }

        try {

            this.context.setVisibleStatus(context.processing);

            VCSGisWorkspace ws = this.getWorkspace();

            this.btnRemoteCheckAll.setEnabled(!context.processing && changes != null);

            this.btnRemoteUnCheckAll.setEnabled(!context.processing && changes != null);

            this.btnRemoteDownloadChanges.setEnabled(!context.processing && ws != null && BooleanUtils.isTrue(this.isSelectedTableInWorkspace()));

            this.btnRemoteCheckout.setEnabled(!context.processing && ws != null && BooleanUtils.isFalse(this.isSelectedTableInWorkspace()));

            this.btnRemoteReloadChanges.setEnabled(!context.processing && ws != null && BooleanUtils.isTrue(this.isSelectedTableInWorkspace()));

            this.btnRemoteCleanChanges.setEnabled(!context.processing && ws != null && BooleanUtils.isTrue(this.isSelectedTableInWorkspace()));

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

            this.btnRemoteTablesReload.setEnabled(!context.processing && ws != null);

            //Show form

            boolean enableShowForm = false;

            int row = this.tblRemoteChanges.getSelectedRow();

            if (row >= 0) {

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

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

                    enableShowForm = true;

                }

            }

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

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

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

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

            LabeledValue selected = (LabeledValue) lstRemoteTables.getSelectedValue();

            if (selected == null) {

                this.btnRemoteMerge.setEnabled(false);

                this.btnRemoteUpdate.setEnabled(false);

                return;

            }

            VCSGisEntity entity = (VCSGisEntity) selected.getValue();

            if (this.getWorkspace().updateNeedMerge(entity.getEntityName())) {

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

                this.btnRemoteUpdate.setEnabled(false);

            } else {

                this.btnRemoteMerge.setEnabled(false);

                this.btnRemoteUpdate.setEnabled(!context.processing && changes != null && !this.changes.isSelectionEmpty());

            }

            Geometry repoGeom = getRepositoryGeometryOfSelectedChange();

            Geometry wsGeom = getWorkspaceGeometryOfSelectedChange();

            Geometry bbox = VCSGisSwingCommons.createBBox(repoGeom, wsGeom);

            this.btnRemoteCenter.setEnabled(!context.processing && bbox != null);

            this.btnRemoteZoom.setEnabled(!context.processing && bbox != null);

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

        }

    }

    private void doToggleSelection() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                Iterator<Long> rows = getChangesSelectionIterator();

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

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

                    return true;

                });

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisToggleSelectionRemoteChanges");

        task.start();

    }

    private Iterator<Long> getChangesSelectionIterator() {

        ListSelectionModel selection = this.tblRemoteChanges.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 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;

                context.doUpdateComponents();

                Iterator<Long> rows = getRowsIterator();

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

                    change.setSelected(true);

                    return true;

                });

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisCheckAllRemoteChanges");

        task.start();

    }

    private void doUnCheckAll() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                Iterator<Long> rows = getRowsIterator();

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

                    change.setSelected(false);

                    return true;

                });

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisCheckAllRemoteChanges");

        task.start();

    }

    private void doUpdate() {

        VCSGisWorkspace ws = getWorkspace();

        if (ws == null) {

            return;

        }

        LabeledValue selectedTable = (LabeledValue) lstRemoteTables.getSelectedValue();

        if (selectedTable == null) {

            return;

        }

        VCSGisEntity entity = (VCSGisEntity) selectedTable.getValue();

        String tableName = entity.getEntityName();

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

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                int r = ws.update(tableName, null);

                doPostUpdate(r);

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisUpdate");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

    private void doPostUpdate(int updateStatus) {

        if (notInSwingThreadInvokeLater(() -> {doPostUpdate(updateStatus);})) {

            return;

        }

        if (updateStatus == ERR_OK) {

            context.setVisibleStatus(false);

        }

        doReloadChanges();

        VCSGisEntity selectedTable = getSelectedTable();

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

        refreshDocument(store);

        context.doUpdateComponents();

        context.updateLocalChangesTable();

    }

    private void doMerge() {

        VCSGisWorkspace ws = getWorkspace();

        if (ws == null) {

            return;

        }

        LabeledValue selectedTable = (LabeledValue) lstRemoteTables.getSelectedValue();

        if (selectedTable == null) {

            return;

        }

        VCSGisEntity entity = (VCSGisEntity) selectedTable.getValue();

        String tableName = entity.getEntityName();

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

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                MutableLong localChangesCreated = new MutableLong(0);

                int r = getWorkspace().merge(

                        tableName,

                        localChangesCreated,

                        this.context.getTaskStatusController().getSimpleTaskStatus()

                );

                doPostMerge(r, localChangesCreated.getValue());

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "VCSGisMerge");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

    private void doPostMerge(int mergeStatus, long localChangesCreated) {

        if (notInSwingThreadInvokeLater(() -> {doPostMerge(mergeStatus, localChangesCreated);})) {

            return;

        }

        if (mergeStatus == ERR_OK) {

            this.context.setVisibleStatus(false);

        }

        doReloadChanges();

        VCSGisEntity selectedTable = getSelectedTable();

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

        refreshDocument(store);

        if(localChangesCreated>0){

            ThreadSafeDialogsManager dialogsManager = ToolsSwingLocator.getThreadSafeDialogsManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            dialogsManager.messageDialog(

                    i18n.getTranslation("_The_process_has_created_local_changes_that_would_need_to_be_committed_to_the_repository"), 

                    null, 

                    i18n.getTranslation("_VCSGis_Merge"), 

                    JOptionPane.INFORMATION_MESSAGE, 

                    "VCSGIS_merge_need_commit");

            context.selectTab(LOCAL_TAB_INDEX);

            context.selectOnlyALocalEntity(selectedTable);

        }

        context.doUpdateComponents();

        context.updateLocalChangesTable();

    }

    private void doShowForm() {

        if (this.changes == null) {

            return;

        }

        int row = this.tblRemoteChanges.getSelectedRow();

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

        if (change.getOperation() == OP_DELETE) {

            return;

        }

        VCSGisWorkspace ws = this.getWorkspace();

        if (ws == null) {

            return;

        }

        VCSGisWorkspaceEntity entity = ws.getWorkspaceEntityByCode(change.getEntityCode());

        if (entity == null) {

            VCSGisEntity repoEntity = ws.getEntity(change.getEntityCode());

            FeatureType featureType = repoEntity.getFeatureType();

            JDynForm form = DynFormLocator.getDynFormManager().createJDynForm(featureType);

            DynObject values = ToolsLocator.getDynObjectManager().createDynObject(featureType);

            Json.addAll(values, change.getRelatedFeatureDataAsJson());

            form.setValues(values);

            form.setReadOnly(true);

            WindowManager winManager = ToolsSwingLocator.getWindowManager();

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

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

            return;

        }

        FeatureStore store = null;

        try {

            DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

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

            Feature feature = store.createNewFeature(change.getRelatedFeatureDataAsJson());

            JFeatureForm form = dataSwingManager.createJFeatureForm(feature);

            form.getDynForm().setReadOnly(true);

            WindowManager winManager = ToolsSwingLocator.getWindowManager();

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

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

        } catch (Exception ex) {

            LOGGER.warn("Can't show form for change '" + change.getCode() + "'.", ex);

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    private void doReloadChanges() {

        VCSGisWorkspace ws = this.getWorkspace();

        if (ws == null) {

            return;

        }

        if (this.changes != null) {

            this.changes.removeAllChangeListener();

        }

        LabeledValue selected = (LabeledValue) lstRemoteTables.getSelectedValue();

        if (selected != null) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            VCSGisEntity entity = (VCSGisEntity) selected.getValue();

            message("Reloading list of remote changes...");

            this.changes = ws.getRemoteChangesByEntity(entity.getEntityName());

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

                context.doUpdateComponents();

            });

            ChangesTableModel changesModel = new ChangesTableModel(changes, ws);

            this.tblRemoteChanges.setModel(changesModel);

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

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

                this.tblRemoteChanges.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;

                    }

                });

            }

            context.doUpdateComponents();

            context.message(i18n.getTranslation(

                    "_Repository_changes_list_updated", 

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

                )

            );

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

        } else {

            this.changes = null;

            this.tblRemoteChanges.setModel(new DefaultTableModel());

            this.lblRemoteChangesCount.setText("0");

        }

    }

    private void doCleanChanges() {

        VCSGisWorkspace ws = this.getWorkspace();

        if (ws == null) {

            return;

        }

        LabeledValue tableSelected = (LabeledValue) lstRemoteTables.getSelectedValue();

        if (tableSelected != null) {

            final VCSGisEntity entity = (VCSGisEntity) tableSelected.getValue();

            Thread task = new Thread(() -> {

                try {

                    context.processing = true;

                    context.doUpdateComponents();

                    message("Removing list of remote changes from " + entity.getEntityName() + "...");

                    ws.updateClean(entity.getEntityCode());

                    message("Ready.");

                } finally {

                    context.processing = false;

                    context.doUpdateComponents();

                }

            }, "VCSGisUpdateClean");

            task.start();

        }

    }

    private void doDownloadChangesOfSelectedTable() {

        VCSGisWorkspace ws = this.getWorkspace();

        if (ws == null) {

            return;

        }

        LabeledValue selected = (LabeledValue) lstRemoteTables.getSelectedValue();

        if (selected == null) {

            return;

        }

        Thread task = new Thread(() -> {

                try {

                    context.processing = true;

                    context.doUpdateComponents();

                    VCSGisEntity entity = (VCSGisEntity) selected.getValue();

                    message("Removing list of remote changes of " + entity.getEntityName() + "...");

                    ws.updateClean(entity.getEntityName());

                    message("Downloading list of remote changes of " + entity.getEntityName() + "...");

                    ws.updatePrepare(entity.getEntityName());

                    context.updateLocalChangesTable();

                } finally {

                    context.processing = false;

                    context.doUpdateComponents();

                    doReloadChanges();

                }

            }, "VCSGisUpdatePrepare"

        );

        context.processing = true;

        context.doUpdateComponents();

        task.start();

        message("_Ready");

    }

    private void doReloadTables(boolean forceUpdateEntities) {

        DefaultListModel model = new DefaultListModel();

        VCSGisWorkspace ws = this.getWorkspace();

        if (ws == null) {

            this.lstRemoteTables.setModel(model);

            return;

        }

        message("Updating list of tables from remote repository...");// "+ws.getRepository().getLabel()+")...");

        this.context.updateEntitiesFromRepository(forceUpdateEntities);

        message("Loading list of tables...");

        for (VCSGisEntity entity : ws.getRepositoryEntities()) {

            model.addElement(new LabeledValueImpl<>(entity.getEntityName(), entity));

        }

        this.lstRemoteTables.setModel(model);

        context.doUpdateComponents();

        message("Ready.");

    }

    public boolean isProcessing() {

        return context.processing;

    }

    private Geometry getRepositoryGeometryOfSelectedChange() {

        Geometry geom = null;

        int selected = this.tblRemoteChanges.getSelectedRow();

        if(selected >= 0){

            VCSGisRepositoryChange change = changes.get64(selected);

            geom = change.getGeometry();

        }

        return geom;

    }

    private Geometry getWorkspaceGeometryOfSelectedChange() {

        Geometry geom = null;

        int selected = this.tblRemoteChanges.getSelectedRow();

        if(selected >= 0){

            VCSGisRepositoryChange change = changes.get64(selected);

            Feature f = getWorkspace().getRelatedFeature(change);

            if(f!= null){

                geom = f.getDefaultGeometry();

            }

        }

        return geom;

    }

    private FeatureStore getWorkspaceStoreOfSelectedChange() {

        FeatureStore store = null;

        int selected = this.tblRemoteChanges.getSelectedRow();

        if(selected >= 0){

            VCSGisRepositoryChange change = changes.get64(selected);

            VCSGisWorkspace ws = getWorkspace();

            VCSGisWorkspaceEntity entity = ws.getWorkspaceEntityByCode(change.getEntityCode());

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

        }

        return store;

    }

    private void doZoomToSelectedChange() {

        cleanHighligthed();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services = swingManager.getDefaultServices();

        FeatureStore store = getWorkspaceStoreOfSelectedChange();

        Geometry repoGeom = getRepositoryGeometryOfSelectedChange();

        Geometry geom = getWorkspaceGeometryOfSelectedChange();

//        services.zoomActiveViewToGeometry(VCSGisSwingCommons.createBBox(repoGeom, geom));

        services.zoomViewsHavingAStoreToGeometry(store, VCSGisSwingCommons.createBBox(repoGeom, geom));

        if(repoGeom != null){

            services.highlight(HIGHLIGHT_REPOSITORY, repoGeom, store);

        }

        if(geom != null){

            services.highlight(HIGHLIGHT_WORKSPACE, geom, store);

        }

    }

    private void doCenterToSelectedChange() {

        cleanHighligthed();

        VCSGisManager manager = VCSGisLocator.getVCSGisManager();

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services = swingManager.getDefaultServices();

        FeatureStore store = getWorkspaceStoreOfSelectedChange();

        Geometry repoGeom = getRepositoryGeometryOfSelectedChange();

        Geometry geom = getWorkspaceGeometryOfSelectedChange();

//        services.centerActiveViewToGeometry(VCSGisSwingCommons.createBBox(repoGeom, geom));

        services.centerViewsHavingAStoreToGeometry(store, VCSGisSwingCommons.createBBox(repoGeom, geom));

        if(repoGeom != null){

            services.highlight(HIGHLIGHT_REPOSITORY, repoGeom, store);

        }

        if(geom != null){

            services.highlight(HIGHLIGHT_WORKSPACE, geom, store);

        }

    }

    private void doCheckout() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        final VCSGisWorkspace workspace = this.getWorkspace();

        VCSGisEntity entity = getSelectedTable();

        if (workspace != null && entity != null) {

            Thread task = new Thread(() -> {

                try {

                    context.processing = true;

                    context.doUpdateComponents();

                    int r = workspace.checkout(entity.getEntityName());

                    if (r != ERR_OK) {

                        this.message(i18n.getTranslation("_Cant_checkout"));

                    } else {

                        postCheckout(r, entity);

                    }

                } finally {

                    context.processing = false;

                    context.doUpdateComponents();

                    context.updateLocalChangesTable();

                }

            }, "VCSGisCheckout");

            this.context.processing = true;

            doUpdateComponents();

            task.start();

        }

    }

    private void postCheckout(int checkoutStatus, VCSGisEntity entity) {

        if (notInSwingThreadInvokeLater(() -> {

            postCheckout(checkoutStatus, entity);

        })) {

            return;

        }

        VCSGisSwingManager swingManager = VCSGisSwingLocator.getVCSGisSwingManager();

        VCSGisSwingServices services = swingManager.getDefaultServices();

        I18nManager i18n = ToolsLocator.getI18nManager();

        final VCSGisWorkspace workspace = this.getWorkspace();

        if (checkoutStatus == ERR_OK) {

            this.context.setVisibleStatus(false);

            if (StringUtils.isNotBlank(entity.getGeometryFieldName()) && services.isThereAnyActiveView()) {

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                dialogs.confirmDialog(i18n.getTranslation("_Do_you_want_add_layer_to_active_view"),

                        i18n.getTranslation("_VCS_Checkout"),

                        JOptionPane.YES_NO_OPTION,

                        JOptionPane.QUESTION_MESSAGE,

                        "VCSGis_Checkout_add_layer_to_view"

                );

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

                String layerName = workspace.getLabel() + " - " + store.getName();

                services.addLayerToActiveView(store, layerName);

            } else {

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                int res = dialogs.confirmDialog(i18n.getTranslation("_Do_you_want_add_table_to_project"),

                        i18n.getTranslation("_VCS_Checkout"),

                        JOptionPane.YES_NO_OPTION,

                        JOptionPane.QUESTION_MESSAGE,

                        "VCSGis_Checkout_add_table_to_project"

                );

                if (res == JOptionPane.YES_OPTION) {

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

                    services.addTableToProject(workspace, store);

                }

            }

        }

        doReloadChanges();

        VCSGisEntity selectedTable = getSelectedTable();

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

        refreshDocument(store);

    }

    private VCSGisEntity getSelectedTable() {

        LabeledValue<VCSGisEntity> lValue = (LabeledValue<VCSGisEntity>) lstRemoteTables.getSelectedValue();

        if(lValue == null){

            return null;

        }

        return lValue.getValue();

    }

    private Boolean isSelectedTableInWorkspace() {

        VCSGisEntity entity = getSelectedTable();

        if(entity == null){

            return null;

        }

        VCSGisWorkspace ws = getWorkspace();

        if(ws == null){

            return null;

        }

        return ws.getWorkspaceEntity(entity.getEntityCode())!=null;

    }

}