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;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

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

import java.util.TreeMap;

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.event.ChangeListener;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeCellRenderer;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.TreeCellEditor;

import javax.swing.tree.TreePath;

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

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

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

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

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

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

import static org.gvsig.vcsgis.swing.impl.VCSGisEntitySelectorController.ACTION_CHECK;

import static org.gvsig.vcsgis.swing.impl.VCSGisEntitySelectorController.ACTION_CHECK_ID;

import static org.gvsig.vcsgis.swing.impl.VCSGisEntitySelectorController.ACTION_SELECT;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class VCSGisEntitySelectorControllerJTree

        implements

        VCSGisEntitySelectorController {

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

    private final JTextField txtFilter;

    private final JTree treeEntities;

    private Set<String> checkedEntityCodes;

    private Map<String, VCSGisEntity> entities;

    private final JButton btnEntities;

    private FilteredTreeController filteredTree;

    private ActionListenerSupport actionListeners;

    private ChangeListenerHelper changeListeners;

    private VCSGisWorkspace workspace;

    private boolean processing;

    private boolean enabled;

    private Predicate<VCSGisEntity> viewFilter;

    private Predicate<VCSGisEntity> filter;

    private boolean checksEnabled;

    private JButton btnCheckAll;

    private JButton btnUnCheckAll;

    private class EntityCellEditor extends AbstractCellEditor implements TreeCellEditor {

        private final JCheckBox check;

        private final JPanel panel;

        private final JLabel label;

        private Object currentUserObject;

        public EntityCellEditor() {

            this.check = new JCheckBox();

            this.label = new JLabel();

            this.panel = new JPanel();

            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.check.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    if( currentUserObject==null ) {

                        if( check.isSelected() ) {

                            checkedEntityCodes.addAll(getAllEntityCodesFromCategory(null));

                        } else {

                            checkedEntityCodes.removeAll(getAllEntityCodesFromCategory(null));

                        }

                            postCheck();

                        return;

                    }

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

                        String category = (String)currentUserObject;

                        if( check.isSelected() ) {

                            checkedEntityCodes.addAll(getAllEntityCodesFromCategory(category));

                        } else {

                            checkedEntityCodes.removeAll(getAllEntityCodesFromCategory(category));

                        }

                        postCheck();

                        return;

                    }

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

                    if( entity == null ) {

                        return;

                    }

                    if( check.isSelected() ) {

                        checkedEntityCodes.add(entity.getEntityCode());

                    } else {

                        checkedEntityCodes.remove(entity.getEntityCode());

                    }

                    postCheck();

                }

            });

        }

        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 isSelected, boolean expanded, boolean leaf, int row) {

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

                    if( currentUserObject instanceof LabeledValue ) {

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

                        if( entity != null ) {

                            this.check.setEnabled(true);

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

                            this.label.setText(((LabeledValue<VCSGisEntity>) 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.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, leaf, expanded, leaf, row, hasFocus);

            this.label.setText(c.getText());

            this.label.setForeground(c.getForeground());

            this.label.setBackground(c.getBackground());

            if( checksEnabled ) {

                this.check.setVisible(true);

                this.check.setForeground(c.getForeground());

                this.check.setBackground(c.getBackground());

                this.check.setEnabled(false);

                this.check.setSelected(false);

                if(value instanceof DefaultMutableTreeNode){

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

                    if( userObject instanceof LabeledValue ) {

                        VCSGisEntity entity = ((LabeledValue<VCSGisEntity>) 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);

            }

            return this.panel;

        }

        protected JCheckBox getCheckBox() {

            return this.check;

        }

    }

    public VCSGisEntitySelectorControllerJTree(JTree treeEntities) {

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

    }

    public VCSGisEntitySelectorControllerJTree(JTree treeEntities, JTextField txtFilter, JButton btnTable, JButton btnCheckAll, JButton btnUnCheckAll) {

        viewFilter = ALL_ENTITIES;

        filter = ALL_ENTITIES;

        this.treeEntities = treeEntities;

        this.checkedEntityCodes = new HashSet<>();

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

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

            }

        });

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

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

        EntityCellRenderer cellRenderer = new EntityCellRenderer();

        this.treeEntities.setCellRenderer(cellRenderer);

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

        this.treeEntities.setEditable(true);

        this.btnCheckAll.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                checkAll();

            }

        });

        this.btnUnCheckAll.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                clearChecks();

            }

        });

    }

    @Override

    public boolean isProcessing() {

        return this.processing;

    }

    @Override

    public VCSGisEntity getSelectedEntity() {

        if (this.workspace == null) {

            return null;

        }

        TreePath path = treeEntities.getSelectionPath();

        if (path == null) {

            return null;

        }

        LabeledValue selected = (LabeledValue) path.getLastPathComponent();

        if (selected == null) {

            return null;

        }

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

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

            return null;

        }

        return entity;

    }

    @Override

    public List<VCSGisEntity> getCheckedEntities() {

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

        for (String entityCode : this.checkedEntityCodes) {

            checkedEntities.add(this.entities.get(entityCode));

        }

        return checkedEntities;

    }

    @Override

    public void setWorkspace(VCSGisWorkspace workspace) {

        this.checkedEntityCodes.clear();

        this.entities.clear();

        if (workspace == null) {

            this.workspace = workspace;

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

            return;

        }

        if (this.processing && this.workspace == workspace) {

            LOGGER.info("Reentrada");

            return;

        }

        this.workspace = workspace;

        Thread task = new Thread(() -> {

            reloadEntities(this.workspace);

        }, "VCSGisEntitySelectorReloadEntities");

        task.start();

    }

    @Override

    public VCSGisWorkspace getWorkspace() {

        return this.workspace;

    }

    private void reloadEntities(VCSGisWorkspace workspace) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

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

            this.processing = true;

            this.doUpdateComponents();

            workspace.reloadRepositoryEntities(null);

            List<VCSGisEntity> allEntities = workspace.getRepositoryEntities();

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

            for (VCSGisWorkspaceEntity localEntity : localEntities) {

                if (StringUtils.isBlank(localEntity.getRepositoryRevisionCode())) {

                    allEntities.add(localEntity);

                }

            }

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

                @Override

                public int safeCompare(VCSGisEntity o1, VCSGisEntity o2) {

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

                }

            });

            Map<String, VCSGisEntity> theEntities;

            Map<String, DefaultMutableTreeNode> theEntityNodes;

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

            theEntities = new HashMap<>();

            for (VCSGisEntity entity : allEntities) {

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

                LabeledValue entry;

                String s;

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

                    s = VCSGisSwingCommons.getHTMLColorTag(

                            ((VCSGisWorkspaceEntity)entity).getState(),

                            entity.getEntityName()

                    );

                } else {

                    s = VCSGisSwingCommons.getHTMLColorTag(

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

                            entity.getEntityName()

                    );

                }

                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(categories.size()>0){

                        for (String cat : categories) {

                            String category = StringUtils.trimToNull(cat);

                            addNodeEntity(theEntityNodes, category, entry);

                        }

                    } else {

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

                        addNodeEntity(theEntityNodes, category, entry);

                    }

                }

            }

            this.entities = theEntities;

            DefaultMutableTreeNode root = new DefaultMutableTreeNode();

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

                root.add(node);

            }

            postReloadEntities(root);

        } catch (Exception e) {

            LOGGER.warn("_Cant_retrieve_entities_from_repository", e);

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(

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

                    i18n.getTranslation("_Checkout"),

                    JOptionPane.WARNING_MESSAGE

            );

        } finally {

            this.processing = false;

            this.doUpdateComponents();

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

        }

    }

    @Override

    public Collection<VCSGisEntity> 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;

        doUpdateComponents();

    }

    @Override

    public boolean isEnabled() {

        return enabled;

    }

    @Override

    public void setChecksEnabled(boolean enabled) {

        this.checksEnabled = 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<VCSGisEntity> viewFilter) {

        this.viewFilter = viewFilter;

    }

    @Override

    public void setFilter(Predicate<VCSGisEntity> filter) {

        this.filter = filter;

    }

    @Override

    public void check(VCSGisEntity entity) {

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

        this.treeEntities.repaint();

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

    }

    @Override

    public void checkAll() {

        for (Map.Entry<String, VCSGisEntity> 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.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) {

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

            VCSGisEntity 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, VCSGisEntity> entry : this.entities.entrySet()) {

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

    }

}