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;

import java.awt.Color;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.MouseMotionAdapter;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.TreeMap;

import java.util.function.Function;

import java.util.function.Predicate;

import javax.swing.AbstractCellEditor;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.JTree;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.event.ChangeListener;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import javax.swing.text.JTextComponent;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeCellRenderer;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.TreeCellEditor;

import javax.swing.tree.TreeModel;

import javax.swing.tree.TreePath;

import static javax.swing.tree.TreeSelectionModel.SINGLE_TREE_SELECTION;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.util.CompareUtils;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class OnlineEntitySelectorControllerJTree extends AbstractDisposable implements OnlineEntitySelectorController {

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

    private final JTextComponent txtFilter;

    private final JTree treeEntities;

    private Set<String> checkedEntityCodes;

    private Map<String/*entityCode*/,String/*Category*/>categoryOfCheckedEntity;

    private Map<String, OnlineEntity> entities;

    private final JButton btnEntities;

    private FilteredTreeController filteredTree;

    private ActionListenerSupport actionListeners;

    private ChangeListenerHelper changeListeners;

    private OnlineWorkingcopy workspace;

    private boolean processing;

    private boolean enabled;

    private Predicate<OnlineEntity> viewFilter;

    private Predicate<OnlineEntity> filter;

    private boolean checksEnabled;

    private JButton btnCheckAll;

    private JButton btnUnCheckAll;

    private Thread lastThread;

    private Function<OnlineEntity, String> labelEntityFormatter;

    private class EntityCellEditor extends AbstractCellEditor implements TreeCellEditor {

        private final JCheckBox check;

        private final JPanel panel;

        private final JLabel label;

        private Object currentUserObject;

        private TreePath currentRow;

        public EntityCellEditor() {

            this.check = new JCheckBox();

            this.label = new JLabel();

            this.panel = new JPanel();

            this.label.setOpaque(true);

            this.panel.setOpaque(false);

            this.check.setOpaque(false);

            this.panel.setLayout(new FlowLayout(FlowLayout.RIGHT, 2,1));

            this.panel.add(this.check);

            this.panel.add(this.label);

            this.currentUserObject = null;

            this.currentRow = null;

            this.check.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    if( currentUserObject==null ) {

                        // Se ha pulsado en una entidad que no tiene ninguna categoria asignada.

//                        if( check.isSelected() ) {

//                            checkedEntityCodes.addAll(getAllEntityCodesFromCategory(null));

//                        } else {

//                            checkedEntityCodes.removeAll(getAllEntityCodesFromCategory(null));

//                        }

                        postCheck();

                        return;

                    }

//                    if( !(currentUserObject instanceof LabeledValue) ) { 

//                        // Se ha pulsado en una Category

//                        String category = (String)currentUserObject;

//                        if( check.isSelected() ) {

//                            Set<String> x = getAllEntityCodesFromCategory(category);

//                            checkedEntityCodes.addAll(x);

//                            for (String entityCode : x) {

//                                categoryOfCheckedEntity.put(entityCode, category);

//                            }

//                        } else {

//                            Set<String> x = getAllEntityCodesFromCategory(category);

//                            checkedEntityCodes.removeAll(x);

//                            for (String entityCode : x) {

//                                categoryOfCheckedEntity.remove(entityCode);

//                            }

//                        }

//                        postCheck();

//                        return;

//                    }

                    OnlineEntity entity = ((LabeledValue<OnlineEntity>) currentUserObject).getValue();

                    if( entity == null ) {

                        return;

                    }

                    // Se ha pulsado en una entidad

                    String entityCode = entity.getEntityCode();

                    if( check.isSelected() ) {

                        checkedEntityCodes.add(entityCode);

                        categoryOfCheckedEntity.put(entityCode, getCategoryFromCurrentRow());

                    } else {

                        checkedEntityCodes.remove(entityCode);

                        categoryOfCheckedEntity.remove(entityCode);

                    }

                    postCheck();

                }

            });

        }

        private String getCategoryFromCurrentRow() {

            try {

                DefaultMutableTreeNode parent = (DefaultMutableTreeNode) currentRow.getParentPath().getLastPathComponent();

                if( parent == null ) {

                    return null;

                }

                return (String) parent.getUserObject();

            } catch(Exception ex) {

                return null;

            }

        }

        private void postCheck() {

            this.stopCellEditing();

            treeEntities.repaint();

            fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

        }

        @Override

        public Object getCellEditorValue() {

            return currentUserObject;

        }

        @Override

        public Component getTreeCellEditorComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row) {

//            LOGGER.info("Editor: selected=" +selected+", '"+Objects.toString(value)+"'+.");

            Color backgroundColor = UIManager.getColor(COLOR_TREE_TEXTBACKGROUND);

            Color foregroundColor = UIManager.getColor(COLOR_TREE_TEXTFOREGROUND);

            if( selected ) {

                backgroundColor = UIManager.getColor(COLOR_TREE_SELECTIONBACKGROUND);

                foregroundColor = UIManager.getColor(COLOR_TREE_SELECTIONFOREGROUND);

            }            

            this.label.setBackground(backgroundColor);

            this.label.setForeground(foregroundColor);

            I18nManager i18n = ToolsLocator.getI18nManager();

            if( checksEnabled ) {

                this.check.setVisible(true);

                this.check.setEnabled(false);

                this.check.setSelected(false);

                if(value instanceof DefaultMutableTreeNode){

                    currentUserObject = ((DefaultMutableTreeNode) value).getUserObject();

                    currentRow = tree.getPathForRow(row);

                    if( currentUserObject instanceof LabeledValue ) {

                        OnlineEntity entity = ((LabeledValue<OnlineEntity>) currentUserObject).getValue();

                        if( entity != null ) {

                            this.check.setEnabled(true);

                            this.check.setSelected(checkedEntityCodes.contains(entity.getEntityCode()));

                            this.label.setText(((LabeledValue<OnlineEntity>) currentUserObject).getLabel());

                        }

//                    } else if( currentUserObject instanceof String || currentUserObject == null) {

//                        this.check.setEnabled(true);

//                        this.check.setSelected(areSelectedAllEntitiesFromCategory((String)currentUserObject));

//                        if(StringUtils.isBlank((String)currentUserObject)){

//                            this.label.setText(i18n.getTranslation("_Others"));

//                        } else { 

//                            this.label.setText(i18n.getTranslation((String)currentUserObject)); 

//                        }

                    }

                }

            } else {

                this.check.setVisible(false);

            }

            return this.panel;

        }

    }

    private class EntityCellRenderer extends DefaultTreeCellRenderer {

        private final JCheckBox check;

        private final JPanel panel;

        private final JLabel label;

        public EntityCellRenderer() {

            this.check = new JCheckBox();

            this.label = new JLabel();

            this.panel = new JPanel();

            this.label.setOpaque(true);

            this.panel.setOpaque(false);

            this.check.setOpaque(false);

            this.panel.setLayout(new FlowLayout(FlowLayout.RIGHT, 2,1));

            this.panel.add(this.check);

            this.panel.add(this.label);

            this.setLeafIcon(null);

        }   

        @Override

        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {

            JLabel c = (JLabel) super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);

//            LOGGER.info("Renderer: selected=" +selected+", '"+Objects.toString(value)+"'+.");

            Color backgroundColor = UIManager.getColor(COLOR_TREE_TEXTBACKGROUND);

            Color foregroundColor = UIManager.getColor(COLOR_TREE_TEXTFOREGROUND);

            if( selected ) {

                backgroundColor = UIManager.getColor(COLOR_TREE_SELECTIONBACKGROUND);

                foregroundColor = UIManager.getColor(COLOR_TREE_SELECTIONFOREGROUND);

            }            

            this.label.setBackground(backgroundColor);

            this.label.setForeground(foregroundColor);

            this.label.setText(Objects.toString(value));

//            LOGGER.info("1. "+ this.label.getText() +" foreground="+label.getForeground(),toString());

//            this.label.setOpaque(selected);

            if( checksEnabled ) {

                this.check.setVisible(true);

                this.check.setForeground(foregroundColor);

                this.check.setBackground(backgroundColor);

                this.check.setEnabled(false);

                this.check.setSelected(false);

                if(value instanceof DefaultMutableTreeNode){

                    Object userObject = ((DefaultMutableTreeNode) value).getUserObject();

                    if( userObject instanceof LabeledValue ) {

                        OnlineEntity entity = ((LabeledValue<OnlineEntity>) userObject).getValue();

                        if( entity != null ) {

                            this.check.setEnabled(true);

                            this.check.setSelected(checkedEntityCodes.contains(entity.getEntityCode()));

                        }

                    } else if( userObject instanceof String  || userObject == null) {

                        this.check.setEnabled(true);

//                        this.check.setSelected(areSelectedAllEntitiesFromCategory((String)userObject));

                        if(StringUtils.isBlank((String)userObject)){

                            I18nManager i18n = ToolsLocator.getI18nManager();

                            this.label.setText(i18n.getTranslation("_Others"));

                        } else { 

                            this.label.setText((String)userObject); 

                        }

                    }

                }

            } else {

                this.check.setVisible(false);

                if (value instanceof DefaultMutableTreeNode) {

                    Object userObject = ((DefaultMutableTreeNode) value).getUserObject();

                    if (userObject instanceof String || userObject == null) {

                        if (StringUtils.isBlank((String) userObject)) {

                            I18nManager i18n = ToolsLocator.getI18nManager();

                            this.label.setText(i18n.getTranslation("_Others"));

                        } else {

                            this.label.setText((String) userObject);

                        }

                    }

                }

            }

            return this.panel;

        }

        protected JCheckBox getCheckBox() {

            return this.check;

        }

    }

    public OnlineEntitySelectorControllerJTree(JTree treeEntities) {

        this(treeEntities, null, null, null, null);

    }

    public OnlineEntitySelectorControllerJTree(JTree treeEntities, JTextComponent txtFilter, JButton btnTable, JButton btnCheckAll, JButton btnUnCheckAll) {

        viewFilter = ALL_ENTITIES;

        filter = ALL_ENTITIES;

        this.treeEntities = treeEntities;

        this.checkedEntityCodes = new HashSet<>();

        this.categoryOfCheckedEntity = new HashMap<>();

        this.entities = new HashMap<>();

        if (txtFilter == null) {

            this.txtFilter = new JTextField();

        } else {

            this.txtFilter = txtFilter;

        }

        if (btnTable == null) {

            this.btnEntities = new JButton();

        } else {

            this.btnEntities = btnTable;

        }

        if( btnCheckAll==null ) {

            this.btnCheckAll = new JButton();

        } else {

            this.btnCheckAll = btnCheckAll;

        }

        if( btnUnCheckAll==null ) {

            this.btnUnCheckAll = new JButton();

        } else {

            this.btnUnCheckAll = btnCheckAll;

        }

        this.processing = false;

        this.initComponents();

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        this.actionListeners = toolsSwingManager.createActionListenerSupport();

        this.changeListeners = toolsSwingManager.createChangeListenerHelper();

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

        this.treeEntities.getSelectionModel().setSelectionMode(SINGLE_TREE_SELECTION);

        this.treeEntities.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() {

            @Override

            public void valueChanged(TreeSelectionEvent e) {

                try {

                    DefaultMutableTreeNode parent = (DefaultMutableTreeNode) e.getPath().getParentPath().getLastPathComponent();

                    DefaultMutableTreeNode current = (DefaultMutableTreeNode) e.getPath().getLastPathComponent();

                    if( parent != null ) {

                        String category = (String) parent.getUserObject();

                        OnlineEntity entity = ((LabeledValue<OnlineEntity>)current.getUserObject()).getValue();

                        if( entity!=null ) {

                            categoryOfCheckedEntity.put(entity.getEntityCode(), category);

                        }

                    }

                } catch (Exception ex) {

                    LOGGER.debug("Can't set category for current entity",ex);

                }

                fireActionEvent(new ActionEvent(this, 0, ACTION_SELECT));

            }

        });

        this.treeEntities.setRootVisible(false);

        this.treeEntities.setShowsRootHandles(true);

        filteredTree = toolsSwingManager.createFilteredTreeController(treeEntities, txtFilter, btnEntities);

        filteredTree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode()));

        EntityCellRenderer cellRenderer = new EntityCellRenderer();

        this.treeEntities.setCellRenderer(cellRenderer);

        setChecksEnabled(true);

        this.btnCheckAll.addActionListener((ActionEvent e) -> { checkAll(); });

        this.btnUnCheckAll.addActionListener((ActionEvent e) -> { clearChecks(); });

        this.treeEntities.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseClicked(MouseEvent e) {

                TreePath path = treeEntities.getPathForLocation(e.getX(), e.getY());

                if( path!=null ) {

                    treeEntities.startEditingAtPath(path);

                }

            }

        });

        this.treeEntities.addMouseMotionListener(new MouseMotionAdapter() {

            @Override

            public void mouseMoved(MouseEvent e) {

                super.mouseMoved(e); 

                TreePath path = treeEntities.getPathForLocation(e.getX(), e.getY());

                doMouseMoved(path);

            }

        });

    }

    private void doMouseMoved(TreePath path) {

        if(path == null){

            return;

        }

        Object x = ((DefaultMutableTreeNode)path.getLastPathComponent()).getUserObject();

        if(!(x instanceof LabeledValue)){

            this.treeEntities.setToolTipText("");

            return;

        }

        LabeledValue lv = (LabeledValue)x;

        if (lv.getValue() instanceof OnlineEntity) {

            OnlineEntity entity = (OnlineEntity) lv.getValue();

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

            String s;

            //NO PODEMOS A?ADIR ENTIDADES NUEVAS

//            if (StringUtils.isBlank(entity.getRepositoryRevisionCode())) { //Es entidad local nueva

//                s = OnlineSwingCommons.getStateDescription(

//                        ((OnlineEntity) entity).getState()

//                );

//            } else {

                s = OnlineSwingCommons.getStateDescription(

                        lentity == null ? STATE_REMOTE_NEW : lentity.getState()

                );

//            }

            if( StringUtils.equalsIgnoreCase(entity.getEntityCode(), entity.getLabel()) ) {

                s = "<html>"+entity.getLabelOrName()+"<br>"+s+"</html>";

            } else {

                s = "<html>"+entity.getLabel()+"<br>"+entity.getEntityName()+"<br>"+s+"</html>";

            }

            this.treeEntities.setToolTipText(s);

        } else {

            this.treeEntities.setToolTipText("");

        }

    }

    @Override

    public boolean isProcessing() {

        return this.processing;

    }

    @Override

    public OnlineEntity getSelectedEntity() {

        if (this.workspace == null) {

            return null;

        }

        TreePath path = treeEntities.getSelectionPath();

        if (path == null) {

            return null;

        }

        DefaultMutableTreeNode lastComponent = (DefaultMutableTreeNode) path.getLastPathComponent();

        Object userObject = lastComponent.getUserObject();

        if(userObject == null || !(userObject instanceof LabeledValue)){

            return null;

        }

        LabeledValue selected = (LabeledValue) userObject;

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

        if (!this.filter.test(entity)) {

            return null;

        }

        return entity;

    }

    @Override

    public void setSelectedEntity(OnlineEntity entity) {

        if( this.workspace==null ) {

            return;

        }

        for (int i = 0; i < treeEntities.getRowCount(); i++) {

            TreePath path = treeEntities.getPathForRow(i);

            DefaultMutableTreeNode lc = (DefaultMutableTreeNode) path.getLastPathComponent();

            Object x = lc.getUserObject();

            if(x instanceof LabeledValue){

                OnlineEntity value = ((LabeledValue<OnlineEntity>)x).getValue();

                if(StringUtils.equals(entity.getEntityCode(), value.getEntityCode())){

                    treeEntities.setSelectionPath(path);

                    return;

                }

            }

        }

    }

    @Override

    public String getCategory(OnlineEntity entity) {

        String category = this.categoryOfCheckedEntity.get(entity.getEntityCode());

        if( StringUtils.isBlank(category) ) {

            category = entity.getFirstCategory();

        }

        return category;

    }

    @Override

    public List<OnlineEntity> getCheckedEntities() {

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

        for (String entityCode : this.checkedEntityCodes) {

            OnlineEntity entity = this.entities.get(entityCode);

            if(entity != null){

                checkedEntities.add(entity);

            }

        }

        Collections.sort(checkedEntities, new CompareUtils.NullSafeComparator<OnlineEntity>() {

            @Override

            public int safeCompare(OnlineEntity o1, OnlineEntity o2) {

                return StringUtils.compare(o1.getLabelOrName(), o2.getLabelOrName(), true);

            }

        });

        return checkedEntities;

    }

    @Override

    public void setWorkspace(OnlineWorkingcopy workspace) {

        this.checkedEntityCodes.clear();

        this.categoryOfCheckedEntity.clear();

        DisposeUtils.disposeQuietly(this.workspace);

        this.workspace = workspace;

        DisposeUtils.bind(this.workspace);

        reloadEntities();

    }

    @Override

    public OnlineWorkingcopy getWorkspace() {

        return this.workspace;

    }

    @Override

    public void reloadEntities() {

        this.entities.clear();

        if (workspace == null) {

            filteredTree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode()));

            return;

        }

        if (this.processing ) {

            LOGGER.info("Reentrada");

            return;

        }

        Thread task = new Thread(() -> {

            reloadEntities(this.workspace);

        }, "VCSGisEntitySelectorTreeReloadEntities");

        task.start();

        this.lastThread = task;

    }

    private boolean  isCancelled(){

        return Thread.currentThread() != this.lastThread;

    }

    private void reloadEntities(OnlineWorkingcopy workspace) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

            fireActionEvent(new ActionEvent(this, ACTION_BEGIN_PROCESSING_ID, ACTION_BEGIN_PROCESSING));

            SwingUtilities.invokeLater(() -> {

                treeEntities.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));

            });

            this.processing = true;

            this.doUpdateComponents();

