Set the feature row style into the polygon options

@param polygonOptions polygon options
@param featureRow     feature row
@return true if style was set into the polygon options
354468
public boolean setFeatureStyle(PolygonOptions polygonOptions, FeatureRow featureRow) {
        return StyleUtils.setFeatureStyle(polygonOptions, featureStyleExtension, featureRow, density);
    }
572807
public boolean setStyle(PolylineOptions polylineOptions, StyleRow style) {
        return StyleUtils.setStyle(polylineOptions, style, density);
    }
491841
public boolean setFeatureStyle(PolylineOptions polylineOptions, FeatureStyle featureStyle) {
        return StyleUtils.setFeatureStyle(polylineOptions, featureStyle, density);
    }
990788
public static MarkerOptions createMarkerOptions(StyleRow style) {

        MarkerOptions markerOptions = new MarkerOptions();
        setStyle(markerOptions, style);

        return markerOptions;
    }
556000
private Paint getStylePaint(StyleRow style, FeatureDrawType drawType) {

		Paint paint = featurePaintCache.getPaint(style, drawType);

		if (paint == null) {

			mil.nga.geopackage.style.Color color = null;
			Float strokeWidth = null;

			switch (drawType) {
			case CIRCLE:
				color = style.getColorOrDefault();
				break;
			case STROKE:
				color = style.getColorOrDefault();
				strokeWidth = this.scale * (float) style.getWidthOrDefault();
				break;
			case FILL:
				color = style.getFillColor();
				strokeWidth = this.scale * (float) style.getWidthOrDefault();
				break;
			default:
				throw new GeoPackageException("Unsupported Draw Type: "
						+ drawType);
			}

			Paint stylePaint = new Paint();
			stylePaint.setColor(new Color(color.getColorWithAlpha(), true));
			if (strokeWidth != null) {
				stylePaint.setStrokeWidth(strokeWidth);
			}

			synchronized (featurePaintCache) {

				paint = featurePaintCache.getPaint(style, drawType);

				if (paint == null) {
					featurePaintCache.setPaint(style, drawType, stylePaint);
					paint = stylePaint;
				}

			}
		}

		return paint;
	}
999566
@Nullable
  static CircleOptions fromFeature(@NonNull Feature feature) {
    if (feature.geometry() == null) {
      throw new RuntimeException("geometry field is required");
    }
    if (!(feature.geometry() instanceof Point)) {
      return null;
    }

    CircleOptions options = new CircleOptions();
    options.geometry = (Point) feature.geometry();
    if (feature.hasProperty(PROPERTY_CIRCLE_RADIUS)) {
      options.circleRadius = feature.getProperty(PROPERTY_CIRCLE_RADIUS).getAsFloat();
    }
    if (feature.hasProperty(PROPERTY_CIRCLE_COLOR)) {
      options.circleColor = feature.getProperty(PROPERTY_CIRCLE_COLOR).getAsString();
    }
    if (feature.hasProperty(PROPERTY_CIRCLE_BLUR)) {
      options.circleBlur = feature.getProperty(PROPERTY_CIRCLE_BLUR).getAsFloat();
    }
    if (feature.hasProperty(PROPERTY_CIRCLE_OPACITY)) {
      options.circleOpacity = feature.getProperty(PROPERTY_CIRCLE_OPACITY).getAsFloat();
    }
    if (feature.hasProperty(PROPERTY_CIRCLE_STROKE_WIDTH)) {
      options.circleStrokeWidth = feature.getProperty(PROPERTY_CIRCLE_STROKE_WIDTH).getAsFloat();
    }
    if (feature.hasProperty(PROPERTY_CIRCLE_STROKE_COLOR)) {
      options.circleStrokeColor = feature.getProperty(PROPERTY_CIRCLE_STROKE_COLOR).getAsString();
    }
    if (feature.hasProperty(PROPERTY_CIRCLE_STROKE_OPACITY)) {
      options.circleStrokeOpacity = feature.getProperty(PROPERTY_CIRCLE_STROKE_OPACITY).getAsFloat();
    }
    if (feature.hasProperty(PROPERTY_IS_DRAGGABLE)) {
      options.isDraggable = feature.getProperty(PROPERTY_IS_DRAGGABLE).getAsBoolean();
    }
    return options;
  }
109450
public void setLeafStyle(boolean isLeaf) {

        if (isLeaf) {
            m_leafStyleVar.setValue(CSS.listTreeItemLeaf());
        } else {
            m_leafStyleVar.setValue(CSS.listTreeItemInternal());
        }
    }
