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

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.type.GeometryType;

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

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.IMultiShapeSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

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.style.ILineStyle;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.IMask;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.exception.NotYetImplemented;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * MultiShapeSymbol class allows to create a composition of several symbols with

 * different shapes and be treated as a single symbol.These shapes can be

 * marker,line or fill.

 * 

 * @author 2005-2008 jaume dominguez faus - jaume.dominguez@iver.es

 * @author 2009- <a href="cordinyana@gvsig.org">C?sar Ordi?ana</a> - gvSIG team

 */

public class MultiShapeSymbol extends AbstractSymbol implements ILineSymbol, IMarkerSymbol, IFillSymbol, IMultiShapeSymbol {

        private static final Logger LOG = LoggerFactory.getLogger(MultiShapeSymbol.class); 

        public static final String MULTI_SHAPE_SYMBOL_PERSISTENCE_DEFINITION_NAME = "MultiShapeSymbol";

        private static final String FIELD_MARKER = "marker";

        private static final String FIELD_LINE = "line";

        private static final String FIELD_FILL = "fill";

        private static final String FIELD_DESCRIPTION = "description";

        @SuppressWarnings("FieldNameHidesFieldInSuperclass")

        public static final String SYMBOL_NAME = "multiShape";

        private IMarkerSymbol marker;

        private ILineSymbol line;

        private IFillSymbol fill;

        private IMask mask;

        private int referenceSystem;

        private MultiShapeSymbol symSelect;

        public MultiShapeSymbol() {

                super();

                marker = (IMarkerSymbol) createSymbol(IMarkerSymbol.SYMBOL_NAME);

                line = (ILineSymbol) createSymbol(ILineSymbol.SYMBOL_NAME);

                fill = (IFillSymbol) createSymbol(IFillSymbol.SYMBOL_NAME);

        }

        private ISymbol createSymbol(String symbolName) {

                SymbolManager manager = MapContextLocator.getSymbolManager();

                return manager.createSymbol(symbolName);

        }

        public Color getLineColor() {

                return line.getColor();

        }

        @Override

        public void setLineColor(Color color) {

                line.setLineColor(color);

        }

        @Override

        public ILineStyle getLineStyle() {

                return line.getLineStyle();

        }

        @Override

        public void setLineStyle(ILineStyle lineStyle) {

                line.setLineStyle(lineStyle);

        }

        @Override

        public void setLineWidth(double width) {

                line.setLineWidth(width);

        }

        @Override

        public double getLineWidth() {

                return line.getLineWidth();

        }

        @Override

        public int getAlpha() {

                return line.getAlpha();

        }

        @Override

        public void setAlpha(int outlineAlpha) {

                line.setAlpha(outlineAlpha);

        }

        @Override

        public ISymbol getSymbolForSelection() {

                if (symSelect == null) {

                        symSelect = new MultiShapeSymbol();

                }

                if (marker!=null){

                        symSelect.setMarkerSymbol((IMarkerSymbol) marker.getSymbolForSelection());

                }

                if (line!=null){

                        symSelect.setLineSymbol((ILineSymbol) line.getSymbolForSelection());

                }

                if (fill!=null ){

                        symSelect.setFillSymbol((IFillSymbol) fill.getSymbolForSelection());

                }

                if (symSelect instanceof CartographicSupport) {

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

                }

                return symSelect;

        }

        @Override

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

            GeometryType geometryType = geom.getGeometryType();

            if (geometryType.isTypeOf(Geometry.TYPES.POINT)){

                if (marker != null) {

                    if(marker instanceof CartographicSupport){

                        marker.setCartographicContext(this.getCartographicContext());

                    }

                    if(marker instanceof IMarkerSymbol_v2){

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

                    } else {

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

                    }

                }

            }else if (geometryType.isTypeOf(Geometry.TYPES.CURVE)){

                if (line != null) {

                    if(line instanceof CartographicSupport){

                        line.setCartographicContext(this.getCartographicContext());

                    }

                    if(line instanceof ISymbol_v2){

                        ((ISymbol_v2)line).draw(g, affineTransform, geom, f, cancel, r);

                    } else {

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

                    }

                }

            }else if (geometryType.isTypeOf(Geometry.TYPES.SURFACE)){

                if (fill != null) {

                    if(fill instanceof CartographicSupport){

                        fill.setCartographicContext(this.getCartographicContext());

                    }

                    if(fill instanceof ISymbol_v2){

                        ((ISymbol_v2)fill).draw(g, affineTransform, geom, f, cancel, r);

                    } else {

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

                    }

                }                        

            }else if (geometryType.isTypeOf(Geometry.TYPES.AGGREGATE)){

                Aggregate aggregate = (Aggregate)geom;

                for (int i=0 ; i<aggregate.getPrimitivesNumber() ; i++){

                    draw(g, affineTransform, aggregate.getPrimitiveAt(i), f, cancel, r);

                }

            }

        }

//    @Override

//        public boolean isOneDotOrPixel(Geometry geom,

//                        double[] positionOfDotOrPixel, ViewPort viewPort, int dpi) {

