Application: gvSIG desktop

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

 * 

	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

	    GeometryType geometryType = geom.getGeometryType();

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

	        if (marker != null) {

                    if(marker instanceof CartographicSupport){

                        marker.setCartographicContext(this.getCartographicContext());

                    }

                    if(marker instanceof IMarkerSymbol_v2){

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

                    } else {

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

                    }

	        }

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

	        if (line != null) {

                    if(line instanceof CartographicSupport){

                        line.setCartographicContext(this.getCartographicContext());

                    }

                    if(line instanceof ISymbol_v2){

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

                    } else {

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

                    }

	        }

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

	        if (fill != null) {

                    if(fill instanceof CartographicSupport){

                        fill.setCartographicContext(this.getCartographicContext());

                    }

                    if(fill instanceof ISymbol_v2){

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

                    } else {

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

                    }

	        }			

	    }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 isOneDotOrPixel(Geometry geom,

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

//		

//        GeometryType geomType = geom.getGeometryType();

//        if( geomType.isSubTypeOf(Geometry.TYPES.POINT) ) {

//           	if (marker != null) {

//				return marker.isOneDotOrPixel(geom, positionOfDotOrPixel, viewPort, dpi);

//			}

//

//        } else if( geomType.isSubTypeOf(Geometry.TYPES.CURVE) ) {

//            if (line != null) {

//                return line.isOneDotOrPixel(geom, positionOfDotOrPixel, viewPort, dpi);

//			}

//            

//        } else if( geomType.isSubTypeOf(Geometry.TYPES.SURFACE) ) {

//			if (fill != null) {

//				return fill.isOneDotOrPixel(geom, positionOfDotOrPixel, viewPort, dpi);

//			}

//            

//        }

//		if (!geom.isSimple()){

//			Aggregate aggregate = (Aggregate)geom;			

//			for (int i=0 ; i<aggregate.getPrimitivesNumber() ; i++){

//				if (!isOneDotOrPixel(aggregate.getPrimitiveAt(i), positionOfDotOrPixel, viewPort, dpi)){

//					return false;

//				}

//			}

//			return true;

//		}

//		return true;

//	}

//        @Override

//	public void getPixExtentPlus(Geometry geom, float[] distances,

//			ViewPort viewPort, int dpi) {

//		// TODO Implement it

//		throw new Error("Not yet implemented!");

//

//	}

//        @Override

//	public int getOnePointRgb() {

//		// will return a mixture of all symbol's getOnePointRgb() value

//

//		int rMarker = 0;

//		int gMarker = 0;

//		int bMarker = 0;

//		int aMarker = 0;

//

//		if (marker!=null && marker.getColor() != null) {

//			rMarker = marker.getColor().getRed();

//			gMarker = marker.getColor().getGreen();

//			bMarker = marker.getColor().getBlue();

//			aMarker = marker.getColor().getAlpha();

//		}

//

//		int rLine = 0;

//		int gLine = 0;

//		int bLine = 0;

//		int aLine = 0;

//

//		if (line != null  && line.getColor() != null) {

//			rLine = line.getColor().getRed();

//			gLine = line.getColor().getGreen();

//			bLine = line.getColor().getBlue();

//			aLine = line.getColor().getAlpha();

//		}

//

//		int rFill = 0;

//		int gFill = 0;

//		int bFill = 0;

//		int aFill = 0;

//

//		if (fill != null ) {

//			Color colorOfFill = null;

//			if (fill.getOutline()!=null) {

//				colorOfFill = fill.getOutline().getColor();

//			} else if (fill.getFillColor()!=null) {

//				colorOfFill = fill.getFillColor();

//			}

//			if (colorOfFill != null) {

//				rFill = colorOfFill.getRed();

//				gFill = colorOfFill.getGreen();

//				bFill = colorOfFill.getBlue();

//				aFill = colorOfFill.getAlpha();

//

//			}

//		}

//

//		int red = (rMarker + rLine + rFill) / 3;

//		int green = (gMarker + gLine + gFill) / 3;

//		int blue = (bMarker + bLine + bFill) / 3;

//		int alpha = (aMarker + aLine + aFill) / 3;

//

//		return (alpha) << 24 + (red << 16) + (green << 8) + blue;

//	}

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

	}

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

		}

	}

	public int getUnit() {

		if (marker != null) {

			return marker.getUnit();

		}

		if (line != null) {

			return line.getUnit();

		}

		return -1;

	}

	public void setMask(IMask mask) {

		throw new NotYetImplemented();

	}

	public int getReferenceSystem() {

		return this.referenceSystem;

	}

	public void setReferenceSystem(int system) {

		this.referenceSystem = system;

	}

	public IMarkerSymbol getMarkerSymbol() {

		return marker;

	}

	public ILineSymbol getLineSymbol() {

		return line;

	}

	public IFillSymbol getFillSymbol() {

		return fill;

	}

	public void setMarkerSymbol(IMarkerSymbol markerSymbol) {

		this.marker = markerSymbol;

	}

	public void setLineSymbol(ILineSymbol lineSymbol) {

		this.line = lineSymbol;

	}

	public void setFillSymbol(IFillSymbol fillFillSymbol) {

		this.fill = fillFillSymbol;

	}

	public boolean hasFill() {

	if (fill == null) {

		return false;

	}

	return fill.hasFill();

	}

	public void setHasFill(boolean hasFill) {

		if (fill != null) {

			fill.setHasFill(hasFill);

		}

	}

	public boolean hasOutline() {

		return false;

	}

	public void setHasOutline(boolean hasOutline) {

	}

	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;

	}

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

	}

	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 {

		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 {

		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;

		}

	}

}