Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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 2

 * 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.

 * 

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl;

import java.awt.Rectangle;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContext;

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

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.util.Callable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Abstract class that implements the interface the interface for symbols.It is

 * considered as the father of all XXXSymbols and will implement all the methods

 * that these classes had not developed (and correspond with one of the methods

 * of AbstractSymbol class)

 * 

 * @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 abstract class AbstractSymbol implements ISymbol, CartographicSupport {

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

        public static final String SYMBOL_PERSISTENCE_DEFINITION_NAME = "Symbol";

        private static final String FIELD_UNIT = "unit";

        private static final String FIELD_REFERENCE_SYSTEM = "referenceSystem";

        private static final String FIELD_IS_SHAPE_VISIBLE = "isShapeVisible";

        private static final String FIELD_DESCRIPTION = "description";

        private String desc;

        private int unit;

        private int referenceSystem;

        private boolean isShapeVisible = true;

        public AbstractSymbol() {

                super();

                SymbolPreferences preferences =

                                MapContextLocator.getSymbolManager().getSymbolPreferences();

                unit =

                                preferences.getDefaultCartographicSupportMeasureUnit();

                referenceSystem =

                                preferences.getDefaultCartographicSupportReferenceSystem();

        }

        public final void setDescription(String desc) {

                this.desc = desc;

        }

        public final String getDescription() {

                return desc;

        }

        /**

         * @return

         * @uml.property name="isShapeVisible"

         */

        public final boolean isShapeVisible() {

                return isShapeVisible;

        }

        /**

         * Sets this symbol to visible

         * 

         * @param isShapeVisible

         */

        public final void setIsShapeVisible(boolean isShapeVisible) {

                this.isShapeVisible = isShapeVisible;

        }

        public void setUnit(int unitIndex) {

                this.unit = unitIndex;

        }

        public int getUnit() {

                return this.unit;

        }

        public int getReferenceSystem() {

                return this.referenceSystem;

        }

        public void setReferenceSystem(int system) {

                this.referenceSystem = system;

        }

        public boolean equals(Object obj) {

                if (!obj.getClass().equals(getClass())) {

                        return false;

                }

                if (((ISymbol) obj).getOnePointRgb() != getOnePointRgb()) {

                        return false;

                }

                if (getDescription() != null

                                && ((ISymbol) obj).getDescription() != null) {

                        if (!((ISymbol) obj).getDescription().equals(getDescription())) {

                                return false;

                        }

                }

                return true;

        }

        public boolean isOneDotOrPixel(Geometry geom,

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

                int type = geom.getType();

                switch (type) {

                case Geometry.TYPES.NULL:

                case Geometry.TYPES.POINT:

                case Geometry.TYPES.MULTIPOINT:

                        return false;

                default:

                        org.gvsig.fmap.geom.primitive.Envelope geomBounds = geom

                        .getEnvelope();

                        double dist1Pixel = viewPort.getDist1pixel();

                        float[] distances = new float[2];

                        this.getPixExtentPlus(geom, distances, viewPort, dpi);

                        boolean onePoint =

                                        (geomBounds.getLength(0) + distances[0] <= dist1Pixel && geomBounds

                                        .getLength(1)

                                        + distances[1] <= dist1Pixel);

                        if (onePoint) {

                                Rectangle bounds = geom.getBounds();

                                positionOfDotOrPixel[0] = bounds.x;

                                positionOfDotOrPixel[1] = bounds.y;

                        }

                        return onePoint;

                }

        }

        public Object clone() throws CloneNotSupportedException {

                return super.clone();        

        }

        protected ISymbol cloneForSelection() {

                try {

                        ISymbol selectionSymbol = (ISymbol) clone();

                        selectionSymbol.setColor(MapContext.getSelectionColor());

                        if (getDescription() != null){

                                selectionSymbol.setDescription(getDescription().concat(

                                " version for selection"));

                        }else{

                                selectionSymbol.setDescription("version for selection");

                        }

                        return selectionSymbol;

                } catch (CloneNotSupportedException e) {

                        LOG.error(

                                        "Error creating the selection symbol for the symbol "

                                        + this, e);

                }

                return null;

        }

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                setDescription(state.getString(FIELD_DESCRIPTION));

                setIsShapeVisible(state.getBoolean(FIELD_IS_SHAPE_VISIBLE));

                setReferenceSystem(state.getInt(FIELD_REFERENCE_SYSTEM));

                setUnit(state.getInt(FIELD_UNIT));

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                state.set(FIELD_DESCRIPTION, getDescription());

                state.set(FIELD_IS_SHAPE_VISIBLE, isShapeVisible());

                state.set(FIELD_REFERENCE_SYSTEM, getReferenceSystem());

                state.set(FIELD_UNIT, getUnit());

        }

        public static class RegisterPersistence implements Callable {

                public Object call() throws Exception {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

                                DynStruct definition = manager.addDefinition(

                                                AbstractSymbol.class, 

                                                SYMBOL_PERSISTENCE_DEFINITION_NAME, 

                                                SYMBOL_PERSISTENCE_DEFINITION_NAME+" persistence definition", 

                                                null, 

                                                null

                                );

                                // Description

                                definition.addDynFieldString(FIELD_DESCRIPTION);

                                // Is Shape Visible

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

                                // Reference system

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

                                // Unit

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

                        }

                        return Boolean.TRUE;

                }

        }

}