Application: gvSIG desktop

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

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

import javax.swing.JLabel;

import javax.swing.JTree;

import javax.swing.ToolTipManager;

import javax.swing.event.TreeSelectionListener;

import javax.swing.text.Position;

import javax.swing.tree.DefaultTreeCellRenderer;

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

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.fmap.dal.swing.storesrepository.StoresRepositoryController;

import org.gvsig.fmap.dal.swing.storesrepository.StoresRepositoryTreeModel.StoresRepositoryElement;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynField;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class StoresRepositoryControllerImpl implements StoresRepositoryController {

    private JTree tree;

    private final StoresRepository rootRepository;

    private boolean useGeometryIcons;

    public StoresRepositoryControllerImpl(JTree tree) {

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

    }

    public StoresRepositoryControllerImpl(JTree tree, StoresRepository rootRepository) {

        this.tree = tree;

        this.tree.setExpandsSelectedPaths(true);

        this.useGeometryIcons = false;

        this.rootRepository = rootRepository;

        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

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

        this.configureToolTip(this.tree);

        this.tree.setCellRenderer(new DefaultTreeCellRenderer() {

            @Override

            public java.awt.Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {

                JLabel label = (JLabel) super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus); //To change body of generated methods, choose Tools | Templates.

                if( useGeometryIcons ) {

                    Icon icon = getIconForItem(value);

                    setIcon(icon);

                }

                return label;

            }

        });        

    }

    @Override

    public void setUseGeometryIcons(boolean useGeometryIcons) {

        this.useGeometryIcons = useGeometryIcons;

    }

    @Override

    public boolean getUseGeometryIcons() {

        return this.useGeometryIcons;

    }

    public void addTreeSelectionListener(TreeSelectionListener tsl) {

        this.tree.addTreeSelectionListener(tsl);

    }

    @Override

    public DataStore getSelectedStore() {

        TreePath path = this.tree.getSelectionPath();

        if( path == null ) {

            return null;

        }

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

        if( element == null ) {

            return null;

        }

        TreePath parentPath = path.getParentPath();

        if( parentPath == null ) {

            return null;

        }

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

        if( !element.isStore() ) {

            return null;

        }

        if( !parentElement.isRepository() ) {

            return null;

        }

        StoresRepository repository = parentElement.getRepository();

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

        DataStore store;

        try {

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

            store = (DataStore) repository.getStore(element.getStoreName());

        } catch (Exception ex) {

            //FIXME

            store = null;

        }

        return store;

    }

    @Override

    public boolean setSelectedStore(FeatureStore store) {

        TreeModel model = this.tree.getModel();

        StoresRepositoryElement root = (StoresRepositoryElement) 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++){

            StoresRepositoryElement element = (StoresRepositoryElement)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;

    }

    @Override

    public boolean setSelectedStore(String storeName) {

        if( StringUtils.isBlank(storeName) ) {

            this.tree.clearSelection();

            return true;

        }

        DataStoreParameters params = this.rootRepository.get(storeName);

        TreeModel model = this.tree.getModel();

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

        List path = new ArrayList();

        if(!setSelectedStore(model, path, root, params)) {

            return false;

        }

        int currentRow = 0;

        TreePath elementPath = null;

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

            StoresRepositoryElement element = (StoresRepositoryElement)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, StoresRepositoryElement node, DataStoreParameters storeParams) {

        if(node == null){

            return false;

        }

        if( node.isStore()) {

            if(node.getStoreParameters().isTheSameStore(storeParams)){

                return true;

            }

        }

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

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

            path.add(child);

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

                return true;

            }

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

        }

        return false;

    }

    @Override

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

            repositoryTree.setToolTipText("");

            return;

        }

        StoresRepositoryElement element = (StoresRepositoryElement) x;

        if ( element.isRepository() ) {

            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.isStore() ) {

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

            List<DynField> fields = Arrays.asList(element.getStoreParameters().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(element.getStoreParameters().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("");

        }

    }

    @Override

    public void setEnabled(boolean enabled) {

        this.tree.setEnabled(enabled);

    }

    private Icon getIconForItem(Object item0) {

        StoresRepositoryElement item = (StoresRepositoryElement) item0;

        if ( item.isStore()) {

            FeatureStore store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

                store = (FeatureStore) dataManager.openStore(item.getStoreParameters().getProviderName(), item.getStoreParameters());

                Icon icon = dataSwingManager.getStoreGeometryIcon(store);

                return icon;

            } catch(Exception ex) {

//                LOGGER.trace("Can't get geometry type from store.", ex);

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

        } 

        return null;

    }

}