Revision 40862
| branches/v02_desarrollo/libraries/sld/temp/org.gvsig.sldconverter/org.gvsig.sldconverter.lib/org.gvsig.sldconverter.lib.api/src/main/java/org/gvsig/sldconverter/SLDConverterManager.java | ||
|---|---|---|
| 14 | 14 |
|
| 15 | 15 |
public interface SLDConverterManager {
|
| 16 | 16 |
|
| 17 |
public static final int CANNOT_CONVERT = 0; |
|
| 17 |
public static final int CAN_NOT_CONVERT = 0; |
|
| 18 |
public static final int CAN_CONVERT_PARTIALLY = 50; |
|
| 18 | 19 |
public static final int CAN_CONVERT_FULLY = 100; |
| 19 | 20 |
|
| 20 | 21 |
public SLDSymbol toSLDSymbol(ISymbol sym) throws UnsupportedSymbolException; |
| branches/v02_desarrollo/libraries/sld/temp/org.gvsig.sldconverter/org.gvsig.sldconverter.lib/org.gvsig.sldconverter.lib.impl/src/main/java/org/gvsig/sldconverter/impl/util/BasicUtils.java | ||
|---|---|---|
| 117 | 117 |
public static int canConvertUserLayer(SLDUserLayer layer) {
|
| 118 | 118 |
List<SLDUserStyle> stys = layer.getStyles(); |
| 119 | 119 |
if (stys.size() == 0) {
|
| 120 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 120 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 121 | 121 |
} else {
|
| 122 | 122 |
if (stys.size() == 1) {
|
| 123 | 123 |
return canConvertUserStyle( |
| 124 | 124 |
stys.get(0), |
| 125 |
SLDConverterManager.CAN_CONVERT_FULLY);
|
|
| 125 |
SLDConverterManager.CAN_CONVERT_PARTIALLY);
|
|
| 126 | 126 |
} else {
|
| 127 | 127 |
return canConvertUserStyle( |
| 128 | 128 |
stys.get(0), |
| 129 | 129 |
/*result devaluated*/ |
| 130 |
SLDConverterManager.CAN_CONVERT_FULLY / 2);
|
|
| 130 |
SLDConverterManager.CAN_CONVERT_PARTIALLY);
|
|
| 131 | 131 |
} |
| 132 | 132 |
} |
| 133 | 133 |
} |
| ... | ... | |
| 137 | 137 |
|
| 138 | 138 |
List<SLDLayerStyle> stys = layer.getStyles(); |
| 139 | 139 |
if (stys.size() == 0) {
|
| 140 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 140 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 141 | 141 |
} else {
|
| 142 | 142 |
if (stys.size() == 1 && stys.get(0) instanceof SLDUserStyle) {
|
| 143 | 143 |
return canConvertUserStyle( |
| 144 | 144 |
(SLDUserStyle) stys.get(0), |
| 145 |
SLDConverterManager.CAN_CONVERT_FULLY);
|
|
| 145 |
SLDConverterManager.CAN_CONVERT_PARTIALLY);
|
|
| 146 | 146 |
} else {
|
| 147 | 147 |
for (int i=0; i<stys.size(); i++) {
|
| 148 | 148 |
if (stys.get(i) instanceof SLDUserStyle) {
|
| ... | ... | |
| 152 | 152 |
return canConvertUserStyle( |
| 153 | 153 |
(SLDUserStyle) stys.get(0), |
| 154 | 154 |
/*result devaluated*/ |
| 155 |
SLDConverterManager.CAN_CONVERT_FULLY / 2);
|
|
| 155 |
SLDConverterManager.CAN_CONVERT_PARTIALLY);
|
|
| 156 | 156 |
} |
| 157 | 157 |
} |
| 158 | 158 |
// No user style found: |
| 159 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 159 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 160 | 160 |
} |
| 161 | 161 |
} |
| 162 | 162 |
} |
| ... | ... | |
| 165 | 165 |
|
| 166 | 166 |
List<SLDFeatureStyle> fstys = style.getFeatureStyles(); |
| 167 | 167 |
if (fstys.size() == 0) {
|
| 168 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 168 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 169 | 169 |
} else {
|
| 170 | 170 |
if (fstys.size() == 1) {
|
| 171 | 171 |
return canConvertFeatureStyle(fstys.get(0), max); |
| ... | ... | |
| 179 | 179 |
|
| 180 | 180 |
List<SLDRule> rules = sldFeatureStyle.getRules(); |
| 181 | 181 |
if (rules == null || rules.size() == 0) {
|
| 182 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 182 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 183 | 183 |
} |
| 184 | 184 |
|
| 185 | 185 |
if (areRulesOfSingleSymbol(rules)) {
|
| ... | ... | |
| 191 | 191 |
if (areRulesOfIntervals(rules)) {
|
| 192 | 192 |
return max; |
| 193 | 193 |
} else {
|
| 194 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 194 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 195 | 195 |
} |
| 196 | 196 |
} |
| 197 | 197 |
} |
| ... | ... | |
| 1491 | 1491 |
continue; |
| 1492 | 1492 |
} |
| 1493 | 1493 |
filt = rules.get(i).getFilter(); |
| 1494 |
if (filt != null && !filt.isElse()) {
|
|
| 1494 |
if (filt == null) {
|
|
| 1495 |
continue; |
|
| 1496 |
} |
|
| 1497 |
if (!filt.isElse()) {
|
|
| 1495 | 1498 |
oper = filt.getFilterOperator(); |
| 1496 | 1499 |
if (oper instanceof SLDComparisonOperator) {
|
| 1497 |
|
|
| 1498 |
IInterval ival = getInterval((SLDComparisonOperator) oper, pname);
|
|
| 1499 |
if (ival != null) {
|
|
| 1500 |
sym = sldMan().toSymbol(symList.get(0));
|
|
| 1501 |
if (sym != null) {
|
|
| 1500 |
sym = sldMan().toSymbol(symList.get(0)); |
|
| 1501 |
if (sym != null) {
|
|
| 1502 |
IInterval ival = getIntervalForSymbol(
|
|
| 1503 |
(SLDComparisonOperator) oper, pname, sym);
|
|
| 1504 |
if (ival != null) {
|
|
| 1502 | 1505 |
resp.put(ival, sym); |
| 1503 | 1506 |
} |
| 1504 | 1507 |
} |
| 1505 | 1508 |
} |
| 1509 |
} else {
|
|
| 1510 |
// filter is else |
|
| 1506 | 1511 |
} |
| 1507 | 1512 |
} |
| 1508 | 1513 |
return resp; |
| 1509 | 1514 |
} |
| 1510 | 1515 |
|
| 1511 |
private static IInterval getInterval(SLDComparisonOperator oper, String pname) {
|
|
| 1516 |
private static IInterval getIntervalForSymbol( |
|
| 1517 |
SLDComparisonOperator oper, String pname, ISymbol sym) {
|
|
| 1512 | 1518 |
|
| 1513 | 1519 |
double min = 0; |
| 1514 | 1520 |
double max = 0; |
| ... | ... | |
| 1522 | 1528 |
try {
|
| 1523 | 1529 |
min = Double.parseDouble(lit.getValue()); |
| 1524 | 1530 |
max = Double.MAX_VALUE; |
| 1531 |
sym.setDescription("> " + lit.getValue());
|
|
| 1525 | 1532 |
} catch (Exception exc) {
|
| 1526 | 1533 |
return null; |
| 1527 | 1534 |
} |
| ... | ... | |
| 1532 | 1539 |
try {
|
| 1533 | 1540 |
max = Double.parseDouble(lit.getValue()); |
| 1534 | 1541 |
min = -Double.MAX_VALUE; |
| 1542 |
sym.setDescription("< " + lit.getValue());
|
|
| 1535 | 1543 |
} catch (Exception exc) {
|
| 1536 | 1544 |
return null; |
| 1537 | 1545 |
} |
| ... | ... | |
| 1542 | 1550 |
} else {
|
| 1543 | 1551 |
if (oper instanceof SLDIsBetweenOperator) {
|
| 1544 | 1552 |
bw = (SLDIsBetweenOperator) oper; |
| 1553 |
SLDExpression lower = bw.getLowerBoundary(); |
|
| 1554 |
SLDExpression upper = bw.getUpperBoundary(); |
|
| 1555 |
if (lower instanceof SLDLiteral && upper instanceof SLDLiteral) {
|
|
| 1556 |
String lowerstr = ((SLDLiteral) lower).getValue(); |
|
| 1557 |
String upperstr = ((SLDLiteral) upper).getValue(); |
|
| 1558 |
try {
|
|
| 1559 |
min = Double.parseDouble(lowerstr); |
|
| 1560 |
max = Double.parseDouble(upperstr); |
|
| 1561 |
sym.setDescription(lowerstr + " - " + upperstr); |
|
| 1562 |
} catch (Exception exc) {
|
|
| 1563 |
return null; |
|
| 1564 |
} |
|
| 1565 |
} else {
|
|
| 1566 |
return null; |
|
| 1567 |
} |
|
| 1568 |
|
|
| 1545 | 1569 |
} else {
|
| 1546 | 1570 |
return null; |
| 1547 | 1571 |
} |
| ... | ... | |
| 1666 | 1690 |
SLDRule rule = null; |
| 1667 | 1691 |
SLDFeatureStyle fstyle = new SLDFeatureStyle(); |
| 1668 | 1692 |
|
| 1669 |
Object val = null;
|
|
| 1693 |
IInterval iival = null;
|
|
| 1670 | 1694 |
String valstr = null; |
| 1671 | 1695 |
Object[] vals = legend.getValues(); |
| 1672 | 1696 |
ISymbol[] syms = legend.getSymbols(); |
| 1673 | 1697 |
int n = Math.min(vals.length, syms.length); |
| 1674 | 1698 |
SLDFilter filt = null; |
| 1675 |
SLDBinaryComparisonOperator oper = null; |
|
| 1699 |
SLDComparisonOperator oper = null; |
|
| 1700 |
ISymbol elsesym = null; |
|
| 1701 |
|
|
| 1676 | 1702 |
for (int i=0; i<n; i++) {
|
| 1677 | 1703 |
rule = new SLDRule(); |
| 1678 | 1704 |
// ===================== |
| 1679 | 1705 |
sldsym = sldMan().toSLDSymbol(syms[i]); |
| 1680 | 1706 |
rule.getSymbols().add(sldsym); |
| 1681 | 1707 |
// ===================== |
| 1682 |
filt = supMan().createFilter();
|
|
| 1683 |
filt.setIsElse(false);
|
|
| 1684 |
oper = new SLDBinaryComparisonOperator();
|
|
| 1685 |
oper.setComparisonOperator(FilterTags.PROPERTYISEQUALTO);
|
|
| 1686 |
oper.setFirstExpression(new SLDPropertyName(fname));
|
|
| 1687 |
// ======= Value (Object) to String
|
|
| 1688 |
val = vals[i];
|
|
| 1689 |
valstr = valueToString(val);
|
|
| 1690 |
oper.setSecondExpression(new SLDLiteral(valstr));
|
|
| 1691 |
filt.setFilterOperator(oper);
|
|
| 1692 |
// =====================
|
|
| 1693 |
rule.setFilter(filt);
|
|
| 1694 |
// ======================
|
|
| 1695 |
fstyle.getRules().add(rule);
|
|
| 1708 |
if (vals[i] instanceof IInterval) {
|
|
| 1709 |
filt = supMan().createFilter();
|
|
| 1710 |
filt.setIsElse(false);
|
|
| 1711 |
iival = (IInterval) vals[i];
|
|
| 1712 |
oper = intervalToComparisonOperator(iival, fname);
|
|
| 1713 |
filt.setFilterOperator(oper);
|
|
| 1714 |
// =====================
|
|
| 1715 |
rule.setFilter(filt);
|
|
| 1716 |
// ======================
|
|
| 1717 |
fstyle.getRules().add(rule);
|
|
| 1718 |
} else {
|
|
| 1719 |
// assuming "Default"
|
|
| 1720 |
elsesym = syms[i];
|
|
| 1721 |
}
|
|
| 1696 | 1722 |
} |
| 1697 | 1723 |
// ================ Default symbol |
| 1698 |
ISymbol sym = legend.getDefaultSymbol(); |
|
| 1699 |
if (sym != null) {
|
|
| 1724 |
|
|
| 1725 |
// No "Default" value was found in intervals |
|
| 1726 |
// but default sym is enabled |
|
| 1727 |
if (elsesym == null && legend.isUseDefaultSymbol()) {
|
|
| 1728 |
elsesym = legend.getDefaultSymbol(); |
|
| 1729 |
} |
|
| 1730 |
|
|
| 1731 |
if (elsesym != null) {
|
|
| 1700 | 1732 |
rule = new SLDRule(); |
| 1701 |
sldsym = sldMan().toSLDSymbol(sym); |
|
| 1733 |
sldsym = sldMan().toSLDSymbol(elsesym);
|
|
| 1702 | 1734 |
rule.getSymbols().add(sldsym); |
| 1703 | 1735 |
filt = supMan().createFilter(); |
| 1704 | 1736 |
filt.setIsElse(true); |
| ... | ... | |
| 1716 | 1748 |
|
| 1717 | 1749 |
} |
| 1718 | 1750 |
|
| 1751 |
private static SLDComparisonOperator intervalToComparisonOperator( |
|
| 1752 |
IInterval iival, String fieldName) {
|
|
| 1753 |
|
|
| 1754 |
double max = iival.getMax(); |
|
| 1755 |
double min = iival.getMin(); |
|
| 1756 |
if (max == Double.MAX_VALUE && min != -Double.MAX_VALUE) {
|
|
| 1757 |
// greater than min |
|
| 1758 |
SLDBinaryComparisonOperator resp = new SLDBinaryComparisonOperator(); |
|
| 1759 |
resp.setComparisonOperator(FilterTags.PROPERTYISGREATEROREQUALTHAN); |
|
| 1760 |
resp.setFirstExpression(new SLDPropertyName(fieldName)); |
|
| 1761 |
resp.setSecondExpression(new SLDLiteral(Double.toString(min))); |
|
| 1762 |
return resp; |
|
| 1763 |
|
|
| 1764 |
} else {
|
|
| 1765 |
if (min == -Double.MAX_VALUE && max != Double.MAX_VALUE) {
|
|
| 1766 |
// less than max |
|
| 1767 |
SLDBinaryComparisonOperator resp = new SLDBinaryComparisonOperator(); |
|
| 1768 |
resp.setComparisonOperator(FilterTags.PROPERTYISLESSOREQUALTHAN); |
|
| 1769 |
resp.setFirstExpression(new SLDPropertyName(fieldName)); |
|
| 1770 |
resp.setSecondExpression(new SLDLiteral(Double.toString(max))); |
|
| 1771 |
return resp; |
|
| 1772 |
|
|
| 1773 |
} else {
|
|
| 1774 |
// normal (between) |
|
| 1775 |
SLDIsBetweenOperator resp = new SLDIsBetweenOperator(); |
|
| 1776 |
resp.setExpression(new SLDPropertyName(fieldName)); |
|
| 1777 |
resp.setLowerBoundary(new SLDLiteral(Double.toString(min))); |
|
| 1778 |
resp.setUpperBoundary(new SLDLiteral(Double.toString(max))); |
|
| 1779 |
return resp; |
|
| 1780 |
} |
|
| 1781 |
} |
|
| 1782 |
} |
|
| 1719 | 1783 |
|
| 1784 |
|
|
| 1720 | 1785 |
} |
| branches/v02_desarrollo/libraries/sld/temp/org.gvsig.sldconverter/org.gvsig.sldconverter.lib/org.gvsig.sldconverter.lib.impl/src/main/java/org/gvsig/sldconverter/impl/legend/BasicLegendConverter.java | ||
|---|---|---|
| 92 | 92 |
|
| 93 | 93 |
} else {
|
| 94 | 94 |
if (BasicUtils.areRulesOfUniqueSymbol(rules)) {
|
| 95 |
|
|
| 95 | 96 |
// ******************************************************* |
| 96 | 97 |
// * Unique symbol legend |
| 97 | 98 |
// ******************************************************* |
| ... | ... | |
| 125 | 126 |
} |
| 126 | 127 |
if (sym != null) {
|
| 127 | 128 |
unileg.setDefaultSymbol(sym); |
| 129 |
unileg.useDefaultSymbol(true); |
|
| 130 |
} else {
|
|
| 131 |
unileg.useDefaultSymbol(false); |
|
| 128 | 132 |
} |
| 129 | 133 |
String[] atts = new String[1]; |
| 130 | 134 |
atts[0] = pname; |
| 131 | 135 |
unileg.setClassifyingFieldNames(atts); |
| 136 |
int[] typs = new int[1]; |
|
| 137 |
typs[0] = dt.getType(); |
|
| 138 |
unileg.setClassifyingFieldTypes(typs); |
|
| 132 | 139 |
return unileg; |
| 133 | 140 |
|
| 134 | 141 |
} else {
|
| ... | ... | |
| 160 | 167 |
k = iter.next(); |
| 161 | 168 |
intleg.addSymbol(k, map.get(k)); |
| 162 | 169 |
} |
| 170 |
// Setting Default symbol |
|
| 163 | 171 |
if (sym != null) {
|
| 172 |
sym.setDescription("Default");
|
|
| 164 | 173 |
intleg.setDefaultSymbol(sym); |
| 174 |
intleg.useDefaultSymbol(true); |
|
| 175 |
// String among the intervals |
|
| 176 |
intleg.addSymbol(sym.getDescription(), sym); |
|
| 177 |
} else {
|
|
| 178 |
intleg.useDefaultSymbol(false); |
|
| 165 | 179 |
} |
| 180 |
|
|
| 166 | 181 |
String[] atts = new String[1]; |
| 167 | 182 |
atts[0] = pname; |
| 168 | 183 |
intleg.setClassifyingFieldNames(atts); |
| 184 |
int[] typs = new int[1]; |
|
| 185 |
typs[0] = dt.getType(); |
|
| 186 |
intleg.setClassifyingFieldTypes(typs); |
|
| 169 | 187 |
return intleg; |
| 170 | 188 |
// ******************************************************* |
| 171 | 189 |
} else {
|
| branches/v02_desarrollo/libraries/sld/temp/org.gvsig.sldconverter/org.gvsig.sldconverter.lib/org.gvsig.sldconverter.lib.impl/src/main/java/org/gvsig/sldconverter/impl/legend/BasicLegendConverterFactory.java | ||
|---|---|---|
| 31 | 31 |
|| legend instanceof IVectorialUniqueValueLegend |
| 32 | 32 |
|| legend instanceof IVectorialIntervalLegend) {
|
| 33 | 33 |
|
| 34 |
return SLDConverterManager.CAN_CONVERT_FULLY; |
|
| 34 |
/* |
|
| 35 |
* This allows precedence of converters for specific classes |
|
| 36 |
*/ |
|
| 37 |
return SLDConverterManager.CAN_CONVERT_PARTIALLY; |
|
| 35 | 38 |
} else {
|
| 36 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 39 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 37 | 40 |
} |
| 38 | 41 |
} |
| 39 | 42 |
|
| ... | ... | |
| 50 | 53 |
public int canConvert(SLDLayer layer) {
|
| 51 | 54 |
|
| 52 | 55 |
if (layer == null ) {
|
| 53 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 56 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 54 | 57 |
} |
| 55 | 58 |
|
| 56 | 59 |
if (layer instanceof SLDNamedLayer) {
|
| ... | ... | |
| 60 | 63 |
return BasicUtils.canConvertUserLayer((SLDUserLayer) layer); |
| 61 | 64 |
} else {
|
| 62 | 65 |
// Unknown layer |
| 63 |
return SLDConverterManager.CANNOT_CONVERT; |
|
| 66 |
return SLDConverterManager.CAN_NOT_CONVERT;
|
|
| 64 | 67 |
} |
| 65 | 68 |
} |
| 66 | 69 |
} |
| branches/v02_desarrollo/libraries/sld/temp/org.gvsig.sldconverter/org.gvsig.sldconverter.lib/org.gvsig.sldconverter.lib.impl/src/main/java/org/gvsig/sldconverter/impl/symbol/BasicSymbolConverterFactory.java | ||
|---|---|---|
| 6 | 6 |
import org.gvsig.sldconverter.symbol.SLDToSymbolConverterFactory; |
| 7 | 7 |
import org.gvsig.sldconverter.symbol.SymbolToSLDConverter; |
| 8 | 8 |
import org.gvsig.sldconverter.symbol.SymbolToSLDConverterFactory; |
| 9 |
import org.gvsig.sldsupport.sld.symbol.SLDLineSymbol; |
|
| 10 |
import org.gvsig.sldsupport.sld.symbol.SLDMappedColorSymbol; |
|
| 11 |
import org.gvsig.sldsupport.sld.symbol.SLDPointSymbol; |
|
| 12 |
import org.gvsig.sldsupport.sld.symbol.SLDPolygonSymbol; |
|
| 13 |
import org.gvsig.sldsupport.sld.symbol.SLDRasterSymbol; |
|
| 9 | 14 |
import org.gvsig.sldsupport.sld.symbol.SLDSymbol; |
| 15 |
import org.gvsig.sldsupport.sld.symbol.SLDTextSymbol; |
|
| 16 |
import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol; |
|
| 17 |
import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IMultiLayerFillSymbol; |
|
| 18 |
import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol; |
|
| 19 |
import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.IMultiLayerLineSymbol; |
|
| 20 |
import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol; |
|
| 21 |
import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMultiLayerMarkerSymbol; |
|
| 10 | 22 |
|
| 11 | 23 |
public class BasicSymbolConverterFactory |
| 12 | 24 |
implements SymbolToSLDConverterFactory, SLDToSymbolConverterFactory {
|
| 13 | 25 |
|
| 14 | 26 |
public int canConvert(SLDSymbol sldSym) {
|
| 15 | 27 |
|
| 16 |
return SLDConverterManager.CAN_CONVERT_FULLY; |
|
| 28 |
if (sldSym instanceof SLDPointSymbol |
|
| 29 |
|| sldSym instanceof SLDLineSymbol |
|
| 30 |
|| sldSym instanceof SLDPolygonSymbol) {
|
|
| 31 |
|
|
| 32 |
/* |
|
| 33 |
* This allows precedence of specific conversors |
|
| 34 |
*/ |
|
| 35 |
return SLDConverterManager.CAN_CONVERT_PARTIALLY; |
|
| 36 |
} else {
|
|
| 37 |
/* |
|
| 38 |
* SLDRasterSymbol |
|
| 39 |
* SLDTextSymbol |
|
| 40 |
* SLDMappedColorSymbol |
|
| 41 |
*/ |
|
| 42 |
return SLDConverterManager.CAN_NOT_CONVERT; |
|
| 43 |
} |
|
| 44 |
|
|
| 17 | 45 |
} |
| 18 | 46 |
|
| 19 | 47 |
public SLDToSymbolConverter createSLDToSymbolConverter() {
|
| ... | ... | |
| 23 | 51 |
// ====================================== |
| 24 | 52 |
|
| 25 | 53 |
public int canConvert(ISymbol sym) {
|
| 26 |
|
|
| 27 |
return SLDConverterManager.CAN_CONVERT_FULLY; |
|
| 54 |
|
|
| 55 |
if (sym instanceof IMultiLayerMarkerSymbol |
|
| 56 |
|| sym instanceof IMultiLayerLineSymbol |
|
| 57 |
|| sym instanceof IMultiLayerFillSymbol |
|
| 58 |
|| sym instanceof IMarkerSymbol |
|
| 59 |
|| sym instanceof ILineSymbol |
|
| 60 |
|| sym instanceof IFillSymbol) {
|
|
| 61 |
|
|
| 62 |
|
|
| 63 |
return SLDConverterManager.CAN_CONVERT_PARTIALLY; |
|
| 64 |
} else {
|
|
| 65 |
return SLDConverterManager.CAN_NOT_CONVERT; |
|
| 66 |
} |
|
| 28 | 67 |
} |
| 29 | 68 |
|
| 30 | 69 |
public SymbolToSLDConverter createSymbolToSLDConverter() {
|
| branches/v02_desarrollo/libraries/sld/temp/org.gvsig.sldsupport.lib.api/src/main/java/org/gvsig/sldsupport/writer/SLDWriter.java | ||
|---|---|---|
| 22 | 22 |
UnsupportedSLDObjectException, |
| 23 | 23 |
IOException; |
| 24 | 24 |
|
| 25 |
/** |
|
| 26 |
* Writes supported elements (not an invalid SLD file) |
|
| 27 |
* @param obj |
|
| 28 |
* @param outs |
|
| 29 |
* @throws IOException |
|
| 30 |
*/ |
|
| 25 | 31 |
public void forceWrite(SLDObject obj, OutputStream outs) |
| 26 | 32 |
throws IOException; |
| 27 | 33 |
|
Also available in: Unified diff