源码类别
热门源码
 当前位置：源码 > Java源码 >

Java源码示例：org.geotools.styling.PolygonSymbolizer

示例1
private static Style createPolygonStyle() {
    PolygonSymbolizer symbolizer = styleFactory.createPolygonSymbolizer();
    Fill fill = styleFactory.createFill(
            filterFactory.literal("#FFAA00"),
            filterFactory.literal(0.5)
    );
    final Stroke stroke = styleFactory.createStroke(filterFactory.literal(Color.BLACK),
                                                    filterFactory.literal(1));
    symbolizer.setFill(fill);
    symbolizer.setStroke(stroke);
    Rule rule = styleFactory.createRule();
    rule.symbolizers().add(symbolizer);
    FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle();
    fts.rules().add(rule);

    Style style = styleFactory.createStyle();
    style.featureTypeStyles().add(fts);
    return style;
}
示例2
@SuppressWarnings({"deprecation"})
private static Style createStyle() {
    StyleFactory styleFactory = CommonFactoryFinder.getStyleFactory(null);
    FilterFactory filterFactory = CommonFactoryFinder.getFilterFactory(null);
    PolygonSymbolizer symbolizer = styleFactory.createPolygonSymbolizer();
    Fill fill = styleFactory.createFill(
            filterFactory.literal("#FFAA00"),
            filterFactory.literal(0.5)
    );
    symbolizer.setFill(fill);
    Rule rule = styleFactory.createRule();
    rule.setSymbolizers(new Symbolizer[]{symbolizer});
    FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle();
    fts.setRules(new Rule[]{rule});

    Style style = styleFactory.createStyle();
    style.addFeatureTypeStyle(fts);
    return style;
}
示例3
@Override
public List<Symbolizer> convertToFill(String layerName, JsonElement element, int transparency) {
    if(element == null) return null;

    JsonObject obj = element.getAsJsonObject();

    List<Symbolizer> symbolizerList = new ArrayList<Symbolizer>();

    Fill fill = getFill(layerName, obj, transparency);

    PolygonSymbolizer polygon = styleFactory.createPolygonSymbolizer();
    polygon.setStroke(null);
    polygon.setFill(fill);
    symbolizerList.add(polygon);

    return symbolizerList;
}
示例4
/**
 * Returns a sample feature for the given rule, with the following criteria: - if a sample is
 * given in input is returned in output - if a sample is not given in input, scan the rule
 * symbolizers to find the one with the max dimensionality, and return a sample for that
 * dimensionality.
 *
 * @param featureType featureType used to create a sample, if none is given as input
 * @param sample feature sample to be returned as is in output, if defined
 * @param rule rule containing symbolizers to scan for max dimensionality
 */
private Feature getSampleFeatureForRule(
        FeatureType featureType, Feature sample, final Rule rule) {
    Symbolizer[] symbolizers = rule.getSymbolizers();
    // if we don't have a sample as input, we need to create a sampleFeature
    // looking at the requested symbolizers (we chose the one with the max
    // dimensionality and create a congruent sample)
    if (sample == null) {
        int dimensionality = 1;
        for (int sIdx = 0; sIdx < symbolizers.length; sIdx++) {
            final Symbolizer symbolizer = symbolizers[sIdx];
            if (LineSymbolizer.class.isAssignableFrom(symbolizer.getClass())) {
                dimensionality = 2;
            }
            if (PolygonSymbolizer.class.isAssignableFrom(symbolizer.getClass())) {
                dimensionality = 3;
            }
        }
        return createSampleFeature(featureType, dimensionality);
    } else {
        return sample;
    }
}
示例5
/**
 * (non-Javadoc)
 *
 * @see
 *     org.geotools.styling.visitor.DuplicatingStyleVisitor#visit(org.geotools.styling.PolygonSymbolizer)
 */
@Override
public void visit(PolygonSymbolizer poly) {
    PolygonSymbolizer copy = sf.createPolygonSymbolizer();
    copy.setFill(copy(poly.getFill()));

    copy.setGeometry(copy(MultiPolygon.class, poly.getGeometry()));

    copy.setUnitOfMeasure(poly.getUnitOfMeasure());
    copy.setStroke(copy(poly.getStroke()));
    copy.getOptions().putAll(poly.getOptions());

    if (STRICT && !copy.equals(poly)) {
        throw new IllegalStateException(
                "Was unable to duplicate provided PolygonSymbolizer:" + poly);
    }
    pages.push(copy);
}
示例6
/**
 * (non-Javadoc)
 *
 * @see
 *     org.geotools.styling.visitor.DuplicatingStyleVisitor#visit(org.geotools.styling.PolygonSymbolizer)
 */
