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

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

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

import org.gvsig.fmap.geom.Geometry;

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

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

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.marker.IMarkerSymbol;

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

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;

/**

 * SimpleMarkerSymbol is the most basic symbol for the representation of point objects

 * which can define its size and color apart from the rotation and the offset from a point

 * in the map.

 * @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 SimpleMarkerSymbol extends AbstractMarkerSymbol implements ISimpleMarkerSymbol {

        public static final String SIMPLE_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME = "SimpleMarkerSymbol";

        private static final String FIELD_OUTLINED = "outlined";

        private static final String FIELD_OUTLINECOLOR = "outlineColor";

        private static final String FIELD_OUTLINESIZE = "outlineSize";

        private static final String FIELD_MARKERSTYLE = "markerStyle";

        private boolean outlined;

        private Color outlineColor;

        private double outlineSize;

        private ISymbol selectionSymbol;

        private int markerStyle;

        public SimpleMarkerSymbol() {

                super();

        }

        @Override

        public ISymbol getSymbolForSelection(Color selectionColor) {

                if (selectionSymbol == null) {

                        selectionSymbol = (SimpleMarkerSymbol) cloneForSelection();

                } 

        selectionSymbol.setColor(selectionColor);

        if(selectionSymbol instanceof CartographicSupport){

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

        }

                return selectionSymbol;

        }

    @Override

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

        double size_d = getCartographicSize();

        size_d = this.getAdjustedSize(r, size_d);

        int size_i = (int) Math.round(size_d);

        if(r!=null){

            geom = this.getSampleGeometry(r);

        }

        int x = 0;

        int y = 0;

        Point p;

        try {

            p = geom.centroid();

        } catch (Exception ex) {

            return;

        }

        p.transform(affineTransform);

        int halfSize = size_i / 2;

        int posX = (int) (p.getX() + getOffset().getX()) - halfSize;

        int posY = (int) (p.getY() + getOffset().getY()) - halfSize;

        g.translate(posX, posY);

        if (getRotation() != 0.0) {

            g.rotate(getRotation());

        }

        g.setColor(getColor());

        GeneralPathX genPath = null;

        g.setStroke(new BasicStroke(1));

        switch (markerStyle) {

            case CIRCLE_STYLE:

                g.fillOval(x, y, size_i, size_i);

                break;

            case SQUARE_STYLE:

                g.fillRect(x, y, size_i, size_i);

                break;

            case CROSS_STYLE:

                x = x + halfSize;

                y = y + halfSize;

                genPath = new GeneralPathX();

                genPath.moveTo(x, y - halfSize);

                genPath.lineTo(x, y + halfSize);

                genPath.moveTo(x - halfSize, y);

                genPath.lineTo(x + halfSize, y);

                g.draw(genPath);

                break;

            case VERTICAL_LINE_STYLE:

                genPath = new GeneralPathX();

                genPath.moveTo(x + halfSize, y);

                genPath.lineTo(x + halfSize, y + size_i);

                g.draw(genPath);

                break;

            case HORIZONTAL_LINE_STYLE:

                genPath = new GeneralPathX();

                genPath.moveTo(x, y + halfSize);

                genPath.lineTo(x + size_i, y + halfSize);

                g.draw(genPath);

                break;

            case DIAMOND_STYLE:

                x = x + halfSize;

                y = y + halfSize;

                genPath = new GeneralPathX();

                genPath.moveTo(x - halfSize, y);

                genPath.lineTo(x, y + halfSize);

                genPath.lineTo(x + halfSize, y);

                genPath.lineTo(x, y - halfSize);

                genPath.lineTo(x - halfSize, y);

                genPath.closePath();

                g.fill(genPath);

                break;

            case X_STYLE:

                x = x + halfSize;

                y = y + halfSize;

                genPath = new GeneralPathX();

                genPath.moveTo(x - halfSize, y - halfSize);

                genPath.lineTo(x + halfSize, y + halfSize);

                genPath.moveTo(x - halfSize, y + halfSize);

                genPath.lineTo(x + halfSize, y - halfSize);

                g.draw(genPath);

                break;

            case TRIANGLE_STYLE:

                x = x + halfSize;

                y = y + halfSize;

                int otherSize = (int) (size_i * 0.55);

                genPath = new GeneralPathX();

                genPath.moveTo(x - halfSize,

                        y + halfSize);

                genPath.lineTo(x + halfSize,

                        y + halfSize);

                genPath.lineTo(x, y - otherSize);

                genPath.closePath();

                g.fill(genPath);

                break;

            case STAR_STYLE:

                x = x + halfSize;

                y = y + halfSize;

                genPath = new GeneralPathX();

                genPath.moveTo(x - halfSize, y);

                genPath.lineTo(x - 2 * (halfSize / 3), y + (halfSize / 3));

                genPath.lineTo(x - 2 * (halfSize / 3), y + 2 * (halfSize / 3));

                genPath.lineTo(x - (halfSize / 3), y + 2 * (halfSize / 3));

                genPath.lineTo(x, y + halfSize);

                genPath.lineTo(x + (halfSize / 3), y + 2 * (halfSize / 3));

                genPath.lineTo(x + 2 * (halfSize / 3), y + 2 * (halfSize / 3));

                genPath.lineTo(x + 2 * (halfSize / 3), y + (halfSize / 3));

                genPath.lineTo(x + (halfSize), y);

                genPath.lineTo(x + 2 * (halfSize / 3), y - (halfSize / 3));

                genPath.lineTo(x + 2 * (halfSize / 3), y - 2 * (halfSize / 3));

                genPath.lineTo(x + (halfSize / 3), y - 2 * (halfSize / 3));

                genPath.lineTo(x, y - halfSize);

                genPath.lineTo(x - (halfSize / 3), y - 2 * (halfSize / 3));

                genPath.lineTo(x - 2 * (halfSize / 3), y - 2 * (halfSize / 3));

                genPath.lineTo(x - 2 * (halfSize / 3), y - (halfSize / 3));

                genPath.lineTo(x - halfSize, y);

                genPath.closePath();

                g.fill(genPath);

                break;

        }

        if (outlined) {

            g.setColor(outlineColor);

            switch (markerStyle) {

                case CIRCLE_STYLE:

                    g.drawOval(x, y, size_i, size_i);

                    break;

                case SQUARE_STYLE:

                    g.drawRect(x, y, size_i, size_i);

                    break;

                case CROSS_STYLE:

                case DIAMOND_STYLE:

                case STAR_STYLE:

                case X_STYLE:

                case TRIANGLE_STYLE:

                case VERTICAL_LINE_STYLE:

                case HORIZONTAL_LINE_STYLE:

                    g.draw(genPath);

                    break;

            }

        }

        if (getRotation() != 0.0) {

            g.rotate(-getRotation());

        }

        g.translate(-posX, -posY);

    }

        /**

         * Returns true or false depending if the simple marker symbol has an outline or not.

         * @return Returns the outline.

         */

        @Override

        public boolean hasOutline() {

                return outlined;

        }

        /**

         * Establishes the outline for the simple marker symbol.

         * @param outline  The outline to set.

         */

        @Override

        public void setOutlined(boolean outlined) {

                this.outlined = outlined;

        }

        /**

         * Returns the outline color for the symple marker symbol

         *

         * @return Color,outlineColor.

         */

        @Override

        public Color getOutlineColor() {

                return outlineColor;

        }

        /**

         * Sets the outline color for the simple marker symbol

         * @param outlineColor, Color

         */

        @Override

        public void setOutlineColor(Color outlineColor) {

                this.outlineColor = outlineColor;

        }

        /**

         * Gets the size of the outline for the simple marker symbol

         * @return  Returns the outlineSize.

         */

        @Override

        public double getOutlineSize() {

                return outlineSize;

        }

        /**

         * Establishes the size for the outline of the simple marker symbol

         * @param outlineSize  The outlineSize to set.

         */

        @Override

        public void setOutlineSize(double outlineSize) {

                this.outlineSize = outlineSize;

        }

        /**

         * @return  Returns the selectionSymbol.

         */

        @Override

        public ISymbol getSelectionSymbol() {

                return selectionSymbol;

        }

        /**

         * @param selectionSymbol  The selectionSymbol to set.

         */

        @Override

        public void setSelectionSymbol(ISymbol selectionSymbol) {

                this.selectionSymbol = selectionSymbol;

        }

        /**

         * Sets the style for the simple marker symbol

         * @param style

         */

        @Override

        public void setStyle(int style) {

                this.markerStyle = style;

        }

        /**

         * Obtains the style for the simple marker symbol

         * @return markerStyle,int

         */

        @Override

        public int getStyle() {

                return markerStyle;

        }

        @Override

        public Object clone() throws CloneNotSupportedException {

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

                // clone selection

                if (selectionSymbol != null) {

                        copy.selectionSymbol = (ISymbol) selectionSymbol.clone();

                }

                return copy;

        }

        /**

         * Returns if the marker symbol should be drawn outlined.

         * @return if it is outlined

         */

        @Override

        public boolean isOutlined() {

                return outlined;

        }

        @Override

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                // Set parent fill symbol properties

                super.loadFromState(state);

                // Set own properties

                setStyle(state.getInt(FIELD_MARKERSTYLE));

                setOutlined(state.getBoolean(FIELD_OUTLINED));

                if (isOutlined()) {

                        setOutlineColor((Color) state.get(FIELD_OUTLINECOLOR));

                        setOutlineSize(state.getDouble(FIELD_OUTLINESIZE));

                }

        }

        @Override

        public void saveToState(PersistentState state) throws PersistenceException {

                // Save parent fill symbol properties

                super.saveToState(state);

                // Save own properties

                state.set(FIELD_MARKERSTYLE, getStyle());

                state.set(FIELD_OUTLINED, isOutlined());

                if (isOutlined()) {

                        state.set(FIELD_OUTLINECOLOR, getOutlineColor());

                        state.set(FIELD_OUTLINESIZE, getOutlineSize());

                }

        }

        public static class RegisterPersistence implements Callable {

                @Override

                public Object call() throws Exception {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

                                DynStruct definition = manager.addDefinition(

                                                SimpleMarkerSymbol.class,

                                                SIMPLE_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME,

                                                SIMPLE_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME+" Persistence definition",

                                                null,

                                                null

                                );

                                // Extend the FillSymbol base definition

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

                                // Marker style

                                definition.addDynFieldInt(FIELD_MARKERSTYLE).setMandatory(true);

                                // Outlined?

                                definition.addDynFieldBoolean(FIELD_OUTLINED).setMandatory(true);

                                // Outline color

                                definition.addDynFieldObject(FIELD_OUTLINECOLOR).setClassOfValue(Color.class);

                                // Outline size

                                definition.addDynFieldDouble(FIELD_OUTLINESIZE);

                        }

                        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.POINT, Geometry.TYPES.MULTIPOINT };

                manager.registerSymbol(IMarkerSymbol.SYMBOL_NAME,

                    shapeTypes,

                    SimpleMarkerSymbol.class);

                        return Boolean.TRUE;

                }

        }

}