//            workspace.updateEntitiesFromRepository();

//            List<OnlineEntity> allEntities = workspace.getRepositoryEntities();

            List<OnlineEntity> localEntities = workspace.getWorkspaceEntities();

//            for (OnlineEntity localEntity : localEntities) {

//                if(isCancelled()){

//                    return;

//                }

////                if (StringUtils.isBlank(localEntity.getRepositoryRevisionCode())) { //Es entidad local nueva

////                    allEntities.add(localEntity);

////                }

//            }

////            Collections.sort(allEntities, new CompareUtils.NullSafeComparator<OnlineEntity>() {

////                @Override

////                public int safeCompare(OnlineEntity o1, OnlineEntity o2) {

////                    return StringUtils.compare(o1.getLabelOrName(), o2.getLabelOrName(), true);

////                }

////            });

            Map<String, OnlineEntity> theEntities;

            Map<String, DefaultMutableTreeNode> theEntityNodes;

            theEntityNodes = new TreeMap<>((String o1, String o2) -> StringUtils.compare(o1, o2, false));

            theEntities = new HashMap<>();

//            for (OnlineEntity entity : allEntities) {

            for (OnlineEntity entity : localEntities) {

                if(isCancelled()){

                    return;

                }

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

                LabeledValue entry;

                String s;

//                if (StringUtils.isBlank(entity.getRepositoryRevisionCode())) { //Es entidad local nueva

//                    s = OnlineSwingCommons.getHTMLColorTag(

//                            ((OnlineEntity)entity).getState(),

//                            this.getLabelOfEntity(entity)

//                    );

//                } else {

                    s = OnlineSwingCommons.getHTMLColorTag(

                            lentity == null ? STATE_REMOTE_NEW : lentity.getState(),

                            this.getLabelOfEntity(entity)

                    );

//                }

                if(lentity != null && this.viewFilter.test(lentity)){

                        entity = lentity;

                } else {

                    if(!this.viewFilter.test(entity)){

                        entity = null;

                    }

                }

                if (entity!=null) {

                    theEntities.put(entity.getEntityCode(), entity);

                    entry = new LabeledValueImpl(s, entity);

//                    List<String> categories = entity.getCategoriesAsList();

//                    if( CollectionUtils.isNotEmpty(categories) ){

//                        for (String cat : categories) {

//                            String category = StringUtils.trimToNull(cat);

//                            addNodeEntity(theEntityNodes, category, entry);

//                        }

//                    } else {

//                        String category = StringUtils.trimToNull(entity.getCategory());

                        addNodeEntity(theEntityNodes, null, entry);

//                    }

                }

            }

            this.entities = theEntities;

            DefaultMutableTreeNode root = new DefaultMutableTreeNode();

            for (DefaultMutableTreeNode node : theEntityNodes.values()) {

                if(isCancelled()){

                    return;

                }

                root.add(node);

            }

            if(!isCancelled()){

                postReloadEntities(root);

            }

        } catch (Exception e) {

            LOGGER.warn("_Cant_retrieve_entities_from_repository", e);

            if(!isCancelled()){

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                dialogs.messageDialog(

                        i18n.getTranslation("_Cant_retrieve_entities_from_repository") + "\n" + e.getMessage(),

                        i18n.getTranslation("_VCS_Checkout"),

                        JOptionPane.WARNING_MESSAGE

                );

            }

        } finally {

            SwingUtilities.invokeLater(() -> {

                treeEntities.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));

            });

            if (!isCancelled()) {

                this.processing = false;

                this.doUpdateComponents();

                fireActionEvent(new ActionEvent(this, ACTION_END_PROCESSING_ID, ACTION_END_PROCESSING));

            }

        }

    }

    private String getLabelOfEntity(OnlineEntity entity) {

        if( entity == null ) {

            return null;

        }

        if( this.labelEntityFormatter==null ) {

            return workspace.formatEntityLabel(entity);

        }

        String s;

        try {

            s = this.labelEntityFormatter.apply(entity);

        } catch(Exception ex) {

            s = entity.getLabelOrName();

        }

        return s;

    }

    @Override

    public void setLabelEntityFormatter(Function<OnlineEntity,String> formatter) {

        this.labelEntityFormatter = formatter;

    }

    @Override

    public Collection<OnlineEntity> getEntities() {

        return this.entities.values();

    }

    private void addNodeEntity(Map<String, DefaultMutableTreeNode> theEntityNodes, String category, LabeledValue entry) {

        DefaultMutableTreeNode branch = theEntityNodes.get(category);

        if (branch == null) {

            branch = new DefaultMutableTreeNode(category, true);

            theEntityNodes.put(category, branch);

        }

        branch.add(new DefaultMutableTreeNode(entry, false));

    }

    private void postReloadEntities(DefaultMutableTreeNode entities) {

        if (notInSwingThreadInvokeLater(() -> {

            postReloadEntities(entities);

        })) {

            return;

        }

        filteredTree.setModel(new DefaultTreeModel(entities));

        this.expandAllNodes(treeEntities);

        this.processing = false;

        fireActionEvent(new ActionEvent(this, ACTION_RELOAD_ID, ACTION_RELOAD));

    }

    private void doUpdateComponents() {

        if (notInSwingThreadInvokeLater(this::doUpdateComponents)) {

            return;

        }

        this.txtFilter.setEnabled(enabled && !processing);

        this.btnEntities.setEnabled(enabled && !processing);

        this.treeEntities.setEnabled(enabled && !processing);

    }

    @Override

    public void setEnabled(boolean enabled) {

        this.enabled = enabled;

        this.treeEntities.setEditable(enabled);

        doUpdateComponents();

    }

    @Override

    public boolean isEnabled() {

        return enabled;

    }

    @Override

    public void setChecksEnabled(boolean enabled) {

        this.checksEnabled = enabled;

        if(enabled){

            this.treeEntities.setCellEditor(new EntityCellEditor());

        } else {

            this.treeEntities.setCellEditor(null);

        }

        this.treeEntities.setEditable(enabled);

    }

    @Override

    public boolean isChecksEnabled() {

        return this.checksEnabled;

    }

    @Override

    public void addActionListener(ActionListener al) {

        this.actionListeners.addActionListener(al);

    }

    @Override

    public ActionListener[] getActionListeners() {

        return this.actionListeners.getActionListeners();

    }

    @Override

    public void removeActionListener(ActionListener al) {

        this.actionListeners.removeActionListener(al);

    }

    @Override

    public void removeAllActionListener() {

        this.actionListeners.removeAllActionListener();

    }

    @Override

    public void fireActionEvent(ActionEvent ae) {

        this.actionListeners.fireActionEvent(ae);

    }

    @Override

    public boolean hasActionListeners() {

        return this.actionListeners.hasActionListeners();

    }

    @Override

    public void addChangeListener(ChangeListener cl) {

        this.changeListeners.addChangeListener(cl);

    }

    @Override

    public ChangeListener[] getChangeListeners() {

        return this.changeListeners.getChangeListeners();

    }

    @Override

    public void removeChangeListener(ChangeListener cl) {

        this.changeListeners.removeChangeListener(cl);

    }

    @Override

    public void removeAllChangeListener() {

        this.changeListeners.removeAllChangeListener();

    }

    @Override

    public boolean hasChangeListeners() {

        return this.changeListeners.hasChangeListeners();

    }

    @Override

    public void setViewFilter(Predicate<OnlineEntity> viewFilter) {

        this.viewFilter = viewFilter;

    }

    @Override

    public void setFilter(Predicate<OnlineEntity> filter) {

        this.filter = filter;

    }

    @Override

    public void check(OnlineEntity entity) {

        this.checkedEntityCodes.add(entity.getEntityCode());

//        this.categoryOfCheckedEntity.put(entity.getEntityCode(), entity.getFirstCategory());

        this.treeEntities.repaint();

        fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

    }

    public void setCheck(Collection<String> entityCodes, boolean check) {

        if( CollectionUtils.isEmpty(entityCodes) ) {

            return;

        }

        for (String entityCode : entityCodes) {

            if( check ) {

                this.checkedEntityCodes.add(entityCode);

//                OnlineEntity entity = this.entities.get(entityCode);

//                if( entity!=null ) {

//                    this.categoryOfCheckedEntity.put(entityCode, entity.getFirstCategory());

//                }

            } else {

                this.checkedEntityCodes.remove(entityCode);

            }

        }

        this.treeEntities.repaint();

        fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

    }

    @Override

    public void unCheck(OnlineEntity entity) {

        this.checkedEntityCodes.remove(entity.getEntityCode());

        this.treeEntities.repaint();

        fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

    }

    @Override

    public void checkAll() {

        for (Map.Entry<String, OnlineEntity> entry : entities.entrySet()) {

            this.checkedEntityCodes.add(entry.getValue().getEntityCode());

        }

        this.treeEntities.repaint();

        fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

    }

    @Override

    public void clearChecks() {

        this.checkedEntityCodes.clear();

        this.treeEntities.stopEditing();

        this.treeEntities.repaint();

        fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

    }

    private void expandAllNodes(JTree tree) {

        int j = tree.getRowCount();

        int i = 0;

        while(i < j) {

            tree.expandRow(i);

            i += 1;

            j = tree.getRowCount();

        }

    }