public void visit(PolygonSymbolizer poly) {
    PolygonSymbolizer copy = sf.createPolygonSymbolizer();
    copy.setFill(copy(poly.getFill()));

    copy.setGeometry(copy(poly.getGeometry()));

    copy.setUnitOfMeasure(poly.getUnitOfMeasure());
    copy.setStroke(copy(poly.getStroke()));
    copy.getOptions().putAll(poly.getOptions());

    if (STRICT && !copy.equals(poly)) {
        throw new IllegalStateException(
                "Was unable to duplicate provided PolygonSymbolizer:" + poly);
    }
    pages.push(copy);
}
示例7
/**
 * Populate symbolizer.
 *
 * @param ruleTreeNode the rule tree node
 * @param symbolizer the symbolizer
 */
private void populateSymbolizer(DefaultMutableTreeNode ruleTreeNode, Symbolizer symbolizer) {
    DefaultMutableTreeNode symbolizerTreeNode = addObject(ruleTreeNode, symbolizer, true);

    if ((symbolizer instanceof PointSymbolizer) || (symbolizer instanceof PolygonSymbolizer)) {
        addObject(
                symbolizerTreeNode, SLDTreeLeafFactory.getInstance().getFill(symbolizer), true);
    }

    if ((symbolizer instanceof PolygonSymbolizer) || (symbolizer instanceof LineSymbolizer)) {
        addObject(
                symbolizerTreeNode,
                SLDTreeLeafFactory.getInstance().getStroke(symbolizer),
                true);
    }

    if (symbolizer instanceof RasterSymbolizer) {
        handleRasterSymbolizer(symbolizer, symbolizerTreeNode);
    }
}
示例8
@Override
public void populate(SelectedSymbol selectedSymbol) {

    if (selectedSymbol != null) {
        PolygonSymbolizer polygonSymbolizer =
                (PolygonSymbolizer) selectedSymbol.getSymbolizer();
        if (polygonSymbolizer != null) {
            populateStandardData(polygonSymbolizer);

            fieldConfigVisitor.populateField(
                    FieldIdEnum.PERPENDICULAR_OFFSET,
                    polygonSymbolizer.getPerpendicularOffset());

            fieldConfigVisitor.populateField(
                    FieldIdEnum.GEOMETRY, polygonSymbolizer.getGeometry());
        }
    }
}
示例9
protected boolean skipSymbolizer(Symbolizer symbolizer) {
	if (symbolizer instanceof TextSymbolizer) {
		if (!isIncludeText()) {
			return true;
		}
	} else if (symbolizer instanceof LineSymbolizer) {
		if (!isIncludeGeometry()) {
			return true;
		}
	} else if (symbolizer instanceof PointSymbolizer) {
		if (!isIncludeGeometry()) {
			return true;
		}
	} else if (symbolizer instanceof PolygonSymbolizer) {
		if (!isIncludeGeometry()) {
			return true;
		}
	} else if (symbolizer instanceof RasterSymbolizer) {
		if (!isIncludeGeometry()) {
			return true;
		}
	}
	return false;
}
示例10
/**
 * Test method for {@link
 * com.sldeditor.common.tree.leaf.SLDTreeLeafFactory#hasFill(org.opengis.style.Symbolizer)}.
 */
@Test
public void testHasFill() {
    PolygonSymbolizer polygonSymbolizer = DefaultSymbols.createDefaultPolygonSymbolizer();
    PointSymbolizer pointSymbolizer = DefaultSymbols.createDefaultPointSymbolizer();
    // CHECKSTYLE:OFF
    LineSymbolizer lineSymbolizer = DefaultSymbols.createDefaultLineSymbolizer();
    TextSymbolizer textSymbolizer = DefaultSymbols.createDefaultTextSymbolizer();
    // CHECKSTYLE:ON

    assertFalse(SLDTreeLeafFactory.getInstance().hasFill(null));
    assertTrue(SLDTreeLeafFactory.getInstance().hasFill(polygonSymbolizer));
    assertTrue(SLDTreeLeafFactory.getInstance().hasFill(pointSymbolizer));
    assertFalse(SLDTreeLeafFactory.getInstance().hasFill(lineSymbolizer));
    assertFalse(SLDTreeLeafFactory.getInstance().hasFill(textSymbolizer));
}
示例11
/**
 * Test method for {@link
 * com.sldeditor.common.tree.leaf.SLDTreeLeafFactory#getFill(org.opengis.style.Symbolizer)}.
 */
