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

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

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

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

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.feature.exception.ConcurrentDataModificationException;

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.json.Json;

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

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

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

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

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

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

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

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

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

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

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

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 static org.gvsig.online.swing.impl.changes.OnlineJChangesImpl.LOCAL_TAB_INDEX;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.tools.dynform.DynFormLocator;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynobject.DynObject;

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

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

 */

@SuppressWarnings("UseSpecificCatch")

public class RemoteChangesController extends AbstractDisposable {

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

    private static final int MAX_SELECTED_ROWS_TO_SHOW_GEOMETRIES = 200;

    private final PickerController<OnlineWorkingcopy> 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 OnlineChanges<OnlineRemoteChange> changes;

    private final JButton btnRemoteCleanChanges;

    private final OnlineJChangesImpl context;

    private final JButton btnRemoteZoom;

    private final JButton btnRemoteCenter;

    private final JButton btnRemoteHighlight;

    private final JButton btnRemoteCleanHighligthed;

    private final JLabel lblRemoteChangesCount;

    public RemoteChangesController(

            OnlineJChangesImpl context,

            PickerController<OnlineWorkingcopy> workspacePicker,

            JTable tblRemoteChanges,

            JButton btnRemoteCheckAll,

            JButton btnRemoteUnCheckAll,

            JButton btnRemoteReloadChanges,

            JButton btnRemoteCleanChanges,

            JButton btnRemoteUpdate,

            JButton btnRemoteMerge,

            JButton btnRemoteShowForm,

            JButton btnRemoteZoom,

            JButton btnRemoteCenter,

            JButton btnRemoteHighlight,

            JButton btnRemoteCleanHighligthed,

            JLabel lblRemoteChangesCount

    ) {

        this.context = context;

        this.workspacePicker = workspacePicker;

        this.tblRemoteChanges = tblRemoteChanges;

        this.btnRemoteCheckAll = btnRemoteCheckAll;

        this.btnRemoteUnCheckAll = btnRemoteUnCheckAll;

        this.btnRemoteCleanChanges = btnRemoteCleanChanges;

        this.btnRemoteReloadChanges = btnRemoteReloadChanges;

        this.btnRemoteUpdate = btnRemoteUpdate;

        this.btnRemoteMerge = btnRemoteMerge;

        this.btnRemoteShowForm = btnRemoteShowForm;

        this.btnRemoteZoom = btnRemoteZoom;

        this.btnRemoteCenter = btnRemoteCenter;

        this.btnRemoteHighlight = btnRemoteHighlight;

        this.btnRemoteCleanHighligthed = btnRemoteCleanHighligthed;

        this.lblRemoteChangesCount= lblRemoteChangesCount;

        initComponents();

    }

    public void alert(final String msg) {

        this.context.alert(msg);

    }

    public void message(final String msg) {

        this.context.message(msg);

    }

