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.rendering.symbols.CartographicSupport;

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

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

        if (r != null) {

            double myWidth = (r.getWidth() / 3);

            Rectangle rect = new Rectangle(0, 0, (int) myWidth, r.height);

            if (marker != null) {

                CartographicSupport.copyCartographicContext(this, marker);

                g.translate(r.x, r.y);

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

                g.translate(-(r.x), -(r.y));

            }

            if (line != null) {

                CartographicSupport.copyCartographicContext(this, line);

                g.translate(r.x + myWidth, r.y);

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

                g.translate(-(r.x + myWidth), -(r.y));

            }

            if (fill != null) {

                CartographicSupport.copyCartographicContext(this, fill);

                g.translate(r.x + myWidth + myWidth, r.y);

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

                g.translate(-(r.x + myWidth + myWidth), -(r.y));

            }

        } else {

            GeometryType geometryType = geom.getGeometryType();

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

                if (marker != null) {

                    CartographicSupport.copyCartographicContext(this, marker);

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

                }

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

                if (line != null) {

                    CartographicSupport.copyCartographicContext(this, line);

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

                }

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

                if (fill != null) {

                    CartographicSupport.copyCartographicContext(this, fill);

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

                }

            } 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 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;

        }

    }

}