@Test
public void testGetFill() {
    PolygonSymbolizer polygonSymbolizer = DefaultSymbols.createDefaultPolygonSymbolizer();
    PointSymbolizer pointSymbolizer = DefaultSymbols.createDefaultPointSymbolizer();
    // CHECKSTYLE:OFF
    LineSymbolizer lineSymbolizer = DefaultSymbols.createDefaultLineSymbolizer();
    TextSymbolizer textSymbolizer = DefaultSymbols.createDefaultTextSymbolizer();
    // CHECKSTYLE:ON

    assertNull(SLDTreeLeafFactory.getInstance().getFill(null));
    assertTrue(SLDTreeLeafFactory.getInstance().getFill(polygonSymbolizer) != null);
    assertTrue(SLDTreeLeafFactory.getInstance().getFill(pointSymbolizer) != null);

    // Returns default fill
    assertTrue(SLDTreeLeafFactory.getInstance().getFill(lineSymbolizer) != null);
    assertTrue(SLDTreeLeafFactory.getInstance().getFill(textSymbolizer) != null);
}
示例12
/**
 * Test method for {@link
 * com.sldeditor.common.tree.leaf.SLDTreeLeafFactory#hasStroke(org.opengis.style.Symbolizer)}.
 */
@Test
public void testHasStroke() {
    PolygonSymbolizer polygonSymbolizer = DefaultSymbols.createDefaultPolygonSymbolizer();
    PointSymbolizer pointSymbolizer = DefaultSymbols.createDefaultPointSymbolizer();
    // CHECKSTYLE:OFF
    LineSymbolizer lineSymbolizer = DefaultSymbols.createDefaultLineSymbolizer();
    TextSymbolizer textSymbolizer = DefaultSymbols.createDefaultTextSymbolizer();
    // CHECKSTYLE:ON

    assertFalse(SLDTreeLeafFactory.getInstance().hasStroke(null));
    assertTrue(SLDTreeLeafFactory.getInstance().hasStroke(polygonSymbolizer));
    assertFalse(SLDTreeLeafFactory.getInstance().hasStroke(pointSymbolizer));
    assertTrue(SLDTreeLeafFactory.getInstance().hasStroke(lineSymbolizer));
    assertFalse(SLDTreeLeafFactory.getInstance().hasStroke(textSymbolizer));
}
示例13
@Override
public void getMinimumVersion(
        Object parentObj, Object sldObj, List<VendorOptionPresent> vendorOptionsPresentList) {

    if (parentObj instanceof PolygonSymbolizer) {
        PolygonSymbolizer polygon = (PolygonSymbolizer) parentObj;
        Map<String, String> options = polygon.getOptions();

        for (Entry<FieldIdEnum, String> entry : fieldMap.entrySet()) {
            String vendorOptionAttributeKey = entry.getValue();

            if (options.containsKey(vendorOptionAttributeKey)) {
                VendorOptionPresent voPresent =
                        new VendorOptionPresent(sldObj, getVendorOptionInfo());

                if (vendorOptionsPresentList != null) {
                    vendorOptionsPresentList.add(voPresent);
                }
            }
        }
    }
}
示例14
/**
 * Gets the graphic.
 *
 * @param symbolizer the symbolizer
 * @return the graphic
 */