    private void initComponents() {

        I18nManager i18n = ToolsLocator.getI18nManager();

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

        this.btnRemoteCleanChanges.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.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.btnRemoteHighlight.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

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

        translate();

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

            doUpdateChangesCount();

        });

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

            doCheckAll();

        });

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

            doUnCheckAll();

        });

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

            doReloadChanges();

        });

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

            doCleanChanges();

        });

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

            doHighLightSelectedChange();

        });

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

            cleanHighligthed();

        });

        context.doUpdateComponents();

        SwingUtilities.invokeLater(() -> {

            doReloadChanges();

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

            this.lblRemoteChangesCount.setText("");

        });

    }

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

        swingManager.translate(this.btnRemoteHighlight);

        swingManager.translate(this.btnRemoteZoom);

        swingManager.translate(this.btnRemoteCleanHighligthed);

    }

    private OnlineWorkingcopy getUndisposableWorkspace() {

        OnlineWorkingcopy ws = this.context.getWorkspace();

        DisposeUtils.disposeQuietly(ws);

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

        return ws;

    }

    /* friend */ void doUpdateComponents() {

        if (notInSwingThreadInvokeLater(() -> {

            doUpdateComponents();

        })) {

            return;

        }

        OnlineWorkingcopy ws;

        for (int i = 0; i < 10; i++) {

            try {

                RemoteChangesTableModel tableModel = (RemoteChangesTableModel) this.tblRemoteChanges.getModel();

                this.context.setVisibleStatus(context.processing);

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

                ws = this.getUndisposableWorkspace();

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

                this.btnRemoteCheckAll.setEnabled(!context.processing && !tableModel.isEmpty());

                this.btnRemoteUnCheckAll.setEnabled(!context.processing && !tableModel.isEmpty());

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

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

                //Show form

                boolean enableShowForm = false;

                int row = this.tblRemoteChanges.getSelectedRow();

                if (row >= 0) {

                    enableShowForm = true;

                }

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

                context.getEntitySelector().setEnabled(!context.processing);

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

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

                if (CollectionUtils.isEmpty(checkedEntities)) {

                    this.btnRemoteMerge.setEnabled(false);

                    this.btnRemoteUpdate.setEnabled(false);

                } else {

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

                    for (OnlineEntity checkedEntity : checkedEntities) {

                        if (!ws.canUpdate(msg, checkedEntity.getEntityName())) {

                            break;

                        }

                    }

                    if (msg.getValue() != null) {

                        this.btnRemoteMerge.setEnabled(false);

                        this.btnRemoteUpdate.setEnabled(false);

                        this.alert(msg.getValue());

                    } else {

                        if (checkedEntities.size() == 1) {

                            OnlineEntity checkedEntity = checkedEntities.get(0);

                            if (ws.updateNeedMerge(checkedEntity.getEntityName())) {

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

                                this.btnRemoteUpdate.setEnabled(false);

                            } else {

                                this.btnRemoteMerge.setEnabled(false);

                                this.btnRemoteUpdate.setEnabled(!context.processing && !tableModel.isSelectionEmpty());

                            }

                        } else {

                            this.btnRemoteMerge.setEnabled(false);

                            this.btnRemoteUpdate.setEnabled(!context.processing && !tableModel.isSelectionEmpty());

                            for (OnlineEntity checkedEntity : checkedEntities) {

                                if (ws.updateNeedMerge(checkedEntity.getEntityName())) {

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

                                    this.btnRemoteUpdate.setEnabled(false);

                                    break;

                                }

                            }

                        }

                    }

                }

                Geometry repoGeom = getRepositoryGeometryOfSelectedChange();

                Geometry wsGeom = getWorkspaceGeometryOfSelectedChange();

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

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

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

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

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

            } catch (ConcurrentDataModificationException e3) {

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException ex) {

                    //Do nothing

                }

                LOGGER.info("Retrying doUpdateComponents "+i);

                continue;

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

            }

            break;

        }

    }

    private void doToggleSelection() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                ListSelectionModel selectionModel = this.tblRemoteChanges.getSelectionModel();

                RemoteChangesTableModel model = (RemoteChangesTableModel) this.tblRemoteChanges.getModel();

                model.toggleSelection(selectionModel);

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "OnlineToggleSelectionRemoteChanges");

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

                RemoteChangesTableModel model = (RemoteChangesTableModel) this.tblRemoteChanges.getModel();

                model.selectAll();

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "OnlineCheckAllRemoteChanges");

        task.start();

    }

    private void doUnCheckAll() {

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                RemoteChangesTableModel model = (RemoteChangesTableModel) this.tblRemoteChanges.getModel();

                model.deselectAll();

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "OnlineCheckAllRemoteChanges");

        task.start();

    }

    private void doUpdate() {

        OnlineWorkingcopy ws = getUndisposableWorkspace();

        if (ws == null) {

            return;

        }

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

        if ( CollectionUtils.isEmpty(checkedEntities) ) {

            return;

        }

        this.tblRemoteChanges.setModel(createEmptyTableModel());

        SimpleTaskStatus taskStatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("_Download_changes");

        Thread task = new Thread(() -> {

            try {

                taskStatus.setAutoremove(true);

                taskStatus.add();

                context.setTaskStatus(taskStatus);

                context.processing = true;

                context.doUpdateComponents();

                int r = ERR_OK;

                for (OnlineEntity checkedEntity : checkedEntities) {

                    r = ws.update(checkedEntity.getEntityName(), taskStatus);

                    if( r!=ERR_OK ) {

                        break;

                    }

                }

                doPostUpdate(checkedEntities, r);

                taskStatus.terminate();

            } catch(UserCancelTaskException ex) {

                LOGGER.warn("User cancelled");

                taskStatus.cancel();

            } catch(Exception ex) {

                taskStatus.abort();

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "OnlineUpdate");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

    private void doPostUpdate(List<OnlineEntity> checkedEntities, int updateStatus) {

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

            return;

        }

        if (updateStatus == ERR_OK) {

            context.setVisibleStatus(false);

        }

        OnlineWorkingcopy ws = getUndisposableWorkspace();

        doReloadChanges();

        for (OnlineEntity checkedEntity : checkedEntities) {

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

            refreshDocument(store);

        }

        context.doUpdateComponents();

        context.updateLocalChangesTable();

        cleanHighligthed();        

    }

    private void doMerge() {

        OnlineWorkingcopy ws = getUndisposableWorkspace();

        if (ws == null) {

            return;

        }

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

        if ( CollectionUtils.isEmpty(checkedEntities) ) {

            return;

        }

//        if( checkedEntities.size()!=1 ) {

//            ThreadSafeDialogsManager dialogsManager = ToolsSwingLocator.getThreadSafeDialogsManager();

//            I18nManager i18n = ToolsLocator.getI18nManager();

//            dialogsManager.messageDialog(

//                    i18n.getTranslation("_Cant_merge_with_more_a_table_selected"), 

//                    null, 

//                    i18n.getTranslation("_Online_Merge"), 

//                    JOptionPane.WARNING_MESSAGE

//            );

//            return;

//        }

//        OnlineEntity entity = checkedEntities.get(0);

//        String tableName = entity.getEntityName();

        this.tblRemoteChanges.setModel(createEmptyTableModel());

        Thread task = new Thread(() -> {

            try {

                context.processing = true;

                context.doUpdateComponents();

                MutableLong localChangesCreated = new MutableLong(0);

                List<OnlineEntity> entitiesWithLocalChanges = new ArrayList<>();

                int r = ERR_OK;

                for (OnlineEntity entity : checkedEntities) {

                    String tableName = entity.getEntityName();

                    long lchanges = localChangesCreated.getValue();

                    r = getUndisposableWorkspace().merge(

                            tableName,

                            localChangesCreated,

                            this.context.getTaskStatusController().getSimpleTaskStatus()

                    );

                    if( r!=ERR_OK ) {

                        break;

                    }

                    if( lchanges!=localChangesCreated.getValue() ) {

                        entitiesWithLocalChanges.add(entity);

                    }

                }

                doPostMerge(checkedEntities, entitiesWithLocalChanges, r, localChangesCreated.getValue());

            } catch(UserCancelTaskException ex) {

                LOGGER.warn("User cancelled");

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "OnlineMerge");

        context.processing = true;

        context.doUpdateComponents();

        task.start();

    }

    private void doPostMerge(List<OnlineEntity> checkedEntities, List<OnlineEntity> entitiesWithLocalChanges, int mergeStatus, long localChangesCreated) {

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

            return;

        }

        if (mergeStatus == ERR_OK) {

            this.context.setVisibleStatus(false);

        }

        doReloadChanges();

        OnlineWorkingcopy ws = getUndisposableWorkspace();

        for (OnlineEntity entity : checkedEntities) {

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

            refreshDocument(store);

        }

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

//        refreshDocument(store);

        if(localChangesCreated>0){

            ThreadSafeDialogsManager dialogsManager = ToolsSwingLocator.getThreadSafeDialogsManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            dialogsManager.messageDialog(

                    i18n.getTranslation("_The_process_has_modified_local_changes_that_would_need_to_be_committed_to_the_repository"), 

                    null, 

                    i18n.getTranslation("_Online_Merge"), 

                    JOptionPane.INFORMATION_MESSAGE, 

                    "Online_merge_need_commit");

            context.selectTab(LOCAL_TAB_INDEX);

            context.selectOnlyALocalEntity(entitiesWithLocalChanges);

        }

        context.doUpdateComponents();

        context.updateLocalChangesTable();

        cleanHighligthed();

    }

    private void doShowForm() {

        RemoteChangesTableModel model = (RemoteChangesTableModel)this.tblRemoteChanges.getModel();

        int row = this.tblRemoteChanges.getSelectedRow();

        OnlineRemoteChange change = model.getRow(row);

        if(change == null) {

            return;

        }

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

            return;

        }

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws == null) {

            return;

        }

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

        if (entity == null) {

            OnlineEntity 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.openFeatureStore(entity.getEntityName(),false);

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

        }

    }

    protected void doReloadChanges() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws == null) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        RemoteChangesTableModel changesModel = createTableModel();

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

                    OnlineRemoteChange changeRow = null;

                    try {

                        changeRow = changesModel.getRow(row);

                    } catch (IndexOutOfBoundsException ex) {

                        //Do nothing

                    }

                    if(changeRow != null){

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

                    }

                    return c;

                }

            });

        }

        context.doUpdateComponents();

        doUpdateChangesCount();

        context.message(i18n.getTranslation(

                "_Repository_changes_list_updated", 

                new String[] { String.valueOf(changesModel.getRowCount()) }

            )

        );

    }

    private void doUpdateChangesCount() {

        TableModel model = tblRemoteChanges.getModel();

        int selectedCounts = tblRemoteChanges.getSelectedRowCount();

        if(selectedCounts<1){

            this.lblRemoteChangesCount.setText(String.valueOf(model.getRowCount()));

        } else if (selectedCounts < MAX_SELECTED_ROWS_TO_SHOW_GEOMETRIES) {

            this.lblRemoteChangesCount.setText("<html>"+getHTMLFontColorTag(java.awt.Color.GREEN.darker(),true, false, String.valueOf(selectedCounts))+"/"+model.getRowCount()+"</html>");

        } else {

            this.lblRemoteChangesCount.setText(selectedCounts+"/"+model.getRowCount());

        }

    }

    protected RemoteChangesTableModel createEmptyTableModel() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws == null) {

            return null;

        }

        RemoteChangesTableModel changesModel = new RemoteChangesTableModel(ws);

        return changesModel;

    }

    protected RemoteChangesTableModel createTableModel() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws == null) {

            return null;

        }

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

        if ( CollectionUtils.isEmpty(checkedEntities) ) {

            return new RemoteChangesTableModel(ws);

        }

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

        OnlineChanges<OnlineRemoteChange> theChanges = ws.getRemoteChangesByEntity(

            checkedEntities.stream()

                .map((t) -> {return t.getEntityName();})

                .toArray((n) -> { return new String[n];})

        );

        RemoteChangesTableModel changesModel = new RemoteChangesTableModel(theChanges, ws);

        changesModel.addTableModelListener(new TableModelListener() {

            @Override

            public void tableChanged(TableModelEvent e) {

                context.doUpdateComponents();

            }

        });

        return changesModel;

    }

    private List<OnlineEntity>  getWorkspaceCheckedEntities() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws == null) {

            return null;

        }

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

        if ( CollectionUtils.isEmpty(checkedEntities) ) {

            return null;

        }

        List<OnlineEntity> workspaceCheckedEntities = new ArrayList<>();

        for (OnlineEntity entity : checkedEntities) {

            if( ws.getWorkspaceEntityByCode(entity.getEntityCode())!=null ) {

                workspaceCheckedEntities.add(entity);

            }

        }

        if ( CollectionUtils.isEmpty(workspaceCheckedEntities) ) {

            return null;

        }

        return workspaceCheckedEntities;

    }

