Aplicación gvSIG con fines educativos » Interfaz de usuario

					if (value.startsWith("file:")) {

						File file = aState.getFile(field.getName());

						file = fixRelativeFilePath(file, rootFolder);

				}else if ((field.getType() == org.gvsig.tools.dataTypes.DataTypes.FILE)

					// if value starts with / add file.

					if (value.startsWith("/")) {

					if (value.startsWith("file:")) {

    LayerListener, TreeSelectionListener {

    /**

    private static final long serialVersionUID = 3761640139439674486L;

    @SuppressWarnings("unused")

    private static final org.slf4j.Logger LOG = org.slf4j.LoggerFactory

        .getLogger(DefaultPortableViewToc.class);

    private static final FLayer[] EMPTY_SELECTION = new FLayer[0];

    private PortableViewViewer viewer;

    private boolean initialized;

    private JTree tree;

    private FLayers rootLayer;

    private TocTreeNode rootNode;

    private DefaultTreeModel treeModel;

    private PortableViewTocImageProvider imageProvider;

    private TocTreeCellRenderer cellRenderer;

    private boolean internalSelectionChanging;

    private final PortableViewSwingManager swingManager;

    public DefaultPortableViewToc() {

        swingManager = PortableViewSwingLocator.getSwingManager();

        initialized = false;

        imageProvider = swingManager.getDefaultTocImageProvider();

    }

    public void setImageProvider(PortableViewTocImageProvider imageProvider) {

        this.imageProvider = imageProvider;

        if (cellRenderer != null) {

            cellRenderer.setImageProvider(imageProvider);

        }

    }

    /**

     * Load tree model from mapContext

     */

    private void loadTreeModel() {

        rootLayer = getMapContext().getLayers();

        // rootNode = new LayerTreeNode(rootLayer);

        // rootLayer.addLayerCollectionListener(this);

        loadLayerNode(rootLayer, null);

        treeModel = new DefaultTreeModel(rootNode);

        tree.setModel(treeModel);

        tree.invalidate();

        tree.getSelectionModel().addTreeSelectionListener(this);

    }

    /**

     * Load a layer Node

     *

     * @param layer

     * @param parent

     */

    private void loadLayerNode(FLayer layer, TocTreeNode parent) {

        layer.addLayerListener(this);

        TocTreeNode node;

        if (layer instanceof LayerCollection) {

            LayerCollection collection = (LayerCollection) layer;

            node = new TocTreeNode((LayerCollection) layer);

            // collection.addLayerCollectionListener(this);

            for (int i = collection.getLayersCount(); i > 0; i--) {

                loadLayerNode(collection.getLayer(i-1), node);

            }

            if (parent == null) {

                rootNode = node;

            } else {

                parent.add(node);

            }

        } else {

            loadSingleLayerNode((SingleLayer) layer, parent);

        }

    }

    private void loadSingleLayerNode(SingleLayer layer, TocTreeNode parent) {

        TocTreeNode node;

        if (layer instanceof Classifiable) {

            Classifiable classifLayer = (Classifiable) layer;

            if (classifLayer.getLegend() != null) {

                loadLayerWithLegendNode(layer, classifLayer.getLegend(), parent);

                return;

            }

        }

        if (layer instanceof IHasImageLegend) {

            Image imgLegend = ((IHasImageLegend) layer).getImageLegend();

            loadLayerWithImageLegendNode(layer, imgLegend, parent);

            return;

        }

        node = new TocTreeNode(layer);

        parent.add(node);

    }

    /**

     * @param layer

     * @param imgLegend

     * @param parent

     */

    private void loadLayerWithImageLegendNode(SingleLayer layer,

        Image imgLegend, TocTreeNode parent) {

        TocTreeNode node;

        if (imgLegend == null) {

            node = new TocTreeNode(layer);

        } else {

            node = new TocTreeNode(layer, imgLegend);

            TocTreeNode legendNode = new TocTreeNode(imgLegend, layer);

            node.add(legendNode);

        }

        parent.add(node);

    }

    /**

     * @param layer

     * @param legend

     * @param parent

     */

    private void loadLayerWithLegendNode(SingleLayer layer, ILegend legend,

        TocTreeNode parent) {

        TocTreeNode node;

        ISymbol defSymbol = legend.getDefaultSymbol();

        if (legend instanceof IClassifiedLegend) {

            node = new TocTreeNode(layer, true);

            IClassifiedLegend cl = (IClassifiedLegend) legend;

            String[] descriptions = cl.getDescriptions();

            ISymbol[] symbols = cl.getSymbols();

            TocTreeNode symNode;

            for (int j = 0; j < descriptions.length; j++) {

                symNode = new TocTreeNode(symbols[j], descriptions[j], layer);

                node.add(symNode);

            }

        } else

            if (legend instanceof ISingleSymbolLegend && defSymbol != null) {

                node = new TocTreeNode(layer, true);

                TocTreeNode symNode =

                    new TocTreeNode(defSymbol, defSymbol.getDescription(),

                        layer);

                node.add(symNode);

            } else {

                node = new TocTreeNode(layer, false);

            }

        parent.add(node);

    }

    private List<TocTreeNode> getNodesFromType(TYPE... types) {

        List<TocTreeNode> nodesFound = new ArrayList<TocTreeNode>();

        getNodesFromType(rootNode, nodesFound, types);

        return nodesFound;

    }

    private void getNodesFromType(TocTreeNode node,

        List<TocTreeNode> nodesFound, TYPE... types) {

        for (TYPE type : types) {

            if (node.getType() == type) {

                nodesFound.add(node);

            }

        }

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

            getNodesFromType((TocTreeNode) node.getChildAt(index), nodesFound,

                types);

        }

    }

    /** {@inheridDoc} */

    public JComponent getSwingComponent() {

        if (viewer == null) {

            throw new IllegalStateException("Viewer not set yet");

        }

        return this;

    }

    /** {@inheridDoc} */

    public FLayer[] getSelectedLayers() {

        if (viewer == null) {

            throw new IllegalStateException("Viewer not set yet");

        }

        List<FLayer> selectedLayers = new ArrayList<FLayer>();

        TocTreeNode node;

        TreePath[] paths = tree.getSelectionPaths();

        if (paths != null && paths.length > 0) {

            for (TreePath path : paths) {

                node = (TocTreeNode) path.getLastPathComponent();

                if (node.isLayer()) {

                    selectedLayers.add(node.getLayer());

                }

            }

        } else {

            return EMPTY_SELECTION;

        }

        return selectedLayers.toArray(EMPTY_SELECTION);

    }

    /** {@inheridDoc} */

    public void attachTo(PortableViewViewer viewer) {

        if (this.viewer != null && !this.viewer.equals(viewer)) {

            throw new IllegalStateException("Viewer already attached");

        }

        this.viewer = viewer;

        initializeUI();

        loadTreeModel();

    }

    /** {@inheridDoc} */

    public PortableViewViewer getViewer() {

        return viewer;

    }

    /**

     * Initialize User Interface components

     */

    private void initializeUI() {

        if (initialized) {

            return;

        }

        setLayout(new BorderLayout());

        tree = new JTree();

        cellRenderer = new TocTreeCellRenderer();

        if (imageProvider != null) {

            cellRenderer.setImageProvider(imageProvider);

        }

        tree.setCellRenderer(cellRenderer);

        tree.setRootVisible(false);

        tree.getSelectionModel().setSelectionMode(

            TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);

        add(new JScrollPane(tree), BorderLayout.CENTER);

        tree.addMouseListener(new MouseListener() {

            public void mouseReleased(MouseEvent e) {

                processTreeMouseEvent(e);

            }

            public void mousePressed(MouseEvent e) {

                processTreeMouseEvent(e);

            }

            public void mouseExited(MouseEvent e) {

                processTreeMouseEvent(e);

            }

            public void mouseEntered(MouseEvent e) {

                processTreeMouseEvent(e);

            }

            public void mouseClicked(MouseEvent e) {

                processTreeMouseEvent(e);

            }

        });

        setMinimumSize(new Dimension(200, 100));

        initialized = true;

    }

    /**

     * Locates the layer node in all tree structure from root

     *

     * @param layer

     * @return

     */

    private DefaultMutableTreeNode findLayerNode(FLayer layer) {

        if (rootNode == null) {

            return null;

        }

        return findLayerNode(rootNode, layer);

    }

    /**

     * Locates the layer node in all tree structure from root

     *

     * @param node

     * @param layer

     * @return

     */

    private TocTreeNode findLayerNode(TocTreeNode node, FLayer layer) {

        if (node.getLayer() == layer) {

            return node;

        }

        if (node.isLeaf()) {

            return null;

        }

        TocTreeNode aNode;

        TocTreeNode result;

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

            aNode = (TocTreeNode) node.getChildAt(i);

            result = findLayerNode(aNode, layer);

            if (result != null) {

                return result;

            }

        }

        return null;

    }

    public DynObject getParameters() {

        // TODO Auto-generated method stub

        return null;

    }

    public TOCFactory getFactory() {

        // TODO Auto-generated method stub

        return null;

    }

    public JComponent getComponent() {

        return getSwingComponent();

    }

    public MapContext getMapContext() {

        if (viewer == null) {

            return null;

        }

        return viewer.getPortableView().getMapContext();

    }

    public void showAll() {

        List<TocTreeNode> nodes = getNodesFromType(TYPE.values());

        for (TocTreeNode node : nodes) {

            tree.expandPath(new TreePath(node.getPath()));

        }

    }

    public void hideAll() {

        DefaultMutableTreeNode node;

        for (int i = rootNode.getChildCount(); i < rootNode.getChildCount(); i++) {

            node = (DefaultMutableTreeNode) rootNode.getChildAt(i);

            tree.collapsePath(new TreePath(node.getPath()));

        }

    }

    public void showAllLegends() {

        List<TocTreeNode> nodes =

            getNodesFromType(TYPE.LAYER_WITH_LEGEND,

                TYPE.LAYER_WITH_IMAGE_LEGEND);

        for (TocTreeNode node : nodes) {

            tree.expandPath(new TreePath(node.getPath()));

        }

    }

    public void hideAllLegends() {

        List<TocTreeNode> nodes =

            getNodesFromType(TYPE.LAYER_WITH_LEGEND,

                TYPE.LAYER_WITH_IMAGE_LEGEND);

        for (TocTreeNode node : nodes) {

            tree.collapsePath(new TreePath(node.getPath()));

        }

    }

    public void show(FLayer lyr, boolean detailed) {

        DefaultMutableTreeNode node = findLayerNode(lyr);

        if (detailed && node.getChildCount() > 0) {

            node = (DefaultMutableTreeNode) node.getFirstChild();

        }

        tree.scrollPathToVisible(new TreePath(node.getPath()));

    }

    public void showLegend(FLayer lyr) {

        show(lyr, true);

    }

    public void hideLegend(FLayer lyr) {

        DefaultMutableTreeNode node = findLayerNode(lyr);

        tree.collapsePath(new TreePath(node.getPath()));

    }

    public void selectLayer(FLayer lyr) {

        DefaultMutableTreeNode node = findLayerNode(lyr);

        tree.getSelectionModel().addSelectionPath(new TreePath(node.getPath()));

    }

    public void unselectLayer(FLayer lyr) {

        DefaultMutableTreeNode node = findLayerNode(lyr);

        tree.getSelectionModel().removeSelectionPath(

            new TreePath(node.getPath()));

    }

    public void clearSelection() {

        tree.clearSelection();

    }

    public void setActiveLayer(FLayer lyr) {

        TocTreeNode node = (TocTreeNode) findLayerNode(lyr);

        tree.getSelectionModel().setSelectionPath(new TreePath(node.getPath()));

    }

    public FLayer getActiveLayer() {

        if (tree.getSelectionCount() < 1) {

            return null;

        }

        TocTreeNode node =

            (TocTreeNode) tree.getSelectionPath().getLastPathComponent();

        if (!node.isLayer()) {

            return null;

        }

        return node.getLayer();

    }

    public void invokeAction(FLayer lyr, String action) {

        throw new UnsupportedOperationException();

    }

    public void addLegendActionListener(LegendActionEventListener lel) {

        throw new UnsupportedOperationException();

    }

    public void removeLegendActionListener(LegendActionEventListener lel) {

        throw new UnsupportedOperationException();

    }

    public void addLayerActionListener(LayerActionEventListener lel) {

        throw new UnsupportedOperationException();

    }

    public void removeLayerActionListener(LayerActionEventListener lel) {

        throw new UnsupportedOperationException();

    }

    public void addActiveLayerChangeListener(

        ActiveLayerChangeEventListener alcel) {

        throw new UnsupportedOperationException();

    }

    public void removeActiveLayerChangeListener(

        ActiveLayerChangeEventListener alcel) {

        throw new UnsupportedOperationException();

    }

    public Manager getManager() {

        // Nothing to do

        return null;

    }

    public void visibilityChanged(LayerEvent e) {

        DefaultMutableTreeNode node = findLayerNode(e.getSource());

        treeModel.nodeChanged(node);

    }

    public void activationChanged(LayerEvent e) {

        if (internalSelectionChanging) {

            return;

        }

        FLayer layer = e.getSource();

        TocTreeNode node = (TocTreeNode) findLayerNode(layer);

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

        if (layer.isActive()) {

            tree.addSelectionPath(path);

        } else {

            tree.removeSelectionPath(path);

        }

    }

    public void nameChanged(LayerEvent e) {

        DefaultMutableTreeNode node = findLayerNode(e.getSource());

        treeModel.nodeChanged(node);

    }

    public void editionChanged(LayerEvent e) {

        // Nothing to do

    }

    public void drawValueChanged(LayerEvent e) {

        // Nothing to do

    }

    protected void processTreeMouseEvent(MouseEvent e) {

        if (!tree.isEnabled()) {

            return;

        }

        if (e.getID() != MouseEvent.MOUSE_CLICKED) {

            return;

        }

        int x = e.getX();

        int y = e.getY();

        int row = tree.getRowForLocation(x, y);

        if (row < 0) {

            return;

        }

        // click inside some node

        Rectangle rect = tree.getRowBounds(row);

        if (rect == null) {

            return;

        }

        // Get the node

        TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());

        final TocTreeNode node = (TocTreeNode) selPath.getLastPathComponent();

        if (!node.isLayer() || !node.getLayer().isAvailable()) {

            // no layer or unavailable layer: do nothing

            return;

        }

        // click on a valid node

        TocTreeCellRenderer renderer =

            (TocTreeCellRenderer) tree.getCellRenderer();

        // adjust renderer for node and check box has been clicked

        renderer.getTreeCellRendererComponent(tree, node, false, false, false,

            row, false);

        if (!renderer.isOnCheck(x - rect.x, y - rect.y)) {

            return;

        }

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                swichLayerVisibilid(node);

            }

        });

    }

    /**

     * @param node

     */

    private void swichLayerVisibilid(TocTreeNode node) {

        if (!node.isLayer()) {

            return;

        }

        FLayer layer = node.getLayer();

        setLayerVisibilid(node, !layer.isVisible());

    }

    private void setLayerVisibilid(TocTreeNode node, boolean newValue) {

        if (node.isLayer()) {

            FLayer layer = node.getLayer();

            layer.setVisible(newValue);

            treeModel.nodeChanged(node);

        }

        if (node.isLeaf()) {

            return;

        }

        TocTreeNode child;

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

            child = (TocTreeNode) node.getChildAt(index);

            setLayerVisibilid(child, newValue);

        }

    }

    public void valueChanged(TreeSelectionEvent e) {

        internalSelectionChanging = true;

        getMapContext().beginAtomicEvent();

        List<FLayer> prevActives =

            new ArrayList<FLayer>(Arrays.asList(rootLayer.getActives()));

        TreePath[] selectedPaths = e.getPaths();

        List<FLayer> newActives = new ArrayList<FLayer>(selectedPaths.length);

        // mark new active

        TocTreeNode node;

        FLayer layer;

        for (TreePath path : selectedPaths) {

            node = (TocTreeNode) path.getLastPathComponent();

            if (node.isLayer()) {

                layer = node.getLayer();

                if (!layer.isActive()) {

                    layer.setActive(true);

                } else {

                    prevActives.remove(layer);

                }

                newActives.add(layer);

            }

        }

        // Clear the previous

        for (FLayer aLayer : prevActives) {

            aLayer.setActive(false);

        }

        getMapContext().endAtomicEvent();

        internalSelectionChanging = false;

    }