private Graphic getGraphic(Symbolizer symbolizer) {
    Graphic graphic = null;

    if (symbolizer instanceof PointSymbolizerImpl) {
        PointSymbolizer pointSymbolizer = (PointSymbolizer) symbolizer;
        graphic = pointSymbolizer.getGraphic();
    } else if (symbolizer instanceof PolygonSymbolizerImpl) {
        PolygonSymbolizer polygonSymbolizer = (PolygonSymbolizer) symbolizer;
        if (polygonSymbolizer != null) {
            Fill fill = polygonSymbolizer.getFill();

            if (fill != null) {
                graphic = fill.getGraphicFill();
            }
        }
    }

    return graphic;
}
示例15
/** Test new polygon sld. */
@Test
public void testNewPolygonSLD() {
    NewPolygonSLD newData = new NewPolygonSLD();

    StyledLayerDescriptor sld = newData.create();

    assertTrue(sld.layers().size() == 1);

    StyledLayer styledLayer = sld.layers().get(0);

    NamedLayer namedLayer = (NamedLayer) styledLayer;

    Symbolizer symbolizer =
            namedLayer
                    .styles()
                    .get(0)
                    .featureTypeStyles()
                    .get(0)
                    .rules()
                    .get(0)
                    .symbolizers()
                    .get(0);

    assertTrue(symbolizer instanceof PolygonSymbolizer);
}
示例16
/**
 * Test method for {@link
 * com.sldeditor.common.tree.leaf.SLDTreeLeafFactory#getStroke(org.opengis.style.Symbolizer)}.
 */
@Test
public void testGetStroke() {
    PolygonSymbolizer polygonSymbolizer = DefaultSymbols.createDefaultPolygonSymbolizer();
    // CHECKSTYLE:OFF
    PointSymbolizer pointSymbolizer = DefaultSymbols.createDefaultPointSymbolizer();
    LineSymbolizer lineSymbolizer = DefaultSymbols.createDefaultLineSymbolizer();
    TextSymbolizer textSymbolizer = DefaultSymbols.createDefaultTextSymbolizer();
    // CHECKSTYLE:ON

    assertNull(SLDTreeLeafFactory.getInstance().getStroke(null));
    assertTrue(SLDTreeLeafFactory.getInstance().getStroke(polygonSymbolizer) != null);
    assertTrue(SLDTreeLeafFactory.getInstance().getStroke(lineSymbolizer) != null);

    // Returns default stroke
    assertTrue(SLDTreeLeafFactory.getInstance().getStroke(pointSymbolizer) != null);
    assertTrue(SLDTreeLeafFactory.getInstance().getStroke(textSymbolizer) != null);
}
示例17
private static Style createLineStyle() {
    final StyleFactory styleFactory = CommonFactoryFinder.getStyleFactory();
    final FilterFactory filterFactory = CommonFactoryFinder.getFilterFactory();

    // create a partially opaque outline stroke
    final Stroke stroke = styleFactory.createStroke(
            filterFactory.literal(Color.WHITE),
            filterFactory.literal(1),
            filterFactory.literal(.5)
    );

    // create a partially opaque fill
    final Fill fill = styleFactory.createFill(
            filterFactory.literal(Color.RED),
            filterFactory.literal(.25)
    );

    // setting the geometryPropertyName arg to null signals that we want to draw the default geometry of features
    final PolygonSymbolizer sym = styleFactory.createPolygonSymbolizer(stroke, fill, null);

    // make rule
    final Rule rule = styleFactory.createRule();
    rule.symbolizers().add(sym);

    final FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle(new Rule[]{rule});
    final Style style = styleFactory.createStyle();
    style.getDescription().setTitle("Line Style");
    style.featureTypeStyles().add(fts);

    return style;
}
示例18
@Override
public void convert(Rule rule, JsonElement element, String layerName, int transparency) {
    if(element == null) return;
    if(rule == null) return;

    JsonObject obj = element.getAsJsonObject();
    @SuppressWarnings("unused")
    int style = getInt(obj, CommonSymbolKeys.STYLE);

    List<Symbolizer> symbolizerList = rule.symbolizers();

    JsonElement jsonOutlineElement = obj.get(SimpleFillSymbolKeys.OUTLINE);
    List<Stroke> strokeList = SymbolManager.getInstance().getStrokeList(jsonOutlineElement);

    Stroke stroke = null;

    if(strokeList != null)
    {
        if(!strokeList.isEmpty())
        {
            stroke = strokeList.get(0);
        }
    }

    Expression fillColour = getColour(obj.get(SimpleFillSymbolKeys.FILL_COLOUR));

    Fill fill = null;

    if(fillColour != null)
    {
        fill = styleFactory.createFill(fillColour, getTransparency(transparency));
    }

    PolygonSymbolizer polygonSymbolizer = styleFactory.createPolygonSymbolizer(stroke, fill, null);

    symbolizerList.add(polygonSymbolizer);
}
示例19
private void checkFillExists() {
    if (fill == null) {
        if (fillColor == null) {
            fillColor = DEFAULT_COLOR;
        }
        fill = sf.createFill(ff.literal(fillColor));
        PolygonSymbolizer polygonSymbolizer = (PolygonSymbolizer) getSymbolizer();
        polygonSymbolizer.setFill(fill);
        fillGraphicFill = fill.getGraphicFill();
    }
}
示例20
/**
 * Handle raster symbolizer.
 *
 * @param symbolizer the symbolizer
 * @param symbolizerTreeNode the symbolizer tree node
 */
