Application: gvSIG desktop

package org.gvsig.app.extension.copytable;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.MouseEvent;

import java.awt.event.MouseMotionAdapter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.Objects;

import javax.swing.JTree;

import javax.swing.ToolTipManager;

import javax.swing.event.TreeSelectionListener;

import javax.swing.text.Position;

import javax.swing.tree.TreeModel;

import javax.swing.tree.TreePath;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.StoresRepository;

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

import static org.gvsig.fmap.dal.resource.db.DBParameters.PASSWORD_PARAMTER_NAME;

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

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.util.LabeledValue;

/**

 *

 * @author jjdelcerro

 */

public class StoresRepositoryController {

    private JTree tree;

    private final StoresRepository rootRepository;

    public StoresRepositoryController(JTree tree) {

        this(tree, DALLocator.getDataManager().getStoresRepository());

    }

    public StoresRepositoryController(JTree tree, StoresRepository rootRepository) {

        this.tree = tree;

        this.tree.setExpandsSelectedPaths(true);

        this.rootRepository = rootRepository;

        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        this.tree.setModel(dataSwingManager.createTreeModel(rootRepository));

        this.configureToolTip(this.tree);

    }

    public void addTreeSelectionListener(TreeSelectionListener tsl) {

        this.tree.addTreeSelectionListener(tsl);

    }

    public DataStore getSelectedStore() {

        TreePath path = this.tree.getSelectionPath();

        if( path == null ) {

            return null;

        }

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

        if( element == null ) {

            return null;

        }

        TreePath parentPath = path.getParentPath();

        if( parentPath == null ) {

            return null;

        }

        LabeledValue parentElement = (LabeledValue) parentPath.getLastPathComponent();

        if( !(element.getValue() instanceof DataStoreParameters) ) {

            return null;

        }

        if( !(parentElement.getValue() instanceof StoresRepository) ) {

            return null;

        }

        StoresRepository repository = (StoresRepository) parentElement.getValue();

//        DataStore store = (DataStore) repository.getStore(element.getLabel());

        DataStoreParameters storeParams = repository.get(element.getLabel());

        DataStore store = null;

        try {

            store = DALLocator.getManager().openStore(storeParams.getProviderName(), storeParams);

        } catch (Exception ex) {

            //FIXME

            store = null;

        }

        return store;

    }

    public boolean setSelectedStore(FeatureStore store) {

        TreeModel model = this.tree.getModel();

        LabeledValue root = (LabeledValue) model.getRoot();

        List path = new ArrayList();

        if(!setSelectedStore(model, path, root, store.getParameters())) {

            return false;

        };

        int currentRow = 0;

        TreePath elementPath = null;

        for (int i = 0; i< path.size(); i++){

            LabeledValue element = (LabeledValue)path.get(i);

            elementPath = this.tree.getNextMatch(element.getLabel(), currentRow, Position.Bias.Forward);

            if(elementPath == null) {

                break;

            }

            this.tree.expandPath(elementPath);

            currentRow = this.tree.getRowForPath(elementPath);

            if(currentRow < 0){

                break;

            }

        }

        if(elementPath == null) {

            return false;

        }

//        this.tree.expandPath(elementPath.getParentPath());

        this.tree.setSelectionPath(elementPath);

        this.tree.scrollPathToVisible(elementPath);

        return true;

    }

    private boolean setSelectedStore(TreeModel model, List path, LabeledValue node, DataStoreParameters storeParams) {

        if(node == null){

            return false;

        }

        Object value = node.getValue();

        if(value instanceof DataStoreParameters) {

            DataStoreParameters nodeParams = (DataStoreParameters)value;

            if(nodeParams.isTheSameStore(storeParams)){

                return true;

            }

        }

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

            LabeledValue child = (LabeledValue) model.getChild(node, i);

            path.add(child);

            if(setSelectedStore(model, path, child, storeParams)){

                return true;

            }

            path.remove(path.size()-1);

        }

        return false;

    }

    public FeatureStore getSelectedFeatureStore() {

        DataStore store = this.getSelectedStore();

        if( store instanceof FeatureStore ) {

            return (FeatureStore) store;

        }

        DisposeUtils.dispose(store);

        return null;

    }

    private void configureToolTip(JTree repositoryTree) {

        repositoryTree.addMouseMotionListener(new MouseMotionAdapter() {

            @Override

            public void mouseMoved(MouseEvent e) {

                super.mouseMoved(e); 

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

                updateToolTip(repositoryTree, path);

            }

        });

        repositoryTree.addFocusListener(new FocusAdapter() {

            @Override

            public void focusLost(FocusEvent e) {

                // Tratamos de forzar que se oculte el tooltip si estuvise

                // mostrado o a punto de mostrarse.

                ToolTipManager toolTipManager = ToolTipManager.sharedInstance();    

                toolTipManager.mouseExited(new MouseEvent(repositoryTree, 0, 0, 0, 0, 0, 0, true));

            }

        });

    }

    private void updateToolTip(JTree repositoryTree, TreePath path) {

        if(path == null){

            repositoryTree.setToolTipText("");

            return;

        }

        Object x = path.getLastPathComponent();

        if(!(x instanceof LabeledValue)){

            repositoryTree.setToolTipText("");

            return;

        }

        LabeledValue element = (LabeledValue)x;

        if (element.getValue() instanceof StoresRepository ) {

            StoresRepository repository = (StoresRepository) element.getValue();            

            String s = "<html>\n<b>"+repository.getLabel()+"</b><br>\nID: "+repository.getID()+"\n</html>";

            repositoryTree.setToolTipText(s);

        } else if (element.getValue() instanceof DataStoreParameters ) {

            DataStoreParameters paramsters = (DataStoreParameters) element.getValue();

            List<DynField> fields = Arrays.asList(paramsters.getDynClass().getDynFields());

            Collections.sort(fields, (DynField o1, DynField o2) -> StringUtils.compareIgnoreCase(o1.getName(),o2.getName()));

            StringBuilder s = new StringBuilder();

            s.append("<html>\n<b>");

            s.append(element.getLabel());

            s.append("</b><br>\n");

            for (DynField field : fields) {

                String value = Objects.toString(paramsters.getDynValue(field.getName()),null);

                if( StringUtils.isNoneBlank(value)) {

                    s.append(field.getName());

                    s.append(": ");

                    if( StringUtils.equalsIgnoreCase(field.getName(),PASSWORD_PARAMTER_NAME) ) {

                        s.append("********");

                    } else {

                        s.append(value);

                    }

                    s.append("<br>\n");

                }

            }

            s.append("</html>");

            repositoryTree.setToolTipText(s.toString());

        } else {

            repositoryTree.setToolTipText("");

        }

    }

}