Application: gvSIG desktop

		// Default back color

		jccDefaultViewBackColor.setColor(DefaultViewPanel.getDefaultBackColor());

		/*

		 * Locator's background color, for when we let it be possible

		 * // Default map overview back color

		// Default selection color

		jccDefaultSelectionColor.setColor(DefaultProject.getDefaultSelectionColor());

		String[] distanceNames=MapContext.getDistanceNames();

		// Map units

		if (DefaultProject.getDefaultMapUnits()<=distanceNames.length && distanceNames.length != jCmbMapUnits.getItemCount()){

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

 */

public class CharacterMarkerSymbol implements IMarkerSymbol {

	private static Logger logger =

			LoggerFactory.getLogger(CharacterMarkerSymbol.class);

	public static final String CHARACTER_MARKER_SYMBOL_PERSISTENCE_NAME =

			"CHARACTER_MARKER_SYMBOL_PERSISTENCE_NAME";

	private Font font = new Font("Arial", Font.PLAIN, 20);

	private int unicode;

	private ISymbol selectionSymbol;

	private VisualCorrection visualCorrection;

	private double size;

	private boolean isShapeVisible = true;

	private String desc = "";

	private IMask mask;

	private int unit = -1;

	private int referenceSystem = CartographicSupport.WORLD;

	private int alpha = 255;

	private Point2D offset = new Point2D.Double();

	/*

	 */

	private double rotation_radians = 0;

	private Color color = Color.BLACK;

	private static GeometryManager geoman = GeometryLocator.getGeometryManager();