private void handleRasterSymbolizer(
        Symbolizer symbolizer, DefaultMutableTreeNode symbolizerTreeNode) {
    // Handle the image outline symbolizer for raster symbols
    Symbolizer outlineSymbolizer = ((RasterSymbolizer) symbolizer).getImageOutline();

    if (outlineSymbolizer instanceof LineSymbolizer) {
        LineSymbolizer outlineLineSymbolizer = (LineSymbolizer) outlineSymbolizer;
        DefaultMutableTreeNode symbolizerImageOutlineLineNode =
                addObject(symbolizerTreeNode, outlineLineSymbolizer, true);

        addObject(
                symbolizerImageOutlineLineNode,
                SLDTreeLeafFactory.getInstance().getStroke(outlineLineSymbolizer),
                true);
    } else if (outlineSymbolizer instanceof PolygonSymbolizer) {
        PolygonSymbolizer outlinePolygonSymbolizer = (PolygonSymbolizer) outlineSymbolizer;

        DefaultMutableTreeNode symbolizerImageOutlinePolygonNode =
                addObject(symbolizerTreeNode, outlinePolygonSymbolizer, true);

        addObject(
                symbolizerImageOutlinePolygonNode,
                SLDTreeLeafFactory.getInstance().getFill(outlinePolygonSymbolizer),
                true);
        addObject(
                symbolizerImageOutlinePolygonNode,
                SLDTreeLeafFactory.getInstance().getStroke(outlinePolygonSymbolizer),
                true);
    }
}
示例21
/**
 * Test method for {@link
 * com.sldeditor.common.tree.leaf.SLDTreeLeafPolygon#removeStroke(org.opengis.style.Symbolizer)}.
 */
@Test
public void testRemoveStroke() {
    SLDTreeLeafPolygon leaf = new SLDTreeLeafPolygon();

    PolygonSymbolizer polygonSymbolizer = DefaultSymbols.createDefaultPolygonSymbolizer();
    leaf.removeStroke(polygonSymbolizer);

    assertNull(polygonSymbolizer.getStroke());
}
示例22
private LiteShape2 getSampleShape(Symbolizer symbolizer, int width, int height) {
	MetaBufferEstimator estimator = new MetaBufferEstimator();
	estimator.visit(symbolizer);
	// add an extra pixel to the margin (odd line widths were not always shown)
	int margin = estimator.getBuffer() + 1;
	// we define a shape in WKT of size 1 x 1 and transform it to a rectangle of (width-margin) x (height-margin),
	// to make sure we capture thick strokes
	MathTransform transform = new AffineTransform2D(width - margin, 0, 0, height - margin, 0.5 * margin,
			0.5 * margin);
	try {
		WKTReader wktReader = new WKTReader();
		if (symbolizer instanceof LineSymbolizer) {
			return new LiteShape2(wktReader.read("LINESTRING (0 0, 0.66 0.33, 0.33 0.66, 1 1)"), transform, null,
					false);
		} else if (symbolizer instanceof PolygonSymbolizer) {
			return new LiteShape2(wktReader.read("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))"), transform, null, false);
		} else if (symbolizer instanceof PointSymbolizer) {
			return new LiteShape2(wktReader.read("POINT (0.5 0.5)"), transform, null, false);
		} else {
			return null;
		}
	} catch (Exception e) { // NOSONAR
		// should not happen
		log.warn("Could not create sample shapes", e);
		return null;
	}
}
示例23
/**
 * Creates a default {@link Rule} for a polygon.
 * 
 * @return the default rule.
 */