319936
public void setFeatures(Map<String, List<org.geomajas.layer.feature.Feature>> featureMap) {
		MapModel mapModel = mapWidget.getMapModel();

		for (Entry<String, List<org.geomajas.layer.feature.Feature>> clientLayerId : featureMap.entrySet()) {
			Layer<?> layer = mapModel.getLayer(clientLayerId.getKey());
			if (null != layer) {
				List<org.geomajas.layer.feature.Feature> orgFeatures = clientLayerId.getValue();
				if (!orgFeatures.isEmpty()) {
					addFeatures(layer, orgFeatures);
				}
			}
		}
	}
180478
@Api
	public void setRectangleStyle(ShapeStyle rectangleStyle) {
		this.rectangleStyle = rectangleStyle;
		if (targetRectangle != null) {
			targetRectangle.setStyle(rectangleStyle);
			render(targetRectangle, RenderGroup.SCREEN, RenderStatus.ALL);
		}
	}
960479
@Override
   public void setStylerFactory(StylerFactory stylerFactory) {
      this.stylerFactory = stylerFactory;
      try {
         FONT.initialize(stylerFactory.getSettings());
      } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) {
         throw new VectorPrintRuntimeException(ex);
      }
   }
142244
public static boolean setStyle(PolylineOptions polylineOptions, StyleRow style, float density) {

        if (style != null) {

            Color color = style.getColorOrDefault();
            polylineOptions.color(color.getColorWithAlpha());

            double width = style.getWidthOrDefault();
            polylineOptions.width((float) width * density);

        }

        return style != null;
    }
889103
function(geometry, style, featureId) {
        var components = geometry.components;
        var len = components.length;
        this.drawLinearRing(components[0], style, featureId);
        // erase inner rings
        for (var i=1; i<len; ++i) {
            /** 
             * Note that this is overly agressive.  Here we punch holes through 
             * all previously rendered features on the same canvas.  A better 
             * solution for polygons with interior rings would be to draw the 
             * polygon on a sketch canvas first.  We could erase all holes 
             * there and then copy the drawing to the layer canvas. 
             * TODO: http://trac.osgeo.org/openlayers/ticket/3130 
             */
            this.canvas.globalCompositeOperation = "destination-out";
            if (this.hitDetection) {
                this.hitContext.globalCompositeOperation = "destination-out";
            }
            this.drawLinearRing(
                components[i], 
                OpenLayers.Util.applyDefaults({stroke: false, fillOpacity: 1.0}, style),
                featureId
            );
            this.canvas.globalCompositeOperation = "source-over";
            if (this.hitDetection) {
                this.hitContext.globalCompositeOperation = "source-over";
            }
            this.drawLinearRing(
                components[i], 
                OpenLayers.Util.applyDefaults({fill: false}, style),
                featureId
            );
        }
    }
738975
public static Style createDefaultStyle( SimpleFeatureCollection featureCollection ) {
        GeometryDescriptor geometryDescriptor = featureCollection.getSchema().getGeometryDescriptor();
        Style style = null;
        if (EGeometryType.isPoint(geometryDescriptor)) {
            style = createDefaultPointStyle();
        } else if (EGeometryType.isLine(geometryDescriptor)) {
            style = createDefaultLineStyle();
        } else if (EGeometryType.isPolygon(geometryDescriptor)) {
            style = createDefaultPolygonStyle();
        }
        if (style != null) {
            style.setName(featureCollection.getSchema().getTypeName());
        }
        return style;
    }
619901
public void addFeaturePath( String featurePath, String filter ) {
        if (!featurePaths.contains(featurePath)) {
            featurePaths.add(featurePath);
            if (filter == null) {
                filter = "";
            }
            featureFilter.add(filter);
        }
    }
1277644
public void setFeaturesListLabels(Map<String, String> featuresListLabels) {
		this.featuresListLabels = featuresListLabels;
		controller.setFeaturesListLabels(featuresListLabels);
	}
653530
public static Style createDefaultPolygonStyle() {
        FeatureTypeStyle featureTypeStyle = sf.createFeatureTypeStyle();
        featureTypeStyle.rules().add(createDefaultPolygonRule());

        Style style = sf.createStyle();
        style.featureTypeStyles().add(featureTypeStyle);

        return style;
    }
100014
private void _addFeatureOnce(Object name, Feature feature) {
        String _name = String.valueOf(name);
        if (!this.feature().containsKey(_name)) {
            this.feature().put(_name, feature);
        }
    }