//                

//        GeometryType geomType = geom.getGeometryType();

//        if( geomType.isSubTypeOf(Geometry.TYPES.POINT) ) {

//                   if (marker != null) {

//                                return marker.isOneDotOrPixel(geom, positionOfDotOrPixel, viewPort, dpi);

//                        }

//

//        } else if( geomType.isSubTypeOf(Geometry.TYPES.CURVE) ) {

//            if (line != null) {

//                return line.isOneDotOrPixel(geom, positionOfDotOrPixel, viewPort, dpi);

//                        }

//            

//        } else if( geomType.isSubTypeOf(Geometry.TYPES.SURFACE) ) {

//                        if (fill != null) {

//                                return fill.isOneDotOrPixel(geom, positionOfDotOrPixel, viewPort, dpi);

//                        }

//            

//        }

//                if (!geom.isSimple()){

//                        Aggregate aggregate = (Aggregate)geom;                        

//                        for (int i=0 ; i<aggregate.getPrimitivesNumber() ; i++){

//                                if (!isOneDotOrPixel(aggregate.getPrimitiveAt(i), positionOfDotOrPixel, viewPort, dpi)){

//                                        return false;

//                                }

//                        }

//                        return true;

//                }

//                return true;

//        }

//        @Override

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

//                        ViewPort viewPort, int dpi) {

//                // TODO Implement it

//                throw new Error("Not yet implemented!");

//

//        }

//        @Override

//        public int getOnePointRgb() {

//                // will return a mixture of all symbol's getOnePointRgb() value

//

//                int rMarker = 0;

//                int gMarker = 0;

//                int bMarker = 0;

//                int aMarker = 0;

//

//                if (marker!=null && marker.getColor() != null) {

//                        rMarker = marker.getColor().getRed();

//                        gMarker = marker.getColor().getGreen();

//                        bMarker = marker.getColor().getBlue();

//                        aMarker = marker.getColor().getAlpha();

//                }

//

//                int rLine = 0;

//                int gLine = 0;

//                int bLine = 0;

//                int aLine = 0;

//

//                if (line != null  && line.getColor() != null) {

//                        rLine = line.getColor().getRed();

//                        gLine = line.getColor().getGreen();

//                        bLine = line.getColor().getBlue();

//                        aLine = line.getColor().getAlpha();

//                }

//

//                int rFill = 0;

//                int gFill = 0;

//                int bFill = 0;

//                int aFill = 0;

//

//                if (fill != null ) {

//                        Color colorOfFill = null;

//                        if (fill.getOutline()!=null) {

//                                colorOfFill = fill.getOutline().getColor();

//                        } else if (fill.getFillColor()!=null) {

//                                colorOfFill = fill.getFillColor();

//                        }

//                        if (colorOfFill != null) {

//                                rFill = colorOfFill.getRed();

//                                gFill = colorOfFill.getGreen();

//                                bFill = colorOfFill.getBlue();

//                                aFill = colorOfFill.getAlpha();

//

//                        }

//                }

//

//                int red = (rMarker + rLine + rFill) / 3;

//                int green = (gMarker + gLine + gFill) / 3;

//                int blue = (bMarker + bLine + bFill) / 3;

//                int alpha = (aMarker + aLine + aFill) / 3;

//

//                return (alpha) << 24 + (red << 16) + (green << 8) + blue;