	/**

		if (selectionSymbol == null) {

			selectionSymbol = (ISymbol) LabelClassUtils.clone(this);

			selectionSymbol.setColor(MapContext.getSelectionColor());

		}

		return selectionSymbol;

	}

	public void draw(Graphics2D g,

			AffineTransform affineTransform, Geometry geom,

			Feature feat, Cancellable cancel) {

		g.setColor(getColor());

		double theta = getRotation();

		if (size < 0.0001) {

			return;

		}

		org.gvsig.fmap.geom.primitive.Point cen = null;

		try {

			cen = geom.centroid();

		} catch (Exception e) {

			logger.error("While getting centroid", e);

		}

		Point2D p = new Point2D.Double(cen.getX(), cen.getY());

		if (isVisuallyCorrected()) {

	/**

	 * Sets the unicode for a symbol represented by a character

	 * @param symbol, int

					}

				}

			}

			int realWidth = bi.getWidth() - realRight-realLeft;

			int realHeight = bi.getHeight() - realBottom - realTop;

			visualCorrection = new VisualCorrection();

			if (realBottom!=-1 && realTop!=-1 && realLeft!=-1 && realRight != -1) {

				double correctingSize = Math.max(realHeight, realWidth);

				visualCorrection.sizeScale = clone.getSize() / correctingSize;

			visualCorrection = null;

		}

	}

	public Object clone() throws CloneNotSupportedException {

		return LabelClassUtils.clone(this);

	}

	public void getPixExtentPlus(

			Geometry geom, float[] distances,

			ViewPort viewPort, int dpi) {

		float cs = (float) getCartographicSize(viewPort, dpi, geom);

		distances[0] = cs;

		distances[1] = cs;

			return onePoint;

		}

	}

	public int getOnePointRgb() {

		return this.getColor().getRGB();

	}

	public void drawInsideRectangle(Graphics2D g,

			AffineTransform scaleInstance, Rectangle r,

			PrintAttributes properties) throws SymbolDrawingException {

		org.gvsig.fmap.geom.primitive.Point center = null;

		try {

			center = geoman.createPoint(

			print(g, scaleInstance, center, properties);

			setSize(originalSize);

		}

	}

		}

		*/

	}

	public void setUnit(int unitIndex) {

	public double toCartographicSize(ViewPort viewPort, double dpi,

			Geometry geom) {

		double oldSize = getSize();

		setCartographicSize(getCartographicSize(viewPort, dpi, geom), geom);

		return oldSize;	}

	public double getCartographicSize(ViewPort viewPort, double dpi,

			Geometry geom) {

		return SymbolUtils.getCartographicLength(this,

									  getSize(),

									  viewPort,

	public void setMask(IMask m) {

		mask = m;

	}

	// =========================================

	public void loadFromState(PersistentState state) throws PersistenceException {

		if (state.hasValue("vc_xOffsetScale")) {

			this.visualCorrection = new VisualCorrection();

			this.visualCorrection.xOffsetScale = state.getDouble("vc_xOffsetScale");

		// ==============================================

		this.color = (Color) state.get("color");

		this.font = (Font) state.get("font");

		double aux = state.getDouble("size");

		this.setSize(aux);

		this.unicode = state.getInt("unicode");

		this.desc = state.getString("desc");

		this.isShapeVisible = state.getBoolean("isShapeVisible");

		double x = state.getDouble("xOffset");

		double y = state.getDouble("yOffset");

		this.offset = new Point2D.Double(x, y);

		this.rotation_radians = state.getDouble("rotation");

		this.unit = state.getInt("unit");

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		if (this.visualCorrection != null) {

			state.set("vc_xOffsetScale", this.visualCorrection.xOffsetScale);

			state.set("vc_yOffsetScale", this.visualCorrection.yOffsetScale);

		state.set("yOffset", this.offset.getY());

		state.set("rotation", this.rotation_radians);

		state.set("unit", this.unit);

	}

	public static void registerPersistent() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

			DynStruct definition = manager.addDefinition(

					CharacterMarkerSymbol.class,

					CHARACTER_MARKER_SYMBOL_PERSISTENCE_NAME,

					CHARACTER_MARKER_SYMBOL_PERSISTENCE_NAME+" Persistence definition",

					null

			);

			definition.addDynFieldObject("color").setClassOfValue(Color.class).setMandatory(true);

			definition.addDynFieldObject("font").setClassOfValue(Font.class).setMandatory(true);

			definition.addDynFieldDouble("size").setMandatory(true);

			definition.addDynFieldDouble("vc_xOffsetScale").setMandatory(false);

			definition.addDynFieldDouble("vc_yOffsetScale").setMandatory(false);

			definition.addDynFieldDouble("vc_sizeScale").setMandatory(false);

	}

		double yOffsetScale = 1;

		double sizeScale = 1;

	}

}

    public static final String MULTILAYER_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME = "MultiLayerFillSymbol";

    private static final String FIELD_LAYERS = "layers";

	private static final double OPACITY_SELECTION_FACTOR = .8;

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

	private MultiLayerFillSymbol selectionSymbol;

	public ISymbol getSymbolForSelection() {

	    // TODO: revisar

		    	    new MultiLayerFillSymbol();

			selectionSymbol.setDescription(getDescription());

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

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

			}

			setSymbolForSelection(selectionSymbol);

		return selectionSymbol;

	}

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

		return contains;

	}

	public void setUnit(int unitIndex) {

		super.setUnit(unitIndex);

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

		}

		return size;

	}

	public Object clone() throws CloneNotSupportedException {

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

						MultiLayerFillSymbol.class,

						MULTILAYER_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME,

						MULTILAYER_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME+" Persistence definition",

						null

				);

			}

			return Boolean.TRUE;

		}

	}

	public static class RegisterSymbol implements Callable {

			return Boolean.TRUE;

		}

	}

}

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

				selectionSymbol.setHasFill(true);

				setSymbolForSelection(selectionSymbol);

			}

		}

		return symbolForSelection;

	}

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

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

	private void draw(Graphics2D g, AffineTransform affineTransform, Geometry geom, Cancellable cancel) {

 		Color fillColor = getFillColor();

 		Shape transf_geom = geom.getShape(affineTransform);

		if (fillColor != null) {

			g.setColor(fillColor);

			g.fill(transf_geom);

			g.setPaint(resulPatternFill);

		}

		if (angle == 0) {

		    g.fill(transf_geom);

		} else {

		    Geometry pixels_geom = geom.cloneGeometry();

		    pixels_geom.transform(affineTransform);

		    pixels_geom.transform(at);

		    g.rotate(-angle);

		    g.fill(pixels_geom.getShape());

		    g.rotate(angle);

			selectionSym = (PictureFillSymbol) cloneForSelection();

			selectionSym.selected=true;

			selectionSym.selectionSym = selectionSym; // avoid too much lazy creations

		}

		return selectionSym;

		return null;

	}

	@Override

	public double toCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

		return super.toCartographicSize(viewPort, dpi, geom);

	public void draw(Graphics2D g, AffineTransform affineTransform,

			Geometry geom, Feature f, Cancellable cancel) {

		draw(g, affineTransform, geom, cancel);

	}

    public Object clone() throws CloneNotSupportedException {

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

        }

        // FIXME: clone properties

        return copy;

    }

        this.bgSelImage =

            (BackgroundFileStyle) state.get(BACKGROUND_SELECTION_IMAGE);

        this.angle = (Double) state.get(ANGLE);

        this.xScale = (Double) state.get(X_SCALE);

        this.yScale = (Double) state.get(Y_SCALE);

        this.markerFillProperties = (IMarkerFillPropertiesStyle) state.get(MARKER_FILL_PROPERTIES);

    }

    public void saveToState(PersistentState state) throws PersistenceException {

		public Object call() throws Exception {

	        SymbolManager manager = MapContextLocator.getSymbolManager();

	        manager.registerSymbol(PICTURE_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME,

	            PictureFillSymbol.class);

			return Boolean.TRUE;

		}

	}

	public IBackgroundFileStyle getBackgroundFileStyle() {

 */

public class MarkerFillSymbol extends AbstractFillSymbol implements IMarkerFillSymbol {

	private static final Logger logger = LoggerFactory.getLogger(MarkerFillSymbol.class);

    public static final String MARK_FILL_SYMBOL_PERSISTENCE_DEFINITION_NAME =

        "MarkerFillSymbol";

    private static final String MARKER_SYMBOL = "markerSymbol";

		if (selectionSymbol == null) {

			selectionSymbol = (MarkerFillSymbol) cloneForSelection();

			selectionSymbol.setFillColor(MapContext.getSelectionColor());

		return selectionSymbol;

	}

	}

	public void setCartographicSize(double cartographicSize, Geometry geom) {

		super.setCartographicSize(cartographicSize, geom);

		IMarkerSymbol marker = getMarker();

		if (marker!=null) {

				marker.setCartographicSize(previousMarkerSize, geom);

			}

		super.setCartographicSize(cartographicSize, geom);

	}

		}

		double s = super.toCartographicSize(viewPort, dpi, geom);

		return s;

	}

    public Object clone() throws CloneNotSupportedException {

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

        }

        // FIXME: clone properties

        return copy;

    }

		public Object call() throws Exception {

	        int[] shapeTypes;

	        SymbolManager manager = MapContextLocator.getSymbolManager();

	        shapeTypes =

	            new int[] { Geometry.TYPES.SURFACE, Geometry.TYPES.CIRCLE,

	                Geometry.TYPES.ELLIPSE, Geometry.TYPES.MULTISURFACE };

	        manager.registerMultiLayerSymbol(IFillSymbol.SYMBOL_NAME,

	            shapeTypes,

	            MarkerFillSymbol.class);

			return Boolean.TRUE;

		}

	}

		ILineSymbol, IMultiLayerSymbol, IMultiLayerLineSymbol {

    public static final String MULTILAYER_LINE_SYMBOL_PERSISTENCE_DEFINITION_NAME = "MultiLayerLineSymbol";

    private static final String FIELD_LAYERS = "layers";

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

	private MultiLayerLineSymbol selectionSymbol;

	// Cached greatest line width from all the layers

	private double lineWidth;

	public MultiLayerLineSymbol() {

		super();

	}

	public Color getColor() {

		/*

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

//	return myLineWidth;

//    }

	if (width > 0 && width != lineWidth) {

	    this.lineWidth = width;

	    double scaleFactor = width / lineWidth;

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

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

			}

		return selectionSymbol;

	}

		// Save own properties

		state.set(FIELD_LAYERS, layers);

	}

	public static class RegisterPersistence implements Callable {

		public Object call() throws Exception {

						MultiLayerLineSymbol.class,

						MULTILAYER_LINE_SYMBOL_PERSISTENCE_DEFINITION_NAME,

						MULTILAYER_LINE_SYMBOL_PERSISTENCE_DEFINITION_NAME+" Persistence definition",

						null

				);

				// Extend the LineSymbol base definition

			}

			return Boolean.TRUE;

		}

	}

	public static class RegisterSymbol implements Callable {

			return Boolean.TRUE;

		}

	}

}

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

	public ISymbol getSymbolForSelection() {

		if (symbolForSelection == null) {

			symbolForSelection = (SimpleLineSymbol) cloneForSelection();

		}

		return symbolForSelection;

	}

import org.gvsig.compat.print.PrintAttributes;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

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

			selectionSym = (PictureLineSymbol) cloneForSelection();

			selectionSym.selected=true;

			selectionSym.selectionSym = selectionSym; // avoid too much lazy creations

		}

		return selectionSym;

	    }

	    float csWidth = getLineStyle().getLineWidth();

		BasicStroke bs = new BasicStroke(

		    (float) csWidth,

		    BasicStroke.CAP_ROUND,

		    BasicStroke.CAP_ROUND);

		Shape geom_transf_clip = geom.getShape(affineTransform);

		g.setClip(bs.createStrokedShape(geom_transf_clip));

		BackgroundFileStyle bg = (!selected) ? bgImage : bgSelImage ;

		Rectangle bounds = bg.getBounds();

        this.properties=null;

	}

	/**

	 * Returns the URL of the image that is used as a picture line symbol (when it

	 * is selected in the map)

	public URL getSource() {

		return bgImage.getSource();

	}

	/**

	 * Returns the xscale for the picture line symbol

	 * @param xScale

				getCartographicLength(this, width, viewPort, dpi), geom);

		return s;

	}

    public Object clone() throws CloneNotSupportedException {

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

        }

        // FIXME: clone properties

        return copy;

    }

                    .setClassOfValue(BackgroundFileStyle.class).setMandatory(false);

                definition.addDynFieldObject(BACKGROUND_SELECTION_IMAGE)

                    .setClassOfValue(BackgroundFileStyle.class).setMandatory(false);

                definition.addDynFieldObject(WIDTH)

                    .setClassOfValue(Double.class).setMandatory(true);

            }

            return Boolean.TRUE;

        }

    }

	public static class RegisterSymbol implements Callable {

		public Object call() throws Exception {

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 MultiLayerMarkerSymbol selectionSymbol;

	private double markerSize;

	private double rotation;

	public MultiLayerMarkerSymbol() {

		super();

	}

	public Color getColor() {

		/*

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

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

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

			}

		return selectionSymbol;

	}

						MultiLayerMarkerSymbol.class,

						MULTILAYER_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME,

						MULTILAYER_MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME+" Persistence definition",

						null

				);

				// Extend the MarkerSymbol base definition

			}

			return Boolean.TRUE;

		}

	}

	public static class RegisterSymbol implements Callable {

			return Boolean.TRUE;

		}

	}

}

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

	public ISymbol getSymbolForSelection() {

		if (selectionSymbol == null) {

			selectionSymbol = (SimpleMarkerSymbol) cloneForSelection();

		}

		return selectionSymbol;

	}

public class ArrowMarkerSymbol extends AbstractMarkerSymbol implements CartographicSupport, IArrowMarkerSymbol {

	public static final String ARROW_MARKER_SYMBOL_DYNCLASS_NAME = "ArrowMarkerSymbol";

	private ArrowMarkerSymbol symSel;

	private double sharpeness;

	public ISymbol getSymbolForSelection() {

		if (symSel == null) {

			symSel.setColor(MapContext.getSelectionColor());

		}

		return symSel;

		g.setStroke(new BasicStroke());

		AffineTransform newAf = (AffineTransform)affineTransform.clone();

		newAf.translate(p.getX(), p.getY());

		newAf.rotate(theta);

		GeneralPathX gp = new GeneralPathX();

		gp.moveTo(0, 0);

		gp.lineTo(size, -halfHeight);

		gp.closePath();

		gp.transform(newAf);

		g.fill(gp);

	}

	public Object clone() throws CloneNotSupportedException {

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

		// Clone the selection symbol

		if (symSel != null) {

			copy.symSel = (ArrowMarkerSymbol) symSel.clone();

						ArrowMarkerSymbol.class,

						ARROW_MARKER_SYMBOL_DYNCLASS_NAME,

						ARROW_MARKER_SYMBOL_DYNCLASS_NAME+" Persistence definition",

						null

				);

				// Extend the FillSymbol base definition

			}

			return Boolean.TRUE;

		}

	}

}

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

    private static final String BACKGROUND_SELECTION_IMAGE = "bgSelImage";

//    private static final float SELECTION_OPACITY_FACTOR = .3F;

    private boolean selected;

    private PictureMarkerSymbol selectionSym;

    /**

     * Constructor method

     * @param imageURL

     *            , URL of the normal image

     * @param selImageURL

    /**

     * Sets the file for the image to be used as a marker symbol

     * @param imageFile

     *            , File

     * @throws IOException

    /**

     * Sets the file for the image to be used as a marker symbol (when it is

     * selected in the map)

     * @param imageFile

     *            , File

     * @throws IOException

            selectionSym.selected = true;

            selectionSym.selectionSym = selectionSym; // avoid too much lazy

                                                      // creations

        }

        return selectionSym;

    }

        }

    }

    public void drawInsideRectangle(Graphics2D g, AffineTransform scaleInstance, Rectangle r, PrintAttributes properties) throws SymbolDrawingException {

        /*

         * Marker symbols which are not simple (images, etc)

         */

        double saved_size = this.getSize();

        this.setSize(r.getHeight());

        // =================== Restoring size

        this.setSize(saved_size);

    public String getClassName() {

        return getClass().getName();

    }

            return Boolean.TRUE;

        }

    }

	public static class RegisterSymbol implements Callable {

		public Object call() throws Exception {

			return Boolean.TRUE;

		}

	}

}