//    private List<OnlineEntity>  getRepositoryCheckedEntities() {

//        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

//        if (ws == null) {

//            return null;

//        }

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

//        if ( CollectionUtils.isEmpty(checkedEntities) ) {

//            return null;

//        }

//        List<OnlineEntity> workspaceCheckedEntities = new ArrayList<>();

//        for (OnlineEntity entity : checkedEntities) {

//            if( ws.getWorkspaceEntityByCode(entity.getEntityCode())==null ) {

//                workspaceCheckedEntities.add(entity);

//            }

//        }

//        if ( CollectionUtils.isEmpty(workspaceCheckedEntities) ) {

//            return null;

//        }

//        return workspaceCheckedEntities;

//    }

    private void doCleanChanges() {

        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

        if (ws == null) {

            return;

        }

        List<OnlineEntity> entitiesToCleanChanges = this.getWorkspaceCheckedEntities();

        if ( CollectionUtils.isEmpty(entitiesToCleanChanges) ) {

            return;

        }

        Thread task = new Thread(() -> {

            try {

                RemoteChangesTableModel model = (RemoteChangesTableModel) tblRemoteChanges.getModel();

                context.processing = true;

                context.doUpdateComponents();

                for (OnlineEntity checkedEntity : entitiesToCleanChanges) {

                    message("Removing list of remote changes from selected tables" + checkedEntity.getEntityName() + "...");

//                    ws.removeRemoteChanges(checkedEntity.getEntityName());

                    model.removeRemoteChanges(checkedEntity.getEntityName());

                }

//                doReloadChanges();

                context.doReloadTables();

                message("Ready.");

            } finally {

                context.processing = false;

                context.doUpdateComponents();

            }

        }, "OnlineUpdateClean");

        task.start();

    }

