Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * 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.symbology.fmap.mapcontext.rendering.symbol.marker.impl;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.gvsig.compat.print.PrintAttributes;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.rendering.symbols.CartographicSupport;

import org.gvsig.fmap.mapcontext.rendering.symbols.IMultiLayerSymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol_v2;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMultiLayerMarkerSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.util.Callable;

/**

 * MultiLayerMarkerSymbol allows to group several marker symbols

 * (xxxMarkerSymbol implementing IMarkerSymbol)in one and treat it as an only

 * one symbol.

 *

 * @author gvSIG team

 */

@SuppressWarnings("UseSpecificCatch")

public class MultiLayerMarkerSymbol extends AbstractMarkerSymbol implements IMarkerSymbol, IMultiLayerSymbol, IMultiLayerMarkerSymbol {

    public static final String MULTILAYER_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME = "MultiLayerMarkerSymbol";

    private static final String FIELD_LAYERS = "layers";

    private static final String FIELD_ROTATION = "rotation";

    private IMarkerSymbol[] layers = new IMarkerSymbol[0];

    private MultiLayerMarkerSymbol selectionSymbol;

    private double markerSize;

    private double rotation;

    public MultiLayerMarkerSymbol() {

        super();

    }

    @Override

    public Color getColor() {

        /*

                 * a multilayer symbol does not define any color, the color

                 * of each layer is defined by the layer itself

         */

        return null;

    }

    @Override

    public double getRotation() {

        return rotation;

    }

    @Override

    public void setColor(Color color) {

        for (int i = 0; layers != null && i < layers.length; i++) {

            if (layers[i] == null) {

                continue;

            }

            layers[i].setColor(color);

        }

    }

    @Override

    public void setRotation(double rotation) {

        this.rotation = rotation;

    }

    @Override

    public double getSize() {

        double myMarkerSize = 0;

        for (int i = 0; i < getLayerCount(); i++) {

            ISymbol layer = getLayer(i);

            if (layer == null) {

                continue;

            }

            myMarkerSize = Math.max(myMarkerSize, ((IMarkerSymbol) layer).getSize());

        }

        if (markerSize != myMarkerSize) {

            markerSize = myMarkerSize;

        }

        return markerSize;

    }

    @Override

    public void setSize(double size) {

        if (size > 0 && size != getSize()) {

            double scale = size / getSize();

            this.markerSize = size;

            for (int i = 0; layers != null && i < layers.length; i++) {

                if (layers[i] == null) {

                    continue;

                }

                double lSize = layers[i].getSize();

                layers[i].setSize(lSize * scale);

            }

        }

    }

    @Override

    public void draw(Graphics2D g, AffineTransform affineTransform, Geometry geom, Feature f, Cancellable cancel, Rectangle r) {

        if(r!=null){

            geom = this.getSampleGeometry(r);

        }

        Point p;

        try {

            p = geom.centroid();

        } catch (Exception ex) {

            return;

        }

        g.rotate(rotation, p.getX(), p.getY());

        for (int i = 0; (cancel == null || !cancel.isCanceled())

                && layers != null && i < layers.length; i++) {

            IMarkerSymbol layer = layers[i];

            if (layer == null) {

                continue;

            }

            layer.setCartographicContext(this.getCartographicContext());

            if(layer instanceof IMarkerSymbol_v2){

                ((IMarkerSymbol_v2)layer).draw(g, affineTransform, geom, f, cancel, r);

            } else {

                layer.draw(g, affineTransform, geom, f, cancel);

            }

        }

        g.rotate(-rotation, p.getX(), p.getY());

    }

//    @Override

//    public int getOnePointRgb() {

//        // will paint only the last layer pixel

//        return layers[layers.length - 1].getOnePointRgb();

//    }

//

//    @Override

//    public void getPixExtentPlus(Geometry geom, float[] distances,

//            ViewPort viewPort, int dpi) {

//        float[] myDistances = new float[]{0, 0};

//        distances[0] = 0;

//        distances[1] = 0;

//        for (int i = 0; layers != null && i < layers.length; i++) {

//            if (layers[i] == null) {

//                continue;

//            }

//            layers[i].getPixExtentPlus(geom, myDistances, viewPort, dpi);

//            distances[0] = Math.max(myDistances[0], distances[0]);

//            distances[1] = Math.max(myDistances[1], distances[1]);

//        }

//    }