//    private boolean areSelectedAllEntitiesFromCategory(String category) {

//        

//        // Hay que tener cuiado con este metodo que durante el pintado del 

//        // arbol se llama bastantes mas veces de las que parece.

//        

//        for (Map.Entry<String, OnlineEntity> entry : this.entities.entrySet()) {

//            OnlineEntity entity = entry.getValue();

//            if(StringUtils.isBlank(category)){

//                if(StringUtils.isBlank(entity.getCategory())){

//                    if (!this.checkedEntityCodes.contains(entity.getEntityCode())) {

//                        return false;

//                    }

//                }

//            } else {

//                if (entity.getCategoriesAsList().contains(category)) {

//                    if (!this.checkedEntityCodes.contains(entity.getEntityCode())) {

//                        return false;

//                    }

//                }

//            }

//        }

//        return true;

//    }

//    private Set<String> getAllEntityCodesFromCategory(String category){

//        Set<String> entityCodes = new HashSet<>();

//        for (Map.Entry<String, OnlineEntity> entry : this.entities.entrySet()) {

//            OnlineEntity entity = entry.getValue();

//            if(StringUtils.isBlank(category)){

//                if(StringUtils.isBlank(entity.getCategory())){

//                    entityCodes.add(entity.getEntityCode());

//                }

//            } else {

//                if (entity.getCategoriesAsList().contains(category)) {

//                    entityCodes.add(entity.getEntityCode());

//                }

//            }

//        }

//        return entityCodes;

//    }

    @Override

    public void clear() {

        this.setWorkspace(null);

    }

    @Override

    protected void doDispose() throws BaseException {

        DisposeUtils.disposeQuietly(this.workspace);

    }

    public void collapseAll() {

      TreeModel model = this.treeEntities.getModel();

      Object root = model.getRoot();

      for (int i = 0; i < model.getChildCount(root); i++) {

        DefaultMutableTreeNode node = (DefaultMutableTreeNode) model.getChild(root, i);

        TreePath path = new TreePath(node.getPath());

        this.treeEntities.collapsePath(path);          

      }                

    }

    public void expandAll() {

        this.expandAllNodes(this.treeEntities);

    }

//          TreeModel model = this.treeEntities.getModel();

//      Object root = model.getRoot();

//        for (int i = 0; i < model.getChildCount(root); i++) {

//          DefaultTreeNode node = model.getChild(root, i);

//        }

}