//        }

        @Override

        public boolean isShapeVisible() {

                if (marker!=null) {

                        return marker.isShapeVisible();

                }

                if (line != null) {

                        return line.isShapeVisible();

                }

                if (fill != null) {

                        fill.isShapeVisible();

                }

                return false;

        }

        @Override

        public int getSymbolType() {

                return Geometry.TYPES.GEOMETRY;

        }

        @Override

        public boolean isSuitableFor(Geometry geom) {

                // suitable for everything (why else does it exist?)

                return true;

        }

    @Override

        public double getRotation() {

                if (marker != null) {

                        return marker.getRotation();

                }

                return 0;

        }

        @Override

        public void setRotation(double rotation) {

                if (marker != null) {

                        marker.setRotation(rotation);

                }

        }

        @Override

        public Point2D getOffset() {

                if (marker != null) {

                        return marker.getOffset();

                }

                return new Point2D.Double();

        }

        @Override

        public void setOffset(Point2D offset) {

                if (marker != null) {

                        marker.setOffset(offset);

                }

        }

        @Override

        public double getSize() {

                if (marker != null) {

                        return marker.getSize();

                }

                return 0;

        }

        @Override

        public void setSize(double size) {

                if (marker != null) {

                        marker.setSize(size);

                }

        }

        @Override

        public Color getColor() {

                if (marker != null) {

                        return marker.getColor();

                }

                return null;

        }

        @Override

        public void setColor(Color color) {

                if (marker != null) {

                        marker.setColor(color);

                }

        }

        @Override

        public void setFillColor(Color color) {

                if (fill != null) {

                        fill.setFillColor(color);

                }

        }

        @Override

        public void setOutline(ILineSymbol outline) {

                if (fill != null) {

                        fill.setOutline(outline);

                }

        }

        @Override

        public Color getFillColor() {

                if (fill != null) {

                        return fill.getFillColor();

                }

                return null;

        }

        @Override

        public ILineSymbol getOutline() {

                if (fill != null) {

                        return fill.getOutline();

                }

                return null;

        }

        @Override

        public int getFillAlpha() {

                if (fill != null) {

                        return fill.getFillAlpha();

                }

                return 255;

        }

        @Override

        public IMask getMask() {

                return mask;

        }

        @Override

        public void setUnit(int unitIndex) {

                if (marker != null) {

                        marker.setUnit(unitIndex);

                }

                if (line != null) {

                        line.setUnit(unitIndex);

                }

        }

    @Override

        public int getUnit() {

                if (marker != null) {

                        return marker.getUnit();

                }

                if (line != null) {

                        return line.getUnit();

                }

                return -1;

        }

    @Override

        public void setMask(IMask mask) {

                throw new NotYetImplemented();

        }

    @Override

        public int getReferenceSystem() {

                return this.referenceSystem;

        }

    @Override

        public void setReferenceSystem(int system) {

                this.referenceSystem = system;

        }

    @Override

        public IMarkerSymbol getMarkerSymbol() {

                return marker;

        }

    @Override

        public ILineSymbol getLineSymbol() {

                return line;

        }

    @Override

        public IFillSymbol getFillSymbol() {

                return fill;

        }

    @Override

        public void setMarkerSymbol(IMarkerSymbol markerSymbol) {

                this.marker = markerSymbol;

        }

    @Override

        public void setLineSymbol(ILineSymbol lineSymbol) {

                this.line = lineSymbol;

        }

    @Override

        public void setFillSymbol(IFillSymbol fillFillSymbol) {

                this.fill = fillFillSymbol;

        }

    @Override

        public boolean hasFill() {

        if (fill == null) {

                return false;

        }

        return fill.hasFill();

        }

    @Override

        public void setHasFill(boolean hasFill) {

                if (fill != null) {

                        fill.setHasFill(hasFill);

                }

        }

    @Override

        public boolean hasOutline() {

                return false;

        }

    @Override

        public void setHasOutline(boolean hasOutline) {

        }

    @Override

        public Object clone() throws CloneNotSupportedException {

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

                // Clone inner symbols

                if (marker != null) {

                        copy.marker = (IMarkerSymbol) marker.clone();

                }

                if (line != null) {

                        copy.line = (ILineSymbol) line.clone();

                }

                if (fill != null) {

                        copy.fill = (IFillSymbol) fill.clone();

                }

                if (mask != null) {

                        copy.mask = (IMask) mask.clone();

                }

                // Clone selection symbol

                if (symSelect != null) {

                        copy.symSelect = (MultiShapeSymbol) symSelect.clone();

                }

                return copy;

        }

    @Override

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                setDescription(state.getString(FIELD_DESCRIPTION));

                setFillSymbol((IFillSymbol) state.get(FIELD_FILL));

                setMarkerSymbol((IMarkerSymbol) state.get(FIELD_MARKER));

                setLineSymbol((ILineSymbol) state.get(FIELD_LINE));

        }

    @Override

        public void saveToState(PersistentState state) throws PersistenceException {

                state.set(FIELD_DESCRIPTION, getDescription());

                state.set(FIELD_FILL, getFillSymbol());

                state.set(FIELD_MARKER, getMarkerSymbol());

                state.set(FIELD_LINE, getLineSymbol());

        }

        public static class RegisterPersistence implements Callable {

        @Override

                public Object call() throws Exception {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

                                DynStruct definition = manager.addDefinition(

                                                MultiShapeSymbol.class,

                                                MULTI_SHAPE_SYMBOL_PERSISTENCE_DEFINITION_NAME,

                                                MULTI_SHAPE_SYMBOL_PERSISTENCE_DEFINITION_NAME+" Persistence definition",

                                                null, 

                                                null

                                );

                                // Description

                                definition.addDynFieldString(FIELD_DESCRIPTION).setMandatory(false);

                                // Fill symbol

                                definition.addDynFieldObject(FIELD_FILL).setClassOfValue(IFillSymbol.class).setMandatory(true);

                                // Line symbol

                                definition.addDynFieldObject(FIELD_LINE).setClassOfValue(ILineSymbol.class).setMandatory(true);

                                // Marker symbol

                                definition.addDynFieldObject(FIELD_MARKER).setClassOfValue(IMarkerSymbol.class).setMandatory(true);

                        }

                        return Boolean.TRUE;

                }

        }

        public static class RegisterSymbol implements Callable {

        @Override

                public Object call() throws Exception {

                int[] shapeTypes;

                SymbolManager manager = MapContextLocator.getSymbolManager();

                shapeTypes = new int[] { Geometry.TYPES.GEOMETRY };

                manager.registerSymbol(MultiShapeSymbol.SYMBOL_NAME,

                    shapeTypes,

                    MultiShapeSymbol.class

                );

                        return Boolean.TRUE;

                }

        }

}