| gvSIG desktop 1

import org.xmlpull.v1.XmlPullParserException;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.values.Value;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.SymbologyFactory;

/**

 * Implements the driver for Styled Layer Descriptor documents in order

 * to allow gvSIG to read or write XML documents of this OGC Standard.

 * @author pepe vidal salvador - jose.vidal.salvador@iver.es

 */

public class FMapSLDDriver implements IFMapLegendDriver{

	private FLayer layer;

	private String[] fieldNames;

	private int[] fieldTypes;

	private static String sldReadVersion;

	public boolean accept(File f) {

	/**

	 * Obtains the classifying field names that are used in the .sld

	 * document

	 * @return Array of Strings with the classifying field names

	 */

	public String[] getClassifyingFieldNames() { return fieldNames; }

	/**

	 * Returns the classifying field types of the classifying field names

	 * that are used in the .sld document

	 * @return Array of integers with the types

	 */

	/**

	 * Returns true if any layer contained in the TOC menu of gvSIG has the

	 * @param layer

	 * @return boolean

	 */

	private boolean checkIsUsableSldLyr(FLayer layer, String name) {

					return true;

				}

			}

		return layer.getName().equals(name);

	}

		try {

			sldReadVersion = my_sld.getVersion();

			((SLDProtocolHandler) my_sld).parse(file);

	/**

	 * Takes a SLDLayer and with its information, creates a gvSIG legend. Depending

	 * on if the layer has filters or not, it will be created a single symbol legend

	 * @param sldLayer layer contained in a .sld document

	 * @return a gvSIG legend

	 * @throws ReadDriverException

				}

			}

			return legend;

	}

	/**

	 * Checks if the field names contained in an sld document appear in the information

	 * of the layer that we are using. If all the field names are correct the method

	 * returns true.Otherwise, false.

	 * @param fieldNames

	 * @return

	 * @throws ReadDriverException

	}

	/**

	 * Transforms a SLD Symbolizer into an ISymbol.

	 * @param symbolizer to be transfomed into an ISymbol

	 * @return ISymbol

	 * @throws NumberFormatException

	public static ISymbol SLDSymbolizer2ISymbol(ISLDSymbolizer symbolizer) throws NumberFormatException, LegendDriverException {

		///////////////////////////////////////////////////////////////////////////////////////////////////////////

		//LINE//

		if (symbolizer instanceof SLDLineSymbolizer) {

			SLDLineSymbolizer myLine = (SLDLineSymbolizer) symbolizer;

			if(myLine.getStroke().getFloatDashArray().length == 0) {

				dash = null;

			}

			BasicStroke str = new BasicStroke(width,

					lineCap,

					marker = createMarker(myMark,size,rotation);

					line.setLineWidth(marker.getSize());

					marker.setUnit(-1);

					line.setMarker(marker);

					line.setAlpha(marker.getColor().getAlpha());

					if(str.getDashArray() != null)

		///////////////////////////////////////////////////////////////////////////////////////////////////////////

		//POLYGON//

		else if (symbolizer instanceof SLDPolygonSymbolizer) {

			SLDPolygonSymbolizer myPolygon = (SLDPolygonSymbolizer)symbolizer;

			//SimpleFillSymbol

						Color myColor = new Color(color.getRed(),color.getGreen(),color.getBlue(),alpha);

						simpleFill.setFillColor(myColor);

					}

						simpleFill.setFillColor(color);

				}

					simpleFill.setOutline(createOutline(myPolygon.getStroke()));

				}

				return simpleFill;

			else if (myPolygon.getFill() != null && myPolygon.getFill().getFillGraphic() != null) {

				SLDGraphic myFill = myPolygon.getFill().getFillGraphic();

		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////

		//POINT//

		else if (symbolizer instanceof SLDPointSymbolizer) {

			SLDPointSymbolizer myPoint = (SLDPointSymbolizer)symbolizer;

			//Marker->SimpleMarkerSymbol

					Color myColor = new Color(color.getRed(),color.getGreen(),color.getBlue(),alpha);

					marker.setColor(myColor);

				}

					marker.setColor(color);

			}

		}

				marker.setOutlineColor(myMark.getStroke().getStrokeColor());

				marker.setOutlineSize(myMark.getStroke().getStrokeWidth());

				marker.setOutlined(true);

		}

		if( size.getLiteral() != null) {

		}

			marker.setRotation(Float.valueOf(rotation.getLiteral()));

		return marker;

					marker.setUnit(-1);

					marker.setSize(Float.valueOf(size.getLiteral()));

				}

					marker.setRotation(Float.valueOf(rotation.getLiteral()));

			}

		} catch (IOException e1) {

	public static ILineSymbol createOutline(SLDStroke stroke) throws NumberFormatException, LegendDriverException {

		SLDLineSymbolizer line ;

		try {

			line = (SLDLineSymbolizer) Class.forName(

					classNameForVersion(SLDLineSymbolizer.class,sldReadVersion )).newInstance();

					}

					else {

						xmlBuilder.openTag(SLDTags.RULE);

						xmlBuilder.openTag(FilterTags.FILTER);

						xmlBuilder.openTag(FilterTags.PROPERTYISEQUALTO);

						xmlBuilder.writeTag(FilterTags.PROPERTYNAME,myLegend.getClassifyingFieldNames()[0]);

						xmlBuilder.closeTag();

						xmlBuilder.closeTag();

				Object[] values = myLegend.getValues();

				String[] descriptions = myLegend.getDescriptions();

				for(int i = 0; i < symbols.length; i++ ){

					FilterFactory filterFactory = new FilterFactory();

					xmlBuilder.openTag(SLDTags.RULE);

//		String cName = packageName + "sld" + versionString + "." +

//		subPackage + sldClass.getName().substring(

//				sldClass.getName().lastIndexOf(".", sldClass.getName().length())) + versionString;

		String path = sldClass.toString();

		path = sldClass.toString().substring("class ".length(),path.length());

		path = path.replace(".sld.", ".sld.sld"+versionString+".");

		String cName = path+versionString;

		return cName;

	}

	/**

	 * Transforms an ISymbol into a SLD Symbolizer

	 * @param symbol ISymbol to be transformed

	 * @return SLD Symbolizer

	 */

	throws LegendDriverException, InstantiationException, IllegalAccessException, ClassNotFoundException {

		//MultiLayer Symbol

		if(symbol instanceof IMultiLayerSymbol) {

			//Made up of  lines

			if(symbol instanceof MultiLayerLineSymbol) {

				MultiLayerLineSymbol multiLine = (MultiLayerLineSymbol) symbol;

					(SLDMultiLineSymbolizer) Class.forName(

							classNameForVersion(SLDMultiLineSymbolizer.class, sldVersion)).newInstance();

				for (int i = 0; i < multiLine.getLayerCount(); i++) {

				}

				return (ISLDSymbolizer) multiSldLine;

			}

			//Made up of polygons

			else if (symbol instanceof MultiLayerFillSymbol) {

				MultiLayerFillSymbol multiFill = (MultiLayerFillSymbol) symbol;

					(SLDMultiPolygonSymbolizer) Class.forName(

							classNameForVersion(SLDMultiPolygonSymbolizer.class, sldVersion)).newInstance();

				for (int i = 0; i < multiFill.getLayerCount(); i++) {

				}

				return (ISLDSymbolizer) multiSldPolygon;

			}

				SLDMultiPointSymbolizer multiSldPoint = (SLDMultiPointSymbolizer) Class.forName(

						classNameForVersion(SLDMultiPointSymbolizer.class, sldVersion)).newInstance();

				for (int i = 0; i < multiMarker.getLayerCount(); i++) {

				}

				return (ISLDSymbolizer) multiSldPoint;

			}

		}

//		else if(symbol instanceof MultiShapeSymbol) {

//		MultiShapeSymbol multiShape = (MultiShapeSymbol) symbol;

//		SLDMultiShapeSymbolizer sldMultiShape = new SLDMultiShapeSymbolizer();

//		sldMultiShape.addSldPolygon((SLDPolygonSymbolizer)ISymbol2SLDSymbolizer(multiShape.getFillSymbol()));

//		sldMultiShape.addSldPoint((SLDPointSymbolizer)ISymbol2SLDSymbolizer(multiShape.getMarkerSymbol()));

//		}

		//Single symbol

		else {

			for (int i = 0; i < multi.getLayerCount(); i++) {

				if (max < ((IMarkerSymbol)multi.getLayer(i)).getSize()) {

					marker =  (IMarkerSymbol) multi.getLayer(i);

				}

			}

			myGraphic = createMarkerFill(marker, myGraphic, sldVersion);

			wellKnownName.setLiteral(SLDUtils.getMarkWellKnownName(SimpleMarkerSymbol.SQUARE_STYLE));

			mark.setWellKnownName(wellKnownName);

			mark.setFill(fill);

		}

		FExpression expressionSize = new FExpression();

	throws InstantiationException, IllegalAccessException, ClassNotFoundException {

		SLDExternalGraphic extGra = (SLDExternalGraphic) Class.forName(

				classNameForVersion(SLDExternalGraphic.class, sldVersion)).newInstance();

			for (int i = 0; i < multiLine.getLayerCount(); i++) {

				ILineSymbol myNewLine =  (ILineSymbol) multiLine.getLayer(i);

				if (myLine.getLineWidth() < myNewLine.getLineWidth())

			}

			myLine = (ILineSymbol) multiLine.getLayer(0);

		}

			stroke.setFloatDashArray(str.getDashArray());

			stroke.setExpressionLineCap(SLDUtils.convertLineCapToString(str.getEndCap()));

			stroke.setExpressionLineJoin(SLDUtils.convertLineJoinToString(str.getLineJoin()));

			stroke.setExpressionDashOffset(Double.toString(str.getDashPhase()));

		}

		if(myLine instanceof MarkerLineSymbol) {

				str.setExpressionColor(SLDUtils.convertColorToHexString(marker.getOutlineColor()));

			str.setExpressionWidth(String.valueOf(marker.getOutlineSize()));

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

				SLDFill fill = (SLDFill) Class.forName(

			} catch (MalformedURLException e) {

				e.printStackTrace();

			}

		}

		else if (myMarker instanceof CharacterMarkerSymbol) {

			SLDMark mark = (SLDMark) Class.forName(