Merge pull request #912 from tschaub/seperate-fill-stroke

Separate fill and stroke symbolizers.  Allow styles with no rules (and also support "else" symbolizers).

examples/getfeatureinfo.js

@@ -6,8 +6,7 @@ goog.require('ol.layer.Vector');
 goog.require('ol.parser.GeoJSON');
 goog.require('ol.source.TiledWMS');
 goog.require('ol.source.Vector');
-goog.require('ol.style.Polygon');
+goog.require('ol.style.Stroke');
-goog.require('ol.style.Rule');
 goog.require('ol.style.Style');
 
 
@@ -23,15 +22,14 @@ var vector = new ol.layer.Vector({
     parser: new ol.parser.GeoJSON(),
     url: 'data/countries.geojson'
   }),
-  style: new ol.style.Style({rules: [
+  style: new ol.style.Style({
-    new ol.style.Rule({
+    symbolizers: [
-      symbolizers: [
+      new ol.style.Stroke({
-        new ol.style.Polygon({
+        color: '#33cc66',
-          strokeColor: '#bada55'
+        width: 2
-        })
+      })
-      ]
+    ]
-    })
+  }),
-  ]}),
   transformFeatureInfo: function(features) {
     return features.length > 0 ?
         features[0].getFeatureId() + ': ' + features[0].get('name') : ' ';

examples/gml.js

@@ -6,8 +6,8 @@ goog.require('ol.layer.Vector');
 goog.require('ol.parser.ogc.GML_v3');
 goog.require('ol.source.MapQuestOpenAerial');
 goog.require('ol.source.Vector');
-goog.require('ol.style.Polygon');
+goog.require('ol.style.Fill');
-goog.require('ol.style.Rule');
+goog.require('ol.style.Stroke');
 goog.require('ol.style.Style');
 
 var raster = new ol.layer.TileLayer({
@@ -19,15 +19,17 @@ var vector = new ol.layer.Vector({
     parser: new ol.parser.ogc.GML_v3(),
     url: 'data/gml/topp-states-wfs.xml'
   }),
-  style: new ol.style.Style({rules: [
+  style: new ol.style.Style({
-    new ol.style.Rule({
+    symbolizers: [
-      symbolizers: [
+      new ol.style.Fill({
-        new ol.style.Polygon({
+        color: '#ffffff',
-          strokeColor: '#bada55'
+        opacity: 0.25
-        })
+      }),
-      ]
+      new ol.style.Stroke({
-    })
+        color: '#6666ff'
-  ]})
+      })
+    ]
+  })
 });
 
 var map = new ol.Map({
@@ -35,7 +37,7 @@ var map = new ol.Map({
   renderer: ol.RendererHint.CANVAS,
   target: 'map',
   view: new ol.View2D({
-    center: [-10997171.194994785, 5206335.565590534],
+    center: [-10997171, 4658434],
     zoom: 4
   })
 });

examples/kml-timezones.js

@@ -7,8 +7,8 @@ goog.require('ol.layer.Vector');
 goog.require('ol.parser.KML');
 goog.require('ol.source.Stamen');
 goog.require('ol.source.Vector');
-goog.require('ol.style.Polygon');
+goog.require('ol.style.Fill');
-goog.require('ol.style.Rule');
+goog.require('ol.style.Stroke');
 goog.require('ol.style.Style');
 
 
@@ -40,17 +40,17 @@ ol.expr.register('getOpacity', function() {
   return 0.75 * (1 - delta / 12);
 });
 
-var style = new ol.style.Style({rules: [
+var style = new ol.style.Style({
-  new ol.style.Rule({
+  symbolizers: [
-    symbolizers: [
+    new ol.style.Fill({
-      new ol.style.Polygon({
+      color: '#ffff33',
-        strokeColor: '#ffffff',
+      opacity: ol.expr.parse('getOpacity()')
-        fillColor: '#ffff33',
+    }),
-        fillOpacity: ol.expr.parse('getOpacity()')
+    new ol.style.Stroke({
-      })
+      color: '#ffffff'
-    ]
+    })
-  })
+  ]
-]});
+});
 
 var vector = new ol.layer.Vector({
   source: new ol.source.Vector({

examples/style-rules.js

@@ -7,9 +7,10 @@ goog.require('ol.layer.Vector');
 goog.require('ol.parser.GeoJSON');
 goog.require('ol.proj');
 goog.require('ol.source.Vector');
-goog.require('ol.style.Line');
+goog.require('ol.style.Fill');
 goog.require('ol.style.Rule');
 goog.require('ol.style.Shape');
+goog.require('ol.style.Stroke');
 goog.require('ol.style.Style');
 goog.require('ol.style.Text');
 
@@ -18,25 +19,25 @@ var style = new ol.style.Style({rules: [
   new ol.style.Rule({
     filter: 'where == "outer"',
     symbolizers: [
-      new ol.style.Line({
+      new ol.style.Stroke({
-        strokeColor: ol.expr.parse('color'),
+        color: ol.expr.parse('color'),
-        strokeWidth: 4,
+        width: 4,
-        strokeOpacity: 1
+        opacity: 1
       })
     ]
   }),
   new ol.style.Rule({
     filter: 'where == "inner"',
     symbolizers: [
-      new ol.style.Line({
+      new ol.style.Stroke({
-        strokeColor: '#013',
+        color: '#013',
-        strokeWidth: 4,
+        width: 4,
-        strokeOpacity: 1
+        opacity: 1
       }),
-      new ol.style.Line({
+      new ol.style.Stroke({
-        strokeColor: ol.expr.parse('color'),
+        color: ol.expr.parse('color'),
-        strokeWidth: 2,
+        width: 2,
-        strokeOpacity: 1
+        opacity: 1
       })
     ]
   }),
@@ -45,7 +46,7 @@ var style = new ol.style.Style({rules: [
     symbolizers: [
       new ol.style.Shape({
         size: 40,
-        fillColor: '#013'
+        fill: new ol.style.Fill({color: '#013'})
       }),
       new ol.style.Text({
         color: '#bada55',

examples/topojson.js

@@ -6,8 +6,8 @@ goog.require('ol.layer.Vector');
 goog.require('ol.parser.TopoJSON');
 goog.require('ol.source.TileJSON');
 goog.require('ol.source.Vector');
-goog.require('ol.style.Polygon');
+goog.require('ol.style.Fill');
-goog.require('ol.style.Rule');
+goog.require('ol.style.Stroke');
 goog.require('ol.style.Style');
 
 
@@ -22,19 +22,19 @@ var vector = new ol.layer.Vector({
     url: 'data/topojson/world-110m.json',
     parser: new ol.parser.TopoJSON()
   }),
-  style: new ol.style.Style({rules: [
+  style: new ol.style.Style({
-    new ol.style.Rule({
+    symbolizers: [
-      symbolizers: [
+      new ol.style.Fill({
-        new ol.style.Polygon({
+        color: '#BADA55',
-          fillColor: '#BADA55',
+        opacity: 0.5
-          fillOpacity: 0.5,
+      }),
-          strokeColor: '#FFF',
+      new ol.style.Stroke({
-          strokeOpacity: 1,
+        color: '#FFF',
-          strokeWidth: 1.5
+        opacity: 1,
-        })
+        width: 1.5
-      ]
+      })
-    })
+    ]
-  ]})
+  })
 });
 
 var map = new ol.Map({

examples/vector-layer.js

@@ -7,8 +7,9 @@ goog.require('ol.layer.Vector');
 goog.require('ol.parser.GeoJSON');
 goog.require('ol.source.MapQuestOpenAerial');
 goog.require('ol.source.Vector');
-goog.require('ol.style.Polygon');
+goog.require('ol.style.Fill');
 goog.require('ol.style.Rule');
+goog.require('ol.style.Stroke');
 goog.require('ol.style.Style');
 goog.require('ol.style.Text');
 
@@ -30,11 +31,13 @@ var vector = new ol.layer.Vector({
   style: new ol.style.Style({rules: [
     new ol.style.Rule({
       symbolizers: [
-        new ol.style.Polygon({
+        new ol.style.Fill({
-          strokeColor: '#319FD3',
+          color: '#ffffff',
-          strokeOpacity: 1,
+          opacity: 0.6
-          fillColor: '#ffffff',
+        }),
-          fillOpacity: 0.6
+        new ol.style.Stroke({
+          color: '#319FD3',
+          opacity: 1
         })
       ]
     }),

src/objectliterals.jsdoc

@@ -612,23 +612,9 @@
  */
 
 /**
- * @typedef {Object} ol.style.LineOptions
+ * @typedef {Object} ol.style.FillOptions
- * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
+ * @property {string|ol.expr.Expression|undefined} color Fill color as hex color
- *     color as hex color code.
+ *     code.
- * @property {number|ol.expr.Expression|undefined} strokeOpacity Stroke
- *     opacity (0-1).
- * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
- *     width in pixels.
- */
-
-/**
- * @typedef {Object} ol.style.PolygonOptions
- * @property {string|ol.expr.Expression|undefined} fillColor Fill color as
- *     hex color code.
- * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
- *     color as hex color code.
- * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
- *     width in pixels.
  * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
  */
 
@@ -642,21 +628,24 @@
  * @typedef {Object} ol.style.ShapeOptions
  * @property {ol.style.ShapeType|undefined} type Type.
  * @property {number|ol.expr.Expression|undefined} size Size in pixels.
- * @property {string|ol.expr.Expression|undefined} fillColor Fill color as
+ * @property {ol.style.Fill|undefined} fill Fill symbolizer for shape.
- *     hex color code.
+ * @property {ol.style.Stroke|undefined} stroke Stroke symbolizer for shape.
- * @property {number|ol.expr.Expression|undefined} fillOpacity Fill opacity
+ */
- *     (0-1).
+
- * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
+/**
- *     color as hex color code.
+ * @typedef {Object} ol.style.StrokeOptions
- * @property {number|ol.expr.Expression|undefined} strokeOpacity Stroke opacity
+ * @property {string|ol.expr.Expression|undefined} color Stroke color as hex
- *     (0-1).
+ *     color code.
- * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
+ * @property {number|ol.expr.Expression|undefined} opacity Stroke opacity (0-1).
- *     width in pixels.
+ * @property {number|ol.expr.Expression|undefined} width Stroke width in pixels.
  */
 
 /**
  * @typedef {Object} ol.style.StyleOptions
- * @property {Array.<ol.style.Rule>} rules Rules.
+ * @property {Array.<ol.style.Rule>|undefined} rules Rules.
+ * @property {Array.<ol.style.Symbolizer>|undefined} symbolizers Symbolizers
+ *     (that apply if no rules are provided or where none of the provided rules
+ *     apply).
  */
 
 /**

src/ol/feature.js

@@ -84,18 +84,11 @@ ol.Feature.prototype.getGeometry = function() {
 
 
 /**
- * @return {Array.<ol.style.SymbolizerLiteral>} Symbolizer literals.
+ * Get any symbolizers set directly on the feature.
+ * @return {Array.<ol.style.Symbolizer>} Symbolizers (or null if none).
  */
-ol.Feature.prototype.getSymbolizerLiterals = function() {
+ol.Feature.prototype.getSymbolizers = function() {
-  var symbolizerLiterals = null;
+  return this.symbolizers_;
-  if (!goog.isNull(this.symbolizers_)) {
-    var numSymbolizers = this.symbolizers_.length;
-    symbolizerLiterals = new Array(numSymbolizers);
-    for (var i = 0; i < numSymbolizers; ++i) {
-      symbolizerLiterals[i] = this.symbolizers_[i].createLiteral(this);
-    }
-  }
-  return symbolizerLiterals;
 };
 
 

src/ol/layer/vectorlayer.js

@@ -384,15 +384,21 @@ ol.layer.Vector.prototype.groupFeaturesBySymbolizerLiteral =
   var uniqueLiterals = {},
       featuresBySymbolizer = [],
       style = this.style_,
-      i, j, l, feature, literals, numLiterals, literal, uniqueLiteral, key,
+      i, j, l, feature, symbolizers, literals, numLiterals, literal,
-      item;
+      uniqueLiteral, key, item;
   for (i in features) {
     feature = features[i];
-    literals = feature.getSymbolizerLiterals();
+    // feature level symbolizers take precedence
-    if (goog.isNull(literals)) {
+    symbolizers = feature.getSymbolizers();
-      literals = goog.isNull(style) ?
+    if (!goog.isNull(symbolizers)) {
-          ol.style.Style.applyDefaultStyle(feature) :
+      literals = ol.style.Style.createLiterals(symbolizers, feature);
-          style.apply(feature);
+    } else {
+      if (!goog.isNull(style)) {
+        // layer style second
+        literals = style.createLiterals(feature);
+      } else {
+        literals = ol.style.Style.defaults.createLiterals(feature);
+      }
     }
     numLiterals = literals.length;
     for (j = 0; j < numLiterals; ++j) {
@@ -409,7 +415,7 @@ ol.layer.Vector.prototype.groupFeaturesBySymbolizerLiteral =
         uniqueLiterals[key] = featuresBySymbolizer.length;
         featuresBySymbolizer.push([
           /** @type {Array.<ol.Feature>} */ ([]),
-          /** @type {ol.style.SymbolizerLiteral} */ (literal),
+          /** @type {ol.style.Literal} */ (literal),
           /** @type {Array} */ ([])
         ]);
       }

src/ol/parser/kml.js

@@ -27,11 +27,9 @@ goog.require('ol.parser.DomFeatureParser');
 goog.require('ol.parser.ReadFeaturesOptions');
 goog.require('ol.parser.StringFeatureParser');
 goog.require('ol.parser.XML');
+goog.require('ol.style.Fill');
 goog.require('ol.style.Icon');
-goog.require('ol.style.Line');
+goog.require('ol.style.Stroke');
-goog.require('ol.style.LineLiteral');
-goog.require('ol.style.Polygon');
-goog.require('ol.style.PolygonLiteral');
 
 
 
@@ -338,48 +336,48 @@ ol.parser.KML = function(opt_options) {
         }
       },
       'LineStyle': function(node, obj) {
-        var symbolizer = {};
+        var style = {}; // from KML
-        this.readChildNodes(node, symbolizer);
+        var options = {}; // for ol.style.Stroke
-        if (symbolizer.color) {
+        this.readChildNodes(node, style);
-          symbolizer.strokeColor = symbolizer.color.color;
+        if (style.color) {
-          symbolizer.strokeOpacity = symbolizer.color.opacity;
+          options.color = style.color.color;
+          options.opacity = style.color.opacity;
         }
-        if (symbolizer.width) {
+        if (style.width) {
-          symbolizer.strokeWidth = parseFloat(symbolizer.width);
+          options.width = parseFloat(style.width);
         }
-        delete symbolizer.color;
-        delete symbolizer.width;
         obj['ids'].push(node.getAttribute('id'));
-        obj['symbolizers'].push(new ol.style.Line(symbolizer));
+        obj['symbolizers'].push(new ol.style.Stroke(options));
       },
       'PolyStyle': function(node, obj) {
         var style = {}; // from KML
-        var symbolizer = {}; // for ol.style.Polygon
+        var options = {}; // for ol.style.Fill
         this.readChildNodes(node, style);
         // check if poly has fill
         if (!(style.fill === '0' || style.fill === 'false')) {
           if (style.color) {
-            symbolizer.fillColor = style.color.color;
+            options.color = style.color.color;
-            symbolizer.fillOpacity = style.color.opacity;
+            options.opacity = style.color.opacity;
           } else {
             // KML defaults
-            symbolizer.fillColor = '#ffffff';
+            options.color = '#ffffff';
-            symbolizer.fillOpacity = 1;
+            options.opacity = 1;
           }
+          obj['symbolizers'].push(new ol.style.Fill(options));
         }
         // check if poly has stroke
         if (!(style.outline === '0' || style.outline === 'false')) {
           if (style.color) {
-            symbolizer.strokeColor = style.color.color;
+            options.color = style.color.color;
-            symbolizer.strokeOpacity = style.color.opacity;
+            options.opacity = style.color.opacity;
           } else {
             // KML defaults
-            symbolizer.strokeColor = '#ffffff';
+            options.color = '#ffffff';
-            symbolizer.strokeOpacity = 1;
+            options.opacity = 1;
           }
+          obj['symbolizers'].push(new ol.style.Stroke(options));
         }
         obj['ids'].push(node.getAttribute('id'));
-        obj['symbolizers'].push(new ol.style.Polygon(symbolizer));
       },
       'fill': function(node, obj) {
         obj.fill = this.getChildValue(node);
@@ -418,19 +416,19 @@ ol.parser.KML = function(opt_options) {
         };
       },
       'IconStyle': function(node, obj) {
-        var symbolizer = {};
+        var style = {}; // from KML
-        this.readChildNodes(node, symbolizer);
+        var options = {}; // for ol.style.Icon
-        var scale = symbolizer.scale || 1;
+        this.readChildNodes(node, style);
+        var scale = style.scale || 1;
         // set default width and height of icon
         var width = 32 * scale;
         var height = 32 * scale;
         var x, y;
-        delete symbolizer.scale;
+        if (goog.isDef(style.icon)) {
-        if (goog.isDef(symbolizer.icon)) {
+          var href = style.icon.href;
-          var href = symbolizer.icon.href;
           if (goog.isDef(href)) {
-            var w = symbolizer.icon.w;
+            var w = style.icon.w;
-            var h = symbolizer.icon.h;
+            var h = style.icon.h;
             // Settings for Google specific icons that are 64x64
             // We set the width and height to 64 and halve the
             // scale to prevent icons from being too big
@@ -463,45 +461,42 @@ ol.parser.KML = function(opt_options) {
             if (matches) {
               var palette = matches[1];
               var file_extension = matches[2];
-              x = symbolizer.icon.x;
+              x = style.icon.x;
-              y = symbolizer.icon.y;
+              y = style.icon.y;
               var posX = x ? x / 32 : 0;
               var posY = y ? (7 - y / 32) : 7;
               var pos = posY * 8 + posX;
               href = 'http://maps.google.com/mapfiles/kml/pal' +
                   palette + '/icon' + pos + file_extension;
             }
-            symbolizer.opacity = 1;
+            options.opacity = 1;
-            symbolizer.url = href;
+            options.url = href;
           }
         }
-        if (goog.isDef(symbolizer.hotSpot)) {
+        if (goog.isDef(style.hotSpot)) {
-          x = symbolizer.hotSpot.x;
+          x = style.hotSpot.x;
-          y = symbolizer.hotSpot.y;
+          y = style.hotSpot.y;
-          var xUnits = symbolizer.hotSpot.xunits,
+          var xUnits = style.hotSpot.xunits,
-              yUnits = symbolizer.hotSpot.yunits;
+              yUnits = style.hotSpot.yunits;
           if (xUnits === 'pixels') {
-            symbolizer.graphicXOffset = -x * scale;
+            options.xOffset = -x * scale;
           } else if (xUnits === 'insetPixels') {
-            symbolizer.graphicXOffset = -width + (x * scale);
+            options.xOffset = -width + (x * scale);
           } else if (xUnits === 'fraction') {
-            symbolizer.graphicXOffset = -width * x;
+            options.xOffset = -width * x;
           }
           if (yUnits == 'pixels') {
-            symbolizer.graphicYOffset = -height + (y * scale) + 1;
+            options.yOffset = -height + (y * scale) + 1;
           } else if (yUnits == 'insetPixels') {
-            symbolizer.graphicYOffset = -(y * scale) + 1;
+            options.yOffset = -(y * scale) + 1;
           } else if (yUnits == 'fraction') {
-            symbolizer.graphicYOffset = -height * (1 - y) + 1;
+            options.yOffset = -height * (1 - y) + 1;
           }
         }
-        symbolizer.width = width;
+        options.width = width;
-        symbolizer.height = height;
+        options.height = height;
-        delete symbolizer.scale;
-        delete symbolizer.icon;
-        delete symbolizer.hotSpot;
         obj['ids'].push(node.getAttribute('id'));
-        obj['symbolizers'].push(new ol.style.Icon(symbolizer));
+        obj['symbolizers'].push(new ol.style.Icon(options));
       },
       'color': function(node, obj) {
         var kmlColor = this.getChildValue(node);
@@ -611,31 +606,27 @@ ol.parser.KML = function(opt_options) {
         }
         return node;
       },
-      '_symbolizer': function(symbolizerObj) {
+      '_symbolizer': function(obj) {
-        var symbolizer = symbolizerObj.symbolizer;
+        var symbolizer = obj.symbolizer;
         if (symbolizer instanceof ol.style.Icon) {
-          return this.writeNode('IconStyle', symbolizerObj);
+          return this.writeNode('IconStyle', obj);
-        } else if (symbolizer instanceof ol.style.Line ||
+        } else if (symbolizer instanceof ol.style.Stroke) {
-            symbolizer instanceof ol.style.LineLiteral) {
+          return this.writeNode('LineStyle', obj);
-          return this.writeNode('LineStyle', symbolizerObj);
+        } else if (symbolizer instanceof ol.style.Fill) {
-        } else if (symbolizer instanceof ol.style.Polygon ||
+          return this.writeNode('PolyStyle', obj);
-            symbolizer instanceof ol.style.PolygonLiteral) {
-          return this.writeNode('PolyStyle', symbolizerObj);
         }
       },
-      'PolyStyle': function(symbolizerObj) {
+      'PolyStyle': function(obj) {
         /**
-         * There is not a 1:1 mapping between KML PolyStyle and
+         * In KML, if a PolyStyle has <outline>1</outline>
-         * ol.style.Polygon.  In KML, if a PolyStyle has <outline>1</outline>
          * then the "current" LineStyle is used to stroke the polygon.
          */
         var node = this.createElementNS('PolyStyle');
-        if (symbolizerObj.id) {
+        if (obj.id) {
-          this.setAttributeNS(node, null, 'id', symbolizerObj.id);
+          this.setAttributeNS(node, null, 'id', obj.id);
         }
-        var symbolizer = symbolizerObj.symbolizer;
+        var literal = obj.symbolizer.createLiteral(
-        var literal = symbolizer instanceof ol.style.PolygonLiteral ?
+            ol.geom.GeometryType.POLYGON);
-            symbolizer : symbolizer.createLiteral();
         var color, opacity;
         if (literal.fillOpacity !== 0) {
           this.writeNode('fill', '1', null, node);
@@ -669,19 +660,18 @@ ol.parser.KML = function(opt_options) {
         node.appendChild(this.createTextNode(outline));
         return node;
       },
-      'LineStyle': function(symbolizerObj) {
+      'LineStyle': function(obj) {
         var node = this.createElementNS('LineStyle');
-        if (symbolizerObj.id) {
+        if (obj.id) {
-          this.setAttributeNS(node, null, 'id', symbolizerObj.id);
+          this.setAttributeNS(node, null, 'id', obj.id);
         }
-        var symbolizer = symbolizerObj.symbolizer;
+        var literal = obj.symbolizer.createLiteral(
-        var literal = symbolizer instanceof ol.style.LineLiteral ?
+            ol.geom.GeometryType.LINESTRING);
-            symbolizer : symbolizer.createLiteral();
         this.writeNode('color', {
-          color: literal.strokeColor.substring(1),
+          color: literal.color.substring(1),
-          opacity: literal.strokeOpacity
+          opacity: literal.opacity
         }, null, node);
-        this.writeNode('width', literal.strokeWidth, null, node);
+        this.writeNode('width', literal.width, null, node);
         return node;
       },
       'color': function(colorObj) {
@@ -698,10 +688,11 @@ ol.parser.KML = function(opt_options) {
         node.appendChild(this.createTextNode(width));
         return node;
       },
-      'IconStyle': function(symbolizerObj) {
+      'IconStyle': function(obj) {
         var node = this.createElementNS('IconStyle');
-        this.setAttributeNS(node, null, 'id', symbolizerObj.id);
+        this.setAttributeNS(node, null, 'id', obj.id);
-        this.writeNode('Icon', symbolizerObj.symbolizer.createLiteral().url,
+        this.writeNode('Icon',
+            obj.symbolizer.createLiteral(ol.geom.GeometryType.POINT).url,
             null, node);
         return node;
       },
@@ -723,12 +714,14 @@ ol.parser.KML = function(opt_options) {
         }
         this.writeNode('name', feature, null, node);
         this.writeNode('description', feature, null, node);
-        var literals = feature.getSymbolizerLiterals();
         if (goog.isDef(feature.get('styleUrl'))) {
           this.writeNode('styleUrl', feature, null, node);
-        } else if (goog.isDefAndNotNull(literals)) {
+        } else {
           // inline style
-          this.writeNode('_style', {symbolizers: literals}, null, node);
+          var symbolizers = feature.getSymbolizers();
+          if (!goog.isNull(symbolizers)) {
+            this.writeNode('_style', {symbolizers: symbolizers}, null, node);
+          }
         }
         this.writeNode('_geometry', feature.getGeometry(), null, node);
         return node;
@@ -995,14 +988,13 @@ ol.parser.KML.prototype.read = function(data, opt_callback) {
  * @private
  * @param {ol.Feature} feature The feature to apply the style to.
  * @param {Array} styles The style list to search in.
- * @param {Array=} opt_symbolizers Optional symbolizers.
+ * @param {Array.<ol.style.Symbolizer>=} opt_symbolizers Optional symbolizers.
  */
 ol.parser.KML.prototype.applyStyle_ = function(feature, styles,
     opt_symbolizers) {
   var symbolizers = opt_symbolizers;
   var i, ii;
-  if (feature.get('styleUrl') &&
+  if (feature.get('styleUrl') && feature.getSymbolizers() === null) {
-      feature.getSymbolizerLiterals() === null) {
     var styleUrl = feature.get('styleUrl');
     styleUrl = styleUrl.substring(styleUrl.indexOf('#') + 1);
     // look for the style and set in the feature
@@ -1016,14 +1008,6 @@ ol.parser.KML.prototype.applyStyle_ = function(feature, styles,
     }
   }
   if (goog.isDef(symbolizers)) {
-    var geom = feature.getGeometry();
-    if (geom && geom instanceof ol.geom.LineString) {
-      for (i = 0, ii = symbolizers.length; i < ii; i++) {
-        if (symbolizers[i] instanceof ol.style.Polygon) {
-          symbolizers.splice(i, 1);
-        }
-      }
-    }
     feature.setSymbolizers(symbolizers);
   }
 };

src/ol/renderer/canvas/canvasvectorrenderer.js

@@ -19,11 +19,11 @@ goog.require('ol.geom.Point');
 goog.require('ol.geom.Polygon');
 goog.require('ol.style.IconLiteral');
 goog.require('ol.style.LineLiteral');
+goog.require('ol.style.Literal');
 goog.require('ol.style.PointLiteral');
 goog.require('ol.style.PolygonLiteral');
 goog.require('ol.style.ShapeLiteral');
 goog.require('ol.style.ShapeType');
-goog.require('ol.style.SymbolizerLiteral');
 goog.require('ol.style.TextLiteral');
 
 
@@ -101,7 +101,7 @@ ol.renderer.canvas.VectorRenderer.prototype.getMaxSymbolSize = function() {
 /**
  * @param {ol.geom.GeometryType} type Geometry type.
  * @param {Array.<ol.Feature>} features Array of features.
- * @param {ol.style.SymbolizerLiteral} symbolizer Symbolizer.
+ * @param {ol.style.Literal} symbolizer Symbolizer.
  * @param {Array} data Additional data.
  * @return {boolean} true if deferred, false if rendered.
  */
@@ -153,9 +153,9 @@ ol.renderer.canvas.VectorRenderer.prototype.renderLineStringFeatures_ =
       i, ii, feature, id, currentSize, geometry, components, j, jj, line, dim,
       k, kk, vec, strokeSize;
 
-  context.globalAlpha = symbolizer.strokeOpacity;
+  context.globalAlpha = symbolizer.opacity;
-  context.strokeStyle = symbolizer.strokeColor;
+  context.strokeStyle = symbolizer.color;
-  context.lineWidth = symbolizer.strokeWidth;
+  context.lineWidth = symbolizer.width;
   context.lineCap = 'round'; // TODO: accept this as a symbolizer property
   context.lineJoin = 'round'; // TODO: accept this as a symbolizer property
   strokeSize = context.lineWidth * this.inverseScale_;

src/ol/style.exports

@@ -1,10 +1,9 @@
+@exportClass ol.style.Fill ol.style.FillOptions
 @exportClass ol.style.Icon ol.style.IconOptions
-@exportClass ol.style.Line ol.style.LineOptions
-@exportClass ol.style.Polygon ol.style.PolygonOptions
 @exportClass ol.style.Rule ol.style.RuleOptions
 @exportClass ol.style.Shape ol.style.ShapeOptions
+@exportClass ol.style.Stroke ol.style.StrokeOptions
 @exportClass ol.style.Style ol.style.StyleOptions
 @exportClass ol.style.Text ol.style.TextOptions
-@exportSymbol ol.style.IconType
 @exportSymbol ol.style.ShapeType
 @exportProperty ol.style.ShapeType.CIRCLE

src/ol/style/fillsymbolizer.js

@@ -0,0 +1,126 @@
+goog.provide('ol.style.Fill');
+
+goog.require('goog.asserts');
+goog.require('ol.Feature');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Literal');
+goog.require('ol.geom.GeometryType');
+goog.require('ol.style.PolygonLiteral');
+goog.require('ol.style.Symbolizer');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.Symbolizer}
+ * @param {ol.style.FillOptions=} opt_options Polygon options.
+ */
+ol.style.Fill = function(opt_options) {
+  goog.base(this);
+  var options = opt_options || {};
+
+  /**
+   * @type {ol.expr.Expression}
+   * @private
+   */
+  this.color_ = !goog.isDefAndNotNull(options.color) ?
+      new ol.expr.Literal(ol.style.FillDefaults.color) :
+      (options.color instanceof ol.expr.Expression) ?
+          options.color : new ol.expr.Literal(options.color);
+
+  /**
+   * @type {ol.expr.Expression}
+   * @private
+   */
+  this.opacity_ = !goog.isDefAndNotNull(options.opacity) ?
+      new ol.expr.Literal(ol.style.FillDefaults.opacity) :
+      (options.opacity instanceof ol.expr.Expression) ?
+          options.opacity : new ol.expr.Literal(options.opacity);
+
+};
+goog.inherits(ol.style.Fill, ol.style.Symbolizer);
+
+
+/**
+ * @inheritDoc
+ * @return {ol.style.PolygonLiteral} Literal shape symbolizer.
+ */
+ol.style.Fill.prototype.createLiteral = function(featureOrType) {
+  var feature, type;
+  if (featureOrType instanceof ol.Feature) {
+    feature = featureOrType;
+    var geometry = feature.getGeometry();
+    type = geometry ? geometry.getType() : null;
+  } else {
+    type = featureOrType;
+  }
+  var literal = null;
+
+  if (type === ol.geom.GeometryType.POLYGON ||
+      type === ol.geom.GeometryType.MULTIPOLYGON) {
+
+    var color = ol.expr.evaluateFeature(this.color_, feature);
+    goog.asserts.assertString(
+        color, 'color must be a string');
+
+    var opacity = ol.expr.evaluateFeature(this.opacity_, feature);
+    goog.asserts.assertNumber(
+        opacity, 'color must be a number');
+
+    literal = new ol.style.PolygonLiteral({
+      fillColor: color,
+      fillOpacity: opacity
+    });
+  }
+
+  return literal;
+};
+
+
+/**
+ * Get the fill color.
+ * @return {ol.expr.Expression} Fill color.
+ */
+ol.style.Fill.prototype.getColor = function() {
+  return this.color_;
+};
+
+
+/**
+ * Get the fill opacity.
+ * @return {ol.expr.Expression} Fill opacity.
+ */
+ol.style.Fill.prototype.getOpacity = function() {
+  return this.opacity_;
+};
+
+
+/**
+ * Set the fill color.
+ * @param {ol.expr.Expression} color Fill color.
+ */
+ol.style.Fill.prototype.setColor = function(color) {
+  goog.asserts.assertInstanceof(color, ol.expr.Expression);
+  this.color_ = color;
+};
+
+
+/**
+ * Set the fill opacity.
+ * @param {ol.expr.Expression} opacity Fill opacity.
+ */
+ol.style.Fill.prototype.setOpacity = function(opacity) {
+  goog.asserts.assertInstanceof(opacity, ol.expr.Expression);
+  this.opacity_ = opacity;
+};
+
+
+/**
+ * @typedef {{fillColor: (string),
+ *            fillOpacity: (number)}}
+ */
+ol.style.FillDefaults = {
+  color: '#ffffff',
+  opacity: 0.4
+};

src/ol/style/iconliteral.js

@@ -0,0 +1,52 @@
+goog.provide('ol.style.IconLiteral');
+
+goog.require('ol.style.PointLiteral');
+
+
+/**
+ * @typedef {{url: (string),
+ *            width: (number|undefined),
+ *            height: (number|undefined),
+ *            opacity: (number),
+ *            rotation: (number)}}
+ */
+ol.style.IconLiteralOptions;
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.PointLiteral}
+ * @param {ol.style.IconLiteralOptions} options Icon literal options.
+ */
+ol.style.IconLiteral = function(options) {
+
+  /** @type {string} */
+  this.url = options.url;
+
+  /** @type {number|undefined} */
+  this.width = options.width;
+
+  /** @type {number|undefined} */
+  this.height = options.height;
+
+  /** @type {number} */
+  this.opacity = options.opacity;
+
+  /** @type {number} */
+  this.rotation = options.rotation;
+
+};
+goog.inherits(ol.style.IconLiteral, ol.style.PointLiteral);
+
+
+/**
+ * @inheritDoc
+ */
+ol.style.IconLiteral.prototype.equals = function(iconLiteral) {
+  return this.url == iconLiteral.url &&
+      this.width == iconLiteral.width &&
+      this.height == iconLiteral.height &&
+      this.opacity == iconLiteral.opacity &&
+      this.rotation == iconLiteral.rotation;
+};

src/ol/style/iconsymbolizer.js

@@ -1,62 +1,13 @@
 goog.provide('ol.style.Icon');
-goog.provide('ol.style.IconLiteral');
-goog.provide('ol.style.IconType');
 
 goog.require('goog.asserts');
+goog.require('ol.Feature');
 goog.require('ol.expr');
 goog.require('ol.expr.Expression');
 goog.require('ol.expr.Literal');
+goog.require('ol.geom.GeometryType');
+goog.require('ol.style.IconLiteral');
 goog.require('ol.style.Point');
-goog.require('ol.style.PointLiteral');
-
-
-/**
- * @typedef {{url: (string),
- *            width: (number|undefined),
- *            height: (number|undefined),
- *            opacity: (number),
- *            rotation: (number)}}
- */
-ol.style.IconLiteralOptions;
-
-
-
-/**
- * @constructor
- * @extends {ol.style.PointLiteral}
- * @param {ol.style.IconLiteralOptions} options Icon literal options.
- */
-ol.style.IconLiteral = function(options) {
-
-  /** @type {string} */
-  this.url = options.url;
-
-  /** @type {number|undefined} */
-  this.width = options.width;
-
-  /** @type {number|undefined} */
-  this.height = options.height;
-
-  /** @type {number} */
-  this.opacity = options.opacity;
-
-  /** @type {number} */
-  this.rotation = options.rotation;
-
-};
-goog.inherits(ol.style.IconLiteral, ol.style.PointLiteral);
-
-
-/**
- * @inheritDoc
- */
-ol.style.IconLiteral.prototype.equals = function(iconLiteral) {
-  return this.url == iconLiteral.url &&
-      this.width == iconLiteral.width &&
-      this.height == iconLiteral.height &&
-      this.opacity == iconLiteral.opacity &&
-      this.rotation == iconLiteral.rotation;
-};
 
 
 
@@ -119,37 +70,52 @@ ol.style.Icon = function(options) {
  * @inheritDoc
  * @return {ol.style.IconLiteral} Literal shape symbolizer.
  */
-ol.style.Icon.prototype.createLiteral = function(opt_feature) {
+ol.style.Icon.prototype.createLiteral = function(featureOrType) {
-
+  var feature, type;
-  var url = ol.expr.evaluateFeature(this.url_, opt_feature);
+  if (featureOrType instanceof ol.Feature) {
-  goog.asserts.assertString(url, 'url must be a string');
+    feature = featureOrType;
-  goog.asserts.assert(url != '#', 'url must not be "#"');
+    var geometry = feature.getGeometry();
-
+    type = geometry ? geometry.getType() : null;
-  var width;
+  } else {
-  if (!goog.isNull(this.width_)) {
+    type = featureOrType;
-    width = ol.expr.evaluateFeature(this.width_, opt_feature);
-    goog.asserts.assertNumber(width, 'width must be a number');
   }
 
-  var height;
+  var literal = null;
-  if (!goog.isNull(this.height_)) {
+  if (type === ol.geom.GeometryType.POINT ||
-    height = ol.expr.evaluateFeature(this.height_, opt_feature);
+      type === ol.geom.GeometryType.MULTIPOINT) {
-    goog.asserts.assertNumber(height, 'height must be a number');
+
+    var url = ol.expr.evaluateFeature(this.url_, feature);
+    goog.asserts.assertString(url, 'url must be a string');
+    goog.asserts.assert(url != '#', 'url must not be "#"');
+
+    var width;
+    if (!goog.isNull(this.width_)) {
+      width = ol.expr.evaluateFeature(this.width_, feature);
+      goog.asserts.assertNumber(width, 'width must be a number');
+    }
+
+    var height;
+    if (!goog.isNull(this.height_)) {
+      height = ol.expr.evaluateFeature(this.height_, feature);
+      goog.asserts.assertNumber(height, 'height must be a number');
+    }
+
+    var opacity = ol.expr.evaluateFeature(this.opacity_, feature);
+    goog.asserts.assertNumber(opacity, 'opacity must be a number');
+
+    var rotation = ol.expr.evaluateFeature(this.rotation_, feature);
+    goog.asserts.assertNumber(rotation, 'rotation must be a number');
+
+    literal = new ol.style.IconLiteral({
+      url: url,
+      width: width,
+      height: height,
+      opacity: opacity,
+      rotation: rotation
+    });
   }
 
-  var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
+  return literal;
-  goog.asserts.assertNumber(opacity, 'opacity must be a number');
-
-  var rotation = ol.expr.evaluateFeature(this.rotation_, opt_feature);
-  goog.asserts.assertNumber(rotation, 'rotation must be a number');
-
-  return new ol.style.IconLiteral({
-    url: url,
-    width: width,
-    height: height,
-    opacity: opacity,
-    rotation: rotation
-  });
 };
 
 
@@ -249,10 +215,10 @@ ol.style.Icon.prototype.setWidth = function(width) {
 
 
 /**
- * @type {ol.style.IconLiteral}
+ * @typedef {{opacity: (number),
+ *            rotation: (number)}}
  */
-ol.style.IconDefaults = new ol.style.IconLiteral({
+ol.style.IconDefaults = {
-  url: '#',
   opacity: 1,
   rotation: 0
-});
+};

src/ol/style/line.js

@@ -1,189 +0,0 @@
-goog.provide('ol.style.Line');
-goog.provide('ol.style.LineLiteral');
-
-goog.require('goog.asserts');
-goog.require('ol.expr');
-goog.require('ol.expr.Expression');
-goog.require('ol.expr.Literal');
-goog.require('ol.style.Symbolizer');
-goog.require('ol.style.SymbolizerLiteral');
-
-
-/**
- * @typedef {{strokeColor: (string),
- *            strokeOpacity: (number),
- *            strokeWidth: (number)}}
- */
-ol.style.LineLiteralOptions;
-
-
-
-/**
- * @constructor
- * @extends {ol.style.SymbolizerLiteral}
- * @param {ol.style.LineLiteralOptions} options Line literal options.
- */
-ol.style.LineLiteral = function(options) {
-  goog.base(this);
-
-  goog.asserts.assertString(
-      options.strokeColor, 'strokeColor must be a string');
-  /** @type {string} */
-  this.strokeColor = options.strokeColor;
-
-  goog.asserts.assertNumber(
-      options.strokeOpacity, 'strokeOpacity must be a number');
-  /** @type {number} */
-  this.strokeOpacity = options.strokeOpacity;
-
-  goog.asserts.assertNumber(
-      options.strokeWidth, 'strokeWidth must be a number');
-  /** @type {number} */
-  this.strokeWidth = options.strokeWidth;
-
-};
-goog.inherits(ol.style.LineLiteral, ol.style.SymbolizerLiteral);
-
-
-/**
- * @inheritDoc
- */
-ol.style.LineLiteral.prototype.equals = function(lineLiteral) {
-  return this.strokeColor == lineLiteral.strokeColor &&
-      this.strokeOpacity == lineLiteral.strokeOpacity &&
-      this.strokeWidth == lineLiteral.strokeWidth;
-};
-
-
-
-/**
- * @constructor
- * @extends {ol.style.Symbolizer}
- * @param {ol.style.LineOptions} options Line options.
- */
-ol.style.Line = function(options) {
-  goog.base(this);
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeColor_ = !goog.isDef(options.strokeColor) ?
-      new ol.expr.Literal(ol.style.LineDefaults.strokeColor) :
-      (options.strokeColor instanceof ol.expr.Expression) ?
-          options.strokeColor : new ol.expr.Literal(options.strokeColor);
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeOpacity_ = !goog.isDef(options.strokeOpacity) ?
-      new ol.expr.Literal(ol.style.LineDefaults.strokeOpacity) :
-      (options.strokeOpacity instanceof ol.expr.Expression) ?
-          options.strokeOpacity : new ol.expr.Literal(options.strokeOpacity);
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeWidth_ = !goog.isDef(options.strokeWidth) ?
-      new ol.expr.Literal(ol.style.LineDefaults.strokeWidth) :
-      (options.strokeWidth instanceof ol.expr.Expression) ?
-          options.strokeWidth : new ol.expr.Literal(options.strokeWidth);
-
-};
-goog.inherits(ol.style.Line, ol.style.Symbolizer);
-
-
-/**
- * @inheritDoc
- * @return {ol.style.LineLiteral} Literal line symbolizer.
- */
-ol.style.Line.prototype.createLiteral = function(opt_feature) {
-
-  var strokeColor = ol.expr.evaluateFeature(
-      this.strokeColor_, opt_feature);
-  goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
-
-  var strokeOpacity = ol.expr.evaluateFeature(
-      this.strokeOpacity_, opt_feature);
-  goog.asserts.assertNumber(strokeOpacity, 'strokeOpacity must be a number');
-
-  var strokeWidth = ol.expr.evaluateFeature(
-      this.strokeWidth_, opt_feature);
-  goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
-
-
-  return new ol.style.LineLiteral({
-    strokeColor: strokeColor,
-    strokeOpacity: strokeOpacity,
-    strokeWidth: strokeWidth
-  });
-};
-
-
-/**
- * Get the stroke color.
- * @return {ol.expr.Expression} Stroke color.
- */
-ol.style.Line.prototype.getStrokeColor = function() {
-  return this.strokeColor_;
-};
-
-
-/**
- * Get the stroke opacity.
- * @return {ol.expr.Expression} Stroke opacity.
- */
-ol.style.Line.prototype.getStrokeOpacity = function() {
-  return this.strokeOpacity_;
-};
-
-
-/**
- * Get the stroke width.
- * @return {ol.expr.Expression} Stroke width.
- */
-ol.style.Line.prototype.getStrokeWidth = function() {
-  return this.strokeWidth_;
-};
-
-
-/**
- * Set the stroke color.
- * @param {ol.expr.Expression} strokeColor Stroke color.
- */
-ol.style.Line.prototype.setStrokeColor = function(strokeColor) {
-  goog.asserts.assertInstanceof(strokeColor, ol.expr.Expression);
-  this.strokeColor_ = strokeColor;
-};
-
-
-/**
- * Set the stroke opacity.
- * @param {ol.expr.Expression} strokeOpacity Stroke opacity.
- */
-ol.style.Line.prototype.setStrokeOpacity = function(strokeOpacity) {
-  goog.asserts.assertInstanceof(strokeOpacity, ol.expr.Expression);
-  this.strokeOpacity_ = strokeOpacity;
-};
-
-
-/**
- * Set the stroke width.
- * @param {ol.expr.Expression} strokeWidth Stroke width.
- */
-ol.style.Line.prototype.setStrokeWidth = function(strokeWidth) {
-  goog.asserts.assertInstanceof(strokeWidth, ol.expr.Expression);
-  this.strokeWidth_ = strokeWidth;
-};
-
-
-/**
- * @type {ol.style.LineLiteral}
- */
-ol.style.LineDefaults = new ol.style.LineLiteral({
-  strokeColor: '#696969',
-  strokeOpacity: 0.75,
-  strokeWidth: 1.5
-});

src/ol/style/lineliteral.js

@@ -0,0 +1,50 @@
+goog.provide('ol.style.LineLiteral');
+
+goog.require('goog.asserts');
+goog.require('ol.style.Literal');
+
+
+/**
+ * @typedef {{color: (string),
+ *            opacity: (number),
+ *            width: (number)}}
+ */
+ol.style.LineLiteralOptions;
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.Literal}
+ * @param {ol.style.LineLiteralOptions} options Line literal options.
+ */
+ol.style.LineLiteral = function(options) {
+  goog.base(this);
+
+  goog.asserts.assertString(
+      options.color, 'color must be a string');
+  /** @type {string} */
+  this.color = options.color;
+
+  goog.asserts.assertNumber(
+      options.opacity, 'opacity must be a number');
+  /** @type {number} */
+  this.opacity = options.opacity;
+
+  goog.asserts.assertNumber(
+      options.width, 'width must be a number');
+  /** @type {number} */
+  this.width = options.width;
+
+};
+goog.inherits(ol.style.LineLiteral, ol.style.Literal);
+
+
+/**
+ * @inheritDoc
+ */
+ol.style.LineLiteral.prototype.equals = function(lineLiteral) {
+  return this.color == lineLiteral.color &&
+      this.opacity == lineLiteral.opacity &&
+      this.width == lineLiteral.width;
+};

src/ol/style/literal.js

@@ -0,0 +1,16 @@
+goog.provide('ol.style.Literal');
+
+
+
+/**
+ * @constructor
+ */
+ol.style.Literal = function() {};
+
+
+/**
+ * @param {ol.style.Literal} symbolizerLiteral Symbolizer literal to
+ *     compare to.
+ * @return {boolean} Is the passed symbolizer literal equal to this instance?
+ */
+ol.style.Literal.prototype.equals = goog.abstractMethod;

src/ol/style/pointliteral.js

@@ -0,0 +1,14 @@
+goog.provide('ol.style.PointLiteral');
+
+goog.require('ol.style.Literal');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.Literal}
+ */
+ol.style.PointLiteral = function() {
+  goog.base(this);
+};
+goog.inherits(ol.style.PointLiteral, ol.style.Literal);

src/ol/style/pointsymbolizer.js

@@ -1,19 +1,6 @@
 goog.provide('ol.style.Point');
-goog.provide('ol.style.PointLiteral');
 
 goog.require('ol.style.Symbolizer');
-goog.require('ol.style.SymbolizerLiteral');
-
-
-
-/**
- * @constructor
- * @extends {ol.style.SymbolizerLiteral}
- */
-ol.style.PointLiteral = function() {
-  goog.base(this);
-};
-goog.inherits(ol.style.PointLiteral, ol.style.SymbolizerLiteral);
 
 
 

src/ol/style/polygon.js

@@ -1,365 +0,0 @@
-goog.provide('ol.style.Polygon');
-goog.provide('ol.style.PolygonLiteral');
-
-goog.require('goog.asserts');
-goog.require('ol.expr');
-goog.require('ol.expr.Expression');
-goog.require('ol.expr.Literal');
-goog.require('ol.style.Symbolizer');
-goog.require('ol.style.SymbolizerLiteral');
-
-
-/**
- * @typedef {{fillColor: (string|undefined),
- *            fillOpacity: (number|undefined),
- *            strokeColor: (string|undefined),
- *            strokeOpacity: (number|undefined),
- *            strokeWidth: (number|undefined)}}
- */
-ol.style.PolygonLiteralOptions;
-
-
-
-/**
- * @constructor
- * @extends {ol.style.SymbolizerLiteral}
- * @param {ol.style.PolygonLiteralOptions} options Polygon literal options.
- */
-ol.style.PolygonLiteral = function(options) {
-  goog.base(this);
-
-  /** @type {string|undefined} */
-  this.fillColor = options.fillColor;
-  if (goog.isDef(options.fillColor)) {
-    goog.asserts.assertString(options.fillColor, 'fillColor must be a string');
-  }
-
-  /** @type {number|undefined} */
-  this.fillOpacity = options.fillOpacity;
-  if (goog.isDef(options.fillOpacity)) {
-    goog.asserts.assertNumber(
-        options.fillOpacity, 'fillOpacity must be a number');
-  }
-
-  /** @type {string|undefined} */
-  this.strokeColor = options.strokeColor;
-  if (goog.isDef(this.strokeColor)) {
-    goog.asserts.assertString(
-        this.strokeColor, 'strokeColor must be a string');
-  }
-
-  /** @type {number|undefined} */
-  this.strokeOpacity = options.strokeOpacity;
-  if (goog.isDef(this.strokeOpacity)) {
-    goog.asserts.assertNumber(
-        this.strokeOpacity, 'strokeOpacity must be a number');
-  }
-
-  /** @type {number|undefined} */
-  this.strokeWidth = options.strokeWidth;
-  if (goog.isDef(this.strokeWidth)) {
-    goog.asserts.assertNumber(
-        this.strokeWidth, 'strokeWidth must be a number');
-  }
-
-  // fill and/or stroke properties must be defined
-  var fillDef = goog.isDef(this.fillColor) && goog.isDef(this.fillOpacity);
-  var strokeDef = goog.isDef(this.strokeColor) &&
-      goog.isDef(this.strokeOpacity) &&
-      goog.isDef(this.strokeWidth);
-  goog.asserts.assert(fillDef || strokeDef,
-      'Either fillColor and fillOpacity or ' +
-      'strokeColor and strokeOpacity and strokeWidth must be set');
-
-};
-goog.inherits(ol.style.PolygonLiteral, ol.style.SymbolizerLiteral);
-
-
-/**
- * @inheritDoc
- */
-ol.style.PolygonLiteral.prototype.equals = function(polygonLiteral) {
-  return this.fillColor == polygonLiteral.fillColor &&
-      this.fillOpacity == polygonLiteral.fillOpacity &&
-      this.strokeColor == polygonLiteral.strokeColor &&
-      this.strokeOpacity == polygonLiteral.strokeOpacity &&
-      this.strokeWidth == polygonLiteral.strokeWidth;
-};
-
-
-
-/**
- * @constructor
- * @extends {ol.style.Symbolizer}
- * @param {ol.style.PolygonOptions} options Polygon options.
- */
-ol.style.Polygon = function(options) {
-  goog.base(this);
-
-
-  // fill handling - if any fill property is supplied, use all defaults
-  var fillColor = null,
-      fillOpacity = null;
-
-  if (goog.isDefAndNotNull(options.fillColor) ||
-      goog.isDefAndNotNull(options.fillOpacity)) {
-
-    if (goog.isDefAndNotNull(options.fillColor)) {
-      fillColor = (options.fillColor instanceof ol.expr.Expression) ?
-          options.fillColor :
-          new ol.expr.Literal(options.fillColor);
-    } else {
-      fillColor = new ol.expr.Literal(
-          /** @type {string} */ (ol.style.PolygonDefaults.fillColor));
-    }
-
-    if (goog.isDefAndNotNull(options.fillOpacity)) {
-      fillOpacity = (options.fillOpacity instanceof ol.expr.Expression) ?
-          options.fillOpacity :
-          new ol.expr.Literal(options.fillOpacity);
-    } else {
-      fillOpacity = new ol.expr.Literal(
-          /** @type {number} */ (ol.style.PolygonDefaults.fillOpacity));
-    }
-
-  }
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.fillColor_ = fillColor;
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.fillOpacity_ = fillOpacity;
-
-
-  // stroke handling - if any stroke property is supplied, use defaults
-  var strokeColor = null,
-      strokeOpacity = null,
-      strokeWidth = null;
-
-  if (goog.isDefAndNotNull(options.strokeColor) ||
-      goog.isDefAndNotNull(options.strokeOpacity) ||
-      goog.isDefAndNotNull(options.strokeWidth)) {
-
-    if (goog.isDefAndNotNull(options.strokeColor)) {
-      strokeColor = (options.strokeColor instanceof ol.expr.Expression) ?
-          options.strokeColor :
-          new ol.expr.Literal(options.strokeColor);
-    } else {
-      strokeColor = new ol.expr.Literal(
-          /** @type {string} */ (ol.style.PolygonDefaults.strokeColor));
-    }
-
-    if (goog.isDefAndNotNull(options.strokeOpacity)) {
-      strokeOpacity = (options.strokeOpacity instanceof ol.expr.Expression) ?
-          options.strokeOpacity :
-          new ol.expr.Literal(options.strokeOpacity);
-    } else {
-      strokeOpacity = new ol.expr.Literal(
-          /** @type {number} */ (ol.style.PolygonDefaults.strokeOpacity));
-    }
-
-    if (goog.isDefAndNotNull(options.strokeWidth)) {
-      strokeWidth = (options.strokeWidth instanceof ol.expr.Expression) ?
-          options.strokeWidth :
-          new ol.expr.Literal(options.strokeWidth);
-    } else {
-      strokeWidth = new ol.expr.Literal(
-          /** @type {number} */ (ol.style.PolygonDefaults.strokeWidth));
-    }
-
-  }
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeColor_ = strokeColor;
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeOpacity_ = strokeOpacity;
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeWidth_ = strokeWidth;
-
-  // one of stroke or fill can be null, both null is user error
-  var fill = !goog.isNull(this.fillColor_) && !goog.isNull(this.fillOpacity_);
-  var stroke = !goog.isNull(this.strokeColor_) &&
-      !goog.isNull(this.strokeOpacity_) &&
-      !goog.isNull(this.strokeWidth_);
-  goog.asserts.assert(fill || stroke,
-      'Stroke or fill properties must be provided');
-
-};
-goog.inherits(ol.style.Polygon, ol.style.Symbolizer);
-
-
-/**
- * @inheritDoc
- * @return {ol.style.PolygonLiteral} Literal shape symbolizer.
- */
-ol.style.Polygon.prototype.createLiteral = function(opt_feature) {
-
-  var fillColor;
-  if (!goog.isNull(this.fillColor_)) {
-    fillColor = ol.expr.evaluateFeature(this.fillColor_, opt_feature);
-    goog.asserts.assertString(fillColor, 'fillColor must be a string');
-  }
-
-  var fillOpacity;
-  if (!goog.isNull(this.fillOpacity_)) {
-    fillOpacity = ol.expr.evaluateFeature(this.fillOpacity_, opt_feature);
-    goog.asserts.assertNumber(fillOpacity, 'fillOpacity must be a number');
-  }
-
-  var strokeColor;
-  if (!goog.isNull(this.strokeColor_)) {
-    strokeColor = ol.expr.evaluateFeature(this.strokeColor_, opt_feature);
-    goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
-  }
-
-  var strokeOpacity;
-  if (!goog.isNull(this.strokeOpacity_)) {
-    strokeOpacity = ol.expr.evaluateFeature(this.strokeOpacity_, opt_feature);
-    goog.asserts.assertNumber(strokeOpacity, 'strokeOpacity must be a number');
-  }
-
-  var strokeWidth;
-  if (!goog.isNull(this.strokeWidth_)) {
-    strokeWidth = ol.expr.evaluateFeature(this.strokeWidth_, opt_feature);
-    goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
-  }
-
-  var fill = goog.isDef(fillColor) && goog.isDef(fillOpacity);
-  var stroke = goog.isDef(strokeColor) && goog.isDef(strokeOpacity) &&
-      goog.isDef(strokeWidth);
-
-  goog.asserts.assert(fill || stroke,
-      'either fill or stroke properties must be defined');
-
-  return new ol.style.PolygonLiteral({
-    fillColor: fillColor,
-    fillOpacity: fillOpacity,
-    strokeColor: strokeColor,
-    strokeOpacity: strokeOpacity,
-    strokeWidth: strokeWidth
-  });
-};
-
-
-/**
- * Get the fill color.
- * @return {ol.expr.Expression} Fill color.
- */
-ol.style.Polygon.prototype.getFillColor = function() {
-  return this.fillColor_;
-};
-
-
-/**
- * Get the fill opacity.
- * @return {ol.expr.Expression} Fill opacity.
- */
-ol.style.Polygon.prototype.getFillOpacity = function() {
-  return this.fillOpacity_;
-};
-
-
-/**
- * Get the stroke color.
- * @return {ol.expr.Expression} Stroke color.
- */
-ol.style.Polygon.prototype.getStrokeColor = function() {
-  return this.strokeColor_;
-};
-
-
-/**
- * Get the stroke opacity.
- * @return {ol.expr.Expression} Stroke opacity.
- */
-ol.style.Polygon.prototype.getStrokeOpacity = function() {
-  return this.strokeOpacity_;
-};
-
-
-/**
- * Get the stroke width.
- * @return {ol.expr.Expression} Stroke width.
- */
-ol.style.Polygon.prototype.getStrokeWidth = function() {
-  return this.strokeWidth_;
-};
-
-
-/**
- * Set the fill color.
- * @param {ol.expr.Expression} fillColor Fill color.
- */
-ol.style.Polygon.prototype.setFillColor = function(fillColor) {
-  goog.asserts.assertInstanceof(fillColor, ol.expr.Expression);
-  this.fillColor_ = fillColor;
-};
-
-
-/**
- * Set the fill opacity.
- * @param {ol.expr.Expression} fillOpacity Fill opacity.
- */
-ol.style.Polygon.prototype.setFillOpacity = function(fillOpacity) {
-  goog.asserts.assertInstanceof(fillOpacity, ol.expr.Expression);
-  this.fillOpacity_ = fillOpacity;
-};
-
-
-/**
- * Set the stroke color.
- * @param {ol.expr.Expression} strokeColor Stroke color.
- */
-ol.style.Polygon.prototype.setStrokeColor = function(strokeColor) {
-  goog.asserts.assertInstanceof(strokeColor, ol.expr.Expression);
-  this.strokeColor_ = strokeColor;
-};
-
-
-/**
- * Set the stroke opacity.
- * @param {ol.expr.Expression} strokeOpacity Stroke opacity.
- */
-ol.style.Polygon.prototype.setStrokeOpacity = function(strokeOpacity) {
-  goog.asserts.assertInstanceof(strokeOpacity, ol.expr.Expression);
-  this.strokeOpacity_ = strokeOpacity;
-};
-
-
-/**
- * Set the stroke width.
- * @param {ol.expr.Expression} strokeWidth Stroke width.
- */
-ol.style.Polygon.prototype.setStrokeWidth = function(strokeWidth) {
-  goog.asserts.assertInstanceof(strokeWidth, ol.expr.Expression);
-  this.strokeWidth_ = strokeWidth;
-};
-
-
-/**
- * @type {ol.style.PolygonLiteral}
- */
-ol.style.PolygonDefaults = new ol.style.PolygonLiteral({
-  fillColor: '#ffffff',
-  fillOpacity: 0.4,
-  strokeColor: '#696969',
-  strokeOpacity: 0.8,
-  strokeWidth: 1.5
-});

src/ol/style/polygonliteral.js

@@ -0,0 +1,82 @@
+goog.provide('ol.style.PolygonLiteral');
+
+goog.require('goog.asserts');
+goog.require('ol.style.Literal');
+
+
+/**
+ * @typedef {{fillColor: (string|undefined),
+ *            fillOpacity: (number|undefined),
+ *            strokeColor: (string|undefined),
+ *            strokeOpacity: (number|undefined),
+ *            strokeWidth: (number|undefined)}}
+ */
+ol.style.PolygonLiteralOptions;
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.Literal}
+ * @param {ol.style.PolygonLiteralOptions} options Polygon literal options.
+ */
+ol.style.PolygonLiteral = function(options) {
+  goog.base(this);
+
+  /** @type {string|undefined} */
+  this.fillColor = options.fillColor;
+  if (goog.isDef(options.fillColor)) {
+    goog.asserts.assertString(options.fillColor, 'fillColor must be a string');
+  }
+
+  /** @type {number|undefined} */
+  this.fillOpacity = options.fillOpacity;
+  if (goog.isDef(options.fillOpacity)) {
+    goog.asserts.assertNumber(
+        options.fillOpacity, 'fillOpacity must be a number');
+  }
+
+  /** @type {string|undefined} */
+  this.strokeColor = options.strokeColor;
+  if (goog.isDef(this.strokeColor)) {
+    goog.asserts.assertString(
+        this.strokeColor, 'strokeColor must be a string');
+  }
+
+  /** @type {number|undefined} */
+  this.strokeOpacity = options.strokeOpacity;
+  if (goog.isDef(this.strokeOpacity)) {
+    goog.asserts.assertNumber(
+        this.strokeOpacity, 'strokeOpacity must be a number');
+  }
+
+  /** @type {number|undefined} */
+  this.strokeWidth = options.strokeWidth;
+  if (goog.isDef(this.strokeWidth)) {
+    goog.asserts.assertNumber(
+        this.strokeWidth, 'strokeWidth must be a number');
+  }
+
+  // fill and/or stroke properties must be defined
+  var fillDef = goog.isDef(this.fillColor) && goog.isDef(this.fillOpacity);
+  var strokeDef = goog.isDef(this.strokeColor) &&
+      goog.isDef(this.strokeOpacity) &&
+      goog.isDef(this.strokeWidth);
+  goog.asserts.assert(fillDef || strokeDef,
+      'Either fillColor and fillOpacity or ' +
+      'strokeColor and strokeOpacity and strokeWidth must be set');
+
+};
+goog.inherits(ol.style.PolygonLiteral, ol.style.Literal);
+
+
+/**
+ * @inheritDoc
+ */
+ol.style.PolygonLiteral.prototype.equals = function(polygonLiteral) {
+  return this.fillColor == polygonLiteral.fillColor &&
+      this.fillOpacity == polygonLiteral.fillOpacity &&
+      this.strokeColor == polygonLiteral.strokeColor &&
+      this.strokeOpacity == polygonLiteral.strokeOpacity &&
+      this.strokeWidth == polygonLiteral.strokeWidth;
+};

src/ol/style/shape.js

@@ -1,442 +0,0 @@
-goog.provide('ol.style.Shape');
-goog.provide('ol.style.ShapeLiteral');
-goog.provide('ol.style.ShapeType');
-
-goog.require('goog.asserts');
-goog.require('ol.expr');
-goog.require('ol.expr.Expression');
-goog.require('ol.expr.Literal');
-goog.require('ol.style.Point');
-goog.require('ol.style.PointLiteral');
-
-
-/**
- * @enum {string}
- */
-ol.style.ShapeType = {
-  CIRCLE: 'circle'
-};
-
-
-/**
- * @typedef {{type: (ol.style.ShapeType),
- *            size: (number),
- *            fillColor: (string|undefined),
- *            fillOpacity: (number|undefined),
- *            strokeColor: (string|undefined),
- *            strokeOpacity: (number|undefined),
- *            strokeWidth: (number|undefined)}}
- */
-ol.style.ShapeLiteralOptions;
-
-
-
-/**
- * @constructor
- * @extends {ol.style.PointLiteral}
- * @param {ol.style.ShapeLiteralOptions} options Shape literal options.
- */
-ol.style.ShapeLiteral = function(options) {
-
-  goog.asserts.assertString(options.type, 'type must be a string');
-  /** @type {ol.style.ShapeType} */
-  this.type = options.type;
-
-  goog.asserts.assertNumber(options.size, 'size must be a number');
-  /** @type {number} */
-  this.size = options.size;
-
-  /** @type {string|undefined} */
-  this.fillColor = options.fillColor;
-  if (goog.isDef(options.fillColor)) {
-    goog.asserts.assertString(options.fillColor, 'fillColor must be a string');
-  }
-
-  /** @type {number|undefined} */
-  this.fillOpacity = options.fillOpacity;
-  if (goog.isDef(options.fillOpacity)) {
-    goog.asserts.assertNumber(
-        options.fillOpacity, 'fillOpacity must be a number');
-  }
-
-  /** @type {string|undefined} */
-  this.strokeColor = options.strokeColor;
-  if (goog.isDef(this.strokeColor)) {
-    goog.asserts.assertString(
-        this.strokeColor, 'strokeColor must be a string');
-  }
-
-  /** @type {number|undefined} */
-  this.strokeOpacity = options.strokeOpacity;
-  if (goog.isDef(this.strokeOpacity)) {
-    goog.asserts.assertNumber(
-        this.strokeOpacity, 'strokeOpacity must be a number');
-  }
-
-  /** @type {number|undefined} */
-  this.strokeWidth = options.strokeWidth;
-  if (goog.isDef(this.strokeWidth)) {
-    goog.asserts.assertNumber(
-        this.strokeWidth, 'strokeWidth must be a number');
-  }
-
-  // fill and/or stroke properties must be defined
-  var fillDef = goog.isDef(this.fillColor) && goog.isDef(this.fillOpacity);
-  var strokeDef = goog.isDef(this.strokeColor) &&
-      goog.isDef(this.strokeOpacity) &&
-      goog.isDef(this.strokeWidth);
-  goog.asserts.assert(fillDef || strokeDef,
-      'Either fillColor and fillOpacity or ' +
-      'strokeColor and strokeOpacity and strokeWidth must be set');
-
-};
-goog.inherits(ol.style.ShapeLiteral, ol.style.PointLiteral);
-
-
-/**
- * @inheritDoc
- */
-ol.style.ShapeLiteral.prototype.equals = function(shapeLiteral) {
-  return this.type == shapeLiteral.type &&
-      this.size == shapeLiteral.size &&
-      this.fillColor == shapeLiteral.fillColor &&
-      this.fillOpacity == shapeLiteral.fillOpacity &&
-      this.strokeColor == shapeLiteral.strokeColor &&
-      this.strokeOpacity == shapeLiteral.strokeOpacity &&
-      this.strokeWidth == shapeLiteral.strokeWidth;
-};
-
-
-
-/**
- * @constructor
- * @extends {ol.style.Point}
- * @param {ol.style.ShapeOptions} options Shape options.
- */
-ol.style.Shape = function(options) {
-
-  /**
-   * @type {ol.style.ShapeType}
-   * @private
-   */
-  this.type_ = /** @type {ol.style.ShapeType} */ (goog.isDef(options.type) ?
-      options.type : ol.style.ShapeDefaults.type);
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.size_ = !goog.isDefAndNotNull(options.size) ?
-      new ol.expr.Literal(ol.style.ShapeDefaults.size) :
-      (options.size instanceof ol.expr.Expression) ?
-          options.size : new ol.expr.Literal(options.size);
-
-  // fill handling - if any fill property is supplied, use all defaults
-  var fillColor = null,
-      fillOpacity = null;
-
-  if (goog.isDefAndNotNull(options.fillColor) ||
-      goog.isDefAndNotNull(options.fillOpacity)) {
-
-    if (goog.isDefAndNotNull(options.fillColor)) {
-      fillColor = (options.fillColor instanceof ol.expr.Expression) ?
-          options.fillColor :
-          new ol.expr.Literal(options.fillColor);
-    } else {
-      fillColor = new ol.expr.Literal(
-          /** @type {string} */ (ol.style.ShapeDefaults.fillColor));
-    }
-
-    if (goog.isDefAndNotNull(options.fillOpacity)) {
-      fillOpacity = (options.fillOpacity instanceof ol.expr.Expression) ?
-          options.fillOpacity :
-          new ol.expr.Literal(options.fillOpacity);
-    } else {
-      fillOpacity = new ol.expr.Literal(
-          /** @type {number} */ (ol.style.ShapeDefaults.fillOpacity));
-    }
-
-  }
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.fillColor_ = fillColor;
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.fillOpacity_ = fillOpacity;
-
-
-  // stroke handling - if any stroke property is supplied, use defaults
-  var strokeColor = null,
-      strokeOpacity = null,
-      strokeWidth = null;
-
-  if (goog.isDefAndNotNull(options.strokeColor) ||
-      goog.isDefAndNotNull(options.strokeOpacity) ||
-      goog.isDefAndNotNull(options.strokeWidth)) {
-
-    if (goog.isDefAndNotNull(options.strokeColor)) {
-      strokeColor = (options.strokeColor instanceof ol.expr.Expression) ?
-          options.strokeColor :
-          new ol.expr.Literal(options.strokeColor);
-    } else {
-      strokeColor = new ol.expr.Literal(
-          /** @type {string} */ (ol.style.ShapeDefaults.strokeColor));
-    }
-
-    if (goog.isDefAndNotNull(options.strokeOpacity)) {
-      strokeOpacity = (options.strokeOpacity instanceof ol.expr.Expression) ?
-          options.strokeOpacity :
-          new ol.expr.Literal(options.strokeOpacity);
-    } else {
-      strokeOpacity = new ol.expr.Literal(
-          /** @type {number} */ (ol.style.ShapeDefaults.strokeOpacity));
-    }
-
-    if (goog.isDefAndNotNull(options.strokeWidth)) {
-      strokeWidth = (options.strokeWidth instanceof ol.expr.Expression) ?
-          options.strokeWidth :
-          new ol.expr.Literal(options.strokeWidth);
-    } else {
-      strokeWidth = new ol.expr.Literal(
-          /** @type {number} */ (ol.style.ShapeDefaults.strokeWidth));
-    }
-
-  }
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeColor_ = strokeColor;
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeOpacity_ = strokeOpacity;
-
-  /**
-   * @type {ol.expr.Expression}
-   * @private
-   */
-  this.strokeWidth_ = strokeWidth;
-
-  // one of stroke or fill can be null, both null is user error
-  var fill = !goog.isNull(this.fillColor_) && !goog.isNull(this.fillOpacity_);
-  var stroke = !goog.isNull(this.strokeColor_) &&
-      !goog.isNull(this.strokeOpacity_) &&
-      !goog.isNull(this.strokeWidth_);
-  goog.asserts.assert(fill || stroke,
-      'Stroke or fill properties must be provided');
-
-};
-
-
-/**
- * @inheritDoc
- * @return {ol.style.ShapeLiteral} Literal shape symbolizer.
- */
-ol.style.Shape.prototype.createLiteral = function(opt_feature) {
-
-  var size = ol.expr.evaluateFeature(this.size_, opt_feature);
-  goog.asserts.assertNumber(size, 'size must be a number');
-
-  var fillColor;
-  if (!goog.isNull(this.fillColor_)) {
-    fillColor = ol.expr.evaluateFeature(this.fillColor_, opt_feature);
-    goog.asserts.assertString(fillColor, 'fillColor must be a string');
-  }
-
-  var fillOpacity;
-  if (!goog.isNull(this.fillOpacity_)) {
-    fillOpacity = ol.expr.evaluateFeature(this.fillOpacity_, opt_feature);
-    goog.asserts.assertNumber(fillOpacity, 'fillOpacity must be a number');
-  }
-
-  var strokeColor;
-  if (!goog.isNull(this.strokeColor_)) {
-    strokeColor = ol.expr.evaluateFeature(this.strokeColor_, opt_feature);
-    goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
-  }
-
-  var strokeOpacity;
-  if (!goog.isNull(this.strokeOpacity_)) {
-    strokeOpacity = ol.expr.evaluateFeature(this.strokeOpacity_, opt_feature);
-    goog.asserts.assertNumber(strokeOpacity, 'strokeOpacity must be a number');
-  }
-
-  var strokeWidth;
-  if (!goog.isNull(this.strokeWidth_)) {
-    strokeWidth = ol.expr.evaluateFeature(this.strokeWidth_, opt_feature);
-    goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
-  }
-
-  var fill = goog.isDef(fillColor) && goog.isDef(fillOpacity);
-  var stroke = goog.isDef(strokeColor) && goog.isDef(strokeOpacity) &&
-      goog.isDef(strokeWidth);
-
-  goog.asserts.assert(fill || stroke,
-      'either fill or stroke properties must be defined');
-
-  return new ol.style.ShapeLiteral({
-    type: this.type_,
-    size: size,
-    fillColor: fillColor,
-    fillOpacity: fillOpacity,
-    strokeColor: strokeColor,
-    strokeOpacity: strokeOpacity,
-    strokeWidth: strokeWidth
-  });
-};
-
-
-/**
- * Get the fill color.
- * @return {ol.expr.Expression} Fill color.
- */
-ol.style.Shape.prototype.getFillColor = function() {
-  return this.fillColor_;
-};
-
-
-/**
- * Get the fill opacity.
- * @return {ol.expr.Expression} Fill opacity.
- */
-ol.style.Shape.prototype.getFillOpacity = function() {
-  return this.fillOpacity_;
-};
-
-
-/**
- * Get the shape size.
- * @return {ol.expr.Expression} Shape size.
- */
-ol.style.Shape.prototype.getSize = function() {
-  return this.size_;
-};
-
-
-/**
- * Get the stroke color.
- * @return {ol.expr.Expression} Stroke color.
- */
-ol.style.Shape.prototype.getStrokeColor = function() {
-  return this.strokeColor_;
-};
-
-
-/**
- * Get the stroke opacity.
- * @return {ol.expr.Expression} Stroke opacity.
- */
-ol.style.Shape.prototype.getStrokeOpacity = function() {
-  return this.strokeOpacity_;
-};
-
-
-/**
- * Get the stroke width.
- * @return {ol.expr.Expression} Stroke width.
- */
-ol.style.Shape.prototype.getStrokeWidth = function() {
-  return this.strokeWidth_;
-};
-
-
-/**
- * Get the shape type.
- * @return {ol.style.ShapeType} Shape type.
- */
-ol.style.Shape.prototype.getType = function() {
-  return this.type_;
-};
-
-
-/**
- * Set the fill color.
- * @param {ol.expr.Expression} fillColor Fill color.
- */
-ol.style.Shape.prototype.setFillColor = function(fillColor) {
-  goog.asserts.assertInstanceof(fillColor, ol.expr.Expression);
-  this.fillColor_ = fillColor;
-};
-
-
-/**
- * Set the fill opacity.
- * @param {ol.expr.Expression} fillOpacity Fill opacity.
- */
-ol.style.Shape.prototype.setFillOpacity = function(fillOpacity) {
-  goog.asserts.assertInstanceof(fillOpacity, ol.expr.Expression);
-  this.fillOpacity_ = fillOpacity;
-};
-
-
-/**
- * Set the shape size.
- * @param {ol.expr.Expression} size Shape size.
- */
-ol.style.Shape.prototype.setSize = function(size) {
-  goog.asserts.assertInstanceof(size, ol.expr.Expression);
-  this.size_ = size;
-};
-
-
-/**
- * Set the stroke color.
- * @param {ol.expr.Expression} strokeColor Stroke color.
- */
-ol.style.Shape.prototype.setStrokeColor = function(strokeColor) {
-  goog.asserts.assertInstanceof(strokeColor, ol.expr.Expression);
-  this.strokeColor_ = strokeColor;
-};
-
-
-/**
- * Set the stroke opacity.
- * @param {ol.expr.Expression} strokeOpacity Stroke opacity.
- */
-ol.style.Shape.prototype.setStrokeOpacity = function(strokeOpacity) {
-  goog.asserts.assertInstanceof(strokeOpacity, ol.expr.Expression);
-  this.strokeOpacity_ = strokeOpacity;
-};
-
-
-/**
- * Set the stroke width.
- * @param {ol.expr.Expression} strokeWidth Stroke width.
- */
-ol.style.Shape.prototype.setStrokeWidth = function(strokeWidth) {
-  goog.asserts.assertInstanceof(strokeWidth, ol.expr.Expression);
-  this.strokeWidth_ = strokeWidth;
-};
-
-
-/**
- * Set the shape type.
- * @param {ol.style.ShapeType} type Shape type.
- */
-ol.style.Shape.prototype.setType = function(type) {
-  this.type_ = type;
-};
-
-
-/**
- * @type {ol.style.ShapeLiteral}
- */
-ol.style.ShapeDefaults = new ol.style.ShapeLiteral({
-  type: ol.style.ShapeType.CIRCLE,
-  size: 5,
-  fillColor: '#ffffff',
-  fillOpacity: 0.4,
-  strokeColor: '#696969',
-  strokeOpacity: 0.8,
-  strokeWidth: 1.5
-});

src/ol/style/shapeliteral.js

@@ -0,0 +1,102 @@
+goog.provide('ol.style.ShapeLiteral');
+goog.provide('ol.style.ShapeType');
+
+goog.require('goog.asserts');
+goog.require('ol.style.PointLiteral');
+
+
+/**
+ * @enum {string}
+ */
+ol.style.ShapeType = {
+  CIRCLE: 'circle'
+};
+
+
+/**
+ * @typedef {{type: (ol.style.ShapeType),
+ *            size: (number),
+ *            fillColor: (string|undefined),
+ *            fillOpacity: (number|undefined),
+ *            strokeColor: (string|undefined),
+ *            strokeOpacity: (number|undefined),
+ *            strokeWidth: (number|undefined)}}
+ */
+ol.style.ShapeLiteralOptions;
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.PointLiteral}
+ * @param {ol.style.ShapeLiteralOptions} options Shape literal options.
+ */
+ol.style.ShapeLiteral = function(options) {
+
+  goog.asserts.assertString(options.type, 'type must be a string');
+  /** @type {ol.style.ShapeType} */
+  this.type = options.type;
+
+  goog.asserts.assertNumber(options.size, 'size must be a number');
+  /** @type {number} */
+  this.size = options.size;
+
+  /** @type {string|undefined} */
+  this.fillColor = options.fillColor;
+  if (goog.isDef(options.fillColor)) {
+    goog.asserts.assertString(options.fillColor, 'fillColor must be a string');
+  }
+
+  /** @type {number|undefined} */
+  this.fillOpacity = options.fillOpacity;
+  if (goog.isDef(options.fillOpacity)) {
+    goog.asserts.assertNumber(
+        options.fillOpacity, 'fillOpacity must be a number');
+  }
+
+  /** @type {string|undefined} */
+  this.strokeColor = options.strokeColor;
+  if (goog.isDef(this.strokeColor)) {
+    goog.asserts.assertString(
+        this.strokeColor, 'strokeColor must be a string');
+  }
+
+  /** @type {number|undefined} */
+  this.strokeOpacity = options.strokeOpacity;
+  if (goog.isDef(this.strokeOpacity)) {
+    goog.asserts.assertNumber(
+        this.strokeOpacity, 'strokeOpacity must be a number');
+  }
+
+  /** @type {number|undefined} */
+  this.strokeWidth = options.strokeWidth;
+  if (goog.isDef(this.strokeWidth)) {
+    goog.asserts.assertNumber(
+        this.strokeWidth, 'strokeWidth must be a number');
+  }
+
+  // fill and/or stroke properties must be defined
+  var fillDef = goog.isDef(this.fillColor) && goog.isDef(this.fillOpacity);
+  var strokeDef = goog.isDef(this.strokeColor) &&
+      goog.isDef(this.strokeOpacity) &&
+      goog.isDef(this.strokeWidth);
+  goog.asserts.assert(fillDef || strokeDef,
+      'Either fillColor and fillOpacity or ' +
+      'strokeColor and strokeOpacity and strokeWidth must be set');
+
+};
+goog.inherits(ol.style.ShapeLiteral, ol.style.PointLiteral);
+
+
+/**
+ * @inheritDoc
+ */
+ol.style.ShapeLiteral.prototype.equals = function(shapeLiteral) {
+  return this.type == shapeLiteral.type &&
+      this.size == shapeLiteral.size &&
+      this.fillColor == shapeLiteral.fillColor &&
+      this.fillOpacity == shapeLiteral.fillOpacity &&
+      this.strokeColor == shapeLiteral.strokeColor &&
+      this.strokeOpacity == shapeLiteral.strokeOpacity &&
+      this.strokeWidth == shapeLiteral.strokeWidth;
+};

src/ol/style/shapesymbolizer.js

@@ -0,0 +1,204 @@
+goog.provide('ol.style.Shape');
+
+goog.require('goog.asserts');
+goog.require('ol.Feature');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Literal');
+goog.require('ol.geom.GeometryType');
+goog.require('ol.style.Fill');
+goog.require('ol.style.Point');
+goog.require('ol.style.ShapeLiteral');
+goog.require('ol.style.ShapeType');
+goog.require('ol.style.Stroke');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.Point}
+ * @param {ol.style.ShapeOptions} options Shape options.
+ */
+ol.style.Shape = function(options) {
+
+  /**
+   * @type {ol.style.ShapeType}
+   * @private
+   */
+  this.type_ = /** @type {ol.style.ShapeType} */ (goog.isDef(options.type) ?
+      options.type : ol.style.ShapeDefaults.type);
+
+  /**
+   * @type {ol.expr.Expression}
+   * @private
+   */
+  this.size_ = !goog.isDefAndNotNull(options.size) ?
+      new ol.expr.Literal(ol.style.ShapeDefaults.size) :
+      (options.size instanceof ol.expr.Expression) ?
+          options.size : new ol.expr.Literal(options.size);
+
+  /**
+   * @type {ol.style.Fill}
+   * @private
+   */
+  this.fill_ = goog.isDefAndNotNull(options.fill) ? options.fill : null;
+
+  /**
+   * @type {ol.style.Stroke}
+   * @private
+   */
+  this.stroke_ = goog.isDefAndNotNull(options.stroke) ? options.stroke : null;
+
+  // one of stroke or fill can be null, both null is user error
+  goog.asserts.assert(this.fill_ || this.stroke_,
+      'Stroke or fill must be provided');
+
+};
+
+
+/**
+ * @inheritDoc
+ * @return {ol.style.ShapeLiteral} Literal shape symbolizer.
+ */
+ol.style.Shape.prototype.createLiteral = function(featureOrType) {
+  var feature, type;
+  if (featureOrType instanceof ol.Feature) {
+    feature = featureOrType;
+    var geometry = feature.getGeometry();
+    type = geometry ? geometry.getType() : null;
+  } else {
+    type = featureOrType;
+  }
+
+  var literal = null;
+  if (type === ol.geom.GeometryType.POINT ||
+      type === ol.geom.GeometryType.MULTIPOINT) {
+    var size = ol.expr.evaluateFeature(this.size_, feature);
+    goog.asserts.assertNumber(size, 'size must be a number');
+
+    var fillColor, fillOpacity;
+    if (!goog.isNull(this.fill_)) {
+      fillColor = ol.expr.evaluateFeature(this.fill_.getColor(), feature);
+      goog.asserts.assertString(
+          fillColor, 'fillColor must be a string');
+      fillOpacity = ol.expr.evaluateFeature(this.fill_.getOpacity(), feature);
+      goog.asserts.assertNumber(
+          fillOpacity, 'fillOpacity must be a number');
+    }
+
+    var strokeColor, strokeOpacity, strokeWidth;
+    if (!goog.isNull(this.stroke_)) {
+      strokeColor = ol.expr.evaluateFeature(this.stroke_.getColor(), feature);
+      goog.asserts.assertString(
+          strokeColor, 'strokeColor must be a string');
+      strokeOpacity = ol.expr.evaluateFeature(this.stroke_.getOpacity(),
+          feature);
+      goog.asserts.assertNumber(
+          strokeOpacity, 'strokeOpacity must be a number');
+      strokeWidth = ol.expr.evaluateFeature(this.stroke_.getWidth(), feature);
+      goog.asserts.assertNumber(
+          strokeWidth, 'strokeWidth must be a number');
+    }
+
+    literal = new ol.style.ShapeLiteral({
+      type: this.type_,
+      size: size,
+      fillColor: fillColor,
+      fillOpacity: fillOpacity,
+      strokeColor: strokeColor,
+      strokeOpacity: strokeOpacity,
+      strokeWidth: strokeWidth
+    });
+  }
+
+  return literal;
+};
+
+
+/**
+ * Get the fill.
+ * @return {ol.style.Fill} Shape fill.
+ */
+ol.style.Shape.prototype.getFill = function() {
+  return this.fill_;
+};
+
+
+/**
+ * Get the shape size.
+ * @return {ol.expr.Expression} Shape size.
+ */
+ol.style.Shape.prototype.getSize = function() {
+  return this.size_;
+};
+
+
+/**
+ * Get the stroke.
+ * @return {ol.style.Stroke} Shape stroke.
+ */
+ol.style.Shape.prototype.getStroke = function() {
+  return this.stroke_;
+};
+
+
+/**
+ * Get the shape type.
+ * @return {ol.style.ShapeType} Shape type.
+ */
+ol.style.Shape.prototype.getType = function() {
+  return this.type_;
+};
+
+
+/**
+ * Set the fill.
+ * @param {ol.style.Fill} fill Shape fill.
+ */
+ol.style.Shape.prototype.setFill = function(fill) {
+  if (!goog.isNull(fill)) {
+    goog.asserts.assertInstanceof(fill, ol.style.Fill);
+  }
+  this.fill_ = fill;
+};
+
+
+/**
+ * Set the shape size.
+ * @param {ol.expr.Expression} size Shape size.
+ */
+ol.style.Shape.prototype.setSize = function(size) {
+  goog.asserts.assertInstanceof(size, ol.expr.Expression);
+  this.size_ = size;
+};
+
+
+/**
+ * Set the stroke.
+ * @param {ol.style.Stroke} stroke Shape stroke.
+ */
+ol.style.Shape.prototype.setStroke = function(stroke) {
+  if (!goog.isNull(stroke)) {
+    goog.asserts.assertInstanceof(stroke, ol.style.Stroke);
+  }
+  this.stroke_ = stroke;
+};
+
+
+/**
+ * Set the shape type.
+ * @param {ol.style.ShapeType} type Shape type.
+ */
+ol.style.Shape.prototype.setType = function(type) {
+  this.type_ = type;
+};
+
+
+/**
+ * @typedef {{type: (ol.style.ShapeType),
+ *            size: (number)}}
+ */
+ol.style.ShapeDefaults = {
+  type: ol.style.ShapeType.CIRCLE,
+  size: 5
+};

src/ol/style/strokesymbolizer.js

@@ -0,0 +1,169 @@
+goog.provide('ol.style.Stroke');
+goog.provide('ol.style.StrokeDefaults');
+
+goog.require('goog.asserts');
+goog.require('ol.Feature');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Literal');
+goog.require('ol.geom.GeometryType');
+goog.require('ol.style.LineLiteral');
+goog.require('ol.style.PolygonLiteral');
+goog.require('ol.style.Symbolizer');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.Symbolizer}
+ * @param {ol.style.StrokeOptions=} opt_options Stroke options.
+ */
+ol.style.Stroke = function(opt_options) {
+  goog.base(this);
+  var options = opt_options || {};
+
+  /**
+   * @type {ol.expr.Expression}
+   * @private
+   */
+  this.color_ = !goog.isDefAndNotNull(options.color) ?
+      new ol.expr.Literal(ol.style.StrokeDefaults.color) :
+      (options.color instanceof ol.expr.Expression) ?
+          options.color : new ol.expr.Literal(options.color);
+
+  /**
+   * @type {ol.expr.Expression}
+   * @private
+   */
+  this.opacity_ = !goog.isDefAndNotNull(options.opacity) ?
+      new ol.expr.Literal(ol.style.StrokeDefaults.opacity) :
+      (options.opacity instanceof ol.expr.Expression) ?
+          options.opacity : new ol.expr.Literal(options.opacity);
+
+  /**
+   * @type {ol.expr.Expression}
+   * @private
+   */
+  this.width_ = !goog.isDefAndNotNull(options.width) ?
+      new ol.expr.Literal(ol.style.StrokeDefaults.width) :
+      (options.width instanceof ol.expr.Expression) ?
+          options.width : new ol.expr.Literal(options.width);
+
+};
+goog.inherits(ol.style.Stroke, ol.style.Symbolizer);
+
+
+/**
+ * @inheritDoc
+ * @return {ol.style.LineLiteral|ol.style.PolygonLiteral} Symbolizer literal.
+ */
+ol.style.Stroke.prototype.createLiteral = function(featureOrType) {
+  var feature, type;
+  if (featureOrType instanceof ol.Feature) {
+    feature = featureOrType;
+    var geometry = feature.getGeometry();
+    type = geometry ? geometry.getType() : null;
+  } else {
+    type = featureOrType;
+  }
+
+  var color = ol.expr.evaluateFeature(
+      this.color_, feature);
+  goog.asserts.assertString(color, 'color must be a string');
+
+  var opacity = ol.expr.evaluateFeature(
+      this.opacity_, feature);
+  goog.asserts.assertNumber(opacity, 'opacity must be a number');
+
+  var width = ol.expr.evaluateFeature(
+      this.width_, feature);
+  goog.asserts.assertNumber(width, 'width must be a number');
+
+  var literal = null;
+  if (type === ol.geom.GeometryType.LINESTRING ||
+      type === ol.geom.GeometryType.MULTILINESTRING) {
+    literal = new ol.style.LineLiteral({
+      color: color,
+      opacity: opacity,
+      width: width
+    });
+  } else if (type === ol.geom.GeometryType.POLYGON ||
+      type === ol.geom.GeometryType.MULTIPOLYGON) {
+    literal = new ol.style.PolygonLiteral({
+      strokeColor: color,
+      strokeOpacity: opacity,
+      strokeWidth: width
+    });
+  }
+
+  return literal;
+};
+
+
+/**
+ * Get the stroke color.
+ * @return {ol.expr.Expression} Stroke color.
+ */
+ol.style.Stroke.prototype.getColor = function() {
+  return this.color_;
+};
+
+
+/**
+ * Get the stroke opacity.
+ * @return {ol.expr.Expression} Stroke opacity.
+ */
+ol.style.Stroke.prototype.getOpacity = function() {
+  return this.opacity_;
+};
+
+
+/**
+ * Get the stroke width.
+ * @return {ol.expr.Expression} Stroke width.
+ */
+ol.style.Stroke.prototype.getWidth = function() {
+  return this.width_;
+};
+
+
+/**
+ * Set the stroke color.
+ * @param {ol.expr.Expression} color Stroke color.
+ */
+ol.style.Stroke.prototype.setColor = function(color) {
+  goog.asserts.assertInstanceof(color, ol.expr.Expression);
+  this.color_ = color;
+};
+
+
+/**
+ * Set the stroke opacity.
+ * @param {ol.expr.Expression} opacity Stroke opacity.
+ */
+ol.style.Stroke.prototype.setOpacity = function(opacity) {
+  goog.asserts.assertInstanceof(opacity, ol.expr.Expression);
+  this.opacity_ = opacity;
+};
+
+
+/**
+ * Set the stroke width.
+ * @param {ol.expr.Expression} width Stroke width.
+ */
+ol.style.Stroke.prototype.setWidth = function(width) {
+  goog.asserts.assertInstanceof(width, ol.expr.Expression);
+  this.width_ = width;
+};
+
+
+/**
+ * @typedef {{strokeColor: (string),
+ *            strokeOpacity: (number),
+ *            strokeWidth: (number)}}
+ */
+ol.style.StrokeDefaults = {
+  color: '#696969',
+  opacity: 0.75,
+  width: 1.5
+};

src/ol/style/style.js

@@ -1,9 +1,15 @@
 goog.provide('ol.style.Style');
 
+goog.require('goog.object');
 goog.require('ol.Feature');
 goog.require('ol.geom.GeometryType');
+goog.require('ol.style.Fill');
+goog.require('ol.style.Literal');
+goog.require('ol.style.PolygonLiteral');
 goog.require('ol.style.Rule');
-goog.require('ol.style.SymbolizerLiteral');
+goog.require('ol.style.Shape');
+goog.require('ol.style.Stroke');
+goog.require('ol.style.Symbolizer');
 
 
 
@@ -19,52 +25,125 @@ ol.style.Style = function(options) {
    */
   this.rules_ = goog.isDef(options.rules) ? options.rules : [];
 
+  /**
+   * Symbolizers that apply if no rules are given or where none of the given
+   * rules apply (these are the "else" symbolizers).
+   * @type {Array.<ol.style.Symbolizer>}
+   * @private
+   */
+  this.symbolizers_ = goog.isDef(options.symbolizers) ?
+      options.symbolizers : [];
+
 };
 
 
 /**
+ * Create an array of symbolizer literals for a feature.
  * @param {ol.Feature} feature Feature.
- * @return {Array.<ol.style.SymbolizerLiteral>} Symbolizer literals for the
+ * @return {Array.<ol.style.Literal>} Symbolizer literals for the
  *     feature.
  */
-ol.style.Style.prototype.apply = function(feature) {
+ol.style.Style.prototype.createLiterals = function(feature) {
   var rules = this.rules_,
-      literals = [],
+      symbolizers = [],
-      rule, symbolizers;
+      applies = false,
+      rule;
   for (var i = 0, ii = rules.length; i < ii; ++i) {
     rule = rules[i];
     if (rule.applies(feature)) {
-      symbolizers = rule.getSymbolizers();
+      applies = true;
-      for (var j = 0, jj = symbolizers.length; j < jj; ++j) {
+      symbolizers.push.apply(symbolizers, rule.getSymbolizers());
-        literals.push(symbolizers[j].createLiteral(feature));
-      }
     }
+  } if (!applies) {
+    // these are the "else" symbolizers
+    symbolizers = this.symbolizers_;
   }
-  return literals;
+  return ol.style.Style.createLiterals(symbolizers, feature);
 };
 
 
 /**
- * @param {ol.Feature} feature Feature.
+ * The default style.
- * @return {Array.<ol.style.SymbolizerLiteral>} Default symbolizer literals for
+ * @type {ol.style.Style}
- *     the feature.
  */
-ol.style.Style.applyDefaultStyle = function(feature) {
+ol.style.Style.defaults = new ol.style.Style({
-  var geometry = feature.getGeometry(),
+  symbolizers: [
-      symbolizerLiterals = [];
+    new ol.style.Shape({
-  if (!goog.isNull(geometry)) {
+      fill: new ol.style.Fill(),
-    var type = geometry.getType();
+      stroke: new ol.style.Stroke()
-    if (type === ol.geom.GeometryType.POINT ||
+    }),
-        type === ol.geom.GeometryType.MULTIPOINT) {
+    new ol.style.Fill(),
-      symbolizerLiterals.push(ol.style.ShapeDefaults);
+    new ol.style.Stroke()
-    } else if (type === ol.geom.GeometryType.LINESTRING ||
+  ]
-        type === ol.geom.GeometryType.MULTILINESTRING) {
+});
-      symbolizerLiterals.push(ol.style.LineDefaults);
+
-    } else if (type === ol.geom.GeometryType.LINEARRING ||
+
-        type === ol.geom.GeometryType.POLYGON ||
+/**
-        type === ol.geom.GeometryType.MULTIPOLYGON) {
+ * Given an array of symbolizers, generate an array of literals.
-      symbolizerLiterals.push(ol.style.PolygonDefaults);
+ * @param {Array.<ol.style.Symbolizer>} symbolizers List of symbolizers.
+ * @param {ol.Feature|ol.geom.GeometryType} featureOrType Feature or geometry
+ *     type.
+ * @return {Array.<ol.style.Literal>} Array of literals.
+ */
+ol.style.Style.createLiterals = function(symbolizers, featureOrType) {
+  var length = symbolizers.length;
+  var literals = new Array(length);
+  for (var i = 0; i < length; ++i) {
+    literals[i] = symbolizers[i].createLiteral(featureOrType);
+  }
+  return ol.style.Style.reduceLiterals_(literals);
+};
+
+
+/**
+ * Collapse partial polygon symbolizers and remove null symbolizers.
+ * @param {Array.<ol.style.Literal>} literals Input literals.
+ * @return {Array.<ol.style.Literal>} Reduced literals.
+ * @private
+ */
+ol.style.Style.reduceLiterals_ = function(literals) {
+  var reduced = [];
+  var literal, stroke, fill, key, value;
+  for (var i = 0, ii = literals.length; i < ii; ++i) {
+    literal = literals[i];
+    if (literal instanceof ol.style.PolygonLiteral) {
+      if (goog.isDef(literal.strokeColor) &&
+          !goog.isDef(literal.fillColor)) {
+        // stroke only, check for previous fill only
+        if (fill) {
+          for (key in literal) {
+            value = literal[key];
+            if (goog.isDef(value)) {
+              fill[key] = value;
+            }
+          }
+          fill = null;
+        } else {
+          stroke = literal;
+          reduced.push(stroke);
+        }
+      } else if (goog.isDef(literal.fillColor) &&
+          !goog.isDef(literal.strokeColor)) {
+        // fill only, check for previous stroke only
+        if (stroke) {
+          for (key in literal) {
+            value = literal[key];
+            if (goog.isDef(value)) {
+              stroke[key] = value;
+            }
+          }
+          stroke = null;
+        } else {
+          fill = literal;
+          reduced.push(fill);
+        }
+      } else {
+        // both stroke and fill, proceed
+        reduced.push(literal);
+      }
+    } else if (literal) {
+      reduced.push(literal);
     }
   }
-  return symbolizerLiterals;
+  return reduced;
 };

src/ol/style/symbolizer.js

@@ -1,22 +1,7 @@
 goog.provide('ol.style.Symbolizer');
-goog.provide('ol.style.SymbolizerLiteral');
 
 goog.require('ol.Feature');
-
+goog.require('ol.style.Literal');
-
-
-/**
- * @constructor
- */
-ol.style.SymbolizerLiteral = function() {};
-
-
-/**
- * @param {ol.style.SymbolizerLiteral} symbolizerLiteral Symbolizer literal to
- *     compare to.
- * @return {boolean} Is the passed symbolizer literal equal to this instance?
- */
-ol.style.SymbolizerLiteral.prototype.equals = goog.abstractMethod;
 
 
 
@@ -27,7 +12,10 @@ ol.style.Symbolizer = function() {};
 
 
 /**
- * @param {ol.Feature=} opt_feature Feature for evaluating expressions.
+ * Create a literal from the symbolizer given a complete feature or a geometry
- * @return {ol.style.SymbolizerLiteral} Literal symbolizer.
+ * type.
+ * @param {ol.geom.GeometryType|ol.Feature} featureOrType Feature for evaluating
+ *     expressions or a geometry type.
+ * @return {ol.style.Literal} Literal symbolizer.
  */
 ol.style.Symbolizer.prototype.createLiteral = goog.abstractMethod;

src/ol/style/textliteral.js

@@ -0,0 +1,57 @@
+goog.provide('ol.style.TextLiteral');
+
+goog.require('goog.asserts');
+goog.require('ol.style.Literal');
+
+
+/**
+ * @typedef {{color: string,
+ *            fontFamily: string,
+ *            fontSize: number,
+ *            text: string,
+ *            opacity: number}}
+ */
+ol.style.TextLiteralOptions;
+
+
+
+/**
+ * @constructor
+ * @extends {ol.style.Literal}
+ * @param {ol.style.TextLiteralOptions} options Text literal options.
+ */
+ol.style.TextLiteral = function(options) {
+
+  goog.asserts.assertString(options.color, 'color must be a string');
+  /** @type {string} */
+  this.color = options.color;
+
+  goog.asserts.assertString(options.fontFamily, 'fontFamily must be a string');
+  /** @type {string} */
+  this.fontFamily = options.fontFamily;
+
+  goog.asserts.assertNumber(options.fontSize, 'fontSize must be a number');
+  /** @type {number} */
+  this.fontSize = options.fontSize;
+
+  goog.asserts.assertString(options.text, 'text must be a string');
+  /** @type {string} */
+  this.text = options.text;
+
+  goog.asserts.assertNumber(options.opacity, 'opacity must be a number');
+  /** @type {number} */
+  this.opacity = options.opacity;
+
+};
+goog.inherits(ol.style.TextLiteral, ol.style.Literal);
+
+
+/**
+ * @inheritDoc
+ */
+ol.style.TextLiteral.prototype.equals = function(textLiteral) {
+  return this.color == textLiteral.color &&
+      this.fontFamily == textLiteral.fontFamily &&
+      this.fontSize == textLiteral.fontSize &&
+      this.opacity == textLiteral.opacity;
+};

src/ol/style/textsymbolizer.js

@@ -1,65 +1,12 @@
 goog.provide('ol.style.Text');
-goog.provide('ol.style.TextLiteral');
 
 goog.require('goog.asserts');
+goog.require('ol.Feature');
 goog.require('ol.expr');
 goog.require('ol.expr.Expression');
 goog.require('ol.expr.Literal');
 goog.require('ol.style.Symbolizer');
-goog.require('ol.style.SymbolizerLiteral');
+goog.require('ol.style.TextLiteral');
-
-
-/**
- * @typedef {{color: string,
- *            fontFamily: string,
- *            fontSize: number,
- *            text: string,
- *            opacity: number}}
- */
-ol.style.TextLiteralOptions;
-
-
-
-/**
- * @constructor
- * @extends {ol.style.SymbolizerLiteral}
- * @param {ol.style.TextLiteralOptions} options Text literal options.
- */
-ol.style.TextLiteral = function(options) {
-
-  goog.asserts.assertString(options.color, 'color must be a string');
-  /** @type {string} */
-  this.color = options.color;
-
-  goog.asserts.assertString(options.fontFamily, 'fontFamily must be a string');
-  /** @type {string} */
-  this.fontFamily = options.fontFamily;
-
-  goog.asserts.assertNumber(options.fontSize, 'fontSize must be a number');
-  /** @type {number} */
-  this.fontSize = options.fontSize;
-
-  goog.asserts.assertString(options.text, 'text must be a string');
-  /** @type {string} */
-  this.text = options.text;
-
-  goog.asserts.assertNumber(options.opacity, 'opacity must be a number');
-  /** @type {number} */
-  this.opacity = options.opacity;
-
-};
-goog.inherits(ol.style.TextLiteral, ol.style.SymbolizerLiteral);
-
-
-/**
- * @inheritDoc
- */
-ol.style.TextLiteral.prototype.equals = function(textLiteral) {
-  return this.color == textLiteral.color &&
-      this.fontFamily == textLiteral.fontFamily &&
-      this.fontSize == textLiteral.fontSize &&
-      this.opacity == textLiteral.opacity;
-};
 
 
 
@@ -121,21 +68,29 @@ goog.inherits(ol.style.Text, ol.style.Symbolizer);
  * @inheritDoc
  * @return {ol.style.TextLiteral} Literal text symbolizer.
  */
-ol.style.Text.prototype.createLiteral = function(opt_feature) {
+ol.style.Text.prototype.createLiteral = function(featureOrType) {
+  var feature, type;
+  if (featureOrType instanceof ol.Feature) {
+    feature = featureOrType;
+    var geometry = feature.getGeometry();
+    type = geometry ? geometry.getType() : null;
+  } else {
+    type = featureOrType;
+  }
 
-  var color = ol.expr.evaluateFeature(this.color_, opt_feature);
+  var color = ol.expr.evaluateFeature(this.color_, feature);
   goog.asserts.assertString(color, 'color must be a string');
 
-  var fontFamily = ol.expr.evaluateFeature(this.fontFamily_, opt_feature);
+  var fontFamily = ol.expr.evaluateFeature(this.fontFamily_, feature);
   goog.asserts.assertString(fontFamily, 'fontFamily must be a string');
 
-  var fontSize = ol.expr.evaluateFeature(this.fontSize_, opt_feature);
+  var fontSize = ol.expr.evaluateFeature(this.fontSize_, feature);
   goog.asserts.assertNumber(fontSize, 'fontSize must be a number');
 
-  var text = ol.expr.evaluateFeature(this.text_, opt_feature);
+  var text = ol.expr.evaluateFeature(this.text_, feature);
   goog.asserts.assertString(text, 'text must be a string');
 
-  var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
+  var opacity = ol.expr.evaluateFeature(this.opacity_, feature);
   goog.asserts.assertNumber(opacity, 'opacity must be a number');
 
   return new ol.style.TextLiteral({
@@ -244,12 +199,14 @@ ol.style.Text.prototype.setText = function(text) {
 
 
 /**
- * @type {ol.style.TextLiteral}
+ * @typedef {{color: string,
+ *            fontFamily: string,
+ *            fontSize: number,
+ *            opacity: number}}
  */
-ol.style.TextDefaults = new ol.style.TextLiteral({
+ol.style.TextDefaults = {
   color: '#000',
   fontFamily: 'sans-serif',
   fontSize: 10,
-  text: '',
   opacity: 1
-});
+};

test/spec/ol/layer/vectorlayer.test.js

@@ -106,9 +106,9 @@ describe('ol.layer.Vector', function() {
         rules: [
           new ol.style.Rule({
             symbolizers: [
-              new ol.style.Line({
+              new ol.style.Stroke({
-                strokeWidth: 2,
+                width: 2,
-                strokeColor: ol.expr.parse('colorProperty'),
+                color: ol.expr.parse('colorProperty'),
                 opacity: 1
               })
             ]
@@ -137,20 +137,20 @@ describe('ol.layer.Vector', function() {
       var groups = layer.groupFeaturesBySymbolizerLiteral(features);
       expect(groups.length).to.be(2);
       expect(groups[0][0].length).to.be(1);
-      expect(groups[0][1].strokeColor).to.be('#BADA55');
+      expect(groups[0][1].color).to.be('#BADA55');
       expect(groups[1][0].length).to.be(2);
-      expect(groups[1][1].strokeColor).to.be('#013');
+      expect(groups[1][1].color).to.be('#013');
     });
 
     it('groups equal symbolizers also when defined on features', function() {
-      var symbolizer = new ol.style.Line({
+      var symbolizer = new ol.style.Stroke({
-        strokeWidth: 3,
+        width: 3,
-        strokeColor: ol.expr.parse('colorProperty'),
+        color: ol.expr.parse('colorProperty'),
         opacity: 1
       });
-      var anotherSymbolizer = new ol.style.Line({
+      var anotherSymbolizer = new ol.style.Stroke({
-        strokeWidth: 3,
+        width: 3,
-        strokeColor: '#BADA55',
+        color: '#BADA55',
         opacity: 1
       });
       var featureWithSymbolizers = new ol.Feature({
@@ -165,9 +165,9 @@ describe('ol.layer.Vector', function() {
       features.push(featureWithSymbolizers, anotherFeatureWithSymbolizers);
 
       var groups = layer.groupFeaturesBySymbolizerLiteral(features);
-      expect(groups.length).to.be(3);
+      expect(groups).to.have.length(3);
       expect(groups[2][0].length).to.be(2);
-      expect(groups[2][1].strokeWidth).to.be(3);
+      expect(groups[2][1].width).to.be(3);
 
     });
 
@@ -188,6 +188,6 @@ goog.require('ol.geom.Point');
 goog.require('ol.proj');
 goog.require('ol.layer.Vector');
 goog.require('ol.source.Vector');
-goog.require('ol.style.Line');
 goog.require('ol.style.Rule');
+goog.require('ol.style.Stroke');
 goog.require('ol.style.Style');

test/spec/ol/parser/kml.test.js

@@ -1,6 +1,6 @@
-goog.provide('ol.test.parser.kml');
+goog.provide('ol.test.parser.KML');
 
-describe('ol.parser.kml', function() {
+describe('ol.parser.KML', function() {
 
   var parser = new ol.parser.KML();
 
@@ -165,8 +165,9 @@ describe('ol.parser.kml', function() {
       expect(obj.features[0].get('description')).to.eql('Full of text.');
       expect(obj.features[0].get('name')).to.eql('Pezinok');
     });
-    it('Test line style (read / write)', function() {
+
-      var test_style = '<kml xmlns="http://www.opengis.net/kml/2.2" ' +
+    it('handles line style (read / write)', function() {
+      var kml = '<kml xmlns="http://www.opengis.net/kml/2.2" ' +
           'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' +
           'xsi:schemaLocation="http://www.opengis.net/kml/2.2 ' +
           'http://schemas.opengis.net/kml/2.2.0/ogckml22.xsd"> ' +
@@ -175,16 +176,24 @@ describe('ol.parser.kml', function() {
           '<coordinates> -112,36 -113,37 </coordinates> </LineString>' +
           '</Placemark></Document></kml>';
       var p = new ol.parser.KML({extractStyles: true});
-      var obj = p.read(test_style);
+      var obj = p.read(kml);
       var output = p.write(obj);
-      expect(goog.dom.xml.loadXml(test_style)).to.xmleql(
+      expect(goog.dom.xml.loadXml(kml)).to.xmleql(
           goog.dom.xml.loadXml(output));
-      var symbolizer = obj.features[0].getSymbolizerLiterals()[0];
+
-      expect(symbolizer instanceof ol.style.LineLiteral).to.be.ok();
+      var symbolizers = obj.features[0].getSymbolizers();
-      expect(symbolizer.strokeColor).to.eql('#ff0000');
+      expect(symbolizers).to.have.length(1);
-      expect(symbolizer.strokeOpacity).to.eql(0.5294117647058824);
+
-      expect(symbolizer.strokeWidth).to.eql(10);
+      var stroke = symbolizers[0];
+      expect(stroke).to.be.a(ol.style.Stroke);
+
+      var literal = stroke.createLiteral(ol.geom.GeometryType.LINESTRING);
+      expect(literal).to.be.a(ol.style.LineLiteral);
+      expect(literal.color).to.eql('#ff0000');
+      expect(literal.opacity).to.eql(0.5294117647058824);
+      expect(literal.width).to.eql(10);
     });
+
     it('reads PolyStyle fill', function() {
       var kml = '<kml xmlns="http://www.opengis.net/kml/2.2">' +
           '<Document><Placemark>    <Style> <PolyStyle> <fill>1</fill> ' +
@@ -203,11 +212,34 @@ describe('ol.parser.kml', function() {
           '</outerBoundaryIs></Polygon></Placemark></Document></kml>';
       var p = new ol.parser.KML({extractStyles: true});
       var obj = p.read(kml);
-      var symbolizer1 = obj.features[0].getSymbolizerLiterals()[0];
+
-      var symbolizer2 = obj.features[1].getSymbolizerLiterals()[0];
+      var symbolizers = obj.features[0].getSymbolizers();
-      expect(symbolizer1.strokeColor).to.be('#ff0000');
+      expect(symbolizers).to.have.length(2);
-      expect(symbolizer2.fillOpacity).to.be(undefined);
+      expect(symbolizers[0]).to.be.a(ol.style.Fill);
+      expect(symbolizers[1]).to.be.a(ol.style.Stroke);
+
+      var literals = ol.style.Style.createLiterals(
+          symbolizers, ol.geom.GeometryType.POLYGON);
+      expect(literals).to.have.length(1);
+
+      var literal = literals[0];
+      expect(literal).to.be.a(ol.style.PolygonLiteral);
+      expect(literal.fillColor).to.be('#ff0000');
+      expect(literal.strokeColor).to.be('#ff0000');
+
+      symbolizers = obj.features[1].getSymbolizers();
+      expect(symbolizers).to.have.length(1);
+      expect(symbolizers[0]).to.be.a(ol.style.Stroke);
+
+      var literals = ol.style.Style.createLiterals(
+          symbolizers, ol.geom.GeometryType.POLYGON);
+      expect(literals).to.have.length(1);
+
+      literal = literals[0];
+      expect(literal).to.be.a(ol.style.PolygonLiteral);
+      expect(literal.fillColor).to.be(undefined);
     });
+
     it('writes PolyStyle fill and outline', function() {
       var kml = '<kml xmlns="http://www.opengis.net/kml/2.2" ' +
           'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' +
@@ -226,18 +258,28 @@ describe('ol.parser.kml', function() {
       expect(goog.dom.xml.loadXml(kml)).to.xmleql(
           goog.dom.xml.loadXml(output));
     });
-    it('Test iconStyle (read / write)', function(done) {
+
+    it('handles iconStyle (read / write)', function(done) {
       var url = 'spec/ol/parser/kml/iconstyle.kml';
       afterLoadXml(url, function(xml) {
         var p = new ol.parser.KML({extractStyles: true});
         var obj = p.read(xml);
         var output = p.write(obj);
         expect(goog.dom.xml.loadXml(output)).to.xmleql(xml);
-        var symbolizer = obj.features[0].getSymbolizerLiterals()[0];
+
+        var symbolizers = obj.features[0].getSymbolizers();
+        expect(symbolizers).to.have.length(1);
+
+        var symbolizer = symbolizers[0];
+        expect(symbolizer).to.be.a(ol.style.Icon);
+
+        var literal = symbolizer.createLiteral(ol.geom.GeometryType.POINT);
+        expect(literal).to.be.a(ol.style.IconLiteral);
+
         var url = 'http://maps.google.com/mapfiles/kml/pushpin/ylw-pushpin.png';
-        expect(symbolizer.url).to.eql(url);
+        expect(literal.url).to.eql(url);
-        expect(symbolizer.width).to.eql(32);
+        expect(literal.width).to.eql(32);
-        expect(symbolizer.height).to.eql(32);
+        expect(literal.height).to.eql(32);
         done();
       });
     });
@@ -295,6 +337,7 @@ goog.require('goog.array');
 goog.require('goog.dom.xml');
 
 goog.require('ol.Feature');
+goog.require('ol.geom.GeometryType');
 goog.require('ol.geom.GeometryCollection');
 goog.require('ol.geom.LineString');
 goog.require('ol.geom.MultiLineString');
@@ -302,4 +345,10 @@ goog.require('ol.geom.MultiPolygon');
 goog.require('ol.geom.Point');
 goog.require('ol.geom.Polygon');
 goog.require('ol.parser.KML');
+goog.require('ol.style.Fill');
+goog.require('ol.style.Icon');
+goog.require('ol.style.IconLiteral');
 goog.require('ol.style.LineLiteral');
+goog.require('ol.style.PolygonLiteral');
+goog.require('ol.style.Stroke');
+goog.require('ol.style.Style');

test/spec/ol/style/fillsymbolizer.test.js

@@ -0,0 +1,164 @@
+goog.provide('ol.test.style.Fill');
+
+describe('ol.style.Fill', function() {
+
+  describe('constructor', function() {
+
+    it('accepts literal values', function() {
+      var symbolizer = new ol.style.Fill({
+        color: '#BADA55'
+      });
+      expect(symbolizer).to.be.a(ol.style.Fill);
+    });
+
+    it('accepts expressions', function() {
+      var symbolizer = new ol.style.Fill({
+        opacity: ol.expr.parse('value / 100'),
+        color: ol.expr.parse('fillAttr')
+      });
+      expect(symbolizer).to.be.a(ol.style.Fill);
+    });
+
+  });
+
+  describe('#createLiteral()', function() {
+
+    it('evaluates expressions with the given feature', function() {
+      var symbolizer = new ol.style.Fill({
+        opacity: ol.expr.parse('value / 100'),
+        color: ol.expr.parse('fillAttr')
+      });
+
+      var feature = new ol.Feature({
+        value: 42,
+        fillAttr: '#ff0000',
+        geometry: new ol.geom.Polygon(
+            [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]])
+      });
+
+      var literal = symbolizer.createLiteral(feature);
+      expect(literal).to.be.a(ol.style.PolygonLiteral);
+      expect(literal.fillOpacity).to.be(42 / 100);
+      expect(literal.fillColor).to.be('#ff0000');
+    });
+
+    it('applies default opacity', function() {
+      var symbolizer = new ol.style.Fill({
+        color: '#ff0000'
+      });
+
+      var literal = symbolizer.createLiteral(ol.geom.GeometryType.POLYGON);
+      expect(literal).to.be.a(ol.style.PolygonLiteral);
+      expect(literal.fillColor).to.be('#ff0000');
+      expect(literal.fillOpacity).to.be(0.4);
+    });
+
+    it('applies default color', function() {
+      var symbolizer = new ol.style.Fill({
+        opacity: 0.8
+      });
+
+      var literal = symbolizer.createLiteral(ol.geom.GeometryType.POLYGON);
+      expect(literal).to.be.a(ol.style.PolygonLiteral);
+      expect(literal.fillColor).to.be('#ffffff');
+      expect(literal.fillOpacity).to.be(0.8);
+    });
+
+  });
+
+  describe('#getColor()', function() {
+
+    it('returns the fill color', function() {
+      var symbolizer = new ol.style.Fill({
+        color: '#ff0000'
+      });
+
+      var color = symbolizer.getColor();
+      expect(color).to.be.a(ol.expr.Literal);
+      expect(color.getValue()).to.be('#ff0000');
+    });
+
+  });
+
+  describe('#getOpacity()', function() {
+
+    it('returns the fill opacity', function() {
+      var symbolizer = new ol.style.Fill({
+        color: '#ffffff',
+        opacity: 0.123
+      });
+
+      var opacity = symbolizer.getOpacity();
+      expect(opacity).to.be.a(ol.expr.Literal);
+      expect(opacity.getValue()).to.be(0.123);
+    });
+
+  });
+
+  describe('#setColor()', function() {
+
+    it('sets the fill color', function() {
+      var symbolizer = new ol.style.Fill({
+        color: '#ff0000'
+      });
+
+      symbolizer.setColor(new ol.expr.Literal('#0000ff'));
+
+      var color = symbolizer.getColor();
+      expect(color).to.be.a(ol.expr.Literal);
+      expect(color.getValue()).to.be('#0000ff');
+    });
+
+    it('throws when not provided an expression', function() {
+      var symbolizer = new ol.style.Fill({
+        color: '#ff0000'
+      });
+
+      expect(function() {
+        symbolizer.setColor('#0000ff');
+      }).throwException(function(err) {
+        expect(err).to.be.a(goog.asserts.AssertionError);
+      });
+    });
+
+  });
+
+  describe('#setOpacity()', function() {
+
+    it('sets the fill opacity', function() {
+      var symbolizer = new ol.style.Fill({
+        color: '#ff0000'
+      });
+
+      symbolizer.setOpacity(new ol.expr.Literal(0.321));
+
+      var opacity = symbolizer.getOpacity();
+      expect(opacity).to.be.a(ol.expr.Literal);
+      expect(opacity.getValue()).to.be(0.321);
+    });
+
+    it('throws when not provided an expression', function() {
+      var symbolizer = new ol.style.Fill({
+        color: '#ff0000'
+      });
+
+      expect(function() {
+        symbolizer.setOpacity(0.123);
+      }).throwException(function(err) {
+        expect(err).to.be.a(goog.asserts.AssertionError);
+      });
+    });
+
+  });
+
+});
+
+goog.require('goog.asserts.AssertionError');
+
+goog.require('ol.Feature');
+goog.require('ol.expr');
+goog.require('ol.expr.Literal');
+goog.require('ol.geom.GeometryType');
+goog.require('ol.geom.Polygon');
+goog.require('ol.style.Fill');
+goog.require('ol.style.PolygonLiteral');

test/spec/ol/style/iconliteral.test.js

@@ -0,0 +1,71 @@
+goog.provide('ol.test.style.IconLiteral');
+
+describe('ol.style.IconLiteral', function() {
+
+  describe('#equals()', function() {
+
+    it('identifies equal literals', function() {
+      var literal = new ol.style.IconLiteral({
+        height: 10,
+        width: 20,
+        opacity: 1,
+        rotation: 0.1,
+        url: 'http://example.com/1.png'
+      });
+      var equalLiteral = new ol.style.IconLiteral({
+        height: 10,
+        width: 20,
+        opacity: 1,
+        rotation: 0.1,
+        url: 'http://example.com/1.png'
+      });
+      var differentLiteral1 = new ol.style.IconLiteral({
+        height: 11,
+        width: 20,
+        opacity: 1,
+        rotation: 0.1,
+        url: 'http://example.com/1.png'
+      });
+      var differentLiteral2 = new ol.style.IconLiteral({
+        height: 10,
+        width: 2,
+        opacity: 1,
+        rotation: 0.1,
+        url: 'http://example.com/1.png'
+      });
+      var differentLiteral3 = new ol.style.IconLiteral({
+        height: 10,
+        width: 20,
+        opacity: 0.5,
+        rotation: 0.1,
+        url: 'http://example.com/1.png'
+      });
+      var differentLiteral4 = new ol.style.IconLiteral({
+        height: 10,
+        width: 20,
+        opacity: 1,
+        rotation: 0.2,
+        url: 'http://example.com/1.png'
+      });
+      var differentLiteral5 = new ol.style.IconLiteral({
+        height: 10,
+        width: 20,
+        opacity: 1,
+        rotation: 0.1,
+        url: 'http://example.com/2.png'
+      });
+      expect(literal.equals(equalLiteral)).to.be(true);
+      expect(literal.equals(differentLiteral1)).to.be(false);
+      expect(literal.equals(differentLiteral2)).to.be(false);
+      expect(literal.equals(differentLiteral3)).to.be(false);
+      expect(literal.equals(differentLiteral4)).to.be(false);
+      expect(literal.equals(differentLiteral5)).to.be(false);
+    });
+
+  });
+
+});
+
+
+
+goog.require('ol.style.IconLiteral');

test/spec/ol/style/iconsymbolizer.test.js

@@ -1,71 +1,5 @@
 goog.provide('ol.test.style.Icon');
 
-describe('ol.style.IconLiteral', function() {
-
-  describe('#equals()', function() {
-
-    it('identifies equal literals', function() {
-      var literal = new ol.style.IconLiteral({
-        height: 10,
-        width: 20,
-        opacity: 1,
-        rotation: 0.1,
-        url: 'http://example.com/1.png'
-      });
-      var equalLiteral = new ol.style.IconLiteral({
-        height: 10,
-        width: 20,
-        opacity: 1,
-        rotation: 0.1,
-        url: 'http://example.com/1.png'
-      });
-      var differentLiteral1 = new ol.style.IconLiteral({
-        height: 11,
-        width: 20,
-        opacity: 1,
-        rotation: 0.1,
-        url: 'http://example.com/1.png'
-      });
-      var differentLiteral2 = new ol.style.IconLiteral({
-        height: 10,
-        width: 2,
-        opacity: 1,
-        rotation: 0.1,
-        url: 'http://example.com/1.png'
-      });
-      var differentLiteral3 = new ol.style.IconLiteral({
-        height: 10,
-        width: 20,
-        opacity: 0.5,
-        rotation: 0.1,
-        url: 'http://example.com/1.png'
-      });
-      var differentLiteral4 = new ol.style.IconLiteral({
-        height: 10,
-        width: 20,
-        opacity: 1,
-        rotation: 0.2,
-        url: 'http://example.com/1.png'
-      });
-      var differentLiteral5 = new ol.style.IconLiteral({
-        height: 10,
-        width: 20,
-        opacity: 1,
-        rotation: 0.1,
-        url: 'http://example.com/2.png'
-      });
-      expect(literal.equals(equalLiteral)).to.be(true);
-      expect(literal.equals(differentLiteral1)).to.be(false);
-      expect(literal.equals(differentLiteral2)).to.be(false);
-      expect(literal.equals(differentLiteral3)).to.be(false);
-      expect(literal.equals(differentLiteral4)).to.be(false);
-      expect(literal.equals(differentLiteral5)).to.be(false);
-    });
-
-  });
-
-});
-
 describe('ol.style.Icon', function() {
 
   describe('constructor', function() {
@@ -110,7 +44,8 @@ describe('ol.style.Icon', function() {
         widthAttr: 0.42,
         opacityAttr: 0.5,
         rotationAttr: 123,
-        urlAttr: 'http://example.com/1.png'
+        urlAttr: 'http://example.com/1.png',
+        geometry: new ol.geom.Point([1, 2])
       });
 
       var literal = symbolizer.createLiteral(feature);
@@ -131,7 +66,7 @@ describe('ol.style.Icon', function() {
         url: ol.expr.parse('"http://example.com/1.png"')
       });
 
-      var literal = symbolizer.createLiteral();
+      var literal = symbolizer.createLiteral(ol.geom.GeometryType.POINT);
       expect(literal).to.be.a(ol.style.IconLiteral);
       expect(literal.height).to.be(10);
       expect(literal.width).to.be(20);
@@ -147,7 +82,7 @@ describe('ol.style.Icon', function() {
         url: ol.expr.parse('"http://example.com/1.png"')
       });
 
-      var literal = symbolizer.createLiteral();
+      var literal = symbolizer.createLiteral(ol.geom.GeometryType.POINT);
       expect(literal).to.be.a(ol.style.IconLiteral);
       expect(literal.opacity).to.be(1);
       expect(literal.rotation).to.be(0);
@@ -397,5 +332,7 @@ goog.require('goog.asserts.AssertionError');
 goog.require('ol.Feature');
 goog.require('ol.expr');
 goog.require('ol.expr.Literal');
+goog.require('ol.geom.GeometryType');
+goog.require('ol.geom.Point');
 goog.require('ol.style.Icon');
 goog.require('ol.style.IconLiteral');

test/spec/ol/style/line.test.js

@@ -1,206 +0,0 @@
-goog.provide('ol.test.style.Line');
-
-describe('ol.style.LineLiteral', function() {
-
-  describe('#equals()', function() {
-
-    it('identifies equal literals', function() {
-      var literal = new ol.style.LineLiteral({
-        strokeWidth: 3,
-        strokeColor: '#BADA55',
-        strokeOpacity: 1
-      });
-      var equalLiteral = new ol.style.LineLiteral({
-        strokeColor: '#BADA55',
-        strokeWidth: 3,
-        strokeOpacity: 1
-      });
-      var differentLiteral = new ol.style.LineLiteral({
-        strokeColor: '#013',
-        strokeWidth: 3,
-        strokeOpacity: 1
-      });
-      expect(literal.equals(equalLiteral)).to.be(true);
-      expect(literal.equals(differentLiteral)).to.be(false);
-    });
-
-  });
-
-});
-
-describe('ol.style.Line', function() {
-
-  describe('constructor', function() {
-
-    it('accepts literal values', function() {
-      var symbolizer = new ol.style.Line({
-        strokeColor: '#BADA55',
-        strokeWidth: 3
-      });
-      expect(symbolizer).to.be.a(ol.style.Line);
-    });
-
-    it('accepts expressions', function() {
-      var symbolizer = new ol.style.Line({
-        strokeOpacity: ol.expr.parse('value / 100'),
-        strokeWidth: ol.expr.parse('widthAttr')
-      });
-      expect(symbolizer).to.be.a(ol.style.Line);
-    });
-
-  });
-
-  describe('#createLiteral()', function() {
-
-    it('evaluates expressions with the given feature', function() {
-      var symbolizer = new ol.style.Line({
-        strokeOpacity: ol.expr.parse('value / 100'),
-        strokeWidth: ol.expr.parse('widthAttr')
-      });
-
-      var feature = new ol.Feature({
-        value: 42,
-        widthAttr: 1.5
-      });
-
-      var literal = symbolizer.createLiteral(feature);
-      expect(literal).to.be.a(ol.style.LineLiteral);
-      expect(literal.strokeOpacity).to.be(42 / 100);
-      expect(literal.strokeWidth).to.be(1.5);
-    });
-
-  });
-
-  describe('#getStrokeColor()', function() {
-
-    it('returns the stroke color', function() {
-      var symbolizer = new ol.style.Line({
-        strokeColor: '#ff0000'
-      });
-
-      var strokeColor = symbolizer.getStrokeColor();
-      expect(strokeColor).to.be.a(ol.expr.Literal);
-      expect(strokeColor.getValue()).to.be('#ff0000');
-    });
-
-  });
-
-  describe('#getStrokeWidth()', function() {
-
-    it('returns the stroke width', function() {
-      var symbolizer = new ol.style.Line({
-        strokeWidth: 10
-      });
-
-      var strokeWidth = symbolizer.getStrokeWidth();
-      expect(strokeWidth).to.be.a(ol.expr.Literal);
-      expect(strokeWidth.getValue()).to.be(10);
-    });
-
-  });
-
-  describe('#getStrokeOpacity()', function() {
-
-    it('returns the stroke opacity', function() {
-      var symbolizer = new ol.style.Line({
-        strokeOpacity: 0.123
-      });
-
-      var opacity = symbolizer.getStrokeOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.123);
-    });
-
-  });
-
-  describe('#setStrokeColor()', function() {
-
-    it('sets the stroke color', function() {
-      var symbolizer = new ol.style.Line({
-        strokeColor: '#ff0000'
-      });
-
-      symbolizer.setStrokeColor(new ol.expr.Literal('#0000ff'));
-
-      var strokeColor = symbolizer.getStrokeColor();
-      expect(strokeColor).to.be.a(ol.expr.Literal);
-      expect(strokeColor.getValue()).to.be('#0000ff');
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Line({
-        strokeColor: '#ff0000'
-      });
-
-      expect(function() {
-        symbolizer.setStrokeColor('#0000ff');
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setStrokeWidth()', function() {
-
-    it('sets the stroke width', function() {
-      var symbolizer = new ol.style.Line({
-        strokeWidth: 10
-      });
-      symbolizer.setStrokeWidth(new ol.expr.Literal(20));
-
-      var strokeWidth = symbolizer.getStrokeWidth();
-      expect(strokeWidth).to.be.a(ol.expr.Literal);
-      expect(strokeWidth.getValue()).to.be(20);
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Line({
-        strokeWidth: 10
-      });
-
-      expect(function() {
-        symbolizer.setStrokeWidth(10);
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setStrokeOpacity()', function() {
-
-    it('sets the stroke opacity', function() {
-      var symbolizer = new ol.style.Line({
-        strokeOpacity: 0.123
-      });
-      symbolizer.setStrokeOpacity(new ol.expr.Literal(0.321));
-
-      var opacity = symbolizer.getStrokeOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.321);
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Line({
-        strokeOpacity: 1
-      });
-
-      expect(function() {
-        symbolizer.setStrokeOpacity(0.5);
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-});
-
-goog.require('goog.asserts.AssertionError');
-
-goog.require('ol.Feature');
-goog.require('ol.expr');
-goog.require('ol.expr.Literal');
-goog.require('ol.style.Line');
-goog.require('ol.style.LineLiteral');

test/spec/ol/style/lineliteral.test.js

@@ -0,0 +1,43 @@
+goog.provide('ol.test.style.LineLiteral');
+
+describe('ol.style.LineLiteral', function() {
+
+  describe('#equals()', function() {
+
+    it('identifies equal literals', function() {
+      var literal = new ol.style.LineLiteral({
+        width: 3,
+        color: '#BADA55',
+        opacity: 1
+      });
+      var equalLiteral = new ol.style.LineLiteral({
+        color: '#BADA55',
+        width: 3,
+        opacity: 1
+      });
+      var differentColor = new ol.style.LineLiteral({
+        width: 3,
+        color: '#ff0000',
+        opacity: 1
+      });
+      var differentWidth = new ol.style.LineLiteral({
+        width: 3.5,
+        color: '#BADA55',
+        opacity: 1
+      });
+      var differentOpacity = new ol.style.LineLiteral({
+        width: 3,
+        color: '#BADA55',
+        opacity: 0.5
+      });
+      expect(literal.equals(equalLiteral)).to.be(true);
+      expect(literal.equals(differentColor)).to.be(false);
+      expect(literal.equals(differentWidth)).to.be(false);
+      expect(literal.equals(differentOpacity)).to.be(false);
+    });
+
+  });
+
+});
+
+goog.require('ol.style.LineLiteral');

test/spec/ol/style/polygon.test.js

@@ -1,317 +0,0 @@
-goog.provide('ol.test.style.Polygon');
-
-describe('ol.style.PolygonLiteral', function() {
-
-  describe('#equals()', function() {
-
-    it('identifies equal literals', function() {
-      var literal = new ol.style.PolygonLiteral({
-        strokeWidth: 3,
-        strokeColor: '#013',
-        strokeOpacity: 0.4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.3
-      });
-      var equalLiteral = new ol.style.PolygonLiteral({
-        strokeWidth: 3,
-        strokeColor: '#013',
-        strokeOpacity: 0.4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.3
-      });
-      var differentStrokeWidth = new ol.style.PolygonLiteral({
-        strokeWidth: 5,
-        strokeColor: '#013',
-        strokeOpacity: 0.4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.3
-      });
-      var differentStrokeColor = new ol.style.PolygonLiteral({
-        strokeWidth: 3,
-        strokeColor: '#ffff00',
-        strokeOpacity: 0.4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.3
-      });
-      var differentStrokeOpacity = new ol.style.PolygonLiteral({
-        strokeWidth: 3,
-        strokeColor: '#013',
-        strokeOpacity: 0.41,
-        fillColor: '#BADA55',
-        fillOpacity: 0.3
-      });
-      var differentFillColor = new ol.style.PolygonLiteral({
-        strokeWidth: 3,
-        strokeColor: '#013',
-        strokeOpacity: 0.4,
-        fillColor: '#00ffff',
-        fillOpacity: 0.3
-      });
-      var differentFillOpacity = new ol.style.PolygonLiteral({
-        strokeWidth: 3,
-        strokeColor: '#013',
-        strokeOpacity: 0.4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.31
-      });
-      expect(literal.equals(equalLiteral)).to.be(true);
-      expect(literal.equals(differentStrokeWidth)).to.be(false);
-      expect(literal.equals(differentStrokeColor)).to.be(false);
-      expect(literal.equals(differentStrokeOpacity)).to.be(false);
-      expect(literal.equals(differentFillColor)).to.be(false);
-      expect(literal.equals(differentFillOpacity)).to.be(false);
-    });
-
-  });
-
-});
-
-describe('ol.style.Polygon', function() {
-
-  describe('constructor', function() {
-
-    it('accepts literal values', function() {
-      var symbolizer = new ol.style.Polygon({
-        fillColor: '#BADA55',
-        strokeWidth: 3
-      });
-      expect(symbolizer).to.be.a(ol.style.Polygon);
-    });
-
-    it('accepts expressions', function() {
-      var symbolizer = new ol.style.Polygon({
-        fillOpacity: ol.expr.parse('value / 100'),
-        fillColor: ol.expr.parse('fillAttr')
-      });
-      expect(symbolizer).to.be.a(ol.style.Polygon);
-    });
-
-  });
-
-  describe('#createLiteral()', function() {
-
-    it('evaluates expressions with the given feature', function() {
-      var symbolizer = new ol.style.Polygon({
-        fillOpacity: ol.expr.parse('value / 100'),
-        fillColor: ol.expr.parse('fillAttr')
-      });
-
-      var feature = new ol.Feature({
-        value: 42,
-        fillAttr: '#ff0000'
-      });
-
-      var literal = symbolizer.createLiteral(feature);
-      expect(literal).to.be.a(ol.style.PolygonLiteral);
-      expect(literal.fillOpacity).to.be(42 / 100);
-      expect(literal.fillColor).to.be('#ff0000');
-      expect(literal.strokeColor).to.be(undefined);
-    });
-
-    it('applies default strokeWidth if only strokeColor is given', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeColor: '#ff0000'
-      });
-
-      var literal = symbolizer.createLiteral();
-      expect(literal).to.be.a(ol.style.PolygonLiteral);
-      expect(literal.strokeColor).to.be('#ff0000');
-      expect(literal.strokeWidth).to.be(1.5);
-      expect(literal.fillColor).to.be(undefined);
-    });
-
-  });
-
-  describe('#getFillColor()', function() {
-
-    it('returns the fill color', function() {
-      var symbolizer = new ol.style.Polygon({
-        fillColor: '#ff0000'
-      });
-
-      var fillColor = symbolizer.getFillColor();
-      expect(fillColor).to.be.a(ol.expr.Literal);
-      expect(fillColor.getValue()).to.be('#ff0000');
-    });
-
-  });
-
-  describe('#getFillOpacity()', function() {
-
-    it('returns the fill opacity', function() {
-      var symbolizer = new ol.style.Polygon({
-        fillColor: '#ffffff',
-        fillOpacity: 0.123
-      });
-
-      var opacity = symbolizer.getFillOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.123);
-    });
-
-  });
-
-  describe('#getStrokeColor()', function() {
-
-    it('returns the stroke color', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeColor: '#ff0000'
-      });
-
-      var strokeColor = symbolizer.getStrokeColor();
-      expect(strokeColor).to.be.a(ol.expr.Literal);
-      expect(strokeColor.getValue()).to.be('#ff0000');
-    });
-
-  });
-
-  describe('#getStrokeWidth()', function() {
-
-    it('returns the stroke width', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeWidth: 10
-      });
-
-      var strokeWidth = symbolizer.getStrokeWidth();
-      expect(strokeWidth).to.be.a(ol.expr.Literal);
-      expect(strokeWidth.getValue()).to.be(10);
-    });
-
-  });
-
-  describe('#getStrokeOpacity()', function() {
-
-    it('returns the stroke opacity', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeWidth: 1,
-        strokeOpacity: 0.123
-      });
-
-      var opacity = symbolizer.getStrokeOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.123);
-    });
-
-  });
-
-  describe('#setFillColor()', function() {
-
-    it('sets the fill color', function() {
-      var symbolizer = new ol.style.Polygon({
-        fillColor: '#ff0000'
-      });
-
-      symbolizer.setFillColor(new ol.expr.Literal('#0000ff'));
-
-      var fillColor = symbolizer.getFillColor();
-      expect(fillColor).to.be.a(ol.expr.Literal);
-      expect(fillColor.getValue()).to.be('#0000ff');
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Polygon({
-        fillColor: '#ff0000'
-      });
-
-      expect(function() {
-        symbolizer.setFillColor('#0000ff');
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setStrokeColor()', function() {
-
-    it('sets the stroke color', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeColor: '#ff0000'
-      });
-
-      symbolizer.setStrokeColor(new ol.expr.Literal('#0000ff'));
-
-      var strokeColor = symbolizer.getStrokeColor();
-      expect(strokeColor).to.be.a(ol.expr.Literal);
-      expect(strokeColor.getValue()).to.be('#0000ff');
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeColor: '#ff0000'
-      });
-
-      expect(function() {
-        symbolizer.setStrokeColor('#0000ff');
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setStrokeWidth()', function() {
-
-    it('sets the stroke width', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeWidth: 10
-      });
-      symbolizer.setStrokeWidth(new ol.expr.Literal(20));
-
-      var strokeWidth = symbolizer.getStrokeWidth();
-      expect(strokeWidth).to.be.a(ol.expr.Literal);
-      expect(strokeWidth.getValue()).to.be(20);
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeWidth: 10
-      });
-
-      expect(function() {
-        symbolizer.setStrokeWidth(10);
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setStrokeOpacity()', function() {
-
-    it('sets the stroke opacity', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeWidth: 1,
-        strokeOpacity: 0.123
-      });
-      symbolizer.setStrokeOpacity(new ol.expr.Literal(0.321));
-
-      var opacity = symbolizer.getStrokeOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.321);
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Polygon({
-        strokeWidth: 1,
-        strokeOpacity: 1
-      });
-
-      expect(function() {
-        symbolizer.setStrokeOpacity(0.5);
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-});
-
-goog.require('goog.asserts.AssertionError');
-
-goog.require('ol.Feature');
-goog.require('ol.expr');
-goog.require('ol.expr.Literal');
-goog.require('ol.style.Polygon');
-goog.require('ol.style.PolygonLiteral');

test/spec/ol/style/polygonliteral.test.js

@@ -0,0 +1,70 @@
+goog.provide('ol.test.style.PolygonLiteral');
+
+describe('ol.style.PolygonLiteral', function() {
+
+  describe('#equals()', function() {
+
+    it('identifies equal literals', function() {
+      var literal = new ol.style.PolygonLiteral({
+        strokeWidth: 3,
+        strokeColor: '#013',
+        strokeOpacity: 0.4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.3
+      });
+      var equalLiteral = new ol.style.PolygonLiteral({
+        strokeWidth: 3,
+        strokeColor: '#013',
+        strokeOpacity: 0.4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.3
+      });
+      var differentStrokeWidth = new ol.style.PolygonLiteral({
+        strokeWidth: 5,
+        strokeColor: '#013',
+        strokeOpacity: 0.4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.3
+      });
+      var differentStrokeColor = new ol.style.PolygonLiteral({
+        strokeWidth: 3,
+        strokeColor: '#ffff00',
+        strokeOpacity: 0.4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.3
+      });
+      var differentStrokeOpacity = new ol.style.PolygonLiteral({
+        strokeWidth: 3,
+        strokeColor: '#013',
+        strokeOpacity: 0.41,
+        fillColor: '#BADA55',
+        fillOpacity: 0.3
+      });
+      var differentFillColor = new ol.style.PolygonLiteral({
+        strokeWidth: 3,
+        strokeColor: '#013',
+        strokeOpacity: 0.4,
+        fillColor: '#00ffff',
+        fillOpacity: 0.3
+      });
+      var differentFillOpacity = new ol.style.PolygonLiteral({
+        strokeWidth: 3,
+        strokeColor: '#013',
+        strokeOpacity: 0.4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.31
+      });
+      expect(literal.equals(equalLiteral)).to.be(true);
+      expect(literal.equals(differentStrokeWidth)).to.be(false);
+      expect(literal.equals(differentStrokeColor)).to.be(false);
+      expect(literal.equals(differentStrokeOpacity)).to.be(false);
+      expect(literal.equals(differentFillColor)).to.be(false);
+      expect(literal.equals(differentFillOpacity)).to.be(false);
+    });
+
+  });
+
+});
+
+
+goog.require('ol.style.PolygonLiteral');

test/spec/ol/style/shape.test.js

@@ -1,424 +0,0 @@
-goog.provide('ol.test.style.Shape');
-
-describe('ol.style.ShapeLiteral', function() {
-
-  describe('#equals()', function() {
-
-    it('identifies equal literals', function() {
-      var literal = new ol.style.ShapeLiteral({
-        type: ol.style.ShapeType.CIRCLE,
-        size: 4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.9,
-        strokeColor: '#013',
-        strokeOpacity: 0.8,
-        strokeWidth: 3
-      });
-      var equalLiteral = new ol.style.ShapeLiteral({
-        type: ol.style.ShapeType.CIRCLE,
-        size: 4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.9,
-        strokeColor: '#013',
-        strokeOpacity: 0.8,
-        strokeWidth: 3
-      });
-      var differentSize = new ol.style.ShapeLiteral({
-        type: ol.style.ShapeType.CIRCLE,
-        size: 5,
-        fillColor: '#BADA55',
-        fillOpacity: 0.9,
-        strokeColor: '#013',
-        strokeOpacity: 0.8,
-        strokeWidth: 3
-      });
-      var differentFillColor = new ol.style.ShapeLiteral({
-        type: ol.style.ShapeType.CIRCLE,
-        size: 4,
-        fillColor: '#ffffff',
-        fillOpacity: 0.9,
-        strokeColor: '#013',
-        strokeOpacity: 0.8,
-        strokeWidth: 3
-      });
-      var differentFillOpacity = new ol.style.ShapeLiteral({
-        type: ol.style.ShapeType.CIRCLE,
-        size: 4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.8,
-        strokeColor: '#013',
-        strokeOpacity: 0.8,
-        strokeWidth: 3
-      });
-      var differentStrokeColor = new ol.style.ShapeLiteral({
-        type: ol.style.ShapeType.CIRCLE,
-        size: 4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.9,
-        strokeColor: '#ffffff',
-        strokeOpacity: 0.8,
-        strokeWidth: 3
-      });
-      var differentStrokeOpacity = new ol.style.ShapeLiteral({
-        type: ol.style.ShapeType.CIRCLE,
-        size: 4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.9,
-        strokeColor: '#013',
-        strokeOpacity: 0.7,
-        strokeWidth: 3
-      });
-      var differentStrokeWidth = new ol.style.ShapeLiteral({
-        type: ol.style.ShapeType.CIRCLE,
-        size: 4,
-        fillColor: '#BADA55',
-        fillOpacity: 0.9,
-        strokeColor: '#013',
-        strokeOpacity: 0.8,
-        strokeWidth: 4
-      });
-      expect(literal.equals(equalLiteral)).to.be(true);
-      expect(literal.equals(differentSize)).to.be(false);
-      expect(literal.equals(differentFillColor)).to.be(false);
-      expect(literal.equals(differentFillOpacity)).to.be(false);
-      expect(literal.equals(differentStrokeColor)).to.be(false);
-      expect(literal.equals(differentStrokeOpacity)).to.be(false);
-      expect(literal.equals(differentStrokeWidth)).to.be(false);
-    });
-
-  });
-
-});
-
-describe('ol.style.Shape', function() {
-
-  describe('constructor', function() {
-
-    it('accepts literal values', function() {
-      var symbolizer = new ol.style.Shape({
-        size: 4,
-        fillColor: '#BADA55'
-      });
-      expect(symbolizer).to.be.a(ol.style.Shape);
-    });
-
-    it('accepts expressions', function() {
-      var symbolizer = new ol.style.Shape({
-        size: ol.expr.parse('sizeAttr'),
-        strokeColor: ol.expr.parse('color')
-      });
-      expect(symbolizer).to.be.a(ol.style.Shape);
-    });
-
-  });
-
-  describe('#createLiteral()', function() {
-
-    it('evaluates expressions with the given feature', function() {
-      var symbolizer = new ol.style.Shape({
-        size: ol.expr.parse('sizeAttr'),
-        fillOpacity: ol.expr.parse('opacityAttr'),
-        fillColor: '#BADA55'
-      });
-
-      var feature = new ol.Feature({
-        sizeAttr: 42,
-        opacityAttr: 0.4
-      });
-
-      var literal = symbolizer.createLiteral(feature);
-      expect(literal).to.be.a(ol.style.ShapeLiteral);
-      expect(literal.size).to.be(42);
-      expect(literal.fillOpacity).to.be(0.4);
-    });
-
-    it('can be called without a feature', function() {
-      var symbolizer = new ol.style.Shape({
-        size: 10,
-        fillColor: '#BADA55',
-        strokeColor: '#013',
-        strokeOpacity: 1,
-        strokeWidth: 2
-      });
-
-      var literal = symbolizer.createLiteral();
-      expect(literal).to.be.a(ol.style.ShapeLiteral);
-      expect(literal.size).to.be(10);
-      expect(literal.fillColor).to.be('#BADA55');
-      expect(literal.strokeColor).to.be('#013');
-      expect(literal.strokeOpacity).to.be(1);
-      expect(literal.strokeWidth).to.be(2);
-    });
-
-  });
-
-  describe('#getFillColor()', function() {
-
-    it('returns the fill color', function() {
-      var symbolizer = new ol.style.Shape({
-        fillColor: '#ff0000'
-      });
-
-      var fillColor = symbolizer.getFillColor();
-      expect(fillColor).to.be.a(ol.expr.Literal);
-      expect(fillColor.getValue()).to.be('#ff0000');
-    });
-
-  });
-
-  describe('#getFillOpacity()', function() {
-
-    it('returns the fill opacity', function() {
-      var symbolizer = new ol.style.Shape({
-        fillOpacity: 0.123
-      });
-
-      var opacity = symbolizer.getFillOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.123);
-    });
-
-    it('returns the default if none provided', function() {
-      var symbolizer = new ol.style.Shape({
-        fillColor: '#ffffff'
-      });
-
-      var opacity = symbolizer.getFillOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.4);
-    });
-
-  });
-
-  describe('#getStrokeColor()', function() {
-
-    it('returns the stroke color', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeColor: '#ff0000'
-      });
-
-      var strokeColor = symbolizer.getStrokeColor();
-      expect(strokeColor).to.be.a(ol.expr.Literal);
-      expect(strokeColor.getValue()).to.be('#ff0000');
-    });
-
-  });
-
-  describe('#getStrokeOpacity()', function() {
-
-    it('returns the stroke opacity', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 1,
-        strokeOpacity: 0.123
-      });
-
-      var opacity = symbolizer.getStrokeOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.123);
-    });
-
-    it('returns the default if none provided', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 1
-      });
-
-      var opacity = symbolizer.getStrokeOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.8);
-    });
-
-  });
-
-  describe('#getStrokeWidth()', function() {
-
-    it('returns the stroke width', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 10
-      });
-
-      var strokeWidth = symbolizer.getStrokeWidth();
-      expect(strokeWidth).to.be.a(ol.expr.Literal);
-      expect(strokeWidth.getValue()).to.be(10);
-    });
-
-  });
-
-  describe('#getType()', function() {
-
-    it('returns the shape type', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 1,
-        opacity: 0.123
-      });
-
-      var type = symbolizer.getType();
-      expect(type).to.be(ol.style.ShapeType.CIRCLE);
-    });
-
-  });
-
-  describe('#setFillColor()', function() {
-
-    it('sets the fill color', function() {
-      var symbolizer = new ol.style.Shape({
-        fillColor: '#ff0000'
-      });
-
-      symbolizer.setFillColor(new ol.expr.Literal('#0000ff'));
-
-      var fillColor = symbolizer.getFillColor();
-      expect(fillColor).to.be.a(ol.expr.Literal);
-      expect(fillColor.getValue()).to.be('#0000ff');
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Shape({
-        fillColor: '#ff0000'
-      });
-
-      expect(function() {
-        symbolizer.setFillColor('#0000ff');
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setFillOpacity()', function() {
-
-    it('sets the fill opacity', function() {
-      var symbolizer = new ol.style.Shape({
-        fillOpacity: 0.5
-      });
-
-      symbolizer.setFillOpacity(new ol.expr.Literal(0.6));
-
-      var fillOpacity = symbolizer.getFillOpacity();
-      expect(fillOpacity).to.be.a(ol.expr.Literal);
-      expect(fillOpacity.getValue()).to.be(0.6);
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Shape({
-        fillOpacity: 0.5
-      });
-
-      expect(function() {
-        symbolizer.setFillOpacity(0.4);
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setStrokeColor()', function() {
-
-    it('sets the stroke color', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeColor: '#ff0000'
-      });
-
-      symbolizer.setStrokeColor(new ol.expr.Literal('#0000ff'));
-
-      var strokeColor = symbolizer.getStrokeColor();
-      expect(strokeColor).to.be.a(ol.expr.Literal);
-      expect(strokeColor.getValue()).to.be('#0000ff');
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeColor: '#ff0000'
-      });
-
-      expect(function() {
-        symbolizer.setStrokeColor('#0000ff');
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setStrokeOpacity()', function() {
-
-    it('sets the stroke opacity', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 1,
-        strokeOpacity: 0.123
-      });
-      symbolizer.setStrokeOpacity(new ol.expr.Literal(0.321));
-
-      var opacity = symbolizer.getStrokeOpacity();
-      expect(opacity).to.be.a(ol.expr.Literal);
-      expect(opacity.getValue()).to.be(0.321);
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 1,
-        strokeOpacity: 1
-      });
-
-      expect(function() {
-        symbolizer.setStrokeOpacity(0.5);
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setStrokeWidth()', function() {
-
-    it('sets the stroke width', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 10
-      });
-      symbolizer.setStrokeWidth(new ol.expr.Literal(20));
-
-      var strokeWidth = symbolizer.getStrokeWidth();
-      expect(strokeWidth).to.be.a(ol.expr.Literal);
-      expect(strokeWidth.getValue()).to.be(20);
-    });
-
-    it('throws when not provided an expression', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 10
-      });
-
-      expect(function() {
-        symbolizer.setStrokeWidth(10);
-      }).throwException(function(err) {
-        expect(err).to.be.a(goog.asserts.AssertionError);
-      });
-    });
-
-  });
-
-  describe('#setType()', function() {
-
-    it('sets the shape type', function() {
-      var symbolizer = new ol.style.Shape({
-        strokeWidth: 1,
-        opacity: 0.123
-      });
-      symbolizer.setType(ol.style.ShapeType.CIRCLE);
-
-      var type = symbolizer.getType();
-      expect(type).to.be(ol.style.ShapeType.CIRCLE);
-    });
-
-  });
-
-});
-
-goog.require('goog.asserts.AssertionError');
-
-goog.require('ol.Feature');
-goog.require('ol.expr');
-goog.require('ol.expr.Literal');
-goog.require('ol.style.Shape');
-goog.require('ol.style.ShapeLiteral');
-goog.require('ol.style.ShapeType');

test/spec/ol/style/shapeliteral.test.js

@@ -0,0 +1,94 @@
+goog.provide('ol.test.style.ShapeLiteral');
+
+describe('ol.style.ShapeLiteral', function() {
+
+  describe('#equals()', function() {
+
+    it('identifies equal literals', function() {
+      var literal = new ol.style.ShapeLiteral({
+        type: ol.style.ShapeType.CIRCLE,
+        size: 4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.9,
+        strokeColor: '#013',
+        strokeOpacity: 0.8,
+        strokeWidth: 3
+      });
+      var equalLiteral = new ol.style.ShapeLiteral({
+        type: ol.style.ShapeType.CIRCLE,
+        size: 4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.9,
+        strokeColor: '#013',
+        strokeOpacity: 0.8,
+        strokeWidth: 3
+      });
+      var differentSize = new ol.style.ShapeLiteral({
+        type: ol.style.ShapeType.CIRCLE,
+        size: 5,
+        fillColor: '#BADA55',
+        fillOpacity: 0.9,
+        strokeColor: '#013',
+        strokeOpacity: 0.8,
+        strokeWidth: 3
+      });
+      var differentFillColor = new ol.style.ShapeLiteral({
+        type: ol.style.ShapeType.CIRCLE,
+        size: 4,
+        fillColor: '#ffffff',
+        fillOpacity: 0.9,
+        strokeColor: '#013',
+        strokeOpacity: 0.8,
+        strokeWidth: 3
+      });
+      var differentFillOpacity = new ol.style.ShapeLiteral({
+        type: ol.style.ShapeType.CIRCLE,
+        size: 4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.8,
+        strokeColor: '#013',
+        strokeOpacity: 0.8,
+        strokeWidth: 3
+      });
+      var differentStrokeColor = new ol.style.ShapeLiteral({
+        type: ol.style.ShapeType.CIRCLE,
+        size: 4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.9,
+        strokeColor: '#ffffff',
+        strokeOpacity: 0.8,
+        strokeWidth: 3
+      });
+      var differentStrokeOpacity = new ol.style.ShapeLiteral({
+        type: ol.style.ShapeType.CIRCLE,
+        size: 4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.9,
+        strokeColor: '#013',
+        strokeOpacity: 0.7,
+        strokeWidth: 3
+      });
+      var differentStrokeWidth = new ol.style.ShapeLiteral({
+        type: ol.style.ShapeType.CIRCLE,
+        size: 4,
+        fillColor: '#BADA55',
+        fillOpacity: 0.9,
+        strokeColor: '#013',
+        strokeOpacity: 0.8,
+        strokeWidth: 4
+      });
+      expect(literal.equals(equalLiteral)).to.be(true);
+      expect(literal.equals(differentSize)).to.be(false);
+      expect(literal.equals(differentFillColor)).to.be(false);
+      expect(literal.equals(differentFillOpacity)).to.be(false);
+      expect(literal.equals(differentStrokeColor)).to.be(false);
+      expect(literal.equals(differentStrokeOpacity)).to.be(false);
+      expect(literal.equals(differentStrokeWidth)).to.be(false);
+    });
+
+  });
+
+});
+
+goog.require('ol.style.ShapeLiteral');
+goog.require('ol.style.ShapeType');

test/spec/ol/style/shapesymbolizer.test.js

@@ -0,0 +1,203 @@
+goog.provide('ol.test.style.Shape');
+
+describe('ol.style.Shape', function() {
+
+  describe('constructor', function() {
+
+    it('accepts literal values', function() {
+      var symbolizer = new ol.style.Shape({
+        size: 4,
+        fill: new ol.style.Fill({
+          color: '#ff0000'
+        })
+      });
+      expect(symbolizer).to.be.a(ol.style.Shape);
+    });
+
+    it('accepts expressions', function() {
+      var symbolizer = new ol.style.Shape({
+        size: ol.expr.parse('sizeAttr'),
+        stroke: new ol.style.Stroke({
+          color: ol.expr.parse('color')
+        })
+      });
+      expect(symbolizer).to.be.a(ol.style.Shape);
+    });
+
+  });
+
+  describe('#createLiteral()', function() {
+
+    it('evaluates expressions with the given feature', function() {
+      var symbolizer = new ol.style.Shape({
+        size: ol.expr.parse('sizeAttr'),
+        fill: new ol.style.Fill({
+          opacity: ol.expr.parse('opacityAttr'),
+          color: '#BADA55'
+        })
+      });
+
+      var feature = new ol.Feature({
+        sizeAttr: 42,
+        opacityAttr: 0.4,
+        geometry: new ol.geom.Point([1, 2])
+      });
+
+      var literal = symbolizer.createLiteral(feature);
+      expect(literal).to.be.a(ol.style.ShapeLiteral);
+      expect(literal.size).to.be(42);
+      expect(literal.fillOpacity).to.be(0.4);
+    });
+
+    it('can be called without a feature', function() {
+      var symbolizer = new ol.style.Shape({
+        size: 10,
+        fill: new ol.style.Fill({
+          color: '#BADA55'
+        }),
+        stroke: new ol.style.Stroke({
+          color: '#013',
+          opacity: 1,
+          width: 2
+        })
+      });
+
+      var literal = symbolizer.createLiteral(ol.geom.GeometryType.POINT);
+      expect(literal).to.be.a(ol.style.ShapeLiteral);
+      expect(literal.size).to.be(10);
+      expect(literal.fillColor).to.be('#BADA55');
+      expect(literal.strokeColor).to.be('#013');
+      expect(literal.strokeOpacity).to.be(1);
+      expect(literal.strokeWidth).to.be(2);
+    });
+
+  });
+
+  describe('#getFill()', function() {
+
+    it('returns the fill', function() {
+      var symbolizer = new ol.style.Shape({
+        fill: new ol.style.Fill({
+          color: '#ff0000'
+        })
+      });
+
+      var fill = symbolizer.getFill();
+      expect(fill).to.be.a(ol.style.Fill);
+    });
+
+  });
+
+  describe('#getStroke()', function() {
+
+    it('returns the stroke', function() {
+      var symbolizer = new ol.style.Shape({
+        stroke: new ol.style.Stroke({
+          color: '#ff0000'
+        })
+      });
+
+      var stroke = symbolizer.getStroke();
+      expect(stroke).to.be.a(ol.style.Stroke);
+    });
+
+  });
+
+  describe('#getType()', function() {
+
+    it('returns the shape type', function() {
+      var symbolizer = new ol.style.Shape({
+        stroke: new ol.style.Stroke({
+          width: 1,
+          opacity: 0.123
+        })
+      });
+
+      var type = symbolizer.getType();
+      expect(type).to.be(ol.style.ShapeType.CIRCLE);
+    });
+
+  });
+
+  describe('#setFill()', function() {
+
+    it('sets the fill', function() {
+      var symbolizer = new ol.style.Shape({
+        stroke: new ol.style.Stroke({color: '#ff0000'})
+      });
+      expect(symbolizer.getFill()).to.be(null);
+
+      symbolizer.setFill(new ol.style.Fill({color: '#0000ff'}));
+      expect(symbolizer.getFill()).to.be.a(ol.style.Fill);
+    });
+
+    it('throws when not provided a fill', function() {
+      var symbolizer = new ol.style.Shape({
+        fill: new ol.style.Fill({color: '#ff0000'})
+      });
+
+      expect(function() {
+        symbolizer.setFill('#0000ff');
+      }).throwException(function(err) {
+        expect(err).to.be.a(goog.asserts.AssertionError);
+      });
+    });
+
+  });
+
+  describe('#setStroke()', function() {
+
+    it('sets the stroke', function() {
+      var symbolizer = new ol.style.Shape({
+        fill: new ol.style.Fill({color: '#ff0000'})
+      });
+      expect(symbolizer.getStroke()).to.be(null);
+
+      symbolizer.setStroke(new ol.style.Stroke({color: '#0000ff'}));
+      expect(symbolizer.getStroke()).to.be.a(ol.style.Stroke);
+    });
+
+    it('throws when not provided a stroke', function() {
+      var symbolizer = new ol.style.Shape({
+        stroke: new ol.style.Stroke({color: '#ff0000'})
+      });
+
+      expect(function() {
+        symbolizer.setStroke('#0000ff');
+      }).throwException(function(err) {
+        expect(err).to.be.a(goog.asserts.AssertionError);
+      });
+    });
+
+  });
+
+  describe('#setType()', function() {
+
+    it('sets the shape type', function() {
+      var symbolizer = new ol.style.Shape({
+        stroke: new ol.style.Stroke({
+          width: 1,
+          opacity: 0.123
+        })
+      });
+      symbolizer.setType(ol.style.ShapeType.CIRCLE);
+
+      var type = symbolizer.getType();
+      expect(type).to.be(ol.style.ShapeType.CIRCLE);
+    });
+
+  });
+
+});
+
+goog.require('goog.asserts.AssertionError');
+
+goog.require('ol.Feature');
+goog.require('ol.geom.GeometryType');
+goog.require('ol.geom.Point');
+goog.require('ol.expr');
+goog.require('ol.style.Fill');
+goog.require('ol.style.Shape');
+goog.require('ol.style.ShapeLiteral');
+goog.require('ol.style.ShapeType');
+goog.require('ol.style.Stroke');

test/spec/ol/style/strokesymbolizer.test.js

@@ -0,0 +1,191 @@
+goog.provide('ol.test.style.Stroke');
+
+describe('ol.style.Stroke', function() {
+
+  describe('constructor', function() {
+
+    it('accepts literal values', function() {
+      var symbolizer = new ol.style.Stroke({
+        color: '#BADA55',
+        width: 3
+      });
+      expect(symbolizer).to.be.a(ol.style.Stroke);
+    });
+
+    it('accepts expressions', function() {
+      var symbolizer = new ol.style.Stroke({
+        opacity: ol.expr.parse('value / 100'),
+        width: ol.expr.parse('widthAttr')
+      });
+      expect(symbolizer).to.be.a(ol.style.Stroke);
+    });
+
+  });
+
+  describe('#createLiteral()', function() {
+
+    it('evaluates expressions with the given feature', function() {
+      var symbolizer = new ol.style.Stroke({
+        opacity: ol.expr.parse('value / 100'),
+        width: ol.expr.parse('widthAttr')
+      });
+
+      var feature = new ol.Feature({
+        value: 42,
+        widthAttr: 1.5,
+        geometry: new ol.geom.LineString([[1, 2], [3, 4]])
+      });
+
+      var literal = symbolizer.createLiteral(feature);
+      expect(literal).to.be.a(ol.style.LineLiteral);
+      expect(literal.opacity).to.be(42 / 100);
+      expect(literal.width).to.be(1.5);
+    });
+
+    it('applies the default values', function() {
+      var symbolizer = new ol.style.Stroke({});
+
+      var literal = symbolizer.createLiteral(ol.geom.GeometryType.LINESTRING);
+      expect(literal).to.be.a(ol.style.LineLiteral);
+      expect(literal.color).to.be('#696969');
+      expect(literal.opacity).to.be(0.75);
+      expect(literal.width).to.be(1.5);
+    });
+
+  });
+
+  describe('#getColor()', function() {
+
+    it('returns the stroke color', function() {
+      var symbolizer = new ol.style.Stroke({
+        color: '#ff0000'
+      });
+
+      var color = symbolizer.getColor();
+      expect(color).to.be.a(ol.expr.Literal);
+      expect(color.getValue()).to.be('#ff0000');
+    });
+
+  });
+
+  describe('#getWidth()', function() {
+
+    it('returns the stroke width', function() {
+      var symbolizer = new ol.style.Stroke({
+        width: 10
+      });
+
+      var width = symbolizer.getWidth();
+      expect(width).to.be.a(ol.expr.Literal);
+      expect(width.getValue()).to.be(10);
+    });
+
+  });
+
+  describe('#getOpacity()', function() {
+
+    it('returns the stroke opacity', function() {
+      var symbolizer = new ol.style.Stroke({
+        opacity: 0.123
+      });
+
+      var opacity = symbolizer.getOpacity();
+      expect(opacity).to.be.a(ol.expr.Literal);
+      expect(opacity.getValue()).to.be(0.123);
+    });
+
+  });
+
+  describe('#setColor()', function() {
+
+    it('sets the stroke color', function() {
+      var symbolizer = new ol.style.Stroke({
+        color: '#ff0000'
+      });
+
+      symbolizer.setColor(new ol.expr.Literal('#0000ff'));
+
+      var color = symbolizer.getColor();
+      expect(color).to.be.a(ol.expr.Literal);
+      expect(color.getValue()).to.be('#0000ff');
+    });
+
+    it('throws when not provided an expression', function() {
+      var symbolizer = new ol.style.Stroke({
+        color: '#ff0000'
+      });
+
+      expect(function() {
+        symbolizer.setColor('#0000ff');
+      }).throwException(function(err) {
+        expect(err).to.be.a(goog.asserts.AssertionError);
+      });
+    });
+
+  });
+
+  describe('#setWidth()', function() {
+
+    it('sets the stroke width', function() {
+      var symbolizer = new ol.style.Stroke({
+        width: 10
+      });
+      symbolizer.setWidth(new ol.expr.Literal(20));
+
+      var width = symbolizer.getWidth();
+      expect(width).to.be.a(ol.expr.Literal);
+      expect(width.getValue()).to.be(20);
+    });
+
+    it('throws when not provided an expression', function() {
+      var symbolizer = new ol.style.Stroke({
+        width: 10
+      });
+
+      expect(function() {
+        symbolizer.setWidth(10);
+      }).throwException(function(err) {
+        expect(err).to.be.a(goog.asserts.AssertionError);
+      });
+    });
+
+  });
+
+  describe('#setOpacity()', function() {
+
+    it('sets the stroke opacity', function() {
+      var symbolizer = new ol.style.Stroke({
+        opacity: 0.123
+      });
+      symbolizer.setOpacity(new ol.expr.Literal(0.321));
+
+      var opacity = symbolizer.getOpacity();
+      expect(opacity).to.be.a(ol.expr.Literal);
+      expect(opacity.getValue()).to.be(0.321);
+    });
+
+    it('throws when not provided an expression', function() {
+      var symbolizer = new ol.style.Stroke({
+        opacity: 1
+      });
+
+      expect(function() {
+        symbolizer.setOpacity(0.5);
+      }).throwException(function(err) {
+        expect(err).to.be.a(goog.asserts.AssertionError);
+      });
+    });
+
+  });
+
+});
+
+goog.require('goog.asserts.AssertionError');
+
+goog.require('ol.Feature');
+goog.require('ol.expr');
+goog.require('ol.expr.Literal');
+goog.require('ol.geom.GeometryType');
+goog.require('ol.geom.LineString');
+goog.require('ol.style.Stroke');
+goog.require('ol.style.LineLiteral');

test/spec/ol/style/style.test.js

@@ -2,10 +2,40 @@ goog.provide('ol.test.style.Style');
 
 describe('ol.style.Style', function() {
 
-  describe('#apply()', function() {
+  describe('constructor', function() {
 
-    it('applies a style to a feature', function() {
+    it('creates a style instance given rules', function() {
+      var style = new ol.style.Style({
+        rules: [
+          new ol.style.Rule({
+            filter: 'foo == "bar"',
+            symbolizers: [
+              new ol.style.Fill({
+                color: '#ff0000'
+              })
+            ]
+          })
+        ]
+      });
+      expect(style).to.be.a(ol.style.Style);
+    });
 
+    it('creates a style instance given only "else" symbolizers', function() {
+      var style = new ol.style.Style({
+        symbolizers: [
+          new ol.style.Fill({
+            color: '#ff0000'
+          })
+        ]
+      });
+      expect(style).to.be.a(ol.style.Style);
+    });
+
+  });
+
+  describe('#createLiterals()', function() {
+
+    it('creates symbolizer literals for a feature', function() {
       var style = new ol.style.Style({
         rules: [
           new ol.style.Rule({
@@ -13,58 +43,254 @@ describe('ol.style.Style', function() {
             symbolizers: [
               new ol.style.Shape({
                 size: 4,
-                fillColor: '#BADA55'
+                fill: new ol.style.Fill({
+                  color: ol.expr.parse('fillColor')
+                })
               })
             ]
           })
         ]
       });
-      var feature = new ol.Feature();
+      var feature = new ol.Feature({
+        fillColor: '#BADA55',
+        geometry: new ol.geom.Point([1, 2])
+      });
       feature.set('foo', 'bar');
-      expect(style.apply(feature).length).to.be(1);
+
-      expect(style.apply(feature)[0].fillColor).to.be('#BADA55');
+      var literals = style.createLiterals(feature);
+      expect(literals).to.have.length(1);
+      expect(literals[0].fillColor).to.be('#BADA55');
+
       feature.set('foo', 'baz');
-      expect(style.apply(feature).length).to.be(0);
+      expect(style.createLiterals(feature)).to.have.length(0);
+    });
+
+    it('uses the "else" symbolizers when no rules are provided', function() {
+      var style = new ol.style.Style({
+        symbolizers: [
+          new ol.style.Stroke({
+            color: '#ff0000'
+          })
+        ]
+      });
+
+      var feature = new ol.Feature({
+        geometry: new ol.geom.LineString([[1, 2], [3, 4]])
+      });
+
+      var literals = style.createLiterals(feature);
+      expect(literals).to.have.length(1);
+      expect(literals[0].color).to.be('#ff0000');
+    });
+
+    it('uses the "else" symbolizers when no rules apply', function() {
+      var style = new ol.style.Style({
+        rules: [
+          new ol.style.Rule({
+            filter: 'name == "match"',
+            symbolizers: [
+              new ol.style.Stroke({
+                color: '#ff00ff'
+              })
+            ]
+          })
+        ],
+        // these are the "else" symbolizers
+        symbolizers: [
+          new ol.style.Stroke({
+            color: '#00ff00'
+          })
+        ]
+      });
+
+      var feature = new ol.Feature({
+        geometry: new ol.geom.LineString([[1, 2], [3, 4]])
+      });
+
+      var literals = style.createLiterals(feature);
+      expect(literals).to.have.length(1);
+      expect(literals[0].color).to.be('#00ff00');
+
+      feature = new ol.Feature({
+        name: 'match',
+        geometry: new ol.geom.LineString([[1, 2], [3, 4]])
+      });
+      literals = style.createLiterals(feature);
+      expect(literals).to.have.length(1);
+      expect(literals[0].color).to.be('#ff00ff');
     });
 
   });
 
-  describe('ol.style.Style.applyDefaultStyle()', function() {
+  describe('ol.style.Style.defaults.createLiterals(feature)', function() {
     var feature = new ol.Feature();
 
     it('returns an empty array for features without geometry', function() {
-      expect(ol.style.Style.applyDefaultStyle(feature).length).to.be(0);
+      expect(ol.style.Style.defaults.createLiterals(feature))
+          .to.have.length(0);
     });
 
     it('returns an array with the Shape default for points', function() {
       feature.setGeometry(new ol.geom.Point([0, 0]));
-      var symbolizers = ol.style.Style.applyDefaultStyle(feature);
+
-      expect(symbolizers.length).to.be(1);
+      var literals = ol.style.Style.defaults.createLiterals(feature);
-      expect(symbolizers[0]).to.be.a(ol.style.ShapeLiteral);
+      expect(literals).to.have.length(1);
-      expect(symbolizers[0].equals(ol.style.ShapeDefaults)).to.be(true);
+
+      var literal = literals[0];
+      expect(literal).to.be.a(ol.style.ShapeLiteral);
+      expect(literal.type).to.be(ol.style.ShapeDefaults.type);
+      expect(literal.fillColor).to.be(ol.style.FillDefaults.color);
+      expect(literal.fillOpacity).to.be(ol.style.FillDefaults.opacity);
+      expect(literal.strokeColor).to.be(ol.style.StrokeDefaults.color);
+      expect(literal.strokeOpacity).to.be(ol.style.StrokeDefaults.opacity);
+      expect(literal.strokeWidth).to.be(ol.style.StrokeDefaults.width);
     });
 
     it('returns an array with the Line default for lines', function() {
       feature.setGeometry(new ol.geom.LineString([[0, 0], [1, 1]]));
-      expect(ol.style.Style.applyDefaultStyle(feature)[0]
+
-          .equals(ol.style.LineDefaults)).to.be(true);
+      var literals = ol.style.Style.defaults.createLiterals(feature);
+      expect(literals).to.have.length(1);
+
+      var literal = literals[0];
+      expect(literal).to.be.a(ol.style.LineLiteral);
+      expect(literal.color).to.be(ol.style.StrokeDefaults.color);
+      expect(literal.opacity).to.be(ol.style.StrokeDefaults.opacity);
+      expect(literal.width).to.be(ol.style.StrokeDefaults.width);
     });
 
     it('returns an array with the Polygon default for polygons', function() {
       feature.setGeometry(new ol.geom.Polygon([[[0, 0], [1, 1], [0, 0]]]));
-      expect(ol.style.Style.applyDefaultStyle(feature)[0]
+
-          .equals(ol.style.PolygonDefaults)).to.be(true);
+      var literals = ol.style.Style.defaults.createLiterals(feature);
+      expect(literals).to.have.length(1);
+
+      var literal = literals[0];
+      expect(literal).to.be.a(ol.style.PolygonLiteral);
+      expect(literal.fillColor).to.be(ol.style.FillDefaults.color);
+      expect(literal.fillOpacity).to.be(ol.style.FillDefaults.opacity);
+      expect(literal.strokeColor).to.be(ol.style.StrokeDefaults.color);
+      expect(literal.strokeOpacity).to.be(ol.style.StrokeDefaults.opacity);
+      expect(literal.strokeWidth).to.be(ol.style.StrokeDefaults.width);
     });
 
   });
 
+  describe('#reduceLiterals_', function() {
+
+    it('collapses stroke or fill only literals where possible', function() {
+      var literals = [
+        new ol.style.PolygonLiteral({
+          fillColor: '#ff0000',
+          fillOpacity: 0.5
+        }),
+        new ol.style.PolygonLiteral({
+          strokeColor: '#00ff00',
+          strokeOpacity: 0.6,
+          strokeWidth: 3
+        })
+      ];
+
+      var reduced = ol.style.Style.reduceLiterals_(literals);
+      expect(reduced).to.have.length(1);
+
+      var poly = reduced[0];
+      expect(poly.fillColor).to.be('#ff0000');
+      expect(poly.fillOpacity).to.be(0.5);
+      expect(poly.strokeColor).to.be('#00ff00');
+      expect(poly.strokeOpacity).to.be(0.6);
+      expect(poly.strokeWidth).to.be(3);
+    });
+
+    it('leaves complete polygon literals alone', function() {
+      var literals = [
+        new ol.style.PolygonLiteral({
+          fillColor: '#ff0000',
+          fillOpacity: 0.5,
+          strokeColor: '#00ff00',
+          strokeOpacity: 0.6,
+          strokeWidth: 3
+        }),
+        new ol.style.PolygonLiteral({
+          strokeColor: '#0000ff',
+          strokeOpacity: 0.7,
+          strokeWidth: 1
+        })
+      ];
+
+      var reduced = ol.style.Style.reduceLiterals_(literals);
+      expect(reduced).to.have.length(2);
+
+      var first = reduced[0];
+      expect(first.fillColor).to.be('#ff0000');
+      expect(first.fillOpacity).to.be(0.5);
+      expect(first.strokeColor).to.be('#00ff00');
+      expect(first.strokeOpacity).to.be(0.6);
+      expect(first.strokeWidth).to.be(3);
+
+      var second = reduced[1];
+      expect(second.fillColor).to.be(undefined);
+      expect(second.fillOpacity).to.be(undefined);
+      expect(second.strokeColor).to.be('#0000ff');
+      expect(second.strokeOpacity).to.be(0.7);
+      expect(second.strokeWidth).to.be(1);
+    });
+
+    it('leaves other literals alone', function() {
+      var literals = [
+        new ol.style.PolygonLiteral({
+          strokeColor: '#00ff00',
+          strokeOpacity: 0.6,
+          strokeWidth: 3
+        }),
+        new ol.style.PolygonLiteral({
+          fillColor: '#ff0000',
+          fillOpacity: 0.5
+        }),
+        new ol.style.TextLiteral({
+          color: '#ffffff',
+          fontFamily: 'Arial',
+          fontSize: 11,
+          text: 'Test',
+          opacity: 0.5
+        })
+      ];
+
+      var reduced = ol.style.Style.reduceLiterals_(literals);
+      expect(reduced).to.have.length(2);
+
+      var first = reduced[0];
+      expect(first.fillColor).to.be('#ff0000');
+      expect(first.fillOpacity).to.be(0.5);
+      expect(first.strokeColor).to.be('#00ff00');
+      expect(first.strokeOpacity).to.be(0.6);
+      expect(first.strokeWidth).to.be(3);
+
+      var second = reduced[1];
+      expect(second.color).to.be('#ffffff');
+      expect(second.fontFamily).to.be('Arial');
+      expect(second.fontSize).to.be(11);
+      expect(second.text).to.be('Test');
+      expect(second.opacity).to.be(0.5);
+    });
+
+
+  });
+
 });
 
 goog.require('ol.Feature');
+goog.require('ol.expr');
 goog.require('ol.geom.LineString');
 goog.require('ol.geom.Point');
 goog.require('ol.geom.Polygon');
+goog.require('ol.style.Fill');
+goog.require('ol.style.LineLiteral');
+goog.require('ol.style.PolygonLiteral');
 goog.require('ol.style.Rule');
 goog.require('ol.style.Shape');
 goog.require('ol.style.ShapeLiteral');
+goog.require('ol.style.Stroke');
+goog.require('ol.style.StrokeDefaults');
 goog.require('ol.style.Style');
+goog.require('ol.style.TextLiteral');

test/spec/ol/style/textliteral.test.js

@@ -0,0 +1,69 @@
+goog.provide('ol.test.style.TextLiteral');
+
+describe('ol.style.TextLiteral', function() {
+
+  describe('#equals()', function() {
+
+    it('identifies equal literals', function() {
+      var literal = new ol.style.TextLiteral({
+        color: '#ff0000',
+        fontFamily: 'Arial',
+        fontSize: 11,
+        text: 'Test',
+        opacity: 0.5
+      });
+      var equalLiteral = new ol.style.TextLiteral({
+        color: '#ff0000',
+        fontFamily: 'Arial',
+        fontSize: 11,
+        text: 'Test',
+        opacity: 0.5
+      });
+      var differentLiteral1 = new ol.style.TextLiteral({
+        color: '#0000ff',
+        fontFamily: 'Arial',
+        fontSize: 11,
+        text: 'Test',
+        opacity: 0.5
+      });
+      var differentLiteral2 = new ol.style.TextLiteral({
+        color: '#ff0000',
+        fontFamily: 'Dingbats',
+        fontSize: 11,
+        text: 'Test',
+        opacity: 0.5
+      });
+      var differentLiteral3 = new ol.style.TextLiteral({
+        color: '#ff0000',
+        fontFamily: 'Arial',
+        fontSize: 12,
+        text: 'Test',
+        opacity: 0.5
+      });
+      var differentLiteral4 = new ol.style.TextLiteral({
+        color: '#ff0000',
+        fontFamily: 'Arial',
+        fontSize: 11,
+        text: 'Test',
+        opacity: 0.6
+      });
+      var equalLiteral2 = new ol.style.TextLiteral({
+        color: '#ff0000',
+        fontFamily: 'Arial',
+        fontSize: 11,
+        text: 'Text is not compared for equality',
+        opacity: 0.5
+      });
+      expect(literal.equals(equalLiteral)).to.be(true);
+      expect(literal.equals(differentLiteral1)).to.be(false);
+      expect(literal.equals(differentLiteral2)).to.be(false);
+      expect(literal.equals(differentLiteral3)).to.be(false);
+      expect(literal.equals(differentLiteral4)).to.be(false);
+      expect(literal.equals(equalLiteral2)).to.be(true);
+    });
+
+  });
+
+});
+
+goog.require('ol.style.TextLiteral');

test/spec/ol/style/textsymbolizer.test.js

@@ -1,71 +1,5 @@
 goog.provide('ol.test.style.Text');
 
-describe('ol.style.TextLiteral', function() {
-
-  describe('#equals()', function() {
-
-    it('identifies equal literals', function() {
-      var literal = new ol.style.TextLiteral({
-        color: '#ff0000',
-        fontFamily: 'Arial',
-        fontSize: 11,
-        text: 'Test',
-        opacity: 0.5
-      });
-      var equalLiteral = new ol.style.TextLiteral({
-        color: '#ff0000',
-        fontFamily: 'Arial',
-        fontSize: 11,
-        text: 'Test',
-        opacity: 0.5
-      });
-      var differentLiteral1 = new ol.style.TextLiteral({
-        color: '#0000ff',
-        fontFamily: 'Arial',
-        fontSize: 11,
-        text: 'Test',
-        opacity: 0.5
-      });
-      var differentLiteral2 = new ol.style.TextLiteral({
-        color: '#ff0000',
-        fontFamily: 'Dingbats',
-        fontSize: 11,
-        text: 'Test',
-        opacity: 0.5
-      });
-      var differentLiteral3 = new ol.style.TextLiteral({
-        color: '#ff0000',
-        fontFamily: 'Arial',
-        fontSize: 12,
-        text: 'Test',
-        opacity: 0.5
-      });
-      var differentLiteral4 = new ol.style.TextLiteral({
-        color: '#ff0000',
-        fontFamily: 'Arial',
-        fontSize: 11,
-        text: 'Test',
-        opacity: 0.6
-      });
-      var equalLiteral2 = new ol.style.TextLiteral({
-        color: '#ff0000',
-        fontFamily: 'Arial',
-        fontSize: 11,
-        text: 'Text is not compared for equality',
-        opacity: 0.5
-      });
-      expect(literal.equals(equalLiteral)).to.be(true);
-      expect(literal.equals(differentLiteral1)).to.be(false);
-      expect(literal.equals(differentLiteral2)).to.be(false);
-      expect(literal.equals(differentLiteral3)).to.be(false);
-      expect(literal.equals(differentLiteral4)).to.be(false);
-      expect(literal.equals(equalLiteral2)).to.be(true);
-    });
-
-  });
-
-});
-
 describe('ol.style.Text', function() {
 
   describe('constructor', function() {
@@ -131,7 +65,7 @@ describe('ol.style.Text', function() {
         opacity: ol.expr.parse('0.6')
       });
 
-      var literal = symbolizer.createLiteral();
+      var literal = symbolizer.createLiteral(ol.geom.GeometryType.POINT);
       expect(literal).to.be.a(ol.style.TextLiteral);
       expect(literal.color).to.be('#ff0000');
       expect(literal.fontFamily).to.be('Arial');
@@ -145,7 +79,7 @@ describe('ol.style.Text', function() {
         text: 'Test'
       });
 
-      var literal = symbolizer.createLiteral();
+      var literal = symbolizer.createLiteral(ol.geom.GeometryType.POINT);
       expect(literal).to.be.a(ol.style.TextLiteral);
       expect(literal.color).to.be('#000');
       expect(literal.fontFamily).to.be('sans-serif');
@@ -363,5 +297,6 @@ goog.require('ol.Feature');
 goog.require('ol.expr');
 goog.require('ol.expr.Literal');
 goog.require('ol.expr.Literal');
+goog.require('ol.geom.GeometryType');
 goog.require('ol.style.Text');
 goog.require('ol.style.TextLiteral');