Application: gvSIG desktop

 * @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;

	}

}