    @Override

    public ISymbol getSymbolForSelection() {

        if (selectionSymbol == null) {

            selectionSymbol = new MultiLayerMarkerSymbol();

            selectionSymbol.setDescription(getDescription());

            for (int i = 0; layers != null && i < layers.length; i++) {

                selectionSymbol.addLayer(layers[i].getSymbolForSelection());

            }

        } else {

            for (int i = 0; i < selectionSymbol.getLayerCount(); i++) {

                selectionSymbol.setLayer(i, selectionSymbol.getLayer(i).getSymbolForSelection());

            }

        }

        if (selectionSymbol instanceof CartographicSupport) {

            ((CartographicSupport) selectionSymbol).setUnit(this.getUnit());

        }

        return selectionSymbol;

    }

    @Override

    public boolean isSuitableFor(Geometry geom) {

        return geom.getType() == Geometry.TYPES.POINT;

    }

    public String getClassName() {

        return getClass().getName();

    }

    @Override

    public void print(Graphics2D g, AffineTransform at, Geometry geom, PrintAttributes properties) {

        for (int i = 0; layers != null && i < layers.length; i++) {

            if (layers[i] == null) {

                continue;

            }

            layers[i].print(g, at, geom, properties);

        }

    }

    @Override

    public void setLayer(int index, ISymbol layer) throws IndexOutOfBoundsException {

        layers[index] = (IMarkerSymbol) layer;

    }

    @Override

    public void swapLayers(int index1, int index2) {

        ISymbol aux1 = getLayer(index1), aux2 = getLayer(index2);

        layers[index2] = (IMarkerSymbol) aux1;

        layers[index1] = (IMarkerSymbol) aux2;

    }

    @Override

    public ISymbol getLayer(int layerIndex) {

        return layers[layerIndex];

    }

    @Override

    public int getLayerCount() {

        return layers.length;

    }

    @Override

    public void addLayer(ISymbol newLayer) {

        addLayer(newLayer, layers.length);

    }

    @Override

    public void addLayer(ISymbol newLayer, int layerIndex) throws IndexOutOfBoundsException {

        if (newLayer == null) {

            /*|| newLayer instanceof ILabelStyle)*/ return; // null or symbols that are styles are not allowed

        }

        if(!(newLayer instanceof IMarkerSymbol_v2)){

            LOGGER.info("Symbol "+newLayer.getClass().getName()+" does not implement IMarkerSymbol_v2");

        }

        IMarkerSymbol newMarker = (IMarkerSymbol) newLayer;

        if (getLayerCount() == 0) {

            // apply the new layer properties to this multilayer

            setReferenceSystem(newMarker.getReferenceSystem());

            markerSize = newMarker.getSize();

            //setSize(newMarker.getSize());

            setUnit(newMarker.getUnit());

        } else {

            if (newMarker.getSize() > getSize()) {

                //setSize(newMarker.getSize());

                markerSize = newMarker.getSize();

            }

            newMarker.setReferenceSystem(getReferenceSystem());

            newMarker.setUnit(getUnit());

        }

        selectionSymbol = null;

        /* forces the selection symbol to be re-created

         * next time it is required

         */

        if (layerIndex < 0 || layers.length < layerIndex) {

            throw new IndexOutOfBoundsException(layerIndex + " < 0 or " + layerIndex + " > " + layers.length);

        }

        List<IMarkerSymbol> newLayers = new ArrayList<>();

        newLayers.addAll(Arrays.asList(layers));

        try {

            newLayers.add(layerIndex, (IMarkerSymbol) newLayer);

            layers = (IMarkerSymbol[]) newLayers.toArray(new IMarkerSymbol[newLayers.size()]);

        } catch (ArrayStoreException asEx) {

            throw new ClassCastException(newLayer.getClass().getName() + " is not an IMarkerSymbol");

        }

    }

    @Override

    public boolean removeLayer(ISymbol layer) {

        int capacity;

        capacity = layers.length;

        List<IMarkerSymbol> lst = new ArrayList<>(capacity);

        for (int i = 0; i < capacity; i++) {

            lst.add(layers[i]);

        }

        boolean contains = lst.remove((IMarkerSymbol)layer);

        layers = (IMarkerSymbol[]) lst.toArray(new IMarkerSymbol[0]);

        return contains;

    }

    @Override

