/ - Diff - Application: gvSIG desktop - gvSIG

     import org.gvsig.sldsupport.exception.UnsupportedSLDObjectException;
     import org.gvsig.sldsupport.exception.UnsupportedSLDVersionException;
     import org.gvsig.sldsupport.impl.parser.ExtendedKXmlParser;
     import org.gvsig.sldsupport.impl.sld.parsing.FeatureStyleElement;
     import org.gvsig.sldsupport.impl.sld.parsing.NamedLayerElement;
     import org.gvsig.sldsupport.impl.sld.parsing.UserLayerElement;
     import org.gvsig.sldsupport.impl.sld.parsing.symbol.SymbolElement;
-...
     import org.gvsig.sldsupport.sld.layer.SLDLayer;
     import org.gvsig.sldsupport.sld.layer.SLDNamedLayer;
     import org.gvsig.sldsupport.sld.layer.SLDUserLayer;
     import org.gvsig.sldsupport.sld.style.SLDFeatureStyle;
     import org.gvsig.sldsupport.sld.symbol.SLDSymbol;
     import org.kxml2.io.KXmlParser;
     import org.xmlpull.v1.XmlPullParser;
-...
     			return root;
     		} else {
     			if (name.compareToIgnoreCase(SLDTags.USERDEFINEDLAYER) == 0
     					|| name.compareToIgnoreCase(SLDTags.NAMEDLAYER) == 0) {
     			if (name.compareToIgnoreCase(SLDTags.FEATURESTYLE) == 0
     					|| name.compareToIgnoreCase(SLDTags.FEATURETYPESTYLE) == 0) {
     				/*
     				 * This line is out of the SLD standard
     				 */
     				v = parser.getAttributeValue(null, SLDTags.VERSION_ATTR);
     				return parseLayer(parser, v);
     				return parseFeatureStyle(parser, v);
     			} else {
     				if (name.compareToIgnoreCase(SLDTags.LINESYMBOLIZER) == 0
     						|| name.compareToIgnoreCase(SLDTags.POLYGONSYMBOLIZER) == 0
-...
     	private static SLDSymbol parseSymbol(XmlPullParser parser, String version)
     			throws XmlPullParserException, IOException, SLDReadException {
     		return null;
     		return SymbolElement.parse(parser, version);
+    	}
     	private static SLDLayer parseLayer(XmlPullParser parser, String version)
     			throws XmlPullParserException, IOException, SLDReadException {
-...
     		return resp;
+    	}
     	private static SLDFeatureStyle parseFeatureStyle(
     			XmlPullParser parser, String version)
     			throws XmlPullParserException, IOException, SLDReadException {
     		String name = parser.getName();
     		SLDFeatureStyle resp = null;
     		if (SLDUtils.isStr(name, SLDTags.FEATURESTYLE) ||
     				SLDUtils.isStr(name, SLDTags.FEATURETYPESTYLE)) {
     			resp = FeatureStyleElement.parse(parser, version);
     		} else {
     			throw new SLDReadException(
     					"Expected layer, found: '" + name + "' tag");
+    		}
     		return resp;
+    	}
     	private static SLDRoot parseRoot(XmlPullParser parser, String version)
     			throws XmlPullParserException, IOException, SLDReadException {
-...
+    		}
     		if (! (obj instanceof SLDRoot
     				|| obj instanceof SLDLayer
     				|| obj instanceof SLDFeatureStyle
     				|| obj instanceof SLDSymbol)) {
     			throw new InvalidSLDObjectException("Unexpected class.",
-...
     			throws InvalidSLDObjectException, UnsupportedSLDObjectException {
     		if (! (obj instanceof SLDRoot
     				|| obj instanceof SLDLayer
     				|| obj instanceof SLDFeatureStyle
     				|| obj instanceof SLDSymbol)) {
     			throw new InvalidSLDObjectException("Unexpected class.",
     			throw new InvalidSLDObjectException("Unexpected entity.",
     					obj.getClass().getName());
+    		}
-...
     		if (obj instanceof SLDRoot) {
     			appendRoot((SLDRoot) obj, xmlBuilder, attributes);
     		} else {
     			if (obj instanceof SLDUserLayer) {
     			if (obj instanceof SLDFeatureStyle) {
     				/*
     				 * Doing this is not SLD standard-conformal
     				 */
     				UserLayerElement.append((SLDUserLayer) obj, xmlBuilder, attributes);
     				FeatureStyleElement.append((SLDFeatureStyle) obj, xmlBuilder, attributes);
     			} else {
     				if (obj instanceof SLDNamedLayer) {
     				if (obj instanceof SLDSymbol) {
     					/*
     					 * Doing this is not SLD standard-conformal
     					 */
     					NamedLayerElement.append((SLDNamedLayer) obj, xmlBuilder, attributes);
     				} else {
     					if (obj instanceof SLDSymbol) {
     						/*
     						 * Doing this is not SLD standard-conformal
     						 */
     						SymbolElement.append((SLDSymbol) obj,  xmlBuilder, attributes);
+    					}
     					SymbolElement.append((SLDSymbol) obj,  xmlBuilder, attributes);
+    				}
+    			}
+    		}
-...
     			for (int i=0; i<list.size(); i++) {
     				if (list.get(i) instanceof SLDUserLayer) {
     					// Do not pass attributes 8already written)
     					UserLayerElement.append((SLDUserLayer) list.get(i), xb, null);
     					UserLayerElement.append((SLDUserLayer) list.get(i), xb, root.getVersion());
     				} else {
     					if (list.get(i) instanceof SLDNamedLayer) {
     						// Do not pass attributes 8already written)
     						NamedLayerElement.append((SLDNamedLayer) list.get(i), xb, null);
     						NamedLayerElement.append((SLDNamedLayer) list.get(i), xb, root.getVersion());
     					} else {
     						throw new UnsupportedSLDObjectException(
     								(list.get(i) == null ? "Null" :

     public class NamedLayerElement {
     	public static void append(
     			SLDNamedLayer obj, XmlBuilder xb, Map<String, String> atts)
     			SLDNamedLayer obj, XmlBuilder xb, String version)
     					throws
     					InvalidSLDObjectException, UnsupportedSLDObjectException {
     		if (atts != null) {
     			// This is user layer is main entity of file (not standard)
     			xb.openTag(SLDTags.NAMEDLAYER, atts);
     		} else {
     			xb.openTag(SLDTags.NAMEDLAYER);
+    		}
     		xb.openTag(SLDTags.NAMEDLAYER);
     		//==================================================
     		//==================================================
     		xb.closeTag();
-...
     		int tag = 0;
     		SLDNamedLayer resp = new SLDNamedLayer();
     		resp.setVersion(version);
     		tag = parser.nextTag();
     		String name = parser.getName();

     			throws
     			InvalidSLDObjectException, UnsupportedSLDObjectException {
     		xb.openTag(SLDTags.FILL);
     		// ======================
     		if (obj.getFillGraphic() != null) {
     			GraphicFillElement.append(
     					new SLDGraphicFill(obj.getFillGraphic()), xb, version);
+    		}
     		// =========
     		if (obj.getFillColor() != null) {
     			SLDSvgCssParameter p = new SLDSvgCssParameter();
     			p.setName(SLDTags.FILL_ATTR);
     			p.getExpressionList().add(obj.getFillColor());
     			SvgCssParameterElement.append(p, xb, version);
+    		}
     		// =========
     		if (obj.getOpacity() != null) {
     			SLDSvgCssParameter p = new SLDSvgCssParameter();
     			p.setName(SLDTags.FILLOPACITY_ATTR);
     			p.getExpressionList().add(obj.getOpacity());
     			SvgCssParameterElement.append(p, xb, version);
+    		}
     		// ======================
     		xb.closeTag();
+    	}
     	public static SLDFill parse(XmlPullParser parser , String version)

     	public static void append(
     			SLDFeatureTypeConstraint obj, XmlBuilder xb, String version)
     					throws
     					InvalidSLDObjectException, UnsupportedSLDObjectException {
     	throws InvalidSLDObjectException, UnsupportedSLDObjectException {
     		xb.openTag(SLDTags.FEATURETYPECONSTRAINT);
     		// ========================
     		if (obj.getFeatureTypeName() != null) {
     			xb.writeTag(SLDTags.FEATURETYPENAME, obj.getFeatureTypeName());
+    		}
     		// =========
     		if (obj.getFilter() != null) {
     			// 0 or 1 filters
     			FilterElement.append(obj.getFilter(), xb, version);
+    		}
     		// =========
     		for (int i=0; i<obj.getExtents().size(); i++) {
     			ExtentElement.append(obj.getExtents().get(i), xb, version);
+    		}
     		// ========================
     		xb.closeTag();
+    	}
     	public static SLDFeatureTypeConstraint parse(XmlPullParser parser , String version)
-...
+    				}
     				if (SLDUtils.isStr(name, SLDTags.EXTENT)) {
     					SLDExtent ext = ExtentElement.parse(parser, version);
     					resp.setExtent(ext);
     					resp.getExtents().add(ext);
     					break;
+    				}
     				/*

     		SLDUnaryLogicOperator resp = new SLDUnaryLogicOperator();
     		String op_type = parser.getName();
     		if (SLDUtils.isStr(op_type, FilterTags.NOT)) {
     			resp.setIsNot(true);
     			resp.setOperatorType(FilterTags.NOT);
     		} else {
     			throw new SLDReadException("Unknwon unary operator: " + op_type);
+    		}

branches/v02_desarrollo/libraries/sld/temp/org.gvsig.sldsupport.lib.impl/src/main/java/org/gvsig/sldsupport/impl/sld/parsing/filteroperator/spatial/BBoxOperatorElement.java
58	58	}
59	59	if (SLDUtils.isStr(name, FilterTags.ENVELOPE)) {
60	60	GMLEnvelope env = EnvelopeElement.parse(parser, version);
61		resp.setEnvelope(env.getWKT());
	61	resp.setEnvelope(env);
62	62	break;
63	63	}
64	64	/*

branches/v02_desarrollo/libraries/sld/temp/org.gvsig.sldsupport.lib.impl/src/main/java/org/gvsig/sldsupport/impl/sld/parsing/symbol/SymbolElement.java
63	63	return PolygonSymbolElement.parse(parser, version);
64	64	}
65	65
	66	/*
	67	* RasterSymbol, TextSymbol, MappedColorSymbol
	68	*/
66	69	throw new SLDReadException("Unsupported symbol entity: " + name);
67	70	}
68	71	}

     		if (v.compareToIgnoreCase(SLDUtils.VERSION_1_1_0) == 0) {
     			SLDParameterValue pv = obj.getPerpendicularOffset();
     			if (pv != null) {
     				xb.openTag(SLDTags.PERPENDICULAROFFSET);
     				ParameterValueElement.append(pv, xb, v);
     				xb.closeTag();
     				ParameterValueElement.append(SLDTags.PERPENDICULAROFFSET, pv, xb, v);
+    			}
+    		}
     		// ==================================================

     public class UserLayerElement {
     	public static void append(
     			SLDUserLayer obj, XmlBuilder xb, Map<String, String> atts)
     			SLDUserLayer obj, XmlBuilder xb, String version)
     					throws
     					InvalidSLDObjectException, UnsupportedSLDObjectException {
     		if (atts != null) {
     			// This is user layer is main entity of file (not standard)
     			xb.openTag(SLDTags.USERDEFINEDLAYER, atts);
     		} else {
     			xb.openTag(SLDTags.USERDEFINEDLAYER);
+    		}
     		xb.openTag(SLDTags.USERDEFINEDLAYER);
     		//==================================================
     		//==================================================
     		xb.closeTag();

     package org.gvsig.sldsupport.impl.sld.parsing;
     import java.io.IOException;
     import java.util.HashMap;
     import java.util.List;
     import java.util.Map;
     import org.gvsig.sldsupport.exception.InvalidSLDObjectException;
     import org.gvsig.sldsupport.exception.SLDReadException;
-...
     public class FeatureStyleElement {
     	public static void append(SLDFeatureStyle obj, XmlBuilder xb, String version)
     					throws InvalidSLDObjectException, UnsupportedSLDObjectException {
     	public static void append(
     			SLDFeatureStyle obj, XmlBuilder xb, Map<String, String> atts)
     	throws InvalidSLDObjectException, UnsupportedSLDObjectException {
     		String v = version;
     		String v = obj.getVersion();
     		if (v == null) {
     			v = obj.getVersion();
     			v = SLDUtils.DEFAULT_VERSION;
+    		}
     		if (v.compareToIgnoreCase(SLDUtils.VERSION_1_1_0) == 0) {
-...
+    	}
     	private static void appendv100(SLDFeatureStyle obj, XmlBuilder xb) {
     	private static void appendv100(SLDFeatureStyle obj, XmlBuilder xb)
     			throws InvalidSLDObjectException, UnsupportedSLDObjectException {
     		xb.openTag(SLDTags.FEATURETYPESTYLE);
     		// =================================
     		if (obj.getName() != null) {
     			xb.writeTag(SLDTags.NAME, obj.getName());
+    		}
-...
     			xb.writeTag(SLDTags.TITLE, obj.getTitle());
+    		}
     		if (obj.getDescription() != null) {
     			// it is called "Description" in v. 1.1.0
     			xb.writeTag(SLDTags.ABSTRACT, obj.getDescription());
+    		}
     		if (obj.getFeatureTypeName() != null) {
     			xb.writeTag(SLDTags.FEATURETYPENAME, obj.getFeatureTypeName());
+    		}
     		List<String> list = obj.getSemanticTypeIdentifiers();
     		for (int i=0; i<list.size(); i++) {
     			xb.writeTag(SLDTags.SEMANTICTYPEIDENTIFIER, list.get(i));
+    		}
     		// ================
     		List<SLDRule> rules = obj.getRules();
     		if (rules == null || rules.size() == 0) {
     			throw new InvalidSLDObjectException(
     					SLDTags.FEATURETYPESTYLE, "No rules found");
     		} else {
     			for (int i=0; i<rules.size(); i++) {
     				RuleElement.append(rules.get(i), xb, SLDUtils.VERSION_1_0_0);
+    			}
+    		}
     		// =================================
     		xb.closeTag();
+    	}
     	private static void appendv110(SLDFeatureStyle obj, XmlBuilder xb) {
     	private static void appendv110(SLDFeatureStyle obj, XmlBuilder xb)
     			throws InvalidSLDObjectException, UnsupportedSLDObjectException {
     		xb.openTag(SLDTags.FEATURESTYLE);
     		if (obj.getVersion() != null) {
     			Map<String, String> atts = new HashMap<String, String>();
     			atts.put(SLDTags.VERSION_ATTR, obj.getVersion());
     			xb.openTag(SLDTags.FEATURESTYLE, atts);
     		} else {
     			xb.openTag(SLDTags.FEATURESTYLE);
+    		}
     		// =================================
     		if (obj.getName() != null) {
     			xb.writeTag(SLDTags.NAME, obj.getName());
+    		}
     		if (obj.getDescription() != null) {
     			xb.writeTag(SLDTags.DESCRIPTION, obj.getDescription());
+    		}
     		if (obj.getFeatureTypeName() != null) {
     			xb.writeTag(SLDTags.FEATURETYPENAME, obj.getFeatureTypeName());
     		} else {
     			// mandatory in v 1.1.0
     			throw new InvalidSLDObjectException(
     					SLDTags.FEATURESTYLE,
     					SLDTags.FEATURETYPENAME + " is mandatory in version 1.1.0");
+    		}
     		// =========
     		List<String> list = obj.getSemanticTypeIdentifiers();
     		for (int i=0; i<list.size(); i++) {
     			xb.writeTag(SLDTags.SEMANTICTYPEIDENTIFIER, list.get(i));
+    		}
     		// ================
     		List<SLDRule> rules = obj.getRules();
     		if (rules == null || rules.size() == 0) {
     			throw new InvalidSLDObjectException(
     					SLDTags.FEATURESTYLE, "No rules found");
     		} else {
     			for (int i=0; i<rules.size(); i++) {
     				RuleElement.append(rules.get(i), xb, SLDUtils.VERSION_1_0_0);
+    			}
+    		}
     		// =================================
     		xb.closeTag();
+    	}

     package org.gvsig.sldsupport.sld.constraints;
     import java.util.ArrayList;
     import java.util.List;
     import org.gvsig.sldsupport.sld.extent.SLDExtent;
     import org.gvsig.sldsupport.sld.filter.SLDFilter;
-...
     	protected String featureTypeName = null;
     	protected SLDFilter filter = null;
     	protected SLDExtent extent = null;
     	protected List<SLDExtent> extents = new ArrayList<SLDExtent>();
     	public String getFeatureTypeName() {
     		return featureTypeName;
-...
     		return filter;
+    	}
     	public SLDExtent getExtent() {
     		return extent;
     	public List<SLDExtent> getExtents() {
     		return extents;
+    	}
     	public void setFeatureTypeName(String n) {
-...
     		this.filter = f;
+    	}
     	public void setExtent(SLDExtent se) {
     		this.extent = se;
+    	}
+    }

     import org.gvsig.sldsupport.sld.SLDObject;
     import org.gvsig.sldsupport.sld.constraints.SLDLayerFeatureConstraints;
     public abstract class SLDLayer implements SLDObject {
     public abstract class SLDLayer /*implements SLDObject*/ {
     	protected String name = null;
     	protected SLDLayerFeatureConstraints layerFeatConstraints = null;
     	protected String version = null;
     	// protected String version = null;
     	public SLDLayer() {
+    	}
     	/*
     	public String getVersion() {
     		return version;
+    	}
     	*/
     	public String getName() {
-...
     		this.name = name;
+    	}
     	/*
     	public void setVersion(String version) {
     		this.version = version;
+    	}
     	*/
+    }

     	public SLDGraphicFill() {
+    	}
     	public SLDGraphicFill(SLDGraphic g) {
     		graphic = g;
+    	}
     	public SLDGraphic getGraphic() {
     		return graphic;

     import java.util.ArrayList;
     import java.util.List;
     import org.gvsig.sldsupport.sld.SLDObject;
     import org.gvsig.sldsupport.sld.rule.SLDRule;
     public class SLDFeatureStyle {
     public class SLDFeatureStyle implements SLDObject {
     	protected String name = null;

Application: gvSIG desktop

Revision 40827