public static Rule createDefaultPolygonRule() {
    PolygonSymbolizer polygonSymbolizer = sf.createPolygonSymbolizer();
    Fill fill = createDefaultFill();
    polygonSymbolizer.setFill(fill);
    polygonSymbolizer.setStroke(createDefaultStroke());

    Rule rule = sf.createRule();
    rule.setName("New rule");
    rule.symbolizers().add(polygonSymbolizer);

    return rule;
}
示例24
/** Update symbol. */
private void updateSymbol() {
    if (!Controller.getInstance().isPopulating()) {
        Expression geometryField = ExtractGeometryField.getGeometryField(fieldConfigVisitor);

        Expression perpendicularOffset =
                fieldConfigVisitor.getExpression(FieldIdEnum.PERPENDICULAR_OFFSET);

        //
        // Displacement
        //
        Displacement displacement = null;

        StandardData standardData = getStandardData();

        PolygonSymbolizer polygonSymbolizer =
                (PolygonSymbolizer) SelectedSymbol.getInstance().getSymbolizer();

        if (polygonSymbolizer != null) {
            polygonSymbolizer.setName(standardData.getName());
            polygonSymbolizer.setDescription(standardData.getDescription());
            polygonSymbolizer.setUnitOfMeasure(
                    (standardData.getUnit() != null) ? standardData.getUnit().getUnit() : null);

            polygonSymbolizer.setDisplacement(displacement);
            polygonSymbolizer.setGeometry(geometryField);
            polygonSymbolizer.setPerpendicularOffset(perpendicularOffset);

            this.fireUpdateSymbol();
        }
    }
}
示例25
/** Update symbol. */
private void updateSymbol() {
    if (!Controller.getInstance().isPopulating()) {
        if (symbolizer instanceof PolygonSymbolizer) {
            PolygonSymbolizerImpl newPolygonSymbolizer = (PolygonSymbolizerImpl) symbolizer;

            GraphicFill graphicFill = getGraphicFill();
            Fill fill = symbolTypeFactory.getFill(graphicFill, this.fieldConfigManager);

            Expression expOpacity =
                    fieldConfigVisitor.getExpression(FieldIdEnum.OVERALL_OPACITY);

            // If field is not enabled it returns null
            if ((fill != null) && (expOpacity != null)) {
                fill.setOpacity(expOpacity);
            }

            newPolygonSymbolizer.setFill(fill);

            if (vendorOptionFillFactory != null) {
                vendorOptionFillFactory.updateSymbol(newPolygonSymbolizer);
            }
        }

        this.fireUpdateSymbol();
    }
}
示例26
/**
 * Populate.
 *
 * @param polygonSymbolizer the polygon symbolizer
 */
/*
 * (non-Javadoc)
 *
 * @see
 * com.sldeditor.ui.detail.vendor.geoserver.VendorOptionInterface#populate(org.geotools.styling.
 * PolygonSymbolizer)
 */
@Override
public void populate(PolygonSymbolizer polygonSymbolizer) {
    // Do nothing
}
示例27
/**
 * Update symbol.
 *
 * @param polygonSymbolizer the polygon symbolizer
 */
/*
 * (non-Javadoc)
 *
 * @see
 * com.sldeditor.ui.detail.vendor.geoserver.VendorOptionInterface#updateSymbol(org.geotools.
 * styling.PolygonSymbolizer)
 */
@Override
public void updateSymbol(PolygonSymbolizer polygonSymbolizer) {
    // Do nothing
}
示例28
/**
 * Populate.
 *
 * @param polygonSymbolizer the polygon symbolizer
 */
/*
 * (non-Javadoc)
 *
 * @see
 * com.sldeditor.ui.detail.vendor.geoserver.VendorOptionInterface#populate(org.geotools.styling.
 * PolygonSymbolizer)
 */
@Override
public void populate(PolygonSymbolizer polygonSymbolizer) {
    // Do nothing
}
示例29
/**
 * Update symbol.
 *
 * @param polygonSymbolizer the polygon symbolizer
 */
/*
 * (non-Javadoc)
 *
 * @see
 * com.sldeditor.ui.detail.vendor.geoserver.VendorOptionInterface#updateSymbol(org.geotools.
 * styling.PolygonSymbolizer)
 */
@Override
public void updateSymbol(PolygonSymbolizer polygonSymbolizer) {
    // Do nothing
}
示例30
/**
 * Populate.
 *
 * @param polygonSymbolizer the polygon symbolizer
 */
/*
 * (non-Javadoc)
 *
 * @see
 * com.sldeditor.ui.detail.vendor.geoserver.VendorOptionInterface#populate(org.geotools.styling.
 * PolygonSymbolizer)
 */
@Override
public void populate(PolygonSymbolizer polygonSymbolizer) {
    // Do nothing
}