    public void setUnit(int unit) {

        super.setUnit(unit);

        for (int i = 0; layers != null && i < layers.length; i++) {

            if (layers[i] == null) {

                continue;

            }

            layers[i].setUnit(unit);

        }

    }

    @Override

    public void setReferenceSystem(int system) {

        super.setReferenceSystem(system);

        for (int i = 0; layers != null && i < layers.length; i++) {

            if (layers[i] == null) {

                continue;

            }

            layers[i].setReferenceSystem(system);

        }

    }

    @Override

    public void setAlpha(int alpha) {

        // first, get the biggest alpha in the layers and the index if such layer

        int maxAlpha = Integer.MIN_VALUE;

        int maxAlphaLayerIndex = 0;

        for (int i = 0; layers != null && i < layers.length; i++) {

            if (layers[i] != null) {

                if (layers[i].getColor().getAlpha() > maxAlpha) {

                    maxAlpha = layers[i].getColor().getAlpha();

                    maxAlphaLayerIndex = i;

                }

            }

        }

        // now, max alpha takes the value of the desired alpha and the rest

        // will take a scaled (to biggest alpha) alpha value

        for (int i = 0; layers != null && i < layers.length; i++) {

            if (layers[i] == null) {

                continue;

            }

            int r = layers[i].getColor().getRed();

            int g = layers[i].getColor().getGreen();

            int b = layers[i].getColor().getBlue();

            if (i != maxAlphaLayerIndex) {

                double scaledAlpha = (double) layers[i].getColor().getAlpha() / maxAlpha;

                int myAlpha = (int) (alpha * scaledAlpha);

                if (myAlpha == 0) {

                    myAlpha = 1;

                }

                layers[i].setColor(new Color(r, g, b, myAlpha));

            } else {

                int myAlpha = alpha;

                if (myAlpha == 0) {

                    myAlpha = 1;

                }

                layers[i].setColor(new Color(r, g, b, myAlpha));

            }

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        MultiLayerMarkerSymbol copy = (MultiLayerMarkerSymbol) super.clone();

        // Clone layers

        if (layers != null) {

            IMarkerSymbol[] layersCopy = new IMarkerSymbol[layers.length];

            for (int i = 0; i < layers.length; i++) {

                if (layers[i] == null) {

                    continue;

                }

                layersCopy[i] = (IMarkerSymbol) layers[i].clone();

            }

            copy.layers = layersCopy;

        }

        // Clone selection

        if (selectionSymbol != null) {

            copy.selectionSymbol = (MultiLayerMarkerSymbol) selectionSymbol

                    .clone();

        }

        return copy;

    }

    @SuppressWarnings("unchecked")

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        // Set parent fill symbol properties

        super.loadFromState(state);

        // Set own properties

        List theLayers = state.getList(FIELD_LAYERS);

        if (theLayers != null) {

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

                Object layer = theLayers.get(i);

                if (layer == null) {

                    continue;

                }

                addLayer((ISymbol) layer);

            }

        }

        setRotation(state.getDouble(FIELD_ROTATION));

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent fill symbol properties

        super.saveToState(state);

        // Save own properties

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

            state.set(FIELD_LAYERS, Arrays.asList(layers));

        }

        state.set(FIELD_ROTATION, getRotation());

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(MULTILAYER_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager.addDefinition(

                        MultiLayerMarkerSymbol.class,

                        MULTILAYER_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME,

                        MULTILAYER_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

                        null,

                        null

                );

                // Extend the MarkerSymbol base definition

                definition.extend(manager.getDefinition(MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME));

                // Layers

                definition.addDynFieldList(FIELD_LAYERS).setClassOfItems(IMarkerSymbol.class);

                // Rotation

                definition.addDynFieldDouble(FIELD_ROTATION).setMandatory(true);

            }

            return true;

        }

    }

    public static class RegisterSymbol implements Callable {

        @Override

        public Object call() throws Exception {

            int[] shapeTypes;

            SymbolManager manager = MapContextLocator.getSymbolManager();

            shapeTypes = new int[]{Geometry.TYPES.POINT, Geometry.TYPES.MULTIPOINT};

            manager.registerMultiLayerSymbol(IMarkerSymbol.SYMBOL_NAME,

                    shapeTypes,

                    MultiLayerMarkerSymbol.class

            );

            return true;

        }

    }

}