//    private void doReloadTables() {

//        OnlineWorkingcopy ws = this.getUndisposableWorkspace();

//        if (ws == null) {

//            this.entitySelector.setWorkspace(null);

//            return;

//        }

//        this.entitySelector.reloadEntities();

////        context.doUpdateComponents();

//    }

    public boolean isProcessing() {

        return context.processing;

    }

    private Geometry getRepositoryGeometryOfSelectedChange() {

        Geometry geom = null;

        try {

            RemoteChangesTableModel model = (RemoteChangesTableModel) tblRemoteChanges.getModel();

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

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

                    OnlineRemoteChange change = model.getRow(selectedRow);

                    Geometry currentGeom = change.getGeometry();

                    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.tblRemoteChanges.getSelectedRow();

                if(selected >= 0){

                    OnlineRemoteChange change = model.getRow(selected);

                    geom = change.getGeometry();

                }

            }

            return geom;

        } catch (Exception ex) {

            return geom;

        }

    }

    private Envelope getEnvelopeOfAllRepositoryChanges() {

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

        try {

            RemoteChangesTableModel model = (RemoteChangesTableModel) tblRemoteChanges.getModel();

            OnlineChanges<OnlineRemoteChange> changes = model.getChanges();

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

                OnlineRemoteChange change = changes.get64(i);

                Geometry currentGeom = change.getGeometry();

                env.add(currentGeom);

            }

            return env;

        } catch (Exception ex) {

            return env;

        }

    }

    private Geometry getWorkspaceGeometryOfSelectedChange() {

        Geometry geom = null;

        try {

            OnlineWorkingcopy ws = getUndisposableWorkspace();

            RemoteChangesTableModel model = (RemoteChangesTableModel) tblRemoteChanges.getModel();

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

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

                    OnlineRemoteChange change = model.getRow(selectedRow);

                    Feature f = ws.getRelatedFeature(change);

                    if(f!= null){

                        Geometry currentGeom = f.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.tblRemoteChanges.getSelectedRow();

                if(selected >= 0){

                    OnlineRemoteChange change = model.getRow(selected);

                    Feature f = ws.getRelatedFeature(change);

                    if(f!= null){

                        geom = f.getDefaultGeometry();

                    }

                }

            }

            return geom;

        } catch (Exception ex) {

            return geom;

        }

    }

    private FeatureStore getWorkspaceStoreOfSelectedChange() {

        FeatureStore store = null;

        int selected = this.tblRemoteChanges.getSelectedRow();

        RemoteChangesTableModel model = (RemoteChangesTableModel) tblRemoteChanges.getModel();

        if(selected >= 0){

            OnlineRemoteChange change = model.getRow(selected);

            OnlineWorkingcopy ws = getUndisposableWorkspace();

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

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

        }

        return store;

    }

    private void doZoomToSelectedChange() {

        cleanHighligthed();

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        OnlineSwingServices services = swingManager.getDefaultServices();

        if(tblRemoteChanges.getSelectionModel().isSelectionEmpty()) {

            FeatureStore store = this.context.getWorkspaceStoreOfSelectedEntity();

            if(store == null){

                return;

            }

            Envelope env = getEnvelopeOfAllRepositoryChanges();

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

            return;

        }

        FeatureStore store = getWorkspaceStoreOfSelectedChange();

        Geometry repoGeom = getRepositoryGeometryOfSelectedChange();

        Geometry geom = getWorkspaceGeometryOfSelectedChange();

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

        if(repoGeom != null){

            services.highlight(HIGHLIGHT_REMOTE, repoGeom, store);

        }

        if(geom != null){

            services.highlight(HIGHLIGHT_WORKSPACE, geom, store);

        }

    }

    private void doCenterToSelectedChange() {

        cleanHighligthed();

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        OnlineSwingServices services = swingManager.getDefaultServices();

        if(tblRemoteChanges.getSelectionModel().isSelectionEmpty()) {

            FeatureStore store = this.context.getWorkspaceStoreOfSelectedEntity();

            if(store == null){

                return;

            }

            Envelope env = getEnvelopeOfAllRepositoryChanges();

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

            return;

        }

        FeatureStore store = getWorkspaceStoreOfSelectedChange();

        Geometry repoGeom = getRepositoryGeometryOfSelectedChange();

        Geometry geom = getWorkspaceGeometryOfSelectedChange();

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

        if(repoGeom != null){

            services.highlight(HIGHLIGHT_REMOTE, repoGeom, store);

        }

        if(geom != null){

            services.highlight(HIGHLIGHT_WORKSPACE, geom, store);

        }

    }

    private void doHighLightSelectedChange() {

        cleanHighligthed();

        OnlineSwingManager swingManager = OnlineSwingLocator.getOnlineSwingManager();

        OnlineSwingServices services = swingManager.getDefaultServices();

        FeatureStore store = getWorkspaceStoreOfSelectedChange();

        Geometry repoGeom = getRepositoryGeometryOfSelectedChange();

        Geometry geom = getWorkspaceGeometryOfSelectedChange();

        if(repoGeom != null){

            services.highlight(HIGHLIGHT_REMOTE, repoGeom, store);

        }

        if(geom != null){

            services.highlight(HIGHLIGHT_WORKSPACE, geom, store);

        }

    }

    @Override

    protected void doDispose() throws BaseException {

        //TODO: Dispose what is needed

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//        DisposeUtils.disposeQuietly(entitySelector);

    }

}