Application: gvSIG desktop

package org.gvsig.fmap.dal.swing.impl.searchpanel;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.function.Predicate;

import javax.swing.event.TreeModelListener;

import javax.swing.tree.TreeModel;

import javax.swing.tree.TreePath;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.complements.Search;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.ForeingKey;

import org.gvsig.fmap.dal.feature.ForeingKey.ContextForeingKey;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class AdvancedAttributeSelectionTreeModel

        implements TreeModel {

    public interface Node extends LabeledValue<FeatureAttributeDescriptor> {

        public FeatureStore getFeatureStore();

        public boolean isRoot();

        public boolean isLeaf();

        public List<Node> getChildren();

    }

    private class DefaultNode

            extends LabeledValueImpl<FeatureAttributeDescriptor>

            implements Node {

        private List<Node> childs;

        private final FeatureStore store;

        public DefaultNode(FeatureStore store, List<FeatureAttributeDescriptor> attributes) {

            super(store==null? "":store.getName(), null);

            this.store = store;

            this.childs = new ArrayList<>();

            for (FeatureAttributeDescriptor attribute : attributes) {

                this.childs.add(new DefaultNode(store, attribute));

            }

        }

        private DefaultNode(FeatureStore store, FeatureAttributeDescriptor attribute) {

            super(attribute.getLabel(), attribute);

            this.store = store;

            this.childs = null;

        }

        @Override

        public String getLabel() {

            FeatureAttributeDescriptor attrdesc = this.getValue();

            if( attrdesc!=null && attrdesc.isForeingKey() ) {

                ForeingKey foreingKey = attrdesc.getForeingKey();

                return String.format("%s [%s]", super.getLabel(), foreingKey.getTableName());

            }

            return super.getLabel();

        }

        @Override

        public FeatureStore getFeatureStore() {

            return this.store;

        }

        @Override

        public boolean isRoot() {

            return this.getValue() == null;

        }

        @Override

        public List<Node> getChildren() {

            if (this.childs == null) {

                if (this.getValue().isForeingKey()) {

                    ForeingKey foreingKey = this.getValue().getForeingKey();

                    ContextForeingKey context = foreingKey.createContext();

                    // Ojo, no liberamos el contexto para que no se destruya el store.

                    FeatureStore theStore = foreingKey.getFeatureStore(context);

                    FeatureType featureType = foreingKey.getFeatureType(context);

                    String fullName = theStore.getFullName();

                    if (stores.contains(fullName)) {

                        // Si ya hemos a?adido el store al arbol no lo volvemos a a?adir.

                        this.childs = Collections.EMPTY_LIST;

                    } else {

                        Search featureTypeSearch = (Search) ToolsLocator.getComplementsManager().get(

                                Search.COMPLEMENT_MANE, featureType

                        );

                        List<FeatureAttributeDescriptor> attributes = featureTypeSearch.getOrderedAttributes(

                                filterByDataType,

                                Search.LABEL_ORDER,

                                -1

                        );

                        this.childs = new ArrayList<>();

                        for (FeatureAttributeDescriptor attribute : attributes) {

                            this.childs.add(new DefaultNode(theStore, attribute));

                        }

                    }

                } else {

                    this.childs = Collections.EMPTY_LIST;

                }

            }

            return this.childs;

        }

        @Override

        public boolean isLeaf() {

            return this.getChildren().isEmpty();

        }

    }

    private final Set<String> stores;

    private final DefaultNode root;

    private final Predicate<FeatureAttributeDescriptor> filterByDataType;

    public AdvancedAttributeSelectionTreeModel(FeatureStore store, Predicate<FeatureAttributeDescriptor> filterByDataType) {

        if( filterByDataType == null ) {

            this.filterByDataType = Search.ALL_FILTER;

        } else {

            this.filterByDataType = filterByDataType;

        }

        FeatureType featureType;

        try {

            featureType = store.getDefaultFeatureType();

        } catch (Exception ex) {

            throw new RuntimeException("Can't access attributes of store", ex);

        }

        Search featureTypeSearch = (Search) ToolsLocator.getComplementsManager().get(

                Search.COMPLEMENT_MANE, featureType

        );

        List<FeatureAttributeDescriptor> attributes = featureTypeSearch.getOrderedAttributes(

                filterByDataType,

                Search.LABEL_ORDER,

                -1

        );

        this.root = new DefaultNode(store, attributes);

        this.stores = new HashSet<>();

    }

    @Override

    public Object getRoot() {

        return this.root;

    }

    @Override

    public int getChildCount(Object parent) {

        DefaultNode node = (DefaultNode) parent;

        return node.getChildren().size();

    }

    @Override

    public Object getChild(Object parent, int index) {

        DefaultNode node = (DefaultNode) parent;

        return node.getChildren().get(index);

    }

    @Override

    public boolean isLeaf(Object node) {

        return ((DefaultNode) node).isLeaf();

    }

    @Override

    public int getIndexOfChild(Object parent, Object child) {

        try {

            DefaultNode parantNode = (DefaultNode) parent;

            DefaultNode childNode = (DefaultNode) child;

            int index = 0;

            for (Node node : parantNode.getChildren()) {

                if (StringUtils.equalsIgnoreCase(childNode.getValue().getName(), node.getValue().getName())) {

                    return index;

                }

                index++;

            }

        } catch (Exception ex) {

        }

        return 0;

    }

    @Override

    public void valueForPathChanged(TreePath path, Object newValue) {

    }

    @Override

    public void addTreeModelListener(TreeModelListener l) {

    }

    @Override

    public void removeTreeModelListener(TreeModelListener l) {

    }

}